llm_gateway 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '086d7bdff1cb0b6b3febb78d025d7ccfe4b53c6fd40fcb5cddebd335d786e437'
-  data.tar.gz: 1b2ea3af95f44d27c0c1636da321d24dc036fad8a242263f608948c79ac11f88
+  metadata.gz: 173ab613e57543956e39d70f4a38fc865bc6b6bac4e8dfe319be9c2928810f77
+  data.tar.gz: 46c761a838aee6c3cebad151467555cba8ab70480e952ab741874c2d8acc13e8
 SHA512:
-  metadata.gz: '0147478704832819ee6d8fbe4e0e6203f4e598d72fd3b23138b550de9da64fb90cd8354713a5553244acf17b9c6fe0a89a0b5cab624f03ec7382e12f11aebb21'
-  data.tar.gz: 22e1ff9571717ebe8f39a31cd36d37815c6053def32ac1e125a103ccb516a98b37aeb225edae899c6a9ecf121df5344bbbe6f6166a2e1d89ffa05db881c70e14
+  metadata.gz: 0f21f7288e4d8d374ea77d96ee3110b08a260a2e06ef6fd6372357b88abb5e936d2cbeae934720a0a5e17ad431bdce7027a3cd68e4fc60460c6cb5d0f02acc0a
+  data.tar.gz: ecf15206364c5ef7d632c0c421294deb1929e508b4287828acbee91e4a4182fb0efd5fb12cca58d6909499b2b33197070bd4c19e232bed8f25fd12f86e2dd604

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [v0.7.0](https://github.com/Hyper-Unearthing/llm_gateway/tree/v0.7.0) (2026-06-03)
+
+[Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.6.0...v0.7.0)
+
+**Merged pull requests:**
+
+- feat: add agent harness [\#88](https://github.com/Hyper-Unearthing/llm_gateway/pull/88) ([billybonks](https://github.com/billybonks))
+- refactor: prompt to use modern patterns [\#87](https://github.com/Hyper-Unearthing/llm_gateway/pull/87) ([billybonks](https://github.com/billybonks))
+- feat: change our utils to follow actie support style [\#85](https://github.com/Hyper-Unearthing/llm_gateway/pull/85) ([billybonks](https://github.com/billybonks))
+- feat: add reasoning level as soemthing configurable in prompt [\#83](https://github.com/Hyper-Unearthing/llm_gateway/pull/83) ([billybonks](https://github.com/billybonks))
+- feat: add support for code execution tool [\#79](https://github.com/Hyper-Unearthing/llm_gateway/pull/79) ([billybonks](https://github.com/billybonks))
+
 ## [v0.6.0](https://github.com/Hyper-Unearthing/llm_gateway/tree/v0.6.0) (2026-05-27)
 
 [Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.5.0...v0.6.0)

data/README.md

@@ -12,10 +12,18 @@ Provide a unified translation interface for LLM Provider API's, While allowing d
   - [Provider-specific options](#provider-specific-options)
 - [Quick Start: Streaming (all events)](#quick-start-streaming-all-events)
   - [Stream API without handling events (final result only)](#stream-api-without-handling-events-final-result-only)
+- [Prompt classes](#prompt-classes)
 - [Migration guides](#migration-guides)
 - [Tools](#tools)
   - [Defining Tools](#defining-tools)
   - [Handling Tool Calls](#handling-tool-calls)
+  - [Server Tool Use](#server-tool-use)
+- [Agents](#agents)
+  - [Agent events](#agent-events)
+  - [Session managers and persistence](#session-managers-and-persistence)
+  - [Queues, steering, and follow-ups](#queues-steering-and-follow-ups)
+  - [Compaction](#compaction)
+  - [Built-in agent tools](#built-in-agent-tools)
 - [Image Input](#image-input)
 - [Thinking / Reasoning](#thinking--reasoning)
   - [Streaming Thinking Content](#streaming-thinking-content)
@@ -158,7 +166,7 @@ response = adapter.stream(transcript, tools: tools, model: "gpt-5.4", reasoning:
 
   # Tool-call events
   when :tool_start
-    puts "\n[tool_start] id=#{event.id} name=#{event.name} index=#{event.content_index}"
+    puts "\n[tool_start] id=#{event.id} name=#{event.name} type=#{event.tool_type} index=#{event.content_index}"
   when :tool_delta
     streamed_tool_args[event.content_index] << event.delta
     print event.delta
@@ -212,6 +220,7 @@ Stream callback event families:
 - `AssistantStreamEvent` (and subclasses):
   - Text: `:text_start`, `:text_delta`, `:text_end`
   - Tool call: `:tool_start`, `:tool_delta`, `:tool_end`
+  - Tool result: `:tool_result_start`, `:tool_result_delta`, `:tool_result_end` (emitted by some provider-hosted/server tools)
   - Reasoning: `:reasoning_start`, `:reasoning_delta`, `:reasoning_end`
 
 Non-final stream events expose `event.partial`, a `PartialAssistantMessage` snapshot accumulated so far. The final `:message_end` event exposes the complete `AssistantMessage` as `event.message` instead.
@@ -251,8 +260,63 @@ text = result.content
 puts text
 ```
 
+## Prompt classes
+
+`LlmGateway::Prompt` wraps a reusable prompt, provider/model defaults, callbacks, optional tools, and prompt-cache options around the `stream` API.
+
+```ruby
+class AddTool < LlmGateway::Tool
+  name "add"
+  description "Adds two numbers"
+  input_schema(type: "object")
+  cache true # optional: mark the tool definition as cacheable where supported
+
+  def execute(input)
+    input[:left] + input[:right]
+  end
+end
+
+class MathPrompt < LlmGateway::Prompt
+  self.provider = LlmGateway.build_provider(
+    provider: "openai_responses",
+    api_key: ENV.fetch("OPENAI_API_KEY")
+  )
+  self.model = "gpt-5.4"
+
+  TOOLS = [AddTool].freeze
+
+  def prompt
+    "What is 2 + 3? Use the add tool."
+  end
+
+  def system_prompt
+    "You are a careful math assistant."
+  end
+end
+
+response = MathPrompt.new(
+  cache_key: "math-prompt-v1",
+  cache_retention: "short"
+).run
+
+puts response.role # "assistant"
+puts response.content.select { |block| block.type == "text" }.map(&:text).join
+```
+
+How `Prompt` works now:
+
+- `prompt` is evaluated once per `run`.
+- `run(provider:, model:, reasoning:, **options)` calls `stream` and returns the final normalized `AssistantMessage` after any tool calls complete.
+- `stream(input = prompt, provider:, model:, reasoning:, **options, &block)` forwards to the provider and returns the normalized `AssistantMessage`.
+- Tools are declared as tool classes in a `TOOLS` constant. `run` automatically executes returned `tool_use` blocks, appends `tool_result` messages, and loops until no tool calls remain.
+- `system_prompt`, `tools`, `model`, `reasoning`, `cache_key`, and `cache_retention` are forwarded as stream options.
+- `cache_retention` can also enable provider cache control for prompt-owned system/tool blocks where supported, and `Tool.cache true` marks a tool definition with `cache_control`.
+- `before_execute` callbacks receive the resolved input. `after_execute` callbacks receive the final `AssistantMessage`.
+- The old `extract_response` and `parse_response` hooks are no longer called; inspect, parse, or transform the returned `AssistantMessage` after `run`.
+
 ## Migration guides
 
+- [0.7.0 migration guide](docs/migration_guide_0.7.0.md) — update `Prompt` subclasses for normalized `AssistantMessage` return values, automatic tool loops, `TOOLS`, and removed response hooks.
 - [0.6.0 migration guide](docs/migration_guide_0.6.0.md) — move `model_key` to per-request `model:`, update provider keys, update `Prompt` usage, and migrate stream event/usage changes.
 - [Migrating from `chat` to `stream`](docs/migration-guide.md) — use `stream` without a block when you only need the final response.
 
@@ -358,6 +422,196 @@ Notes:
 - Tool results are sent back in the transcript as `{ type: "tool_result", tool_use_id:, content: }` blocks.
 - For multimodal-capable models, `tool_result` content can include image blocks when supported by the provider/model.
 
+### Server Tool Use
+
+Some providers offer provider-hosted tools, such as OpenAI Responses code interpreter or Anthropic code execution. Pass these tools in the provider's native shape; `llm_gateway` preserves them and normalizes server tool activity in streams and final messages.
+
+```ruby
+openai_code_interpreter = {
+  type: "code_interpreter",
+  container: { type: "auto", memory_limit: "1g" }
+}
+
+anthropic_code_execution = {
+  type: "code_execution_20250825",
+  name: "code_execution"
+}
+
+tools = provider == "openai_responses" ? [openai_code_interpreter] : [anthropic_code_execution]
+response = adapter.stream("Create a chart from this CSV and save it as PNG.", tools: tools) do |event|
+  case event.type
+  when :tool_start
+    puts "server tool: #{event.name}" if event.tool_type == "server_tool_use"
+  when :tool_delta
+    print event.delta # streamed code/input JSON when the provider exposes it
+  when :tool_result_start, :tool_result_delta
+    print event.delta # provider-hosted result metadata/content when available
+  end
+end
+
+response.content.each do |block|
+  case block.type
+  when "server_tool_use"
+    puts "server tool #{block.name} input=#{block.input.inspect} id=#{block.id}"
+  when "server_tool_result"
+    puts "server tool result for #{block.tool_use_id}: #{block.content.inspect}"
+  end
+end
+```
+
+Cross-provider server tool handoffs are best-effort:
+
+- Same provider/API replay keeps `server_tool_use` / `server_tool_result` blocks when possible.
+- Cross-provider replay converts server tool uses into normal `tool_use` blocks and server tool results into `tool_result` blocks.
+- `llm_gateway` does not translate server tool names between providers. Supply the target provider's server tool definition on the follow-up request.
+- Some providers require the same server tool to be selected in `tools:` when replaying prior server tool activity.
+
+## Agents
+
+`LlmGateway::Agents::Harness` wraps the streaming API in a stateful conversation loop. It stores session history, executes `LlmGateway::Tool` classes automatically when the model emits tool calls, appends `tool_result` messages, repeats model turns until there are no more tool calls, supports queued user messages while a turn is running, and compacts older session context when needed.
+
+```ruby
+require "llm_gateway"
+require "json"
+
+class WeatherTool < LlmGateway::Tool
+  name "get_weather"
+  description "Get current weather for a location"
+  input_schema(
+    type: "object",
+    properties: {
+      location: { type: "string" }
+    },
+    required: ["location"]
+  )
+
+  def execute(input)
+    location = input[:location] || input["location"]
+
+    JSON.generate(
+      location: location,
+      temperature: 14,
+      condition: "Cloudy"
+    )
+  end
+end
+
+class WeatherHarness < LlmGateway::Agents::Harness
+  TOOLS = [WeatherTool]
+
+  def system_prompt
+    "You are a concise weather assistant. Use tools when useful."
+  end
+end
+
+adapter = LlmGateway.build_provider(
+  provider: "openai_responses",
+  api_key: ENV.fetch("OPENAI_API_KEY")
+)
+
+session = LlmGateway::Agents::InMemorySessionManager.new("weather-session")
+harness = WeatherHarness.new(
+  session,
+  provider: adapter,
+  model: "gpt-5.4",
+  reasoning: "high"
+)
+
+harness.prompt_message(
+  role: "user",
+  content: [ { type: "text", text: "What is the weather in London?" } ]
+) do |event|
+  case event.type
+  when :agent_start
+    puts "Agent started"
+  when :turn_start
+    puts "Turn started"
+  when :message_update
+    # Streaming provider events are wrapped on message update events.
+    stream_event = event.stream_event
+    print stream_event.delta if stream_event.respond_to?(:delta)
+  when :tool_execution_start
+    puts "\nExecuting #{event.parameters[:name]}"
+  when :tool_execution_end
+    puts "\nTool result: #{event.result.content}"
+  when :agent_end
+    puts "\nAgent finished"
+  end
+end
+
+puts harness.transcript.inspect
+```
+
+Harness behavior:
+
+- `prompt_message(message)` accepts an LLM-shaped message hash, records it in the session, streams the provider response, records the final assistant message, executes any returned tool calls from the harness class's `TOOLS` constant, records a user `tool_result` message, and continues until no tool calls remain.
+- Harnesses pass `tools`, `system_prompt`, `model`, `reasoning`, `cache_key`, and `cache_retention` through the inherited `Prompt#stream` defaults.
+- Pass `model:` and optional `reasoning:` to `new`, or set them later with `harness.model = "..."` / `harness.reasoning = "..."`. Model and reasoning changes are recorded as session events.
+- `harness.transcript` (also aliased as `prompt`) returns the current model input: the latest compaction summary, if any, followed by active messages.
+- `harness.run` / `harness.continue` continues from the current session state without adding a new user message.
+
+### Agent events
+
+When a block is passed to `prompt_message`, `run`, or `continue`, the harness emits typed events:
+
+- `:agent_start`
+- `:turn_start`
+- `:message_start`
+- `:message_update` with `event.stream_event` containing the normalized streaming event from the provider
+- `:message_end` with `event.message`
+- `:tool_execution_start` with `event.parameters` (`id`, `type`, `name`, `input`)
+- `:tool_execution_end` with `event.parameters` and `event.result`
+- `:turn_end` with `event.message` and `event.tool_results`
+- `:agent_end`
+
+### Session managers and persistence
+
+- `LlmGateway::Agents::InMemorySessionManager.new(session_id = nil)` keeps session events in memory for the lifetime of the process.
+- `LlmGateway::Agents::FileSessionManager.new(file_name = nil, session_id: nil, session_start: nil, session_dir: nil)` persists session events as JSONL. If `file_name` is omitted, files are created under `LLM_GATEWAY_SESSION_DIR` or `~/.llm_gateway/sessions`.
+- File sessions load existing JSONL sessions and append new events to the same file.
+- Session event types include `session`, `message`, `model_change`, `reasoning_change`, and `compaction`. Queued messages are kept in memory and are persisted only when drained into the active conversation.
+
+### Queues, steering, and follow-ups
+
+Calls made while a harness is already processing are queued instead of recursively starting another run.
+
+- `prompt_message(message)` queues to the harness's default queue while busy. The default is `:next_turn`.
+- `steer_message(message)`, `follow_up_message(message)`, and `next_turn_message(message)` enqueue to their matching queue while busy. When idle, they behave like `prompt_message`.
+- `:steer` messages are drained before the next model request in the current run.
+- `:follow_up` messages run after the current turn finishes and before `:next_turn` messages.
+- `:next_turn` messages run after the current agent run completes.
+- Queued messages drain as `:all` by default. Set `harness.queue_drain_mode = :one_at_a_time` to drain one FIFO message at a time.
+- Set `harness.default_queue_mode = :steer`, `:follow_up`, or `:next_turn` to change where busy `prompt_message` calls are queued.
+
+### Compaction
+
+Before starting a new user message and before draining queued follow-up/next-turn work, the harness checks whether compaction is needed. It compacts when either:
+
+- the latest recorded message usage exceeds `LlmGateway::Agents::Harness::COMPACTION_TOKEN_THRESHOLD`, or
+- the latest assistant message is older than `LlmGateway::Agents::Harness::COMPACTION_IDLE_THRESHOLD_SECONDS`.
+
+Compaction calls `adapter.stream(active_messages, system: "Summarize the conversation so far for future context.", tools: [])`, stores the returned assistant message as a `compaction` event, and builds future model input as the compaction summary plus messages recorded after that compaction.
+
+### Built-in agent tools
+
+The agent harness can use any `LlmGateway::Tool` subclass in its `TOOLS` constant. The library also provides optional coding-oriented tools. Require the ones you want and include them in your harness:
+
+```ruby
+require "llm_gateway/agents/tools/read_tool"
+require "llm_gateway/agents/tools/bash_tool"
+require "llm_gateway/agents/tools/edit_tool"
+require "llm_gateway/agents/tools/write_tool"
+
+class CodingHarness < LlmGateway::Agents::Harness
+  TOOLS = [ReadTool, BashTool, EditTool, WriteTool]
+end
+```
+
+- `ReadTool` (`read`) reads text files and supported images (`jpg`, `png`, `gif`, `webp`). Text output is truncated to 2,000 lines or 50KB from the start; use `offset`/`limit` to continue through large files.
+- `BashTool` (`bash`) runs a command in the current working directory, combines stdout/stderr, supports an optional timeout, truncates long output to the last 2,000 lines or 50KB, and saves full truncated output to a temp file.
+- `EditTool` (`edit`) edits one file with one or more exact `edits[].oldText` → `edits[].newText` replacements. Each `oldText` must be unique in the original file and edits must not overlap.
+- `WriteTool` (`write`) creates parent directories as needed and writes or overwrites a file.
+
 ## Image Input
 
 Send images by including an `image` content block in a user message.

data/docs/migration_guide_0.7.0.md

@@ -0,0 +1,193 @@
+# Migration guide: 0.7.0
+
+This release refactors `LlmGateway::Prompt` around the normalized streaming response model and adds first-class prompt-owned tool loops.
+
+## Breaking changes
+
+### `Prompt.new` uses keyword arguments
+
+Prompt instance configuration is now keyword-only:
+
+```ruby
+# Before
+SummaryPrompt.new(provider, "claude-sonnet-4-20250514").run
+
+# After
+SummaryPrompt.new(
+  provider: provider,
+  model: "claude-sonnet-4-20250514"
+).run
+```
+
+The same applies when overriding class defaults for `reasoning`, `cache_key`, or `cache_retention`.
+
+Class-level prompt defaults should be assigned with writer methods:
+
+```ruby
+class SummaryPrompt < LlmGateway::Prompt
+  self.provider = provider
+  self.model = "gpt-5.4"
+  self.reasoning = "medium"
+end
+```
+
+If you used the older setter-style calls (`provider value` or `model value`) in prompt subclasses, switch to `self.provider = value` / `self.model = value`.
+
+### `Prompt#run` uses `stream` and normalized `AssistantMessage`
+
+`run` now calls the configured provider's `stream` method and expects it to return a normalized `LlmGateway::AssistantMessage` with `content` blocks.
+
+If you use test doubles or custom providers with `Prompt`, update them from hash-like chat responses:
+
+```ruby
+# Before
+{ choices: [ { content: "hello" } ] }
+```
+
+To `AssistantMessage` responses:
+
+```ruby
+LlmGateway::AssistantMessage.new(
+  id: "msg_123",
+  model: "gpt-5.4",
+  role: "assistant",
+  stop_reason: "stop",
+  provider: "openai",
+  api: "responses",
+  timestamp: Time.now.to_i,
+  usage: {},
+  content: [ { type: "text", text: "hello" } ]
+)
+```
+
+`run` returns the final normalized `AssistantMessage` after tool handling is complete. It no longer extracts or concatenates text content for you; inspect `response.content` when you need text or other blocks.
+
+`after_execute` callbacks now receive only the final `AssistantMessage` instead of both the message and extracted text.
+
+Prompt callback storage now uses Rails-style `class_attribute` inheritance. Register callbacks with `before_execute` / `after_execute` or assign a duplicated callback array on the subclass; avoid mutating inherited callback arrays directly with `before_execute_callbacks << ...` because that can affect related classes.
+
+### `extract_response` and `parse_response` hooks were removed
+
+`Prompt#run` no longer calls custom `extract_response` or `parse_response` methods.
+
+Move response transformation outside the prompt call, or wrap `run` in your subclass:
+
+```ruby
+class JsonPrompt < LlmGateway::Prompt
+  def prompt
+    "Return JSON."
+  end
+
+  def run_json(**options)
+    response = run(**options)
+    text = response.content.select { |block| block.type == "text" }.map(&:text).join
+    JSON.parse(text)
+  end
+end
+```
+
+### Tools are declared with `TOOLS`
+
+Prompt tools are now class-level tool classes declared in a `TOOLS` constant. `Prompt#tools` returns their provider definitions.
+
+```ruby
+class AddTool < LlmGateway::Tool
+  name "add"
+  description "Adds two numbers"
+  input_schema(type: "object")
+  cache true # optional cache_control marker where supported
+
+  def execute(input)
+    input[:left] + input[:right]
+  end
+end
+
+class MathPrompt < LlmGateway::Prompt
+  TOOLS = [AddTool].freeze
+
+  def prompt
+    "What is 2 + 3? Use the add tool."
+  end
+end
+```
+
+If a prompt has no tools, `tools` now returns `[]` instead of `nil`.
+
+### `run` automatically loops over tool calls
+
+When the assistant returns `tool_use` content blocks, `Prompt#run` now:
+
+1. Finds the matching class in `TOOLS` by tool name.
+2. Executes `tool_class.new.execute(input)`.
+3. Appends the assistant message and a user `tool_result` message.
+4. Calls `stream` again.
+5. Repeats until the response has no `tool_use` blocks.
+
+Unknown tools and tool execution errors are returned to the model as `tool_result` content rather than raised.
+
+### Prompt input is resolved once per run
+
+`prompt` is evaluated once at the start of `run`. The same initial input is used when building follow-up messages for tool results, so dynamic or expensive prompt builders are not re-evaluated during a single run.
+
+### `Prompt#stream` accepts explicit input and forwards reasoning/cache options
+
+`stream` now has this signature:
+
+```ruby
+stream(input = prompt, provider: nil, model: nil, reasoning: nil, **options, &block)
+```
+
+You can still call `stream` with no input, but subclasses or callers can now provide a transcript directly:
+
+```ruby
+prompt.stream([{ role: "user", content: "Hello" }], model: "gpt-5.4")
+```
+
+`Prompt` also now forwards `reasoning:` when configured on the class, instance, `run`, or `stream` call.
+
+### Prompt-level cache options
+
+Prompt instances accept and forward cache options:
+
+```ruby
+SummaryPrompt.new(
+  provider: provider,
+  model: "gpt-5.4",
+  cache_key: "summary-v1",
+  cache_retention: "short"
+).run
+```
+
+These are passed to providers as managed `cache_key` / `cache_retention` stream options. For providers that support cache control on system/tool blocks, `cache_retention` may also apply cache metadata to the prompt-owned `system_prompt` and tool definitions. Tool classes can also opt into cache metadata with `cache true`.
+
+### Stream callbacks may see server-tool events and content blocks
+
+Provider-hosted tools (for example OpenAI code interpreter or Anthropic code execution) are normalized as distinct server-tool blocks:
+
+- `server_tool_use`
+- `server_tool_result`
+- provider-specific `*_tool_result` blocks during streaming/finalization
+
+Stream callbacks may now receive additional event types when server tools are used:
+
+- `:tool_result_start`
+- `:tool_result_delta`
+- `:tool_result_end`
+
+`tool_start` events also expose `event.tool_type`, which is either `"tool_use"` or `"server_tool_use"`.
+
+If your stream handler exhaustively switches on event/content types, add fallbacks or handlers for these server-tool cases. Cross-provider handoff sanitization may convert server-tool blocks to regular `tool_use` / `tool_result` blocks when replaying transcripts on a different provider/API.
+
+## Migration checklist
+
+- [ ] Replace positional `Prompt.new(provider, model)` calls with `Prompt.new(provider: provider, model: model)`.
+- [ ] Replace prompt class setter-style calls (`provider value`, `model value`) with `self.provider = value` / `self.model = value`.
+- [ ] Update custom provider/test doubles used by `Prompt` to return `AssistantMessage`.
+- [ ] Remove `extract_response` and `parse_response` hooks; inspect, parse, or transform the returned `AssistantMessage` after `run`.
+- [ ] Update `after_execute` callbacks to accept the final `AssistantMessage` only.
+- [ ] Replace direct mutations of `before_execute_callbacks` / `after_execute_callbacks` with the callback registration methods or explicit subclass assignments.
+- [ ] Move prompt tool definitions to a `TOOLS = [ToolClass]` constant.
+- [ ] Account for automatic tool-loop execution in `run`.
+- [ ] Update any `tools.nil?` checks; no-tool prompts now expose `[]`.
+- [ ] Use `cache_key:` / `cache_retention:` on prompt instances when prompt caching is needed.
+- [ ] Add stream/content handling for server-tool event types if your callback code is exhaustive.

data/lib/llm_gateway/adapters/adapter.rb

@@ -103,7 +103,7 @@ module LlmGateway
         target_provider = LlmGateway::Client.provider_id_from_client(client)
         target_api = api_name
 
-        return messages if target_provider.nil? || target_api.nil? || target_model.nil?
+        return messages unless target_provider.present? && target_api.present? && target_model.present?
 
         input_sanitizer.sanitize(
           messages,

data/lib/llm_gateway/adapters/anthropic/input_mapper.rb

@@ -26,6 +26,8 @@ module LlmGateway
             map_tool_use_content(content)
           when "tool_result"
             map_tool_result_content(content)
+          when "server_tool_result"
+            map_server_tool_result_content(content)
           when "thinking", "reasoning"
             map_reasoning_content(content)
           else
@@ -122,6 +124,28 @@ module LlmGateway
             }
           end
 
+          def map_server_tool_result_content(content)
+            {
+              type: native_server_tool_result_type(content),
+              tool_use_id: content[:tool_use_id],
+              content: content[:content]
+            }
+          end
+
+          def native_server_tool_result_type(content)
+            return content[:name] if content[:name] && content[:name] != "server_tool_result"
+
+            result_type = content.dig(:content, :type)
+            case result_type
+            when "bash_code_execution_result"
+              "bash_code_execution_tool_result"
+            when /^text_editor_code_execution_.*_result$/
+              "text_editor_code_execution_tool_result"
+            else
+              content[:name] || "server_tool_result"
+            end
+          end
+
           def map_reasoning_content(content)
             result = {
               type: "thinking",

data/lib/llm_gateway/adapters/anthropic/stream_mapper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 require_relative "../stream_mapper"
 
 module LlmGateway
@@ -17,20 +19,33 @@ module LlmGateway
             accumulator.push({ type: :message_start, delta: }, &block)
           when "content_block_start"
             content_block = chunk.dig(:data, :content_block) || {}
-            @current_content_block_type = content_block[:type]
+            @current_content_block_type = normalize_content_block_type(content_block[:type])
 
             case @current_content_block_type
             when "thinking"
               accumulator.push({ type: :reasoning_start, delta: content_block[:thinking], signature: "" }, &block)
             when "text"
               accumulator.push({ type: :text_start, delta: content_block[:text] }, &block)
-            when "tool_use"
+            when "tool_use", "server_tool_use"
               accumulator.push(
                 {
                   type: :tool_start,
                   delta: "",
                   id: content_block[:id],
-                  name: content_block[:name]
+                  name: content_block[:name],
+                  tool_type: @current_content_block_type
+                },
+                &block
+              )
+            when "server_tool_result"
+              content = content_block[:content]
+              result_delta = content.nil? ? "" : JSON.generate(content)
+              accumulator.push(
+                {
+                  type: :tool_result_start,
+                  delta: result_delta,
+                  tool_use_id: content_block[:tool_use_id],
+                  name: content_block[:type]
                 },
                 &block
               )
@@ -44,9 +59,13 @@ module LlmGateway
             when "text"
               delta = chunk.dig(:data, :delta, :text)
               accumulator.push({ type: :text_delta, delta: }, &block)
-            when "tool_use"
+            when "tool_use", "server_tool_use"
               delta = chunk.dig(:data, :delta, :partial_json)
               accumulator.push({ type: :tool_delta, delta: }, &block)
+            when "server_tool_result"
+              content = chunk.dig(:data, :delta, :content)
+              result_delta = content.nil? ? "" : JSON.generate(content)
+              accumulator.push({ type: :tool_result_delta, delta: result_delta }, &block)
             end
           when "content_block_stop"
             case @current_content_block_type
@@ -54,8 +73,10 @@ module LlmGateway
               accumulator.push({ type: :reasoning_end, delta: "", signature: "" }, &block)
             when "text"
               accumulator.push({ type: :text_end, delta: "" }, &block)
-            when "tool_use"
+            when "tool_use", "server_tool_use"
               accumulator.push({ type: :tool_end, delta: "" }, &block)
+            when "server_tool_result"
+              accumulator.push({ type: :tool_result_end, delta: "" }, &block)
             end
             @current_content_block_type = nil
           when "message_delta"
@@ -78,7 +99,7 @@ module LlmGateway
         private
 
         def normalized_usage(usage)
-          usage = symbolize_keys(usage)
+          usage = usage.to_h.symbolize_keys
 
           input = token_count(usage[:input_tokens])
           cache_write = token_count(usage[:cache_creation_input_tokens])
@@ -99,8 +120,10 @@ module LlmGateway
           value.to_i
         end
 
-        def symbolize_keys(hash)
-          hash.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+        def normalize_content_block_type(type)
+          return type unless type&.end_with?("_tool_result")
+
+          "server_tool_result"
         end
 
         def normalize_message_delta(delta)

data/lib/llm_gateway/adapters/anthropic_option_mapper.rb

@@ -50,7 +50,7 @@ module LlmGateway
       module_function
 
       def map(options)
-        mapped_options = options.reject { |key, _| MANAGED_OPTIONS.include?(key) }
+        mapped_options = options.except(*MANAGED_OPTIONS)
         mapped_options[:max_tokens] = options[:max_completion_tokens] || DEFAULT_MAX_TOKENS
 
         response_format = options[:response_format]