rubik 0.1.0

data/lib/rubik/llm/openai.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "openai_compatible"
+
+module Rubik
+  module LLM
+    class OpenAIProvider < OpenAICompatibleProvider
+      def initialize(model: "gpt-4o", api_key: nil, api_key_env: "OPENAI_API_KEY", endpoint: "https://api.openai.com/v1/chat/completions", headers: {})
+        super(
+          name: "openai",
+          endpoint: endpoint,
+          api_key: api_key,
+          api_key_env: api_key_env,
+          headers: headers,
+          model: model,
+          default_context_limit: 128_000
+        )
+      end
+    end
+  end
+end

data/lib/rubik/llm/openai_compatible.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "provider"
+require_relative "client"
+require_relative "formatter"
+require "json"
+
+module Rubik
+  module LLM
+    class OpenAICompatibleProvider < BaseProvider
+      attr_reader :name, :endpoint, :api_key, :api_key_env, :headers, :model, :default_context_limit, :default_max_output_tokens, :formatter
+
+      def self.normalize_endpoint(url)
+        raw = url.to_s.strip
+        return raw if raw.empty?
+
+        clean = raw.sub(%r{/+\z}, "")
+        return clean if clean.end_with?("/chat/completions") || clean.end_with?("/completions")
+
+        if clean == "https://api.deepseek.com"
+          "https://api.deepseek.com/chat/completions"
+        elsif clean == "https://api.deepseek.com/v1"
+          "https://api.deepseek.com/v1/chat/completions"
+        elsif ["https://openrouter.ai", "https://openrouter.ai/api"].include?(clean)
+          "https://openrouter.ai/api/v1/chat/completions"
+        elsif clean == "https://api.openai.com"
+          "https://api.openai.com/v1/chat/completions"
+        elsif ["https://api.cline.bot", "https://api.cline.bot/api"].include?(clean)
+          "https://api.cline.bot/api/v1/chat/completions"
+        elsif clean =~ %r{/v\d+\z}i || clean.end_with?("/api")
+          "#{clean}/chat/completions"
+        else
+          "#{clean}/v1/chat/completions"
+        end
+      end
+
+      def initialize(name: "openai_compatible", endpoint: "https://api.openai.com/v1/chat/completions", api_key: nil, api_key_env: nil, headers: {},
+                     model: "gpt-4o", default_context_limit: 32_768, default_max_output_tokens: nil, tool_native: true, formatter: nil)
+        super()
+        @name = name.to_s.downcase
+        @endpoint = self.class.normalize_endpoint(endpoint)
+        @api_key = api_key
+        @api_key_env = api_key_env
+        @headers = headers || {}
+        @model = model.to_s
+        @default_context_limit = default_context_limit.to_i
+        @default_max_output_tokens = default_max_output_tokens&.to_i
+        # Plan 85 D-5: config'ten tool_native:false verilirse prefix'li user mesajı kullanılır.
+        @formatter = formatter || OpenAIFormatter.new(tool_native: tool_native)
+      end
+
+      def complete(messages, opts = {})
+        resolved_key = opts[:api_key] || @api_key || (ENV.fetch(@api_key_env, nil) if @api_key_env)
+        target_model = opts[:model] || @model
+        target_endpoint = self.class.normalize_endpoint(opts[:endpoint] || @endpoint)
+        messages = Rubik::LLM::MessageSanitizer.normalize(messages)
+
+        req_headers = { "Content-Type" => "application/json" }
+        req_headers["Authorization"] = "Bearer #{resolved_key}" if resolved_key && !resolved_key.empty?
+
+        # Merge custom headers (e.g. OpenRouter HTTP-Referer, X-Title)
+        @headers.each do |k, v|
+          req_headers[k.to_s] = v.to_s
+        end
+        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+
+        formatted_msgs = format_messages(messages)
+        payload = build_payload(target_model, formatted_msgs, opts, stream: false)
+
+        timeout = opts[:timeout] || opts[:stream_timeout] || 120
+        open_timeout = opts[:open_timeout] || 15
+
+        res_json = HTTPClient.post_json(
+          target_endpoint,
+          headers: req_headers,
+          payload: payload,
+          timeout: timeout,
+          open_timeout: open_timeout,
+          on_retry: opts[:on_retry]
+        )
+
+        root_json = res_json["data"].is_a?(Hash) && res_json["data"]["choices"] ? res_json["data"] : res_json
+        msg = root_json.dig("choices", 0, "message") || {}
+        text = msg["content"] || ""
+        thought = msg["reasoning_content"] || msg["reasoning"] || msg["thought"]
+        thought = nil if thought.to_s.empty?
+        usage = root_json["usage"] || res_json["usage"] || {}
+
+        raw_tool_calls = msg["tool_calls"] || []
+        parsed_tool_calls = raw_tool_calls.map do |tc|
+          fn = tc["function"] || {}
+          args = fn["arguments"]
+          malformed = nil
+          if args.is_a?(String)
+            begin
+              parsed = JSON.parse(args)
+              if parsed.is_a?(Hash)
+                args = parsed
+              else
+                malformed = args
+                args = {}
+              end
+            rescue JSON::ParserError
+              # Issue #55 3.4: the degrade carries the rejected payload so
+              # the executor can echo it back to the model in the error row.
+              malformed = args
+              args = {}
+            end
+          elsif !args.is_a?(Hash) && !args.nil?
+            malformed = args.to_s
+            args = {}
+          end
+          row = {
+            "id" => tc["id"] || "call_#{rand(1000..9999)}",
+            "tool" => fn["name"],
+            "args" => args || {}
+          }
+          row["malformed_args"] = malformed if malformed
+          row
+        end
+
+        in_tokens = usage["prompt_tokens"] || usage["input_tokens"] || estimate_tokens(messages.map { |m| m[:content] || m["content"] }.join)
+        out_tokens = usage["completion_tokens"] || usage["output_tokens"] || estimate_tokens(text)
+
+        Response.new(
+          text: text,
+          usage: {
+            input_tokens: in_tokens,
+            output_tokens: out_tokens
+          },
+          raw: res_json,
+          tool_calls: parsed_tool_calls,
+          thought: thought
+        )
+      end
+
+      # Streaming variant. Yields Chunks. Without a block, returns an
+      # Enumerator (via `to_enum`) so the caller can chain `.each`.
+      def stream_chat(messages, opts = {}, &block)
+        resolved_key = opts[:api_key] || @api_key || (ENV.fetch(@api_key_env, nil) if @api_key_env)
+        target_model = opts[:model] || @model
+        target_endpoint = self.class.normalize_endpoint(opts[:endpoint] || @endpoint)
+        messages = Rubik::LLM::MessageSanitizer.normalize(messages)
+
+        req_headers = { "Content-Type" => "application/json" }
+        req_headers["Authorization"] = "Bearer #{resolved_key}" if resolved_key && !resolved_key.empty?
+        @headers.each { |k, v| req_headers[k.to_s] = v.to_s }
+        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+
+        formatted_msgs = format_messages(messages)
+        payload = build_payload(target_model, formatted_msgs, opts, stream: true)
+
+        return to_enum(:stream_chat, messages, opts) unless block
+
+        timeout = opts[:idle_timeout] || opts[:timeout] || opts[:stream_timeout] || 120
+        open_timeout = opts[:open_timeout] || 15
+
+        HTTPClient.post_stream_json(
+          target_endpoint,
+          headers: req_headers,
+          payload: payload,
+          timeout: timeout,
+          open_timeout: open_timeout,
+          idle_timeout: opts[:idle_timeout]
+        ) do |event|
+          chunk = @formatter.parse_stream_event(event)
+          next if chunk.nil?
+
+          block.call(chunk)
+        end
+      end
+
+      private
+
+      def reasoning_model?(model_name, opts)
+        return true if opts.key?(:reasoning_effort)
+        return true if model_name.to_s.match?(/\A(o[134](-[a-z0-9]+)?|o1|o3|o4)\b/i)
+
+        false
+      end
+
+      def build_payload(target_model, formatted_msgs, opts, stream: false)
+        payload = {
+          model: target_model,
+          messages: formatted_msgs
+        }
+        payload[:stream] = true if stream
+        payload[:stream_options] = { include_usage: true } if stream && opts[:include_usage] != false
+        payload[:tools] = format_tools(opts[:tools]) if opts[:tools] && !opts[:tools].empty?
+
+        if reasoning_model?(target_model, opts)
+          tokens = opts[:max_completion_tokens] || opts[:max_tokens]
+          payload[:max_completion_tokens] = tokens.to_i if tokens
+          payload[:reasoning_effort] = opts[:reasoning_effort].to_s if opts[:reasoning_effort]
+        else
+          payload[:temperature] = opts[:temperature] if opts.key?(:temperature)
+          if opts.key?(:max_completion_tokens)
+            payload[:max_completion_tokens] = opts[:max_completion_tokens].to_i
+          elsif opts.key?(:max_tokens)
+            payload[:max_tokens] = opts[:max_tokens].to_i
+          end
+        end
+
+        payload
+      end
+
+      def format_messages(messages)
+        @formatter.format_messages(messages)
+      end
+
+      def format_tools(tools)
+        @formatter.format_tools(tools)
+      end
+    end
+  end
+end

data/lib/rubik/llm/provider.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Rubik
+  module LLM
+    # Aggregate response from a blocking `#complete` call.
+    # Holds the full text, final usage stats, raw provider payload, and any tool calls.
+    class Response
+      attr_reader :text, :usage, :raw, :tool_calls, :streamed, :thought
+
+      def initialize(text:, usage: {}, raw: {}, tool_calls: [], streamed: false, thought: nil)
+        @text = text.to_s
+        @usage = usage # { input_tokens: int, output_tokens: int }
+        @raw = raw
+        @tool_calls = tool_calls || []
+        @streamed = streamed == true
+        @thought = thought
+      end
+
+      def tool_calls?
+        !@tool_calls.empty?
+      end
+
+      # deprecated: use #tool_calls?; kept for plugin/provider compatibility
+      alias has_tool_calls? tool_calls?
+    end
+
+    # One streaming chunk delivered by `#stream_chat`. A `Chunk` represents
+    # either an incremental text delta, a tool-use delta, a final usage summary,
+    # or a terminator (`done: true`). Concrete providers normalize provider-
+    # specific SSE/NDJSON events into `Chunk`s.
+    class Chunk
+      attr_reader :text_delta, :tool_use_delta, :usage, :done, :raw, :reasoning_delta
+
+      def initialize(text_delta: nil, tool_use_delta: nil, usage: nil, done: false, raw: {}, reasoning_delta: nil)
+        @text_delta = text_delta
+        @tool_use_delta = tool_use_delta
+        @usage = usage
+        @done = done
+        @raw = raw
+        @reasoning_delta = reasoning_delta
+      end
+
+      def text_delta?
+        !@text_delta.nil?
+      end
+
+      def tool_use_delta?
+        !@tool_use_delta.nil?
+      end
+
+      def reasoning_delta?
+        !@reasoning_delta.nil?
+      end
+
+      def done?
+        @done
+      end
+    end
+
+    class BaseProvider
+      # Abstract: concrete providers must implement one of:
+      #   - `#stream_chat` (preferred — enables both APIs via the `complete` fallback below)
+      #   - `#complete` (legacy blocking-only path)
+      def stream_chat(messages, opts = {}, &block)
+        raise NotImplementedError, "#{self.class} must implement #stream_chat (or #complete)" unless method(:complete).owner != Rubik::LLM::BaseProvider
+
+        res = complete(messages, opts)
+        chunk = if res.is_a?(Rubik::LLM::Response)
+                  tc_deltas = res.tool_calls.map.with_index do |tc, idx|
+                    {
+                      "index" => idx,
+                      "id" => tc["id"] || tc[:id],
+                      "name" => tc["tool"] || tc[:tool] || tc["name"] || tc[:name],
+                      "args" => tc["args"] || tc[:args]
+                    }
+                  end
+                  Chunk.new(
+                    text_delta: res.text.to_s.empty? ? nil : res.text,
+                    tool_use_delta: tc_deltas.empty? ? nil : tc_deltas,
+                    usage: res.usage,
+                    raw: res.raw,
+                    done: true
+                  )
+                else
+                  Chunk.new(text_delta: res.to_s, done: true)
+                end
+        if block
+          block.call(chunk)
+          res
+        else
+          [chunk].to_enum
+        end
+      end
+
+      # Default `#complete` implementation: streams chunks from `#stream_chat`
+      # straight into the incremental Chunk::Assembler (Plan 87 E-2) — the
+      # chunk list is never buffered. Concrete providers may override for a
+      # more efficient batch path, but the streaming implementation alone is
+      # sufficient and must keep tool calls intact — a stream-only provider
+      # routed through batch mode may not lose them.
+      def complete(messages, opts = {})
+        assembler = Rubik::LLM::Chunk::Assembler.new
+        # Re-route through #stream_chat so we never duplicate provider logic.
+        result = stream_chat(messages, opts) { |chunk| assembler.push(chunk) }
+        # If the provider returned an Enumerator (no block given), drain it.
+        result.each { |chunk| assembler.push(chunk) } if result.is_a?(Enumerator) && !assembler.pushed?
+        assembler.finish(streamed: false)
+      end
+
+      def sanitize_prompt(prompt)
+        "<user_input>#{prompt}</user_input>"
+      end
+
+      # Token estimator: 3.8 chars/token matches Rubik::Prompt::TokenEstimator
+      # (CHARS_PER_TOKEN). Both live in the context-budget path; keeping them in
+      # agreement prevents one side from over- or under-counting against the
+      # model's window. The previous 4.0 ratio understated token counts.
+      def estimate_tokens(text)
+        return 0 if text.nil? || text.to_s.empty?
+
+        (text.to_s.length / 3.8).ceil
+      end
+    end
+  end
+end