silas 0.1.7 → 0.2.0

data/lib/silas/mcp/server.rb

@@ -2,20 +2,20 @@ require "socket"
 
 module Silas
   module Mcp
-    # A minimal HTTP/1.1 server hosting the MCP Handler for the lifetime of one
-    # claude -p subprocess. Deliberately NOT Puma/Rack: the transport claude's
-    # MCP client needs (verified in the spike) is plain request/response JSON —
-    # one request per connection, application/json, no SSE — so a raw threaded
-    # TCPServer is fewer moving parts than embedding an app server in a worker.
+    # A minimal HTTP/1.1 server hosting the MCP Handler in-process. Deliberately
+    # NOT Puma/Rack: the transport MCP clients need (verified in the spike) is
+    # plain request/response JSON — one request per connection,
+    # application/json, no SSE — so a raw threaded TCPServer is fewer moving
+    # parts than embedding an app server in a worker.
     #
     # In-process: the Handler has direct access to the Ledger/models, so no
-    # cross-service call is needed and it works on any worker box.
+    # cross-service call is needed and it works on any worker box. This is the
+    # seam for the "mount your agent's tools as an MCP server" feature.
     class Server
       attr_reader :port
 
-      def self.start(turn:, step:, tools:, resolver:, host: Silas.config.agent_sdk_mcp_host)
-        token = SecureRandom.hex(16)
-        turn.update_columns(mcp_token: token)
+      def self.start(turn:, step:, tools:, resolver:, host: Silas.config.mcp_server_host)
+        token = SecureRandom.hex(16) # minted and compared in memory only
         handler = Handler.new(turn: turn, step: step, tools: tools, resolver: resolver, token: token)
         new(handler: handler, turn: turn, token: token, host: host).tap(&:boot)
       end

data/lib/silas/step_runner.rb

@@ -11,7 +11,7 @@ module Silas
       step = Step.find_or_create_by!(turn: turn, index: index)
 
       unless step.completed?
-        result = execute_model_call(turn, index)
+        result = execute_model_call(turn, index, step)
 
         # One transaction: the step's response, its terminal verdict, and the
         # pending ledger rows commit together — or none of them do.
@@ -48,7 +48,7 @@ module Silas
       end
     end
 
-    def execute_model_call(turn, index)
+    def execute_model_call(turn, index, step)
       assert_definitions_unchanged!(turn)
       engine = Silas.resolved_engine
       context = {
@@ -60,10 +60,25 @@ module Silas
         model: turn_model(turn),
         limits: { max_steps: Silas.agent.max_steps }
       }
-      if (hook = Silas.config.around_model_call)
-        hook.call(context) { engine.execute_step(context) }
-      else
-        engine.execute_step(context)
+
+      # Live deltas: the engine yields Events, the buffer coalesces them into
+      # "silas.delta" notifications. A replayed step never reaches this method
+      # (the completed? guard above), so replay emits nothing. The emitter is
+      # created HERE and closed over by the inner block, so around_model_call
+      # hooks keep their existing one-argument contract and can't swallow it.
+      buffer = DeltaBuffer.new(turn: turn, step: step)
+      emitter = ->(event) { buffer.append(event.payload[:text].to_s) if event.type == :text_delta }
+
+      begin
+        if (hook = Silas.config.around_model_call)
+          hook.call(context) { engine.execute_step(context, &emitter) }
+        else
+          engine.execute_step(context, &emitter)
+        end
+      ensure
+        # Tail flush BEFORE the step row commits — the authoritative
+        # after_commit render must never race a straggling delta batch.
+        buffer.finish
       end
     end
 

data/lib/silas/tool.rb

@@ -7,6 +7,11 @@ module Silas
   #     approval :always                          # :never | :once | :always | lambda
   #     transactional!                            # or at_most_once! (default) / idempotent!
   #
+  # :once approves ONE (tool, arguments) pair per session — an identical repeat
+  # call skips re-approval; different arguments park again. For graded gates
+  # (e.g. auto-approve under a threshold) use a lambda:
+  #   approval ->(session:, input:) { input[:amount] > 5000 ? :user_approval : :approved }
+  #
   #     def call(order_id:, amount:, note: nil)
   #       ...
   #     end

data/lib/silas/version.rb

@@ -1,3 +1,3 @@
 module Silas
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end

data/lib/silas.rb

@@ -24,6 +24,8 @@ require "silas/connection"
 require "silas/connections"
 require "silas/inbox"
 require "silas/inbox/cost"
+require "silas/inbox/delta_broadcaster"
+require "silas/delta_buffer"
 require "silas/budget"
 require "silas/registry"
 require "silas/agent"
@@ -31,19 +33,14 @@ require "silas/tools/load_skill"
 require "silas/tools/remember"
 require "silas/tools/recall"
 require "silas/tools/handoff"
-require "silas/engines/base"
-require "silas/agent_sdk/version_guard"
-require "silas/agent_sdk/stream_parser"
-require "silas/agent_sdk/cli"
 require "silas/mcp/handler"
 require "silas/mcp/server"
-require "silas/engines/agent_sdk"
+require "silas/engines/base"
 require "ruby_llm"
 require "silas/engines/ruby_llm"
 require "silas/message_builder"
 require "silas/instructions"
 require "silas/step_runner"
-require "silas/subprocess_runner"
 require "silas/eval" # after engines (ScriptedEngine < Engines::Base)
 require "silas/chat"
 
@@ -97,13 +94,16 @@ module Silas
 
     def reset_agent_memo! = (@agent = nil) # after Registry.install! swaps dirs
 
-    # The inference adapter instance. config.engine may be a symbol (:ruby_llm,
-    # :agent_sdk) or any object responding to #execute_step (specs, custom).
+    # The inference adapter instance. config.engine may be :ruby_llm or any
+    # object responding to #execute_step (specs, custom).
     def resolved_engine
       @resolved_engine ||=
         case config.engine
         when :ruby_llm then Engines::RubyLLM.new
-        when :agent_sdk then Engines::AgentSdk.new
+        when :agent_sdk
+          raise Error, "the :agent_sdk engine was removed in Silas 0.2 — the claude -p " \
+                       "subprocess integration is gone (its subscription-auth rationale was " \
+                       "unreachable). Use engine :ruby_llm, the production path."
         when Symbol then raise Error, "unknown engine #{config.engine.inspect}"
         else config.engine
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silas
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel St Paul
@@ -117,6 +117,7 @@ files:
 - app/controllers/silas/inbox/base_controller.rb
 - app/controllers/silas/inbox/invocations_controller.rb
 - app/controllers/silas/inbox/sessions_controller.rb
+- app/controllers/silas/inbox/turns_controller.rb
 - app/helpers/silas/inbox/trace_helper.rb
 - app/jobs/silas/agent_loop_job.rb
 - app/jobs/silas/channel_delivery_job.rb
@@ -152,6 +153,7 @@ files:
 - db/migrate/20260716000001_add_budget_overrides_to_silas_turns.rb
 - db/migrate/20260716000002_add_cancel_requested_to_silas_turns.rb
 - db/migrate/20260721000001_create_silas_memories.rb
+- db/migrate/20260724000001_drop_agent_sdk_columns_from_silas_turns.rb
 - lib/generators/silas/install/install_generator.rb
 - lib/generators/silas/install/templates/agent.yml
 - lib/generators/silas/install/templates/bin_ci
@@ -167,17 +169,14 @@ files:
 - lib/silas.rb
 - lib/silas/agent.rb
 - lib/silas/agent_scope.rb
-- lib/silas/agent_sdk/cli.rb
-- lib/silas/agent_sdk/stream_parser.rb
-- lib/silas/agent_sdk/version_guard.rb
 - lib/silas/budget.rb
 - lib/silas/channel.rb
 - lib/silas/chat.rb
 - lib/silas/configuration.rb
 - lib/silas/connection.rb
 - lib/silas/connections.rb
+- lib/silas/delta_buffer.rb
 - lib/silas/engine.rb
-- lib/silas/engines/agent_sdk.rb
 - lib/silas/engines/base.rb
 - lib/silas/engines/ruby_llm.rb
 - lib/silas/errors.rb
@@ -192,6 +191,7 @@ files:
 - lib/silas/eval/transcript.rb
 - lib/silas/inbox.rb
 - lib/silas/inbox/cost.rb
+- lib/silas/inbox/delta_broadcaster.rb
 - lib/silas/instructions.rb
 - lib/silas/ledger.rb
 - lib/silas/mcp/client.rb
@@ -209,7 +209,6 @@ files:
 - lib/silas/skill.rb
 - lib/silas/slack.rb
 - lib/silas/step_runner.rb
-- lib/silas/subprocess_runner.rb
 - lib/silas/tool.rb
 - lib/silas/tools/delegate.rb
 - lib/silas/tools/handoff.rb

data/lib/silas/agent_sdk/cli.rb

@@ -1,59 +0,0 @@
-require "json"
-
-module Silas
-  module AgentSdk
-    # Builds the verified claude -p argv and manages the subprocess. --bare is
-    # the API-key-only auth guard (never subscription OAuth); alwaysLoad + a
-    # non-zero MCP_TIMEOUT are BOTH mandatory or the single-shot -p turn races
-    # ahead of the MCP handshake and never sees the tools (spike trap #1).
-    class Cli
-      def initialize(bin:, prompt:, system:, model:, mcp_url:, allowed:, resume_session_id: nil)
-        @bin = bin
-        @prompt = prompt
-        @system = system
-        @model = model
-        @mcp_url = mcp_url
-        @allowed = allowed
-        @resume_session_id = resume_session_id
-      end
-
-      # Spawns claude, yields each stdout line, returns the exit status integer.
-      def stream
-        @io = IO.popen(env, argv, err: %i[child out], pgroup: true)
-        @pid = @io.pid
-        @io.each_line { |line| yield line }
-        @io.close
-        $?.exitstatus
-      end
-
-      def terminate
-        return unless @pid
-
-        Process.kill("-TERM", @pid)
-        Process.kill("-KILL", @pid)
-      rescue Errno::ESRCH, Errno::EPERM
-        # already gone
-      end
-
-      def argv
-        args = [ @bin, "-p", @prompt,
-                 "--output-format", "stream-json", "--verbose", "--bare",
-                 "--mcp-config", mcp_config_json,
-                 "--allowedTools", @allowed.join(","),
-                 "--model", @model ]
-        args += [ "--append-system-prompt", @system ] if @system.present?
-        args += [ "--resume", @resume_session_id ] if @resume_session_id.present?
-        args
-      end
-
-      def mcp_config_json
-        JSON.generate("mcpServers" => { "silas" => { "type" => "http", "url" => @mcp_url, "alwaysLoad" => true } })
-      end
-
-      def env
-        { "ANTHROPIC_API_KEY" => ENV["ANTHROPIC_API_KEY"],
-          "MCP_TIMEOUT" => Silas.config.agent_sdk_mcp_timeout_ms.to_s }
-      end
-    end
-  end
-end

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