rubik 0.1.0

data/lib/rubik/llm/formatter.rb

@@ -0,0 +1,450 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../platform"
+
+module Rubik
+  module LLM
+    class BaseFormatter
+      def self.format_messages(messages)
+        new.format_messages(messages)
+      end
+
+      def self.format_tools(tools)
+        new.format_tools(tools)
+      end
+
+      # Parse one streaming event into a `Chunk`. The `event` argument is the
+      # `{ type:, data: }` Hash produced by `SSEParser` (SSE providers) or
+      # `{ raw: <json-string> }` (NDJSON providers). Returns nil to indicate
+      # the event should be skipped (e.g. ping, malformed JSON, comment).
+      def self.parse_stream_event(event)
+        new.parse_stream_event(event)
+      end
+
+      def format_messages(messages)
+        messages
+      end
+
+      def format_tools(tools)
+        tools
+      end
+
+      # Default: no streaming. Subclasses override.
+      def parse_stream_event(_event)
+        nil
+      end
+
+      protected
+
+      def extract_role(message)
+        (message[:role] || message["role"]).to_s
+      end
+
+      def extract_content(message)
+        message[:content] || message["content"] || ""
+      end
+
+      def extract_tool_calls(message)
+        message[:tool_calls] || message["tool_calls"]
+      end
+
+      def extract_call_id(item, default = "call_default")
+        (item[:tool_call_id] || item["tool_call_id"] || item[:call_id] || item["call_id"] || item[:id] || item["id"] || default).to_s
+      end
+    end
+
+    class OpenAIFormatter < BaseFormatter
+      # Plan 85 D-5 (opsiyonel): tool-native olmayan OpenAI-compatible modeller için
+      # prefix'li user mesajı üretmeyi aç/kapat. Varsayılan true → mevcut davranış.
+      attr_accessor :tool_native
+
+      def initialize(tool_native: true)
+        super()
+        @tool_native = tool_native
+      end
+
+      def format_messages(messages)
+        return [] if messages.nil?
+
+        formatted = []
+        messages.each_with_index do |m, idx|
+          role = extract_role(m)
+          content = extract_content(m)
+          tcs = extract_tool_calls(m)
+
+          if role == "assistant" && tcs
+            formatted_tcs = tcs.map do |tc|
+              fn_args = tc["args"] || tc[:args] || {}
+              args_str = fn_args.is_a?(String) ? Rubik::Platform.clean_utf8(fn_args) : Rubik::Platform.safe_json_generate(fn_args)
+              call_id = extract_call_id(tc, "call_#{rand(1000..9999)}")
+              {
+                "id" => call_id,
+                "type" => "function",
+                "function" => {
+                  "name" => tc["tool"] || tc[:tool],
+                  "arguments" => args_str
+                }
+              }
+            end
+            msg = { "role" => "assistant", "tool_calls" => formatted_tcs }
+            msg["content"] = content if content && !content.empty?
+            formatted << msg
+          elsif role == "tool"
+            if @tool_native
+              # Standart OpenAI tool result formatı (mevcut davranış)
+              call_id = extract_call_id(m, "call_default")
+              formatted << {
+                "role" => "tool",
+                "tool_call_id" => call_id,
+                "content" => content
+              }
+            else
+              # Tool-native olmayan modeller için prefix'li user mesajı (Plan 85 D-5)
+              tool_name = (m[:tool_name] || m["tool_name"]).to_s
+              label = tool_name.empty? ? "Tool" : tool_name
+              formatted << { "role" => "user", "content" => "[Tool result: #{label}]\n#{content}" }
+            end
+          elsif role == "system"
+            formatted << if idx.zero?
+                           { "role" => "system", "content" => content }
+                         else
+                           # Strict endpoints like DeepSeek/Groq reject mid-conversation system messages.
+                           { "role" => "user", "content" => "[System Notification]\n#{content}" }
+                         end
+          else
+            formatted << {
+              "role" => role,
+              "content" => content
+            }
+          end
+        end
+        formatted
+      end
+
+      def format_tools(tools)
+        return [] if tools.nil?
+
+        tools.map do |tool|
+          if tool.key?(:function) || tool.key?("function")
+            tool
+          else
+            fn_name = tool[:name] || tool["name"]
+            fn_desc = tool[:description] || tool["description"]
+            fn_params = tool[:params_schema] || tool["params_schema"] || tool[:parameters] || tool["parameters"] || { type: "object", properties: {} }
+
+            {
+              type: "function",
+              function: {
+                name: fn_name,
+                description: fn_desc,
+                parameters: fn_params
+              }
+            }
+          end
+        end
+      end
+
+      # OpenAI SSE streaming event → Chunk.
+      # OpenAI emits `data: {json}` lines for each delta and a
+      # terminator `data: [DONE]` line. Each event Hash has
+      # { type: "message", data: <json or "[DONE]"> }.
+      def parse_stream_event(event)
+        data = event[:data].to_s
+        return nil if data.empty?
+        return Chunk.new(done: true) if data.strip == "[DONE]"
+
+        parsed = JSON.parse(data)
+        choices = parsed["choices"] || []
+
+        usage = nil
+        done = false
+        if parsed["usage"].is_a?(Hash)
+          u = parsed["usage"].dup
+          u[:input_tokens] = u.delete("prompt_tokens") || u[:input_tokens] || 0
+          u[:output_tokens] = u.delete("completion_tokens") || u[:output_tokens] || 0
+          usage = u
+          done = true
+        end
+
+        if choices.empty?
+          return usage ? Chunk.new(usage: usage, done: done, raw: parsed) : nil
+        end
+
+        choice = choices[0] || {}
+        delta = choice["delta"] || {}
+        text = delta["content"] && !delta["content"].to_s.empty? ? delta["content"].to_s : nil
+
+        reasoning = delta["reasoning_content"] || delta["reasoning"] || delta["thought"]
+        reasoning_text = reasoning && !reasoning.to_s.empty? ? reasoning.to_s : nil
+
+        tool_deltas = nil
+        if delta["tool_calls"] && !delta["tool_calls"].empty?
+          tool_deltas = delta["tool_calls"].map do |tc|
+            {
+              "index" => tc["index"],
+              "id" => tc["id"],
+              "name" => tc.dig("function", "name"),
+              "arguments_delta" => tc.dig("function", "arguments").to_s
+            }
+          end
+        end
+
+        done = true if choice["finish_reason"]
+
+        Chunk.new(
+          text_delta: text,
+          tool_use_delta: tool_deltas,
+          usage: usage,
+          done: done,
+          raw: parsed,
+          reasoning_delta: reasoning_text
+        )
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    class AnthropicFormatter < BaseFormatter
+      def format_messages(messages)
+        return [] if messages.nil?
+
+        formatted = []
+        messages.each do |m|
+          role = extract_role(m)
+          content = extract_content(m)
+          tcs = extract_tool_calls(m)
+
+          if role == "assistant" && tcs
+            content_blocks = []
+            content_blocks << { "type" => "text", "text" => content } if content && !content.empty?
+            (tcs || []).each do |tc|
+              call_id = extract_call_id(tc, "call_#{rand(1000..9999)}")
+              content_blocks << {
+                "type" => "tool_use",
+                "id" => call_id,
+                "name" => tc["tool"] || tc[:tool],
+                "input" => tc["args"] || tc[:args] || {}
+              }
+            end
+            formatted << { "role" => "assistant", "content" => content_blocks }
+          elsif role == "tool"
+            call_id = extract_call_id(m, "call_default")
+            block = { "type" => "tool_result", "tool_use_id" => call_id, "content" => content }
+            prev = formatted.last
+            # Plan 61 D-6: parallel tool results must land in ONE user
+            # message — the API rejects consecutive user turns.
+            if prev.is_a?(Hash) && prev["role"] == "user" && prev["content"].is_a?(Array) &&
+               !prev["content"].empty? && prev["content"].first.is_a?(Hash) &&
+               prev["content"].first["type"] == "tool_result"
+              prev["content"] << block
+            else
+              formatted << { "role" => "user", "content" => [block] }
+            end
+          else
+            prev = formatted.last
+            # Consecutive plain same-role turns (compaction summaries,
+            # restored histories) are merged to keep strict role alternation.
+            if prev.is_a?(Hash) && prev["role"] == role && !role.to_s.empty? && role != "system"
+              if prev["content"].is_a?(String)
+                prev["content"] = "#{prev['content']}\n\n#{content}"
+              elsif !content.to_s.empty?
+                # A tool_result block array must never be stringified —
+                # fold the plain text in as an extra content block.
+                prev["content"] << { "type" => "text", "text" => content }
+              end
+            else
+              formatted << { "role" => role, "content" => content }
+            end
+          end
+        end
+        formatted
+      end
+
+      def format_tools(tools)
+        return [] if tools.nil?
+
+        tools.map do |tool|
+          if tool.key?(:input_schema) || tool.key?("input_schema")
+            tool
+          else
+            fn = tool[:function] || tool["function"]
+            name = fn ? (fn[:name] || fn["name"]) : (tool[:name] || tool["name"])
+            desc = fn ? (fn[:description] || fn["description"]) : (tool[:description] || tool["description"])
+            schema = if fn
+                       fn[:parameters] || fn["parameters"]
+                     else
+                       tool[:params_schema] || tool["params_schema"] || tool[:parameters] || tool["parameters"] || {}
+                     end
+            {
+              name: name,
+              description: desc,
+              input_schema: schema
+            }
+          end
+        end
+      end
+
+      # Anthropic SSE streaming event → Chunk.
+      # Event types: message_start, content_block_start, content_block_delta,
+      # content_block_stop, message_delta, message_stop, ping, error
+      def parse_stream_event(event)
+        type = event[:type].to_s
+        data = event[:data].to_s
+        return nil if type == "ping"
+
+        if type == "error"
+          parsed_err = begin
+            JSON.parse(data)
+          rescue JSON::ParserError
+            { "error" => { "message" => data } }
+          end
+          msg = parsed_err.dig("error", "message") || parsed_err["message"] || "Anthropic streaming error"
+          raise ClientError, msg
+        end
+
+        parsed = JSON.parse(data)
+        chunk = nil
+
+        case type
+        when "content_block_delta"
+          delta = parsed["delta"] || {}
+          if delta["type"] == "text_delta" && delta["text"]
+            chunk = Chunk.new(text_delta: delta["text"].to_s)
+          elsif delta["type"] == "thinking_delta" && delta["thinking"]
+            chunk = Chunk.new(reasoning_delta: delta["thinking"].to_s)
+          elsif delta["type"] == "input_json_delta"
+            chunk = Chunk.new(
+              tool_use_delta: {
+                "index" => parsed["index"],
+                "arguments_delta" => delta["partial_json"].to_s
+              }
+            )
+          end
+        when "message_delta"
+          usage = parsed["usage"] || parsed.dig("delta", "usage")
+          chunk = Chunk.new(usage: usage, raw: parsed)
+        when "message_stop"
+          chunk = Chunk.new(done: true, raw: parsed)
+        when "message_start", "content_block_start", "content_block_stop"
+          chunk = Chunk.new(raw: parsed)
+        end
+
+        chunk || Chunk.new(raw: parsed)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    class OllamaFormatter < BaseFormatter
+      def format_messages(messages)
+        return [] if messages.nil?
+
+        messages.map do |m|
+          role = extract_role(m)
+          content = extract_content(m)
+          tcs = extract_tool_calls(m)
+
+          if role == "tool"
+            tool_name = (m[:tool_name] || m["tool_name"]).to_s
+            label = tool_name.empty? ? "Tool" : tool_name
+            # Prefix ile modelin tool sonucunu kullanıcı mesajıyla karıştırmaması
+            # sağlanır. Ollama native tool calling'i olmayan modeller için açık
+            # etiket kritik (Plan 85 D-1).
+            prefixed_content = "[Tool result: #{label}]\n#{content}"
+            {
+              "role" => "user",
+              "content" => prefixed_content
+            }
+          elsif role == "assistant" && tcs
+            formatted_tcs = tcs.map do |tc|
+              fn_args = tc["args"] || tc[:args] || {}
+              {
+                "function" => {
+                  "name" => tc["tool"] || tc[:tool],
+                  "arguments" => fn_args
+                }
+              }
+            end
+            msg = { "role" => "assistant", "tool_calls" => formatted_tcs }
+            msg["content"] = content if content && !content.empty?
+            msg
+          else
+            {
+              "role" => role,
+              "content" => content
+            }
+          end
+        end
+      end
+
+      def format_tools(tools)
+        return [] if tools.nil?
+
+        tools.map do |tool|
+          if tool.key?(:function) || tool.key?("function")
+            tool
+          else
+            {
+              type: "function",
+              function: {
+                name: tool[:name] || tool["name"],
+                description: tool[:description] || tool["description"],
+                parameters: tool[:params_schema] || tool["params_schema"] || tool[:parameters] || tool["parameters"]
+              }
+            }
+          end
+        end
+      end
+
+      # Ollama NDJSON streaming line → Chunk.
+      # `/api/chat` lines carry { "message": { "role", "content",
+      # "tool_calls"? } } while legacy `/api/generate` lines carry a
+      # top-level "response" — both shapes are supported (Plan 61 B15/B4:
+      # the chat shape used to be dropped entirely, losing streamed text
+      # AND native tool calls). The final line has "done": true plus
+      # eval_count / prompt_eval_count.
+      def parse_stream_event(event)
+        data = event[:data].to_s
+        return nil if data.empty?
+
+        parsed = JSON.parse(data)
+        chat_msg = parsed["message"].is_a?(Hash) ? parsed["message"] : {}
+
+        text = chat_msg["content"]
+        text = parsed["response"] if text.to_s.empty?
+        text = nil if text.to_s.empty?
+
+        tool_deltas = nil
+        if chat_msg["tool_calls"].is_a?(Array) && !chat_msg["tool_calls"].empty?
+          tool_deltas = chat_msg["tool_calls"].map.with_index do |tc, idx|
+            fn = tc["function"] || {}
+            delta = { "index" => idx, "id" => tc["id"], "name" => fn["name"] }
+            # Ollama sends complete argument objects, not partial JSON.
+            args = fn["arguments"]
+            delta["args"] = args if args.is_a?(Hash) || args.is_a?(String)
+            delta
+          end
+        end
+
+        done = parsed["done"] == true
+        usage = nil
+        if done
+          usage = {
+            input_tokens: parsed["prompt_eval_count"] || 0,
+            output_tokens: parsed["eval_count"] || 0
+          }
+        end
+        Chunk.new(
+          text_delta: text,
+          tool_use_delta: tool_deltas,
+          usage: usage,
+          done: done,
+          raw: parsed
+        )
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/rubik/llm/message_sanitizer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../prompt/conversation_rows"
+
+module Rubik
+  module LLM
+    # Normalizes internal message histories into provider-safe shapes
+    # (Plan 61 D-6). Strict endpoints (Anthropic Messages API, some
+    # OpenAI-compatible gateways) reject histories with consecutive
+    # same-role turns — which this runtime can produce through compaction
+    # summaries, notification messages and restored sessions.
+    #
+    # Rules:
+    # * Consecutive plain same-role messages are folded together with a
+    #   blank-line join (user+user, assistant+assistant, system+system).
+    # * An assistant message carrying tool_calls always starts a new unit
+    #   (it pairs with the following role:"tool" results).
+    # * role:"tool" messages are never merged — each carries its own
+    #   tool_call_id; strict providers coalesce them at format time.
+    module MessageSanitizer
+      module_function
+
+      def normalize(messages)
+        return [] if messages.nil?
+
+        merged = []
+        messages.each do |msg|
+          unless Prompt::ConversationRows.row?(msg)
+            Rubik::Platform.debug_warn("MessageSanitizer: dropping non-hash message #{msg.inspect}")
+            next
+          end
+
+          role = Prompt::ConversationRows.role_of(msg)
+          prev = merged.last
+          if mergeable?(prev, role, msg)
+            merge_into!(prev, msg)
+          else
+            merged << msg.dup
+          end
+        end
+        merged
+      end
+
+      def mergeable?(prev, role, msg)
+        return false if prev.nil? || prev.empty?
+        return false if Prompt::ConversationRows.role_of(prev) != role
+        return false if role == "tool" || role.empty?
+
+        # An assistant message carrying tool_calls always opens a fresh
+        # atomic unit — folding it into the previous turn would break the
+        # tool_calls → tool results pairing.
+        current_tcs = msg[:tool_calls] || msg["tool_calls"]
+        return false if role == "assistant" && current_tcs.is_a?(Array) && !current_tcs.empty?
+
+        true
+      end
+
+      def merge_into!(prev, msg)
+        content_key = Prompt::ConversationRows.content_key_of(prev)
+        prev[content_key] = join_content(prev[content_key], Prompt::ConversationRows.content_of(msg))
+
+        tcs = msg[:tool_calls] || msg["tool_calls"]
+        return if tcs.nil? || (tcs.is_a?(Array) && tcs.empty?)
+
+        tc_key = Prompt::ConversationRows.resolve_key(prev, :tool_calls)
+        prev[tc_key] = Array(prev[tc_key] || []) + Array(tcs)
+      rescue StandardError => e
+        # Warn once per process: normalize runs on every provider call, so an
+        # unguarded warn would spam one line per message for a poisoned history.
+        unless @merge_failure_warned
+          @merge_failure_warned = true
+          Rubik::Log.warn(:llm, "message merge failed (#{e.class}: #{e.message}); tool_calls/content may be dropped")
+        end
+        nil
+      end
+
+      def join_content(first, second)
+        first_str = first.to_s
+        second_str = second.to_s
+        return second_str if first_str.strip.empty?
+        return first_str if second_str.strip.empty?
+
+        "#{first_str}\n\n#{second_str}"
+      end
+    end
+  end
+end

data/lib/rubik/llm/ollama.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative "provider"
+require_relative "client"
+require_relative "formatter"
+require "json"
+
+module Rubik
+  module LLM
+    class OllamaProvider < BaseProvider
+      attr_reader :name, :endpoint, :model, :num_ctx, :formatter, :headers
+      alias host endpoint
+
+      def initialize(name: nil, endpoint: nil, host: nil, model: "llama3", num_ctx: nil, formatter: OllamaFormatter.new, headers: {})
+        super()
+        @name = name.to_s.downcase
+        @endpoint = endpoint || host || "http://localhost:11434"
+        @model = model
+        @num_ctx = num_ctx
+        @formatter = formatter || OllamaFormatter.new
+        @headers = headers || {}
+      end
+
+      def complete(messages, opts = {})
+        target_model = opts[:model] || @model
+        chat_endpoint = @endpoint.end_with?("/api/chat") ? @endpoint : "#{@endpoint}/api/chat"
+
+        req_headers = {}
+        @headers.each { |k, v| req_headers[k.to_s] = v.to_s }
+        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+
+        payload = {
+          model: target_model,
+          messages: format_messages(messages),
+          stream: false
+        }
+        apply_num_ctx!(payload, opts)
+
+        payload[:tools] = format_tools(opts[:tools]) if opts[:tools] && !opts[:tools].empty?
+
+        timeout = opts[:timeout] || opts[:stream_timeout] || 120
+        open_timeout = opts[:open_timeout] || 15
+
+        res_json = HTTPClient.post_json(
+          chat_endpoint,
+          headers: req_headers,
+          payload: payload,
+          timeout: timeout,
+          open_timeout: open_timeout,
+          on_retry: opts[:on_retry]
+        )
+
+        msg_content = res_json.dig("message", "content") || ""
+        in_tokens = res_json["prompt_eval_count"] || estimate_tokens(messages.map { |m| m[:content] || m["content"] }.join)
+        out_tokens = res_json["eval_count"] || estimate_tokens(msg_content)
+
+        raw_tool_calls = res_json.dig("message", "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
+
+        Response.new(
+          text: msg_content,
+          usage: { input_tokens: in_tokens, output_tokens: out_tokens },
+          raw: res_json,
+          tool_calls: parsed_tool_calls
+        )
+      end
+
+      # Streaming variant. Ollama uses NDJSON — one JSON object per line.
+      # The provider's HTTPClient call already speaks NDJSON (we just don't
+      # frame events into \n\n blocks on the client side); each line is fed
+      # to the formatter via the same `{ type:, data: }` event shape, which
+      # the OllamaFormatter normalizes into a Chunk.
+      def stream_chat(messages, opts = {}, &block)
+        target_model = opts[:model] || @model
+        chat_endpoint = @endpoint.end_with?("/api/chat") ? @endpoint : "#{@endpoint}/api/chat"
+
+        payload = {
+          model: target_model,
+          messages: format_messages(messages),
+          stream: true
+        }
+        apply_num_ctx!(payload, opts)
+        payload[:tools] = format_tools(opts[:tools]) if opts[:tools] && !opts[:tools].empty?
+
+        return to_enum(:stream_chat, messages, opts) unless block
+
+        req_headers = {}
+        @headers.each { |k, v| req_headers[k.to_s] = v.to_s }
+        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+
+        timeout = opts[:timeout] || opts[:stream_timeout] || 120
+        open_timeout = opts[:open_timeout] || 15
+
+        HTTPClient.post_stream_json(
+          chat_endpoint,
+          headers: req_headers,
+          payload: payload,
+          timeout: timeout,
+          open_timeout: open_timeout,
+          terminator: SSEParser::NDJSON_TERMINATOR
+        ) do |event|
+          # Ollama's NDJSON may not include event types. The `data` field
+          # carries the full JSON line, and `type` is empty. Forward both
+          # shapes — the formatter ignores `type` and parses `data`.
+          chunk = @formatter.parse_stream_event(event)
+          next if chunk.nil?
+
+          block.call(chunk)
+        end
+      end
+
+      private
+
+      # Plan 61 D-1: without num_ctx the Ollama server silently clips the
+      # prompt head to its own default window (~2-4k tokens) — the model
+      # never sees the system prompt or earlier turns. Precedence: explicit
+      # request opt > provider-level config (providers.<name>.num_ctx) >
+      # the orchestrator's compaction target (opts[:context_limit]).
+      def apply_num_ctx!(payload, opts)
+        num_ctx = opts[:num_ctx] || @num_ctx || opts[:context_limit]
+        max_tokens = opts[:max_tokens] || opts[:max_output_tokens]
+        opts_hash = {}
+        opts_hash[:num_ctx] = num_ctx.to_i if num_ctx&.to_i&.positive?
+        opts_hash[:num_predict] = max_tokens.to_i if max_tokens&.to_i&.positive?
+        payload[:options] = opts_hash unless opts_hash.empty?
+      end
+
+      def format_messages(messages)
+        @formatter.format_messages(messages)
+      end
+
+      def format_tools(tools)
+        @formatter.format_tools(tools)
+      end
+    end
+  end
+end