simple_acp 0.0.1

data/lib/simple_acp/server/agent.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module SimpleAcp
+  module Server
+    # Wrapper for registered agent handlers.
+    #
+    # Encapsulates an agent's manifest (metadata) and handler (execution logic),
+    # normalizing different handler return types into a consistent format.
+    class Agent
+      # @return [Models::AgentManifest] the agent's metadata
+      attr_reader :manifest
+
+      # @return [#call] the handler that processes requests
+      attr_reader :handler
+
+      # Create a new agent.
+      #
+      # @param manifest [Models::AgentManifest] agent metadata
+      # @param handler [#call] callable that accepts a Context and returns messages
+      def initialize(manifest:, handler:)
+        @manifest = manifest
+        @handler = handler
+      end
+
+      # @return [String] the agent's name
+      def name
+        @manifest.name
+      end
+
+      # @return [String, nil] the agent's description
+      def description
+        @manifest.description
+      end
+
+      # Execute the agent handler with the given context.
+      #
+      # Normalizes various return types (Message, String, Array, Enumerator)
+      # into a consistent enumerable of {RunYield} or {RunYieldAwait} objects.
+      #
+      # @param context [Context] the execution context
+      # @return [Enumerable<RunYield, RunYieldAwait>] yielded results
+      def call(context)
+        result = @handler.call(context)
+
+        # Handle different return types
+        case result
+        when Enumerator, Enumerator::Lazy
+          # Generator-style handler that yields messages
+          result
+        when RunYield, RunYieldAwait
+          # Already wrapped
+          [result]
+        when Models::Message
+          # Single message return
+          [RunYield.new(result)]
+        when Array
+          # Array of messages or yields
+          result.map { |m| wrap_result_item(m) }
+        when String
+          # Simple string response
+          [RunYield.new(Models::Message.agent(result))]
+        else
+          # Try to convert to enumerator
+          result.respond_to?(:each) ? result.each : [wrap_result_item(result)]
+        end
+      end
+
+      # Check if the agent is valid for registration.
+      #
+      # @return [Boolean] true if manifest is valid and handler is callable
+      def valid?
+        @manifest.valid? && @handler.respond_to?(:call)
+      end
+
+      private
+
+      def wrap_result_item(item)
+        case item
+        when RunYield, RunYieldAwait
+          item
+        when Models::Message
+          RunYield.new(item)
+        when String
+          RunYield.new(Models::Message.agent(item))
+        else
+          item
+        end
+      end
+    end
+
+    # DSL module for defining agents with block syntax.
+    module AgentDSL
+      # Define an agent from a block.
+      #
+      # @param name [String] agent name (must follow RFC 1123 DNS label format)
+      # @param description [String, nil] human-readable description
+      # @param options [Hash] additional manifest options
+      # @option options [Array<String>] :input_content_types accepted MIME types
+      # @option options [Array<String>] :output_content_types produced MIME types
+      # @option options [Hash] :metadata agent metadata
+      # @yield [Context] block that handles agent requests
+      # @return [Agent] the created agent
+      def self.define(name:, description: nil, **options, &block)
+        manifest = Models::AgentManifest.new(
+          name: name,
+          description: description,
+          input_content_types: options[:input_content_types] || ["text/plain"],
+          output_content_types: options[:output_content_types] || ["text/plain"],
+          metadata: options[:metadata]
+        )
+
+        Agent.new(manifest: manifest, handler: block)
+      end
+    end
+  end
+end

data/lib/simple_acp/server/app.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "roda"
+require "json"
+
+module SimpleAcp
+  module Server
+    # Roda application implementing ACP HTTP endpoints.
+    #
+    # Provides REST endpoints for agent discovery, run management,
+    # and session handling. Supports sync, async, and streaming modes.
+    #
+    # == Endpoints
+    #
+    # - GET /ping - Health check
+    # - GET /agents - List agents
+    # - GET /agents/:name - Get agent manifest
+    # - POST /runs - Create a run
+    # - GET /runs/:id - Get run status
+    # - POST /runs/:id - Resume awaited run
+    # - POST /runs/:id/cancel - Cancel run
+    # - GET /runs/:id/events - Get run events
+    # - GET /session/:id - Get session info
+    class App < Roda
+      plugin :json
+      plugin :json_parser
+      plugin :all_verbs
+      plugin :halt
+
+      # Configure the Roda app with a server instance.
+      #
+      # @param server [Server::Base] the server to handle requests
+      # @return [void]
+      def self.configure(server)
+        @server = server
+      end
+
+      # Get the configured server instance.
+      #
+      # @return [Server::Base] the server
+      def self.server
+        @server
+      end
+
+      route do |r|
+        response["Content-Type"] = "application/json"
+
+        # Health check
+        r.get "ping" do
+          { status: "ok" }
+        end
+
+        # List agents
+        r.get "agents" do
+          limit = (r.params["limit"] || 10).to_i.clamp(1, 1000)
+          offset = (r.params["offset"] || 0).to_i
+
+          agents = self.class.server.agents.values
+          total = agents.length
+          agents = agents.drop(offset).take(limit)
+
+          {
+            agents: agents.map { |a| a.manifest.to_h },
+            total: total,
+            limit: limit,
+            offset: offset
+          }
+        end
+
+        # Get specific agent
+        r.get "agents", String do |name|
+          agent = self.class.server.agents[name]
+          unless agent
+            response.status = 404
+            r.halt({ error: Models::Error.not_found("Agent '#{name}' not found").to_h })
+          end
+          agent.manifest.to_h
+        end
+
+        # Runs endpoints
+        r.on "runs" do
+          # Create a new run (only matches POST /runs with no path segment)
+          r.is do
+            r.post do
+            body = r.params
+            request = Models::RunCreateRequest.from_hash(body)
+
+            unless request&.valid?
+              response.status = 400
+              r.halt({ error: Models::Error.invalid_input("Invalid run request").to_h })
+            end
+
+            mode = request.mode || Models::Types::RunMode::SYNC
+
+            begin
+              case mode
+              when Models::Types::RunMode::SYNC
+                run = self.class.server.run_sync(
+                  agent_name: request.agent_name,
+                  input: request.input,
+                  session_id: request.session_id,
+                  session: request.session
+                )
+                run.to_h
+              when Models::Types::RunMode::ASYNC
+                run = self.class.server.run_async(
+                  agent_name: request.agent_name,
+                  input: request.input,
+                  session_id: request.session_id,
+                  session: request.session
+                )
+                run.to_h
+              when Models::Types::RunMode::STREAM
+                headers = {
+                  "Content-Type" => "text/event-stream",
+                  "Cache-Control" => "no-cache",
+                  "Connection" => "keep-alive",
+                  "X-Accel-Buffering" => "no"
+                }
+
+                server_instance = self.class.server
+                req = request
+
+                body = proc do |stream|
+                  begin
+                    server_instance.run_stream(
+                      agent_name: req.agent_name,
+                      input: req.input,
+                      session_id: req.session_id,
+                      session: req.session
+                    ) do |event|
+                      stream.write(event.sse_format)
+                    end
+                  rescue => error
+                    SimpleAcp.logger&.error("Stream error: #{error.message}")
+                  ensure
+                    stream.close rescue nil
+                  end
+                end
+
+                r.halt [200, headers, body]
+              else
+                response.status = 400
+                r.halt({ error: Models::Error.invalid_input("Invalid mode: #{mode}").to_h })
+              end
+            rescue SimpleAcp::NotFoundError => e
+              response.status = 404
+              r.halt({ error: Models::Error.not_found(e.message).to_h })
+            rescue StandardError => e
+              response.status = 500
+              r.halt({ error: Models::Error.server_error(e.message).to_h })
+            end
+            end
+          end
+
+          r.on String do |run_id|
+            # Cancel a run (must come before r.is to match /cancel path)
+            r.post "cancel" do
+              begin
+                run = self.class.server.cancel_run(run_id)
+                run.to_h
+              rescue SimpleAcp::NotFoundError => e
+                response.status = 404
+                r.halt({ error: Models::Error.not_found(e.message).to_h })
+              end
+            end
+
+            # Get run events (must come before r.is to match /events path)
+            r.get "events" do
+              limit = (r.params["limit"] || 100).to_i.clamp(1, 1000)
+              offset = (r.params["offset"] || 0).to_i
+
+              events = self.class.server.storage.get_events(run_id, limit: limit, offset: offset)
+              { events: events.map(&:to_h) }
+            end
+
+            # Get run status or resume run (matches exactly /runs/:id)
+            r.is do
+              r.get do
+                run = self.class.server.storage.get_run(run_id)
+                unless run
+                  response.status = 404
+                  r.halt({ error: Models::Error.not_found("Run '#{run_id}' not found").to_h })
+                end
+                run.to_h
+              end
+
+              # Resume a paused run
+              r.post do
+              body = r.params
+              request = Models::RunResumeRequest.from_hash(body.merge("run_id" => run_id))
+
+              unless request&.valid?
+                response.status = 400
+                r.halt({ error: Models::Error.invalid_input("Invalid resume request").to_h })
+              end
+
+              mode = request.mode
+
+              begin
+                case mode
+                when Models::Types::RunMode::SYNC
+                  run = self.class.server.resume_sync(
+                    run_id: run_id,
+                    await_resume: request.await_resume
+                  )
+                  run.to_h
+                when Models::Types::RunMode::STREAM
+                  headers = {
+                    "Content-Type" => "text/event-stream",
+                    "Cache-Control" => "no-cache",
+                    "Connection" => "keep-alive",
+                    "X-Accel-Buffering" => "no"
+                  }
+
+                  server_instance = self.class.server
+                  req = request
+                  rid = run_id
+
+                  body = proc do |stream|
+                    begin
+                      server_instance.resume_stream(
+                        run_id: rid,
+                        await_resume: req.await_resume
+                      ) do |event|
+                        stream.write(event.sse_format)
+                      end
+                    rescue => error
+                      SimpleAcp.logger&.error("Resume stream error: #{error.message}")
+                    ensure
+                      stream.close rescue nil
+                    end
+                  end
+
+                  r.halt [200, headers, body]
+                else
+                  response.status = 400
+                  r.halt({ error: Models::Error.invalid_input("Invalid mode: #{mode}").to_h })
+                end
+              rescue SimpleAcp::NotFoundError => e
+                response.status = 404
+                r.halt({ error: Models::Error.not_found(e.message).to_h })
+              rescue StandardError => e
+                response.status = 500
+                r.halt({ error: Models::Error.server_error(e.message).to_h })
+              end
+              end
+            end
+          end
+        end
+
+        # Session endpoint
+        r.get "session", String do |session_id|
+          session = self.class.server.storage.get_session(session_id)
+          unless session
+            response.status = 404
+            r.halt({ error: Models::Error.not_found("Session '#{session_id}' not found").to_h })
+          end
+          Models::SessionResponse.from_session(session).to_h
+        end
+      end
+    end
+  end
+end