update mcp definition example

src/agentCore.jl

@@ -9,9 +9,9 @@ using JSON, DataStructures, Dates, UUIDs, HTTP, Random, PrettyPrinting, Serializ
 using GeneralUtils
 using ..type, ..utils, ..toolRegistry
 
-function register_all_tools(store::toolRegistry.toolStore)
+function register_all_tools(store::toolRegistry.toolStore, mcpServer=nothing)
     # Call parent module's version which has access to tool functions
-    parentmodule(@__MODULE__).register_all_tools(store)
+    parentmodule(@__MODULE__).register_all_tools(store, mcpServer)
 end
 
 # ---------------------------------------------- 100 --------------------------------------------- #
@@ -49,7 +49,83 @@ mutable struct yiemAgent <: agent             # High-level agent wrapper
   # Each block has a type — "text", "thinking", or "toolCall". 
   # The code filters for type === "toolCall" blocks, then passes them to executeToolCalls().
   llmCall                         
-                                              
+                                               
+  # Callable struct for MCP server communication.
+  # Called as: mcpServer("tools/list") → returns parsed JSON dict of available tools
+  #            mcpServer("tools/call", toolName, arguments) → returns tool result as parsed JSON dict
+  #
+  # # Example (weather tool)
+  #   # User provides a callable struct
+  #   struct MyMCPClient
+  #     natsConn::NATS.Connection
+  #     topic::String
+  #     senderID::String
+  #     fileserver_url::String
+  #   end
+  #
+  #   function (c::MyMCPClient)(method::String)
+  #       payload = Dict("method"=> method)
+  #       payloads = [("method", payload, "dictionary")]
+  #       _, msg_envelope_json_str = msghandler.smartpack(
+  #             c.topic, payloads; sender_id=c.senderID,
+  #             msg_purpose="mcp_tools_list", fileserver_url=c.fileserver_url)
+  #       reply = NATS.request(c.natsConn, c.topic, msg_envelope_json_str, timeout=180)
+  #       incoming_env = msghandler.smartunpack(String(reply.payload))
+  #       return incoming_env["payloads"][1][2]
+  #   end
+  #
+  #   function (c::MyMCPClient)(method::String, toolName::String, arguments::Dict{String,Any})
+  #       payload = Dict("method"=> method, "toolName"=> toolName, "arguments"=>arguments)
+  #       payloads = [("method", payload, "dictionary"),]
+  #       _, msg_envelope_json_str = msghandler.smartpack(
+  #             c.topic, payloads; sender_id=c.senderID,
+  #             msg_purpose="mcp_tool_call", fileserver_url=c.fileserver_url)
+  #       reply = NATS.request(c.natsConn, c.topic, msg_envelope_json_str, timeout=180)
+  #       incoming_env = msghandler.smartunpack(String(reply.payload))
+  #       return incoming_env["payloads"][1][2]
+  #   end
+  #
+  #   # "tools/list" input:
+  #     mcpServer("tools/list")
+  #     # sending out payload before smart packed by msghandler:
+  #     Dict("method"=> "tools/list")
+  #     # expected return after smart unpacked by msghandler:
+  #     Dict("tools" => [
+  #       Dict(
+  #         "toolName" => "getWeather",
+  #         "title" => "Weather Lookup",
+  #         "description" => "Fetch current weather for a city.",
+  #         "inputSchema" => Dict("type"=>"object",
+  #                               "properties" => Dict("city"=>Dict("type"=>"string", "description"=>"City name"),
+  #                                                   "units"=>Dict("type"=>"string", "enum"=>["celsius","fahrenheit"], "default"=>"celsius")),
+  #                               "required" => ["city"])
+  #       )
+  #     ])
+  #
+  #   # "tools/call" input:
+  #     mcpServer("tools/call", "getWeather", Dict("city"=>"Tokyo", "units"=>"celsius"))
+  #     # sending out payload before smart packed by msghandler:
+  #     Dict(
+  #       "method"=> "tools/call",
+  #       "toolName"=>"getWeather",
+  #       "arguments"=>Dict("city"=>"Tokyo", "units"=>"celsius")
+  #     )
+  #     # expected return after smart unpacked by msghandler (success):
+  #     Dict(
+  #       "toolName"=> "getWeather",
+  #       "content" => [{"type" => "text", "text" => "Weather in Tokyo: Sunny, 22°C"}],
+  #       "error"=> "",
+  #       "isError" => false
+  #     )
+  #     # expected return after smart unpacked by msghandler (error):
+  #     Dict(
+  #       "toolName"=> "getWeather",
+  #       "content" => [],
+  #       "error" => Dict("code"=>1, "message"=>"City not found"),
+  #       "isError" => true
+  #     )
+  mcpServer                        
+
   # Callback invoked before executing a tool call (ask for user permission/confirmation/abort, etc..)
   beforeToolCall::Union{Function, Nothing}    
 
@@ -86,6 +162,9 @@ on `inputChannel` and `followUpChannel` channels concurrently.
 - `maxRetryDelayMs::Union{Int64, Nothing}`: Maximum delay between retries in milliseconds (default: `nothing`)
 - `parallelToolExecute::Bool`: Run tool calls in parallel (default: `false`)
 - `agentEventSink::Function`: Callback to receive agent events
+- `mcpServer`: Callable struct for MCP server communication. Called as
+  `mcpServer("tools/list")` to discover tools, or `mcpServer("tools/call", args)`
+  to execute a tool. Returns parsed JSON dicts. (default: `nothing`)
 
 # Returns
 - A new `yiemAgent` instance with an active background task
@@ -106,6 +185,7 @@ function yiemAgent(
   maxRetryDelayMs::Union{Int64, Nothing}=nothing,
   parallelToolExecute::Bool=false,
   agentEventSink=agentEventSink,
+  mcpServer=nothing,
   )
   # Create channels: input (user -> agent), followUp (async queue), output (agent -> user)
   inputChannel    = Channel(16)
@@ -114,7 +194,7 @@ function yiemAgent(
 
   # load tools (statically registered at module init)
   toolStore1 = toolStore(name="myagent")
-  register_all_tools(toolStore1)
+  register_all_tools(toolStore1, mcpServer)
 
   # Create struct with a placeholder task, then spawn and replace it
   agent = yiemAgent(
@@ -126,6 +206,7 @@ function yiemAgent(
     prepareContext,
     formatMsgForLLM,
     llmCall,
+    mcpServer,
     beforeToolCall,
     afterToolCall,
     # prepareNextTurn,