fast-completions 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b689b98f53f49ee1e7dcf541b2339f24683d34c6b8331994764ddffc0bdb86df
+  data.tar.gz: 815c13df95de3782a8dfd8303d3ad50173fd9c0d5c8795fa8cdd7fc9173df8c6
+SHA512:
+  metadata.gz: 5025050d712a676ac2bb5972506260cc63fa4aaff9ca47d20409e18a9ea756b0096deeea9a5168729d5f3757bf03820a88c680107e718d097946b52b0c3ae9dc
+  data.tar.gz: 4715c20690b34fc1d569a9b41ff9f291f3c110d32ed66daa9945989f54b18f53de09b265f6d7c1c11815b0f95201327a3627339968ebe2b0b0f37fbc89468317

data/CHANGELOG.md

@@ -0,0 +1,51 @@
+# Changelog
+
+Notable changes to the fast-completions gem. The format is prose-first,
+one section per released version, newest first.
+
+## 0.2.0 (2026-10-15)
+
+- Tolerant inbound stream (I61): a malformed SSE chunk no longer kills
+  the turn. The parser rejoins a data payload cut across lines by a raw
+  newline (the z.ai coalesced-delta malformation observed 2026-10-15),
+  the chunk seam repairs raw control characters inside strings (pi
+  `parseJsonWithRepair` semantics) and re-parses, and a chunk still
+  unparseable after rejoin and repair is dropped and counted
+  (`Client#dropped_chunks`) while the stream continues to its natural
+  terminal. `StreamError` no longer originates from chunk parsing; the
+  missing-finish terminal discipline (§10.5) is unchanged. Healthy
+  wires are byte-unaffected — the malformed shapes do not occur on
+  them.
+
+## 0.1.0
+
+- Initial release. `Fast::Completions` is a standalone, fiber-native
+  client for the OpenAI-compatible chat-completions wire.
+- The request/stream codec is byte-faithful to pi's wire behavior
+  (pi `packages/ai/src/api/openai-completions.ts` is the cited oracle
+  throughout the source). Codec arms: the plain OpenAI arm (default),
+  the zai arm, and the deepseek arm.
+- Dialects are data: a closed 13-key declaration vocabulary via
+  `Fast::Completions.dialect(:name) { ... }`, with the well-known
+  `:zai`, `:deepseek`, and `:fireworks` declarations shipped. No model
+  catalog, no pricing, no provider registry, no base-URL constants.
+- `Client` holds one persistent `Async::HTTP::Client` and runs inside
+  the caller's reactor: TTFB deadline + inactivity read-timeout, task
+  cancellation that aborts the request and discards the connection, and
+  the frozen error taxonomy (ApiError tree, TimeoutError,
+  ConnectionError, CancelledError).
+- `Chat` runs the agent turn: build → stream → yield events → execute
+  the tool batch CONCURRENTLY (one reactor task per call, children of
+  the step task) with results appended in call order, per-call failure
+  isolation (a raised error becomes that call's error result while
+  siblings complete), and the batch cancel discipline (a cancel aborts
+  the in-flight calls and surfaces `CancelledError` with no partial
+  results) — cancellation checkpoints and before/after hooks keyed by
+  tool-call id.
+- Replay normalization ports pi's cross-model thinking rules: same-model
+  signature replay (`reasoning` / `reasoning_content` / `reasoning_text`),
+  `reasoning_details` array replay, cross-model folding to text,
+  synthetic results for orphaned tool calls, deepseek's
+  `reasoning_content: ""`.
+- Parity harness: the byte fixtures (lane `harness`) pin the wire
+  against pi's recorded request bodies.

data/README.md

@@ -0,0 +1,132 @@
+# fast-completions
+
+`Fast::Completions` is a fast & focused HTTP client for OpenAI-compatible chat
+completions APIs. It speaks `POST {base}/chat/completions` and supports SSE
+streaming. It's implemented on top of [socketry/async-http] and won't block
+your reactor.
+
+## Fast & Focused
+
+This gem is laser focused on **just the chat completions API**
+
+It does:
+
+* Streaming chat completions
+* Tool calling ([see the tool docs])
+* Pre-made & Custom "Dialects" (common API variations) ([see the dialect docs])
+
+There are also a bunch of things `Fast::Completions` _does not_ do:
+
+* No model catalog
+* No other API shapes 
+* No universal translation
+* No synchronous requests (streaming only)
+* No images over the wire
+
+## Dialects
+
+Various providers/models make slight deviations from the "official" API. To
+support a wide variety of shapes, we have a concept of "Dialects." The default
+dialect is `:openai`, and we also ship `:zai`, `:deepseek`, and `:fireworks`.
+
+Custom dialects can also be declared at runtime. See the [Dialect Docs] for
+more info.
+
+## Installation
+
+```ruby
+gem "fast-completions"
+```
+
+The only runtime dependency is `async-http`.
+
+## Quickstart
+
+```ruby
+require "fast/completions"
+
+class ReadFile < Fast::Completions::Tool
+  description "Read file contents."
+  parameters do
+    {"type" => "object", "required" => ["path"],
+     "properties" => {"path" => {"type" => "string"}}}
+  end
+
+  def execute(path:)
+    File.read(path)
+  end
+end
+
+model = Fast::Completions::Model.new(
+  id: "my-model",
+  reasoning: true,
+  context_window: 128_000,
+  max_tokens: 4096,
+)
+
+client = Fast::Completions::Client.new(
+  base_url: "https://api.example.com/v1",
+  api_key: ENV["API_KEY"],
+)
+
+Async do |task| # fiber-native!
+  chat = Fast::Completions::Chat.new(client: client, model: model)
+  chat.with_instructions("You are a helpful assistant.")
+      .with_tools(ReadFile)
+
+  answer = chat.step do |event|
+    puts event.delta if event.type == :text_delta
+  end
+  puts answer.to_h.inspect
+end
+```
+
+## Dialects as data
+
+A dialect is a declaration. The vocabulary is closed (13 keys); unknown
+keys or values raise `ArgumentError` at declaration time — fail loud,
+never silently mistranslate. `:zai`, `:deepseek`, and `:fireworks` ship
+as declarations:
+
+```ruby
+Fast::Completions.dialect(:zai) do
+  thinking_format :zai
+  zai_tool_stream true
+  max_tokens_field "max_tokens"
+  supports_developer_role false
+  supports_reasoning_effort true
+  supports_store false
+end
+
+model = Fast::Completions::Model.new(..., dialect: :zai)
+Fast::Completions.dialect(:zai)         # lookup (KeyError if undeclared)
+Fast::Completions.dialects              # the frozen name→Dialect hash
+Fast::Completions.dialect(:acme) { max_tokens_field "max_tokens" } # declare your own
+```
+
+Re-declaring a name overrides — last declaration wins.
+
+## Error taxonomy
+
+The error table moved to [the error docs](docs/reference/errors.md) —
+every class with the status mapping, the timeout and connection families,
+and why `CancelledError` stands outside `Error`.
+
+## Parity
+
+The request/stream codec is byte-faithful to pi's wire: a fixture
+harness (recorded pi request bodies, SHA256-pinned) drives every codec
+arm through the gem and asserts BYTE equality. See
+`spec/fixtures/wire/` and `wire_parity_spec.rb`.
+
+## Fiber-native
+
+One persistent `Async::HTTP::Client` per `Fast::Completions::Client`;
+requests run inside the caller's reactor — the gem never creates its
+own. Cancellation (`Async::Cancel` / `Chat#cancel`) aborts the
+in-flight request, discards the connection, and raises
+`CancelledError` with no phantom terminal event.
+[see the tool docs]: docs/reference/tools.md
+[see the dialect docs]: docs/reference/dialects.md
+[Dialect Docs]: docs/reference/dialects.md
+[socketry/async-http]: https://github.com/socketry/async-http

data/lib/fast/completions/cancellation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "async"
+
+module Fast
+  module Completions
+    # Cancellation checkpoints (Specification §11, D8): a no-op outside a
+    # reactor; inside one it raises CancelledError when the current
+    # Async::Task has been cancelled. Chat calls it before each tool
+    # execution and at stream start.
+    module Cancellation
+      module_function
+
+      def check
+        task = Async::Task.current rescue nil
+        return unless task&.cancelled?
+
+        raise CancelledError, "current task cancelled"
+      end
+    end
+  end
+end

data/lib/fast/completions/chat.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Fast
+  module Completions
+    # The agent turn (Specification §12): build → stream → yield events →
+    # on :tool_use execute the tool batch CONCURRENTLY (pi's
+    # executeToolCallsParallel shape, tart I52's fiber mechanics) — a
+    # serial before-phase, one reactor child per executable call, results
+    # appended IN CALL ORDER — and return the final assistant Message.
+    # Hooks dispatch IN REGISTRATION ORDER; attribution is BY tool_call
+    # id — no Thread/fiber-local pairing anywhere (the I49 discipline).
+    class Chat
+      def initialize(client:, model:)
+        @client = client
+        @model = model
+        @instructions = nil
+        @messages = []
+        @tools = []
+        @thinking_level = nil
+        @max_output_tokens = nil
+        @before_tool_hooks = []
+        @after_tool_hooks = []
+        @cancelled = false
+        @tool_batch_pending = false
+        @in_flight = nil
+      end
+
+      # Chainable history configuration. with_instructions replaces (may
+      # be called once — later call replaces, §3).
+      def with_instructions(text)
+        @instructions = text
+        self
+      end
+
+      # Additive; Tool classes or instances.
+      def with_tools(*tools)
+        @tools.concat(tools.map { |tool| tool.is_a?(Class) ? tool.new : tool })
+        self
+      end
+
+      # The gem never mutates a consumer message (§12).
+      def add_message(message)
+        @messages << message
+        self
+      end
+
+      def messages
+        @messages.dup
+      end
+
+      # The ladder + nil (nil = off-equivalent: no effort); clamped at
+      # request build (§9.3).
+      def thinking_level=(level)
+        @thinking_level = level
+      end
+
+      def with_thinking_level(level)
+        @thinking_level = level
+        self
+      end
+
+      def with_max_output_tokens(tokens)
+        @max_output_tokens = tokens
+        self
+      end
+
+      # Multiple blocks register; dispatch in registration order (§12).
+      def before_tool_call(&block)
+        @before_tool_hooks << block
+        self
+      end
+
+      def after_tool_result(&block)
+        @after_tool_hooks << block
+        self
+      end
+
+      # True when the last turn ended with no pending tool batch (§12).
+      def complete?
+        !@tool_batch_pending
+      end
+
+      # Cancel the in-flight turn (stream or tool batch): latch +
+      # Async::Cancel into the task running #step. The turn aborts,
+      # CancelledError surfaces, and NO phantom terminal event is emitted
+      # (AC3/D8). Cancelling from the step task ITSELF (inside a HOOK
+      # execution — hooks run on the calling fiber) sets the latch only —
+      # a self-cancelled async task would swallow the unwinding; the
+      # checkpoints below honor the latch instead. A tool execution runs
+      # on a batch child, so a cancel from inside a tool task-cancels the
+      # step task: async stops the sibling children and the join
+      # re-raises (D5).
+      def cancel
+        @cancelled = true
+        current = (Async::Task.current rescue nil)
+        @in_flight&.cancel unless current&.equal?(@in_flight)
+        nil
+      end
+
+      # One assistant turn + tool execution (§12). Returns the final
+      # assistant Message.
+      def step(&block)
+        raise CancelledError, "chat cancelled" if @cancelled
+        Cancellation.check # D8 checkpoint at stream start
+        @in_flight = Async::Task.current
+        reason = nil
+        final = @client.stream(
+          model: @model, messages: @messages, instructions: @instructions,
+          tools: @tools, thinking: @thinking_level, max_tokens: @max_output_tokens,
+        ) do |event|
+          reason = event.reason if event.type == :done
+          block&.call(event)
+        end
+
+        add_message(final) # the Chat's own output (stamped by the accumulator, §12)
+        if reason == :tool_use
+          @tool_batch_pending = true
+          run_tool_batch(final)
+        else
+          @tool_batch_pending = false
+        end
+        # @in_flight covers the WHOLE turn — stream AND batch: the batch's
+        # children hang off this task, so a cancel landing during the
+        # batch (sibling-called or tool-called) reaches them via async's
+        # stop-children semantics and re-raises from the join (D5).
+        @in_flight = nil
+        final
+      rescue Async::Cancel
+        # A cancel landing between awaits (inside hook execution —
+        # async raises Async::Cancel synchronously on self-cancel):
+        # surface the gem's CancelledError (D8).
+        raise CancelledError, "chat cancelled"
+      end
+
+      private
+
+      # Two-phase batch executor (§1.1 — pi executeToolCallsParallel's
+      # shape). PHASE A, serial on the calling fiber per tool_call block
+      # IN CALL ORDER: the D8 checkpoints (latch + Cancellation.check),
+      # the before hooks (registration order), then executability
+      # resolution — an unknown tool finalizes INLINE with the exact
+      # result bytes, NO child task (the immediate arm; before hooks fire
+      # for it too — gem continuity over pi's look-up-first). PHASE B:
+      # ONE reactor child per executable call (children of the step task
+      # — the Sync-inline reactor discipline, tart I52's shape). Results
+      # collect INDEX-KEYED (call position) and append IN CALL ORDER
+      # after the join — history bytes identical to the serial executor's
+      # for every batch (wire-neutral by construction, D7). The join
+      # re-raises immediately on cancel — never waits out natural
+      # completion — so an aborted batch appends NOTHING and fires NO
+      # after hooks (no phantom terminals, D5).
+      def run_tool_batch(final)
+        results = Array.new(final.content.size)
+        executable = [] # ordered specs: [block index, tool_call, tool]
+
+        final.content.each_with_index do |block, index|
+          next unless block.is_a?(Hash) && block[:type] == :tool_call
+
+          # D8 checkpoint: the async task AND the cancel latch (a cancel
+          # from inside a hook cannot task-cancel itself, §12).
+          raise CancelledError, "chat cancelled" if @cancelled
+
+          tool_call = {id: block[:id], name: block[:name], arguments: block[:arguments]}
+          Cancellation.check # D8: checkpoint before EACH call's hooks
+          @before_tool_hooks.each { |hook| hook.call(tool_call) }
+          tool = @tools.find { |candidate| candidate.name == tool_call[:name] }
+          unless tool
+            # Immediate arm (D3): the unknown-tool outcome, verbatim.
+            results[index] = Message.tool_result(
+              tool_call_id: tool_call[:id], tool_name: tool_call[:name],
+              content: "no such tool: #{tool_call[:name]}", is_error: true)
+            next
+          end
+          executable << [index, tool_call, tool]
+        end
+
+        parent = Async::Task.current
+        children = executable.map do |index, tool_call, tool|
+          parent.async { run_tool_child(tool_call, tool, index, results) }
+        end
+        begin
+          children.map(&:wait) # the join: re-raises immediately on cancel
+        ensure
+          # The join surfaces WITHOUT waiting out natural completion — but
+          # the children would outlive it: #step's ladder converts the
+          # join's Async::Cancel into CancelledError (a StandardError), so
+          # async's own stop-children transition never runs and the
+          # reactor reparents still-running children. Cancel them HERE:
+          # no after hooks, no dangling results for aborted calls (D5 —
+          # the serial executor's raise-aborts-the-batch semantics). A
+          # no-op for children that already finished.
+          children.each(&:cancel)
+        end
+
+        results.each { |result| add_message(result) if result } # CALL ORDER (D7)
+      end
+
+      # ONE batch child (Phase B): the opening D8 checkpoint (a cancel
+      # that landed during Phase A or a sibling's execution kills THIS
+      # child here — its tool never runs), execute with failure
+      # isolation, after hooks INSIDE the child as the call completes
+      # (keyed by tool_call id through this closure — never
+      # completion-shared state), INDEX-keyed collection.
+      def run_tool_child(tool_call, tool, index, results)
+        raise CancelledError, "chat cancelled" if @cancelled
+        Cancellation.check
+        result = execute_tool_result(tool_call, tool)
+        @after_tool_hooks.each { |hook| hook.call(tool_call, result) }
+        results[index] = result
+      end
+
+      # §11 outcome + D4 failure isolation: a StandardError from the
+      # tool's own execution becomes THIS call's error result (siblings
+      # unaffected, the join completes — pi executePreparedToolCall);
+      # CancelledError re-raises (never a result); Async::Cancel passes
+      # through (< Exception, not caught here). An ArgumentError
+      # re-raises too: Ruby raises it at the DISPATCH boundary — the
+      # tool's execute signature cannot accept the provider's arguments
+      # (the tool body never ran) — a tool-declaration defect with no pi
+      # analog (JS dispatch ignores arity); today's raise-through
+      # behavior is kept for it.
+      def execute_tool_result(tool_call, tool)
+        Message.tool_result(
+          tool_call_id: tool_call[:id], tool_name: tool_call[:name],
+          **execute_tool_call(tool_call, tool))
+      rescue CancelledError
+        raise
+      rescue ArgumentError
+        raise
+      rescue StandardError => e
+        Message.tool_result(
+          tool_call_id: tool_call[:id], tool_name: tool_call[:name],
+          content: e.message.to_s, is_error: true)
+      end
+
+      # §11: String → content; Hash → JSON.generate; {error:} → is_error.
+      # The block's arguments stay string-keyed (provider JSON bytes); the
+      # execute splash symbolizes without mutating the history block.
+      def execute_tool_call(tool_call, tool)
+        outcome = tool.execute(**symbolize_keys(tool_call[:arguments]))
+        if outcome.is_a?(Hash) && outcome.keys == [:error]
+          {content: outcome[:error].to_s, is_error: true}
+        elsif outcome.is_a?(Hash)
+          {content: JSON.generate(outcome), is_error: false}
+        else
+          {content: outcome.to_s, is_error: false}
+        end
+      end
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) { |(k, v), out| out[k.to_sym] = v }
+      end
+    end
+  end
+end

data/lib/fast/completions/client.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "json"
+require "async"
+require "async/http"
+
+module Fast
+  module Completions
+    # ONE persistent Async::HTTP::Client per instance, fiber-native: every
+    # request runs INSIDE the caller's reactor — the client never creates
+    # its own (§6).
+    class Client
+      DEFAULT_TIMEOUT = 30
+
+      # TTFB deadline + inactivity read-timeout watchdog (D5/OQ-1): one
+      # value serves both. A fire cancels the waiting task; `fired` tells
+      # the cancel apart from a user's (D8).
+      class Watchdog
+        def initialize(task, seconds)
+          @task = task
+          @seconds = seconds
+          @timer = nil
+          @fired = false
+        end
+
+        attr_reader :fired
+
+        # (Re)arm: TTFB deadline before the POST, re-armed as the
+        # inactivity read-timeout after every body chunk.
+        def arm
+          stop
+          @timer = Async do
+            sleep @seconds
+            @fired = true
+            @task.cancel
+          end
+        end
+
+        def stop
+          @timer&.stop
+          @timer = nil
+        end
+      end
+
+      NETWORK_ERRORS = [
+        Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE, Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH, Errno::ETIMEDOUT, EOFError, IOError, SocketError,
+      ].freeze
+
+      attr_reader :timeout, :dropped_chunks
+
+      def initialize(base_url:, api_key:, timeout: DEFAULT_TIMEOUT)
+        @endpoint = Async::HTTP::Endpoint.parse(base_url)
+        @api_key = api_key
+        @timeout = timeout
+        @client = Async::HTTP::Client.new(@endpoint)
+        @path = @endpoint.path.chomp("/") + "/chat/completions"
+      end
+
+      def close
+        @client.close
+        nil
+      end
+
+      # POST {base}/chat/completions, stream the SSE reply, yield every
+      # Event to the block, return the final assistant Message (the
+      # accumulator itself — §3). Runs inside the caller's task.
+      def stream(model:, messages:, instructions: nil, tools: [], thinking: nil,
+        max_tokens: nil, temperature: nil, session_id: nil, &block)
+        request = Protocol.build_request(
+          model: model, messages: messages, instructions: instructions,
+          tools: tools, thinking: thinking, max_tokens: max_tokens,
+          temperature: temperature,
+        )
+        headers = default_headers.merge(session_headers(model.dialect, session_id))
+        accumulator = Protocol::StreamAccumulator.new(model, model.dialect)
+
+        watchdog = Watchdog.new(Async::Task.current, @timeout)
+        begin
+          watchdog.arm
+          response = @client.post(@path, headers: headers, body: JSON.generate(request))
+          begin
+            raise_api_error(response) unless (200...300).cover?(response.status)
+            yield accumulator.start_event if block # :start precedes every block event (§10.6)
+            feed_stream(response, accumulator, watchdog, &block)
+          ensure
+            # Complete bodies return the connection to the pool; an aborted
+            # read (cancel/timeout) discards it — a cancelled connection is
+            # never reused (AC3/D8).
+            begin
+              response.finish
+            rescue StandardError, Async::Cancel
+              nil
+            end
+          end
+        rescue Async::Cancel
+          watchdog.fired ? raise(TimeoutError, "no data within #{@timeout}s") : raise(CancelledError, "stream cancelled")
+        rescue *NETWORK_ERRORS => e
+          raise ConnectionError, "#{e.class}: #{e.message}"
+        ensure
+          watchdog.stop
+        end
+        raise TimeoutError, "no data within #{@timeout}s" if watchdog.fired
+
+        deliver_terminal(accumulator, &block)
+      end
+
+      private
+
+      def default_headers
+        {
+          "authorization" => "Bearer #{@api_key}",
+          "content-type" => "application/json",
+          "accept" => "application/json",
+        }
+      end
+
+      # Session-affinity headers per dialect when a session id is supplied
+      # (§6; pi openai-completions.ts :776-789, compat-schema.ts :4-9).
+      def session_headers(dialect, session_id)
+        return {} unless dialect.send_session_affinity_headers && session_id
+
+        case dialect.session_affinity_format
+        when :openrouter
+          {"x-session-id" => session_id}
+        when :openai_nosession
+          {"x-client-request-id" => session_id, "x-session-affinity" => session_id}
+        else # :openai
+          {"session_id" => session_id, "x-client-request-id" => session_id, "x-session-affinity" => session_id}
+        end
+      end
+
+      def feed_stream(response, accumulator, watchdog, &block)
+        parser = SSE.new
+        @dropped_chunks = 0
+        response.body.each do |chunk|
+          watchdog.arm # re-arm the inactivity read-timeout per chunk (D5)
+          parser.push(chunk).each do |item|
+            next if item == SSE::DONE # terminal token; no payload
+
+            json = parse_chunk(item)
+            next if json.nil? # dropped (I61): counted, the stream continues
+
+            events = accumulator.consume(json)
+            events.each { |event| yield event } if block
+          end
+        end
+      end
+
+      # The chunk seam (I61): parse, on failure ONE repair pass (pi
+      # parseJsonWithRepair — raw control characters inside strings
+      # escaped) and re-parse. StreamError no longer originates from
+      # chunk parsing; §10.5's missing-finish path still covers a dropped
+      # finish-carrying chunk.
+      def parse_chunk(item)
+        JSON.parse(item)
+      rescue JSON::ParserError
+        parse_repaired(item)
+      end
+
+      # The repair re-parse (its own method: a rescue body's exception
+      # needs its own rescue). A payload repair cannot fix is DROPPED —
+      # counted, never raised; the stream continues (I61).
+      def parse_repaired(item)
+        JSON.parse(Protocol.repair_json(item))
+      rescue JSON::ParserError
+        @dropped_chunks += 1
+        nil
+      end
+
+      # Finalize blocks, then the terminal discipline (§10.5): an error
+      # stop and a missing finish both emit :error FIRST, then raise
+      # StreamError; otherwise :done with the mapped reason. Cancel never
+      # reaches here — it unwinds mid-read with NO terminal event (AC3).
+      def deliver_terminal(accumulator, &block)
+        events, outcome = accumulator.finish
+        events.each { |event| yield event } if block
+        if outcome[0] == :stream_error
+          yield Event.new(type: :error, reason: :error, message: accumulator.partial) if block
+          raise StreamError.new(outcome[1], stop_reason: :error)
+        end
+        yield Event.new(type: :done, reason: outcome[1], message: accumulator.partial) if block
+        accumulator.partial
+      end
+
+      # Non-2xx: read the body, map per §8.
+      def raise_api_error(response)
+        body = response.body.read
+        raise Errors.class_for_status(response.status, body).new(status: response.status, body: body)
+      end
+    end
+  end
+end