🥮 mooncakes.io

    colmugx/acp/agent does not have a README file

    AgentAuthenticateHandler

    source

    Typed async authentication handlers.

    AgentCancelHandler

    source
    type AgentCancelHandler = async (AgentContext, 
    CancelParams    ) -> Unit

    AgentCloseSessionHandler

    source

    AgentContextNotificationBroker

    source
    type AgentContextNotificationBroker = async (
    ClientNotification    ) -> Result[Unit, AgentContextError]

    The notification-side composition seam. Notifications have no response value, so success is represented only by Unit.

    AgentContextRequestBroker

    source

    The request-side composition seam. It is a one-shot broker, not a queue or a mutable registry; connection state remains owned by the runtime.

    AgentDeleteSessionHandler

    source

    AgentForkSessionHandler

    source

    AgentListSessionsHandler

    source

    AgentLoadSessionHandler

    source

    Typed async handler signatures for optional session operations.

    AgentLogoutHandler

    source

    AgentNewSessionHandler

    source

    Typed async handler signatures for the required session operations.

    AgentPromptHandler

    source

    AgentResumeSessionHandler

    source

    AgentSetConfigOptionHandler

    source

    AgentSetModeHandler

    source

    AgentAdapterError

    source
    pub(all) suberror AgentAdapterError {
      EndpointMismatch(reason~ : String)
      UnexpectedMessage(kind~ : String)
      LateCompletion(request_id~ : 
    RequestId    )
      CompletionMismatch(method_name~ : String)
    } derive(Eq, 
    Debug    )

    Fail-fast adapter failures indicate an invalid composition boundary or a completion that no longer belongs to the owner-held reservation.

    AgentContextError

    source
    pub(all) suberror AgentContextError {
      AgentContextUnavailable(method_name~ : String)
      AgentContextCancelled(method_name~ : String)
      AgentContextBrokerFailure(method_name~ : String)
      AgentContextReplyMismatch(method_name~ : String)
    } derive(Eq, 
    Debug    )

    Failures crossing an Agent-to-Client context port. Runtime adapters may construct these values from negotiated capability gates or transport cancellation, while application code never handles untyped JSON here.

    AgentAdapterAdmission

    source
    pub(all) enum AgentAdapterAdmission {
      Immediate(AgentAdapterStep)
      Invoke(state~ : AgentAdapterState, invocation~ : AgentAdapterInvocation)
    }

    Admission is synchronous and owner-loop controlled. Initialize and protocol errors are immediate; only typed invocations cross the async task boundary.

    AgentAdapterCommand

    source
    pub(all) enum AgentAdapterCommand {
      CancelRequest(request_id~ : 
    RequestId    )
      TraceError(method_name~ : String, error~ : 
    JsonRpcError    )
      CloseConnection(reason~ : String)
    } derive(Eq, 
    Debug    )

    Runtime-facing commands emitted by the Agent adapter. These values are intents only; the adapter never owns tasks, queues, or connection state.

    AgentAdapterCompletion

    source
    pub(all) enum AgentAdapterCompletion {
      AuthenticateCompleted(id~ : 
    RequestId    , result~ : Result[
    AuthenticateResult    , 
    HandlerError    ])
      LogoutCompleted(id~ : 
    RequestId    , result~ : Result[
    LogoutResult    , 
    HandlerError    ])
      SessionNewCompleted(id~ : 
    RequestId    , result~ : Result[
    NewSessionResult    , 
    HandlerError    ])
      SessionLoadCompleted(id~ : 
    RequestId    , result~ : Result[
    LoadSessionResult    , 
    HandlerError    ])
      SessionResumeCompleted(id~ : 
    RequestId    , result~ : Result[
    ResumeSessionResult    , 
    HandlerError    ])
      SessionForkCompleted(id~ : 
    RequestId    , result~ : Result[
    ForkSessionResult    , 
    HandlerError    ])
      SessionListCompleted(id~ : 
    RequestId    , result~ : Result[
    ListSessionsResult    , 
    HandlerError    ])
      SessionDeleteCompleted(id~ : 
    RequestId    , result~ : Result[
    DeleteSessionResult    , 
    HandlerError    ])
      SessionCloseCompleted(id~ : 
    RequestId    , result~ : Result[
    CloseSessionResult    , 
    HandlerError    ])
      SessionSetModeCompleted(id~ : 
    RequestId    , result~ : Result[
    SetSessionModeResult    , 
    HandlerError    ])
      SessionSetConfigOptionCompleted(id~ : 
    RequestId    , result~ : Result[
    SetSessionConfigOptionResult    , 
    HandlerError    ])
      SessionPromptCompleted(id~ : 
    RequestId    , result~ : Result[
    PromptResult    , 
    HandlerError    ])
      SessionCancelCompleted(result~ : Result[Unit, 
    HandlerError    ])
    } derive(Eq, 
    Debug    )

    The result of one typed handler invocation. No wire response is produced here: the owner loop serializes this completion through agent_adapter_complete.

    AgentAdapterInvocation

    source
    pub(all) enum AgentAdapterInvocation {
      AuthenticateInvocation(id~ : 
    RequestId    , params~ : 
    AuthenticateParams    )
      LogoutInvocation(id~ : 
    RequestId    , params~ : 
    LogoutParams    )
      SessionNewInvocation(id~ : 
    RequestId    , params~ : 
    NewSessionParams    )
      SessionLoadInvocation(id~ : 
    RequestId    , params~ : 
    LoadSessionParams    )
      SessionResumeInvocation(id~ : 
    RequestId    , params~ : 
    ResumeSessionParams    )
      SessionForkInvocation(id~ : 
    RequestId    , params~ : 
    ForkSessionParams    )
      SessionListInvocation(id~ : 
    RequestId    , params~ : 
    ListSessionsParams    )
      SessionDeleteInvocation(id~ : 
    RequestId    , params~ : 
    DeleteSessionParams    )
      SessionCloseInvocation(id~ : 
    RequestId    , params~ : 
    CloseSessionParams    )
      SessionSetModeInvocation(id~ : 
    RequestId    , params~ : 
    SetSessionModeParams    )
      SessionSetConfigOptionInvocation(id~ : 
    RequestId    , params~ : 
    SetSessionConfigOptionParams    )
      SessionPromptInvocation(id~ : 
    RequestId    , params~ : 
    PromptParams    )
      SessionCancelInvocation(params~ : 
    CancelParams    )
    } derive(Eq, 
    Debug    )

    A typed operation admitted by the Agent adapter. The operation carries only immutable protocol values; connection state is owned by the caller that admitted it.

    AgentAdapterOutput

    source

    Typed adapter output. Responses and notifications are wire values that the owner loop serializes; commands are interpreted by the native runtime.

    AgentAdapterReservation

    source
    pub(all) enum AgentAdapterReservation {
      Idle
      AuthenticatePending(
    RequestId    )
      LogoutPending(
    RequestId    )
    } derive(Eq, 
    Debug    )

    Authentication/lifecycle reservations are immutable protocol state. A pending reservation prevents a second state-changing request from using a stale snapshot while its first handler is still running.

    AgentAdapterState

    source

    State owned by the connection/reducer loop. Handler tasks receive a copy of this value only through an admission result; they never mutate it.

    AgentAdapterState::protocol

    source

    AgentAdapterState::reservation

    source

    AgentAdapterStep

    source
    pub(all) struct AgentAdapterStep {
      state : AgentAdapterState
      outputs : Array[AgentAdapterOutput]
    } derive(Eq, 
    Debug    )

    One explicit state transition produced by admission or completion.

    AgentAuthService

    source

    Immutable authentication service. methods is copied and checked before the service can be used by an endpoint.

    AgentContext

    source

    Opaque typed outbound context supplied to one Agent invocation. It owns the two immutable broker closures plus one read-only client_info accessor naming the connecting Client implementation; it contains no connection state, queue, task, global registry, or raw protocol value.

    AgentContext::cancel_request

    source
    async fn AgentContext::cancel_request(self : AgentContext, request_id : 
    RequestId    ) -> Unit raise AgentContextError

    Request cancellation of one in-flight typed request. The runtime decides how to cancel the task; this facade only emits the typed notification.

    AgentContext::elicitation_complete

    source

    Complete a typed elicitation notification. No response is synthesized.

    AgentContext::elicitation_create

    source

    Create either form- or URL-mode elicitation using the stable union.

    AgentContext::read_text_file

    source

    Read one absolute filesystem path through the negotiated Client service.

    AgentContext::request_permission

    source

    Ask the Client for permission to execute a tool call.

    AgentContext::session_update

    source

    Deliver a typed session update notification. No response is synthesized.

    AgentContext::terminal_create

    source

    Create a terminal owned by the caller's Client runtime.

    AgentContext::terminal_kill

    source

    Kill a typed terminal process.

    AgentContext::terminal_output

    source

    Read accumulated output from a typed terminal handle.

    AgentContext::terminal_release

    source

    Release a typed terminal handle.

    AgentContext::terminal_wait_for_exit

    source

    Wait for a typed terminal to exit.

    AgentContext::write_text_file

    source

    Write one absolute filesystem path through the negotiated Client service.

    AgentEndpoint

    source

    An opaque, fully validated Agent endpoint. It contains immutable service closures and derived initialization data, never connection-scoped state.

    AgentEndpoint::auth_methods

    source

    Return a defensive copy of the advertised authentication methods.

    AgentEndpoint::authenticate

    source

    AgentEndpoint::cancel

    source

    Invoke the required typed session/cancel handler.

    AgentEndpoint::capabilities

    source

    Return capabilities derived from service presence and support values.

    AgentEndpoint::close_session

    source

    AgentEndpoint::delete_session

    source

    AgentEndpoint::fork_session

    source

    AgentEndpoint::info

    source

    Return the immutable implementation information for initialization.

    AgentEndpoint::list_sessions

    source

    AgentEndpoint::load_session

    source

    AgentEndpoint::logout

    source

    AgentEndpoint::new_session

    source

    Invoke the required typed session/new handler.

    AgentEndpoint::prompt

    source

    Invoke the required typed session/prompt handler.

    AgentEndpoint::resume_session

    source

    AgentEndpoint::set_config_option

    source

    AgentEndpoint::set_mode

    source

    AgentOutboundReply

    source
    pub(all) enum AgentOutboundReply {
      AgentReplyRequestPermission(
    RequestPermissionResponse    )
      AgentReplyFsReadTextFile(
    ReadTextFileResult    )
      AgentReplyFsWriteTextFile(
    WriteTextFileResult    )
      AgentReplyTerminalCreate(
    TerminalCreateResult    )
      AgentReplyTerminalOutput(
    TerminalOutputResult    )
      AgentReplyTerminalWaitForExit(
    TerminalWaitForExitResult    )
      AgentReplyTerminalKill(
    TerminalKillResult    )
      AgentReplyTerminalRelease(
    TerminalReleaseResult    )
      AgentReplyElicitationCreate(
    ElicitationCreateResult    )
    } derive(Eq, 
    Debug    )

    The closed set of typed results that a Client can return to an Agent.

    Constructor names are deliberately prefixed so this facade cannot be confused with the corresponding wire request or endpoint constructors.

    AgentSessionService

    source
    pub struct AgentSessionService {
      new_handler : async (AgentContext, 
    NewSessionParams    ) -> 
    NewSessionResult
      prompt_handler : async (AgentContext, 
    PromptParams    ) -> 
    PromptResult
      cancel_handler : async (AgentContext, 
    CancelParams    ) -> Unit
      load_handler : async (AgentContext, 
    LoadSessionParams    ) -> 
    LoadSessionResult    ?
      resume_handler : async (AgentContext, 
    ResumeSessionParams    ) -> 
    ResumeSessionResult    ?
      fork_handler : async (AgentContext, 
    ForkSessionParams    ) -> 
    ForkSessionResult    ?
      list_handler : async (AgentContext, 
    ListSessionsParams    ) -> 
    ListSessionsResult    ?
      delete_handler : async (AgentContext, 
    DeleteSessionParams    ) -> 
    DeleteSessionResult    ?
      close_handler : async (AgentContext, 
    CloseSessionParams    ) -> 
    CloseSessionResult    ?
      set_mode_handler : async (AgentContext, 
    SetSessionModeParams    ) -> 
    SetSessionModeResult    ?
      set_config_option_handler : async (AgentContext, 
    SetSessionConfigOptionParams    ) -> 
    SetSessionConfigOptionResult    ?
    }

    Immutable required/optional session service. The fields remain private so callers cannot construct a half-populated service record.

    AgentSpec

    source

    Immutable specification consumed by the Reader composition program.

    AgentSupport

    source
    pub struct AgentSupport {
      prompt_image : Bool
      prompt_audio : Bool
      prompt_embedded_context : Bool
      mcp_http : Bool
      mcp_sse : Bool
      additional_directories : Bool
    }

    Non-service support declarations used to derive prompt/MCP capabilities. These are immutable values, not a second manually supplied capability map.

    agent_adapter_admit

    source

    Decode and admit one message. This function is synchronous and pure from the owner loop's perspective; it never calls an application handler.

    agent_adapter_cancel_completion

    source
    fn agent_adapter_cancel_completion(invocation : AgentAdapterInvocation) -> AgentAdapterCompletion

    Synthesize the typed cancellation completion for one invocation. The owner loop uses this when it grants an inbound cancellation so the reservation and wire id settle through the normal completion path.

    agent_adapter_complete

    source
    fn agent_adapter_complete(state : AgentAdapterState, invocation : AgentAdapterInvocation, completion : AgentAdapterCompletion) -> AgentAdapterStep raise AgentAdapterError

    Complete one admitted invocation in the owner loop. A state-changing completion must match its immutable reservation; duplicate/late auth and logout completions fail explicitly instead of producing a second response.

    agent_adapter_execute

    source
    async fn agent_adapter_execute(invocation : AgentAdapterInvocation, endpoint : AgentEndpoint, context : AgentContext) -> AgentAdapterCompletion noraise

    Execute one already-admitted typed operation. This function has no protocol state parameter and cannot emit stdout; it only returns a typed completion for the owner loop.

    agent_adapter_failure_completion

    source
    fn agent_adapter_failure_completion(invocation : AgentAdapterInvocation) -> AgentAdapterCompletion

    Synthesize the redacted typed failure completion for one invocation, following the agent_adapter_call convention for unknown failures. The owner task boundary uses this when async execution itself fails before a typed completion exists.

    agent_adapter_invocation_method_name

    source
    fn agent_adapter_invocation_method_name(invocation : AgentAdapterInvocation) -> String

    The stable wire method name of one typed invocation. Runtime bridges use it for trace intents only; it never replaces the typed completion.

    agent_adapter_state_new

    source

    agent_auth_service

    source

    agent_context

    source

    Construct one immutable context around caller-owned typed transport ports. This is intentionally a one-shot constructor rather than a builder. client_info defaults to a constant-Omitted accessor; the runtime runner injects the accessor backed by the peer's initialize params.

    agent_endpoint_from_spec

    source
    fn agent_endpoint_from_spec(spec : AgentSpec) -> AgentEndpoint

    agent_runtime_owner_port

    source

    Bind one Agent endpoint and its outbound context onto the single connection owner-loop engine. The returned port captures the immutable endpoint and context values plus one owner-write publication cell; every protocol transition stays inside the engine-owned AgentAdapterState. There is no second owner loop, shadow pending map, Mutex, or builder surface here: the only Ref is the write-once clientInfo cell that the owner-loop admit path publishes so session handlers read the connecting client's identity through the read-only AgentContext::client_info accessor. Handler tasks never write it.

    Residual AgentAdapterError values (EndpointMismatch, UnexpectedMessage) indicate composition or protocol bugs, but the owner port closures are total by signature. Each residual is therefore answered with an explicit typed fallback instead of being swallowed: requests get exactly one internal-error response plus one trace effect, notifications get one trace effect and no response, and the owner state is held unchanged. The fallback is visible on the wire and in the trace sink; it is never a silent success.

    agent_runtime_run

    source
    async fn agent_runtime_run(endpoint~ : AgentEndpoint, context~ : AgentContext, initial_state~ : AgentAdapterState, ports~ : 
    RuntimePorts    , options~ : 
    RuntimeOptions    ) -> Unit

    Run one Agent connection on the single native owner-loop engine. This is a thin composition of connection_runtime_run_owner with agent_runtime_owner_port: it validates the options fail-fast and creates no connection state of its own.

    agent_runtime_run_with_outbound

    source

    Run one Agent connection on the single native owner-loop engine with the engine-level outbound channel handed to the Agent context factory. The factory runs after the connection-local queues and shutdown state exist and before the loop starts; it typically builds agent_context_over_channel (in connection/broker) so handlers running mid-execution can issue reverse requests and stream notifications through the real engine. This runner adds no second loop or channel state of its own: it validates the options fail-fast and reuses the same single reader/writer/reducer engine as agent_runtime_run, whose signature and behavior stay unchanged.

    agent_serve_stdio

    source
    async fn agent_serve_stdio(endpoint~ : AgentEndpoint, context~ : AgentContext, initial_state~ : AgentAdapterState, options? : 
    RuntimeOptions    , trace? : (
    RuntimeTraceEvent    ) -> Unit) -> Unit

    Serve this process's real stdio as one Agent connection: inbound ACP frames arrive on stdin, outbound frames (including one final response per request) go to stdout, and every diagnostic goes to the trace sink (stderr by default). This is a thin composition of agent_runtime_run over runtime_stdio_ports: it validates the options fail-fast before any I/O binding and creates no connection state of its own. The loop ends when stdin reaches EOF or the engine fails; both outcomes surface through the same single reader/writer/reducer engine as every other runner.

    agent_serve_stdio_with_outbound

    source

    Serve this process's real stdio as one Agent connection with the engine-level outbound channel handed to the Agent context factory, so handlers running mid-execution can stream session/update notifications and issue reverse requests (session/request_permission, elicitation, filesystem, terminal) through the real engine instead of a fail-fast broker. Without this composition a stdio Agent could answer requests but never exercise the reverse direction of the protocol; the factory timing mirrors agent_runtime_run_with_outbound (after the connection-local queues exist, before the loop starts). This is a thin composition over runtime_stdio_ports: it validates the options fail-fast before any I/O binding and creates no second loop, channel state, or connection state of its own. The loop ends when stdin reaches EOF or the engine fails.

    agent_session_service

    source
    fn agent_session_service(new_session~ : async (AgentContext, 
    NewSessionParams    ) -> 
    NewSessionResult    , prompt~ : async (AgentContext, 
    PromptParams    ) -> 
    PromptResult    , cancel~ : async (AgentContext, 
    CancelParams    ) -> Unit, load? : async (AgentContext, 
    LoadSessionParams    ) -> 
    LoadSessionResult    , resume_session? : async (AgentContext, 
    ResumeSessionParams    ) -> 
    ResumeSessionResult    , fork_session? : async (AgentContext, 
    ForkSessionParams    ) -> 
    ForkSessionResult    , list? : async (AgentContext, 
    ListSessionsParams    ) -> 
    ListSessionsResult    , delete? : async (AgentContext, 
    DeleteSessionParams    ) -> 
    DeleteSessionResult    , close? : async (AgentContext, 
    CloseSessionParams    ) -> 
    CloseSessionResult    , set_mode? : async (AgentContext, 
    SetSessionModeParams    ) -> 
    SetSessionModeResult    , set_config_option? : async (AgentContext, 
    SetSessionConfigOptionParams    ) -> 
    SetSessionConfigOptionResult    ) -> AgentSessionService

    Compose all required session callbacks once. Optional callbacks are represented by None; there is no mutable registration phase.

    agent_spec

    source

    agent_support

    source
    fn agent_support(prompt_image? : Bool, prompt_audio? : Bool, prompt_embedded_context? : Bool, mcp_http? : Bool, mcp_sse? : Bool, additional_directories? : Bool) -> AgentSupport

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io