silas 0.1.6 → 0.2.0

data/lib/silas/agent_sdk/stream_parser.rb

@@ -1,86 +0,0 @@
-require "json"
-
-module Silas
-  module AgentSdk
-    # Tolerant NDJSON parser for `claude -p --output-format stream-json`. The
-    # event schema is under-documented and shifts between versions, so unknown
-    # lines/types must never raise. Yields Silas::Event objects; accumulates the
-    # terminal Result (final text, tool_use blocks, usage, session_id).
-    class StreamParser
-      attr_reader :session_id, :final_text, :usage, :stop_reason, :blocks, :tool_calls
-
-      def initialize
-        @blocks = []
-        @tool_calls = []
-        @final_text = nil
-        @usage = nil
-        @session_id = nil
-        @stop_reason = nil
-      end
-
-      def ingest(line)
-        line = line.to_s.strip
-        return if line.empty?
-
-        event = JSON.parse(line)
-        @session_id ||= event["session_id"] if event["session_id"]
-
-        case event["type"]
-        when "system"
-          @session_id ||= event["session_id"]
-          yield Event.new(type: :"system.#{event['subtype']}", payload: symbolize(event))
-        when "assistant"
-          ingest_assistant(event) { |e| yield e }
-        when "user"
-          yield Event.new(type: :tool_result, payload: symbolize(event))
-        when "result"
-          @final_text = event["result"]
-          @stop_reason = event["subtype"]
-          @usage = extract_usage(event)
-          # The result text usually repeats the last assistant text — only add a
-          # block if it isn't already captured.
-          if @final_text && @blocks.none? { |b| b["type"] == "text" && b["text"] == @final_text }
-            @blocks << { "type" => "text", "text" => @final_text }
-          end
-          yield Event.new(type: :result, payload: symbolize(event))
-        else
-          yield Event.new(type: :unknown, payload: symbolize(event))
-        end
-      rescue JSON::ParserError
-        # A non-JSON line (banner, warning) — ignore.
-      end
-
-      # tool_calls stays [] on the Result: in the engine-owned path Claude Code
-      # already executed the tools (through our MCP endpoint), so the framework
-      # loop must not try to run them again.
-      def to_result
-        Engines::Result.new(blocks: @blocks, tool_calls: [], stop_reason: @stop_reason || "end_turn", usage: @usage)
-      end
-
-      private
-
-      def ingest_assistant(event)
-        Array(event.dig("message", "content")).each do |block|
-          case block["type"]
-          when "text"
-            @blocks << { "type" => "text", "text" => block["text"] }
-            yield Event.new(type: :text, payload: { text: block["text"] })
-          when "tool_use"
-            @tool_calls << block["id"]
-            @blocks << { "type" => "tool_call", "id" => block["id"], "name" => block["name"], "arguments" => block["input"] }
-            yield Event.new(type: :tool_call, payload: symbolize(block))
-          end
-        end
-      end
-
-      def extract_usage(event)
-        u = event["usage"] || {}
-        { input_tokens: u["input_tokens"], output_tokens: u["output_tokens"], cost_usd: event["total_cost_usd"] }
-      end
-
-      def symbolize(hash)
-        hash.transform_keys(&:to_sym)
-      end
-    end
-  end
-end

data/lib/silas/agent_sdk/version_guard.rb

@@ -1,26 +0,0 @@
-module Silas
-  module AgentSdk
-    # The adapter wraps an external CLI whose JSON stream can shift between
-    # versions, so pin a tested range and fail loudly outside it.
-    module VersionGuard
-      module_function
-
-      def assert!(bin, requirement: Silas.config.agent_sdk_cli_version_range)
-        version = detect(bin)
-        raise Silas::Error, "could not determine `#{bin}` version (is the Claude CLI installed?)" if version.nil?
-
-        unless Gem::Requirement.new(requirement.split(",").map(&:strip)).satisfied_by?(Gem::Version.new(version))
-          raise Silas::Error, "claude CLI #{version} is outside the tested range (#{requirement}); pin or upgrade"
-        end
-        version
-      end
-
-      def detect(bin)
-        out = `#{bin} --version 2>/dev/null`
-        out[/\d+\.\d+\.\d+/]
-      rescue StandardError
-        nil
-      end
-    end
-  end
-end

data/lib/silas/engines/agent_sdk.rb

@@ -1,75 +0,0 @@
-module Silas
-  module Engines
-    # The engine-owned adapter: one `claude -p` subprocess runs a whole agentic
-    # turn, calling back into Silas tools over an in-worker HTTP MCP endpoint
-    # whose tools/call goes THROUGH the Ledger (exactly-once within the run).
-    # The mirror image of :ruby_llm — Claude Code owns the loop; Silas hosts the
-    # tools and maps the NDJSON stream onto durable rows.
-    #
-    # v1 contract (honestly weaker than :ruby_llm): exactly-once WITHIN a run,
-    # approval :never tools only, and fail-closed on mid-subprocess worker kill.
-    class AgentSdk < Base
-      def self.loop_ownership = :engine
-
-      def execute_step(context, &on_event)
-        turn = context[:turn]
-        Silas::AgentSdk::VersionGuard.assert!(Silas.config.agent_sdk_claude_bin)
-        assert_api_key!
-
-        tools = allowed_tools(context[:tools])
-        server = Mcp::Server.start(turn: turn, step: context[:step], tools: tools, resolver: Silas.tool_resolver)
-        cli = nil
-        begin
-          server.await_ready!
-          cli = build_cli(context, server, tools)
-          parser = Silas::AgentSdk::StreamParser.new
-          cli.stream do |line|
-            parser.ingest(line) do |event|
-              persist_session_id!(turn, parser)
-              on_event&.call(event)
-              ActiveSupport::Notifications.instrument("silas.agent_sdk.event", turn_id: turn.id, type: event.type)
-            end
-          end
-          parser.to_result
-        ensure
-          cli&.terminate
-          server.stop
-        end
-      end
-
-      private
-
-      def build_cli(context, server, tools)
-        Silas::AgentSdk::Cli.new(
-          bin: Silas.config.agent_sdk_claude_bin,
-          prompt: context[:turn].input,
-          system: context[:system],
-          model: Silas.config.agent_sdk_model || context[:model],
-          mcp_url: server.mcp_url,
-          allowed: tools.map { |d| "mcp__silas__#{d['name']}" }
-        )
-      end
-
-      # v1 excludes approval-gated tools entirely (both tools/list and
-      # --allowedTools) — an engine-owned subprocess can't park cheaply.
-      def allowed_tools(definitions)
-        kept = definitions.select { |d| Silas.tool_resolver.call(d["name"]).approval_policy == :never }
-        dropped = definitions.map { |d| d["name"] } - kept.map { |d| d["name"] }
-        Rails.logger&.info("silas: :agent_sdk excludes approval-gated tools #{dropped.inspect}") if dropped.any?
-        kept
-      end
-
-      def persist_session_id!(turn, parser)
-        return unless turn.cli_session_id.nil? && parser.session_id.present?
-
-        turn.update_columns(cli_session_id: parser.session_id)
-      end
-
-      def assert_api_key!
-        return if ENV["ANTHROPIC_API_KEY"].present?
-
-        raise Silas::BootGuardError, ":agent_sdk uses --bare (API-key auth only); set ANTHROPIC_API_KEY"
-      end
-    end
-  end
-end

data/lib/silas/subprocess_runner.rb

@@ -1,41 +0,0 @@
-module Silas
-  # The engine-owned analog of StepRunner: it wraps one whole subprocess run in
-  # a single anchor Step and persists the durable result. Replay-aware and
-  # fail-closed — a resumed run whose subprocess got far enough to register a
-  # CLI session but did not finish is FAILED rather than re-spawned, because an
-  # engine-owned subprocess can't be replayed exactly-once (design risk #1).
-  module SubprocessRunner
-    module_function
-
-    # Returns :terminal or :failed.
-    def call(turn)
-      step = Step.find_or_create_by!(turn: turn, index: 0)
-      return :terminal if step.completed?
-
-      if turn.cli_session_id.present?
-        # A prior execution spawned a subprocess that never completed the step.
-        turn.finish!(:failed, reason: "agent_sdk_interrupted")
-        return :failed
-      end
-
-      result = Silas.resolved_engine.execute_step(engine_context(turn, step))
-      step.update!(
-        status: "completed", terminal: true,
-        response_blocks: result.blocks, stop_reason: result.stop_reason,
-        model: Silas.agent.model,
-        input_tokens: result.usage&.dig(:input_tokens),
-        output_tokens: result.usage&.dig(:output_tokens)
-      )
-      :terminal
-    end
-
-    def engine_context(turn, step)
-      { turn: turn, step: step, index: 0,
-        system: turn.instructions_snapshot,
-        messages: MessageBuilder.call(turn, upto_index: nil),
-        tools: Silas.tool_definitions,
-        model: Silas.agent.model,
-        limits: { max_steps: Silas.agent.max_steps } }
-    end
-  end
-end