ask-llm-providers 0.8.7 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d0b181ef0d5094ee52f234c097cbce2fecad3dcad729c91e6923036483a47cf
-  data.tar.gz: 8afd2d428cbe66ffa17bacdfe65e459acdef03ec8052ab764f7a742f7f453be4
+  metadata.gz: ceebc12e911bceb83ec1528b66716605dbdb2e838d69051751ea9455f21cb018
+  data.tar.gz: f435785c44e2cc895c8dce3280ad1220dd19445dea044fd11e0070f11605b476
 SHA512:
-  metadata.gz: 4a4c3741d5d530624c8acde90a60cc01b9c0b5742f219f2a237d8d9de45291b1da98d7cb43d34678c7597865dac54574b0dd36c6f31eae4ec31eeb5f281de57c
-  data.tar.gz: 2577b18aaa21cd12ce02788dbfd53d1a05196bace3e6443127deca449ba477ef9342fa0bd11de43fe3c411cab2784794efbb4707fa60d183a19cbdf11f30bcfc
+  metadata.gz: 299eb23798c50249fe2dce48981418516bf9630235eaaa25ffec01e6753aeaefe9c2867c02c697ee97084e092ed1e5ee4b7051cf1ef29b08efd095af402c9f3c
+  data.tar.gz: 196fe1897eeccd769a1ce8b097a0ce238199abb50fd4d2e0d16378a4e83a13b6599765f60a2708d3a52f6f32245f96f098247bcd31a20591e1ba4ef50dbb591f

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [0.9.0] — 2026-07-21
+
+### Added
+
+- **Prompt caching support for Anthropic** — `build_request` now accepts `prompt_caching: true`. When enabled, the system prompt is sent as an array with `cache_control: { type: "ephemeral" }` and the last user message content is wrapped to include `cache_control`. Response metadata includes `cache_creation_input_tokens` and `cache_read_input_tokens` from the provider.
+
+- **Prompt caching support for OpenAI** — `parse_response` now extracts `usage.prompt_tokens_details.cached_tokens` into response metadata as `cached_tokens`.
+
+- **Both providers advertise `prompt_caching: true`** in their capabilities.
+
+## [0.8.7] — 2026-07-18
+
+### Fixed
+
+- **`OpenAI#format_message` no longer sends empty `tool_calls: []` on assistant messages** — When a model response has no tool calls, the formatted message previously included `tool_calls: []` in the output. Some providers (notably opencode_go) reject messages with an empty `tool_calls` array. Now the field is only added when there are actual tool calls to report. Fixes multi-turn conversations breaking on all providers that reject empty `tool_calls`.
+
+## [0.8.6] — 2026-07-18
+
+### Added
+
+- **`OpenAICompatible#resolve_credential_from_env_name` now tries both flat key and path segments** — The credential fallback resolves the `api_key_env` name (e.g., `OPENCODE_API_KEY`) both as a flat key (`:opencode_api_key`) and as a nested path (`[:opencode, :api_key]`). This works with the new `Ask::Auth.resolve` multi-name and path segment support from ask-auth 0.2.3.
+
 ## [0.8.5] — 2026-07-18
 
 ### Fixed

data/lib/ask/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module LLM
-    VERSION = "0.8.7"
+    VERSION = "0.9.0"
   end
 end

data/lib/ask/provider/anthropic.rb

@@ -69,7 +69,7 @@ module Ask
 
       def build_request(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params)
         system_msgs, chat_msgs = messages.partition { |m| (m[:role] || m["role"]).to_s == "system" }
-        system_content = format_system_content(system_msgs)
+        prompt_caching = params.delete(:prompt_caching) || false
 
         payload = {
           model:,
@@ -78,7 +78,21 @@ module Ask
           stream: stream || false
         }
 
-        payload[:system] = system_content if system_content
+        if prompt_caching
+          payload[:system] = format_system_with_caching(system_msgs, chat_msgs)
+          # Mark the last user message for caching (required by Anthropic for conversation caching)
+          if payload[:messages].any?
+            last_user_idx = payload[:messages].rindex { |m| m[:role] == "user" }
+            if last_user_idx
+              content = payload[:messages][last_user_idx][:content]
+              payload[:messages][last_user_idx][:content] = wrap_content_for_caching(content)
+            end
+          end
+        else
+          system_content = format_system_content(system_msgs)
+          payload[:system] = system_content if system_content
+        end
+
         tool_defs = format_tools(tools) if tools&.any?
         payload[:tools] = tool_defs if tool_defs
         payload[:temperature] = temperature if temperature
@@ -102,6 +116,8 @@ module Ask
           stop_sequence: body["stop_sequence"],
           input_tokens: usage["input_tokens"],
           output_tokens: usage["output_tokens"],
+          cache_creation_input_tokens: usage["cache_creation_input_tokens"],
+          cache_read_input_tokens: usage["cache_read_input_tokens"],
           thinking: thinking_blocks.map { |b| b["thinking"] || b["text"] }.compact.join("\n"),
           raw: body
         }.compact
@@ -203,6 +219,32 @@ module Ask
         texts.join("\n")
       end
 
+      def format_system_with_caching(system_msgs, chat_msgs)
+        texts = system_msgs.map { |m| m[:content] || m["content"] }.compact
+        return nil if texts.empty?
+
+        combined = texts.join("\n")
+        [{ type: "text", text: combined, cache_control: { type: "ephemeral" } }]
+      end
+
+      # Wrap the last user message content for caching.
+      # Plain strings become [{ type: "text", text: content, cache_control: { type: "ephemeral" } }].
+      # Already-structured content blocks get cache_control appended.
+      def wrap_content_for_caching(content)
+        case content
+        when Array
+          content.map { |c|
+            if c.is_a?(Hash)
+              c.merge(cache_control: { type: "ephemeral" })
+            else
+              { type: "text", text: c.to_s, cache_control: { type: "ephemeral" } }
+            end
+          }
+        else
+          [{ type: "text", text: content.to_s, cache_control: { type: "ephemeral" } }]
+        end
+      end
+
       def parse_json(str)
         JSON.parse(str)
       rescue JSON::ParserError

data/lib/ask/provider/openai.rb

@@ -31,8 +31,19 @@ module Ask
 
       def chat(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params, &block)
         msgs = messages.is_a?(Ask::Conversation) ? messages.to_a : messages
-        payload = build_request(msgs, model:, tools:, temperature:, stream:, schema:, **params)
-        stream ? chat_stream(payload, model, &block) : chat_nonstream(payload, model)
+
+        # Separate provider tools from regular tools
+        regular_tools, provider_tools = split_tools(tools)
+
+        if provider_tools.any?
+          # Use the Responses API when provider tools are involved
+          responses_chat(msgs, model:, regular_tools:, provider_tools:,
+                         temperature:, stream:, schema:, **params, &block)
+        else
+          payload = build_request(msgs, model:, tools: regular_tools,
+                                  temperature:, stream:, schema:, **params)
+          stream ? chat_stream(payload, model, &block) : chat_nonstream(payload, model)
+        end
       end
 
       def embed(texts, model:)
@@ -65,7 +76,8 @@ module Ask
           {
             chat: true, streaming: true, tool_calls: true, vision: true,
             thinking: true, structured_output: true, embed: true,
-            transcribe: true, paint: true, moderate: true
+            transcribe: true, paint: true, moderate: true,
+            prompt_caching: true
           }
         end
 
@@ -94,18 +106,19 @@ module Ask
 
         msg = choice["message"]
         usage = body["usage"] || {}
-        Ask::Message.new(
-          role: :assistant,
-          content: msg["content"],
-          tool_calls: parse_tool_calls(msg["tool_calls"]),
-          metadata: {
-            model: body["model"] || model,
-            finish_reason: choice["finish_reason"],
-            input_tokens: usage["prompt_tokens"],
-            output_tokens: usage["completion_tokens"],
-            raw: body
-          }
-        )
+	        Ask::Message.new(
+	          role: :assistant,
+	          content: msg["content"],
+	          tool_calls: parse_tool_calls(msg["tool_calls"]),
+	          metadata: {
+	            model: body["model"] || model,
+	            finish_reason: choice["finish_reason"],
+	            input_tokens: usage["prompt_tokens"],
+	            output_tokens: usage["completion_tokens"],
+	            cached_tokens: usage.dig("prompt_tokens_details", "cached_tokens"),
+	            raw: body
+	          }
+	        )
       end
 
       def parse_stream(raw, stream, model, &block)
@@ -126,7 +139,15 @@ module Ask
         end
       end
 
+      def split_tools(tools)
+        return [[], []] unless tools&.any?
+
+        tools.partition { |t| !t.respond_to?(:provider_tool?) || !t.provider_tool? }
+      end
+
       def format_tools(tools)
+        return [] unless tools&.any?
+
         tools.map do |t|
           {
             type: "function",
@@ -139,6 +160,21 @@ module Ask
         end
       end
 
+      def format_responses_tools(provider_tools)
+        provider_tools.map do |pt|
+          case pt.name
+          when "web_search"
+            { type: "web_search" }.merge(pt.args)
+          when "file_search"
+            { type: "file_search" }.merge(pt.args)
+          when "code_interpreter"
+            { type: "code_interpreter" }.merge(pt.args)
+          else
+            { type: pt.name }.merge(pt.args)
+          end
+        end
+      end
+
       def format_message(msg)
         role = msg[:role] || msg["role"] || :user
         { role: role.to_s, content: msg[:content] || msg["content"] }.tap do |fm|
@@ -156,6 +192,139 @@ module Ask
         end.compact
       end
 
+      # Use the OpenAI Responses API, which supports provider-executed tools
+      # like web_search, file_search, and code_interpreter.
+      def responses_chat(messages, model:, regular_tools:, provider_tools:,
+                         temperature: nil, stream: nil, schema: nil, **params, &block)
+        payload = {
+          model: model,
+          input: format_responses_input(messages)
+        }
+
+        all_tools = []
+        all_tools.concat(format_tools(regular_tools)) if regular_tools&.any?
+        all_tools.concat(format_responses_tools(provider_tools)) if provider_tools&.any?
+        payload[:tools] = all_tools if all_tools.any?
+        payload[:temperature] = temperature if temperature
+        payload.merge!(params)
+
+        if stream
+          responses_chat_stream(payload, model, provider_tools, &block)
+        else
+          responses_chat_nonstream(payload, model, provider_tools)
+        end
+      end
+
+      def responses_chat_nonstream(payload, model, provider_tools)
+        response = @http.post("responses") { |r| r.body = payload }
+        raise LLM::HTTP.map_error(response.status, response.body, provider: "OpenAI") unless response.success?
+
+        body = response.body
+        output = body["output"] || []
+
+        # Extract text content and provider-executed tool results
+        text_parts = output.select { |o| o["type"] == "message" }
+        content = text_parts.flat_map { |m| (m["content"] || []) }
+                            .select { |c| c["type"] == "output_text" }
+                            .map { |c| c["text"] }
+                            .join
+
+        # Extract provider-executed tool results
+        provider_results = extract_responses_provider_results(output, provider_tools)
+
+        # Extract regular tool calls
+        regular_calls = extract_responses_tool_calls(output)
+
+        usage = body["usage"] || {}
+        Ask::Message.new(
+          role: :assistant,
+          content: content,
+          tool_calls: regular_calls,
+          metadata: {
+            model: body["model"] || model,
+            finish_reason: body.dig("status"),
+            input_tokens: usage["input_tokens"],
+            output_tokens: usage["output_tokens"],
+            provider_results: provider_results,
+            raw: body
+          }
+        )
+      end
+
+      def responses_chat_stream(payload, model, provider_tools, &block)
+        # Streaming with the Responses API — for now, fall back to non-streaming
+        # and return the full result. Full streaming support can be added later.
+        responses_chat_nonstream(payload, model, provider_tools)
+      end
+
+      def format_responses_input(messages)
+        messages.map do |msg|
+          role = msg[:role] || msg["role"] || "user"
+          content = msg[:content] || msg["content"] || ""
+
+          entry = { role: role.to_s }
+          entry[:content] = [{ type: "input_text", text: content.to_s }]
+
+          # Handle tool calls in assistant messages
+          if (tc = msg[:tool_calls] || msg["tool_calls"]) && tc.respond_to?(:any?) && tc.any?
+            calls = tc.is_a?(Hash) ? tc.values : tc
+            entry[:content] = calls.map { |t|
+              id = t.respond_to?(:id) ? t.id : (t[:id] || t["id"])
+              name = t.respond_to?(:name) ? t.name : (t[:name] || t["name"] || t.dig(:function, :name))
+              raw_args = t.respond_to?(:arguments) ? t.arguments : (t[:arguments] || t["arguments"] || t.dig(:function, :arguments))
+              args = raw_args.is_a?(String) ? raw_args : JSON.generate(raw_args)
+              { type: "function_call", id: id, name: name, arguments: args, status: "completed" }
+            }
+          end
+
+          # Handle tool results
+          if (tid = msg[:tool_call_id] || msg["tool_call_id"])
+            entry[:content] = [{ type: "function_call_output", id: tid, output: content.to_s }]
+          end
+
+          entry
+        end
+      end
+
+      def extract_responses_provider_results(output, provider_tools)
+        results = {}
+        provider_tool_names = provider_tools.map(&:name)
+
+        output.each do |item|
+          case item["type"]
+          when "web_search_call"
+            result_item = output.find { |o| o["type"] == "web_search_result" && o["id"] == item["id"] }
+            if result_item
+              results[item["id"]] = {
+                provider_executed: true,
+                tool_name: "web_search",
+                message: result_item.to_s,
+                status: "success"
+              }
+            end
+          when "file_search_call"
+            result_item = output.find { |o| o["type"] == "file_search_result" && o["id"] == item["id"] }
+            if result_item
+              results[item["id"]] = {
+                provider_executed: true,
+                tool_name: "file_search",
+                message: result_item.to_s,
+                status: "success"
+              }
+            end
+          when "function_call"
+            # Regular tool call — handled elsewhere
+          end
+        end
+        results
+      end
+
+      def extract_responses_tool_calls(output)
+        output.select { |o| o["type"] == "function_call" }.map do |fc|
+          { id: fc["id"], type: "function", name: fc["name"], arguments: fc["arguments"] }
+        end
+      end
+
       private
 
       def extract_provider_keys(config)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-llm-providers
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.9.0
 platform: ruby
 authors:
 - Kaka Ruto