commit 38f587c9122270f1fc776b4909d0d0fe6cbe3056 · anil.recoil.org/ocaml-mcp

+9 -9

bin/multimodal_sdk.ml

···

       262
       262
        
             let audio_data = generate_sine_wave_audio (float_of_int frequency) duration in

     

       263
       263
        
             

     

       264
       264
        
             (* Create a multimodal tool result *)

     

       265
       265
       -
             create_tool_result [

     

       265
       265
       +
             Tool.create_tool_result [

     

       266
       266
        
               Mcp.make_text_content message;

     

       267
       267
        
               Mcp.make_image_content image_data "image/gif";

     

       268
       268
        
               Mcp.make_audio_content audio_data "audio/wav"

     
···

       270
       270
        
           with

     

       271
       271
        
           | Failure msg -> 

     

       272
       272
        
             Log.error (Printf.sprintf "Error in multimodal tool: %s" msg);

     

       273
       273
       -
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       273
       273
       +
             Tool.create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       274
       274
        
         )

     

       275
       275
        
       

     

       276
       276
        
       (* Define and register a tool for generating only images *)

     
···

       288
       288
        
             let height = get_int_param args "height" in

     

       289
       289
        
             

     

       290
       290
        
             if width < 1 || width > 1024 || height < 1 || height > 1024 then

     

       291
       291
       -
               create_tool_result 

     

       291
       291
       +
               Tool.create_tool_result 

     

       292
       292
        
                 [Mcp.make_text_content "Error: Dimensions must be between 1 and 1024 pixels"] 

     

       293
       293
        
                 ~is_error:true

     

       294
       294
        
             else

     

       295
       295
        
               let image_data = generate_random_image width height in

     

       296
       296
       -
               create_tool_result 

     

       296
       296
       +
               Tool.create_tool_result 

     

       297
       297
        
                 [Mcp.make_image_content image_data "image/gif"]

     

       298
       298
        
                 ~is_error:false

     

       299
       299
        
           with

     

       300
       300
        
           | Failure msg ->

     

       301
       301
        
             Log.error (Printf.sprintf "Error in generate_image tool: %s" msg);

     

       302
       302
       -
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       302
       302
       +
             Tool.create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       303
       303
        
         )

     

       304
       304
        
       

     

       305
       305
        
       (* Define and register a tool for generating only audio *)

     
···

       317
       317
        
             let duration = get_int_param args "duration" in

     

       318
       318
        
             

     

       319
       319
        
             if frequency < 20 || frequency > 20000 then

     

       320
       320
       -
               create_tool_result 

     

       320
       320
       +
               Tool.create_tool_result 

     

       321
       321
        
                 [Mcp.make_text_content "Error: Frequency must be between 20Hz and 20,000Hz"] 

     

       322
       322
        
                 ~is_error:true

     

       323
       323
        
             else if duration < 1 || duration > 10 then

     

       324
       324
       -
               create_tool_result 

     

       324
       324
       +
               Tool.create_tool_result 

     

       325
       325
        
                 [Mcp.make_text_content "Error: Duration must be between 1 and 10 seconds"] 

     

       326
       326
        
                 ~is_error:true

     

       327
       327
        
             else

     

       328
       328
        
               let audio_data = generate_sine_wave_audio (float_of_int frequency) duration in

     

       329
       329
       -
               create_tool_result 

     

       329
       329
       +
               Tool.create_tool_result 

     

       330
       330
        
                 [Mcp.make_audio_content audio_data "audio/wav"]

     

       331
       331
        
                 ~is_error:false

     

       332
       332
        
           with

     

       333
       333
        
           | Failure msg ->

     

       334
       334
        
             Log.error (Printf.sprintf "Error in generate_audio tool: %s" msg);

     

       335
       335
       -
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       335
       335
       +
             Tool.create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       336
       336
        
         )

     

       337
       337
        
       

     

       338
       338
        
       (* Define and register a resource example with multimodal content *)

+3 -3

bin/ocaml_eval_sdk.ml

···

       1
       1
        
       open Mcp_sdk

     

       2
       2
       -
       open Mcp_message

     

       2
       2
       +
       open Mcp_rpc

     

       3
       3
        
       

     

       4
       4
        
       (* Set up the formatter for capturing evaluation output *)

     

       5
       5
        
       let capture_output f =

     
···

       150
       150
        
             in

     

       151
       151
        
             

     

       152
       152
        
             (* Create a tool result with colorized output *)

     

       153
       153
       -
             create_tool_result [

     

       153
       153
       +
             Tool.create_tool_result [

     

       154
       154
        
               Mcp.make_text_content output

     

       155
       155
        
             ] ~is_error:(not success)

     

       156
       156
        
             

     

       157
       157
        
           with

     

       158
       158
        
           | Failure msg ->

     

       159
       159
        
             Log.error (Printf.sprintf "Error in OCaml eval tool: %s" msg);

     

       160
       160
       -
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       160
       160
       +
             Tool.create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       161
       161
        
         )

     

       162
       162
        
       

     

       163
       163
        
       (* Run the server with the default scheduler *)

lib/mcp_message.ml lib/mcp_rpc.ml

lib/mcp_message.mli lib/mcp_rpc.mli