phronomy 0.25.0 → 0.27.0

data/lib/phronomy/multi_agent/fan_out_session_builder.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require "state_machines"
-
-module Phronomy
-  module MultiAgent
-    # Builds and registers a fan-out coordination FSMSession.
-    class FanOutSessionBuilder
-      AUTO_STATE_SET = {idle: true}.freeze
-      DECLARED_STATES = %i[idle running completed failed timed_out cancelled].freeze
-      WAIT_STATES = [].freeze
-
-      def self.start(
-        invocation:,
-        timeout: nil,
-        cancellation_token: nil,
-        runtime: Phronomy::Runtime.instance
-      )
-        result = Phronomy::Task.deferred(name: "fan-out")
-
-        if cancellation_token&.cancelled?
-          result.fail(Phronomy::CancellationError.new("fan-out cancelled"))
-          return result
-        end
-
-        session = build(invocation: invocation, runtime: runtime)
-        source = Phronomy::Task.deferred(name: "fan-out-source:#{session.id}")
-        source.on_complete do |context, error|
-          if error
-            result.fail(error)
-          elsif context.error
-            result.fail(context.error)
-          else
-            result.complete(context.results)
-          end
-        end
-
-        runtime.event_loop.register(session, completion: source)
-        if timeout
-          runtime.timer_queue.schedule(seconds: timeout) do
-            session.event_sink.post(
-              :timeout,
-              {message: "dispatch_parallel timed out after #{timeout}s"}
-            )
-          end
-        end
-        cancellation_token&.on_cancel do
-          session.event_sink.post(:cancel, nil)
-        end
-        result
-      rescue => error
-        result ||= Phronomy::Task.deferred(name: "fan-out:registration")
-        result.fail(error)
-        result
-      end
-
-      def self.build(invocation:, runtime:)
-        event_sink = Phronomy::FSMSession::EventSink.new(event_loop: runtime.event_loop)
-        phase_machine = build_phase_machine(runtime, event_sink)
-        external_events = {
-          child_completed: [{from: :running, to: :running, guard: nil}],
-          driver_failed: [{from: :running, to: :failed, guard: nil}],
-          timeout: [{from: :running, to: :timed_out, guard: nil}],
-          cancel: [{from: :running, to: :cancelled, guard: nil}]
-        }
-
-        Phronomy::FSMSession.new(
-          context: invocation,
-          event_sink: event_sink,
-          entry_point: :idle,
-          entry_actions: {},
-          auto_state_set: AUTO_STATE_SET,
-          declared_states: DECLARED_STATES,
-          wait_state_names: WAIT_STATES,
-          external_events: external_events,
-          phase_machine_class: phase_machine,
-          recursion_limit: 10_000,
-          event_loop: runtime.event_loop
-        )
-      end
-      private_class_method :build
-
-      def self.build_phase_machine(runtime, event_sink)
-        Class.new do
-          attr_accessor :context, :current_event
-
-          state_machine :phase, initial: :idle do
-            state :idle
-            state :running
-            state :completed
-            state :failed
-            state :timed_out
-            state :cancelled
-
-            event :state_completed do
-              transition idle: :running
-            end
-
-            event :child_completed do
-              transition running: :failed, if: ->(m) { m.context&.failed? }
-              transition running: :completed, if: ->(m) { m.context&.completed? }
-              transition running: :running
-            end
-
-            event(:driver_failed) { transition running: :failed }
-            event(:timeout) { transition running: :timed_out }
-            event(:cancel) { transition running: :cancelled }
-
-            after_transition to: :running do |machine|
-              machine.context.start_available!(runtime, event_sink: event_sink)
-            end
-          end
-        end
-      end
-      private_class_method :build_phase_machine
-    end
-  end
-end

data/lib/phronomy/multi_agent/parallel_tool_chat.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module MultiAgent
-    # RubyLLM::Chat subclass supporting concurrent direct Tool execution.
-    #
-    # AgentInvocation installs +on_tool_call_batch+ and intercepts the whole batch
-    # before this class dispatches anything. The direct-chat fallback dispatches
-    # the complete batch concurrently; process protection remains the responsibility
-    # of Runtime's bounded executors and queues.
-    # @api private
-    class ParallelToolChat < RubyLLM::Chat
-      def initialize(cancellation_token: nil, **opts)
-        super(**opts)
-        @cancellation_token = cancellation_token
-      end
-
-      attr_writer :cancellation_token
-
-      # Registers an Agent-owned batch interceptor. The callback must return
-      # quickly or raise ToolCallIntercepted; it must not execute Tool bodies.
-      def on_tool_call_batch(&block)
-        @on[:tool_call_batch] = block
-        self
-      end
-
-      private
-
-      def handle_tool_calls(response, &block)
-        tool_calls = response.tool_calls.values
-        return super if tool_calls.size <= 1
-
-        if @on[:tool_call_batch]
-          tool_calls.each { run_callbacks(:before_message, :new_message) }
-          @on[:tool_call_batch].call(tool_calls)
-          return
-        end
-
-        # Direct ParallelToolChat fallback. Agent execution never reaches this
-        # branch because AgentInvocation installs the batch interceptor first.
-        # RubyLLM >= 1.15 additive callbacks are dispatched together with their
-        # legacy equivalents, matching RubyLLM::Chat semantics.
-        tool_calls.each do |tool_call|
-          run_callbacks(:before_message, :new_message)
-          run_callbacks(:before_tool_call, :tool_call, tool_call)
-        end
-
-        cancellation_token = @cancellation_token
-        if cancellation_token&.cancelled?
-          raise Phronomy::CancellationError,
-            "invocation cancelled before tool execution"
-        end
-
-        dispatched = tool_calls.map do |tool_call|
-          tool = tools[tool_call.name.to_sym]
-          unless tool
-            next {
-              tool_call: tool_call,
-              awaitable: nil,
-              result: {
-                error: "Model tried to call unavailable tool `#{tool_call.name}`. " \
-                  "Available tools: #{tools.keys.to_json}."
-              }
-            }
-          end
-
-          awaitable = Phronomy::Agent::ToolExecutor.call_async(
-            tool: tool,
-            args: tool_call.arguments,
-            cancellation_token: cancellation_token
-          )
-          {tool_call: tool_call, awaitable: awaitable, result: nil}
-        end
-
-        tool_results = dispatched.map do |item|
-          result = item[:awaitable] ? item[:awaitable].wait_result : item[:result]
-          {tool_call: item[:tool_call], result: result}
-        end
-
-        halt_result = nil
-        tool_results.each do |item|
-          result = item[:result]
-          run_callbacks(:after_tool_result, :tool_result, result)
-          tool_payload = result.is_a?(RubyLLM::Tool::Halt) ? result.content : result
-          content = content_like?(tool_payload) ? tool_payload : tool_payload.to_s
-          message = add_message(
-            role: :tool,
-            content: content,
-            tool_call_id: item[:tool_call].id
-          )
-          run_callbacks(:after_message, :end_message, message)
-          halt_result = result if result.is_a?(RubyLLM::Tool::Halt)
-        end
-
-        reset_tool_choice if forced_tool_choice?
-        halt_result || complete(&block)
-      end
-
-      def execute_tool(tool_call)
-        tool = tools[tool_call.name.to_sym]
-        unless tool
-          return {
-            error: "Model tried to call unavailable tool `#{tool_call.name}`. " \
-              "Available tools: #{tools.keys.to_json}."
-          }
-        end
-
-        Phronomy::Agent::ToolExecutor.call_async(
-          tool: tool,
-          args: tool_call.arguments,
-          cancellation_token: @cancellation_token
-        ).wait_result
-      end
-    end
-  end
-end