solid_loop 0.0.4

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

@@ -0,0 +1,107 @@
+module SolidLoop
+  module Middlewares
+    class ErrorHandling
+      def initialize(app)
+        @app = app
+      end
+
+      GRACEFUL_ERRORS = [
+        SolidLoop::CancellationError,
+        SolidLoop::LimitExceededError,
+        SolidLoop::McpError,
+        Faraday::Error,
+        JSON::ParserError
+      ].freeze
+
+      def call(env)
+        begin
+          @app.call(env)
+          # Only raise the exception if one of the inner middlewares caught it but didn't re-raise
+          # (although inner layers shouldn't rescue unless they fully handle it, some might put it in env.exception)
+          raise env.exception if env.exception
+        rescue StandardError => e
+          raise e unless graceful_error?(e)
+          handle_exception(env, e)
+        end
+      end
+
+      private
+
+      def graceful_error?(e)
+        GRACEFUL_ERRORS.any? { |klass| e.is_a?(klass) }
+      end
+
+      def handle_exception(env, e)
+        error_msg = "#{e.class}: #{e.message}"
+        Rails.logger.error "ERROR IN MIDDLEWARE CHAIN: #{error_msg}\n#{e.backtrace.take(10).join("\n")}"
+
+        if e.is_a?(SolidLoop::CancellationError)
+          # Deliberately NOT token-fenced: cancellation fires precisely when
+          # this generation lost the token (pause/stop), and it only finalizes
+          # the messages this attempt itself created/owns.
+          Rails.logger.info "Stream cancelled: #{e.message}"
+          env.triggering_message&.update!(status: "success")
+
+          if env.assistant_message
+            # Born-hidden shell protocol: a cancelled/force-stopped partial is
+            # NOT a canonical turn — mark it failed + keep it hidden (partial
+            # content preserved for audit), never `success`. MessageBuilding's
+            # `is_hidden: false` filter then excludes it from a retried turn's
+            # payload, so we never resend a partial as history.
+            env.assistant_message.update!(status: "failed", is_hidden: true)
+            env.assistant_message.broadcast_update
+          end
+          return
+        end
+
+        if e.is_a?(SolidLoop::LimitExceededError)
+          Rails.logger.info "Limit exceeded: #{e.message}"
+          env.loop.transition_status(
+            from: :running,
+            to: :paused,
+            expected_execution_token: env.execution_token,
+            error_message: error_msg,
+            execution_token: nil,
+            lease_expires_at: nil
+          )
+          return
+        end
+
+        Rails.logger.error "LLM Job Failed with Exception: #{error_msg}"
+
+        # Message states and counters are generation-owned: they run inside
+        # the status CAS (under the loop lock), so a stale worker whose token
+        # already lost performs zero mutations against the current run.
+        transitioned = env.loop.transition_status(
+          from: :running,
+          to: :failed,
+          expected_execution_token: env.execution_token,
+          error_message: error_msg,
+          execution_token: nil,
+          lease_expires_at: nil
+        ) do
+          env.triggering_message&.update!(status: "failed", error_message: error_msg)
+          # Keep any failed processing shell hidden (born-hidden protocol) so a
+          # partial never re-enters a retried turn's payload as history.
+          env.assistant_message&.update!(status: "failed", error_message: error_msg, is_hidden: true)
+
+          # Capture duration up to this point
+          if env.request_started_at
+            duration = (Time.current - env.request_started_at).to_f
+            env.loop.increment!(:duration_generation, duration)
+          end
+        end
+
+        if transitioned
+          env.triggering_message&.broadcast_update
+          env.assistant_message&.broadcast_update
+        end
+
+        # We don't re-raise here because ActiveJob would just retry it endlessly.
+        # We mark the loop as failed in DB, which is the correct business behavior.
+        # But we DO put it in env so outer layers (like Tests) can inspect it
+        env.exception = e
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module SolidLoop
+  module Middlewares
+    class EventLogging
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        headers = { "Content-Type" => "application/json" }
+        headers["Authorization"] = "Bearer #{env.model_config[:api_token]}" if env.model_config[:api_token].present?
+
+        safe_headers = headers.dup
+        safe_headers["Authorization"] = "[REDACTED]" if safe_headers.key?("Authorization")
+
+        env.event = SolidLoop::Event.new(
+          eventable: env.triggering_message || env.loop,
+          loop_id: env.loop.id,
+          message_id: env.triggering_message&.id,
+          name: "llm_completion",
+          http_method: "POST",
+          url: env.model_config[:base_url].to_s,
+          request_data: env.payload,
+          headers: safe_headers,
+          log: "Requesting LLM (#{env.agent.streaming? ? 'Streaming' : 'Sync'})..."
+        )
+
+        # We save before request if configured for slow models debugging
+        env.event.save! if SolidLoop::LlmCompletionJob::EVENTS_SAVE_BEFORE_REQUEST
+
+        # Set up log buffers for the network layer to use
+        env.log_buffer ||= StringIO.new
+        env.debug_output ||= StringIO.new
+
+        begin
+          env.mark_request_started!
+          @app.call(env)
+        ensure
+          finalize_event(env)
+        end
+      end
+
+      private
+
+      def finalize_event(env)
+        return unless env.event
+
+        eventable = env.assistant_message || env.triggering_message || env.loop
+
+        detailed_log = env.log_buffer.string
+        detailed_log += "--- Stream/Raw Data ---\n#{env.debug_output.string}\n"
+        detailed_log = redact_credentials(detailed_log)
+
+        # $! surfaces a connection/timeout error that is still propagating up to
+        # ErrorHandling (which sets env.exception only afterwards), so the Event
+        # captures the raw transport failure too — not just LLM HTTP errors.
+        raised = env.exception || $!
+        error_message = raised&.message
+        error_message = "#{raised.class}: #{error_message}" if raised && !env.exception
+        error_message = redact_credentials(error_message) if error_message
+
+        response_data =
+          if env.error_status
+            # Failing (non-2xx) response: persist the provider's status, headers
+            # and (redacted) body so the failure is debuggable in the admin.
+            # This is the wire-log gap for LLM HTTP errors — mirrors what the MCP
+            # path records for its request/response envelopes.
+            {
+              http_status: env.error_status,
+              response_headers: env.error_headers || {},
+              response_body: redact_credentials(env.error_body.to_s)
+            }
+          elsif env.agent.streaming?
+            env.aggregator&.result || {}
+          else
+            begin
+              env.response ? JSON.parse(env.response.body) : {}
+            rescue => _
+              { error: "Failed to parse body" }
+            end
+          end
+
+        env.event.assign_attributes(
+          eventable: eventable,
+          message_id: eventable.is_a?(SolidLoop::Message) ? eventable.id : env.event.message_id,
+          url: redact_credentials(env.request_url || env.event.url),
+          response_data: response_data.merge(error: error_message).compact,
+          log: detailed_log,
+          duration: env.duration || (Time.current - env.request_started_at).to_f
+        )
+        env.event.save!
+      end
+
+      def redact_credentials(value)
+        value.to_s
+          .gsub(/(Authorization|x-api-key|api-key):[^\r\n]*/i, "\\1: [REDACTED]")
+          .gsub(/([?&](?:key|api_key|api-key)=)[^&\s]*/i, "\\1[REDACTED]")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module SolidLoop
+  module Middlewares
+    class MessageBuilding
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        build_messages(env)
+        build_payload(env)
+
+        env.triggering_message&.update!(status: "processing")
+
+        @app.call(env)
+      end
+
+      private
+
+      def build_messages(env)
+        env.messages = []
+        env.triggering_message = nil
+        env.messages_text_for_token_estimation = ""
+
+        # Turn boundary: the previous turn's tool results are all written and no
+        # half-open batch exists yet, so this is the one safe point to fold any
+        # user-enqueued steering messages into the conversation. Materialization
+        # un-hides them (so they appear below) and marks them delivered (so a turn
+        # retry never re-delivers). It must precede the assembly query so the
+        # newly un-hidden rows are included in THIS turn.
+        env.loop.drain_pending_steering!
+
+        # Order by COALESCE(conversation_order, id): ordinary messages (NULL) keep
+        # id order; a DELIVERED steering message uses its delivery-time
+        # conversation_order so it sorts after any tool batch it was enqueued amid,
+        # preserving the assistant(tool_calls) -> tool results pairing invariant.
+        all_messages = env.loop.messages.where(is_hidden: false)
+          .order(Arel.sql("COALESCE(conversation_order, id)")).includes(:tool_calls)
+
+        # Build tool_call_id -> function_name lookup for tool response messages
+        tool_call_name_index = all_messages
+          .flat_map { |m| m.tool_calls.sort_by(&:id) }
+          .each_with_object({}) { |tc, h| h[tc.tool_call_id] = tc.function_name }
+
+        all_messages.each do |msg|
+          m = { role: msg.role, content: msg.content }
+
+          env.messages_text_for_token_estimation += msg.content.to_s + msg.reasoning_content.to_s
+
+          if msg.role == "assistant" && msg.reasoning_content.present?
+            # Pass raw reasoning data down to the network layer (adapter)
+            # We use internal keys to prevent polluting the standard OpenAI payload
+            # The adapter will process and remove these based on its strategies.
+            m[:_sl_reasoning] = msg.reasoning_content
+
+            if msg.metadata && msg.metadata["thought_signature"]
+              m[:_sl_signature] = msg.metadata["thought_signature"]
+            end
+          end
+
+          if msg.role == "tool"
+            m[:tool_call_id] = msg.tool_call_id
+            m[:name] = tool_call_name_index[msg.tool_call_id]
+            env.triggering_message = msg
+          elsif msg.role == "user"
+            env.triggering_message = msg
+          elsif msg.role == "assistant" && msg.tool_calls.any?
+            m[:tool_calls] = msg.tool_calls.sort_by(&:id).map do |atc|
+              {
+                id: atc.tool_call_id,
+                type: "function",
+                function: { name: atc.function_name, arguments: atc.arguments.to_json }
+              }
+            end
+          end
+
+          env.messages << m
+        end
+      end
+
+      def build_payload(env)
+        tools = env.loop.mcp_tools.ordered.map(&:to_tool_spec)
+
+        env.payload = {
+          model: env.model_config[:model],
+          messages: env.messages,
+          stream: !!env.agent.streaming?
+        }
+        env.payload[:tools] = tools if tools.any?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  module Middlewares
+    class NetworkCalling
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        adapter_class = SolidLoop::Adapters::Native
+
+        # Determine the dialect from the agent
+        dialect_name = env.agent.llm_dialect_name.to_s
+        dialect =
+          case dialect_name
+          when "gemini"    then SolidLoop::Dialects::Gemini.new
+          when "anthropic" then SolidLoop::Dialects::Anthropic.new
+          else                  SolidLoop::Dialects::OpenAi.new
+          end
+
+        adapter = adapter_class.new(
+          base_url: env.model_config[:base_url],
+          api_token: env.model_config[:api_token],
+          model_name: env.model_config[:llm_model_name],
+          payload: env.payload,
+          streaming: !!env.agent.streaming?,
+          reasoning_strategies: env.agent.reasoning_strategies,
+          dialect: dialect,
+          fallback_messages_text: env.messages_text_for_token_estimation,
+          read_timeout: env.model_config[:read_timeout],
+          cancellation_check: -> { env.loop_active_fresh? }
+        )
+
+        if env.agent.streaming?
+          # Born hidden: a mid-stream partial is not canonical
+          # history. The ONLY path that flips it visible is the canonical LLM
+          # commit txn in ResponseParsing (status: success + is_hidden: false).
+          # Reclaim/pause/stop/error keep it hidden and mark it failed, so a
+          # retried turn never resends a partial (MessageBuilding filters
+          # is_hidden: false). Hosts opt into showing live processing shells.
+          env.assistant_message = env.loop.messages.create!(
+            role: "assistant",
+            status: "processing",
+            content: "",
+            reasoning_content: "",
+            is_hidden: true
+          )
+
+          adapter.on_chunk_proc = proc do |content, reasoning, tool_calls, metrics|
+            # Business logic: Check if we should continue
+            if !env.loop_active_fresh?
+              Rails.logger.warn "Loop #{env.loop.id} is no longer active. Cancelling stream from middleware."
+              raise SolidLoop::CancellationError, "Loop status changed to #{env.loop.status}"
+            end
+
+            env.assistant_message.trigger_content_append(
+              content,
+              reasoning,
+              tool_calls,
+              **metrics.to_h
+            )
+          end
+        end
+
+        env.request_url = adapter.build_url
+
+        # Execute and capture results back into env
+        result = adapter.call
+
+        env.response = result[:response]
+        env.normalized_data = result[:normalized_data]
+        env.duration = result[:duration]
+        env.aggregator = result[:aggregator]
+
+        # Merge logs back to environment buffers
+        env.log_buffer.write(result[:log]) if env.log_buffer
+        env.debug_output.write(result[:debug_log]) if env.debug_output
+
+        @app.call(env)
+      end
+    end
+  end
+end