ollama_agent 0.1.0 → 0.3.0

data/lib/ollama_agent/agent.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "agent_prompt"
+require_relative "prompt_skills"
 require_relative "console"
 require_relative "ollama_connection"
 require_relative "tools_schema"
@@ -8,52 +9,139 @@ require_relative "sandboxed_tools"
 require_relative "think_param"
 require_relative "timeout_param"
 require_relative "tool_content_parser"
+require_relative "streaming/hooks"
+require_relative "resilience/retry_middleware"
+require_relative "resilience/audit_logger"
+require_relative "context/manager"
+require_relative "session/store"
+require_relative "env_config"
+require_relative "model_env"
+require_relative "agent/agent_config"
+require_relative "agent/client_wiring"
+require_relative "agent/prompt_wiring"
+require_relative "agent/session_wiring"
 
 module OllamaAgent
   # Runs a tool-calling loop against Ollama: read files, search, apply unified diffs.
+  # Public entry: {#run}. Other instance methods are internal to the agent loop.
+  # rubocop:disable Metrics/ClassLength -- facade coordinates includes and turn loop
   class Agent
     include SandboxedTools
+    include ClientWiring
+    include PromptWiring
+    include SessionWiring
 
     MAX_TURNS = 64
-    # ollama-client defaults to 30s; multi-turn tool chats often need longer on local hardware.
     DEFAULT_HTTP_TIMEOUT = 120
 
-    attr_reader :client, :root
-
-    # rubocop:disable Metrics/ParameterLists -- CLI and tests pass explicit dependencies
-    def initialize(client: nil, model: nil, root: nil, confirm_patches: true, http_timeout: nil, think: nil)
-      @model = model || default_model
-      @root = File.expand_path(root || ENV.fetch("OLLAMA_AGENT_ROOT", Dir.pwd))
-      @confirm_patches = confirm_patches
-      @http_timeout_override = http_timeout
-      @think = think
+    attr_reader :client, :root, :hooks
+
+    # @param config [AgentConfig, nil] when set, keyword options are ignored (use {Runner} or build {AgentConfig}).
+    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable Metrics/MethodLength
+    def initialize(client: nil, config: nil, model: nil, root: nil, confirm_patches: true, http_timeout: nil,
+                   think: nil,
+                   read_only: false, patch_policy: nil,
+                   skill_paths: nil, skills_enabled: nil, skills_include: nil, skills_exclude: nil,
+                   external_skills_enabled: nil,
+                   orchestrator: false, confirm_delegation: nil,
+                   max_retries: nil, audit: nil,
+                   session_id: nil, resume: false,
+                   max_tokens: nil, context_summarize: nil,
+                   stdin: $stdin, stdout: $stdout)
+      cfg = config || AgentConfig.new(
+        model: model, root: root, confirm_patches: confirm_patches, http_timeout: http_timeout, think: think,
+        read_only: read_only, patch_policy: patch_policy,
+        skill_paths: skill_paths, skills_enabled: skills_enabled, skills_include: skills_include,
+        skills_exclude: skills_exclude, external_skills_enabled: external_skills_enabled,
+        orchestrator: orchestrator, confirm_delegation: confirm_delegation,
+        max_retries: max_retries, audit: audit, session_id: session_id, resume: resume,
+        max_tokens: max_tokens, context_summarize: context_summarize, stdin: stdin, stdout: stdout
+      )
+      apply_agent_config(cfg)
+      @user_prompt = UserPrompt.new(stdin: cfg.stdin, stdout: cfg.stdout)
+      @context_manager = Context::Manager.new(max_tokens: @max_tokens, context_summarize: @context_summarize)
+      @hooks = Streaming::Hooks.new
+      attach_audit_logger if resolved_audit_enabled
       @client = client || build_default_client
     end
+    # rubocop:enable Metrics/MethodLength
     # rubocop:enable Metrics/ParameterLists
 
     def run(query)
-      messages = [
-        { role: "system", content: system_prompt },
-        { role: "user", content: query }
-      ]
-
+      Console.reset_thinking_session!
+      messages = build_messages_for_run(query)
       execute_agent_turns(messages)
     end
 
     private
 
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize -- maps AgentConfig to ivars + resolved max turns
+    def apply_agent_config(cfg)
+      @model = cfg.model || default_model
+      @root = File.expand_path(cfg.root || ENV.fetch("OLLAMA_AGENT_ROOT", Dir.pwd))
+      @confirm_patches = cfg.confirm_patches
+      @read_only = cfg.read_only
+      @patch_policy = cfg.patch_policy
+      @http_timeout_override = cfg.http_timeout
+      @think = cfg.think
+      @skill_paths = cfg.skill_paths
+      @skills_enabled = cfg.skills_enabled
+      @skills_include = cfg.skills_include
+      @skills_exclude = cfg.skills_exclude
+      @external_skills_enabled = cfg.external_skills_enabled
+      @orchestrator = cfg.orchestrator
+      @confirm_delegation = cfg.resolved_confirm_delegation
+      @max_retries = cfg.max_retries
+      @audit = cfg.audit
+      @session_id = cfg.session_id
+      @resume = cfg.resume
+      @max_tokens = cfg.max_tokens
+      @context_summarize = cfg.context_summarize
+      strict = EnvConfig.strict_env?
+      @max_turns = EnvConfig.fetch_int("OLLAMA_AGENT_MAX_TURNS", MAX_TURNS, strict: strict)
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    # rubocop:disable Metrics/MethodLength -- turn loop with early break
     def execute_agent_turns(messages)
-      max_turns.times do
-        message = chat_assistant_message(messages)
+      @current_turn = 0
+      @max_turns.times do
+        @current_turn += 1
+        trimmed = trimmed_messages_for_chat(messages)
+        message = chat_assistant_message(trimmed)
         tool_calls = tool_calls_from(message)
-
-        messages << message.to_h
-        return if tool_calls.empty?
+        persist_assistant_turn(messages, message)
+        break if tool_calls.empty?
 
         append_tool_results(messages, tool_calls)
       end
+      emit_turn_complete(messages)
+      warn_max_turns_if_needed
+    end
+    # rubocop:enable Metrics/MethodLength
 
-      warn "ollama_agent: maximum tool rounds (#{max_turns}) reached" if ENV["OLLAMA_AGENT_DEBUG"] == "1"
+    def trimmed_messages_for_chat(messages)
+      @context_manager.trim(messages)
+    end
+
+    def persist_assistant_turn(messages, message)
+      messages << message.to_h
+      save_message_to_session(message.to_h)
+    end
+
+    def emit_turn_complete(messages)
+      @hooks.emit(:on_complete, { messages: messages, turns: @current_turn })
+    end
+
+    def warn_max_turns_if_needed
+      return unless ENV["OLLAMA_AGENT_DEBUG"] == "1" && @current_turn >= @max_turns
+
+      warn "ollama_agent: maximum tool rounds (#{@max_turns}) reached"
+    end
+
+    def current_turn
+      @current_turn || 0
     end
 
     def tool_calls_from(message)
@@ -63,15 +151,16 @@ module OllamaAgent
       ToolContentParser.synthetic_calls(message.content)
     end
 
-    def max_turns
-      Integer(ENV.fetch("OLLAMA_AGENT_MAX_TURNS", MAX_TURNS.to_s))
-    rescue ArgumentError, TypeError
-      MAX_TURNS
+    def chat_assistant_message(messages)
+      if @hooks.subscribed?(:on_token)
+        stream_assistant_message(messages)
+      else
+        block_assistant_message(messages)
+      end
     end
 
-    def chat_assistant_message(messages)
+    def block_assistant_message(messages)
       response = @client.chat(**chat_request_args(messages))
-
       message = response.message
       raise Error, "Empty assistant message" if message.nil?
 
@@ -79,16 +168,41 @@ module OllamaAgent
       message
     end
 
+    def stream_assistant_message(messages)
+      response = @client.chat(**chat_request_args(messages), hooks: ollama_stream_hooks)
+      message = response.message
+      raise Error, "Empty assistant message" if message.nil?
+
+      message
+    end
+
     def chat_request_args(messages)
-      args = {
+      base_chat_request_args(messages).tap do |args|
+        th = resolve_think
+        args[:think] = th unless th.nil?
+      end
+    end
+
+    def base_chat_request_args(messages)
+      {
         messages: messages,
-        tools: TOOLS,
+        tools: OllamaAgent.tools_for(read_only: @read_only, orchestrator: @orchestrator),
         model: @model,
         options: { temperature: 0.2 }
       }
-      th = resolve_think
-      args[:think] = th unless th.nil?
-      args
+    end
+
+    def ollama_stream_hooks
+      {
+        on_thinking: ->(fragment) { @hooks.emit(:on_thinking, { token: fragment.to_s, turn: current_turn }) },
+        on_token: lambda do |*args|
+          token = args[0]
+          logprobs = args[1]
+          payload = { token: token, turn: current_turn }
+          payload[:logprobs] = logprobs unless logprobs.nil?
+          @hooks.emit(:on_token, payload)
+        end
+      }
     end
 
     def announce_assistant_content(message)
@@ -100,47 +214,8 @@ module OllamaAgent
     end
 
     def default_model
-      ENV["OLLAMA_AGENT_MODEL"] || Ollama::Config.new.model
-    end
-
-    def build_default_client
-      config = Ollama::Config.new
-      @http_timeout_seconds = resolved_http_timeout_seconds
-      config.timeout = @http_timeout_seconds
-      OllamaConnection.apply_env_to_config(config)
-      Ollama::Client.new(config: config)
-    end
-
-    def resolved_http_timeout_seconds
-      parsed = TimeoutParam.parse_positive(@http_timeout_override)
-      return parsed if parsed
-
-      parsed = TimeoutParam.parse_positive(ENV.fetch("OLLAMA_AGENT_TIMEOUT", nil))
-      return parsed if parsed
-
-      DEFAULT_HTTP_TIMEOUT
-    end
-
-    def system_prompt
-      AgentPrompt.text
-    end
-
-    def append_tool_results(messages, tool_calls)
-      tool_calls.each do |tool_call|
-        result = execute_tool(tool_call.name, tool_call.arguments || {})
-        messages << tool_message(tool_call, result)
-      end
-    end
-
-    def tool_message(tool_call, result)
-      msg = {
-        role: "tool",
-        name: tool_call.name,
-        content: result.to_s
-      }
-      id = tool_call.id
-      msg[:tool_call_id] = id if id && !id.to_s.empty?
-      msg
+      ModelEnv.default_chat_model
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ollama_agent/agent_prompt.rb

@@ -5,7 +5,7 @@ module OllamaAgent
   module AgentPrompt
     def self.text
       <<~PROMPT
-        You are a coding assistant with tools: list_files, read_file, search_code, edit_file.
+        You are a coding assistant with tools: list_files, read_file, search_code, edit_file, write_file.
         Work only under the project root. Briefly state your plan, then use tools.
 
         Large Ruby codebases: use search_code with mode "method", "class", "module", or "constant" to locate definitions
@@ -15,6 +15,9 @@ module OllamaAgent
         Do not paste JSON tool calls or {"name": ...} blocks in your reply text. Tools run only when the host
         receives native tool calls from the model API—not from prose. Never put commas after --- or +++ file lines.
 
+        Use write_file to create a new file or fully replace an existing file with complete content.
+        Prefer edit_file for surgical changes to existing files; reserve write_file for new files or full rewrites.
+
         For README or documentation updates that should reflect the codebase:
         1) list_files on "." or "lib" (and read ollama_agent.gemspec if present) to see structure.
         2) read_file every file you will change before editing (e.g. README.md, lib/ollama_agent.rb).
@@ -40,5 +43,32 @@ module OllamaAgent
         them as the assistant message.
       PROMPT
     end
+
+    def self.self_review_text
+      <<~PROMPT
+        You are reviewing the ollama_agent Ruby gem. Tools available: list_files, read_file, search_code only.
+        Do not call edit_file and do not output unified diffs—this run is analysis-only.
+
+        The user message may begin with a "## Static analysis (ruby_mastery)" section from automated tooling; weigh it
+        against what you verify in the tree.
+
+        Work only under the project root. Briefly state your plan, then use tools.
+
+        Large Ruby trees: use search_code with mode "method", "class", "module", or "constant" to locate definitions
+        via the Prism index, then read_file with start_line/end_line for only the lines you need.
+
+        Final reply: strengths, risks, and concrete suggestions with file paths (and line numbers when clear).
+        Do not paste JSON tool calls in prose; tools run only via native tool calls from the API.
+      PROMPT
+    end
+
+    def self.orchestrator_addon
+      <<~PROMPT
+        Orchestrator mode: you may call list_external_agents to see which external CLI tools are installed,
+        then delegate_to_agent with a valid agent_id from that list. Gather context with read_file and
+        search_code first; keep task and context_summary short. Do not invent agent_id values.
+        External runs use non-interactive argv only; cwd is the project root.
+      PROMPT
+    end
   end
 end

data/lib/ollama_agent/chat_stream_carry.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  # ollama-client 1.1.0 +process_chat_stream_chunk+ returns the *previous* +last_data+ for every
+  # non-+done+ line, so +message.tool_calls+ seen on an intermediate NDJSON row are dropped when the
+  # final +done+ row omits them. Carry forward merged state and copy +tool_calls+ onto the +done+ row.
+  module ChatStreamCarry
+    module_function
+
+    def next_last_data(prev, obj)
+      return json_dup(obj) if prev.nil? && !truthy_done?(obj)
+      return prev if truthy_done?(obj)
+
+      merge_carry(prev, obj)
+    end
+
+    def stitch_done_message_tool_calls!(done_obj, prev_carry)
+      prev_tc = tool_calls_from_carry(prev_carry)
+      return if prev_tc.nil? || !truthy_done?(done_obj)
+
+      apply_tool_calls_to_done!(done_obj, prev_tc)
+    end
+
+    def merge_carry(prev, obj)
+      merged = json_dup(prev)
+      chunk_msg = obj["message"]
+      return merged if chunk_msg.nil? || !chunk_msg.is_a?(Hash)
+
+      merge_message_fields!(merged, chunk_msg)
+      merged
+    end
+
+    def truthy_done?(obj)
+      obj.is_a?(Hash) && (obj["done"] == true || obj[:done] == true)
+    end
+
+    def json_dup(payload)
+      return payload if payload.nil?
+
+      JSON.parse(JSON.generate(payload))
+    rescue JSON::GeneratorError, JSON::ParserError, TypeError
+      dup_via_marshal(payload)
+    end
+
+    def tool_calls_from_carry(prev_carry)
+      return unless prev_carry.is_a?(Hash)
+
+      prev_msg = prev_carry["message"]
+      return unless prev_msg.is_a?(Hash)
+
+      tc = prev_msg["tool_calls"]
+      return tc if tc.is_a?(Array) && !tc.empty?
+
+      nil
+    end
+    private_class_method :tool_calls_from_carry
+
+    def apply_tool_calls_to_done!(done_obj, prev_tc)
+      done_msg = done_obj["message"]
+      unless done_msg.is_a?(Hash)
+        done_obj["message"] = { "role" => "assistant", "tool_calls" => prev_tc }
+        return
+      end
+
+      done_tc = done_msg["tool_calls"]
+      return if done_tc.is_a?(Array) && !done_tc.empty?
+
+      done_msg["tool_calls"] = prev_tc
+    end
+    private_class_method :apply_tool_calls_to_done!
+
+    def merge_message_fields!(merged, chunk_msg)
+      mm = (merged["message"] ||= {})
+      tc = chunk_msg["tool_calls"]
+      mm["tool_calls"] = tc if tc.is_a?(Array) && !tc.empty?
+      role = chunk_msg["role"]
+      mm["role"] = role if role && !role.to_s.strip.empty?
+    end
+    private_class_method :merge_message_fields!
+
+    def dup_via_marshal(payload)
+      Marshal.load(Marshal.dump(payload))
+    rescue ArgumentError, TypeError
+      payload.dup
+    end
+    private_class_method :dup_via_marshal
+  end
+end

data/lib/ollama_agent/chat_stream_thinking_format.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OllamaAgent
+  # Coerces streamed +message.thinking+ payloads to a String before ollama-client appends
+  # with +full_thinking << thinking+ (which raises TypeError on Hash/Array for some models/APIs).
+  module ChatStreamThinkingFormat
+    module_function
+
+    def normalize_message_thinking!(message_hash)
+      return unless message_hash.is_a?(Hash)
+
+      raw = message_hash["thinking"]
+      return if raw.nil? || raw.is_a?(String)
+
+      message_hash["thinking"] = coerce_thinking_to_string(raw)
+    end
+
+    def coerce_thinking_to_string(raw)
+      case raw
+      when String then raw
+      when Array then raw.map { |elem| coerce_thinking_to_string(elem) }.join
+      else
+        JSON.generate(raw)
+      end
+    rescue JSON::GeneratorError, TypeError
+      raw.to_s
+    end
+  end
+end