ask-llm-providers 0.3.0 → 0.4.0

data/lib/ask/provider/cloudflare.rb

@@ -5,6 +5,8 @@ module Ask
     # Cloudflare Workers AI provider. Supports both direct Workers AI and AI Gateway.
     class Cloudflare < Ask::Provider
       include Ask::LLM::SSEBuffer
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -25,15 +27,8 @@ 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)
         endpoint = @config.gateway_id ? "chat/completions" : "run/#{model}"
-        payload = if @config.gateway_id
-                    { model: model, messages: msgs.map { |m| { role: (m[:role] || m["role"]).to_s, content: m[:content] || m["content"] } }, stream: stream || false }
-                  else
-                    { messages: msgs.map { |m| { role: (m[:role] || m["role"]).to_s, content: m[:content] || m["content"] } } }
-                  end
-        payload[:temperature] = temperature if temperature
-        payload.merge(params)
-
         if stream && @config.gateway_id
           chat_stream_gateway(endpoint, payload, model, &block)
         else
@@ -42,7 +37,6 @@ module Ask
       end
 
       def list_models
-        # Workers AI lists models differently — rely on model catalog
         []
       end
 
@@ -52,18 +46,62 @@ module Ask
       end
 
       class << self
+        def slug; "cloudflare"; end
+
         def capabilities
           { chat: true, streaming: true, vision: true }
         end
+
         def configuration_options; %i[api_key account_id gateway_id]; end
         def configuration_requirements; %i[api_key account_id]; end
-        def slug; "cloudflare"; end
+      end
+
+      # --- Config transformation contract ---
+
+      def build_request(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params)
+        if @config.gateway_id
+          payload = {
+            model:,
+            messages: messages.map { |m| format_message(m) },
+            stream: stream || false
+          }
+        else
+          payload = {
+            messages: messages.map { |m| format_message(m) }
+          }
+        end
+        payload[:temperature] = temperature if temperature
+        payload.merge(params)
+      end
+
+      def parse_response(body, model)
+        if @config.gateway_id
+          parse_openai_response(body, model)
+        else
+          result = body["result"] || {}
+          Ask::Message.new(role: :assistant, content: result["response"], metadata: { model:, raw: body })
+        end
+      end
+
+      def parse_stream(raw, stream, model, &block)
+        each_sse_event(raw) do |data|
+          parsed = JSON.parse(data) rescue next
+          delta = parsed.dig("choices", 0, "delta") || {}
+          chunk = Ask::Chunk.new(content: delta["content"])
+          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"] }
       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[:cloudflare_api_key],
           account_id: config[:account_id] || config["account_id"] || config[:cf_account_id],
@@ -72,27 +110,22 @@ module Ask
       end
 
       def build_http
-        LLM::HTTP.connection(api_base, headers: headers, request: { open_timeout: 30, timeout: 120 })
-      end
-
-      def chat_nonstream(endpoint, payload, model)
-        response = @http.post(endpoint) { |r| r.body = payload }
-        raise LLM::HTTP.map_error(response.status, response.body, provider: "Cloudflare") unless response.success?
-
-        body = response.body
-        if @config.gateway_id
-          parse_openai_response(body, model)
-        else
-          result = body["result"] || {}
-          Ask::Message.new(role: :assistant, content: result["response"], metadata: { model: model, raw: body })
-        end
+        LLM::HTTP.connection(api_base, headers:, request: { open_timeout: 30, timeout: 120 })
       end
 
       def parse_openai_response(body, model)
         choice = body.dig("choices", 0)
         return Ask::Message.new(role: :assistant, content: nil) unless choice
+
         msg = choice["message"]
-        Ask::Message.new(role: :assistant, content: msg["content"], metadata: { model: model, finish_reason: choice["finish_reason"], raw: body })
+        Ask::Message.new(role: :assistant, content: msg["content"], metadata: { model:, finish_reason: choice["finish_reason"], raw: body })
+      end
+
+      def chat_nonstream(endpoint, payload, model)
+        response = @http.post(endpoint) { |r| r.body = payload }
+        raise LLM::HTTP.map_error(response.status, response.body, provider: "Cloudflare") unless response.success?
+
+        parse_response(response.body, model)
       end
 
       def chat_stream_gateway(endpoint, payload, model, &block)
@@ -100,22 +133,13 @@ module Ask
         init_sse_buffer
         response = @http.post(endpoint) do |req|
           req.body = payload.merge(stream: true)
-          req.options.on_data = proc { |data, _bytes, _env| process_stream_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: "Cloudflare") unless response.success?
+
         stream.finish!
         stream
       end
-
-      def process_stream_chunk(raw, stream, model)
-        each_sse_event(raw) do |data|
-          parsed = JSON.parse(data) rescue next
-          delta = parsed.dig("choices", 0, "delta") || {}
-          chunk = Ask::Chunk.new(content: delta["content"])
-          stream.add(chunk)
-          yield chunk if block_given?
-        end
-      end
     end
   end
 end

data/lib/ask/provider/google.rb

@@ -5,6 +5,8 @@ module Ask
     # Google Gemini API provider. Also supports Vertex AI via GCP service account auth.
     class Google < Ask::Provider
       include Ask::LLM::SSEBuffer
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -30,7 +32,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)
         path = chat_path(model)
         if stream
           chat_stream(path, payload, model, &block)
@@ -41,8 +43,11 @@ module Ask
 
       def embed(texts, model:)
         texts = Array(texts)
-        response = @http.post("models/#{model}:batchEmbedContents") { |r| r.body = { requests: texts.map { |t| { model: "models/#{model}", content: { parts: [{ text: t }] } } } } }
+        response = @http.post("models/#{model}:batchEmbedContents") { |r|
+          r.body = { requests: texts.map { |t| { model: "models/#{model}", content: { parts: [{ text: t }] } } } }
+        }
         raise LLM::HTTP.map_error(response.status, response.body, provider: "Google") unless response.success?
+
         embeddings = response.body.dig("embeddings") || []
         Ask::Result.success(embeddings.map { |e| e["values"] })
       end
@@ -50,7 +55,10 @@ module Ask
       def list_models
         response = @http.get("models") { |r| r.params["key"] = @config.api_key if @config.api_key }
         return [] unless response.success?
-        (response.body["models"] || []).map { |m| Ask::ModelInfo.new(id: m["name"].sub("models/", ""), provider: slug) }
+
+        (response.body["models"] || []).map { |m|
+          Ask::ModelInfo.new(id: m["name"].sub("models/", ""), provider: slug)
+        }
       end
 
       def parse_error(response)
@@ -59,40 +67,23 @@ module Ask
       end
 
       class << self
+        def slug; "gemini"; end
+
         def capabilities
-          { chat: true, streaming: true, tool_calls: true, vision: true, structured_output: true, embed: true, file_upload: true }
+          {
+            chat: true, streaming: true, tool_calls: true, vision: true,
+            structured_output: true, embed: true, file_upload: true
+          }
         end
+
         def configuration_options; %i[api_key access_token vertex_token project_id api_base]; end
         def configuration_requirements; %i[api_key]; end
-        def slug; "gemini"; end
-      end
-
-      private
-
-      def normalize_config(config)
-        return config unless config.is_a?(Hash)
-        key = config[:api_key] || config["api_key"] || config[:gemini_api_key]
-        Ask::LLM::Config.new(
-          api_key: key,
-          access_token: config[:access_token] || config["access_token"],
-          vertex_token: config[:vertex_token] || config["vertex_token"],
-          project_id: config[:project_id] || config["project_id"],
-          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
 
-      def chat_path(model)
-        model_id = model.respond_to?(:id) ? model.id : model.to_s
-        "models/#{model_id}:generateContent"
-      end
+      # --- Config transformation contract ---
 
-      def build_chat_payload(messages, model, tools, temperature, stream, schema, **params)
-        contents = format_contents(messages)
-        payload = { contents: contents, systemInstruction: format_system(messages) }
+      def build_request(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params)
+        payload = { contents: format_contents(messages), systemInstruction: format_system(messages) }
 
         if tools&.any?
           payload[:tools] = [{ functionDeclarations: tools.map { |t| format_tool(t) } }]
@@ -107,19 +98,46 @@ module Ask
         payload.merge(params)
       end
 
-      def format_contents(messages)
-        messages.reject { |m| (m[:role] || m["role"]).to_s == "system" }.map { |m| format_content(m) }
+      def parse_response(body, model)
+        candidate = body.dig("candidates", 0)
+        return Ask::Message.new(role: :assistant, content: nil) unless candidate
+
+        content = candidate.dig("content", "parts")&.map { |p| p["text"] }&.compact&.join
+        fc = candidate.dig("content", "parts")&.select { |p| p["functionCall"] } || []
+        tool_calls = fc.map do |p|
+          f = p["functionCall"]
+          { id: SecureRandom.hex(8), type: "function", name: f["name"], arguments: JSON.generate(f["args"] || {}) }
+        end
+
+        usage = body["usageMetadata"] || {}
+        Ask::Message.new(
+          role: :assistant,
+          content:,
+          tool_calls: tool_calls.empty? ? nil : tool_calls,
+          metadata: {
+            model:,
+            finish_reason: candidate["finishReason"],
+            input_tokens: usage["promptTokenCount"],
+            output_tokens: usage["candidatesTokenCount"],
+            raw: body
+          }
+        )
       end
 
-      def format_system(messages)
-        sys = messages.select { |m| (m[:role] || m["role"]).to_s == "system" }
-        return nil if sys.empty?
-        texts = sys.map { |m| m[:content] || m["content"] }.compact
-        return nil if texts.empty?
-        { parts: texts.map { |t| { text: t } } }
+      def parse_stream(raw, stream, model, &block)
+        each_sse_event(raw) do |data|
+          parsed = JSON.parse(data) rescue next
+          candidate = parsed.dig("candidates", 0) or next
+          part = candidate.dig("content", "parts", 0)
+          next unless part
+
+          chunk = Ask::Chunk.new(content: part["text"])
+          stream.add(chunk)
+          yield chunk if block_given?
+        end
       end
 
-      def format_content(msg)
+      def format_message(msg)
         role = (msg[:role] || msg["role"]).to_s
         content = msg[:content] || msg["content"]
         google_role = role == "assistant" ? "model" : role
@@ -127,7 +145,6 @@ module Ask
         parts = []
         parts << { text: content } if content
 
-        # Handle tool calls
         if msg[:tool_calls] || msg["tool_calls"]
           (msg[:tool_calls] || msg["tool_calls"]).each do |tc|
             parts << {
@@ -139,7 +156,6 @@ module Ask
           end
         end
 
-        # Handle tool results
         if msg[:tool_call_id] || msg["tool_call_id"]
           parts << {
             functionResponse: {
@@ -149,11 +165,59 @@ module Ask
           }
         end
 
-        { role: google_role, parts: parts }
+        { role: google_role, parts: }
+      end
+
+      def format_tools(tools)
+        tools.map { |t|
+          {
+            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
+
+      private
+
+      def normalize_config(config)
+        return config unless config.is_a?(Hash)
+
+        key = config[:api_key] || config["api_key"] || config[:gemini_api_key]
+        Ask::LLM::Config.new(
+          api_key: key,
+          access_token: config[:access_token] || config["access_token"],
+          vertex_token: config[:vertex_token] || config["vertex_token"],
+          project_id: config[:project_id] || config["project_id"],
+          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 chat_path(model)
+        model_id = model.respond_to?(:id) ? model.id : model.to_s
+        "models/#{model_id}:generateContent"
+      end
+
+      def format_contents(messages)
+        messages.reject { |m| (m[:role] || m["role"]).to_s == "system" }.map { |m| format_message(m) }
+      end
+
+      def format_system(messages)
+        sys = messages.select { |m| (m[:role] || m["role"]).to_s == "system" }
+        return nil if sys.empty?
+
+        texts = sys.map { |m| m[:content] || m["content"] }.compact
+        return nil if texts.empty?
+
+        { parts: texts.map { |t| { text: t } } }
       end
 
       def format_tool(t)
-        { 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] || {}) }
+        format_tools([t]).first
       end
 
       def parse_json(str)
@@ -168,22 +232,8 @@ module Ask
           req.params["key"] = @config.api_key if @config.api_key
         end
         raise LLM::HTTP.map_error(response.status, response.body, provider: "Google") unless response.success?
-        parse_response(response.body, model)
-      end
-
-      def parse_response(body, model)
-        candidate = body.dig("candidates", 0)
-        return Ask::Message.new(role: :assistant, content: nil) unless candidate
 
-        content = candidate.dig("content", "parts")&.map { |p| p["text"] }&.compact&.join
-        fc = candidate.dig("content", "parts")&.select { |p| p["functionCall"] } || []
-        tool_calls = fc.map do |p|
-          f = p["functionCall"]
-          { id: SecureRandom.hex(8), type: "function", name: f["name"], arguments: JSON.generate(f["args"] || {}) }
-        end
-
-        usage = body["usageMetadata"] || {}
-        Ask::Message.new(role: :assistant, content: content, tool_calls: tool_calls.empty? ? nil : tool_calls, metadata: { model: model, finish_reason: candidate["finishReason"], input_tokens: usage["promptTokenCount"], output_tokens: usage["candidatesTokenCount"], raw: body })
+        parse_response(response.body, model)
       end
 
       def chat_stream(path, payload, model, &block)
@@ -192,24 +242,13 @@ module Ask
         response = @http.post(path) do |req|
           req.body = payload
           req.params["key"] = @config.api_key if @config.api_key
-          req.options.on_data = proc { |data, _bytes, _env| process_google_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: "Google") unless response.success?
+
         stream.finish!
         stream
       end
-
-      def process_google_chunk(raw, stream, model)
-        each_sse_event(raw) do |data|
-          parsed = JSON.parse(data) rescue next
-          candidate = parsed.dig("candidates", 0) or next
-          part = candidate.dig("content", "parts", 0)
-          next unless part
-          chunk = Ask::Chunk.new(content: part["text"])
-          stream.add(chunk)
-          yield chunk if block_given?
-        end
-      end
     end
   end
 end

data/lib/ask/provider/mistral.rb

@@ -4,6 +4,8 @@ module Ask
   module Providers
     # Mistral AI provider. Uses OpenAI-compatible wire format.
     class Mistral < Ask::Provider
+      include Ask::LLM::ProviderConfig
+
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -19,15 +21,20 @@ module Ask
       end
 
       def chat(messages, model:, tools: nil, temperature: nil, stream: nil, schema: nil, **params, &block)
-        # Reuse OpenAI provider's logic since Mistral is OpenAI-compatible
-        openai = Providers::OpenAI.new(api_key: @config.api_key, base_url: api_base)
-        openai.chat(messages, model: model, tools: tools, temperature: temperature, stream: stream, schema: schema, **params, &block)
+        msgs = messages.is_a?(Ask::Conversation) ? messages.to_a : messages
+        payload = build_request(msgs, model:, tools:, temperature:, stream:, schema:, **params)
+        if stream
+          chat_stream(payload, model, &block)
+        else
+          chat_nonstream(payload, model)
+        end
       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: "Mistral") unless response.success?
+
         embeddings = response.body["data"].map { |d| d["embedding"] }
         Ask::Result.success(embeddings.one? ? embeddings.first : embeddings)
       end
@@ -35,6 +42,7 @@ 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) }
       end
 
@@ -44,18 +52,94 @@ module Ask
       end
 
       class << self
+        def slug; "mistral"; end
+
         def capabilities
           { chat: true, streaming: true, tool_calls: true, structured_output: true, embed: true }
         end
+
         def configuration_options; %i[api_key api_base]; end
         def configuration_requirements; %i[api_key]; end
-        def slug; "mistral"; 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
+        }
+        payload[:temperature] = temperature if temperature
+        tool_defs = format_tools(tools) if tools&.any?
+        payload[:tools] = tool_defs if tool_defs
+        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"] || {}
+          chunk = Ask::Chunk.new(
+            content: delta["content"],
+            tool_calls: parse_stream_tool_calls(delta["tool_calls"]),
+            finish_reason: choice["finish_reason"],
+            usage: parsed["usage"]
+          )
+          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"] }
+      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_key: config[:api_key] || config["api_key"] || config[:mistral_api_key],
           api_base: config[:api_base] || config["api_base"]
@@ -63,7 +147,73 @@ module Ask
       end
 
       def build_http
-        LLM::HTTP.connection(api_base, headers: headers, request: { open_timeout: 30, timeout: 120 })
+        LLM::HTTP.connection(api_base, headers:, request: { open_timeout: 30, timeout: 120 })
+      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
+
+      def each_sse_event(raw)
+        @_sse_buffer ||= +""
+        @_sse_buffer << raw
+
+        while (event_end = @_sse_buffer.index("\n\n"))
+          event_data = @_sse_buffer.slice!(0, event_end + 2).strip
+          next if event_data.empty?
+
+          data_content = extract_data(event_data)
+          next if data_content.empty?
+          break if data_content == "[DONE]"
+
+          yield data_content
+        end
+      end
+
+      def extract_data(event_data)
+        content = +""
+        event_data.each_line do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?(":")
+          if line.start_with?("data: ")
+            content << line[6..]
+          elsif line.start_with?("data:")
+            content << line[5..]
+          end
+        end
+        content
+      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: "Mistral") unless response.success?
+
+        parse_response(response.body, model)
+      end
+
+      def chat_stream(payload, model, &block)
+        stream = Ask::Stream.new
+        @_sse_buffer = +""
+        response = @http.post("chat/completions") do |req|
+          req.body = payload.merge(stream: true)
+          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: "Mistral") unless response.success?
+
+        stream.finish!
+        stream
       end
     end
   end