ask-llm-providers 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9356b3e21bb6e8e3c69f531eda38a4ae965ac5c19f20e655bd0ebe3c927f729
-  data.tar.gz: 97d0c10a4937f3d8b6102392328d48b2f5bbf2ad73621fb8139759a892ff0df7
+  metadata.gz: 83d9430295753c63779ef81db7fbbc4e9c56c3e1848f44e53a763c70c43cc1f8
+  data.tar.gz: a9ea83f80669da1e5869204a42af7bc52e071d81f355da80df26002246d3b828
 SHA512:
-  metadata.gz: 138d21391c23578668a9fecec6160a4403e8c01019a2c9795af0ab5f62e380958fe0f9735ef994b7f4a8b9115f060f8a83b724b58a558483465c14a81cb99b6c
-  data.tar.gz: e8e0e7bc5bd760723b01d9e246b443631f87e0a29fc473f2ac673e3115fe772d5732d2ae90f8e4903296e1d5b70c36ccc17de9d4900d4d66c658f5e5523b4add
+  metadata.gz: 870a8543f6810948e62f65b18b39f0924a78ec393108f74e992ecff25cfe8e14ae8331d287d436afdb88f3792379c778598b3188642c4c5a002bb374f56a0c8e
+  data.tar.gz: 211593c5668424aab22e2f03c6230d6ad791a4f7f6002b60b8e26e879f2ae8d6e28782b29790611c796c8fa2d0edab1494e1a9d61ec638a4b78fde1fbba639a2

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [0.5.0] — 2026-07-17
+
+### Added
+
+- **OpenAI-compatible provider registry** (`Ask::LLM::OPENAI_COMPATIBLE`) — 12 providers defined as data, not classes. Adding a new OpenAI-compatible API (Groq, Together, Fireworks, etc.) is one line in the registry. No new file, no subclass.
+- **`Ask::Providers::OpenAICompatible` class** — single class handling all registered providers by reading from the registry. Each provider gets an anonymous subclass with its slug, api_base, env var mapping, and quirks (reasoning_content, extra_headers) set from config.
+- **Unified test** — `OpenAICompatibleTest` dynamically tests every registered provider: identity, slug, capabilities, api_base, env var resolution, request building, response parsing, streaming, and tool formatting.
+
+### Removed
+
+- **5 subclass files** — `deepseek.rb`, `openrouter.rb`, `opencode.rb`, `opencode_go.rb`, `mimo.rb` deleted. Replaced by registry entries.
+- **DeepSeek-specific test file** — covered by the unified test.
+
+## [0.4.0] — 2026-07-16
+
+### Added
+
+- **`Ask::LLM::ProviderConfig` transformation contract** — Shared module that every provider includes, defining the wire-format interface: `build_request`, `parse_response`, `parse_stream`, `format_tools`, `format_message`. Adding a new provider is now mechanical — implement five methods and the provider works. (Inspired by LiteLLM's `BaseConfig` pattern.)
+- **`BaseProviderTests` shared test module** — Every provider test includes this module, which enforces 22 contract tests (interface methods, slug, capabilities, config, request building, error mapping) inherited from LiteLLM's `BaseLLMChatTest` approach. Adding a new provider gives you 22 tests for free.
+- **Comprehensive per-provider tests** — Each provider now has dedicated tests for `build_request`, `parse_response`, `parse_stream`, `format_message`, `format_tools`, `parse_error`, and streaming — covering happy paths, edge cases, and error conditions. Total test count: 341 (up from ~33 in v0.1.0).
+
+### Changed
+
+- **Provider refactoring** — OpenAI, Anthropic, Google, Bedrock, Ollama, Cloudflare, and Mistral providers now include `Ask::LLM::ProviderConfig` and implement its transformation contract. The `chat` method in each is a clean orchestrator: build request → HTTP → parse response. Internal methods (`build_chat_payload`, `process_chunk`, etc.) are renamed to the contract standard.
+- **Subclass compatibility** — DeepSeek, OpenRouter, OpenCode, OpenCodeGo, and Mimo (all OpenAI subclasses) inherit the transformation contract unchanged. Their `format_messages` overrides continue to work through `build_request`.
+
+### Removed
+
+- **Dead files** — Removed `lib/ask/provider/config.rb` (moved to `lib/ask/llm/provider_config.rb` to avoid namespace collision with `Ask::Provider` class).
+
 ## [0.3.1] — 2026-07-14
 
 ### Removed

data/lib/ask/llm/openai_compatible.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ask
+  module LLM
+    # Registry of OpenAI-compatible providers (data, not classes).
+    #
+    # Each entry is configuration for {Ask::Providers::OpenAICompatible}.
+    # To add a new provider, add one line here — no new file, no subclass.
+    #
+    # @example Adding Groq
+    #   groq: { api_base: "https://api.groq.com/openai/v1", api_key_env: "GROQ_API_KEY" }
+    #
+    OPENAI_COMPATIBLE = {
+      deepseek:    { api_base: "https://api.deepseek.com",                      api_key_env: "DEEPSEEK_API_KEY",
+                     reasoning_content: true,
+                     capabilities: { chat: true, streaming: true, tool_calls: true, thinking: true } },
+
+      openrouter:  { api_base: "https://openrouter.ai/api/v1",                  api_key_env: "OPENROUTER_API_KEY",
+                     extra_headers: { "HTTP-Referer" => "https://github.com/ask-rb",
+                                      "X-Title" => "ask-rb" },
+                     capabilities: { chat: true, streaming: true, tool_calls: true, vision: true,
+                                     thinking: true, structured_output: true } },
+
+      opencode:    { api_base: "https://opencode.ai/zen/v1",                    api_key_env: "OPENCODE_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true } },
+
+      opencode_go: { api_base: "https://opencode.ai/zen/go/v1",                 api_key_env: "OPENCODE_GO_API_KEY",
+                     alternate_env: "OPENCODE_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true } },
+
+      mimo:        { api_base: "https://token-plan-sgp.xiaomimimo.com/v1",      api_key_env: "MIMO_API_KEY",
+                     capabilities: { chat: true, streaming: true } },
+
+      groq:        { api_base: "https://api.groq.com/openai/v1",                api_key_env: "GROQ_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true, vision: true } },
+
+      together:    { api_base: "https://api.together.xyz/v1",                   api_key_env: "TOGETHER_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true } },
+
+      fireworks:   { api_base: "https://api.fireworks.ai/inference/v1",         api_key_env: "FIREWORKS_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true } },
+
+      perplexity:  { api_base: "https://api.perplexity.ai",                     api_key_env: "PERPLEXITY_API_KEY",
+                     capabilities: { chat: true, streaming: true } },
+
+      cerebras:    { api_base: "https://api.cerebras.ai/v1",                    api_key_env: "CEREBRAS_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true } },
+
+      xai:         { api_base: "https://api.x.ai/v1",                           api_key_env: "XAI_API_KEY",
+                     capabilities: { chat: true, streaming: true, tool_calls: true, vision: true,
+                                     thinking: true } },
+
+      moonshot:    { api_base: "https://api.moonshot.ai/v1",                    api_key_env: "MOONSHOT_API_KEY",
+                     capabilities: { chat: true, streaming: true } }
+    }.freeze
+  end
+end

data/lib/ask/llm/provider_config.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ask
+  module LLM
+    # Shared contract for provider request/response transformation.
+    #
+    # Every provider includes this module and implements the core methods
+    # that define its wire format. The provider's {#chat} method orchestrates
+    # between building requests, making HTTP calls, and parsing responses.
+    #
+    # This separation makes each wire-format concern testable in isolation
+    # and adding a new provider mechanical — you implement four methods and
+    # the provider works.
+    module ProviderConfig
+      # Build a provider-native request payload from internal message format.
+      #
+      # @param messages [Array<Hash>] normalized messages with :role, :content,
+      #   :tool_calls, :tool_call_id
+      # @param model [String] model ID
+      # @param tools [Array<Hash>, nil] tool definitions
+      # @param temperature [Float, nil] sampling temperature
+      # @param stream [Boolean] whether streaming will be used
+      # @param schema [Hash, nil] JSON schema for structured output
+      # @return [Hash] provider-native request body
+      def build_request(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params)
+        raise NotImplementedError, "#{self.class} must implement #build_request"
+      end
+
+      # Parse a non-streaming response into an Ask::Message.
+      #
+      # @param body [Hash] parsed response body
+      # @param model [String] model ID
+      # @return [Ask::Message]
+      def parse_response(body, model)
+        raise NotImplementedError, "#{self.class} must implement #parse_response"
+      end
+
+      # Parse raw stream data and yield Ask::Chunks.
+      #
+      # @param raw [String] raw data from the stream callback
+      # @param stream [Ask::Stream] the accumulating stream
+      # @param model [String] model ID
+      # @yield [Ask::Chunk] optional per-chunk callback
+      def parse_stream(raw, stream, model, &block)
+        raise NotImplementedError, "#{self.class} must implement #parse_stream"
+      end
+
+      # Format tool definitions for this provider's wire format.
+      #
+      # @param tools [Array] tool definitions (Ask::Tool instances or Hashes)
+      # @return [Array] provider-native tool format
+      def format_tools(tools)
+        tools
+      end
+
+      # Format a single message for this provider's wire format.
+      #
+      # @param msg [Hash] message with :role, :content, :tool_calls, :tool_call_id
+      # @return [Hash] provider-native message format
+      def format_message(msg)
+        msg
+      end
+    end
+  end
+end

data/lib/ask/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module LLM
-    VERSION = "0.3.1"
+    VERSION = "0.5.0"
   end
 end

data/lib/ask/provider/anthropic.rb

@@ -5,6 +5,8 @@ module Ask
     # Anthropic Claude API provider.
     class Anthropic < Ask::Provider
       include Ask::LLM::SSEBuffer
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -25,7 +27,7 @@ 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_chat_payload(msgs, model, tools, temperature, stream, schema, **params)
+        payload = build_request(msgs, model:, tools:, temperature:, stream:, schema:, **params)
         if stream
           chat_stream(payload, model, &block)
         else
@@ -40,6 +42,7 @@ module Ask
       def list_models
         response = @http.get("v1/models")
         return [] unless response.success?
+
         response.body["data"].map { |m| Ask::ModelInfo.new(id: m["id"], provider: slug) }
       end
 
@@ -49,63 +52,108 @@ module Ask
       end
 
       class << self
+        def slug; "anthropic"; end
+
         def capabilities
-          { chat: true, streaming: true, tool_calls: true, vision: true, thinking: true, prompt_caching: true, structured_output: true }
+          {
+            chat: true, streaming: true, tool_calls: true, vision: true,
+            thinking: true, prompt_caching: true, structured_output: true
+          }
         end
+
         def configuration_options; %i[api_key api_base]; end
         def configuration_requirements; %i[api_key]; end
-        def slug; "anthropic"; end
-      end
-
-      private
-
-      def normalize_config(config)
-        return config unless config.is_a?(Hash)
-        Ask::LLM::Config.new(
-          api_key: config[:api_key] || config["api_key"] || config[:anthropic_api_key],
-          api_base: config[:api_base] || config["api_base"]
-        )
       end
 
-      def build_http
-        LLM::HTTP.connection(api_base, headers: headers, request: { open_timeout: 30, timeout: 120 })
-      end
+      # --- Config transformation contract ---
 
-      def build_chat_payload(messages, model, tools, temperature, stream, schema, **params)
+      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)
-        tools_array = format_tools(tools) if tools&.any?
 
         payload = {
-          model: model,
+          model:,
           messages: chat_msgs.map { |m| format_message(m) },
           max_tokens: params.delete(:max_tokens) || 4096,
           stream: stream || false
         }
 
         payload[:system] = system_content if system_content
-        payload[:tools] = tools_array if tools_array
+        tool_defs = format_tools(tools) if tools&.any?
+        payload[:tools] = tool_defs if tool_defs
         payload[:temperature] = temperature if temperature
         payload.merge(params)
       end
 
-      def format_system_content(messages)
-        return nil if messages.empty?
-        texts = messages.map { |m| m[:content] || m["content"] }.compact
-        return nil if texts.empty?
-        texts.join("\n")
+      def parse_response(body, model)
+        content_blocks = body["content"] || []
+        text_content = content_blocks.select { |c| c["type"] == "text" }.map { |c| c["text"] }.join
+        tool_blocks = content_blocks.select { |c| c["type"] == "tool_use" }
+        thinking_blocks = content_blocks.select { |c| %w[thinking redacted_thinking].include?(c["type"]) }
+        usage = body["usage"] || {}
+
+        tool_calls = tool_blocks.map do |tb|
+          { id: tb["id"], type: "function", name: tb["name"], arguments: JSON.generate(tb["input"]) }
+        end
+
+        metadata = {
+          model: body["model"] || model,
+          stop_reason: body["stop_reason"],
+          stop_sequence: body["stop_sequence"],
+          input_tokens: usage["input_tokens"],
+          output_tokens: usage["output_tokens"],
+          thinking: thinking_blocks.map { |b| b["thinking"] || b["text"] }.compact.join("\n"),
+          raw: body
+        }.compact
+
+        text = text_content.empty? ? nil : text_content
+        Ask::Message.new(role: :assistant, content: text, tool_calls: tool_calls.empty? ? nil : tool_calls, metadata:)
+      end
+
+      def parse_stream(raw, stream, model, &block)
+        each_sse_event(raw) do |data|
+          parsed = JSON.parse(data) rescue next
+
+          case parsed["type"]
+          when "content_block_delta"
+            delta = parsed.dig("delta")
+            next unless delta
+
+            chunk = Ask::Chunk.new(content: delta["text"])
+            stream.add(chunk)
+            yield chunk if block_given?
+          when "message_stop"
+            usage = parsed["usage"] || parsed["message"]&.dig("usage")
+            if usage
+              chunk = Ask::Chunk.new(finish_reason: "stop", usage:)
+              stream.add(chunk)
+              yield chunk if block_given?
+            end
+          when "message_start"
+            # Handled by content_block_start instead
+          end
+        end
+      end
+
+      def format_tools(tools)
+        tools.map do |t|
+          {
+            name: t.respond_to?(:name) ? t.name : t[:name],
+            description: t.respond_to?(:description) ? t.description : t[:description],
+            input_schema: t.respond_to?(:parameters) ? t.parameters : (t[:parameters] || { type: "object", properties: {} })
+          }
+        end
       end
 
       def format_message(msg)
         role = (msg[:role] || msg["role"]).to_s
         content = msg[:content] || msg["content"]
 
-        # Handle tool calls
         if msg[:tool_calls] || msg["tool_calls"]
           tc = msg[:tool_calls] || msg["tool_calls"]
           return {
-            role: role,
-            content: content,
+            role:,
+            content:,
             tool_calls: tc.map { |t|
               {
                 type: "tool_use",
@@ -117,7 +165,6 @@ module Ask
           }.compact
         end
 
-        # Handle tool results
         if msg[:tool_call_id] || msg["tool_call_id"]
           return {
             role: "user",
@@ -129,7 +176,31 @@ module Ask
           }
         end
 
-        { role: role, content: content }.compact
+        { role:, content: }.compact
+      end
+
+      private
+
+      def normalize_config(config)
+        return config unless config.is_a?(Hash)
+
+        Ask::LLM::Config.new(
+          api_key: config[:api_key] || config["api_key"] || config[:anthropic_api_key],
+          api_base: config[:api_base] || config["api_base"]
+        )
+      end
+
+      def build_http
+        LLM::HTTP.connection(api_base, headers:, request: { open_timeout: 30, timeout: 120 })
+      end
+
+      def format_system_content(messages)
+        return nil if messages.empty?
+
+        texts = messages.map { |m| m[:content] || m["content"] }.compact
+        return nil if texts.empty?
+
+        texts.join("\n")
       end
 
       def parse_json(str)
@@ -138,44 +209,11 @@ module Ask
         {}
       end
 
-      def format_tools(tools)
-        tools.map do |t|
-          {
-            name: t.respond_to?(:name) ? t.name : t[:name],
-            description: t.respond_to?(:description) ? t.description : t[:description],
-            input_schema: t.respond_to?(:parameters) ? t.parameters : (t[:parameters] || { type: "object", properties: {} })
-          }
-        end
-      end
-
       def chat_nonstream(payload, model)
         response = @http.post("v1/messages") { |r| r.body = payload }
         raise LLM::HTTP.map_error(response.status, response.body, provider: "Anthropic") unless response.success?
-        parse_response(response.body, model)
-      end
-
-      def parse_response(body, model)
-        content_blocks = body["content"] || []
-        text_content = content_blocks.select { |c| c["type"] == "text" }.map { |c| c["text"] }.join
-        tool_blocks = content_blocks.select { |c| c["type"] == "tool_use" }
-        thinking_blocks = content_blocks.select { |c| %w[thinking redacted_thinking].include?(c["type"]) }
-        usage = body["usage"] || {}
-
-        tool_calls = tool_blocks.map do |tb|
-          { id: tb["id"], type: "function", name: tb["name"], arguments: JSON.generate(tb["input"]) }
-        end
-
-        metadata = {
-          model: body["model"] || model,
-          stop_reason: body["stop_reason"],
-          stop_sequence: body["stop_sequence"],
-          input_tokens: usage["input_tokens"],
-          output_tokens: usage["output_tokens"],
-          thinking: thinking_blocks.map { |b| b["thinking"] || b["text"] }.compact.join("\n"),
-          raw: body
-        }.compact
 
-        Ask::Message.new(role: :assistant, content: text_content.empty? ? nil : text_content, tool_calls: tool_calls.empty? ? nil : tool_calls, metadata: metadata)
+        parse_response(response.body, model)
       end
 
       def chat_stream(payload, model, &block)
@@ -183,35 +221,13 @@ module Ask
         init_sse_buffer
         response = @http.post("v1/messages") do |req|
           req.body = payload.merge(stream: true)
-          req.options.on_data = proc { |data, _bytes, _env| process_anthropic_chunk(data, stream, model, &block) }
+          req.options.on_data = proc { |data, _bytes, _env| parse_stream(data, stream, model, &block) }
         end
         raise LLM::HTTP.map_error(response.status, JSON.parse(response.body), provider: "Anthropic") unless response.success?
+
         stream.finish!
         stream
       end
-
-      def process_anthropic_chunk(raw, stream, model)
-        each_sse_event(raw) do |data|
-          parsed = JSON.parse(data) rescue next
-
-          case parsed["type"]
-          when "content_block_delta"
-            delta = parsed.dig("delta")
-            next unless delta
-            chunk = Ask::Chunk.new(content: delta["text"])
-            stream.add(chunk)
-            yield chunk if block_given?
-          when "message_stop"
-            usage = parsed["usage"] || parsed["message"]&.dig("usage")
-            if usage
-              chunk = Ask::Chunk.new(finish_reason: "stop", usage: usage)
-              stream.add(chunk)
-              yield chunk if block_given?
-            end
-          when "message_start"
-          end
-        end
-      end
     end
   end
 end

data/lib/ask/provider/bedrock.rb

@@ -5,6 +5,8 @@ module Ask
     # Amazon Bedrock provider using the Converse API.
     # Uses the AWS SDK for authentication (credentials chain: env, ~/.aws, instance profile).
     class Bedrock < Ask::Provider
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -16,7 +18,7 @@ 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_converse_payload(msgs, model, tools, temperature, schema, **params)
+        payload = build_request(msgs, model:, tools:, temperature:, stream:, schema:, **params)
         if stream
           chat_stream(payload, model, &block)
         else
@@ -29,7 +31,6 @@ module Ask
       end
 
       def list_models
-        # Bedrock doesn't have a list models endpoint — rely on model catalog
         []
       end
 
@@ -38,46 +39,84 @@ module Ask
       end
 
       class << self
+        def slug; "bedrock"; end
+
         def capabilities
           { chat: true, streaming: true, tool_calls: true, vision: true }
         end
+
         def configuration_options; %i[region access_key_id secret_access_key session_token]; end
         def configuration_requirements; %i[]; end
-        def slug; "bedrock"; end
       end
 
-      private
+      # --- Config transformation contract ---
 
-      def normalize_config(config)
-        return config unless config.is_a?(Hash)
-        Ask::LLM::Config.new(
-          region: config[:region] || config["region"] || ENV["AWS_REGION"] || "us-east-1",
-          access_key_id: config[:access_key_id] || config["access_key_id"] || ENV["AWS_ACCESS_KEY_ID"],
-          secret_access_key: config[:secret_access_key] || config["secret_access_key"] || ENV["AWS_SECRET_ACCESS_KEY"],
-          session_token: config[:session_token] || config["session_token"] || ENV["AWS_SESSION_TOKEN"]
-        )
-      end
-
-      def build_converse_payload(messages, model, tools, temperature, schema, **params)
+      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" }
         payload = {
           modelId: model,
-          messages: chat_msgs.map { |m| format_bedrock_msg(m) },
+          messages: chat_msgs.map { |m| format_message(m) },
           inferenceConfig: { temperature: temperature || 1.0 }.compact
         }
 
         sys = system_msgs.map { |m| m[:content] || m["content"] }.compact
         payload[:system] = sys.map { |s| { text: s } } if sys.any?
-        if tools&.any?
-          payload[:toolConfig] = { tools: format_bedrock_tools(tools) }
-        end
+        tool_defs = format_tools(tools) if tools&.any?
+        payload[:toolConfig] = { tools: tool_defs } if tool_defs
         if schema
           payload[:inferenceConfig][:response_type] = "json_object"
         end
         payload.merge(params)
       end
 
-      def format_bedrock_msg(msg)
+      def parse_response(body, model)
+        output = body.output
+        return Ask::Message.new(role: :assistant, content: nil) unless output
+
+        msg = output.message
+        text = msg.content&.map { |c| c.text }&.compact&.join
+        tool_uses = msg.content&.select { |c| c.tool_use } || []
+        tool_calls = tool_uses.map do |tu|
+          { id: tu.tool_use.tool_use_id, type: "function", name: tu.tool_use.name, arguments: JSON.generate(tu.tool_use.input.to_h) }
+        end
+
+        usage = body.usage || {}
+        Ask::Message.new(
+          role: :assistant,
+          content: text,
+          tool_calls: tool_calls.empty? ? nil : tool_calls,
+          metadata: {
+            model:,
+            stop_reason: body.stop_reason,
+            input_tokens: usage.input_tokens,
+            output_tokens: usage.output_tokens,
+            raw: body.to_h
+          }
+        )
+      end
+
+      def parse_stream(raw, stream, model, &block)
+        event = raw
+        if event.content_block_delta
+          delta = event.content_block_delta.delta
+          if delta.respond_to?(:text)
+            chunk = Ask::Chunk.new(content: delta.text)
+            stream.add(chunk)
+            yield chunk if block_given?
+          end
+        end
+        if event.message_stop
+          usage = event.message_stop.usage || {}
+          chunk = Ask::Chunk.new(
+            finish_reason: "stop",
+            usage: { input_tokens: usage.input_tokens, output_tokens: usage.output_tokens }
+          )
+          stream.add(chunk)
+          yield chunk if block_given?
+        end
+      end
+
+      def format_message(msg)
         role = (msg[:role] || msg["role"]).to_s
         content = msg[:content] || msg["content"]
         bedrock_role = role == "assistant" ? "assistant" : "user"
@@ -110,12 +149,33 @@ module Ask
         { role: bedrock_role, content: parts }
       end
 
-      def format_bedrock_tools(tools)
+      def format_tools(tools)
         tools.map do |t|
-          { toolSpec: { name: t.respond_to?(:name) ? t.name : t[:name], description: t.respond_to?(:description) ? t.description : t[:description], inputSchema: { json: t.respond_to?(:parameters) ? t.parameters : (t[:parameters] || { type: "object", properties: {} }) } } }
+          {
+            toolSpec: {
+              name: t.respond_to?(:name) ? t.name : t[:name],
+              description: t.respond_to?(:description) ? t.description : t[:description],
+              inputSchema: {
+                json: t.respond_to?(:parameters) ? t.parameters : (t[:parameters] || { type: "object", properties: {} })
+              }
+            }
+          }
         end
       end
 
+      private
+
+      def normalize_config(config)
+        return config unless config.is_a?(Hash)
+
+        Ask::LLM::Config.new(
+          region: config[:region] || config["region"] || ENV["AWS_REGION"] || "us-east-1",
+          access_key_id: config[:access_key_id] || config["access_key_id"] || ENV["AWS_ACCESS_KEY_ID"],
+          secret_access_key: config[:secret_access_key] || config["secret_access_key"] || ENV["AWS_SECRET_ACCESS_KEY"],
+          session_token: config[:session_token] || config["session_token"] || ENV["AWS_SESSION_TOKEN"]
+        )
+      end
+
       def parse_json(str)
         JSON.parse(str)
       rescue JSON::ParserError
@@ -130,45 +190,17 @@ module Ask
       def chat_nonstream(payload, model)
         client = bedrock_client
         resp = client.converse(payload)
-        parse_bedrock_response(resp, model)
+        parse_response(resp, model)
       rescue Aws::Errors::ServiceError => e
         raise LLM::HTTP.map_error(e.status_code&.to_i || 500, { message: e.message }, provider: "Bedrock")
       end
 
-      def parse_bedrock_response(resp, model)
-        output = resp.output
-        return Ask::Message.new(role: :assistant, content: nil) unless output
-
-        msg = output.message
-        text = msg.content&.map { |c| c.text }&.compact&.join
-        tool_uses = msg.content&.select { |c| c.tool_use } || []
-        tool_calls = tool_uses.map do |tu|
-          { id: tu.tool_use.tool_use_id, type: "function", name: tu.tool_use.name, arguments: JSON.generate(tu.tool_use.input.to_h) }
-        end
-
-        usage = resp.usage || {}
-        Ask::Message.new(role: :assistant, content: text, tool_calls: tool_calls.empty? ? nil : tool_calls, metadata: { model: model, stop_reason: resp.stop_reason, input_tokens: usage.input_tokens, output_tokens: usage.output_tokens, raw: resp.to_h })
-      end
-
       def chat_stream(payload, model, &block)
         client = bedrock_client
         stream = Ask::Stream.new
         resp = client.converse_stream(payload)
         resp.stream.each do |event|
-          if event.content_block_delta
-            delta = event.content_block_delta.delta
-            chunk = Ask::Chunk.new(content: delta.text) if delta.respond_to?(:text)
-            if chunk
-              stream.add(chunk)
-              yield chunk if block_given?
-            end
-          end
-          if event.message_stop
-            usage = event.message_stop.usage || {}
-            chunk = Ask::Chunk.new(finish_reason: "stop", usage: { input_tokens: usage.input_tokens, output_tokens: usage.output_tokens })
-            stream.add(chunk)
-            yield chunk if block_given?
-          end
+          parse_stream(event, stream, model, &block)
         end
         stream.finish!
         stream