smith-agents 0.12.4 → 0.12.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2c791c5165889ff1098cc5c92976b1affe2c3f82108815fda1c98fae56c0430
-  data.tar.gz: 5b7d1d9f41e2949c335d6dc8b26a7f69aff73c2edf4ee39e100760ca3c4f4145
+  metadata.gz: 97813bcba79ce652b05eb860da067e3c566b8ba3450344d66940c9f65d23a1dc
+  data.tar.gz: ea20e0a30b7517aab44a43b2668cb5e59fde6b98a829056e8e73ba585338f216
 SHA512:
-  metadata.gz: e76354065df47cf04703bc41cda18256df9f2118a9d714f046f3fe04c567256d969be828235b0a6da2ff0ee83fe8953ba8c381ed4209c4f49776cde1658ab5d0
-  data.tar.gz: 3e73cddd45cd37191712cc2ed4d5cdc1fe62dbe07a2de73b86bd626f43eda0ba74efcbf8b40fabbbc15db21e6517495567ac346c4339f3c9864e316894170d3f
+  metadata.gz: 37d47a1f6268dc96cd05ce69f4138998d1c5a9649bbb41921882b6ae93a8f5d030586c273f37231501c121dd43492e1a37034cefe88981a5f89138cbf1ccd128
+  data.tar.gz: 40eb2c1a4ac979411860e4971b4814e0c2cdaebc39f1a827e956f7fcb2a5ca33c3f34d18aad339edfa1460a8fce07188f505aa174a2e59233d735c50bab258d3

data/CHANGELOG.md

@@ -4,6 +4,48 @@ All notable changes to Smith are documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Smith is pre-1.0 and under active development; expect occasional contract tightening between minor versions until 1.0.
 
+## [0.12.6] - 2026-10-13
+
+### Fixed
+
+- An error of a streamed request is what the provider said it was
+  (`Smith::ProviderErrors`). RubyLLM builds a streamed request's error
+  response itself, guessing its status from the error event's type:
+  Anthropic's adapter says 500 unless overloaded, OpenAI's 400 unless a
+  server error or a rate limit. With 0.12.5 sending a streamed request
+  once, an Anthropic bad request, wrong key or unknown model looked like a
+  passing outage (fallbacks and retries instead of failing or moving to
+  another account), and an OpenAI wrong key, unknown model, regional refusal
+  or rate limit like a bad request (no fallback). Before, RubyLLM's retry
+  hid this by garbling the error into one of the response's real status.
+  Smith reads the type the provider gave in the body (Anthropic's
+  `error.type`, OpenAI's `error.code`, else its `error.type`) and, when it
+  names another status, raises what RubyLLM raises for that status, through
+  RubyLLM's own mapping (context length included), with the provider's
+  message and the response's headers, its cause the error RubyLLM raised.
+  An error the provider sent whole keeps its own status.
+
+## [0.12.5] - 2026-10-13
+
+### Fixed
+
+- A streamed step's requests are each sent once: its chat takes a copy of
+  the agent's config (its context, or RubyLLM's) with RubyLLM's HTTP retries
+  (`max_retries`) off, its model resolved again as RubyLLM resolves a chat
+  built with a context (the same id and provider, and the agent's own
+  `assume_model_exists`, so a model RubyLLM lists keeps its output limit and
+  thinking options). Retrying a stream read the next response's error into
+  the buffer the first had filled, so the provider's words were lost: a
+  refusal for want of credit reached Smith as a bare "Invalid request"
+  (`RubyLLM::BadRequestError`) and was never classified as
+  `RubyLLM::PaymentRequiredError`, and a spend-cap 429 as a plain rate limit.
+  A stream that failed part way was sent again, its text streamed twice.
+  Every provider failure of a streamed request, a transient one at connect
+  time included, now goes straight to the step's fallbacks and retries, so
+  a streamed step that should ride out an outage declares them. Calls that
+  do not stream, and requests OpenAI's Responses route sends whole, keep
+  RubyLLM's retries. The global config and the agent's are never changed.
+
 ## [0.12.4] - 2026-10-13
 
 ### Changed

data/README.md

@@ -30,7 +30,7 @@ What you get:
 
 ```ruby
 # Gemfile
-gem "smith-agents", "0.12.4", require: "smith"
+gem "smith-agents", "0.12.6", require: "smith"
 ```
 
 In a Rails app:

data/docs/AGENTS.md

@@ -155,7 +155,17 @@ reason and message id, with `mode: :stream`), and a replayed step streams again
 (unless a response memo kept its reply: then its sink gets the text at once).
 Graph inspection shows the stream, and runtime readiness reports a missing sink
 (`:stream_sink_missing`) and an agent whose calls go to the Responses API
-(`:stream_whole_replies`).
+(`:stream_whole_replies`). A streamed step's requests are each sent once:
+its chat takes a copy of the agent's config with RubyLLM's HTTP retries
+(`max_retries`) off and its model resolved again as RubyLLM resolves a chat
+built with a context (a model RubyLLM lists keeps its limits), since a
+retried stream loses the first response's error body (a refusal for want of
+credit would reach Smith as a bare "Invalid request") or streams its text
+again. Every provider failure of a streamed request, a transient one at
+connect time included, takes the step's fallbacks and retries directly, so
+declare them (`fallback_models`, `retry_on Smith::AgentError`) on a streamed
+step that should ride out an outage. A request OpenAI's Responses route sends
+whole keeps the retries.
 
 ## Batch mode
 

data/docs/ERRORS_AND_RETRIES.md

@@ -113,8 +113,18 @@ naming `RubyLLM::PaymentRequiredError` makes a step that meets it wait for
 credit instead of failing, even when a fallback then fails some other way.
 `Smith::Providers::Anthropic::Batches#submit` raises it too. Any other error
 stays as it is: a rate limit whose message mentions a quota (Gemini's) is a
-rate limit. RubyLLM's own HTTP retries (`max_retries`) may repeat a 429 or a
-streamed refusal before Smith sees it; a refused request is not charged.
+rate limit. RubyLLM's own HTTP retries (`max_retries`) may repeat a 429 of a
+call that does not stream before Smith sees it (a refused request is not
+charged); a streamed call is sent once, so its refusal reaches Smith whole.
+
+RubyLLM guesses the status of a streamed request's error from the error
+event's type (Anthropic's adapter says 500 unless overloaded, OpenAI's 400
+unless a server error or a rate limit). Smith takes it as what the provider
+said it was, from the type in the body (Anthropic's `error.type`, OpenAI's
+`error.code`, else its `error.type`), through RubyLLM's own mapping, with the
+response's headers: a streamed bad request fails, a wrong key is the
+account's, an unknown model moves to the next candidate, an overload is a
+passing outage. An error the provider sent whole keeps its own status.
 
 Name only errors that mean your own systems failed. A provider's own failure
 (`RubyLLM::Error`, or its HTTP client's `Faraday::Error`) is the provider's

data/lib/smith/agent/attempt_chat.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Smith
+  class Agent
+    module AttemptChat
+      private
+
+      # An attempt's chat. A streamed step's sends each request it streams
+      # over the wire once: RubyLLM's HTTP retries would send it again on an
+      # error, its error body already read into the first request's buffer
+      # (so a refusal for want of credit reaches Smith as a bare "Invalid
+      # request", never classified) or its text already streamed (the
+      # retry's text would join it). Smith's fallbacks and the step's
+      # retries take their place. Its chat takes a copy of the agent's config
+      # (its context, or RubyLLM's) without the retries, and resolves its
+      # model again as RubyLLM builds a chat with a context (the same id and
+      # provider, and the agent's own assume_model_exists, so a model RubyLLM
+      # knows keeps its limits), before any hold attaches to its provider. A
+      # request OpenAI's Responses route sends answers whole, unstreamed,
+      # and keeps the retries.
+      def attempt_chat(agent_class, model_reference)
+        chat = agent_class.chat(**model_reference.chat_options, **bridge_workflow_inputs(agent_class))
+        return chat unless @step_stream && streams_over_the_wire?(chat)
+
+        sent_once(chat, agent_class)
+      end
+
+      def sent_once(chat, agent_class)
+        model = chat.model
+        config = (agent_class.context&.config || RubyLLM.config).dup
+        config.max_retries = 0
+        chat.with_context(RubyLLM::Context.new(config))
+        chat.with_model(model.id, provider: model.provider,
+                                  assume_exists: agent_class.chat_kwargs.fetch(:assume_model_exists, false))
+      end
+
+      def streams_over_the_wire?(chat)
+        return false unless chat.respond_to?(:with_context) && chat.respond_to?(:with_model)
+
+        (chat.params[:openai_api_mode] || chat.params["openai_api_mode"]).to_s != "responses"
+      end
+    end
+  end
+end

data/lib/smith/agent/provider_call_timing.rb

@@ -123,9 +123,11 @@ module Smith
       # have their join target; the error then propagates unchanged. A
       # provider failure's own reported usage is accounted beside the
       # completed prefix, so its trace totals both.
-      # A billing refusal is recorded as the provider account's (BillingRefusals).
+      # An error is recorded as what the provider said it was
+      # (ProviderErrors), a billing refusal as the provider account's
+      # (BillingRefusals).
       def failed_provider_attempt(error, observed_reference, timer, facts, prefix_usages)
-        error = BillingRefusals.classified(error)
+        error = BillingRefusals.classified(ProviderErrors.classified(error))
         aborted = !provider_failure?(error)
         usages = aborted ? prefix_usages : [*prefix_usages, ProviderUsage.from_message(error)].compact
         attempt = ProviderAttempt.failure(

data/lib/smith/agent/provider_completion.rb

@@ -147,7 +147,7 @@ module Smith
       # rubocop:enable Metrics/AbcSize
 
       def prepared_attempt_chat(agent_class, prepared_input, model_reference, shape)
-        chat = agent_class.chat(**model_reference.chat_options, **bridge_workflow_inputs(agent_class))
+        chat = attempt_chat(agent_class, model_reference)
         add_prepared_input(chat, prepared_input, observed_model_reference(chat, fallback: model_reference).provider)
         continue_paused_loop(chat)
         shaped_chat(chat, model_reference, shape)

data/lib/smith/agent/provider_streaming.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "attempt_chat"
+
 module Smith
   class Agent
     # The provider calls of a streamed step (Smith::Streaming): before a
@@ -8,6 +10,8 @@ module Smith
     # reason is read from the stream (Providers::StreamFacts), as a
     # streamed reply keeps no raw body.
     module ProviderStreaming
+      include AttemptChat
+
       # Room for what a pause adds besides its messages (its retry, the
       # attempt's usage).
       PAUSE_MARGIN = 4096

data/lib/smith/provider_errors.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require "ruby_llm"
+
+module Smith
+  # An error of a streamed request as the provider said it was. RubyLLM
+  # builds a streamed request's error response itself, its status a guess
+  # from the error event's type (Anthropic's adapter says 500 unless
+  # overloaded, OpenAI's 400 unless a server error or a rate limit), so a
+  # wrong key, a model the provider does not serve or a refusal by region
+  # could look like a passing outage or a bad request. Smith reads the type
+  # the provider gave in the body (Anthropic's `error.type`, OpenAI's
+  # `error.code`, else its `error.type`) and, when it names another status,
+  # raises what RubyLLM raises for that status (its own mapping, context
+  # length included), with the provider's message, the response's headers
+  # kept, its cause the error RubyLLM raised. An error from a response the
+  # provider sent whole (its status the provider's own), or whose body
+  # names nothing it knows, stays as it is.
+  module ProviderErrors
+    STATUSES = {
+      "invalid_request_error" => 400,
+      "authentication_error" => 401,
+      "invalid_api_key" => 401,
+      "billing_error" => 402,
+      "permission_error" => 403,
+      "unsupported_country_region_territory" => 403,
+      "not_found_error" => 404,
+      "model_not_found" => 404,
+      "request_too_large" => 413,
+      "rate_limit_error" => 429,
+      "rate_limit_exceeded" => 429,
+      "timeout_error" => 504
+    }.freeze
+    private_constant :STATUSES
+
+    Response = Struct.new(:status, :body)
+    Said = Struct.new(:message) do
+      def parse_error(_response) = message
+    end
+    private_constant :Response, :Said
+
+    module_function
+
+    # The error as Smith takes it: a streamed request's error whose body
+    # names another status as the error RubyLLM raises for that status,
+    # anything else unchanged.
+    def classified(error)
+      return error unless error.is_a?(RubyLLM::Error) && streamed?(error)
+
+      said = said_of(body_of(error))
+      status = named_status(said)
+      return error if status.nil? || status == error.response.status.to_i
+
+      reclassify(error, with_status(error.response, status), said["message"])
+    end
+
+    def named_status(said) = said && (STATUSES[said["code"].to_s] || STATUSES[said["type"].to_s])
+
+    # A response RubyLLM built for a streamed request's error, never one the
+    # provider sent whole (a Faraday::Response).
+    def streamed?(error)
+      response = error.response
+      response.respond_to?(:status) && response.respond_to?(:body) && !response.is_a?(Faraday::Response)
+    end
+
+    def reclassify(error, response, message)
+      named = begin
+        RubyLLM::ErrorMiddleware.parse_error(provider: Said.new(message.is_a?(String) ? message : nil), response:)
+      rescue RubyLLM::Error => e
+        e
+      end
+      return error unless named.is_a?(RubyLLM::Error)
+
+      begin
+        raise named.class.new(response, named.message), cause: error
+      rescue RubyLLM::Error => e
+        e
+      end
+    end
+
+    def with_status(response, status)
+      response.respond_to?(:merge) ? response.merge(status:) : Response.new(status, response.body)
+    end
+
+    def said_of(body)
+      said = body.is_a?(Hash) ? body["error"] : nil
+      said.is_a?(Hash) ? said : nil
+    end
+
+    def body_of(error)
+      body = error.response.body
+      body.is_a?(String) ? JSON.parse(body) : body
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/smith/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Smith
-  VERSION = "0.12.4"
+  VERSION = "0.12.6"
   EXECUTION_SEMANTICS_VERSION = "7"
 end

data/lib/smith.rb

@@ -212,6 +212,7 @@ require_relative "smith/tool_failure_notification_failed"
 require_relative "smith/persistence_payload_conflict"
 require_relative "smith/exponential_backoff"
 require_relative "smith/interruptions"
+require_relative "smith/provider_errors"
 require_relative "smith/billing_refusals"
 
 # Event system (depends on Types)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smith-agents
 version: !ruby/object:Gem::Version
-  version: 0.12.4
+  version: 0.12.6
 platform: ruby
 authors:
 - Samuel Ralak
@@ -161,6 +161,7 @@ files:
 - lib/generators/smith/install/templates/workflow_state.rb.tt
 - lib/smith.rb
 - lib/smith/agent.rb
+- lib/smith/agent/attempt_chat.rb
 - lib/smith/agent/chat_construction.rb
 - lib/smith/agent/completion.rb
 - lib/smith/agent/completion_usage_recording.rb
@@ -297,6 +298,7 @@ files:
 - lib/smith/pricing.rb
 - lib/smith/pricing/catalog_validation.rb
 - lib/smith/pricing_configuration_error.rb
+- lib/smith/provider_errors.rb
 - lib/smith/provider_permanent_failure.rb
 - lib/smith/providers/anthropic/batches.rb
 - lib/smith/providers/batch_exchange.rb