phronomy 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a6262c12bc063819c0e1656699f47666b06b182747d6ce85843d2a74988c358
-  data.tar.gz: 6529858071913e61a6a840fe03e36620322bfddd50e415b054314124f9b7fcd1
+  metadata.gz: 9b5c5fc2f42107629541d051e1330e90e48298ccf19192440e7be77a30b6ca68
+  data.tar.gz: 78e4440ec72afb39b7021810c8cdfc8de44f94f15d97442f91000eff50aa967c
 SHA512:
-  metadata.gz: 6b1441aab8f7197c23bd84fea750388280ee00036e729f47de13b0113249261f72fb10f01b5e9a78fb2464fcb0ebac5fd07d91eef7d4b5e83fb973b463c0630e
-  data.tar.gz: d9c0401177c9d59900543c7ff5bbae698401fa0dc5ca7e33272458f41eddff2fa61caa501a5735b273f59b44de96e1fc70b0c5a648bb159066f7facd18b5aa82
+  metadata.gz: 79c98ed427ae1c55d245f871ba9248279199496b27535dfaca2b94d89998bfa95583c8b87a7c192f00f5143c755f6234a4f513ec37c86172ea2c286579e9b72a
+  data.tar.gz: 30d8c27a6a0a0d003da85438ee903fc73af648079c83ab42618ce53d98570b9cfaa39144a71c49e8cce77d94b0f679bb82b87b484e06e654eb8298379e8dc093

data/lib/phronomy/agent/base.rb

@@ -1173,7 +1173,7 @@ module Phronomy
             effective_name = resolved.new.name
             rejected_class = Class.new(resolved) do
               tool_name effective_name
-              define_method(:call) do |_args|
+              define_method(:call) do |_args, **_kwargs|
                 "Tool execution denied: scope :#{scope} is not permitted."
               end
             end
@@ -1199,9 +1199,9 @@ module Phronomy
           effective_name = resolved.new.name
           resolved = Class.new(resolved) do
             tool_name effective_name
-            define_method(:call) do |args|
+            define_method(:call) do |args, **kwargs|
               if handler.call(name, args)
-                super(args)
+                super(args, **kwargs)
               else
                 "Tool execution denied."
               end
@@ -1216,8 +1216,8 @@ module Phronomy
         effective_name4 = resolved.new.name
         Class.new(resolved) do
           tool_name effective_name4
-          define_method(:call) do |args|
-            result = super(args)
+          define_method(:call) do |args, **kwargs|
+            result = super(args, **kwargs)
             result_filters.inject(result) { |val, f| f.call(val, tool_name: name, args: args) }
           end
         end

data/lib/phronomy/agent/invocation_session.rb

@@ -298,27 +298,36 @@ module Phronomy
           end
         end
 
-        # Execute the tool off the EventLoop thread via Runtime.instance.spawn.
-        # Tool implementations (e.g. Orchestrator sub-agent dispatch) may call
-        # agent.invoke_async().wait_result which would deadlock if run directly on the
-        # EventLoop dispatch thread. Returning a Task causes
-        # PhaseMachineBuilder#dispatch_task to await the result off the EventLoop
-        # and post :action_completed back when done.
+        # Dispatch the tool off the EventLoop thread via ToolExecutor, which
+        # routes based on the tool's execution_mode class attribute:
+        #   :blocking_io (default) → BlockingAdapterPool (bounded thread pool)
+        #   :cooperative           → Runtime.instance.spawn (scheduler task)
+        # Wrap the awaitable in Task.deferred so FSMSession recognises it as
+        # an async action and sets async_pending = true.
         tc_id = tc.id
         tc_args = tc.arguments
         tc_name = tc.name
-        Phronomy::Runtime.instance.spawn(name: "tool-exec:#{tc_name}") do
-          result = tool_instance.call(tc_args)
-          ctx.chat.add_message(
-            role: :tool,
-            content: result.to_s,
-            tool_call_id: tc_id
-          )
-          ctx.pending_tool_call = nil
-          ctx.tool_call_pending = false
-          ctx.approval_required = false
-          ctx
+        ct = ctx.config[:cancellation_token]
+        awaitable = tool_instance.call_async(tc_args, cancellation_token: ct)
+        result_task = Phronomy::Task.deferred(name: "tool-exec:#{tc_name}")
+        awaitable.on_complete do |result, error|
+          if error
+            result_task.backend.unblock(nil, error)
+            result_task.transition!(:failed, error: error)
+          else
+            ctx.chat.add_message(
+              role: :tool,
+              content: result.to_s,
+              tool_call_id: tc_id
+            )
+            ctx.pending_tool_call = nil
+            ctx.tool_call_pending = false
+            ctx.approval_required = false
+            result_task.backend.unblock(ctx, nil)
+            result_task.transition!(:completed, value: ctx)
+          end
         end
+        result_task
       end
       private_class_method :executing_tool_action
 

data/lib/phronomy/multi_agent/orchestrator.rb

@@ -252,9 +252,9 @@ module Phronomy
         effective_name = prepared.new.name
         Class.new(prepared) do
           tool_name effective_name
-          define_method(:call) do |args|
+          define_method(:call) do |args, **kwargs|
             self._orchestrator_context = orch.instance_variable_get(:@_orchestrator_context)
-            super(args)
+            super(args, **kwargs)
           end
         end
       end

data/lib/phronomy/tools/mcp.rb

@@ -35,39 +35,43 @@ module Phronomy
         #   - "stdio://<command>"  — spawn a child process
         #   - "http://<url>" / "https://<url>" — connect to an HTTP/SSE server
         # @param tool_name [String] the tool name as registered in the MCP server
+        # @param headers [Hash] additional HTTP request headers forwarded to every
+        #   request (tool discovery and tool execution). Ignored for stdio transports.
+        #   Typical use: <tt>headers: { "Authorization" => "Bearer #{ENV['API_KEY']}" }</tt>
         # @return [Mcp] a configured subclass instance ready for use with an Agent
         # @api public
-        def from_server(server_uri, tool_name:)
+        def from_server(server_uri, tool_name:, headers: {})
           # Use a short-lived transport only to query the tool definition,
           # then close it.  Each Mcp instance creates its own transport
           # so that concurrent callers never share IO streams.
-          transport = build_transport(server_uri)
+          transport = build_transport(server_uri, headers: headers)
           begin
             tool_def = transport.fetch_tool(tool_name)
           ensure
             transport.close
           end
-          build_tool_class(tool_name, server_uri, tool_def).new
+          build_tool_class(tool_name, server_uri, tool_def, headers: headers).new
         end
 
         private
 
-        def build_transport(uri)
+        def build_transport(uri, headers: {})
           scheme, path = uri.split("://", 2)
           case scheme
           when "stdio"
             StdioTransport.new(path)
           when "http", "https"
-            HttpTransport.new(uri)
+            HttpTransport.new(uri, headers: headers)
           else
             raise ArgumentError, "Unsupported MCP transport scheme: #{scheme.inspect}. Supported: 'stdio://', 'http://', 'https://'."
           end
         end
 
-        def build_tool_class(tool_name, server_uri, tool_def)
+        def build_tool_class(tool_name, server_uri, tool_def, headers: {})
           klass = Class.new(Mcp)
           klass.tool_name(tool_name)
           klass.instance_variable_set(:@mcp_server_uri, server_uri)
+          klass.instance_variable_set(:@mcp_headers, headers)
 
           # Register description and params from the MCP tool definition.
           klass.description(tool_def[:description] || tool_name)
@@ -82,7 +86,8 @@ module Phronomy
           # never share IO streams, eliminating the need for synchronisation.
           klass.define_method(:initialize) do
             uri = self.class.instance_variable_get(:@mcp_server_uri)
-            @mcp_transport = self.class.send(:build_transport, uri)
+            hdrs = self.class.instance_variable_get(:@mcp_headers) || {}
+            @mcp_transport = self.class.send(:build_transport, uri, headers: hdrs)
           end
 
           klass.define_method(:execute) do |**args|
@@ -249,8 +254,10 @@ module Phronomy
               raise Phronomy::ToolError,
                 "MCP stdio server did not start within #{@startup_timeout} seconds"
             end
-            line = @stdout.gets
-            @stdout.ungetbyte(line) if line
+            # Do NOT call @stdout.gets here: gets() blocks until a newline arrives,
+            # which hangs indefinitely when the server emits no startup line or a
+            # partial line without '\n'.  IO.select already confirmed the server is
+            # alive and responsive; the first rpc_call will consume actual output.
           end
         end
 

data/lib/phronomy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phronomy
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phronomy
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Raizo T.C.S