phronomy 0.8.0 → 0.9.1

data/lib/phronomy/agent/react_agent.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  module Agent
-    # ReAct pattern (Reasoning + Acting) agent.
-    # Repeats the LLM <-> Tool loop until no more tool calls are made.
-    class ReactAgent < Base
-      private
-
-      # Performs a single (non-retried) ReAct invocation.
-      # Overrides Base#invoke_once so that Base#invoke's retry loop is inherited.
-      def invoke_once(input, messages: [], thread_id: nil, config: {})
-        caller_meta = {}
-        caller_meta[:user_id] = config[:user_id] if config[:user_id]
-        caller_meta[:session_id] = config[:session_id] if config[:session_id]
-        if (ic = config[:invocation_context])
-          caller_meta[:task_id] = ic.task_id if ic.task_id
-          caller_meta[:parent_task_id] = ic.parent_task_id if ic.parent_task_id
-        end
-
-        trace("agent.invoke", input: input, **caller_meta) do |_span|
-          # Run input guardrails before any LLM interaction.
-          run_input_guardrails!(input)
-
-          max_iter = self.class.max_iterations
-
-          # Seed with app-managed conversation history when provided.
-          messages = Array(messages).dup
-          user_asked = false
-          total_usage = Phronomy::TokenUsage.zero
-          iterations_exhausted = true
-
-          max_iter.times do
-            response = step(messages, input, user_asked: user_asked, thread_id: thread_id, config: config)
-            user_asked = true
-            messages = response[:messages]
-            total_usage += response[:usage]
-            if response[:done]
-              iterations_exhausted = false
-              break
-            end
-          end
-
-          # Select the last assistant-produced content as the output, skipping
-          # raw tool result messages (role: :tool) to avoid returning tool JSON
-          # or status strings as the agent's answer when iterations are exhausted.
-          output = messages.reverse.find { |m| m.content && !m.content.empty? && m.role != :tool }&.content
-
-          # Run output guardrails before returning to the caller.
-          run_output_guardrails!(output)
-
-          result = {output: output, messages: messages, usage: total_usage, iterations_exhausted: iterations_exhausted}
-          [result, total_usage]
-        end
-      end
-
-      public
-
-      # Streaming version of #invoke for the ReAct loop.
-      # Yields {Phronomy::Agent::StreamEvent} events while the LLM-tool loop runs.
-      #
-      # @param input     [String, Hash]
-      # @param messages  [Array<RubyLLM::Message>] same as #invoke
-      # @param thread_id [String, nil]              same as #invoke
-      # @param config    [Hash]
-      # @yield [Phronomy::Agent::StreamEvent]
-      # @return [Hash] { output:, messages:, usage: }
-      # @api public
-      def stream(input, messages: [], thread_id: nil, config: {}, &block)
-        return invoke(input, messages: messages, thread_id: thread_id, config: config) unless block
-
-        caller_meta = {}
-        caller_meta[:user_id] = config[:user_id] if config[:user_id]
-        caller_meta[:session_id] = config[:session_id] if config[:session_id]
-        if (ic = config[:invocation_context])
-          caller_meta[:task_id] = ic.task_id if ic.task_id
-          caller_meta[:parent_task_id] = ic.parent_task_id if ic.parent_task_id
-        end
-
-        trace("agent.invoke", input: input, **caller_meta) do |_span|
-          run_input_guardrails!(input)
-
-          max_iter = self.class.max_iterations
-
-          messages = Array(messages).dup
-          user_asked = false
-          total_usage = Phronomy::TokenUsage.zero
-          iterations_exhausted = true
-
-          max_iter.times do
-            response = stream_step(messages, input, user_asked: user_asked, thread_id: thread_id, config: config, &block)
-            user_asked = true
-            messages = response[:messages]
-            total_usage += response[:usage]
-            if response[:done]
-              iterations_exhausted = false
-              break
-            end
-          end
-
-          # Select the last assistant-produced content as the output, skipping
-          # raw tool result messages (role: :tool) — same as the non-streaming path.
-          output = messages.reverse.find { |m| m.content && !m.content.empty? && m.role != :tool }&.content
-          run_output_guardrails!(output)
-
-          result = {output: output, messages: messages, usage: total_usage, iterations_exhausted: iterations_exhausted}
-          block.call(StreamEvent.new(type: :done, payload: result))
-          [result, total_usage]
-        end
-      rescue => e
-        block&.call(StreamEvent.new(type: :error, payload: {error: e}))
-        raise
-      end
-
-      private
-
-      def step(messages, initial_input, user_asked: false, thread_id: nil, config: {})
-        chat = build_chat
-
-        if user_asked
-          # Subsequent loop iteration — messages already contains the full conversation
-          # (including the user's original input from the first step); apply system
-          # instructions and replay the accumulated history, then let the LLM continue.
-          system_text = build_cached_system_text(initial_input)
-          apply_instructions(chat, system_text) if system_text
-          messages.each { |m| chat.add_message(m) }
-        else
-          # First iteration — assemble context (system + history) via build_context so
-          # that trimming, compaction, and knowledge sources are applied consistently.
-          context = build_context(initial_input, messages: messages, thread_id: thread_id, config: config)
-          apply_instructions(chat, context[:system]) if context[:system]
-          context[:messages].each { |m| chat.messages << m }
-        end
-
-        # Run before_completion hooks before each LLM call in the ReAct loop.
-        run_before_completion_hooks!(chat, config)
-
-        # Route the LLM call through the configured LLMAdapter so that the
-        # blocking HTTP request runs inside BlockingAdapterPool and the
-        # adapter can be swapped without changing agent code.
-        # Passing nil as message signals the adapter to call chat.complete
-        # (no new user turn) for continuation iterations.
-        adapter = Phronomy.configuration.llm_adapter
-        message = user_asked ? nil : extract_message(initial_input)
-        response = adapter.complete_async(chat, message, config: config).await
-
-        usage = Phronomy::TokenUsage.from_tokens(response&.tokens)
-        tool_calls = chat.messages.last&.tool_calls
-        done = tool_calls.nil? || tool_calls.empty?
-        {messages: chat.messages, done: done, usage: usage}
-      end
-
-      # Streaming variant of #step.  Yields :token / :tool_call / :tool_result events
-      # via the block while the LLM call is in progress.
-      def stream_step(messages, initial_input, user_asked: false, thread_id: nil, config: {}, &block)
-        chat = build_chat
-
-        if user_asked
-          system_text = build_cached_system_text(initial_input)
-          apply_instructions(chat, system_text) if system_text
-          messages.each { |m| chat.add_message(m) }
-        else
-          context = build_context(initial_input, messages: messages, thread_id: thread_id, config: config)
-          apply_instructions(chat, context[:system]) if context[:system]
-          context[:messages].each { |m| chat.messages << m }
-        end
-
-        current_tool_call = nil
-        chat.on_tool_call do |tc|
-          current_tool_call = tc
-          block.call(StreamEvent.new(type: :tool_call, payload: {tool_call: tc}))
-        end
-        chat.on_tool_result do |tr|
-          block.call(StreamEvent.new(type: :tool_result, payload: {
-            tool_call_id: current_tool_call&.id,
-            tool_name: current_tool_call&.name,
-            tool_result: tr
-          }))
-        end
-
-        # Run before_completion hooks before each LLM call in the streaming loop.
-        run_before_completion_hooks!(chat, config)
-
-        # Route the streaming LLM call through the configured LLMAdapter so that
-        # the blocking HTTP request runs inside BlockingAdapterPool.
-        # Passing nil as message signals the adapter to call chat.complete
-        # (no new user turn) for continuation iterations.
-        # Streaming chunks and tool event callbacks are delivered directly via the
-        # block on the pool worker thread; pending.await yields cooperatively until
-        # streaming is complete.
-        adapter = Phronomy.configuration.llm_adapter
-        message = user_asked ? nil : extract_message(initial_input)
-        streaming_block = proc { |chunk| block.call(StreamEvent.new(type: :token, payload: {content: chunk.content})) }
-        pending = adapter.stream_async(chat, message, config: config, &streaming_block)
-        response = pending.await
-
-        usage = Phronomy::TokenUsage.from_tokens(response&.tokens)
-        tool_calls = chat.messages.last&.tool_calls
-        done = tool_calls.nil? || tool_calls.empty?
-        {messages: chat.messages, done: done, usage: usage}
-      end
-    end
-  end
-end

data/lib/phronomy/embeddings.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # Embeddings adapters for converting text into vector representations.
-  #
-  # Sub-classes are auto-loaded by Zeitwerk:
-  #   Phronomy::Agent::Context::Knowledge::Embeddings::Base
-  #   Phronomy::Agent::Context::Knowledge::Embeddings::RubyLLMEmbeddings
-  module Embeddings
-  end
-end

data/lib/phronomy/loader.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # Document loader implementations for ingesting files into a RAG pipeline.
-  #
-  # Sub-classes are auto-loaded by Zeitwerk:
-  #   Phronomy::Agent::Context::Knowledge::Loader::Base
-  #   Phronomy::Agent::Context::Knowledge::Loader::PlainTextLoader
-  #   Phronomy::Agent::Context::Knowledge::Loader::MarkdownLoader
-  #   Phronomy::Agent::Context::Knowledge::Loader::CsvLoader
-  module Loader
-  end
-end

data/lib/phronomy/splitter.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Phronomy
-  # Text splitter implementations for chunking documents before embedding.
-  #
-  # Sub-classes are auto-loaded by Zeitwerk:
-  #   Phronomy::Agent::Context::Knowledge::Splitter::Base
-  #   Phronomy::Agent::Context::Knowledge::Splitter::FixedSizeSplitter
-  #   Phronomy::Agent::Context::Knowledge::Splitter::RecursiveSplitter
-  module Splitter
-  end
-end