agent-harness 0.44.19 → 0.44.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6eb541ae57479b17bdf0a03cf773d1049d4d0335c7efea0ba8d45bf642717361
-  data.tar.gz: ca088c08d42344691354559cf56b2aac9cde4d320b1bbcaba842f8b9f566722f
+  metadata.gz: 79e4e172d70ecba9f4f3249a6d1ee93af4f47ba444991beea77f1a0d152cc0af
+  data.tar.gz: '0489867bae0853510e78ff6251aab2980048be0de24f10fdba9c8ef2b816f90f'
 SHA512:
-  metadata.gz: 52f5fc4c21a8c29cddeb484f27d2ec70ee7045406e0ef8cc7f19bbc855f8ce8af0c8a98f0ddd48c064c2acf0a7989e500cce2ca71c36945c187f36d9f2b8e411
-  data.tar.gz: d01a63b81d88011db1914122007046a2d272023fedcb2827a8ffae0aa9605618c4c3364dde449f9a56246ae19a4aceef5e6be06ac87e6892c58e3e93fb4bdfcb
+  metadata.gz: 6657b638390c5f3ae19c5100d33e78b8ed8b26292d90bfad5e649479c5e7e4b0619a6c20118c9a68d9fa1f216379d4c2d25f62cea82a4c82b61d858d09ddc309
+  data.tar.gz: c52577902c4a2852afcceda0f76da39e1f829a4a191051cd5978934955c577830b6ac4281d95d6b563bf3f8c2bf62732b9efe70a1636797b6af014b43b5596d6

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.44.19"
+  ".": "0.44.21"
 }

data/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ### Features
 
+* support reasoning-capable OpenAI function-tool chat through the Responses API, including opaque reasoning state across tool-result continuation, streaming tool IDs and arguments, usage, cancellation, classified errors, an explicit compatible-provider protocol contract, and a gated live smoke test ([#499](https://github.com/viamin/agent-harness/issues/499)).
 * verify RDR-072's published capability artifacts and migration limits, retain the application chat loop over normalized transport, and remove the private RubyLLM streaming-refusal patch in favor of an explicit non-streaming schema boundary ([#437](https://github.com/viamin/agent-harness/issues/437)).
 * expose normalized API chat transport and schema-constrained responses with preserved JSON text, locally validated parsed values, and explicit refusal, truncation, invalid JSON, schema mismatch, and unsupported-mode outcomes; this combined delivery supersedes the separate chat-transport work item ([#433](https://github.com/viamin/agent-harness/issues/433), [#434](https://github.com/viamin/agent-harness/issues/434)).
 * add runner model compatibility contract (`AgentHarness.model_compatibility`) with structured `ModelCompatibility::Result` outcomes. Codex exposes static facts for CLI-gated models (e.g. `gpt-5.5` requires Codex CLI `>= 0.116.0`), a baseline supported-model list, supported auth modes, and a `DEFAULT_COMPATIBLE_MODEL_ID` fallback so downstream orchestrators can validate tier/model assignments before scheduling agent runs ([#259](https://github.com/viamin/agent-harness/issues/259)).
@@ -11,6 +12,20 @@
 
 * close the RDR-072 upstream epic from #437's retained-scope evidence while keeping unpublished capabilities and downstream adoption behind their explicit release and integration gates ([#430](https://github.com/viamin/agent-harness/issues/430)).
 
+## [0.44.21](https://github.com/viamin/agent-harness/compare/agent-harness/v0.44.20...agent-harness/v0.44.21) (2026-10-21)
+
+
+### Bug Fixes
+
+* Support reasoning-capable OpenAI chat with function tools through Responses API ([#501](https://github.com/viamin/agent-harness/issues/501)) ([5976a89](https://github.com/viamin/agent-harness/commit/5976a89b2dacec48338eac8b2b45bc59976e4bd1))
+
+## [0.44.20](https://github.com/viamin/agent-harness/compare/agent-harness/v0.44.19...agent-harness/v0.44.20) (2026-10-19)
+
+
+### Bug Fixes
+
+* **deps-dev:** bump @oh-my-pi/pi-coding-agent from 18.8.6 to 18.11.2 in /vendor/pins/omp ([#489](https://github.com/viamin/agent-harness/issues/489)) ([7ea477e](https://github.com/viamin/agent-harness/commit/7ea477e57008a343563aba159ba6aad477337b5a))
+
 ## [0.44.19](https://github.com/viamin/agent-harness/compare/agent-harness/v0.44.18...agent-harness/v0.44.19) (2026-10-19)
 
 

data/README.md

@@ -104,6 +104,55 @@ agent-harness release containing this capability:
 The runtime dependency is Ruby 3.2 or newer and RubyLLM 2.x. No Rails database
 or RubyLLM persistence tables are required for this plain-Ruby operation.
 
+## Native API chat
+
+`AgentHarness::Api::ChatTransport` supports OpenAI's Responses API explicitly.
+Select `protocol: :responses` for reasoning-capable OpenAI models used with
+function tools; this preserves the model's reasoning behavior. Do not select
+Chat Completions and do not disable reasoning or remove tools as a workaround.
+OpenAI-compatible providers that only implement Chat Completions continue to
+use `provider: :openai`, their explicit `endpoint`, and
+`protocol: :chat_completions`; Agent Harness never probes or silently changes
+the selected protocol.
+
+```ruby
+candidate = {
+  provider: :openai,
+  model: "gpt-5.6-luna",
+  protocol: :responses,
+  authentication_mode: :api_key,
+  credentials: {api_key: ENV.fetch("OPENAI_API_KEY")}
+}
+
+result = AgentHarness::Api::ChatTransport.new.call(
+  request_id: SecureRandom.uuid,
+  operation: :chat,
+  candidates: [candidate],
+  messages: [{role: :user, content: "Look up order 42"}],
+  tools: [{
+    name: "lookup_order",
+    description: "Find an order",
+    input_schema: {type: "object", properties: {id: {type: "integer"}}, required: ["id"]}
+  }],
+  stream: true,
+  retry: {max_attempts: 1}
+)
+```
+
+The harness returns tool calls without executing them. For the next request,
+append the assistant message (including `tool_calls` and `provider_state`) and
+then a tool message whose `tool_call_id` is the returned stable harness ID.
+`provider_state` is opaque protocol continuation data: persist and return it
+unchanged, and never inspect or log it. The transport maps the stable ID back
+to the provider call ID and replays the encrypted Responses reasoning item.
+
+To run the credential-gated live tool-continuation smoke test:
+
+```bash
+AGENT_HARNESS_LIVE_OPENAI=1 OPENAI_API_KEY=... \
+  bundle exec rspec spec/live/openai_responses_reasoning_spec.rb
+```
+
 ## Configuration
 
 ### Ruby DSL

data/docs/provider-neutral-api-execution-contract.md

@@ -247,7 +247,10 @@ The input is an ordered array. Each message has a stable caller-owned `id`, one
 of `system`, `user`, `assistant`, or `tool` as its `role`, and an ordered
 `content` array. Content parts initially support `text`; unimplemented media
 parts produce an explicit unsupported outcome. Assistant messages MAY contain
-tool calls. Tool messages MUST reference exactly one `tool_call_id`.
+tool calls. A Responses assistant message that requests tools also carries the
+opaque `provider_state` returned by the preceding result. Consumers MUST
+persist and return that value unchanged and MUST NOT inspect or log it. Tool
+messages MUST reference exactly one `tool_call_id`.
 
 Provider-specific wire roles, system-message placement, and content block
 shapes stay behind the harness boundary. The harness MUST preserve ordering,
@@ -275,6 +278,9 @@ reference the stable ID. Redelivery or restoration MUST skip a tool call when a
 completed result for that ID exists.
 
 The transport never decides approval and never executes application tools.
+For stateless OpenAI Responses continuation, the harness uses `provider_state`
+to replay the provider's encrypted reasoning and function-call output items.
+The field is absent when the selected protocol does not require opaque state.
 
 ### Streaming
 

data/lib/agent_harness/api/chat_transport.rb

@@ -150,6 +150,7 @@ module AgentHarness
             content: schema_result[:content],
             parsed: schema_result[:parsed],
             tool_calls: normalize_tool_calls(adapter_result[:tool_calls]),
+            provider_state: adapter_result[:provider_state],
             finish_reason: adapter_result[:finish_reason],
             usage: aggregate_usage,
             error: schema_result[:error]

data/lib/agent_harness/api/ruby_llm_chat_adapter.rb

@@ -26,8 +26,8 @@ module AgentHarness
           provider_usage_reported = true if event[:type] == :usage_updated
           on_event&.call(event)
         end
-        emit_completed_tool_calls(response, &on_event) if stream
-        normalize_response(response)
+        emit_completed_tool_calls(response, &on_event) if stream && on_event
+        normalize_response(response, candidate)
       end
 
       def prepare(candidate:, messages:, tools:, max_output_tokens:, temperature:, timeout:, on_accounting: nil,
@@ -74,6 +74,66 @@ module AgentHarness
         end
       end
 
+      # Captures the opaque Responses output items that continue a turn.
+      # RubyLLM exposes the provider output only when it kept it: an
+      # unstreamed call parses the response body, and a streamed one keeps the
+      # output for namespaced calls and server tools. A streamed turn that used
+      # plain function calls leaves neither, so its replay items are rebuilt
+      # from the reasoning signature and tool calls the stream accumulator
+      # retained, in the same shape the Responses protocol itself replays.
+      class ResponsesOutput
+        def self.from(message)
+          new(message).items
+        end
+
+        def initialize(message)
+          @message = message
+        end
+
+        def items
+          retained_output || replay_items
+        end
+
+        private
+
+        def retained_output
+          [parsed_body_output, @message.raw_content].find { |output| output.is_a?(Array) && output.any? }
+        end
+
+        # A streamed response's raw is the Faraday response, whose body the
+        # adapter empties, so only an unstreamed body is a parsed Hash here.
+        def parsed_body_output
+          body = @message.raw&.body
+          body["output"] if body.is_a?(Hash)
+        end
+
+        def replay_items
+          [reasoning_item, message_item, *function_call_items].compact
+        end
+
+        def reasoning_item
+          thinking = @message.thinking
+          return unless thinking&.signature
+
+          summary = thinking.text.to_s.empty? ? [] : [{type: "summary_text", text: thinking.text}]
+          {"type" => "reasoning", "summary" => summary, "encrypted_content" => thinking.signature}
+        end
+
+        def message_item
+          content = @message.content.to_s
+          return if content.strip.empty?
+
+          {"role" => "assistant", "content" => [{"type" => "output_text", "text" => content}]}
+        end
+
+        def function_call_items
+          Array(@message.tool_calls&.values).map do |call|
+            {"type" => "function_call", "call_id" => call.id, "name" => call.name,
+             "arguments" => JSON.generate(call.arguments || {})}
+          end
+        end
+      end
+
       private
 
       def ruby_llm_protocol(candidate)
@@ -151,7 +211,7 @@ module AgentHarness
       end
 
       def configure_chat(chat, candidate, messages, tools, max_output_tokens, temperature, schema)
-        chat.messages = normalize_messages(messages)
+        chat.messages = normalize_messages(messages, candidate)
         chat.with_tools(tools.map { |tool| normalized_tool(tool) }) unless tools.empty?
         chat.with_headers(candidate[:headers] || {})
         chat.with_max_output_tokens(max_output_tokens) if max_output_tokens
@@ -185,17 +245,43 @@ module AgentHarness
         token.respond_to?(:cancelled?) ? token.cancelled? : token.call
       end
 
-      def normalize_messages(messages)
+      def normalize_messages(messages, candidate)
         stable_to_provider = tool_id_map(messages)
         messages.map do |message|
           role = message.fetch(:role).to_sym
           normalized = {role: role, content: text_content(message[:content])}
           normalized[:tool_calls] = normalize_input_tool_calls(message[:tool_calls]) if message[:tool_calls]
           normalized[:tool_call_id] = stable_to_provider.fetch(message[:tool_call_id], message[:tool_call_id]) if role == :tool
+          apply_provider_state(normalized, message[:provider_state], candidate) if role == :assistant
           normalized
         end
       end
 
+      def apply_provider_state(message, state, candidate)
+        return unless state
+
+        validate_provider_state(state, candidate)
+        message[:raw_content] = state[:output]
+      end
+
+      # Provider state crosses a caller-owned boundary, so anything the
+      # selected protocol cannot replay as an assistant turn is rejected here
+      # rather than sent: an empty item list would drop the message content and
+      # its tool calls from the request.
+      def validate_provider_state(state, candidate)
+        unless responses_protocol?(candidate) && state[:protocol]&.to_sym == :responses
+          raise UnsupportedOptionError, "provider state does not match the selected protocol"
+        end
+
+        return if state[:output].is_a?(Array) && state[:output].any?
+
+        raise UnsupportedOptionError, "provider state must carry at least one Responses output item"
+      end
+
+      def responses_protocol?(candidate)
+        candidate[:provider].to_s == "openai" && candidate[:protocol].to_s == "responses"
+      end
+
       def tool_id_map(messages)
         messages.each_with_object({}) do |message, ids|
           Array(message[:tool_calls]).each do |call|
@@ -301,17 +387,27 @@ module AgentHarness
         end
       end
 
-      def normalize_response(response)
+      def normalize_response(response, candidate)
         {
           content: response.content || "",
           model: response.model,
           finish_reason: response.finish_reason,
           usage: normalize_usage(response.tokens),
           tool_calls: Array(response.tool_calls&.values).map { |call| normalize_tool_call(call) },
+          provider_state: provider_state(response, candidate),
           refusal: refusal?(response)
         }
       end
 
+      # Only the Responses protocol carries opaque continuation state; other
+      # protocols replay a turn from the normalized messages alone.
+      def provider_state(response, candidate)
+        return unless responses_protocol?(candidate)
+
+        output = ResponsesOutput.from(response)
+        {protocol: :responses, output: output} if output.any?
+      end
+
       def refusal?(response)
         return true if response.finish_reason == :content_filter
         return false unless response.respond_to?(:raw)

data/lib/agent_harness/providers/omp.rb

@@ -12,7 +12,7 @@ module AgentHarness
     # CLI.
     class OhMyPi < Base
       CLI_PACKAGE = "@oh-my-pi/pi-coding-agent"
-      SUPPORTED_CLI_VERSION = "18.8.6"
+      SUPPORTED_CLI_VERSION = "18.11.2"
       SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new("= #{SUPPORTED_CLI_VERSION}").freeze
 
       # Bun runtime requirements. The omp entrypoint is

data/lib/agent_harness/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AgentHarness
-  VERSION = "0.44.19"
+  VERSION = "0.44.21"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.44.19
+  version: 0.44.21
 platform: ruby
 authors:
 - Bart Agapinan