ask-llm-providers 0.1.13 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a74bb6d0bdeec2f86e1ec7e352c121e2c69c44837293e545d78a6a189552c0
-  data.tar.gz: 654529c6b21c4ba943f8d0bcf8eb7361a209ab470b918b4bc77f3afc4ba37321
+  metadata.gz: 8ca86d4692c3bdd09134c7f3b356c62ee924e55751dfa9e5a443aceb05828c59
+  data.tar.gz: c6267cbaa6513caf8159d2fec37906ce6eae362e4067f3524c5db1f4888d41b3
 SHA512:
-  metadata.gz: d9b3fa669828ecadda4d43b6295019b9a47af5aef9cfeb2f1289fc8025a7275e41d83ab6f1a8154964872b7ff3055f54601b73df10e84cc4f7c2318912a191f9
-  data.tar.gz: 633f84f8cfcbfa71d266bbb8ca6c813157e0a312f7cebd69879cf2d5ee53b81cc63d4733ad967290742bf03b781c142197f9c5b23446f5ea72929689b6e262ac
+  metadata.gz: dd36e3ba8058b2bb33d8076c2feb00a09ee8a7ffd8e41a0a28888394711c775fdecf3a261f1bfe3eebce72358e6a255e9134e030c07bedd3edd3d39dfc76cf02
+  data.tar.gz: 77c177f586e71e71c2abf11c328e0649a5182f53c50be5fa880c66654de5a267082d8bc75d5809ea0292d41c7ee00dc2f08a6a1eefb03db15e1cb100debcf01d

data/lib/ask/llm/version.rb

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

data/lib/ask/provider/deepseek.rb

@@ -21,6 +21,17 @@ module Ask
         h
       end
 
+      # DeepSeek requires reasoning_content in every assistant message
+      # that includes tool_calls. Override format_messages to inject it.
+      def format_messages(messages)
+        super.map do |fm|
+          if fm[:role] == "assistant" && fm[:tool_calls]
+            fm[:reasoning_content] = fm[:reasoning_content] || ""
+          end
+          fm
+        end
+      end
+
       class << self
         def slug; "deepseek"; end
         def configuration_options; %i[api_key base_url]; end

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

@@ -0,0 +1,201 @@
+# 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-llm-providers
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
 platform: ruby
 authors:
 - Kaka Ruto
@@ -188,6 +188,7 @@ 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