solid_loop 0.0.4

data/app/queries/solid_loop/admin/loops_query.rb

@@ -0,0 +1,38 @@
+module SolidLoop
+  module Admin
+    class LoopsQuery < BaseQuery
+      def initialize(params, scope: SolidLoop::Loop.order(created_at: :desc))
+        super
+      end
+
+      def call
+        filtered = scope
+        filtered = filtered.where(id: normalized_loop_id) if normalized_loop_id
+        filtered = filtered.where(status: status) if status
+        filtered = filtered.where(agent_class_name: agent_class_name) if agent_class_name
+        filtered
+      end
+
+      def exact_match
+        return unless normalized_loop_id
+
+        SolidLoop::Loop.find_by(id: normalized_loop_id)
+      end
+
+      private
+
+      def normalized_loop_id
+        @normalized_loop_id ||= present_param(:loop_id)&.delete_prefix("#")
+      end
+
+      def status
+        value = present_param(:status)
+        value if SolidLoop::Loop.statuses.key?(value)
+      end
+
+      def agent_class_name
+        present_param(:agent_class_name)
+      end
+    end
+  end
+end

data/app/queries/solid_loop/admin/mcp_inbound_sessions_query.rb

@@ -0,0 +1,31 @@
+module SolidLoop
+  module Admin
+    class McpInboundSessionsQuery < BaseQuery
+      def initialize(params, scope: SolidLoop::McpInboundSession.order(created_at: :desc))
+        super
+      end
+
+      def call
+        filtered = scope
+        filtered = filtered.where(server_name: server_name) if server_name
+        filtered = filtered.where("session_id ILIKE ?", "%#{session_id}%") if session_id
+        filtered = filtered.where("principal ILIKE ?", "%#{principal}%") if principal
+        filtered
+      end
+
+      private
+
+      def server_name
+        present_param(:server_name)
+      end
+
+      def session_id
+        present_param(:session_id)
+      end
+
+      def principal
+        present_param(:principal)
+      end
+    end
+  end
+end

data/app/queries/solid_loop/admin/mcp_sessions_query.rb

@@ -0,0 +1,26 @@
+module SolidLoop
+  module Admin
+    class McpSessionsQuery < BaseQuery
+      def initialize(params, scope: SolidLoop::McpSession.order(created_at: :desc))
+        super
+      end
+
+      def call
+        filtered = scope
+        filtered = filtered.where(mcp_name: mcp_name) if mcp_name
+        filtered = filtered.where("session_id ILIKE ?", "%#{session_id}%") if session_id
+        filtered
+      end
+
+      private
+
+      def mcp_name
+        present_param(:mcp_name)
+      end
+
+      def session_id
+        present_param(:session_id)
+      end
+    end
+  end
+end

data/app/queries/solid_loop/admin/mcp_tools_query.rb

@@ -0,0 +1,26 @@
+module SolidLoop
+  module Admin
+    class McpToolsQuery < BaseQuery
+      def initialize(params, scope: SolidLoop::McpTool.order(created_at: :desc))
+        super
+      end
+
+      def call
+        filtered = scope
+        filtered = filtered.where(name: name) if name
+        filtered = filtered.where(mcp_session_id: mcp_session_id) if mcp_session_id
+        filtered
+      end
+
+      private
+
+      def name
+        present_param(:name)
+      end
+
+      def mcp_session_id
+        present_param(:mcp_session_id)
+      end
+    end
+  end
+end

data/app/queries/solid_loop/admin/messages_query.rb

@@ -0,0 +1,37 @@
+module SolidLoop
+  module Admin
+    class MessagesQuery < BaseQuery
+      def initialize(params, scope: SolidLoop::Message.order(created_at: :desc))
+        super
+      end
+
+      def call
+        filtered = scope
+        filtered = filtered.where(loop_id: loop_id) if loop_id
+        filtered = filtered.where(role: role) if role
+        filtered = filtered.where.not(tool_call_id: nil) if has_tool_call?
+        filtered = filtered.where.not(reasoning_content: [ nil, "" ]) if has_reasoning?
+        filtered
+      end
+
+      private
+
+      def loop_id
+        present_param(:loop_id)
+      end
+
+      def role
+        value = present_param(:role)
+        value if SolidLoop::Message.roles.key?(value)
+      end
+
+      def has_tool_call?
+        present_param(:has_tool_call) == "1"
+      end
+
+      def has_reasoning?
+        present_param(:has_reasoning) == "1"
+      end
+    end
+  end
+end

data/app/queries/solid_loop/admin/tool_calls_query.rb

@@ -0,0 +1,34 @@
+module SolidLoop
+  module Admin
+    class ToolCallsQuery < BaseQuery
+      def initialize(params, scope: SolidLoop::ToolCall.order(created_at: :desc))
+        super
+      end
+
+      def call
+        filtered = scope
+        filtered = filtered.joins(:message).where(solid_loop_messages: { loop_id: loop_id }) if loop_id
+        filtered = filtered.where(function_name: function_name) if function_name
+        filtered = filtered.where(is_success: success) unless success.nil?
+        filtered
+      end
+
+      private
+
+      def loop_id
+        present_param(:loop_id)
+      end
+
+      def function_name
+        present_param(:function_name)
+      end
+
+      def success
+        case present_param(:success)
+        when "1", "true", "success" then true
+        when "0", "false", "failed" then false
+        end
+      end
+    end
+  end
+end

data/app/services/solid_loop/adapters/native.rb

@@ -0,0 +1,170 @@
+module SolidLoop
+  module Adapters
+    class Native
+      attr_writer :on_chunk_proc
+
+      def initialize(base_url:, api_token:, payload:, streaming: false, reasoning_strategies: [], dialect: nil, model_name: nil, fallback_messages_text: "", read_timeout: nil, cancellation_check: nil)
+        @base_url = base_url
+        @api_token = api_token
+        @payload = payload
+        @streaming = streaming
+        @reasoning_strategies = Array(reasoning_strategies)
+        @model_name = model_name
+        @fallback_messages_text = fallback_messages_text
+        # Single coherent read-timeout source: when no explicit
+        # read_timeout is passed, fall back to the SAME `default_read_timeout` the
+        # lease is derived from — NOT the unrelated LlmCompletionJob::READ_TIMEOUT
+        # constant. Previously a configured `default_read_timeout = 60` yielded a
+        # 60s-derived lease but a 600s Faraday timeout, so a healthy turn could run
+        # ~600s while its lease assumed ~60s (invariant lease > client timeout
+        # broken). Reading the config here keeps the derived lease and the actual
+        # HTTP timeout coherent.
+        @read_timeout = read_timeout || SolidLoop.config.default_read_timeout
+        @cancellation_check = cancellation_check
+
+        # Use provided dialect or default to OpenAI
+        @dialect = dialect || SolidLoop::Dialects::OpenAi.new
+
+        @log_buffer = StringIO.new
+        @debug_buffer = StringIO.new
+
+        @last_ui_update_at = Time.current
+        @first_token_at = nil
+        @content_started_at = nil
+        @aggregator = SolidLoop::SseStreamAggregator.new
+      end
+
+      def call
+        @request_started_at = Time.current
+
+        @dialect.apply_reasoning_strategies!(@payload[:messages], @reasoning_strategies)
+        final_payload = @dialect.respond_to?(:render_payload) ? @dialect.render_payload(@payload) : @payload
+        url = build_url
+
+        headers = { "Content-Type" => "application/json" }
+        headers.merge!(@dialect.auth_headers(@api_token))
+
+        wire_logger = Logger.new(@log_buffer)
+        wire_logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
+
+        conn = Faraday.new(url: url) do |f|
+          f.options.timeout = @read_timeout
+          f.options.open_timeout = 10
+          f.response :logger, wire_logger, bodies: { request: true, response: true }, headers: true
+          f.adapter Faraday.default_adapter
+        end
+
+        caller_thread = Thread.current
+        stop_watchdog = false
+        _watchdog = build_watchdog(caller_thread, stop_flag: -> { stop_watchdog })
+
+        begin
+          @response = conn.post do |req|
+            req.headers = headers
+            req.body = final_payload.to_json
+
+            if @streaming
+              req.options.on_data = proc do |chunk, _overall_received_bytes|
+                @debug_buffer.write(chunk)
+                @first_token_at ||= Time.current
+                data = parse_stream_chunk(chunk)
+                emit_chunk_event(data)
+              end
+            end
+          end
+        ensure
+          stop_watchdog = true
+        end
+
+        duration = (Time.current - @request_started_at).to_f
+        Rails.logger.info "LLM Request Finished (Duration: #{duration.round(2)}s)"
+
+        # Final aggregation result
+        raw_data =
+          if @streaming && @aggregator.result.present?
+            @aggregator.result
+          else
+            JSON.parse(@response.body) rescue {}
+          end
+
+        # DIALECT IS THE BOSS OF NORMALIZATION
+        # We pass fallback strings for token estimation if provider is silent
+        normalized_data = @dialect.normalize_response(
+          raw_data,
+          fallback_text: extract_full_text(raw_data),
+          fallback_messages_text: @fallback_messages_text
+        )
+
+        {
+          response: @response,
+          normalized_data: normalized_data,
+          duration: duration,
+          aggregator: @aggregator,
+          log: @log_buffer.string,
+          debug_log: @debug_buffer.string
+        }
+      end
+
+      def build_url
+        base = @dialect.completion_url(@base_url)
+        if @dialect.is_a?(SolidLoop::Dialects::Gemini)
+          method = @streaming ? "streamGenerateContent" : "generateContent"
+          "#{base}/#{@model_name}:#{method}?key=#{@api_token}"
+        else
+          base
+        end
+      end
+
+      private
+
+      def build_watchdog(target_thread, stop_flag:)
+        return nil unless @cancellation_check
+
+        Thread.new do
+          until stop_flag.call
+            active = begin
+              @cancellation_check.call
+            rescue StandardError
+              true # can't determine status (e.g. test transactions) — assume active
+            end
+            unless active
+              target_thread.raise(SolidLoop::CancellationError, "Loop cancelled during prefill")
+              break
+            end
+            sleep 1
+          end
+        end
+      end
+
+      def extract_full_text(data)
+        msg = @dialect.extract_message_data(data)
+        msg[:content].to_s + msg[:reasoning].to_s
+      end
+
+      def parse_stream_chunk(chunk)
+        @aggregator.ingest(chunk)
+        data = @dialect.extract_message_data(@aggregator.result)
+        if @content_started_at.nil? && (data[:content].present? || data[:tool_calls].any?)
+          @content_started_at = Time.current
+        end
+
+        data
+      end
+
+      def emit_chunk_event(data)
+        return unless @streaming
+        return if Time.current - @last_ui_update_at < SolidLoop::LlmCompletionJob::HTTP_STREAMING_UPDATE_MODEL_INTERVAL
+
+        metrics = SolidLoop::LlmMetrics.new(
+          ttft: (@first_token_at ? (@first_token_at - @request_started_at).to_f : 0.0),
+          duration_thinking: ((@content_started_at && @first_token_at) ? (@content_started_at - @first_token_at).to_f : 0.0),
+          duration_generation: (Time.current - @request_started_at).to_f,
+          tokens_completion: ((data[:content]&.length || 0) + (data[:reasoning]&.length || 0)) / 4
+        )
+
+        @on_chunk_proc&.call(data[:content], data[:reasoning], data[:tool_calls], metrics)
+        @last_ui_update_at = Time.current
+      end
+    end
+  end
+end

data/app/services/solid_loop/dialects/anthropic.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  module Dialects
+    class Anthropic
+      def completion_url(base_url)
+        base_url.to_s.gsub(/\/+$/, "") + "/v1/messages"
+      end
+
+      def auth_headers(api_token)
+        h = { "anthropic-version" => "2023-06-01" }
+        h["x-api-key"] = api_token if api_token.present?
+        h
+      end
+
+      def apply_reasoning_strategies!(messages, strategies)
+        return unless messages.is_a?(Array)
+
+        filtered = strategies.reject { |s| s == :gemini_signed }
+        messages.each do |msg|
+          SolidLoop::Dialects::ReasoningPacker.pack(msg, filtered)
+        end
+      end
+
+      def render_payload(payload)
+        messages = payload[:messages] || []
+
+        # Extract system message — Anthropic puts it outside messages array
+        system_msg = messages.find { |m| m[:role] == "system" }
+        non_system  = messages.reject { |m| m[:role] == "system" }
+
+        anthropic_payload = {
+          model:      payload[:model],
+          max_tokens: payload[:max_tokens] || 8096,
+          messages:   merge_tool_results(non_system.map { |m| map_message(m) })
+        }.compact
+
+        anthropic_payload[:system]      = system_msg[:content] if system_msg
+        anthropic_payload[:temperature] = payload[:temperature] if payload[:temperature]
+
+        if payload[:tools]&.any?
+          anthropic_payload[:tools] = payload[:tools].map { |t| map_tool(t) }
+        end
+
+        anthropic_payload
+      end
+
+      def extract_message_data(data)
+        content_blocks = data["content"] || []
+
+        text_block    = content_blocks.find { |b| b["type"] == "text" }
+        thinking_block = content_blocks.find { |b| b["type"] == "thinking" }
+        tool_blocks   = content_blocks.select { |b| b["type"] == "tool_use" }
+
+        {
+          content:    text_block&.dig("text"),
+          reasoning:  thinking_block&.dig("thinking"),
+          tool_calls: map_tool_calls(tool_blocks)
+        }
+      end
+
+      def normalize_response(data, fallback_text: "", fallback_messages_text: "")
+        res = extract_message_data(data)
+
+        usage_data =
+          if data["usage"].is_a?(Hash)
+            SolidLoop::LlmUsageParser::Anthropic.call(data["usage"])
+          else
+            SolidLoop::LlmUsageParser.estimate(fallback_text, fallback_messages_text)
+          end
+
+        {
+          content:    res[:content],
+          reasoning:  res[:reasoning],
+          tool_calls: res[:tool_calls],
+          usage:      usage_data,
+          metadata:   { "model" => data["model"].presence }.compact
+        }
+      end
+
+      private
+
+      def map_message(m)
+        case m[:role]
+        when "tool"
+          # Tool result → Anthropic user message with tool_result block
+          {
+            role:    "user",
+            content: [{
+              type:        "tool_result",
+              tool_use_id: m[:tool_call_id] || m[:id],
+              content:     m[:content].to_s
+            }]
+          }
+        when "assistant"
+          content = []
+          content << { type: "thinking", thinking: m[:_sl_reasoning] } if m[:_sl_reasoning].present?
+          content << { type: "text", text: m[:content] }               if m[:content].present?
+
+          if m[:tool_calls].present?
+            m[:tool_calls].each do |tc|
+              args = tc.dig(:function, :arguments)
+              args = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+              content << {
+                type:  "tool_use",
+                id:    tc[:id],
+                name:  tc.dig(:function, :name),
+                input: args || {}
+              }
+            end
+          end
+
+          { role: "assistant", content: content }
+        else
+          # user message — simple string content
+          { role: m[:role], content: m[:content].to_s }
+        end
+      end
+
+      def merge_tool_results(messages)
+        messages.each_with_object([]) do |msg, result|
+          if tool_result_message?(msg) && tool_result_message?(result.last)
+            result.last[:content].concat(msg[:content])
+          else
+            result << msg
+          end
+        end
+      end
+
+      def tool_result_message?(msg)
+        return false unless msg
+        msg[:role] == "user" &&
+          msg[:content].is_a?(Array) &&
+          msg[:content].all? { |b| b[:type] == "tool_result" }
+      end
+
+      def map_tool(t)
+        func = t[:function] || {}
+        {
+          name:         func[:name],
+          description:  func[:description],
+          input_schema: func[:parameters] || { type: "object", properties: {} }
+        }
+      end
+
+      def map_tool_calls(blocks)
+        blocks.map do |b|
+          {
+            "id"       => b["id"],
+            "type"     => "function",
+            "function" => {
+              "name"      => b["name"],
+              "arguments" => (b["input"] || {}).to_json
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/app/services/solid_loop/dialects/gemini.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  module Dialects
+    class Gemini
+      def completion_url(base_url)
+        base_url.to_s.gsub(/\/+$/, "") + "/v1beta/models"
+      end
+
+      def auth_headers(_api_token)
+        {}  # Gemini uses ?key= query param, not a header
+      end
+
+      def render_payload(payload)
+        gemini_payload = {
+          contents: payload[:messages].map { |m| map_message(m) },
+          generationConfig: {
+            temperature: payload[:temperature],
+            maxOutputTokens: payload[:max_tokens]
+          }.compact
+        }
+        if payload[:tools]&.any?
+          gemini_payload[:tools] = [{ function_declarations: payload[:tools].map { |t| map_tool(t) } }]
+        end
+        gemini_payload
+      end
+
+      def apply_reasoning_strategies!(messages, strategies)
+        return unless messages.is_a?(Array)
+
+        # Gemini filter: only keep gemini-specific and universal XML strategies
+        filtered = strategies.select { |s| [:gemini_signed, :xml, :xml!].include?(s) }
+
+        messages.each do |msg|
+          SolidLoop::Dialects::ReasoningPacker.pack(msg, filtered)
+        end
+      end
+
+      def extract_message_data(data)
+        candidate = data.dig("candidates", 0) || {}
+        content_obj = candidate.dig("content") || {}
+        parts = content_obj.dig("parts") || []
+
+        text_part = parts.find { |p| p["text"].present? }
+        thought_part = parts.find { |p| p["thought"].present? }
+        tool_calls_part = parts.select { |p| p["functionCall"].present? }
+
+        {
+          content: text_part&.dig("text"),
+          reasoning: thought_part&.dig("thought"),
+          tool_calls: map_tool_calls_from_gemini(tool_calls_part),
+          metadata: { thought_signature: candidate.dig("thoughtSignature") }.compact
+        }
+      end
+
+      def normalize_response(data, fallback_text: "", fallback_messages_text: "")
+        res = extract_message_data(data)
+
+        usage_data =
+          if data["usageMetadata"].is_a?(Hash)
+            SolidLoop::LlmUsageParser::Gemini.call(data["usageMetadata"])
+          else
+            SolidLoop::LlmUsageParser.estimate(fallback_text, fallback_messages_text)
+          end
+
+        {
+          content: res[:content],
+          reasoning: res[:reasoning],
+          tool_calls: res[:tool_calls],
+          usage: usage_data,
+          metadata: res[:metadata].merge({ "model" => data["modelVersion"].presence }.compact)
+        }
+      end
+
+      private
+
+      def map_message(m)
+        role = (m[:role] == "assistant") ? "model" : m[:role]
+
+        if m[:role] == "tool"
+          parts = [{ functionResponse: { name: m[:name], response: { content: m[:content] } } }]
+          return { role: "user", parts: parts }
+        end
+
+        parts = []
+        thought = m[:thought] || m[:_sl_reasoning]
+        if thought.present?
+          thought_part = { thought: thought }
+          thought_part[:thoughtSignature] = m[:thought_signature] if m[:thought_signature].present?
+          parts << thought_part
+        end
+        parts << { text: m[:content] } if m[:content].present?
+
+        if m[:tool_calls].present?
+          m[:tool_calls].each do |tc|
+            args = tc.dig(:function, :arguments)
+            args = args.is_a?(String) ? JSON.parse(args) : args rescue args
+            parts << { functionCall: { name: tc.dig(:function, :name), args: args } }
+          end
+        end
+
+        { role: role, parts: parts }
+      end
+
+      def map_tool(t)
+        func = t.dig(:function) || {}
+        { name: func[:name], description: func[:description], parameters: func[:parameters] }
+      end
+
+      def map_tool_calls_from_gemini(parts)
+        parts.map do |p|
+          fc = p["functionCall"]
+          {
+            "id" => SecureRandom.hex(4),
+            "type" => "function",
+            "function" => { "name" => fc["name"], "arguments" => fc["args"].to_json }
+          }
+        end
+      end
+    end
+  end
+end