agent-harness 0.43.0 → 0.44.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40d84099230c75237b23dca08330a46b739029768ce345b57cb232ba0e66a935
-  data.tar.gz: 47d36a8e160bcd29f9d50f6eabc1d0ded6795d6e05f2e45e93038d1987cd352c
+  metadata.gz: 4692f9efdcfe0158cba3afcff4b077fdcc67dc3c9f28198569be1e338add3b74
+  data.tar.gz: 3911441fb063e7b52ed74f3fad737d2ef9189bb122897a44e65c1ebf449fcaa8
 SHA512:
-  metadata.gz: f059d918fed14691fe444dba2e5e93aaeb2cdb185785a580b8a7341db8198616a0a830fd43461b4dfceffc9258f71ce25a8cbb69351747af46980ba0bd783757
-  data.tar.gz: 2f09db993da48a0ca0ed852eee9653898f474e7c61a6e0603dde3588457d226c8f51de71a8b322e7eba46b7e64203cc61a7607aa31764ed63188ef8b38f7c1e5
+  metadata.gz: b933a56fb9905d8e007903ff05245d29885b574bd78db06621d135da1e605f8141ad13e32c616614f0183b4757d88f314aa4750737755d73f587af89955ecf20
+  data.tar.gz: 43e7cc1a88f2984ad163b788dd56a798429a4cecd102e02c1c7b11dc5247bcbd56811cdf6aa2a2eaca87da59d0f679ecb27b64c99e3b7fa972d021962467501a

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.43.0"
+  ".": "0.44.1"
 }

data/CHANGELOG.md

@@ -2,10 +2,25 @@
 
 ### Features
 
+* 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)).
 * **auth:** add provider-owned PKCE code-exchange API for Claude OAuth (`AgentHarness::Authentication.exchange_code`). Takes an authorization code plus PKCE verifier (and `redirect_uri`/`client_id`), posts an `authorization_code` grant to the Claude token endpoint, and persists the resulting access/refresh tokens in the native `claudeAiOauth` shape. Adds `exchange_code_supported?` and a `code_exchange` key to `auth_capabilities` ([#266](https://github.com/viamin/agent-harness/issues/266)).
 
+## [0.44.1](https://github.com/viamin/agent-harness/compare/agent-harness/v0.44.0...agent-harness/v0.44.1) (2026-09-27)
+
+
+### Bug Fixes
+
+* **deps-dev:** bump @anthropic-ai/claude-code from 2.1.275 to 2.1.282 in /vendor/pins/claude ([#453](https://github.com/viamin/agent-harness/issues/453)) ([1848bbb](https://github.com/viamin/agent-harness/commit/1848bbb03653e0b64524fbffbcc939eb8542ad2f))
+
+## [0.44.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.43.0...agent-harness/v0.44.0) (2026-09-25)
+
+
+### Features
+
+* Evaluate resumable loop delegation and implement only if simpler (RDR-072) ([#448](https://github.com/viamin/agent-harness/issues/448)) ([02dedfb](https://github.com/viamin/agent-harness/commit/02dedfb08096631e59f326333df61feb57eba395))
+
 ## [0.43.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.42.0...agent-harness/v0.43.0) (2026-09-25)
 
 

data/README.md

@@ -806,8 +806,9 @@ Health checks run five steps per provider: registration, CLI availability, authe
 The proposed provider-neutral API execution boundary for embeddings, chat,
 structured output, usage, and optional persistence is documented in the
 [Provider-Neutral API Execution Contract](docs/provider-neutral-api-execution-contract.md).
-It is a docs-only design boundary; capability support requires the release
-evidence described there.
+That document records the shipped capability versions, migration examples,
+verified limits, and the evidence-backed decision to retain the application
+conversation loop over the normalized transport.
 
 ```bash
 # Install dependencies

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

@@ -9,9 +9,12 @@ usage, and optional conversation-persistence work.
 
 RDR-072's rollout guard was **docs-only** for the design phase. The normalized
 chat, attempt-accounting, schema, and embedding capabilities described below
-are now implemented. Other capabilities remain design contracts and each still needs
-its own failing-first contract tests, implementation, release evidence, and
-downstream adoption evidence before a caller enables it.
+are now implemented. The resumable-loop delegation evaluation is also
+complete: it closed with a **retained-loop outcome** (see "Resumable-loop
+delegation evaluation"), so no loop runtime was added. Other capabilities
+remain design contracts and each still needs its own failing-first contract
+tests, implementation, release evidence, and downstream adoption evidence
+before a caller enables it.
 
 Existing CLI and subscription behavior remains the default. Existing
 `TextTransport`, `OpenAICompatibleTransport`, `Conversation`, and `Response`
@@ -553,6 +556,7 @@ records.
 | Attempt usage | `usage.ruby_llm` per physical attempt | Useful facts, but the public payload has no stable attempt ID; harness must add one |
 | Plain Ruby resume | transcript can be reconstructed manually | No documented state export/import API; implement normalized export/import outside RubyLLM |
 | Rails resume | `acts_as_chat` transcript plus supporting records | Technically restart-safe at checkpoints; at-least-once side effects remain |
+| Loop controls | `Chat#step`, `#complete`, `#run_tools`, `#approve`, `#deny`, `Tool.requires_approval`, `#cancel` | Evaluated for delegation; retained-loop outcome (see below) |
 
 ### Optional Rails supporting tables
 
@@ -591,14 +595,96 @@ historical/pending-conversation tests. Reverting the gem is not a data rollback.
 2. **Use RubyLLM tool-call and usage tables selectively.** Potentially removes
    bookkeeping, but only after stable-attempt mapping, tenant-scoped access,
    audit, and migration tests are complete.
-3. **Delegate the full loop and all supporting tables.** Not recommended now.
-   It does not yet demonstrate reduced maintenance across both repositories and
-   increases migration and recovery coupling.
+3. **Delegate the full loop and all supporting tables.** Evaluated and
+   rejected for now: the delegation review below found maintenance increases
+   across both repositories. Retaining Paid's loop over the normalized
+   transport is the completed outcome and creates no future delegation
+   obligation.
 
 The state investigation is therefore positive for checkpoint-based Rails
 restoration and normalized plain Ruby reconstruction, and negative for
 exactly-once recovery or an off-the-shelf plain Ruby export/import mechanism.
 
+## Resumable-loop delegation evaluation
+
+RDR-072 permits delegating the chat loop only when behavior is preserved and
+maintenance decreases across both repositories, counting adapters,
+persistence, and recovery code. Retaining Paid's loop over the normalized
+transport is an acceptable completed outcome. This section records the
+evaluation against RubyLLM 2.0.0's public loop controls
+(`Chat#step`, `#complete`, `#run_tools`, `#complete?`, `#awaiting_approval?`,
+`#pending_approvals`, `#approve`, `#deny`, `#cancel`, and
+`Tool.requires_approval`) and its conclusion.
+
+### Verified behaviors
+
+`spec/ruby_llm_loop_delegation_evaluation_spec.rb` drives a real
+`RubyLLM::Chat` through the public API with stubbed Anthropic Messages
+responses and pins each fact with a contract test:
+
+| Required behavior | Result | Evidence |
+| --- | --- | --- |
+| Single-step execution | Verified | `#step` advances one move; `#complete?` flips only on a final answer |
+| Mixed read/write batches | Verified | Reads without approval execute; `requires_approval` writes stay pending (`#awaiting_approval?`) |
+| Multiple pending decisions | Verified | `#pending_approvals` lists every undecided write; `#approve`/`#deny` resolve them independently |
+| Denial | Verified | A denied call receives a structured denial result and the model continues |
+| Completion | Verified | `#complete?` reports the terminal state |
+| Cancellation | Verified | `#cancel` raises `CancelledError` at the next loop checkpoint, then clears |
+| Completed tool results preserved | Verified | `#run_tools` skips calls that already carry results, so a resumed round executes only the remainder |
+
+### Gaps that fail the delegation criteria
+
+| Criterion | Finding | Evidence |
+| --- | --- | --- |
+| Stable tool IDs | `ToolCall#id` is the provider wire id verbatim; no caller-stable identity is generated, so the contract's "provider_id is not a durable application identifier" rule needs a new mapping adapter | provider-id example |
+| Iteration limits | The loop has no bound: `#complete` steps until `#complete?` or `#awaiting_approval?`, and `tool_options` exposes only choice/calls/concurrency; bounding stays caller-owned | unbounded-iteration example |
+| Restart restoration without Rails | Decisions recorded with `#approve` live in per-chat in-memory state; a plain Ruby chat rebuilt from the same messages is awaiting approval again. Durable decisions require `acts_as_chat` (Active Record), which plain Ruby consumers must not require | reconstruction example |
+| Crash recovery | Same as above: checkpoint restoration is Rails-only, so a plain Ruby consumer re-implements decision and transcript persistence | reconstruction example |
+| Runner-isolated tool execution | `Tool#execute` runs in the calling process; the loop has no dispatch boundary. Paid executes tools in runner processes under caller-owned authorization and atomic claims, so delegation needs new dispatch adapters rather than removing code | in-process execution throughout |
+| Bounded, non-nested retries | Each loop `#generate` retries beneath the caller through Faraday middleware by default (`max_retries` defaults to three), violating the single-retry-owner and shared `max_attempts` budget rules; even with retries disabled, per-step budget/fallback sequencing is absent | hidden-retry example |
+| Attempt accounting | `usage.ruby_llm` payloads carry only operation/provider/model/status/tokens/cost — no attempt or request identity — so the harness `AttemptReport` ledger with stable `attempt_id` would be bypassed | usage-payload example |
+
+### Maintenance comparison
+
+Delegating the loop would remove Paid's turn-taking mechanics (step dispatch
+and approve/deny plumbing) while keeping Paid's authorization, atomic claims,
+runner dispatch, iteration bounds, workflow recovery, durable accounting, and
+cross-process cancellation. It would add, across the two repositories:
+
+- a provider-id to stable-id mapping adapter;
+- in-process `Tool#execute` to runner-process dispatch adapters;
+- a per-step retry, shared-budget, and fallback sequencing wrapper;
+- a caller-side iteration-limit driver replacing `#complete`;
+- plain Ruby decision/transcript persistence and export/import (Rails
+  `acts_as_chat` cannot be a dependency); and
+- attempt-accounting extraction with harness-side attempt identity.
+
+The additions exceed the removals, so maintenance increases across both
+repositories and the criteria fail.
+
+### Outcome
+
+**Retained loop.** Paid keeps its conversation loop over
+`Api::ChatTransport`; the harness keeps one normalized response per call
+with bounded retries, fallback, cancellation, and the attempt ledger. Tool
+execution, approval decisions, authorization, atomic claims, iteration
+limits, and crash recovery remain caller responsibilities under the existing
+ownership boundary. No loop runtime, adapter, persistence, or release was
+added, so there is no migration cost and no consumer activation step. This
+closes the evaluation without creating a future delegation obligation.
+
+Re-evaluate only if RubyLLM later documents a public, plain-Ruby-resumable
+loop with caller-stable tool identity, an external tool-dispatch boundary, a
+bounded `#complete`, and per-attempt accounting identity; the evaluation
+spec's examples are the tripwire that detects such changes on upgrade.
+
+### Communication
+
+The retained-loop outcome, the behavior-test evidence above, and the zero
+migration cost are the message for the Paid adoption and closeout tracking
+(viamin/paid#4014 and the parent viamin/agent-harness#430). No scope beyond
+the accepted RDR-072 alternatives is requested or implied.
+
 ## Current harness gaps and incremental delivery
 
 The current transports already normalize basic text, tool calls, token totals,
@@ -615,7 +701,8 @@ Ship capabilities independently in this order:
 3. normalized non-streaming and streaming chat transport;
 4. structured output for verified model/protocol combinations;
 5. plain Ruby state round trips; and
-6. optional Rails persistence evaluation, then loop evaluation.
+6. optional Rails persistence evaluation, then loop evaluation (closed with
+   the retained-loop outcome recorded above; no runtime change).
 
 Each implementation issue starts with failing contract tests for request-local
 credential isolation, custom endpoints/headers, unsupported outcomes,
@@ -625,40 +712,117 @@ types stay behind the harness boundary.
 
 ## Compatibility and release evidence
 
-### Attempt-accounting capability evidence
-
-- Release: pending the first published version containing issue #435; a Git
-  branch or tag alone is not downstream adoption evidence.
-- Scope: normalized chat through `Api::ChatTransport` for Anthropic Messages
-  and OpenAI Responses/Chat Completions (including compatible endpoints), with
-  request-local API-key authentication. It is stacked on the normalized chat
-  capability from #433.
-- Verification: the API contract specs cover request-local credentials,
-  endpoint/header isolation, error classification, bounded non-nested retry,
-  fallback, cancellation, partial usage, cache usage, repeated identity,
-  observer redaction, and JSON reload with preserved pricing. The full upstream
-  suite and lint run on the repository's supported Ruby environment.
-- Migration: no Rails tables or migrations are loaded or required. Paid and
-  agent-image consumer versions remain unverified and MUST NOT adopt this
-  capability until their integration suites record the exact released gem and
-  image versions.
-- Retained paths: CLI/subscription providers, legacy HTTP transports,
-  embeddings, and token trackers remain outside this ledger and require
-  separate migration issues.
-
-### Schema capability release evidence
-
-- Publication: unreleased; record the first installable version before
-  downstream adoption.
-- Verified scopes: `:schema` with Anthropic Messages, OpenAI Responses, and
-  OpenAI Chat Completions using API-key authentication, including compatible
-  endpoints that explicitly select Chat Completions.
-- Contract coverage: valid and required-field schemas, classified failures,
-  bounded retries, cancellation, refusal, truncation, malformed JSON, and
-  schema mismatch.
-- Retained paths: CLI and subscription execution remain on existing provider
-  interfaces. JSON-only mode and model-specific capability discovery are not
-  migrated.
+The following RubyGems releases are the first installable artifacts for each
+capability. Pin the capability's minimum version during migration; do not infer
+support from an issue, branch, or Git tag.
+
+| Capability | First installable version | Contract / delivery | Install check |
+| --- | ---: | ---: | --- |
+| Native embeddings | `0.40.0` | [#432](https://github.com/viamin/agent-harness/issues/432) / [#439](https://github.com/viamin/agent-harness/issues/439) | `gem install agent-harness -v 0.40.0` |
+| Normalized chat, tools, and streaming | `0.41.0` | [#434](https://github.com/viamin/agent-harness/issues/434) / [#441](https://github.com/viamin/agent-harness/issues/441) | `gem install agent-harness -v 0.41.0` |
+| Attempt usage and cost | `0.42.0` | [#435](https://github.com/viamin/agent-harness/issues/435) / [#443](https://github.com/viamin/agent-harness/issues/443) | `gem install agent-harness -v 0.42.0` |
+| Schema-constrained responses | `0.43.0` | [#436](https://github.com/viamin/agent-harness/issues/436) / [#442](https://github.com/viamin/agent-harness/issues/442) | `gem install agent-harness -v 0.43.0` |
+
+All four are plain-Ruby capabilities. They load without Rails or Active Record,
+create no tables, and require no migration. The runtime floor is Ruby 3.2 and
+RubyLLM 2.x. The four released versions above still pin `ruby_llm = 2.0.0` and
+prepend the private `AgentHarness::Api::RubyLlmResponsesStreamingRefusal`
+module into `RubyLLM::Protocols::Responses` process-wide. The prepend-free,
+public-API-only boundary (RubyLLM's public context, chat, message, tool, token
+and cost APIs only; no private method calls, no downstream monkey patch, and a
+loosened `ruby_llm ~> 2.0` dependency) lands in the first release published
+after [#437](https://github.com/viamin/agent-harness/issues/437); record that
+version here once it exists, because support must not be inferred from an
+issue, branch, or Git tag.
+
+### Migration examples and limits
+
+- **Embeddings (`>= 0.40.0`):** replace a downstream direct/proxy HTTP patch
+  with `AgentHarness.embed`, passing credentials, endpoint and headers on each
+  request. Remove the old retry layer after direct and proxy contract tests
+  pass. The operation is OpenAI-compatible, API-key only, has batch-total usage
+  only, and does not estimate missing tokens.
+- **Chat (`>= 0.41.0`):** construct `AgentHarness::Api::ChatTransport` and send
+  one normalized request for each model step. Keep the application loop and
+  append completed tool results to the next request. Verified protocols are
+  Anthropic Messages and OpenAI Responses/Chat Completions; custom compatible
+  endpoints must explicitly choose Chat Completions. Media, custom auth modes,
+  protocol probing, and request-local connect timeouts are unsupported.
+- **Attempt accounting (`>= 0.42.0`):** persist each entry in `result[:attempts]`
+  once by `attempt_id`, including failed and cancelled attempts. Do not add
+  aggregate `result[:usage]` again, convert unknown usage to zero, or wrap the
+  call in another provider-request retry loop. Paid still owns durable budget
+  accounting, workflow recovery and runner changes.
+- **Schema (`>= 0.43.0`):** set `operation: :schema`, `schema_mode:
+  :json_schema`, and provide a named JSON Schema. The harness preserves the
+  provider text and validates it locally; use a non-streaming schema request.
+  JSON-only mode, schema repair, and model-specific capability discovery are
+  also unsupported. Rejection of streamed schema requests
+  (`unsupported/structured_output_not_supported`) and removal of the private
+  RubyLLM streaming-refusal shim land in the first release published after
+  this change; the released `0.43.0` still contains that shim and executes
+  streamed schema requests.
+
+For every migration, run the consumer contract suite with tenant-specific
+credentials and headers, custom endpoints, auth and transient failures,
+cancellation, and the configured attempt bound. Inspect captured logs for
+credentials and request bodies. Record the exact Paid host and agent-image
+artifact versions before enabling that scope.
+
+### Verification and retained paths
+
+The [#431 contract audit](https://github.com/viamin/agent-harness/issues/431)
+is implemented by the upstream specs under `spec/agent_harness/embeddings_spec.rb`
+and `spec/agent_harness/api/`. Those specs cover request-local credential, endpoint and header
+isolation; reserved authentication headers; classified errors; bounded retries
+with RubyLLM retries disabled; cancellation; partial streams; stable attempt
+identity; usage/cost serialization; secret-free observer data; schema refusal,
+truncation and validation; and the public-only RubyLLM integration. The normal
+provider, command-executor, model-discovery and authentication suites remain the
+CLI/subscription regression coverage.
+
+CLI and subscription execution, legacy `TextTransport` and
+`OpenAICompatibleTransport`, provider selection, workflow recovery, and Paid's
+durable accounting are intentionally unchanged. No credential or authentication
+mode is selected implicitly. Rails persistence and conversation state round
+trips were not adopted.
+
+### Retained-loop closeout
+
+The completed boundary is normalized transport with Paid's loop retained.
+`Api::ChatTransport` performs one assistant response and never executes tools;
+Paid continues to own authorization, confirmation policy, tool side effects,
+transcript persistence, approval resumption and crash recovery. Delegating the
+loop would require new persistence, tenant/audit adapters and recovery glue in
+both repositories without removing those application responsibilities. There
+is therefore no demonstrated net maintenance reduction or safe migration of
+pending conversations. Under RDR-072 this evidence-backed retained-loop result
+is complete, not deferred delegation.
+
+Downstream adoption is tracked in
+[viamin/paid#4014](https://github.com/viamin/paid/issues/4014); preservation of
+Codex subscription discovery/recovery during dependency adoption is tracked in
+[viamin/paid#3995](https://github.com/viamin/paid/issues/3995). Close parent
+[agent-harness#430](https://github.com/viamin/agent-harness/issues/430) only
+after those consumers record their exact host/image artifacts and passing
+integration evidence for every scope they enable.
+
+### Loop-delegation evaluation evidence (retained loop)
+
+- Publication: none required. The evaluation changed documentation and tests
+  only; no runtime path, adapter, table, or public API was added or altered,
+  so every released agent-harness version already carries the outcome.
+- Verification: `spec/ruby_llm_loop_delegation_evaluation_spec.rb` exercises
+  only the public RubyLLM 2.0 API (pinned `ruby_llm = 2.0.0`) against stubbed
+  Anthropic Messages responses and runs with the upstream suite and lint on
+  the repository's supported Ruby environment. It records the verified loop
+  behaviors and the gaps that failed the delegation criteria.
+- Migration: none. Paid and other consumers keep their existing loops over
+  `Api::ChatTransport`; no consumer activation, feature flag, or rollout step
+  applies.
+- Retained responsibilities: documented in "Resumable-loop delegation
+  evaluation" above; loop ownership stays with Paid under RDR-072's accepted
+  alternatives.
 
 AgentHarness currently supports Ruby 3.2 and later and must remain usable as a
 plain Ruby gem. RubyLLM 2.0.0 itself supports Ruby 3.1.3 and later and adds
@@ -683,6 +847,6 @@ For every capability, release evidence must name:
 - retained paths and follow-up issues for combinations not migrated.
 
 Paid issue `viamin/paid#4014` should receive this compatibility result, the
-state-restoration conclusion, the stable-ID gap, and the per-capability release
-evidence. Downstream adoption cannot proceed from this design issue closing or
-from a Git tag alone.
+state-restoration conclusion, the stable-ID gap, the per-capability release
+evidence, and the retained-loop outcome of the delegation evaluation.
+Downstream adoption cannot proceed from this closeout or from a Git tag alone.

data/lib/agent_harness/api/chat_transport.rb

@@ -373,7 +373,9 @@ module AgentHarness
         end
 
         def schema_mode_supported?
-          !schema_operation? || !request[:schema_mode] || request[:schema_mode].to_sym == :json_schema
+          return true unless schema_operation?
+
+          request[:stream] != true && (!request[:schema_mode] || request[:schema_mode].to_sym == :json_schema)
         end
 
         def schema_payload

data/lib/agent_harness/api/ruby_llm_chat_adapter.rb

@@ -5,22 +5,6 @@ require "ruby_llm"
 
 module AgentHarness
   module Api
-    # RubyLLM 2.0.0 flattens Responses API refusal deltas into ordinary text
-    # chunks and offers no public access to their event type. The gemspec pins
-    # that exact release so this compatibility shim cannot silently outlive the
-    # private parser shape it targets. Remove it when RubyLLM exposes refusals.
-    module RubyLlmResponsesStreamingRefusal
-      module RefusalChunk; end
-
-      def build_chunk(data)
-        super.tap do |chunk|
-          chunk.extend(RefusalChunk) if data["type"] == "response.refusal.delta"
-        end
-      end
-    end
-
-    RubyLLM::Protocols::Responses.prepend(RubyLlmResponsesStreamingRefusal)
-
     # Translates the normalized public chat values to RubyLLM public objects.
     class RubyLlmChatAdapter
       class UnsupportedOptionError < StandardError; end
@@ -38,12 +22,12 @@ module AgentHarness
         provider_usage_reported = false
         chat = prepared_chat || prepare(candidate:, messages:, tools:, max_output_tokens:, temperature:, timeout:,
           schema:, on_accounting:, provider_usage: -> { provider_usage_reported })
-        response, streamed_refusal = generate(chat, stream, cancellation) do |event|
+        response = generate(chat, stream, cancellation) do |event|
           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, streamed_refusal: streamed_refusal)
+        normalize_response(response)
       end
 
       def prepare(candidate:, messages:, tools:, max_output_tokens:, temperature:, timeout:, on_accounting: nil,
@@ -61,7 +45,6 @@ module AgentHarness
       # duplicate cumulative reports are not re-emitted.
       class StreamState
         attr_accessor :input_tokens, :output_tokens
-        attr_reader :refusal
 
         def initialize
           @provider_id_by_key = {}
@@ -69,7 +52,6 @@ module AgentHarness
           @latest_provider_id = nil
           @input_tokens = nil
           @output_tokens = nil
-          @refusal = false
         end
 
         # Links a stream chunk key to its provider call id, returning true
@@ -90,10 +72,6 @@ module AgentHarness
           total = (input_tokens + output_tokens) if input_tokens && output_tokens
           {input_tokens: input_tokens, output_tokens: output_tokens, total_tokens: total}
         end
-
-        def observe(chunk)
-          @refusal ||= chunk.is_a?(RubyLlmResponsesStreamingRefusal::RefusalChunk)
-        end
       end
 
       private
@@ -182,10 +160,10 @@ module AgentHarness
       end
 
       def generate(chat, stream, cancellation)
-        return [generate_without_events(chat, cancellation), false] unless stream
+        return generate_without_events(chat, cancellation) unless stream
 
         state = StreamState.new
-        response = chat.generate do |chunk|
+        chat.generate do |chunk|
           if cancelled?(cancellation)
             chat.cancel
             raise RubyLLM::CancelledError
@@ -193,7 +171,6 @@ module AgentHarness
 
           stream_events(chunk, state).each { |event| yield event }
         end
-        [response, state.refusal]
       end
 
       def generate_without_events(chat, cancellation)
@@ -259,7 +236,6 @@ module AgentHarness
       end
 
       def stream_events(chunk, state)
-        state.observe(chunk)
         [text_event(chunk), *tool_call_events(chunk, state), usage_event(chunk, state)].compact
       end
 
@@ -325,14 +301,14 @@ module AgentHarness
         end
       end
 
-      def normalize_response(response, streamed_refusal: false)
+      def normalize_response(response)
         {
           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) },
-          refusal: streamed_refusal || refusal?(response)
+          refusal: refusal?(response)
         }
       end
 

data/lib/agent_harness/providers/anthropic.rb

@@ -27,7 +27,7 @@ module AgentHarness
 
       # Model name pattern for Anthropic Claude models
       MODEL_PATTERN = /^claude-[\d.-]+-(?:opus|sonnet|haiku)(?:-\d{8})?$/i
-      SUPPORTED_CLI_VERSION = "2.1.275"
+      SUPPORTED_CLI_VERSION = "2.1.282"
       SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 2.2.0").freeze
 
       # Matches semver (e.g. "2.1.92"), optional pre-release (e.g. "2.1.92-beta.1"),

data/lib/agent_harness/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.43.0
+  version: 0.44.1
 platform: ruby
 authors:
 - Bart Agapinan
@@ -47,16 +47,16 @@ dependencies:
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement