ag-ui 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff8366907501490461eb57be56e07c9054ac1632fea8ad6d47c6c3f5b1332cff
-  data.tar.gz: a40b14e97b6d6b9a09daa6016b98a5e19f23ab0594acd37315a5eddc2bebc55c
+  metadata.gz: ba6811e09735cfc95262ba711a5e953a92d9af8d78ea8b13867f1d1c60fbeedc
+  data.tar.gz: 75e995ce5c17476566258e05e5b56de4481b3df8539554e91d687363e15ad456
 SHA512:
-  metadata.gz: e4a40843efccd8f2a995e86816e7108f34e069aac3698f44c94c3d07873fb1f194630f133dae9521abb30803b5420a93742af89c8bc884997521369ba3d368fc
-  data.tar.gz: 5fedf59e8db8548b66db608308c73733b863b09013640cf82139430f6b2b8ac4882baf638ae0fc240dcfd5cfe458c889edc957b9201e5196e30f07ad86847b94
+  metadata.gz: 7e1bfaaa5c833b60ab7ce9a99d069abd3603eaf8366abf355b73688b07c54fb1d76fd280fb46a00e3e0e01a5cbf9de8d7b4ce7e59b581679eff92f7f891842c2
+  data.tar.gz: 205c4a2f519bcbfcf1fcb975de4929da568633d1358a793c78b042424c867918cce430dd6c9289b965ead31bb1a218a4d706b14e7476093a2ac42d7a10a1e21b

data/lib/ag_ui/terminals/ruby_llm.rb

@@ -14,8 +14,8 @@ module AgUi
     #   require "ag_ui/terminals/ruby_llm"
     #
     #   RubyLLM.configure { |c| c.anthropic_api_key = ENV["ANTHROPIC_API_KEY"] }
-    #   run_loop = AgUi::RunLoop.new(system_prompt: PROMPT,
-    #                                &AgUi::Terminals::RubyLLM.new)
+    #   terminal = AgUi::Terminals::RubyLLM.new
+    #   agent = Brute.agent.use(...).run(terminal)   # standard Brute agent
     #
     # One assistant turn per call: seeds the chat from env[:messages]
     # (including prior tool-call turns), registers env[:tools] as
@@ -517,7 +517,7 @@ describe "AgUi::Terminals::RubyLLM" do
     captured.should == [[:anthropic, "claude-sonnet-4-5"], [:anthropic, "claude-sonnet-4-5"]]
   end
 
-  it "drives the full client-tool run through RunLoop + ToolRouter" do
+  it "drives the full client-tool run through a standard Brute agent + ToolRouter" do
     tool_calls = {
       "tc1" => ::RubyLLM::ToolCall.new(id: "tc1", name: "navigate",
                                        arguments: { "path" => "/data" }),
@@ -525,8 +525,23 @@ describe "AgUi::Terminals::RubyLLM" do
     fake = fake_chat_class.new(final: nil, tool_calls: tool_calls)
     terminal = AgUi::Terminals::RubyLLM.new(chat_factory: ->(**) { fake })
 
-    run_loop = AgUi::RunLoop.new(system_prompt: "Be terse.", &terminal)
-    app = AgUi.agent(agent_id: "default", &run_loop)
+    app = AgUi.agent(agent_id: "default") do |env|
+      input = env["ag_ui.input"]
+      agent = Brute.agent
+                   .use(AgUi::Middleware::SystemPrompt, prompt: "Be terse.", context: input.context)
+                   .use(AgUi::Middleware::ForwardedProps, props: input.forwarded_props)
+                   .use(Brute::Middleware::Loop::ToolResult)
+                   .use(Brute::Middleware::MaxIterations, max_iterations: 10)
+                   .use(AgUi::Middleware::ToolRouter, tools: input.tools, server_tools: [])
+                   .run(terminal)
+      env["ag_ui.stream"].open(thread_id: input.thread_id, run_id: input.run_id) do |stream|
+        stream.run_started
+        agent.start(AgUi::Messages.to_brute(input.messages), events: AgUi::EventBridge.new(stream))
+        stream.run_finished
+      rescue => e
+        stream.run_error(message: e.message, code: e.class.name)
+      end
+    end
 
     body = JSON.generate({
       "threadId" => "t1", "runId" => "r1", "state" => nil,

data/lib/ag_ui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AgUi
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ag_ui.rb

@@ -29,4 +29,3 @@ require "ag_ui/a2ui/catalog"
 require "ag_ui/a2ui/validate"
 require "ag_ui/a2ui/recovery"
 require "ag_ui/middleware/a2ui"
-require "ag_ui/run_loop"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ag-ui
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - AgUi Contributors
@@ -206,7 +206,6 @@ files:
 - lib/ag_ui/protocol/json_schema/definition.rb
 - lib/ag_ui/protocol/json_schema/validation_error.rb
 - lib/ag_ui/run_input.rb
-- lib/ag_ui/run_loop.rb
 - lib/ag_ui/run_store.rb
 - lib/ag_ui/server.rb
 - lib/ag_ui/server/info.rb

data/lib/ag_ui/run_loop.rb

@@ -1,285 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "console"
-require "ag_ui"
-
-module AgUi
-  # The run loop: drives one AG-UI run through a brute turn pipeline.
-  #
-  # The terminal block is the LLM call (ruby_llm or anything else) — it
-  # receives brute's env ({messages:, events:, ...}), streams deltas into
-  # env[:events] (translated live to SSE by EventBridge) and appends the
-  # assistant message to env[:messages]. The gem stays LLM-agnostic.
-  #
-  #   run_loop = AgUi::RunLoop.new(system_prompt: PROMPT) do |env|
-  #     env[:events] << { type: :text_message_start, data: { message_id: id } }
-  #     ... stream provider chunks ...
-  #     env[:events] << { type: :text_message_end, data: { message_id: id } }
-  #     env[:messages].assistant(full_text)
-  #   end
-  #
-  #   app = AgUi.agent(agent_id: "default", &run_loop)
-  #
-  # Lifecycle per run (the AG-UI contract): RUN_STARTED first; then the
-  # pipeline streams; then RUN_FINISHED — or RUN_ERROR if the pipeline
-  # raised. Schema-validation failures are wire-contract bugs and re-raise
-  # after RUN_ERROR so they fail loudly in dev.
-  class RunLoop
-    # a2ui: nil/false = off; an AgUi::A2ui::Catalog = on with that catalog;
-    # true = on degraded (tool injected, no component schema).
-    # server_tools: [{name:, description:, parameters:, handler:}] execute
-    # inline and the turn loops (Loop::ToolResult) until the model answers
-    # in text, a client tool defers to the browser, or max_iterations hits.
-    def initialize(system_prompt: nil, validate: true, middleware: [], a2ui: nil,
-                   server_tools: [], max_iterations: 10, &terminal)
-      unless terminal
-        raise ArgumentError, "RunLoop requires a terminal block (the LLM call)"
-      end
-
-      @system_prompt = system_prompt
-      @validate = validate
-      @middleware = middleware
-      @a2ui = a2ui
-      @server_tools = server_tools
-      @max_iterations = max_iterations
-      @terminal = terminal
-    end
-
-    def a2ui_enabled?
-      !(@a2ui.nil? || @a2ui == false)
-    end
-
-    # AgUi.agent takes a block; RunLoop quacks like one.
-    def to_proc
-      run_loop = self
-      proc { |rack_env| run_loop.handle(rack_env) }
-    end
-
-    def handle(rack_env)
-      input = rack_env["ag_ui.input"]
-
-      rack_env["ag_ui.stream"].open(
-        thread_id: input.thread_id,
-        run_id: input.run_id,
-        validate: @validate,
-      ) do |stream|
-        stream.run_started
-        run(stream, input)
-      end
-    end
-
-    private
-
-      def run(stream, input)
-        pipeline(input).start(
-          Messages.to_brute(input.messages),
-          events: EventBridge.new(stream),
-        )
-        stream.run_finished
-      rescue Protocol::JsonSchema::ValidationError => e
-        Console.error(self, "wire-contract bug: #{e.message}", e)
-        stream.run_error(message: "Internal error", code: "validation")
-        raise
-      rescue => e
-        Console.error(self, "run failed: #{e.class}: #{e.message}", e)
-        stream.run_error(message: e.message, code: e.class.name)
-      end
-
-      def pipeline(input)
-        agent = Brute.agent
-        agent.use(
-          AgUi::Middleware::SystemPrompt,
-          prompt: @system_prompt,
-          context: input.context,
-        )
-        agent.use(AgUi::Middleware::ForwardedProps, props: input.forwarded_props)
-        agent.use(Brute::Middleware::Loop::ToolResult)
-        agent.use(Brute::Middleware::MaxIterations, max_iterations: @max_iterations)
-        if a2ui_enabled?
-          catalog = @a2ui.is_a?(AgUi::A2ui::Catalog) ? @a2ui : nil
-          agent.use(AgUi::Middleware::A2ui, catalog: catalog)
-        end
-        agent.use(AgUi::Middleware::ToolRouter, tools: input.tools, server_tools: @server_tools)
-        @middleware.each do |(klass, options)|
-          agent.use(klass, **(options || {}))
-        end
-        agent.run(@terminal)
-      end
-  end
-end
-
-__END__
-
-describe "AgUi::RunLoop" do
-  minimal_input = JSON.generate({
-    "threadId" => "t1", "runId" => "r1", "state" => nil,
-    "messages" => [{ "id" => "u1", "role" => "user", "content" => "hi" }],
-    "tools" => [], "context" => [{ "description" => "currentPath", "value" => "/data" }],
-    "forwardedProps" => nil,
-  })
-
-  request = ->(app, body) do
-    app.call({
-      "REQUEST_METHOD" => "POST",
-      "PATH_INFO" => "/agent/default/run",
-      "rack.input" => StringIO.new(body),
-    })
-  end
-
-  read_frames = ->(stream) do
-    frames = []
-    while (chunk = stream.read)
-      frames << JSON.parse(chunk.sub(/\Adata: /, "").strip)
-    end
-    frames
-  end
-
-  it "streams a full run through a brute pipeline" do
-    seen_env = nil
-    run_loop = AgUi::RunLoop.new(system_prompt: "Be terse.") do |env|
-      seen_env = env
-      env[:events] << { type: :text_message_start, data: { message_id: "m1" } }
-      env[:events] << { type: :text_message_content, data: { message_id: "m1", delta: "Hello" } }
-      env[:events] << { type: :text_message_end, data: { message_id: "m1" } }
-      env[:messages].assistant("Hello")
-    end
-
-    app = AgUi.agent(agent_id: "default", &run_loop)
-    _status, _headers, body = request.(app, minimal_input)
-
-    frames = read_frames.(body)
-    frames.map { |f| f["type"] }.should == %w[
-      RUN_STARTED TEXT_MESSAGE_START TEXT_MESSAGE_CONTENT TEXT_MESSAGE_END RUN_FINISHED
-    ]
-
-    # The pipeline saw: system prompt (with context addendum) + history.
-    seen_env[:messages].map(&:role).should == [:system, :user, :assistant]
-    seen_env[:messages].first.content.should.include?("Be terse.")
-    seen_env[:messages].first.content.should.include?("currentPath: /data")
-  end
-
-  it "ends the run with RUN_ERROR when the terminal raises" do
-    run_loop = AgUi::RunLoop.new { |_env| raise "provider exploded" }
-    app = AgUi.agent(agent_id: "default", &run_loop)
-
-    _status, _headers, body = request.(app, minimal_input)
-    frames = read_frames.(body)
-
-    frames.map { |f| f["type"] }.should == %w[RUN_STARTED RUN_ERROR]
-    frames.last["message"].should == "provider exploded"
-    frames.last["code"].should == "RuntimeError"
-  end
-
-  it "supports extra brute middleware" do
-    marker = Class.new do
-      def initialize(app, note:)
-        @app = app
-        @note = note
-      end
-
-      def call(env)
-        env[:metadata][:note] = @note
-        @app.call(env)
-      end
-    end
-
-    seen = nil
-    run_loop = AgUi::RunLoop.new(middleware: [[marker, { note: "hi" }]]) do |env|
-      seen = env[:metadata][:note]
-      env[:messages].assistant("ok")
-    end
-
-    request.(AgUi.agent(&run_loop), minimal_input)
-    seen.should == "hi"
-  end
-
-  it "requires a terminal block" do
-    lambda { AgUi::RunLoop.new }.should.raise(ArgumentError)
-  end
-
-  it "executes server tools inline and loops the turn to completion" do
-    weather_tool = {
-      name: "get_weather",
-      description: "Weather for a city",
-      parameters: { "type" => "object" },
-      handler: ->(args) { { "city" => args["city"], "temp" => 21 } },
-    }
-
-    iterations = 0
-    terminal = ->(env) do
-      iterations += 1
-      if iterations == 1
-        env[:messages] << Brute::Message.new(
-          role: :assistant, content: nil,
-          tool_calls: [{ id: "tc1", name: "get_weather", arguments: { "city" => "Lisbon" } }],
-        )
-      else
-        # The model sees its own call + the executed result.
-        env[:messages].last.role.should == :tool
-        env[:messages].last.content.should == "{\"city\":\"Lisbon\",\"temp\":21}"
-        env[:events] << { type: :text_message_start, data: { message_id: "m2" } }
-        env[:events] << { type: :text_message_content, data: { message_id: "m2", delta: "21C in Lisbon" } }
-        env[:events] << { type: :text_message_end, data: { message_id: "m2" } }
-        env[:messages].assistant("21C in Lisbon")
-      end
-    end
-
-    run_loop = AgUi::RunLoop.new(server_tools: [weather_tool], &terminal)
-    app = AgUi.agent(agent_id: "default", &run_loop)
-
-    _status, _headers, stream = request.(app, minimal_input)
-    frames = read_frames.(stream)
-
-    iterations.should == 2
-    frames.map { |f| f["type"] }.should == %w[
-      RUN_STARTED
-      TOOL_CALL_START TOOL_CALL_ARGS TOOL_CALL_END TOOL_CALL_RESULT
-      TEXT_MESSAGE_START TEXT_MESSAGE_CONTENT TEXT_MESSAGE_END
-      RUN_FINISHED
-    ]
-    frames[4]["content"].should == "{\"city\":\"Lisbon\",\"temp\":21}"
-  end
-
-  it "streams the full A2UI sequence when the model renders a surface" do
-    catalog = AgUi::A2ui::Catalog.new(
-      catalog_id: "host://ai-catalog",
-      components: { "Card" => {} },
-    )
-
-    terminal = ->(env) do
-      env[:tools].map { |t| t["name"] }.should.include?("render_a2ui")
-      env[:messages].first.content.should.include?("A2UI Component Schema")
-
-      env[:messages] << Brute::Message.new(
-        role: :assistant, content: nil,
-        tool_calls: [{ id: "tc9", name: "render_a2ui", arguments: {
-          "surfaceId" => "s1",
-          "components" => [{ "id" => "root", "component" => "Card" }],
-        } }],
-      )
-    end
-
-    run_loop = AgUi::RunLoop.new(a2ui: catalog, &terminal)
-    app = AgUi.agent(agent_id: "default", &run_loop)
-
-    _status, _headers, stream = request.(app, minimal_input)
-    frames = read_frames.(stream)
-
-    frames.map { |f| f["type"] }.should == %w[
-      RUN_STARTED TOOL_CALL_START TOOL_CALL_ARGS TOOL_CALL_END
-      ACTIVITY_SNAPSHOT TOOL_CALL_RESULT RUN_FINISHED
-    ]
-
-    snapshot = frames[4]
-    snapshot["messageId"].should == "a2ui-surface-tc9"
-    snapshot["activityType"].should == "a2ui-surface"
-    snapshot["replace"].should == true
-    snapshot["content"]["a2ui_operations"][0]["createSurface"]["catalogId"]
-      .should == "host://ai-catalog"
-
-    result = frames[5]
-    result["toolCallId"].should == "tc9"
-    result["content"].should == "{\"status\":\"rendered\"}"
-  end
-end