ask-llm-providers 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ca86d4692c3bdd09134c7f3b356c62ee924e55751dfa9e5a443aceb05828c59
-  data.tar.gz: c6267cbaa6513caf8159d2fec37906ce6eae362e4067f3524c5db1f4888d41b3
+  metadata.gz: d05af6c6de7917048a5b86d1fea1c0acfd3ef820c71c7672f19375a5024fe138
+  data.tar.gz: 3cf21a18360b52e5fd44d01359c0312e05163a234407f07b515f325abf9ebee7
 SHA512:
-  metadata.gz: dd36e3ba8058b2bb33d8076c2feb00a09ee8a7ffd8e41a0a28888394711c775fdecf3a261f1bfe3eebce72358e6a255e9134e030c07bedd3edd3d39dfc76cf02
-  data.tar.gz: 77c177f586e71e71c2abf11c328e0649a5182f53c50be5fa880c66654de5a267082d8bc75d5809ea0292d41c7ee00dc2f08a6a1eefb03db15e1cb100debcf01d
+  metadata.gz: 7e91f0e672b159d2d8c7af3de889d0155ede9fc60191b38a78c4f34e675892f0c867ef30dfd6d7feac055d04ef0be347f06fa9888b8d3282b48d34d26dcd59c5
+  data.tar.gz: 813cc7dc3ca391fca712dae4c59a356019ef363d34a1b2a19376faf1a0b0ac2f2dddb065bd842b64adb7909045936d048bceadc47d2f07de3377115e748f2f08

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/version.rb

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

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.15
 platform: ruby
 authors:
 - Kaka Ruto
@@ -188,7 +188,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