solid_loop 0.0.4

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  module Dialects
+    class OpenAi
+      def completion_url(base_url)
+        base_url.to_s.gsub(/\/+$/, "") + "/v1/chat/completions"
+      end
+
+      def auth_headers(api_token)
+        api_token.present? ? { "Authorization" => "Bearer #{api_token}" } : {}
+      end
+
+      def apply_reasoning_strategies!(messages, strategies)
+        return unless messages.is_a?(Array)
+
+        # OpenAI filter: remove Gemini-specific strategies, allow XML and string fields
+        filtered = strategies.reject { |s| s == :gemini_signed }
+
+        messages.each do |msg|
+          SolidLoop::Dialects::ReasoningPacker.pack(msg, filtered)
+        end
+      end
+
+      def extract_message_data(data)
+        choice = data.dig("choices", 0, "message") || data.dig("choices", 0, "delta") || {}
+        {
+          content: choice["content"],
+          reasoning: choice["reasoning_content"] || choice["reasoning"] || choice["thought"],
+          tool_calls: choice["tool_calls"] || []
+        }
+      end
+
+      def normalize_response(data, fallback_text: "", fallback_messages_text: "")
+        choice = data.dig("choices", 0, "message") || data.dig("choices", 0, "delta") || {}
+
+        usage_data =
+          if data["usage"].is_a?(Hash) && data["usage"]["total_tokens"].to_i > 0
+            SolidLoop::LlmUsageParser::Openai.call(data["usage"])
+          elsif data["timings"].is_a?(Hash)
+            SolidLoop::LlmUsageParser::Llama.call(data["timings"])
+          else
+            SolidLoop::LlmUsageParser.estimate(fallback_text, fallback_messages_text)
+          end
+
+        reasoning_field =
+          if choice["reasoning_content"] then "reasoning_content"
+          elsif choice["reasoning"] then "reasoning"
+          elsif choice["thought"] then "thought"
+          end
+
+        {
+          content: choice["content"],
+          reasoning: choice[reasoning_field],
+          tool_calls: choice["tool_calls"] || [],
+          usage: usage_data,
+          metadata: { "reasoning_field" => reasoning_field, "model" => data["model"].presence }.compact
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  module Dialects
+    class ReasoningPacker
+      def self.pack(msg, strategies)
+        reasoning = msg.delete(:_sl_reasoning)
+        signature = msg.delete(:_sl_signature)
+        return if reasoning.blank?
+
+        # 1. Determine if we have any native/specific strategies present in the array
+        # Excluding XML and string-based fields
+        has_native_strategy = strategies.any? { |s| s == :gemini_signed }
+
+        strategies.each do |strategy|
+          case strategy
+          when :xml
+            # Apply universal fallback ONLY if no native strategy is active
+            apply_xml!(msg, reasoning) unless has_native_strategy
+          when :xml!
+            # FORCE XML wrapping regardless of other strategies
+            apply_xml!(msg, reasoning)
+          when :gemini_signed
+            msg[:thought] = reasoning
+            msg[:thought_signature] = signature if signature.present?
+          when String
+            msg[strategy.to_sym] = reasoning
+          end
+        end
+      end
+
+      def self.apply_xml!(msg, reasoning)
+        msg[:content] = "<think>\n#{reasoning}\n</think>\n#{msg[:content]}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  class LlmUsageParser
+    class Anthropic
+      def self.call(usage)
+        input  = usage["input_tokens"].to_i
+        output = usage["output_tokens"].to_i
+        cached = usage.dig("cache_read_input_tokens").to_i
+
+        {
+          tokens_prompt:        input,
+          tokens_completion:    output,
+          tokens_total:         input + output,
+          tokens_prompt_cached: cached,
+          cost:                 0.0,
+          tps:                  0.0
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  class LlmUsageParser
+    class Gemini
+      def self.call(usage)
+        {
+          tokens_prompt: usage["promptTokenCount"].to_i,
+          tokens_completion: usage["candidatesTokenCount"].to_i,
+          tokens_total: usage["totalTokenCount"].to_i,
+          tokens_prompt_cached: 0,
+          cost: usage["cost"].to_f, # Support if they add it
+          tps: 0.0
+        }
+      end
+    end
+  end
+end

data/app/services/solid_loop/llm_usage_parser/llama.rb

@@ -0,0 +1,15 @@
+module SolidLoop
+  class LlmUsageParser
+    class Llama
+      def self.call(timings)
+        {
+          tokens_prompt: timings["prompt_n"].to_i,
+          tokens_completion: timings["predicted_n"].to_i,
+          tokens_total: timings["prompt_n"].to_i + timings["predicted_n"].to_i,
+          tokens_prompt_cached: timings["cache_n"].to_i,
+          tps: timings["predicted_per_second"].to_f.round(2)
+        }
+      end
+    end
+  end
+end

data/app/services/solid_loop/llm_usage_parser/openai.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  class LlmUsageParser
+    class Openai
+      def self.call(usage)
+        {
+          tokens_prompt: usage["prompt_tokens"].to_i,
+          tokens_completion: usage["completion_tokens"].to_i,
+          tokens_total: usage["total_tokens"].to_i,
+          tokens_prompt_cached: usage.dig("prompt_tokens_details", "cached_tokens").to_i,
+          cost: usage["cost"].to_f, # Directly from provider
+          tps: 0.0
+        }
+      end
+    end
+  end
+end

data/app/services/solid_loop/llm_usage_parser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  class LlmUsageParser
+    def self.estimate(text, messages_text)
+      tokens_completion = text.to_s.length / 4
+      tokens_prompt = messages_text.to_s.length / 4
+
+      {
+        tokens_prompt: tokens_prompt,
+        tokens_completion: tokens_completion,
+        tokens_total: tokens_prompt + tokens_completion,
+        tokens_prompt_cached: 0,
+        cost: 0.0,
+        tps: 0.0
+      }
+    end
+  end
+end

data/app/services/solid_loop/mcp_session_initializer.rb

@@ -0,0 +1,205 @@
+module SolidLoop
+  class McpSessionInitializer
+    def self.call(loop, agent, execution_token: :any)
+      new(loop, agent, execution_token: execution_token).call
+    end
+
+    def initialize(loop, agent, execution_token: :any)
+      @loop = loop
+      @agent = agent
+      @execution_token = execution_token
+    end
+
+    def call
+      @agent.mcps.each do |mcp_config|
+        process_mcp(mcp_config)
+      end
+
+      validate_tool_name_collisions!
+    end
+
+    private
+
+    # Session/tool sync writes are generation-owned: a stale worker (token
+    # moved on via pause/stop/resume) must not mutate the loop's MCP state.
+    # Network calls cannot run under a row lock, so this is a conditional
+    # re-check before each write phase instead.
+    def stale_generation?
+      return false if @execution_token == :any
+
+      @loop.reload
+      !(@loop.running? && @loop.execution_token == @execution_token)
+    end
+
+    def process_mcp(mcp_config)
+      return if stale_generation?
+
+      name           = mcp_config[:name].to_s
+      session        = @loop.mcp_sessions.find_by(mcp_name: name)
+      refresh_needed = @agent.refresh_mcp_tools?
+      return if session && !refresh_needed
+
+      context = Mcp::CallContext.new(agent: @agent, loop: @loop, principal: @agent.mcp_principal)
+      client  = Mcp::ClientFactory.client_for(mcp_config, context: context)
+      kind    = Mcp::ClientFactory.transport_kind(mcp_config)
+
+      if session.nil?
+        sid = initialize_session(client, mcp_config)
+        return if stale_generation?
+
+        session = @loop.mcp_sessions.create!(mcp_name: name, session_id: sid, transport_kind: kind,
+                                             metadata: { "capabilities" => client.server_capabilities })
+        refresh_needed = true
+      elsif session.transport_kind != kind
+        # The entry form changed (e.g. url: -> toolset:) — keep the admin UI honest.
+        session.update!(transport_kind: kind)
+      end
+
+      refresh_tools(session, mcp_config, client, name) if refresh_needed
+    end
+
+    def initialize_session(client, mcp_config)
+      with_mcp_event("mcp_initialize", client, mcp_config, request_fallback: {}) do
+        client.initialize_session
+      end
+    end
+
+    def refresh_tools(session, mcp_config, client, name)
+      tools = with_mcp_event("mcp_list_tools", client, mcp_config, request_fallback: { session_id: session.session_id }) do
+        client.list_tools(session.session_id)
+      end
+
+      return if stale_generation?
+
+      sync_tools(session, mcp_config, tools)
+      validate_required_tools(session, mcp_config, tools, name)
+      discover_prompts_and_resources(session, mcp_config, client)
+
+      @agent.on_mcp_session_initialized(session) if @agent.respond_to?(:on_mcp_session_initialized)
+    end
+
+    # Snapshots prompts/resources lists into session metadata for the admin UI
+    # when the server advertises those capabilities. Best-effort: a failing
+    # prompts/resources endpoint must not take tool availability down with it
+    # (the attempt still leaves an Event behind).
+    def discover_prompts_and_resources(session, mcp_config, client)
+      capabilities = session.metadata&.fetch("capabilities", {}) || {}
+      discovered   = {}
+
+      { "prompts" => :list_prompts, "resources" => :list_resources }.each do |capability, list_method|
+        next unless capabilities.key?(capability)
+
+        begin
+          discovered[capability] = with_mcp_event("mcp_#{list_method}", client, mcp_config,
+                                                  request_fallback: { session_id: session.session_id }) do
+            client.public_send(list_method, session.session_id)
+          end
+        rescue SolidLoop::McpError
+          nil
+        end
+      end
+
+      return if stale_generation?
+
+      session.update!(metadata: (session.metadata || {}).merge(discovered)) if discovered.any?
+    end
+
+    def sync_tools(session, mcp_config, tools)
+      whitelist = mcp_config[:tools]&.map(&:to_s)
+
+      server_tools = tools.filter_map do |t|
+        next if whitelist && !whitelist.include?(t["name"])
+        t
+      end
+
+      # Tools are advertised to the LLM under their prefixed name; the prefix
+      # is stripped again before tools/call reaches the server.
+      advertised = server_tools.index_by { |t| advertised_name(t["name"], mcp_config) }
+      existing   = session.mcp_tools.index_by(&:name)
+
+      # Destroy tools no longer returned by the server
+      (existing.keys - advertised.keys).each { |n| existing[n].destroy! }
+
+      # Update existing or create new
+      advertised.each do |adv_name, t|
+        attrs = { description: t["description"], input_schema: t["inputSchema"] }
+        if existing[adv_name]
+          existing[adv_name].update!(attrs)
+        else
+          session.mcp_tools.create!(name: adv_name, **attrs)
+        end
+      end
+    end
+
+    def validate_required_tools(session, mcp_config, tools, name)
+      required = (mcp_config[:required_tools] || mcp_config[:tools])&.map(&:to_s)
+      return unless required&.any?
+
+      synced  = session.mcp_tools.pluck(:name)
+      missing = required.reject { |n| synced.include?(advertised_name(n, mcp_config)) }
+      return unless missing.any?
+
+      error_msg = "Stop: Required MCP tools missing for #{name}: #{missing.join(', ')}. " \
+                  "Tools returned from server: #{tools.map { |t| t['name'] }.join(', ')}"
+      fail_loop(error_msg)
+      raise error_msg
+    end
+
+    def validate_tool_name_collisions!
+      pairs = @loop.mcp_tools.joins(:mcp_session)
+                   .pluck("solid_loop_mcp_tools.name", "solid_loop_mcp_sessions.mcp_name")
+      collisions = pairs.group_by(&:first).select { |_, rows| rows.size > 1 }
+      return if collisions.empty?
+
+      details = collisions.map { |tool, rows| "'#{tool}' (servers: #{rows.map(&:last).sort.join(', ')})" }
+      error_msg = "Stop: MCP tool name collision across servers: #{details.join('; ')}. " \
+                  "Add prefix: to one of the servers to disambiguate."
+      fail_loop(error_msg)
+      raise SolidLoop::McpError, error_msg
+    end
+
+    def advertised_name(tool_name, mcp_config)
+      prefix = mcp_config[:prefix]
+      prefix ? "#{prefix}__#{tool_name}" : tool_name
+    end
+
+    def fail_loop(error_msg)
+      # Cleanup 4 — every non-`running` target must clear the LLM lease
+      # (lease_expires_at) so the DB CHECK holds and the reaper doesn't re-select
+      # a terminal row. Failing during MCP init happens while the loop is still
+      # `running` + leased, so NULL the lease with the transition.
+      @loop.transition_status(
+        from: SolidLoop::Loop::ACTIVE_STATUSES,
+        to: :failed,
+        expected_execution_token: @execution_token,
+        error_message: error_msg,
+        execution_token: nil,
+        lease_expires_at: nil
+      )
+    end
+
+    def with_mcp_event(event_name, client, mcp_config, request_fallback:)
+      start_time = Time.current
+      yield
+    ensure
+      record_event(event_name, client, mcp_config, start_time, $!, request_fallback)
+    end
+
+    def record_event(event_name, client, mcp_config, start_time, exception, request_fallback)
+      duration = Time.current - start_time
+      result   = client.last_result
+
+      SolidLoop::Event.create!(
+        loop_id:       @loop.id,
+        eventable:     @loop,
+        name:          event_name,
+        http_method:   "POST",
+        url:           mcp_config[:url] || "mcp://#{mcp_config[:name]}",
+        request_data:  result ? result.raw_request : request_fallback,
+        response_data: result ? result.raw_response || {} : { error: exception&.message }.compact,
+        duration:      duration,
+        log:           client.wire_log
+      )
+    end
+  end
+end

data/app/services/solid_loop/mcp_tool_execution_service.rb

@@ -0,0 +1,153 @@
+module SolidLoop
+  class McpToolExecutionService
+    attr_reader :mcp_tool, :agent, :tool_call, :mcp_config, :session, :client, :retries_count
+
+    def self.call(mcp_tool:, agent:, arguments:, tool_call: nil)
+      new(mcp_tool, agent, tool_call: tool_call).call(arguments)
+    end
+
+    def initialize(mcp_tool, agent, tool_call: nil)
+      @mcp_tool = mcp_tool
+      @agent = agent
+      @tool_call = tool_call
+      @session = mcp_tool.mcp_session
+      @mcp_config = agent.mcps.find { |c| c[:name].to_s == @session&.mcp_name }
+      @retries_count = 0
+    end
+
+    def call(arguments)
+      @start_time = Time.current
+      validate_context!
+      @client = create_client
+      execute_with_retries(arguments)
+    rescue => e
+      build_error_result(e)
+    end
+
+    private
+
+    def validate_context!
+      unless mcp_config && session
+        raise SolidLoop::McpError, "Error: MCP configuration or session for '#{session&.mcp_name}' missing."
+      end
+    end
+
+    def create_client
+      context = Mcp::CallContext.new(
+        agent: agent,
+        loop: session.loop,
+        principal: agent.mcp_principal,
+        idempotency_key: tool_call&.idempotency_key
+      )
+      Mcp::ClientFactory.client_for(mcp_config, context: context)
+    end
+
+    def execute_with_retries(arguments)
+      begin
+        perform_invocation(arguments)
+      rescue SolidLoop::McpSessionInvalidError => e
+        # Some servers bind real state to the session id (sandboxes, workspaces);
+        # silently swapping such a session mid-loop would destroy that state.
+        if session_recovery == :fail
+          raise SolidLoop::McpSessionInvalidError,
+                "#{e.message}. session_recovery is :fail for '#{session.mcp_name}' — " \
+                "not re-initializing; recreate the session explicitly."
+        end
+
+        if retries_count.zero?
+          recover_session(failed_session_id: session.session_id)
+          @retries_count += 1
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    # Value is validated eagerly in Mcp::ClientFactory.
+    def session_recovery
+      (mcp_config[:session_recovery] || :auto).to_sym
+    end
+
+    def perform_invocation(arguments)
+      result_text = client.call_tool(session.session_id, server_tool_name, arguments, meta: call_meta)
+      duration = Time.current - @start_time
+      finalize_result(!client.last_tool_error?, result_text, duration)
+    end
+
+    # Stable per-ToolCall idempotency key on the wire (MCP `_meta`), so remote
+    # servers can dedupe an invocation that is re-delivered after a crash
+    # between their side effect and SolidLoop's executed_at checkpoint.
+    def call_meta
+      return nil unless tool_call
+
+      { "solidloop/idempotencyKey" => tool_call.idempotency_key }
+    end
+
+    # Tools are advertised to the LLM under their prefixed name; the server
+    # only knows the unprefixed one.
+    def server_tool_name
+      prefix = mcp_config[:prefix]
+      prefix ? mcp_tool.name.delete_prefix("#{prefix}__") : mcp_tool.name
+    end
+
+    # Serialize recovery on the McpSession row so two tools that both saw the
+    # SAME session go invalid don't each mint a replacement and overwrite each
+    # other (only the last id would survive; calls would run against different,
+    # orphaned replacements). Under the row lock the first caller replaces the
+    # failed id; a later caller finds the id already moved on and ADOPTS the
+    # winner instead of forking a second replacement. The row lock is DELIBERATELY
+    # held across `client.initialize_session` (a network call) so recovery is
+    # truly serialized; it is bounded by the MCP client's Faraday timeout (default
+    # 60s) and contention is limited to the two workers sharing this one session row.
+    def recover_session(failed_session_id:)
+      session.with_lock do
+        if session.session_id != failed_session_id
+          # Another thread already recovered this exact failed session — adopt
+          # its replacement rather than initializing (and overwriting with) our
+          # own. `session` is reloaded by with_lock, so session_id is current.
+          next
+        end
+
+        sid = client.initialize_session
+        session.update!(session_id: sid)
+      end
+    end
+
+    def build_error_result(exception)
+      duration = Time.current - @start_time
+      result_text = exception.is_a?(SolidLoop::McpError) ? exception.message : "Exception: #{exception.message}"
+      finalize_result(false, result_text, duration, exception: exception)
+    end
+
+    def finalize_result(success, result_text, duration, exception: nil)
+      result = client&.last_result
+      # We attempt to capture logs/data even on failure if client was initialized
+      request_data = capture_request_data(result)
+      response_data = capture_response_data(result, result_text, exception)
+      log_text = client&.wire_log || "No response captured"
+
+      {
+        success: success,
+        result: result_text,
+        duration: duration,
+        log: log_text,
+        request_data: request_data,
+        response_data: response_data,
+        retries_count: retries_count
+      }
+    end
+
+    def capture_request_data(result)
+      result ? result.raw_request : {}
+    end
+
+    def capture_response_data(result, result_text, exception)
+      if result
+        result.raw_response || {}
+      else
+        { result: result_text, error: exception&.message }.compact
+      end
+    end
+  end
+end

data/app/services/solid_loop/middlewares/agent_initialization.rb

@@ -0,0 +1,37 @@
+module SolidLoop
+  module Middlewares
+    class AgentInitialization
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env.agent = env.loop.agent
+        env.model_config = env.agent.llm_provider
+
+        check_limits!(env.loop, env.agent)
+
+        SolidLoop::McpSessionInitializer.call(env.loop, env.agent, execution_token: env.execution_token)
+
+        @app.call(env)
+      end
+
+      private
+
+      def check_limits!(loop, agent)
+        checks = {
+          max_steps:    loop.step_count >= agent.max_steps,
+          max_total_tokens: loop.tokens_total >= agent.max_total_tokens,
+          max_cost:     loop.cost >= agent.max_cost.to_d,
+          max_duration: loop.created_at <= agent.max_duration.ago
+        }
+
+        violated = checks.select { |_, hit| hit }
+        return if violated.empty?
+
+        reason = violated.keys.map(&:to_s).join(", ")
+        raise SolidLoop::LimitExceededError, "Safety limit hit: #{reason}"
+      end
+    end
+  end
+end