ask-llm-providers 0.1.14 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ca86d4692c3bdd09134c7f3b356c62ee924e55751dfa9e5a443aceb05828c59
-  data.tar.gz: c6267cbaa6513caf8159d2fec37906ce6eae362e4067f3524c5db1f4888d41b3
+  metadata.gz: 93b16f8655292838315d314b3a57dd94368182372a421f88b3911d6a9b171488
+  data.tar.gz: 59fe887341f72aa42c765da7bda10e93454aa8b8cc25bfd1ebb85e316d401a17
 SHA512:
-  metadata.gz: dd36e3ba8058b2bb33d8076c2feb00a09ee8a7ffd8e41a0a28888394711c775fdecf3a261f1bfe3eebce72358e6a255e9134e030c07bedd3edd3d39dfc76cf02
-  data.tar.gz: 77c177f586e71e71c2abf11c328e0649a5182f53c50be5fa880c66654de5a267082d8bc75d5809ea0292d41c7ee00dc2f08a6a1eefb03db15e1cb100debcf01d
+  metadata.gz: 8627f783b0e7848373fd9358c13e48db978fe728b043c7c5e9f23fd4425c631203c19eae980d870e1f683cdd16d803199cf7b8cba7b8bb0b5f4bfe7b09ffc1ad
+  data.tar.gz: 13cbee9ed69bca82917cbfd060e6f8f8a5130c717b975b886f3851203dada60da1ac081200c2613efa53b7625e744baedc639e06e2ee60bc990faa91c14bccfa

data/lib/ask/llm/http.rb

@@ -15,10 +15,12 @@ module Ask
 
       # Map an HTTP exception or error response to the appropriate Ask::Error.
       def self.map_error(status, body, provider:)
+        body = JSON.parse(body) rescue body if body.is_a?(String)
         message = extract_error_message(body, status) || "HTTP #{status} from #{provider}"
 
         # Check for context length exceeded regardless of status code
-        if body&.dig("error", "code") == "context_length_exceeded"
+        err_code = body.respond_to?(:dig) ? body.dig("error", "code") : nil
+        if err_code == "context_length_exceeded"
           return Ask::ContextLengthExceeded.new("#{provider}: #{message}")
         end
 
@@ -36,11 +38,15 @@ module Ask
       def self.extract_error_message(body, status)
         return nil unless body
 
-        body.dig("error", "message") ||
-          body.dig("error", "msg") ||
-          body.dig("error", "error") ||
-          body["message"] ||
+        if body.respond_to?(:dig)
+          body.dig("error", "message") ||
+            body.dig("error", "msg") ||
+            body.dig("error", "error") ||
+            body["message"] ||
+            body.to_s
+        else
           body.to_s
+        end
       end
     end
   end

data/lib/ask/llm/sse_buffer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ask
+  module LLM
+    module SSEBuffer
+      def init_sse_buffer
+        @_sse_buffer = +""
+      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
+
+      private
+
+      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
+    end
+  end
+end

data/lib/ask/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module LLM
-    VERSION = "0.1.14"
+    VERSION = "0.1.16"
   end
 end

data/lib/ask/provider/anthropic.rb

@@ -4,6 +4,7 @@ module Ask
   module Providers
     # Anthropic Claude API provider.
     class Anthropic < Ask::Provider
+      include Ask::LLM::SSEBuffer
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -179,6 +180,7 @@ module Ask
 
       def chat_stream(payload, model, &block)
         stream = Ask::Stream.new
+        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) }
@@ -189,39 +191,24 @@ module Ask
       end
 
       def process_anthropic_chunk(raw, stream, model)
-        raw.each_line do |line|
-          line = line.strip
-          next if line.empty? || line.start_with?(":")
-          next unless line.start_with?("event:") || line.start_with?("data:")
-
-          if line.start_with?("data: ")
-            data = line[6..]
-            begin
-              parsed = JSON.parse(data)
-            rescue JSON::ParserError
-              next
-            end
-
-            case parsed["type"]
-            when "content_block_delta"
-              delta = parsed.dig("delta")
-              next unless delta
-              chunk = Ask::Chunk.new(
-                content: delta["text"],
-                finish_reason: delta["type"] == "thinking_delta" ? nil : nil
-              )
+        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?
-            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"
-              # Message started — no content yet
             end
+          when "message_start"
           end
         end
       end

data/lib/ask/provider/cloudflare.rb

@@ -4,6 +4,7 @@ module Ask
   module Providers
     # Cloudflare Workers AI provider. Supports both direct Workers AI and AI Gateway.
     class Cloudflare < Ask::Provider
+      include Ask::LLM::SSEBuffer
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -96,6 +97,7 @@ module Ask
 
       def chat_stream_gateway(endpoint, payload, model, &block)
         stream = Ask::Stream.new
+        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) }
@@ -106,11 +108,7 @@ module Ask
       end
 
       def process_stream_chunk(raw, stream, model)
-        raw.each_line do |line|
-          line = line.strip
-          next unless line.start_with?("data: ")
-          data = line[6..]
-          next if data == "[DONE]"
+        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"])

data/lib/ask/provider/google.rb

@@ -4,6 +4,7 @@ module Ask
   module Providers
     # Google Gemini API provider. Also supports Vertex AI via GCP service account auth.
     class Google < Ask::Provider
+      include Ask::LLM::SSEBuffer
       def initialize(config = {})
         config = normalize_config(config)
         super(config)
@@ -187,6 +188,7 @@ module Ask
 
       def chat_stream(path, payload, model, &block)
         stream = Ask::Stream.new
+        init_sse_buffer
         response = @http.post(path) do |req|
           req.body = payload
           req.params["key"] = @config.api_key if @config.api_key
@@ -198,10 +200,7 @@ module Ask
       end
 
       def process_google_chunk(raw, stream, model)
-        raw.each_line do |line|
-          next unless line.start_with?("data: ")
-          data = line[6..]
-          next if data.strip == "[DONE]"
+        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)

data/lib/ask/provider/ollama.rb

@@ -79,6 +79,7 @@ module Ask
 
       def chat_stream(payload, model, &block)
         stream = Ask::Stream.new
+        @_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) }
@@ -89,7 +90,13 @@ module Ask
       end
 
       def process_ollama_chunk(raw, stream, model)
-        raw.each_line do |line|
+        @_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"])

data/lib/ask/provider/openai.rb

@@ -6,6 +6,7 @@ module Ask
     # (OpenRouter, DeepSeek, Azure, XAI, Perplexity, GPUStack, etc.) via
     # +base_url+ override.
     class OpenAI < Ask::Provider
+      include Ask::LLM::SSEBuffer
       def initialize(config = {})
         @provider_keys = extract_provider_keys(config)
         config = normalize_config(config)
@@ -148,6 +149,7 @@ module Ask
 
       def chat_stream(payload, model, &block)
         stream = Ask::Stream.new
+        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) }
@@ -167,12 +169,8 @@ module Ask
         stream
       end
 
-
       def process_chunk(raw, stream, model)
-        raw.each_line do |line|
-          line = line.strip
-          next if line.empty? || line.start_with?(":") || !line.start_with?("data: ")
-          data = line[6..]; next if data == "[DONE]"
+        each_sse_event(raw) do |data|
           parsed = JSON.parse(data) rescue next
           choice = parsed.dig("choices", 0) or next
           delta = choice["delta"] || {}

data/lib/ask-llm-providers.rb

@@ -10,6 +10,7 @@ require "base64"
 # Common infrastructure
 require_relative "ask/llm/config"
 require_relative "ask/llm/http"
+require_relative "ask/llm/sse_buffer"
 require_relative "ask/llm/models/openai"
 
 # Load providers

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-llm-providers
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.16
 platform: ruby
 authors:
 - Kaka Ruto
@@ -178,6 +178,7 @@ files:
 - lib/ask/llm/config.rb
 - lib/ask/llm/http.rb
 - lib/ask/llm/models/openai.rb
+- lib/ask/llm/sse_buffer.rb
 - lib/ask/llm/version.rb
 - lib/ask/provider/anthropic.rb
 - lib/ask/provider/bedrock.rb
@@ -188,7 +189,6 @@ files:
 - lib/ask/provider/mistral.rb
 - lib/ask/provider/ollama.rb
 - lib/ask/provider/openai.rb
-- lib/ask/provider/openai.rb.bak
 - lib/ask/provider/opencode.rb
 - lib/ask/provider/opencode_go.rb
 - lib/ask/provider/openrouter.rb

data/lib/ask/provider/openai.rb.bak

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Providers
-    # OpenAI API provider. Also handles all OpenAI-compatible providers
-    # (OpenRouter, DeepSeek, Azure, XAI, Perplexity, GPUStack, etc.) via
-    # +base_url+ override.
-    class OpenAI < Ask::Provider
-      def initialize(config = {})
-        @provider_keys = extract_provider_keys(config)
-        config = normalize_config(config)
-        super(config)
-        @http = build_http
-      end
-
-      def api_base
-        @config.base_url || "https://api.openai.com/v1"
-      end
-
-      def headers
-        key = @config.api_key || @config.openai_api_key
-        h = { "Content-Type" => "application/json" }
-        h["Authorization"] = "Bearer #{key}" if key
-        h["OpenAI-Organization"] = @config.organization_id if @config.organization_id
-        h["OpenAI-Project"] = @config.project_id if @config.project_id
-        h
-      end
-
-      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)
-        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 } }
-        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
-
-      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"] }) }
-      end
-
-      def parse_error(response)
-        body = response.body rescue nil
-        body&.dig("error", "message") || body&.dig("error", "code")
-      end
-
-      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 }
-        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
-
-      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)
-
-        slug = self.class.slug
-        env_key = ENV["#{slug.upcase}_API_KEY"]
-        auth_key = Ask::Auth.resolve(:"#{slug}_api_key") rescue nil
-
-        merged = {
-          api_key: config[:api_key] || config["api_key"] ||
-                   config[:"#{slug}_api_key"] || config[:openai_api_key] ||
-                   env_key || auth_key,
-          base_url: config[:base_url] || config["base_url"] ||
-                    ENV["#{slug.upcase}_API_BASE"],
-          organization_id: config[:organization_id] || config["organization_id"],
-          project_id: config[:project_id] || config["project_id"]
-        }.merge(config.reject { |k, _| %i[api_key base_url organization_id project_id openai_api_key].include?(k.to_sym) })
-
-        Ask::LLM::Config.new(merged)
-      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)
-      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] } } }
-      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") } }
-      end
-
-      def chat_stream(payload, model, &block)
-        stream = Ask::Stream.new
-        @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) }
-        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
-            err_body["error"] ||= {}
-            err_body["error"]["_status"] = resp.status
-            raise LLM::HTTP.map_error(resp.status, err_body, provider: "OpenAI")
-          end
-        }
-        stream.finish!
-        stream
-      end
-
-
-      def process_chunk(raw, stream, model)
-        raw.each_line do |line|
-          line = line.strip
-          next if line.empty? || line.start_with?(":") || !line.start_with?("data: ")
-          data = line[6..]; next if data == "[DONE]"
-          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
-      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