ask-llm-providers 0.3.0 → 0.4.0

data/lib/ask/provider/ollama.rb

@@ -5,6 +5,8 @@ module Ask
     # Ollama provider for local LLM inference.
     # Connects to a local Ollama server (default: http://localhost:11434).
     class Ollama < Ask::Provider
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -21,13 +23,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 = { model: model, messages: msgs.map { |m| { role: (m[:role] || m["role"]).to_s, content: m[:content] || m["content"] } }, stream: stream || false, options: {} }
-        payload[:options][:temperature] = temperature if temperature
-        if tools&.any?
-          payload[:tools] = tools.map { |t| { type: "function", function: { name: t.respond_to?(:name) ? t.name : t[:name], description: t.respond_to?(:description) ? t.description : t[:description], parameters: t.respond_to?(:parameters) ? t.parameters : (t[:parameters] || {}) } } }
-        end
-        payload.merge(params)
-
+        payload = build_request(msgs, model:, tools:, temperature:, stream:, schema:, **params)
         if stream
           chat_stream(payload, model, &block)
         else
@@ -37,44 +33,116 @@ module Ask
 
       def embed(texts, model:)
         texts = Array(texts)
-        response = @http.post("api/embeddings") { |r| r.body = { model: model, prompt: texts.first } }
+        response = @http.post("api/embeddings") { |r| r.body = { model:, prompt: texts.first } }
         raise LLM::HTTP.map_error(response.status, response.body, provider: "Ollama") unless response.success?
+
         Ask::Result.success(response.body["embedding"])
       end
 
       def list_models
         response = @http.get("api/tags")
         return [] unless response.success?
+
         response.body["models"].map { |m| Ask::ModelInfo.new(id: m["name"], provider: slug) }
       end
 
       class << self
+        def slug; "ollama"; end
+
         def capabilities
           { chat: true, streaming: true, tool_calls: true, embed: true, local: true }
         end
+
         def configuration_options; %i[api_base]; end
         def configuration_requirements; %i[]; end
-        def slug; "ollama"; end
         def local?; true; end
         def assume_models_exist?; true; end
       end
 
+      # --- Config transformation contract ---
+
+      def build_request(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params)
+        payload = {
+          model:,
+          messages: messages.map { |m| format_message(m) },
+          stream: stream || false,
+          options: {}
+        }
+        payload[:options][:temperature] = temperature if temperature
+        tool_defs = format_tools(tools) if tools&.any?
+        payload[:tools] = tool_defs if tool_defs
+        payload.merge(params)
+      end
+
+      def parse_response(body, model)
+        msg = body["message"] || {}
+        Ask::Message.new(
+          role: :assistant,
+          content: msg["content"],
+          metadata: {
+            model: body["model"] || model,
+            done: body["done"],
+            total_duration: body["total_duration"],
+            raw: body
+          }
+        )
+      end
+
+      def parse_stream(raw, stream, model, &block)
+        @_sse_buffer ||= +""
+        @_sse_buffer << raw
+
+        while (line_end = @_sse_buffer.index("\n"))
+          line = @_sse_buffer.slice!(0, line_end + 1).strip
+          next if line.empty?
+
+          parsed = JSON.parse(line) rescue next
+          msg = parsed["message"] || {}
+          chunk = Ask::Chunk.new(content: msg["content"])
+          stream.add(chunk)
+          yield chunk if block_given?
+          if parsed["done"]
+            chunk = Ask::Chunk.new(finish_reason: "stop", usage: { total_duration: parsed["total_duration"] })
+            stream.add(chunk)
+            yield chunk if block_given?
+          end
+        end
+      end
+
+      def format_message(msg)
+        { role: (msg[:role] || msg["role"]).to_s, content: msg[:content] || msg["content"] }
+      end
+
+      def format_tools(tools)
+        tools.map do |t|
+          {
+            type: "function",
+            function: {
+              name: t.respond_to?(:name) ? t.name : t[:name],
+              description: t.respond_to?(:description) ? t.description : t[:description],
+              parameters: t.respond_to?(:parameters) ? t.parameters : (t[:parameters] || {})
+            }
+          }
+        end
+      end
+
       private
 
       def normalize_config(config)
         return config unless config.is_a?(Hash)
+
         Ask::LLM::Config.new(api_base: config[:api_base] || config["api_base"])
       end
 
       def build_http
-        LLM::HTTP.connection(api_base, headers: headers, request: { open_timeout: 5, timeout: 600 })
+        LLM::HTTP.connection(api_base, headers:, request: { open_timeout: 5, timeout: 600 })
       end
 
       def chat_nonstream(payload, model)
         response = @http.post("api/chat") { |r| r.body = payload }
         raise LLM::HTTP.map_error(response.status, response.body, provider: "Ollama") unless response.success?
-        msg = response.body["message"] || {}
-        Ask::Message.new(role: :assistant, content: msg["content"], metadata: { model: response.body["model"] || model, done: response.body["done"], total_duration: response.body["total_duration"], raw: response.body })
+
+        parse_response(response.body, model)
       end
 
       def chat_stream(payload, model, &block)
@@ -82,33 +150,13 @@ module Ask
         @_sse_buffer = +""
         response = @http.post("api/chat") do |req|
           req.body = payload.merge(stream: true)
-          req.options.on_data = proc { |data, _bytes, _env| process_ollama_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, response.body, provider: "Ollama") unless response.success?
+
         stream.finish!
         stream
       end
-
-      def process_ollama_chunk(raw, stream, model)
-        @_sse_buffer ||= +""
-        @_sse_buffer << raw
-
-        while (line_end = @_sse_buffer.index("\n"))
-          line = @_sse_buffer.slice!(0, line_end + 1).strip
-          next if line.empty?
-
-          parsed = JSON.parse(line) rescue next
-          msg = parsed["message"] || {}
-          chunk = Ask::Chunk.new(content: msg["content"])
-          stream.add(chunk)
-          yield chunk if block_given?
-          if parsed["done"]
-            chunk = Ask::Chunk.new(finish_reason: "stop", usage: { total_duration: parsed["total_duration"] })
-            stream.add(chunk)
-            yield chunk if block_given?
-          end
-        end
-      end
     end
   end
 end

data/lib/ask/provider/openai.rb

@@ -7,6 +7,8 @@ module Ask
     # +base_url+ override.
     class OpenAI < Ask::Provider
       include Ask::LLM::SSEBuffer
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         @provider_keys = extract_provider_keys(config)
         config = normalize_config(config)
@@ -29,14 +31,15 @@ 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)
         stream ? chat_stream(payload, model, &block) : chat_nonstream(payload, model)
       end
 
       def embed(texts, model:)
         texts = Array(texts)
-        response = @http.post("embeddings") { |r| r.body = { model: model, input: texts } }
+        response = @http.post("embeddings") { |r| r.body = { model:, input: texts } }
         raise LLM::HTTP.map_error(response.status, response.body, provider: "OpenAI") unless response.success?
+
         embeddings = response.body["data"].map { |d| d["embedding"] }
         Ask::Result.success(embeddings.one? ? embeddings.first : embeddings)
       end
@@ -44,7 +47,10 @@ module Ask
       def list_models
         response = @http.get("models")
         return [] unless response.success?
-        response.body["data"].map { |m| Ask::ModelInfo.new(id: m["id"], provider: slug, metadata: { owned_by: m["owned_by"] }) }
+
+        response.body["data"].map { |m|
+          Ask::ModelInfo.new(id: m["id"], provider: slug, metadata: { owned_by: m["owned_by"] })
+        }
       end
 
       def parse_error(response)
@@ -54,25 +60,112 @@ module Ask
 
       class << self
         def slug; "openai"; end
+
         def capabilities
-          { chat: true, streaming: true, tool_calls: true, vision: true, thinking: true, structured_output: true, embed: true, transcribe: true, paint: true, moderate: true }
+          {
+            chat: true, streaming: true, tool_calls: true, vision: true,
+            thinking: true, structured_output: true, embed: true,
+            transcribe: true, paint: true, moderate: true
+          }
         end
+
         def configuration_options; %i[api_key base_url organization_id project_id]; end
         def configuration_requirements; %i[api_key]; end
         def assume_models_exist?; false; end
       end
 
+      # --- Config transformation contract ---
+
+      def build_request(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params)
+        payload = { model:, messages: format_messages(messages), stream: stream || false }
+        payload[:temperature] = temperature if temperature
+        payload[:tools] = format_tools(tools) if tools&.any?
+        if schema
+          payload[:response_format] = {
+            type: "json_schema",
+            json_schema: { name: "response", schema:, strict: true }
+          }
+        end
+        payload.merge(params)
+      end
+
+      def parse_response(body, model)
+        choice = body.dig("choices", 0)
+        return Ask::Message.new(role: :assistant, content: nil) unless choice
+
+        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
+          }
+        )
+      end
+
+      def parse_stream(raw, stream, model, &block)
+        each_sse_event(raw) do |data|
+          parsed = JSON.parse(data) rescue next
+          choice = parsed.dig("choices", 0) or next
+          delta = choice["delta"] || {}
+          thinking = extract_thinking(parsed, delta)
+          chunk = Ask::Chunk.new(
+            content: delta["content"],
+            tool_calls: parse_stream_tool_calls(delta["tool_calls"]),
+            finish_reason: choice["finish_reason"],
+            usage: parsed["usage"],
+            thinking:
+          )
+          stream.add(chunk)
+          yield chunk if block_given?
+        end
+      end
+
+      def format_tools(tools)
+        tools.map do |t|
+          {
+            type: "function",
+            function: {
+              name: t.respond_to?(:name) ? t.name : t[:name],
+              description: t.respond_to?(:description) ? t.description : t[:description],
+              parameters: t.respond_to?(:parameters) ? t.parameters : t[:parameters]
+            }
+          }
+        end
+      end
+
+      def format_message(msg)
+        role = msg[:role] || msg["role"] || :user
+        { role: role.to_s, content: msg[:content] || msg["content"] }.tap do |fm|
+          if (tc = msg[:tool_calls] || msg["tool_calls"])
+            calls = tc.is_a?(Hash) ? tc.values : tc
+            fm[:tool_calls] = calls.map { |t|
+              id = t.respond_to?(:id) ? t.id : (t[:id] || t["id"])
+              name = t.respond_to?(:name) ? t.name : (t.dig(:function, :name) || t.dig("function", "name") || t[:name])
+              raw_args = t.respond_to?(:arguments) ? t.arguments : (t.dig(:function, :arguments) || t.dig("function", "arguments") || t[:arguments])
+              args = raw_args.is_a?(String) ? raw_args : JSON.generate(raw_args)
+              { id:, type: "function", function: { name:, arguments: args } }
+            }
+          end
+          fm[:tool_call_id] = msg[:tool_call_id] || msg["tool_call_id"] if msg[:tool_call_id] || msg["tool_call_id"]
+        end.compact
+      end
+
       private
 
-      # Extract and store any provider-specific config keys (e.g., opencode_api_key).
-      # These are not part of the standard OpenAI config but are used by subclasses.
       def extract_provider_keys(config)
         return {} unless config.is_a?(Hash)
+
         known = %i[api_key base_url organization_id project_id openai_api_key]
         config.reject { |k, _| known.include?(k.to_sym) }
       end
 
-      # Resolve provider config from passed options, env vars, and ask-auth chain.
       def normalize_config(config)
         return config if !config.is_a?(Hash)
 
@@ -93,57 +186,18 @@ module Ask
       end
 
       def build_http
-        LLM::HTTP.connection(api_base, headers: headers, request: { open_timeout: 30, timeout: 120 })
-      end
-
-      def build_chat_payload(messages, model, tools, temperature, stream, schema, **params)
-        payload = { model: model, messages: format_messages(messages), stream: stream || false }
-        payload[:temperature] = temperature if temperature
-        payload[:tools] = format_tools(tools) if tools&.any?
-        payload[:response_format] = { type: "json_schema", json_schema: { name: "response", schema: schema, strict: true } } if schema
-        payload.merge(params)
+        LLM::HTTP.connection(api_base, headers:, request: { open_timeout: 30, timeout: 120 })
       end
 
       def format_messages(messages)
-        messages.map do |msg|
-          role = msg[:role] || msg["role"] || :user
-          { role: role.to_s, content: msg[:content] || msg["content"] }.tap do |fm|
-            if (tc = msg[:tool_calls] || msg["tool_calls"])
-              calls = tc.is_a?(Hash) ? tc.values : tc
-              fm[:tool_calls] = calls.map { |t|
-                id = t.respond_to?(:id) ? t.id : (t[:id] || t["id"])
-                name = t.respond_to?(:name) ? t.name : (t.dig(:function, :name) || t.dig("function", "name") || t[:name])
-                raw_args = t.respond_to?(:arguments) ? t.arguments : (t.dig(:function, :arguments) || t.dig("function", "arguments") || t[:arguments])
-                args = raw_args.is_a?(String) ? raw_args : JSON.generate(raw_args)
-                { id: id, type: "function", function: { name: name, arguments: args } }
-              }
-            end
-            fm[:tool_call_id] = msg[:tool_call_id] || msg["tool_call_id"] if msg[:tool_call_id] || msg["tool_call_id"]
-          end.compact
-        end
-      end
-
-      def format_tools(tools)
-        tools.map { |t| { type: "function", function: { name: t.respond_to?(:name) ? t.name : t[:name], description: t.respond_to?(:description) ? t.description : t[:description], parameters: t.respond_to?(:parameters) ? t.parameters : t[:parameters] } } }
+        messages.map { |msg| format_message(msg) }
       end
 
       def chat_nonstream(payload, model)
         response = @http.post("chat/completions") { |r| r.body = payload }
         raise LLM::HTTP.map_error(response.status, response.body, provider: "OpenAI") unless response.success?
-        parse_response(response.body, model)
-      end
-
-      def parse_response(body, model)
-        choice = body.dig("choices", 0)
-        return Ask::Message.new(role: :assistant, content: nil) unless choice
-        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 })
-      end
 
-      def parse_tool_calls(calls)
-        return nil unless calls&.any?
-        calls.map { |tc| { id: tc["id"], type: "function", name: tc.dig("function", "name"), arguments: tc.dig("function", "arguments") } }
+        parse_response(response.body, model)
       end
 
       def chat_stream(payload, model, &block)
@@ -151,14 +205,14 @@ module Ask
         init_sse_buffer
         @http.post("chat/completions") do |req|
           req.body = payload.merge(stream: true)
-          req.options.on_data = proc { |data, _bytes, _env| process_chunk(data, stream, model, &block) }
+          req.options.on_data = proc { |data, _bytes, _env| parse_stream(data, stream, model, &block) }
         end.tap { |resp|
           unless resp.success?
             err_body = case resp.body
-            when Hash then resp.body
-            when String then (JSON.parse(resp.body) rescue { "error" => { "message" => "HTTP #{resp.status}: #{resp.body[0..200]}" } })
-            else { "error" => { "message" => "HTTP #{resp.status}: empty response body" } }
-            end
+                       when Hash then resp.body
+                       when String then (JSON.parse(resp.body) rescue { "error" => { "message" => "HTTP #{resp.status}: #{resp.body[0..200]}" } })
+                       else { "error" => { "message" => "HTTP #{resp.status}: empty response body" } }
+                       end
             err_body["error"] ||= {}
             err_body["error"]["_status"] = resp.status
             raise LLM::HTTP.map_error(resp.status, err_body, provider: "OpenAI")
@@ -168,31 +222,28 @@ module Ask
         stream
       end
 
-      def process_chunk(raw, stream, model)
-        each_sse_event(raw) do |data|
-          parsed = JSON.parse(data) rescue next
-          choice = parsed.dig("choices", 0) or next
-          delta = choice["delta"] || {}
-          thinking = extract_thinking(parsed, delta)
-          chunk = Ask::Chunk.new(content: delta["content"], tool_calls: parse_stream_tool_calls(delta["tool_calls"]), finish_reason: choice["finish_reason"], usage: parsed["usage"], thinking: thinking)
-          stream.add(chunk)
-          yield chunk if block_given?
-        end
+      def parse_tool_calls(calls)
+        return nil unless calls&.any?
+
+        calls.map { |tc|
+          { id: tc["id"], type: "function", name: tc.dig("function", "name"), arguments: tc.dig("function", "arguments") }
+        }
+      end
+
+      def parse_stream_tool_calls(calls)
+        return nil unless calls&.any?
+
+        calls.map { |tc|
+          { id: tc["id"], name: tc.dig("function", "name"), arguments: tc.dig("function", "arguments"), index: tc["index"] }
+        }
       end
 
-      # Extract thinking/reasoning content from provider response.
-      # Some providers (Anthropic, DeepSeek) send thinking in a separate field.
       def extract_thinking(parsed, delta)
         delta["reasoning_content"] || delta["thinking"] ||
           parsed.dig("choices", 0, "delta", "reasoning_content") ||
           parsed.dig("choices", 0, "delta", "thinking") ||
           parsed.dig("choices", 0, "reasoning_content")
       end
-
-      def parse_stream_tool_calls(calls)
-        return nil unless calls&.any?
-        calls.map { |tc| { id: tc["id"], name: tc.dig("function", "name"), arguments: tc.dig("function", "arguments"), index: tc["index"] } }
-      end
     end
   end
 end

data/lib/ask-llm-providers.rb

@@ -14,6 +14,9 @@ require_relative "ask/llm/sse_buffer"
 require_relative "ask/llm/catalog"
 require_relative "ask/llm/aliases"
 
+# Provider transformation contract
+require_relative "ask/llm/provider_config"
+
 # Load providers
 require_relative "ask/provider/openai"
 require_relative "ask/provider/anthropic"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-llm-providers
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -194,6 +194,7 @@ files:
 - lib/ask/llm/models/opencode_go.json
 - lib/ask/llm/models/openrouter.json
 - lib/ask/llm/models_schema.json
+- lib/ask/llm/provider_config.rb
 - lib/ask/llm/sse_buffer.rb
 - lib/ask/llm/version.rb
 - lib/ask/provider/anthropic.rb