active_harness 0.3.8 → 0.3.10

data/lib/active_harness/core/errors.rb

@@ -1,4 +1,15 @@
 module ActiveHarness
+  # Matches a client that went away mid-stream: IOError anywhere, plus
+  # ActionController::Live::ClientDisconnected when Rails is loaded.
+  # Usable in `rescue ActiveHarness::ClientGone`; never raises NameError outside Rails.
+  module ClientGone
+    def self.===(error)
+      return true if IOError === error
+      defined?(::ActionController::Live::ClientDisconnected) &&
+        ::ActionController::Live::ClientDisconnected === error
+    end
+  end
+
   module Errors
     Error = Class.new(StandardError)
 

data/lib/active_harness/pipeline/hooks.rb

@@ -63,7 +63,7 @@ module ActiveHarness
     def fire(event, step_name, data, config)
       run_hooks(config[:hooks], event, step_name, data)
       @stream&.call(:pipeline, event, step_name, data)
-    rescue IOError, ActionController::Live::ClientDisconnected
+    rescue ClientGone
       nil
     end
 

data/lib/active_harness/providers/anthropic.rb

@@ -8,7 +8,11 @@ module ActiveHarness
       ANTHROPIC_VERSION = "2023-06-01"
       DEFAULT_MAX_TOKENS = 1024
 
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      def supports_tools?
+        true
+      end
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         system_msg, chat_messages = extract_system(messages)
 
         body = {
@@ -18,6 +22,7 @@ module ActiveHarness
           messages:    chat_messages
         }
         body[:system] = system_msg if system_msg
+        body[:tools]  = anthropic_tools(tools) if tools && !tools.empty?
 
         headers = {
           "Content-Type"      => "application/json",
@@ -32,30 +37,74 @@ module ActiveHarness
           stream: stream,
           provider: :anthropic,
           model: model
-        ) if stream
+        ) if stream && !(tools && !tools.empty?)
 
         raw  = post_json(URI(config.anthropic_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
         {
-          content:  data.dig("content", 0, "text").to_s.strip,
+          content:  Array(data["content"]).select { |b| b["type"] == "text" }.map { |b| b["text"] }.join.strip,
           provider: :anthropic,
           model:    data["model"] || model,
-          usage:    extract_usage_anthropic(data)
+          usage:    extract_usage_anthropic(data),
+          **anthropic_tool_calls_entry(data)
         }
       end
 
       private
 
       # Anthropic keeps system prompt separate from the messages array.
+      # Also maps the neutral tool-calling message shape to Anthropic content blocks.
       def extract_system(messages)
-        system = messages.find { |m| m[:role] == "system" || m["role"] == "system" }
-        chat   = messages.reject { |m| m[:role] == "system" || m["role"] == "system" }
-                         .map { |m| { role: m[:role] || m["role"], content: m[:content] || m["content"] } }
+        role_of = ->(m) { (m[:role] || m["role"]).to_s }
+        system  = messages.find { |m| role_of.call(m) == "system" }
+        chat    = messages.reject { |m| role_of.call(m) == "system" }.map { |m| anthropic_message(m) }
 
         system_text = system && (system[:content] || system["content"])
-        [system_text, chat]
+        [system_text, merge_tool_results(chat)]
+      end
+
+      def anthropic_message(m)
+        role    = (m[:role] || m["role"]).to_s
+        content = m[:content] || m["content"]
+        calls   = m[:tool_calls] || m["tool_calls"]
+
+        if role == "assistant" && calls && !calls.empty?
+          blocks = []
+          blocks << { type: "text", text: content.to_s } unless content.to_s.empty?
+          calls.each { |c| blocks << { type: "tool_use", id: c[:id], name: c[:name], input: c[:arguments] || {} } }
+          { role: "assistant", content: blocks }
+        elsif role == "tool"
+          { role: "user", content: [{ type: "tool_result", tool_use_id: m[:tool_call_id] || m["tool_call_id"], content: content.to_s }] }
+        else
+          { role: role, content: content }
+        end
+      end
+
+      # Consecutive tool results must live in one user message.
+      def merge_tool_results(chat)
+        chat.each_with_object([]) do |m, out|
+          prev = out.last
+          if prev && prev[:role] == "user" && m[:role] == "user" &&
+             prev[:content].is_a?(Array) && m[:content].is_a?(Array) &&
+             prev[:content].all? { |b| b[:type] == "tool_result" } && m[:content].all? { |b| b[:type] == "tool_result" }
+            prev[:content].concat(m[:content])
+          else
+            out << m
+          end
+        end
+      end
+
+      def anthropic_tools(tools)
+        Array(tools).map { |t| { name: t[:name], description: t[:description].to_s, input_schema: t[:parameters] } }
+      end
+
+      def anthropic_tool_calls_entry(data)
+        calls = Array(data["content"]).select { |b| b["type"] == "tool_use" }
+        return {} if calls.empty?
+
+        { tool_calls: calls.map { |b| { id: b["id"], name: b["name"], arguments: b["input"] || {}, raw_arguments: JSON.generate(b["input"] || {}) } } }
       end
 
       def api_key

data/lib/active_harness/providers/base.rb

@@ -6,6 +6,12 @@ module ActiveHarness
       HTTP            = ActiveHarness::Http::Client.new
       STREAMING_HTTP  = ActiveHarness::Http::StreamingClient.new
 
+      # Providers that can send `tools:` and return `tool_calls:` override this
+      # (see Providers::ToolCalling). Everything else is rejected by Request.
+      def supports_tools?
+        false
+      end
+
       private
 
       def config

data/lib/active_harness/providers/deepseek.rb

@@ -5,11 +5,14 @@ module ActiveHarness
     # DeepSeek — OpenAI-compatible API.
     # https://platform.deepseek.com/api-docs
     class DeepSeek < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.deepseek_api_url, headers: headers, body: body, stream: stream, provider: :deepseek, model: model) if stream
+        return call_streaming(url: config.deepseek_api_url, headers: headers, body: body, stream: stream, provider: :deepseek, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.deepseek_api_url), headers: headers, body: body)
         data = parse!(raw)
@@ -19,7 +22,7 @@ module ActiveHarness
           content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :deepseek,
           model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
+          usage:    extract_usage_openai(data), **openai_tool_calls_entry(data)
         }
       end
 

data/lib/active_harness/providers/gpustack.rb

@@ -13,20 +13,23 @@ module ActiveHarness
     #     use provider: :gpustack, model: "Qwen/Qwen2.5-7B-Instruct-GGUF"
     #   end
     class GPUStack < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         url     = "#{api_base}/v1/chat/completions"
         headers = { "Content-Type" => "application/json" }
         key     = api_key
         headers["Authorization"] = "Bearer #{key}" if key
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: url, headers: headers, body: body, stream: stream, provider: :gpustack, model: model) if stream
+        return call_streaming(url: url, headers: headers, body: body, stream: stream, provider: :gpustack, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :gpustack, model: data["model"] || model, usage: extract_usage_openai(data) }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :gpustack, model: data["model"] || model, usage: extract_usage_openai(data), **openai_tool_calls_entry(data) }
       end
 
       private

data/lib/active_harness/providers/groq.rb

@@ -5,17 +5,20 @@ module ActiveHarness
     # Groq — OpenAI-compatible API with fast inference.
     # https://console.groq.com/docs/openai
     class Groq < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.groq_api_url, headers: headers, body: body, stream: stream, provider: :groq, model: model) if stream
+        return call_streaming(url: config.groq_api_url, headers: headers, body: body, stream: stream, provider: :groq, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.groq_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :groq, model: data["model"] || model, usage: extract_usage_openai(data) }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :groq, model: data["model"] || model, usage: extract_usage_openai(data), **openai_tool_calls_entry(data) }
       end
 
       private

data/lib/active_harness/providers/hetzner.rb

@@ -13,11 +13,14 @@ module ActiveHarness
     #     use provider: :hetzner, model: "meta-llama/Llama-3.3-70B-Instruct"
     #   end
     class Hetzner < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.hetzner_api_url, headers: headers, body: body, stream: stream, provider: :hetzner, model: model) if stream
+        return call_streaming(url: config.hetzner_api_url, headers: headers, body: body, stream: stream, provider: :hetzner, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.hetzner_api_url), headers: headers, body: body)
         data = parse!(raw)
@@ -27,7 +30,7 @@ module ActiveHarness
           content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :hetzner,
           model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
+          usage:    extract_usage_openai(data), **openai_tool_calls_entry(data)
         }
       end
 

data/lib/active_harness/providers/mistral.rb

@@ -5,11 +5,14 @@ module ActiveHarness
     # Mistral AI — OpenAI-compatible API.
     # https://docs.mistral.ai/api
     class Mistral < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.mistral_api_url, headers: headers, body: body, stream: stream, provider: :mistral, model: model) if stream
+        return call_streaming(url: config.mistral_api_url, headers: headers, body: body, stream: stream, provider: :mistral, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.mistral_api_url), headers: headers, body: body)
         data = parse!(raw)
@@ -19,7 +22,7 @@ module ActiveHarness
           content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :mistral,
           model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
+          usage:    extract_usage_openai(data), **openai_tool_calls_entry(data)
         }
       end
 

data/lib/active_harness/providers/ollama.rb

@@ -13,20 +13,23 @@ module ActiveHarness
     #     use provider: :ollama, model: "llama3.2"
     #   end
     class Ollama < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         url     = "#{api_base}/v1/chat/completions"
         headers = { "Content-Type" => "application/json" }
         key     = api_key
         headers["Authorization"] = "Bearer #{key}" if key
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: url, headers: headers, body: body, stream: stream, provider: :ollama, model: model) if stream
+        return call_streaming(url: url, headers: headers, body: body, stream: stream, provider: :ollama, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :ollama, model: data["model"] || model, usage: extract_usage_openai(data) }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :ollama, model: data["model"] || model, usage: extract_usage_openai(data), **openai_tool_calls_entry(data) }
       end
 
       private

data/lib/active_harness/providers/ollama_cloud.rb

@@ -12,11 +12,14 @@ module ActiveHarness
     #     use provider: :ollama_cloud, model: "gpt-oss:120b"
     #   end
     class OllamaCloud < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.ollama_cloud_api_url, headers: headers, body: body, stream: stream, provider: :ollama_cloud, model: model) if stream
+        return call_streaming(url: config.ollama_cloud_api_url, headers: headers, body: body, stream: stream, provider: :ollama_cloud, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.ollama_cloud_api_url), headers: headers, body: body)
         data = parse!(raw)
@@ -26,7 +29,7 @@ module ActiveHarness
           content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :ollama_cloud,
           model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
+          usage:    extract_usage_openai(data), **openai_tool_calls_entry(data)
         }
       end
 

data/lib/active_harness/providers/openai.rb

@@ -3,21 +3,24 @@ require "uri"
 module ActiveHarness
   module Providers
     class OpenAI < Base
+      include ToolCalling
+
       # @param model    [String]
       # @param messages [Array<Hash>]  [{role:, content:}, ...]
       # @param temperature [Float]
       # @return [Hash]  { content:, provider:, model: }
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.openai_api_url, headers: headers, body: body, stream: stream, provider: :openai, model: model) if stream
+        return call_streaming(url: config.openai_api_url, headers: headers, body: body, stream: stream, provider: :openai, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.openai_api_url), headers: headers, body: body)
         data = parse!(raw)
         handle_error!(data)
 
-        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :openai, model: data["model"] || model, usage: extract_usage_openai(data) }
+        { content: data.dig("choices", 0, "message", "content").to_s.strip, provider: :openai, model: data["model"] || model, usage: extract_usage_openai(data), **openai_tool_calls_entry(data) }
       end
 
       private

data/lib/active_harness/providers/openrouter.rb

@@ -4,20 +4,23 @@ module ActiveHarness
   module Providers
     # OpenRouter — OpenAI-compatible API that proxies many models.
     class OpenRouter < Base
+      include ToolCalling
+
       # @param model    [String]
       # @param messages [Array<Hash>]  [{role:, content:}, ...]
       # @param temperature [Float]
       # @param stream   [Proc, nil]  if given, called with each token as it arrives
       # @return [Hash]  { content:, provider:, model: }
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = {
           "Content-Type"  => "application/json",
           "Authorization" => "Bearer #{api_key}",
           "HTTP-Referer"  => config.openrouter_http_referer
         }
-        body = { model: model, messages: messages, temperature: temperature }
+        body = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.openrouter_api_url, headers: headers, body: body, stream: stream, provider: :openrouter, model: model) if stream
+        return call_streaming(url: config.openrouter_api_url, headers: headers, body: body, stream: stream, provider: :openrouter, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.openrouter_api_url), headers: headers, body: body)
         data = parse!(raw)
@@ -27,7 +30,7 @@ module ActiveHarness
           content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :openrouter,
           model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
+          usage:    extract_usage_openai(data), **openai_tool_calls_entry(data)
         }
       end
 

data/lib/active_harness/providers/tool_calling.rb

@@ -0,0 +1,95 @@
+require "json"
+
+module ActiveHarness
+  module Providers
+    # Tool-calling support shared by OpenAI-compatible providers.
+    #
+    # ActiveHarness speaks to providers in a neutral shape:
+    #
+    #   tools:    [{ name: "os__ls", description: "...", parameters: { type: "object", ... } }]
+    #   messages: [{ role: :user, content: "..." },
+    #              { role: :assistant, content: "", tool_calls: [{ id:, name:, arguments: {} }] },
+    #              { role: :tool, tool_call_id: "...", name: "os__ls", content: "..." }]
+    #
+    # and receives tool calls back as [{ id:, name:, arguments: Hash|nil, raw_arguments: String }].
+    # This module maps that shape to and from the OpenAI wire format.
+    module ToolCalling
+      def supports_tools?
+        true
+      end
+
+      private
+
+      def tools?(tools)
+        !tools.nil? && !tools.empty?
+      end
+
+      def openai_tools(tools)
+        Array(tools).map do |t|
+          {
+            type:     "function",
+            function: { name: t[:name], description: t[:description].to_s, parameters: t[:parameters] }
+          }
+        end
+      end
+
+      def openai_messages(messages)
+        messages.map { |m| openai_message(m) }
+      end
+
+      def openai_message(message)
+        role  = (message[:role] || message["role"]).to_s
+        calls = message[:tool_calls] || message["tool_calls"]
+
+        if role == "assistant" && calls && !calls.empty?
+          content = message[:content] || message["content"]
+          {
+            role:       "assistant",
+            content:    content.to_s.empty? ? nil : content,
+            tool_calls: calls.map do |c|
+              {
+                id:       c[:id],
+                type:     "function",
+                function: { name: c[:name], arguments: JSON.generate(c[:arguments] || {}) }
+              }
+            end
+          }
+        elsif role == "tool"
+          {
+            role:         "tool",
+            tool_call_id: message[:tool_call_id] || message["tool_call_id"],
+            content:      (message[:content] || message["content"]).to_s
+          }
+        else
+          message
+        end
+      end
+
+      # { tool_calls: [...] } when the response contains tool calls, {} otherwise.
+      # Meant to be splatted into the provider's response hash.
+      def openai_tool_calls_entry(data)
+        raw = data.dig("choices", 0, "message", "tool_calls")
+        return {} if raw.nil? || raw.empty?
+
+        { tool_calls: raw.map { |c| parse_openai_tool_call(c) } }
+      end
+
+      def parse_openai_tool_call(call)
+        raw_args = call.dig("function", "arguments")
+        args =
+          case raw_args
+          when Hash   then raw_args
+          when String then raw_args.strip.empty? ? {} : (JSON.parse(raw_args) rescue nil)
+          else {}
+          end
+
+        {
+          id:            call["id"],
+          name:          call.dig("function", "name"),
+          arguments:     args.is_a?(Hash) ? args : nil,
+          raw_arguments: raw_args.is_a?(String) ? raw_args : raw_args.to_s
+        }
+      end
+    end
+  end
+end

data/lib/active_harness/providers/xai.rb

@@ -5,11 +5,14 @@ module ActiveHarness
     # xAI (Grok) — OpenAI-compatible API.
     # https://docs.x.ai/api
     class XAI < Base
-      def call(model:, messages:, temperature: 0.7, stream: nil)
+      include ToolCalling
+
+      def call(model:, messages:, temperature: 0.7, stream: nil, tools: nil)
         headers = { "Content-Type" => "application/json", "Authorization" => "Bearer #{api_key}" }
-        body    = { model: model, messages: messages, temperature: temperature }
+        body    = { model: model, messages: openai_messages(messages), temperature: temperature }
+        body[:tools] = openai_tools(tools) if tools?(tools)
 
-        return call_streaming(url: config.xai_api_url, headers: headers, body: body, stream: stream, provider: :xai, model: model) if stream
+        return call_streaming(url: config.xai_api_url, headers: headers, body: body, stream: stream, provider: :xai, model: model) if stream && !tools?(tools)
 
         raw  = post_json(URI(config.xai_api_url), headers: headers, body: body)
         data = parse!(raw)
@@ -19,7 +22,7 @@ module ActiveHarness
           content:  data.dig("choices", 0, "message", "content").to_s.strip,
           provider: :xai,
           model:    data["model"] || model,
-          usage:    extract_usage_openai(data)
+          usage:    extract_usage_openai(data), **openai_tool_calls_entry(data)
         }
       end
 

data/lib/active_harness/railtie.rb

@@ -1,6 +1,6 @@
 module ActiveHarness
   class Railtie < Rails::Railtie
-    APP_AI_DIRS = %w[requests prompts tribunals pipelines memory].freeze
+    APP_AI_DIRS = %w[concerns requests prompts tribunals pipelines memory agents tools goals].freeze
 
     initializer "active_harness.autoload_paths", before: :set_autoload_paths do |app|
       APP_AI_DIRS.each do |dir|

data/lib/active_harness/request/hooks.rb

@@ -70,7 +70,7 @@ module ActiveHarness
     def fire(event, *args)
       run_hook(event, *args)
       @stream&.call(:request, event, *args)
-    rescue IOError, ActionController::Live::ClientDisconnected
+    rescue ClientGone
     end
   end
 end

data/lib/active_harness/request/providers.rb

@@ -65,6 +65,12 @@ module ActiveHarness
       provider = resolve_provider(entry[:provider])
       messages = build_messages(system_prompt, @input)
       opts = { model: entry[:model], messages: messages }
+      if @tools && !@tools.empty?
+        unless provider.respond_to?(:supports_tools?) && provider.supports_tools?
+          raise Errors::InvalidRequestError, "Provider #{entry[:provider].inspect} does not support tool calling"
+        end
+        opts[:tools] = @tools
+      end
       opts[:temperature] = entry[:temperature] if entry[:temperature]
       opts[:stream]      = @token               if @token
       opts[:name]        = entry[:name]        if entry[:name]
@@ -138,6 +144,15 @@ module ActiveHarness
       # See ActiveHarness::Memory for examples.
       messages = []
       messages << { role: "system", content: system_prompt } if system_prompt
+
+      if @messages
+        # Conversation mode (used by Agent): the system prompt of the Request goes first,
+        # unless the conversation already carries its own system message.
+        convo = @messages.map { |m| m.dup }
+        messages.shift if messages.any? && convo.any? { |m| (m[:role] || m["role"]).to_s == "system" }
+        return messages + convo
+      end
+
       messages << { role: "user",   content: input }
       messages
     end