🥮 mooncakes.io

    moonacp

    The Agent Client Protocol for MoonBit: editors talking to agents, over ASGI or stdio.

    acp
    agent-client-protocol
    agent
    client
    editor
    coding-agent
    zed
    json-rpc
    jsonrpc
    rpc
    asgi
    stdio
    stdin
    websocket
    ws
    sse
    http
    streamable-http
    session
    prompt
    streaming
    tool-call
    permission
    terminal
    elicitation
    protocol
    async
    server
    moonbit
    Download zip
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    10 hours ago
    Downloads
    6

    #moonacp

    An editor talks, an agent answers. The Agent Client Protocol for MoonBit.

    Guide · API reference · mooncakes

    An editor and a coding agent are two programs that need to agree on more than text: who owns the session, how an answer arrives while it is still being written, who may write a file, who runs the command. This library is that agreement — the session, the streamed updates, the permission prompts, the files and the terminals — with both sides of it in one place and two transports to carry it.

    moon add moonbitstack/moonacp

    #An agent in full

    Three methods are required. Everything else has a default that reports itself as unsupported, so an agent advertises in initialize exactly what it answers.

    impl @moonacp.Agent for Notes with fn initialize(self, request) {
      ignore(self)
      ignore(request)
      {
        ..@moonacp.Initialized::new(),
        capabilities: {
          ..@moonacp.AgentCapabilities::none(),
          prompt: { image: true, audio: false, embedded_context: true, meta: None },
        },
        agent_info: Some(@moonacp.Implementation::new("notes", "0.1.0")),
      }
    }

    impl @moonacp.Agent for Notes with fn new_session(self, request) {
      self.sessions = self.sessions + 1
      { session_id: "notes-\{self.sessions}", modes: None, config_options: None, meta: None }
    }

    impl @moonacp.Agent for Notes with fn prompt(self, request, session) {
      let text = request.prompt.map(block => match block {
        @moonacp.ContentBlock::Text(content) => content.text
        _ => ""
      }).join(" ")
      session.update(@moonacp.SessionUpdate::AgentMessageChunk({
        content: @moonacp.ContentBlock::Text({ text: "You said: " + text, annotations: None, meta: None }),
        message_id: None,
        meta: None,
      }))
      @moonacp.StopReason::EndTurn
    }

    Serve it on the pipe an editor launches it with:

    async fn main {
      @stdio.serve_stdio(Notes::new())
    }

    #An editor in full

    The client side is the same shape: implement Client for what the editor answers, connect it to a transport, and run the connection so updates arrive while a turn is in flight.

    let child = @stdio.spawn(editor, ["/usr/local/bin/notes-agent"])
    let conn = child.conn()
    @async.with_task_group(async fn(group) {
      group.spawn_bg(async fn() { conn.run() })
      ignore(conn.initialize({
        protocol_version: @moonacp.protocol_version,
        client_capabilities: @moonacp.ClientCapabilities::none(),
        client_info: None,
        meta: None,
      }))
      let session = conn.new_session({
        cwd: "/work",
        additional_directories: None,
        mcp_servers: [],
        meta: None,
      })
      let answer = conn.prompt({
        session_id: session.session_id,
        prompt: [@moonacp.ContentBlock::Text({ text: "hello", annotations: None, meta: None })],
        meta: None,
      })
      println(answer.stop_reason.to_string())
    })

    #Transports

    TransportEntry pointShape
    stdio@stdio.serve_stdio, @stdio.spawnOne JSON-RPC message per line on the process's own streams. The transport an editor uses when it launches an agent.
    ASGI@asgi.to_asgiOne endpoint: POST for client-to-agent messages, long-lived GET streams for the answers, DELETE to end a connection, and a WebSocket upgrade carrying the same messages on one channel.

    The remote transport follows the protocol's request for discussion of 2026-11-04. That document is not final, and the schema has no member for the connection identifier it introduces: the identifier travels in the initialize answer's _meta and in an Acp-Connection-Id header.

    #The interface

    // The agent's side
    pub(open) trait Agent {
      async fn initialize(Self, Initialize) -> Initialized raise Refused
      async fn new_session(Self, NewSession) -> SessionStarted raise Refused
      async fn prompt(Self, Prompt, Session) -> StopReason raise Refused
      // authenticate, logout, session/load, session/resume, session/list, session/delete,
      // session/close, session/set_mode, session/set_config_option, cancel: optional
    }

    // What a prompt uses to talk back
    pub async fn Session::update(Self, SessionUpdate) -> Unit raise Refused
    pub async fn Session::request_permission(Self, Permission) -> Outcome raise Refused
    pub async fn Session::read_text_file(Self, String, line? : Int64, limit? : Int64) -> String raise Refused
    pub async fn Session::write_text_file(Self, String, String) -> Unit raise Refused
    pub async fn Session::terminal(Self, String, ..) -> Terminal raise Refused
    pub async fn Session::elicit(Self, Elicitation) -> Answer raise Refused

    // The editor's side
    pub(open) trait Client {
      async fn update(Self, String, SessionUpdate) -> Unit
      async fn request_permission(Self, Permission) -> Outcome raise Refused
      // read_text_file, write_text_file, create_terminal, terminal_output, wait_for_terminal_exit,
      // kill_terminal, release_terminal, elicit: optional
    }

    pub fn serve(&Agent, &@peer.Frames) -> @peer.Peer
    pub fn connect(&Client, &@peer.Frames) -> Conn
    pub async fn Conn::initialize(Self, Initialize) -> Initialized raise Refused
    pub async fn Conn::prompt(Self, Prompt) -> PromptResult raise Refused
    pub async fn Conn::cancel(Self, String) -> Unit raise Refused
    pub async fn Conn::run(Self) -> Unit

    The wire types are the schema's own: ContentBlock, SessionUpdate with its fourteen shapes, ToolCall, StopReason, AgentCapabilities, ClientCapabilities, the MCP server records, the elicitation forms, and one type per method for its parameters and its answer.

    #MCP servers

    A client names the MCP servers it wants in session/new; launching them and talking to them is the agent's job, and it is written where that job lives — in the example. mcp.mbt there spawns each stdio server, completes the MCP handshake, asks what tools it offers, and closes its input when the session ends. The library itself carries the servers' records and nothing more, because speaking MCP is a protocol of its own.

    #Consistency

    The official conformance suite runs against the example agent on every push, and both official SDKs are driven in both directions. The suite's verdict is CONFORMANT, with every mandatory requirement and every capability the example advertises passing — including its advisory check that the agent connects to the MCP server a session is given. One gap remains, and it is listed rather than hidden:

    • The remote transport has not been driven by the official Rust SDK's HTTP client, which the Rust SDK does not publish yet.

    #License

    Apache-2.0.

    Agent

    source
    pub(open) trait Agent {
      async fn initialize(Self, Initialize) -> Initialized raise Refused
      async fn authenticate(Self, Authenticate) -> Unit raise Refused = _
      async fn logout(Self) -> Unit raise Refused = _
      async fn new_session(Self, NewSession) -> SessionStarted raise Refused
      async fn load_session(Self, LoadSession, Session) -> SessionStarted raise Refused = _
      async fn resume_session(Self, ResumeSession, Session) -> SessionStarted raise Refused = _
      async fn list_sessions(Self, ListSessions) -> SessionList raise Refused = _
      async fn delete_session(Self, DeleteSession) -> Unit raise Refused = _
      async fn close_session(Self, CloseSession) -> Unit raise Refused = _
      async fn set_mode(Self, SetMode) -> Unit raise Refused = _
      async fn set_config_option(Self, SetConfigOption) -> Array[ConfigOption] raise Refused = _
      async fn prompt(Self, Prompt, Session) -> StopReason raise Refused
      async fn cancel(Self, id : String) -> Unit = _
    }

    The agent side. Implement what the agent can do and leave the rest: initialize and new_session and prompt are the three every agent has, the others have defaults that report themselves as unsupported.

    Client

    source
    pub(open) trait Client {
      async fn update(Self, String, SessionUpdate) -> Unit
      async fn request_permission(Self, Permission) -> Outcome raise Refused
      async fn read_text_file(Self, ReadTextFile) -> String raise Refused = _
      async fn write_text_file(Self, WriteTextFile) -> Unit raise Refused = _
      async fn create_terminal(Self, TerminalCommand) -> String raise Refused = _
      async fn terminal_output(Self, TerminalRequest) -> TerminalOutput raise Refused = _
      async fn wait_for_terminal_exit(Self, TerminalRequest) -> ExitStatus raise Refused = _
      async fn kill_terminal(Self, TerminalRequest) -> Unit raise Refused = _
      async fn release_terminal(Self, TerminalRequest) -> Unit raise Refused = _
      async fn elicit(Self, Elicitation) -> Answer raise Refused = _
    }

    The client side. update is the only method the protocol requires; the rest exist so the agent can ask for them, and a client that leaves one out answers -32601 when the agent asks.

    Refused

    source
    pub(all) suberror Refused {
      Refused(code~ : Int, message~ : String, data~ : 
    Json    ?)
      Unsupported(name~ : String)
      Malformed(reason~ : String)
      Closed(reason~ : String)
    } derive(Eq)

    What a handler raises, and what the other side's error object becomes when a call fails. A variant's code is the JSON-RPC code it travels as: Refused(code~, ..) carries the wire code itself, Unsupported is -32601, Malformed is -32602.

    Refused::code

    source
    fn Refused::code(self : Refused) -> Int

    The code this failure travels as.

    Refused::data

    source

    Anything else attached to the failure.

    Refused::equal

    source
    fn Refused::equal(Refused, Refused) -> Bool

    Refused::failure

    source

    The wire form of a failure.

    Refused::message

    source
    fn Refused::message(self : Refused) -> String

    What the other side reads.

    Refused::new

    source
    fn Refused::new(code : Int, message : String, data? : 
    Json    ) -> Refused

    An error object with a code of your choosing.

    Refused::not_equal

    source
    fn Refused::not_equal(x : Refused, y : Refused) -> Bool

    AgentAuthCapabilities

    source
    pub(all) struct AgentAuthCapabilities {
      logout : Bool
      meta : 
    Json    ?
    } derive(Eq)

    Authentication the agent offers.

    AgentAuthCapabilities::equal

    source

    AgentAuthCapabilities::from_json

    source

    AgentAuthCapabilities::none

    source

    No authentication step offered.

    AgentAuthCapabilities::not_equal

    source

    AgentAuthCapabilities::to_json

    source

    AgentCapabilities

    source
    pub(all) struct AgentCapabilities {
      load_session : Bool
      prompt : PromptCapabilities
      mcp : McpCapabilities
      session : SessionCapabilities
      auth : AgentAuthCapabilities?
      meta : 
    Json    ?
    } derive(Eq)

    Everything the agent says it can do, sent back from initialize.

    AgentCapabilities::equal

    source

    AgentCapabilities::from_json

    source

    AgentCapabilities::none

    source

    An agent that supports only session/new and session/prompt.

    AgentCapabilities::not_equal

    source
    fn AgentCapabilities::not_equal(x : AgentCapabilities, y : AgentCapabilities) -> Bool

    AgentCapabilities::to_json

    source

    Annotations

    source
    pub(all) struct Annotations {
      audience : Array[Role]?
      last_modified : String?
      priority : Double?
      meta : 
    Json    ?
    } derive(Eq)

    Hints for how a client shows a piece of content.

    Annotations::equal

    source
    fn Annotations::equal(Annotations, Annotations) -> Bool

    Annotations::from_json

    source

    Annotations::not_equal

    source
    fn Annotations::not_equal(x : Annotations, y : Annotations) -> Bool

    Annotations::to_json

    source

    Answer

    source
    pub(all) enum Answer {
      Accept(Map[String, 
    Json    ]?)
      Decline
      Cancel
      Other(String)
    } derive(Eq)

    What the user did with the ask. content holds one value per field, of whatever type the field asked for, so it stays raw.
    impl FromJson for Answer
    impl ToJson for Answer

    Answer::equal

    source
    fn Answer::equal(Answer, Answer) -> Bool

    Answer::from_json

    source

    Answer::not_equal

    source
    fn Answer::not_equal(x : Answer, y : Answer) -> Bool

    Answer::to_json

    source

    AudioContent

    source
    pub(all) struct AudioContent {
      data : String
      mime_type : String
      annotations : Annotations?
      meta : 
    Json    ?
    } derive(Eq)

    Audio, base64 in data.

    AudioContent::equal

    source

    AudioContent::from_json

    source

    AudioContent::not_equal

    source
    fn AudioContent::not_equal(x : AudioContent, y : AudioContent) -> Bool

    AudioContent::to_json

    source

    AuthMethod

    source
    pub(all) enum AuthMethod {
      Terminal(AuthMethodTerminal)
      Agent(AuthMethodAgent)
    } derive(Eq)

    An authentication method the agent offers, one of two shapes tagged by type on the wire; the agent-driven one carries no tag.

    AuthMethod::equal

    source
    fn AuthMethod::equal(AuthMethod, AuthMethod) -> Bool

    AuthMethod::from_json

    source

    AuthMethod::not_equal

    source
    fn AuthMethod::not_equal(x : AuthMethod, y : AuthMethod) -> Bool

    AuthMethod::to_json

    source

    AuthMethodAgent

    source
    pub(all) struct AuthMethodAgent {
      id : String
      name : String
      description : String?
      meta : 
    Json    ?
    } derive(Eq)

    The agent runs the flow itself once authenticate is called.

    AuthMethodAgent::equal

    source

    AuthMethodAgent::from_json

    source

    AuthMethodAgent::not_equal

    source
    fn AuthMethodAgent::not_equal(x : AuthMethodAgent, y : AuthMethodAgent) -> Bool

    AuthMethodAgent::to_json

    source

    AuthMethodTerminal

    source
    pub(all) struct AuthMethodTerminal {
      id : String
      name : String
      description : String?
      args : Array[String]?
      env : Map[String, String]?
      meta : 
    Json    ?
    } derive(Eq)

    The client runs a command to authenticate.

    AuthMethodTerminal::equal

    source

    AuthMethodTerminal::from_json

    source

    AuthMethodTerminal::not_equal

    source

    AuthMethodTerminal::to_json

    source

    Authenticate

    source
    pub(all) struct Authenticate {
      method_id : String
      meta : 
    Json    ?
    } derive(Eq)

    Names one of the methods from initialize.

    Authenticate::equal

    source

    Authenticate::from_json

    source

    Authenticate::not_equal

    source
    fn Authenticate::not_equal(x : Authenticate, y : Authenticate) -> Bool

    Authenticate::to_json

    source

    AvailableCommand

    source
    pub(all) struct AvailableCommand {
      name : String
      description : String
      input : CommandInput?
      meta : 
    Json    ?
    } derive(Eq)

    A slash command the user may type.

    AvailableCommand::equal

    source

    AvailableCommand::from_json

    source

    AvailableCommand::not_equal

    source
    fn AvailableCommand::not_equal(x : AvailableCommand, y : AvailableCommand) -> Bool

    AvailableCommand::to_json

    source

    AvailableCommands

    source
    pub(all) struct AvailableCommands {
      available_commands : Array[AvailableCommand]
      meta : 
    Json    ?
    } derive(Eq)

    The command list, replacing whatever came before.

    AvailableCommands::equal

    source

    AvailableCommands::from_json

    source

    AvailableCommands::not_equal

    source
    fn AvailableCommands::not_equal(x : AvailableCommands, y : AvailableCommands) -> Bool

    AvailableCommands::to_json

    source

    BlobResource

    source
    pub(all) struct BlobResource {
      uri : String
      blob : String
      mime_type : String?
      meta : 
    Json    ?
    } derive(Eq)

    Resource contents carried as base64 in blob.

    BlobResource::equal

    source

    BlobResource::from_json

    source

    BlobResource::not_equal

    source
    fn BlobResource::not_equal(x : BlobResource, y : BlobResource) -> Bool

    BlobResource::to_json

    source

    BooleanField

    source
    pub(all) struct BooleanField {
      title : String?
      description : String?
      default : Bool?
      meta : 
    Json    ?
    } derive(Eq)

    A field for yes or no.

    BooleanField::equal

    source

    BooleanField::from_json

    source

    BooleanField::not_equal

    source
    fn BooleanField::not_equal(x : BooleanField, y : BooleanField) -> Bool

    BooleanField::to_json

    source

    Cancel

    source
    pub(all) struct Cancel {
      session_id : String
      meta : 
    Json    ?
    } derive(Eq)

    Stops whatever turn is running in a session. A notification, so it is never answered.
    impl FromJson for Cancel
    impl ToJson for Cancel

    Cancel::equal

    source
    fn Cancel::equal(Cancel, Cancel) -> Bool

    Cancel::from_json

    source

    Cancel::not_equal

    source
    fn Cancel::not_equal(x : Cancel, y : Cancel) -> Bool

    Cancel::to_json

    source

    ChoiceItems

    source
    pub(all) enum ChoiceItems {
      Values(Array[String])
      Titled(Array[EnumOption])
    } derive(Eq)

    What a multi-select offers: bare values or titled ones.

    ChoiceItems::equal

    source
    fn ChoiceItems::equal(ChoiceItems, ChoiceItems) -> Bool

    ChoiceItems::not_equal

    source
    fn ChoiceItems::not_equal(x : ChoiceItems, y : ChoiceItems) -> Bool

    ChoiceItems::to_json

    source

    ClientAuthCapabilities

    source
    pub(all) struct ClientAuthCapabilities {
      terminal : Bool
      meta : 
    Json    ?
    } derive(Eq)

    Whether the client runs terminal commands for the agent.

    ClientAuthCapabilities::equal

    source

    ClientAuthCapabilities::from_json

    source

    ClientAuthCapabilities::none

    source

    No terminal authentication offered by the client.

    ClientAuthCapabilities::not_equal

    source

    ClientAuthCapabilities::to_json

    source

    ClientCapabilities

    source
    pub(all) struct ClientCapabilities {
      fs : FileSystemCapabilities
      terminal : Bool
      session : ClientSessionCapabilities?
      auth : ClientAuthCapabilities?
      elicitation : ElicitationCapabilities?
      meta : 
    Json    ?
    } derive(Eq)

    Everything the client says it can do, sent with initialize.

    ClientCapabilities::equal

    source

    ClientCapabilities::from_json

    source

    ClientCapabilities::none

    source

    A client that reads and writes nothing, runs nothing, and answers no ask.

    ClientCapabilities::not_equal

    source

    ClientCapabilities::to_json

    source

    ClientSessionCapabilities

    source
    pub(all) struct ClientSessionCapabilities {
      compaction : Bool
      config_options : Bool
      booleans : Bool
      notices : Bool
      meta : 
    Json    ?
    } derive(Eq)

    The client's support for supplementary session features.

    ClientSessionCapabilities::equal

    source

    ClientSessionCapabilities::from_json

    source

    ClientSessionCapabilities::none

    source

    No supplementary session features.

    ClientSessionCapabilities::not_equal

    source

    ClientSessionCapabilities::to_json

    source

    CloseSession

    source
    pub(all) struct CloseSession {
      session_id : String
      meta : 
    Json    ?
    } derive(Eq)

    Ends a session that is still running.

    CloseSession::equal

    source

    CloseSession::from_json

    source

    CloseSession::not_equal

    source
    fn CloseSession::not_equal(x : CloseSession, y : CloseSession) -> Bool

    CloseSession::to_json

    source

    CommandInput

    source
    pub(all) struct CommandInput {
      hint : String
      meta : 
    Json    ?
    } derive(Eq)

    The text typed after a command's name, offered to the user as a hint.

    CommandInput::equal

    source

    CommandInput::from_json

    source

    CommandInput::not_equal

    source
    fn CommandInput::not_equal(x : CommandInput, y : CommandInput) -> Bool

    CommandInput::to_json

    source

    Compaction

    source
    pub(all) struct Compaction {
      compaction_id : String
      status : CompactionStatus
      summary : Array[ContentBlock]?
      error : String?
      meta : 
    Json    ?
    } derive(Eq)

    A compaction, created the first time its identifier is seen and updated after that.

    Compaction::equal

    source
    fn Compaction::equal(Compaction, Compaction) -> Bool

    Compaction::from_json

    source

    Compaction::not_equal

    source
    fn Compaction::not_equal(x : Compaction, y : Compaction) -> Bool

    Compaction::to_json

    source

    CompactionStatus

    source
    pub(all) enum CompactionStatus {
      InProgress
      Completed
      Failed
      Cancelled
      Other(String)
    } derive(Eq)

    Where a context compaction got to. Unknown states are kept as they came.

    CompactionStatus::equal

    source

    CompactionStatus::from_json

    source

    CompactionStatus::not_equal

    source
    fn CompactionStatus::not_equal(x : CompactionStatus, y : CompactionStatus) -> Bool

    CompactionStatus::of

    source
    fn CompactionStatus::of(name : String) -> CompactionStatus

    The state with that name; unknown names are kept as they came.

    CompactionStatus::to_json

    source

    CompactionStatus::to_string

    source
    fn CompactionStatus::to_string(self : CompactionStatus) -> String

    The name the state travels as.

    CompactionSummary

    source
    pub(all) struct CompactionSummary {
      compaction_id : String
      content : ContentBlock
      meta : 
    Json    ?
    } derive(Eq)

    One more block of a compaction's retained summary.

    CompactionSummary::equal

    source

    CompactionSummary::from_json

    source

    CompactionSummary::not_equal

    source
    fn CompactionSummary::not_equal(x : CompactionSummary, y : CompactionSummary) -> Bool

    CompactionSummary::to_json

    source

    ConfigCategory

    source
    pub(all) enum ConfigCategory {
      Mode
      Model
      ModelConfig
      ThoughtLevel
      Other(String)
    } derive(Eq)

    What a configuration option is about, so a client can place it. Unknown categories are kept.

    ConfigCategory::equal

    source

    ConfigCategory::from_json

    source

    ConfigCategory::not_equal

    source
    fn ConfigCategory::not_equal(x : ConfigCategory, y : ConfigCategory) -> Bool

    ConfigCategory::of

    source
    fn ConfigCategory::of(name : String) -> ConfigCategory

    The category with that name; unknown names are kept as they came.

    ConfigCategory::to_json

    source

    ConfigCategory::to_string

    source
    fn ConfigCategory::to_string(self : ConfigCategory) -> String

    The name the category travels as.

    ConfigChoice

    source
    pub(all) struct ConfigChoice {
      value : String
      name : String
      description : String?
      meta : 
    Json    ?
    } derive(Eq)

    One value of a dropdown.

    ConfigChoice::equal

    source

    ConfigChoice::from_json

    source

    ConfigChoice::not_equal

    source
    fn ConfigChoice::not_equal(x : ConfigChoice, y : ConfigChoice) -> Bool

    ConfigChoice::to_json

    source

    ConfigChoices

    source
    pub(all) enum ConfigChoices {
      Flat(Array[ConfigChoice])
      Grouped(Array[ConfigGroup])
    } derive(Eq)

    The choices of a dropdown, flat or grouped. The two are told apart by whether the first entry carries group.

    ConfigChoices::equal

    source

    ConfigChoices::from_json

    source

    ConfigChoices::not_equal

    source
    fn ConfigChoices::not_equal(x : ConfigChoices, y : ConfigChoices) -> Bool

    ConfigChoices::to_json

    source

    ConfigGroup

    source
    pub(all) struct ConfigGroup {
      group : String
      name : String
      options : Array[ConfigChoice]
      meta : 
    Json    ?
    } derive(Eq)

    Choices under a heading.

    ConfigGroup::equal

    source
    fn ConfigGroup::equal(ConfigGroup, ConfigGroup) -> Bool

    ConfigGroup::from_json

    source

    ConfigGroup::not_equal

    source
    fn ConfigGroup::not_equal(x : ConfigGroup, y : ConfigGroup) -> Bool

    ConfigGroup::to_json

    source

    ConfigOption

    source
    pub(all) struct ConfigOption {
      id : String
      name : String
      description : String?
      category : ConfigCategory?
      value : ConfigValue
      meta : 
    Json    ?
    } derive(Eq)

    One entry of the session configuration picker.

    ConfigOption::equal

    source

    ConfigOption::from_json

    source

    ConfigOption::not_equal

    source
    fn ConfigOption::not_equal(x : ConfigOption, y : ConfigOption) -> Bool

    ConfigOption::to_json

    source

    ConfigValue

    source
    pub(all) enum ConfigValue {
      Select(String, ConfigChoices)
      Boolean(Bool)
    } derive(Eq)

    What a configuration option holds: a picked value or a switch.

    ConfigValue::equal

    source
    fn ConfigValue::equal(ConfigValue, ConfigValue) -> Bool

    ConfigValue::not_equal

    source
    fn ConfigValue::not_equal(x : ConfigValue, y : ConfigValue) -> Bool

    ConfigValue::to_json

    source

    ConfigValueId

    source
    pub(all) enum ConfigValueId {
      Value(String)
      Boolean(Bool)
    } derive(Eq)

    Sets a configuration option. The wire has two shapes, a value id or a boolean, told apart by type.

    ConfigValueId::equal

    source

    ConfigValueId::not_equal

    source
    fn ConfigValueId::not_equal(x : ConfigValueId, y : ConfigValueId) -> Bool

    Conn

    source
    pub struct Conn {
      peer : 
    Peer
      client : &Client
    }

    A connection to an agent, from the editor's side. run takes messages in; the methods here send them out and wait for their answers.

    Conn::authenticate

    source
    async fn Conn::authenticate(self : Conn, request : Authenticate) -> Unit raise Refused

    Runs one of the agent's authentication methods.

    Conn::call

    source
    async fn Conn::call(self : Conn, name : String, params : 
    Json    ) -> 
    Json     raise Refused

    A call the protocol does not name: send it raw and read the answer raw.

    Conn::cancel

    source
    async fn Conn::cancel(self : Conn, session_id : String) -> Unit raise Refused

    Asks the agent to stop the turn running in a session. A notice: nothing comes back, and the turn answers Cancelled on its own.

    Conn::client

    source
    fn Conn::client(self : Conn) -> &Client

    The client this connection feeds.

    Conn::close_session

    source
    async fn Conn::close_session(self : Conn, request : CloseSession) -> Unit raise Refused

    Ends a running session, as if session/cancel had been sent.

    Conn::delete_session

    source
    async fn Conn::delete_session(self : Conn, request : DeleteSession) -> Unit raise Refused

    Forgets a session.

    Conn::initialize

    source
    async fn Conn::initialize(self : Conn, request : Initialize) -> Initialized raise Refused

    Negotiates the version and trades capabilities. Call it once, before anything else.

    Conn::list_sessions

    source
    async fn Conn::list_sessions(self : Conn, request : ListSessions) -> SessionList raise Refused

    The sessions the agent remembers, one page at a time.

    Conn::load_session

    source
    async fn Conn::load_session(self : Conn, request : LoadSession) -> SessionStarted raise Refused

    Reopens a session; the updates that replay its history arrive on run.

    Conn::logout

    source
    async fn Conn::logout(self : Conn) -> Unit raise Refused

    Drops whatever authenticate established.

    Conn::new_session

    source
    async fn Conn::new_session(self : Conn, request : NewSession) -> SessionStarted raise Refused

    Starts a session and returns what the agent says about it: identifier, modes, options.

    Conn::notify

    source
    async fn Conn::notify(self : Conn, name : String, params : 
    Json    ) -> Unit raise Refused

    A notice the protocol does not name.

    Conn::prompt

    source
    async fn Conn::prompt(self : Conn, request : Prompt) -> PromptResult raise Refused

    Sends one turn and waits for its answer. Updates arrive through the client's update while this waits, because the connection is being run in another task.

    Conn::resume_session

    source
    async fn Conn::resume_session(self : Conn, request : ResumeSession) -> SessionStarted raise Refused

    Reattaches to a live session without replaying anything.

    Conn::run

    source
    async fn Conn::run(self : Conn) -> Unit

    Takes messages in until the other side goes away. Updates reach the client from here, so it has to run in a task of its own while the other tasks call the agent.

    Conn::set_config_option

    source
    async fn Conn::set_config_option(self : Conn, request : SetConfigOption) -> Array[ConfigOption] raise Refused

    Sets one configuration option and returns the whole list, as the protocol requires.

    Conn::set_mode

    source
    async fn Conn::set_mode(self : Conn, request : SetMode) -> Unit raise Refused

    Switches the session's mode.

    Content

    source
    pub(all) struct Content {
      content : ContentBlock
      meta : 
    Json    ?
    } derive(Eq)

    A standard content block wrapped for a tool call's output.
    impl FromJson for Content
    impl ToJson for Content

    Content::equal

    source
    fn Content::equal(Content, Content) -> Bool

    Content::from_json

    source

    Content::not_equal

    source
    fn Content::not_equal(x : Content, y : Content) -> Bool

    Content::to_json

    source

    ContentBlock

    source
    pub(all) enum ContentBlock {
      Text(TextContent)
      Image(ImageContent)
      Audio(AudioContent)
      ResourceLink(ResourceLink)
      Resource(EmbeddedResource)
    } derive(Eq)

    One displayable piece of a prompt or of a tool's output, tagged by type on the wire.

    ContentBlock::equal

    source

    ContentBlock::from_json

    source

    ContentBlock::not_equal

    source
    fn ContentBlock::not_equal(x : ContentBlock, y : ContentBlock) -> Bool

    ContentBlock::to_json

    source

    ContentChunk

    source
    pub(all) struct ContentChunk {
      content : ContentBlock
      message_id : String?
      meta : 
    Json    ?
    } derive(Eq)

    One streamed item of content.

    ContentChunk::equal

    source

    ContentChunk::from_json

    source

    ContentChunk::not_equal

    source
    fn ContentChunk::not_equal(x : ContentChunk, y : ContentChunk) -> Bool

    ContentChunk::to_json

    source

    Cost

    source
    pub(all) struct Cost {
      amount : Double
      currency : String
      meta : 
    Json    ?
    } derive(Eq)

    What the turn cost, in whatever currency the agent bills in.
    impl FromJson for Cost
    impl ToJson for Cost

    Cost::equal

    source
    fn Cost::equal(Cost, Cost) -> Bool

    Cost::from_json

    source

    Cost::not_equal

    source
    fn Cost::not_equal(x : Cost, y : Cost) -> Bool

    Cost::to_json

    source

    DeleteSession

    source
    pub(all) struct DeleteSession {
      session_id : String
      meta : 
    Json    ?
    } derive(Eq)

    Removes a session from what session/list returns.

    DeleteSession::equal

    source

    DeleteSession::from_json

    source

    DeleteSession::not_equal

    source
    fn DeleteSession::not_equal(x : DeleteSession, y : DeleteSession) -> Bool

    DeleteSession::to_json

    source

    Diff

    source
    pub(all) struct Diff {
      path : String
      new_text : String
      old_text : String?
      meta : 
    Json    ?
    } derive(Eq)

    A file edit, given as the whole file before and after.
    impl FromJson for Diff
    impl ToJson for Diff

    Diff::equal

    source
    fn Diff::equal(Diff, Diff) -> Bool

    Diff::from_json

    source

    Diff::not_equal

    source
    fn Diff::not_equal(x : Diff, y : Diff) -> Bool

    Diff::to_json

    source

    ElicitScope

    source
    pub(all) enum ElicitScope {
      OfSession(String, String?)
      OfRequest(
    Json    )
    } derive(Eq)

    Which request an elicitation belongs to: a session's turn, or a bare JSON-RPC request.

    ElicitScope::equal

    source
    fn ElicitScope::equal(ElicitScope, ElicitScope) -> Bool

    ElicitScope::from_json

    source

    ElicitScope::not_equal

    source
    fn ElicitScope::not_equal(x : ElicitScope, y : ElicitScope) -> Bool

    ElicitScope::to_json

    source

    Elicitation

    source
    pub(all) enum Elicitation {
      Form(FormRequest)
      Url(UrlRequest)
    } derive(Eq)

    An ask, tagged by mode on the wire.

    Elicitation::equal

    source
    fn Elicitation::equal(Elicitation, Elicitation) -> Bool

    Elicitation::from_json

    source

    Elicitation::not_equal

    source
    fn Elicitation::not_equal(x : Elicitation, y : Elicitation) -> Bool

    Elicitation::to_json

    source

    ElicitationCapabilities

    source
    pub(all) struct ElicitationCapabilities {
      form : Bool
      url : Bool
      meta : 
    Json    ?
    } derive(Eq)

    Elicitation kinds the client can show.

    ElicitationCapabilities::equal

    source

    ElicitationCapabilities::from_json

    source

    ElicitationCapabilities::none

    source

    No elicitation kind supported.

    ElicitationCapabilities::not_equal

    source

    ElicitationCapabilities::to_json

    source

    ElicitationSchema

    source
    pub(all) struct ElicitationSchema {
      properties : Map[String, Field]
      required : Array[String]?
      title : String?
      description : String?
      meta : 
    Json    ?
    } derive(Eq)

    The form to render.

    ElicitationSchema::equal

    source

    ElicitationSchema::from_json

    source

    ElicitationSchema::not_equal

    source
    fn ElicitationSchema::not_equal(x : ElicitationSchema, y : ElicitationSchema) -> Bool

    ElicitationSchema::to_json

    source

    EmbeddedResource

    source
    pub(all) struct EmbeddedResource {
      resource : Resource
      annotations : Annotations?
      meta : 
    Json    ?
    } derive(Eq)

    A resource carried by value inside a message.

    EmbeddedResource::equal

    source

    EmbeddedResource::from_json

    source

    EmbeddedResource::not_equal

    source
    fn EmbeddedResource::not_equal(x : EmbeddedResource, y : EmbeddedResource) -> Bool

    EmbeddedResource::to_json

    source

    EnumOption

    source
    pub(all) struct EnumOption {
      value : String
      title : String
      description : String?
      meta : 
    Json    ?
    } derive(Eq)

    One titled choice of a string field.

    EnumOption::equal

    source
    fn EnumOption::equal(EnumOption, EnumOption) -> Bool

    EnumOption::from_json

    source

    EnumOption::not_equal

    source
    fn EnumOption::not_equal(x : EnumOption, y : EnumOption) -> Bool

    EnumOption::to_json

    source

    EnvVariable

    source
    pub(all) struct EnvVariable {
      name : String
      value : String
      meta : 
    Json    ?
    } derive(Eq)

    One environment variable for a spawned MCP server.

    EnvVariable::equal

    source
    fn EnvVariable::equal(EnvVariable, EnvVariable) -> Bool

    EnvVariable::from_json

    source

    EnvVariable::not_equal

    source
    fn EnvVariable::not_equal(x : EnvVariable, y : EnvVariable) -> Bool

    EnvVariable::to_json

    source

    ExitStatus

    source
    pub(all) struct ExitStatus {
      exit_code : Int64?
      signal : String?
      meta : 
    Json    ?
    } derive(Eq)

    How a command ended.

    ExitStatus::equal

    source
    fn ExitStatus::equal(ExitStatus, ExitStatus) -> Bool

    ExitStatus::from_json

    source

    ExitStatus::not_equal

    source
    fn ExitStatus::not_equal(x : ExitStatus, y : ExitStatus) -> Bool

    ExitStatus::to_json

    source

    Field

    source
    pub(all) enum Field {
      Text(TextField)
      Number(NumberField)
      Integer(IntegerField)
      Boolean(BooleanField)
      MultiSelect(MultiSelectField)
      Other(
    Json    )
    } derive(Eq)

    One field of a form, tagged by type on the wire. A kind the protocol does not define yet is kept as it came so a client can still show it.
    impl FromJson for Field
    impl ToJson for Field

    Field::equal

    source
    fn Field::equal(Field, Field) -> Bool

    Field::from_json

    source

    Field::not_equal

    source
    fn Field::not_equal(x : Field, y : Field) -> Bool

    Field::to_json

    source

    FileSystemCapabilities

    source
    pub(all) struct FileSystemCapabilities {
      read_text_file : Bool
      write_text_file : Bool
      meta : 
    Json    ?
    } derive(Eq)

    Files the client lets the agent read and write on its behalf.

    FileSystemCapabilities::equal

    source

    FileSystemCapabilities::from_json

    source

    FileSystemCapabilities::none

    source

    No file access granted.

    FileSystemCapabilities::not_equal

    source

    FileSystemCapabilities::to_json

    source

    FileText

    source
    pub(all) struct FileText {
      content : String
      meta : 
    Json    ?
    } derive(Eq)

    FormRequest

    source
    pub(all) struct FormRequest {
      message : String
      schema : ElicitationSchema
      scope : ElicitScope
      meta : 
    Json    ?
    } derive(Eq)

    A form for the user to fill in.

    FormRequest::equal

    source
    fn FormRequest::equal(FormRequest, FormRequest) -> Bool

    FormRequest::from_json

    source

    FormRequest::not_equal

    source
    fn FormRequest::not_equal(x : FormRequest, y : FormRequest) -> Bool

    FormRequest::to_json

    source

    HttpHeader

    source
    pub(all) struct HttpHeader {
      name : String
      value : String
      meta : 
    Json    ?
    } derive(Eq)

    One header sent to an MCP server.

    HttpHeader::equal

    source
    fn HttpHeader::equal(HttpHeader, HttpHeader) -> Bool

    HttpHeader::from_json

    source

    HttpHeader::not_equal

    source
    fn HttpHeader::not_equal(x : HttpHeader, y : HttpHeader) -> Bool

    HttpHeader::to_json

    source

    ImageContent

    source
    pub(all) struct ImageContent {
      data : String
      mime_type : String
      uri : String?
      annotations : Annotations?
      meta : 
    Json    ?
    } derive(Eq)

    An image, base64 in data.

    ImageContent::equal

    source

    ImageContent::from_json

    source

    ImageContent::not_equal

    source
    fn ImageContent::not_equal(x : ImageContent, y : ImageContent) -> Bool

    ImageContent::to_json

    source

    Implementation

    source
    pub(all) struct Implementation {
      name : String
      version : String
      title : String?
      meta : 
    Json    ?
    } derive(Eq)

    A name and version, for the log and the about box.

    Implementation::equal

    source

    Implementation::from_json

    source

    Implementation::new

    source
    fn Implementation::new(name : String, version : String) -> Implementation

    A name and a version, which is all the protocol asks for.

    Implementation::not_equal

    source
    fn Implementation::not_equal(x : Implementation, y : Implementation) -> Bool

    Implementation::to_json

    source

    Initialize

    source
    pub(all) struct Initialize {
      protocol_version : Int
      client_capabilities : ClientCapabilities
      client_info : Implementation?
      meta : 
    Json    ?
    } derive(Eq)

    Opens the conversation: versions and capabilities, once per connection.

    Initialize::equal

    source
    fn Initialize::equal(Initialize, Initialize) -> Bool

    Initialize::from_json

    source

    Initialize::not_equal

    source
    fn Initialize::not_equal(x : Initialize, y : Initialize) -> Bool

    Initialize::to_json

    source

    Initialized

    source
    pub(all) struct Initialized {
      protocol_version : Int
      capabilities : AgentCapabilities
      auth_methods : Array[AuthMethod]
      agent_info : Implementation?
      meta : 
    Json    ?
    } derive(Eq)

    The answer to initialize.

    Initialized::equal

    source
    fn Initialized::equal(Initialized, Initialized) -> Bool

    Initialized::from_json

    source

    Initialized::new

    source

    A first answer for an agent that supports nothing beyond session/new: the version, no capabilities, no authentication.

    Initialized::not_equal

    source
    fn Initialized::not_equal(x : Initialized, y : Initialized) -> Bool

    Initialized::to_json

    source

    IntegerField

    source
    pub(all) struct IntegerField {
      title : String?
      description : String?
      minimum : Int64?
      maximum : Int64?
      default : Int64?
      meta : 
    Json    ?
    } derive(Eq)

    A field for a whole number.

    IntegerField::equal

    source

    IntegerField::from_json

    source

    IntegerField::not_equal

    source
    fn IntegerField::not_equal(x : IntegerField, y : IntegerField) -> Bool

    IntegerField::to_json

    source

    ListSessions

    source
    pub(all) struct ListSessions {
      cwd : String?
      cursor : String?
      meta : 
    Json    ?
    } derive(Eq)

    Asks for the sessions the agent remembers.

    ListSessions::equal

    source

    ListSessions::from_json

    source

    ListSessions::not_equal

    source
    fn ListSessions::not_equal(x : ListSessions, y : ListSessions) -> Bool

    ListSessions::to_json

    source

    LoadSession

    source
    pub(all) struct LoadSession {
      session_id : String
      cwd : String
      additional_directories : Array[String]?
      mcp_servers : Array[McpServer]
      meta : 
    Json    ?
    } derive(Eq)

    Reopens a session and replays its history as updates.

    LoadSession::equal

    source
    fn LoadSession::equal(LoadSession, LoadSession) -> Bool

    LoadSession::from_json

    source

    LoadSession::not_equal

    source
    fn LoadSession::not_equal(x : LoadSession, y : LoadSession) -> Bool

    LoadSession::to_json

    source

    McpCapabilities

    source
    pub(all) struct McpCapabilities {
      http : Bool
      sse : Bool
      meta : 
    Json    ?
    } derive(Eq)

    MCP transports the agent can connect to.

    McpCapabilities::equal

    source

    McpCapabilities::from_json

    source

    McpCapabilities::none

    source

    No MCP transport supported.

    McpCapabilities::not_equal

    source
    fn McpCapabilities::not_equal(x : McpCapabilities, y : McpCapabilities) -> Bool

    McpCapabilities::to_json

    source

    McpHttp

    source
    pub(all) struct McpHttp {
      name : String
      url : String
      headers : Array[HttpHeader]
      meta : 
    Json    ?
    } derive(Eq)

    An MCP server reached over HTTP.
    impl FromJson for McpHttp
    impl ToJson for McpHttp

    McpHttp::equal

    source
    fn McpHttp::equal(McpHttp, McpHttp) -> Bool

    McpHttp::from_json

    source

    McpHttp::not_equal

    source
    fn McpHttp::not_equal(x : McpHttp, y : McpHttp) -> Bool

    McpHttp::to_json

    source

    McpServer

    source
    pub(all) enum McpServer {
      Http(McpHttp)
      Sse(McpSse)
      Stdio(McpStdio)
    } derive(Eq)

    An MCP server a session may use. The wire tells the two HTTP shapes apart by type; the stdio shape carries no tag at all.
    impl ToJson for McpServer

    McpServer::equal

    source
    fn McpServer::equal(McpServer, McpServer) -> Bool

    McpServer::from_json

    source

    McpServer::not_equal

    source
    fn McpServer::not_equal(x : McpServer, y : McpServer) -> Bool

    McpServer::to_json

    source

    McpSse

    source
    pub(all) struct McpSse {
      name : String
      url : String
      headers : Array[HttpHeader]
      meta : 
    Json    ?
    } derive(Eq)

    An MCP server reached over the older HTTP plus SSE transport.
    impl FromJson for McpSse
    impl ToJson for McpSse

    McpSse::equal

    source
    fn McpSse::equal(McpSse, McpSse) -> Bool

    McpSse::from_json

    source

    McpSse::not_equal

    source
    fn McpSse::not_equal(x : McpSse, y : McpSse) -> Bool

    McpSse::to_json

    source

    McpStdio

    source
    pub(all) struct McpStdio {
      name : String
      command : String
      args : Array[String]
      env : Array[EnvVariable]
      meta : 
    Json    ?
    } derive(Eq)

    An MCP server the client is to launch as a child process.
    impl ToJson for McpStdio

    McpStdio::equal

    source
    fn McpStdio::equal(McpStdio, McpStdio) -> Bool

    McpStdio::from_json

    source

    McpStdio::not_equal

    source
    fn McpStdio::not_equal(x : McpStdio, y : McpStdio) -> Bool

    McpStdio::to_json

    source

    ModeChanged

    source
    pub(all) struct ModeChanged {
      current_mode_id : String
      meta : 
    Json    ?
    } derive(Eq)

    The session's mode changed.

    ModeChanged::equal

    source
    fn ModeChanged::equal(ModeChanged, ModeChanged) -> Bool

    ModeChanged::from_json

    source

    ModeChanged::not_equal

    source
    fn ModeChanged::not_equal(x : ModeChanged, y : ModeChanged) -> Bool

    ModeChanged::to_json

    source

    MultiSelectField

    source
    pub(all) struct MultiSelectField {
      title : String?
      description : String?
      min_items : Int64?
      max_items : Int64?
      items : ChoiceItems
      default : Array[String]?
      meta : 
    Json    ?
    } derive(Eq)

    A field for picking several of a set.

    MultiSelectField::equal

    source

    MultiSelectField::from_json

    source

    MultiSelectField::not_equal

    source
    fn MultiSelectField::not_equal(x : MultiSelectField, y : MultiSelectField) -> Bool

    MultiSelectField::to_json

    source

    NewSession

    source
    pub(all) struct NewSession {
      cwd : String
      additional_directories : Array[String]?
      mcp_servers : Array[McpServer]
      meta : 
    Json    ?
    } derive(Eq)

    Starts a conversation. The working directory is where the agent reads and writes.

    NewSession::equal

    source
    fn NewSession::equal(NewSession, NewSession) -> Bool

    NewSession::from_json

    source

    NewSession::not_equal

    source
    fn NewSession::not_equal(x : NewSession, y : NewSession) -> Bool

    NewSession::to_json

    source

    Notice

    source
    pub(all) struct Notice {
      severity : Severity
      title : String
      description : String?
      meta : 
    Json    ?
    } derive(Eq)

    Something to tell the user that is not part of the conversation.
    impl FromJson for Notice
    impl ToJson for Notice

    Notice::equal

    source
    fn Notice::equal(Notice, Notice) -> Bool

    Notice::from_json

    source

    Notice::not_equal

    source
    fn Notice::not_equal(x : Notice, y : Notice) -> Bool

    Notice::to_json

    source

    NumberField

    source
    pub(all) struct NumberField {
      title : String?
      description : String?
      minimum : Double?
      maximum : Double?
      default : Double?
      meta : 
    Json    ?
    } derive(Eq)

    A field for a fractional number.

    NumberField::equal

    source
    fn NumberField::equal(NumberField, NumberField) -> Bool

    NumberField::from_json

    source

    NumberField::not_equal

    source
    fn NumberField::not_equal(x : NumberField, y : NumberField) -> Bool

    NumberField::to_json

    source

    Outcome

    source
    pub(all) enum Outcome {
      Selected(String)
      Cancelled
    } derive(Eq)

    What came back: one option chosen, or the ask dismissed.
    impl FromJson for Outcome
    impl ToJson for Outcome

    Outcome::equal

    source
    fn Outcome::equal(Outcome, Outcome) -> Bool

    Outcome::from_json

    source

    Outcome::not_equal

    source
    fn Outcome::not_equal(x : Outcome, y : Outcome) -> Bool

    Outcome::to_json

    source

    Permission

    source
    pub(all) struct Permission {
      tool_call : ToolCallUpdate
      options : Array[PermissionOption]
      meta : 
    Json    ?
    } derive(Eq)

    The ask the agent makes: run this tool call, and here is what the user may choose.

    Permission::equal

    source
    fn Permission::equal(Permission, Permission) -> Bool

    Permission::from_json

    source

    Permission::not_equal

    source
    fn Permission::not_equal(x : Permission, y : Permission) -> Bool

    Permission::to_json

    source

    PermissionOption

    source
    pub(all) struct PermissionOption {
      option_id : String
      name : String
      kind : PermissionOptionKind
      meta : 
    Json    ?
    } derive(Eq)

    One button in a permission prompt.

    PermissionOption::equal

    source

    PermissionOption::from_json

    source

    PermissionOption::not_equal

    source
    fn PermissionOption::not_equal(x : PermissionOption, y : PermissionOption) -> Bool

    PermissionOption::to_json

    source

    PermissionOptionKind

    source
    pub(all) enum PermissionOptionKind {
      AllowOnce
      AllowAlways
      RejectOnce
      RejectAlways
    } derive(Eq)

    What choosing an option means, so a client can group the buttons.

    PermissionOptionKind::equal

    source

    PermissionOptionKind::from_json

    source

    PermissionOptionKind::not_equal

    source

    PermissionOptionKind::of

    source
    fn PermissionOptionKind::of(name : String) -> PermissionOptionKind?

    The option kind with that name, or None.

    PermissionOptionKind::to_json

    source

    PermissionOptionKind::to_string

    source
    fn PermissionOptionKind::to_string(self : PermissionOptionKind) -> String

    The name the option kind travels as.

    Plan

    source
    pub(all) struct Plan {
      entries : Array[PlanEntry]
      meta : 
    Json    ?
    } derive(Eq)

    The whole plan, replacing whatever came before.
    impl FromJson for Plan
    impl ToJson for Plan

    Plan::equal

    source
    fn Plan::equal(Plan, Plan) -> Bool

    Plan::from_json

    source

    Plan::not_equal

    source
    fn Plan::not_equal(x : Plan, y : Plan) -> Bool

    Plan::to_json

    source

    PlanEntry

    source
    pub(all) struct PlanEntry {
      content : String
      priority : PlanEntryPriority
      status : PlanEntryStatus
      meta : 
    Json    ?
    } derive(Eq)

    PlanEntryPriority

    source
    pub(all) enum PlanEntryPriority {
      High
      Medium
      Low
    } derive(Eq)

    How urgent a plan entry is.

    PlanEntryPriority::equal

    source

    PlanEntryPriority::from_json

    source

    PlanEntryPriority::not_equal

    source
    fn PlanEntryPriority::not_equal(x : PlanEntryPriority, y : PlanEntryPriority) -> Bool

    PlanEntryPriority::of

    source
    fn PlanEntryPriority::of(name : String) -> PlanEntryPriority?

    The priority with that name, or None.

    PlanEntryPriority::to_json

    source

    PlanEntryPriority::to_string

    source
    fn PlanEntryPriority::to_string(self : PlanEntryPriority) -> String

    The name the priority travels as.

    PlanEntryStatus

    source
    pub(all) enum PlanEntryStatus {
      Pending
      InProgress
      Completed
    } derive(Eq)

    How far a plan entry got.

    PlanEntryStatus::equal

    source

    PlanEntryStatus::from_json

    source

    PlanEntryStatus::not_equal

    source
    fn PlanEntryStatus::not_equal(x : PlanEntryStatus, y : PlanEntryStatus) -> Bool

    PlanEntryStatus::of

    source
    fn PlanEntryStatus::of(name : String) -> PlanEntryStatus?

    The status with that name, or None.

    PlanEntryStatus::to_json

    source

    PlanEntryStatus::to_string

    source
    fn PlanEntryStatus::to_string(self : PlanEntryStatus) -> String

    The name the status travels as.

    Prompt

    source
    pub(all) struct Prompt {
      session_id : String
      prompt : Array[ContentBlock]
      meta : 
    Json    ?
    } derive(Eq)

    One turn of the conversation.
    impl FromJson for Prompt
    impl ToJson for Prompt

    Prompt::equal

    source
    fn Prompt::equal(Prompt, Prompt) -> Bool

    Prompt::from_json

    source

    Prompt::not_equal

    source
    fn Prompt::not_equal(x : Prompt, y : Prompt) -> Bool

    Prompt::to_json

    source

    PromptCapabilities

    source
    pub(all) struct PromptCapabilities {
      image : Bool
      audio : Bool
      embedded_context : Bool
      meta : 
    Json    ?
    } derive(Eq)

    Content kinds the agent accepts inside a prompt.

    PromptCapabilities::equal

    source

    PromptCapabilities::from_json

    source

    PromptCapabilities::none

    source

    Nothing supported: no images, no audio, no embedded context.

    PromptCapabilities::not_equal

    source

    PromptCapabilities::to_json

    source

    PromptResult

    source
    pub(all) struct PromptResult {
      stop_reason : StopReason
      meta : 
    Json    ?
    } derive(Eq)

    The answer to a prompt: why the turn ended.

    PromptResult::equal

    source

    PromptResult::from_json

    source

    PromptResult::not_equal

    source
    fn PromptResult::not_equal(x : PromptResult, y : PromptResult) -> Bool

    PromptResult::to_json

    source

    ReadTextFile

    source
    pub(all) struct ReadTextFile {
      session_id : String
      path : String
      line : Int64?
      limit : Int64?
      meta : 
    Json    ?
    } derive(Eq)

    A text file to read.

    ReadTextFile::equal

    source

    ReadTextFile::from_json

    source

    ReadTextFile::not_equal

    source
    fn ReadTextFile::not_equal(x : ReadTextFile, y : ReadTextFile) -> Bool

    ReadTextFile::to_json

    source

    Resource

    source
    pub(all) enum Resource {
      Text(TextResource)
      Blob(BlobResource)
    } derive(Eq)

    Either kind of embedded resource contents, told apart by text against blob.
    impl ToJson for Resource

    Resource::equal

    source
    fn Resource::equal(Resource, Resource) -> Bool

    Resource::from_json

    source

    Resource::not_equal

    source
    fn Resource::not_equal(x : Resource, y : Resource) -> Bool

    Resource::to_json

    source

    pub(all) struct ResourceLink {
      uri : String
      name : String
      title : String?
      description : String?
      mime_type : String?
      size : Int64?
      annotations : Annotations?
      meta : 
    Json    ?
    } derive(Eq)

    A resource the client can read, named by URI rather than by value.

    ResourceLink::equal

    source

    ResourceLink::from_json

    source

    ResourceLink::not_equal

    source
    fn ResourceLink::not_equal(x : ResourceLink, y : ResourceLink) -> Bool

    ResourceLink::to_json

    source

    ResumeSession

    source
    pub(all) struct ResumeSession {
      session_id : String
      cwd : String
      additional_directories : Array[String]?
      mcp_servers : Array[McpServer]?
      meta : 
    Json    ?
    } derive(Eq)

    Reattaches to a session without replaying its history.

    ResumeSession::equal

    source

    ResumeSession::from_json

    source

    ResumeSession::not_equal

    source
    fn ResumeSession::not_equal(x : ResumeSession, y : ResumeSession) -> Bool

    ResumeSession::to_json

    source

    Role

    source
    pub(all) enum Role {
      Assistant
      User
    } derive(Eq)

    Who a piece of content is for.
    impl FromJson for Role
    impl ToJson for Role

    Role::equal

    source
    fn Role::equal(Role, Role) -> Bool

    Role::from_json

    source

    Role::not_equal

    source
    fn Role::not_equal(x : Role, y : Role) -> Bool

    Role::of

    source
    fn Role::of(name : String) -> Role?

    The role with that name, or None.

    Role::to_json

    source

    Role::to_string

    source
    fn Role::to_string(self : Role) -> String

    The name the role travels as.

    Session

    source
    pub struct Session {
      peer : 
    Peer
      id : String
    }

    One session, as the agent sees it inside prompt. Everything here is a call to the client: updates, permission, files, terminals, elicitation.

    Session::elicit

    source
    async fn Session::elicit(self : Session, ask : Elicitation) -> Answer raise Refused

    Asks the user for a few fields or for a visit to a URL. The ask is scoped to this session, and to the tool call it came from when one is given.

    Session::id

    source
    fn Session::id(self : Session) -> String

    The session's identifier, the one the client sent with session/new.

    Session::read_text_file

    source
    async fn Session::read_text_file(self : Session, path : String, line? : Int64, limit? : Int64) -> String raise Refused

    Reads a text file through the client, sliced from line when one is given.

    Session::request_permission

    source
    async fn Session::request_permission(self : Session, ask : Permission) -> Outcome raise Refused

    Asks the user to allow a tool call. The client answers with the option it picked, or Cancelled when the prompt was dismissed; a client that never answers blocks the turn, so keep the ask in the turn's own task.

    Session::terminal

    source
    async fn Session::terminal(self : Session, command : String, args? : Array[String], env? : Array[EnvVariable], cwd? : String, output_byte_limit? : Int64) -> Terminal raise Refused

    Runs a command in a terminal the client owns. The returned handle reads, waits for, kills and releases it.

    Session::update

    source
    async fn Session::update(self : Session, update : SessionUpdate) -> Unit raise Refused

    Sends one update. Updates are notifications, so they are never answered and never fail the turn by themselves; the connection going away raises Closed.

    Session::write_text_file

    source
    async fn Session::write_text_file(self : Session, path : String, content : String) -> Unit raise Refused

    Writes a text file through the client.

    SessionCapabilities

    source
    pub(all) struct SessionCapabilities {
      list : Bool
      delete : Bool
      additional_directories : Bool
      resume_session : Bool
      close : Bool
      meta : 
    Json    ?
    } derive(Eq)

    Session methods beyond session/new. Each flag is a promise to answer that method.

    SessionCapabilities::equal

    source

    SessionCapabilities::from_json

    source

    SessionCapabilities::none

    source

    No session method beyond session/new.

    SessionCapabilities::not_equal

    source

    SessionCapabilities::to_json

    source

    SessionInfo

    source
    pub(all) struct SessionInfo {
      session_id : String
      cwd : String
      additional_directories : Array[String]?
      title : String?
      updated_at : String?
      meta : 
    Json    ?
    } derive(Eq)

    One row of session/list.

    SessionInfo::equal

    source
    fn SessionInfo::equal(SessionInfo, SessionInfo) -> Bool

    SessionInfo::from_json

    source

    SessionInfo::not_equal

    source
    fn SessionInfo::not_equal(x : SessionInfo, y : SessionInfo) -> Bool

    SessionInfo::to_json

    source

    SessionInfoChanged

    source
    pub(all) struct SessionInfoChanged {
      title : String?
      updated_at : String?
      meta : 
    Json    ?
    } derive(Eq)

    The session's metadata changed; only the fields that changed are present.

    SessionInfoChanged::equal

    source

    SessionInfoChanged::from_json

    source

    SessionInfoChanged::not_equal

    source

    SessionInfoChanged::to_json

    source

    SessionList

    source
    pub(all) struct SessionList {
      sessions : Array[SessionInfo]
      next_cursor : String?
      meta : 
    Json    ?
    } derive(Eq)

    The page of sessions, and the cursor for the next one.

    SessionList::equal

    source
    fn SessionList::equal(SessionList, SessionList) -> Bool

    SessionList::from_json

    source

    SessionList::not_equal

    source
    fn SessionList::not_equal(x : SessionList, y : SessionList) -> Bool

    SessionList::to_json

    source

    SessionMode

    source
    pub(all) struct SessionMode {
      id : String
      name : String
      description : String?
      meta : 
    Json    ?
    } derive(Eq)

    One mode the agent can work in.

    SessionMode::equal

    source
    fn SessionMode::equal(SessionMode, SessionMode) -> Bool

    SessionMode::from_json

    source

    SessionMode::not_equal

    source
    fn SessionMode::not_equal(x : SessionMode, y : SessionMode) -> Bool

    SessionMode::to_json

    source

    SessionModes

    source
    pub(all) struct SessionModes {
      current_mode_id : String
      available_modes : Array[SessionMode]
      meta : 
    Json    ?
    } derive(Eq)

    The modes on offer and the one in force.

    SessionModes::equal

    source

    SessionModes::from_json

    source

    SessionModes::not_equal

    source
    fn SessionModes::not_equal(x : SessionModes, y : SessionModes) -> Bool

    SessionModes::to_json

    source

    SessionNotification

    source
    pub(all) struct SessionNotification {
      session_id : String
      update : SessionUpdate
      meta : 
    Json    ?
    } derive(Eq)

    One update as it travels: the session it belongs to and the update itself.

    SessionNotification::equal

    source

    SessionNotification::from_json

    source

    SessionNotification::not_equal

    source

    SessionNotification::to_json

    source

    SessionStarted

    source
    pub(all) struct SessionStarted {
      session_id : String
      modes : SessionModes?
      config_options : Array[ConfigOption]?
      meta : 
    Json    ?
    } derive(Eq)

    What session/new and its siblings answer with.

    SessionStarted::equal

    source

    SessionStarted::from_json

    source

    SessionStarted::not_equal

    source
    fn SessionStarted::not_equal(x : SessionStarted, y : SessionStarted) -> Bool

    SessionStarted::to_json

    source

    SessionUpdate

    source
    pub(all) enum SessionUpdate {
      UserMessageChunk(ContentChunk)
      AgentMessageChunk(ContentChunk)
      AgentThoughtChunk(ContentChunk)
      ToolCall(ToolCall)
      ToolCallUpdate(ToolCallUpdate)
      Plan(Plan)
      AvailableCommands(AvailableCommands)
      ModeChanged(ModeChanged)
      ConfigOptionChanged(Array[ConfigOption])
      SessionInfoChanged(SessionInfoChanged)
      Usage(Usage)
      Notice(Notice)
      Compaction(Compaction)
      CompactionSummary(CompactionSummary)
    } derive(Eq)

    Everything the agent may tell the client mid-turn, tagged by sessionUpdate on the wire.

    SessionUpdate::equal

    source

    SessionUpdate::from_json

    source

    SessionUpdate::not_equal

    source
    fn SessionUpdate::not_equal(x : SessionUpdate, y : SessionUpdate) -> Bool

    SessionUpdate::to_json

    source

    SetConfigOption

    source
    pub(all) struct SetConfigOption {
      session_id : String
      config_id : String
      value : ConfigValueId
      meta : 
    Json    ?
    } derive(Eq)

    Sets one configuration option.

    SetConfigOption::equal

    source

    SetConfigOption::from_json

    source

    SetConfigOption::not_equal

    source
    fn SetConfigOption::not_equal(x : SetConfigOption, y : SetConfigOption) -> Bool

    SetConfigOption::to_json

    source

    SetConfigOptions

    source
    pub(all) struct SetConfigOptions {
      config_options : Array[ConfigOption]
      meta : 
    Json    ?
    } derive(Eq)

    The whole option list after one of them changed.

    SetConfigOptions::equal

    source

    SetConfigOptions::from_json

    source

    SetConfigOptions::not_equal

    source
    fn SetConfigOptions::not_equal(x : SetConfigOptions, y : SetConfigOptions) -> Bool

    SetConfigOptions::to_json

    source

    SetMode

    source
    pub(all) struct SetMode {
      session_id : String
      mode_id : String
      meta : 
    Json    ?
    } derive(Eq)

    Severity

    source
    pub(all) enum Severity {
      Info
      Warning
      Error
      Other(String)
    } derive(Eq)

    How loud a notice is. Unknown severities are kept as they came.
    impl ToJson for Severity

    Severity::equal

    source
    fn Severity::equal(Severity, Severity) -> Bool

    Severity::from_json

    source

    Severity::not_equal

    source
    fn Severity::not_equal(x : Severity, y : Severity) -> Bool

    Severity::of

    source
    fn Severity::of(name : String) -> Severity

    The severity with that name; unknown names are kept as they came.

    Severity::to_json

    source

    Severity::to_string

    source
    fn Severity::to_string(self : Severity) -> String

    The name the severity travels as.

    StopReason

    source
    pub(all) enum StopReason {
      EndTurn
      MaxTokens
      MaxTurnRequests
      Refusal
      Cancelled
    } derive(Eq)

    Why the agent stopped.

    StopReason::equal

    source
    fn StopReason::equal(StopReason, StopReason) -> Bool

    StopReason::from_json

    source

    StopReason::not_equal

    source
    fn StopReason::not_equal(x : StopReason, y : StopReason) -> Bool

    StopReason::of

    source
    fn StopReason::of(name : String) -> StopReason?

    The reason with that name, or None.

    StopReason::to_json

    source

    StopReason::to_string

    source
    fn StopReason::to_string(self : StopReason) -> String

    The name the reason travels as.

    StringFormat

    source
    pub(all) enum StringFormat {
      Email
      Uri
      Date
      DateTime
    } derive(Eq)

    A string field's format hint.

    StringFormat::equal

    source

    StringFormat::from_json

    source

    StringFormat::not_equal

    source
    fn StringFormat::not_equal(x : StringFormat, y : StringFormat) -> Bool

    StringFormat::of

    source
    fn StringFormat::of(name : String) -> StringFormat?

    The format with that name, or None.

    StringFormat::to_json

    source

    StringFormat::to_string

    source
    fn StringFormat::to_string(self : StringFormat) -> String

    The name the format travels as.

    Terminal

    source
    pub struct Terminal {
      session : Session
      terminal_id : String
    }

    A command running in a terminal the client owns. Holding one is not owning a process: release hands the terminal back, and the exit status is only known after wait.

    Terminal::id

    source
    fn Terminal::id(self : Terminal) -> String

    The identifier the client gave this terminal.

    Terminal::kill

    source
    async fn Terminal::kill(self : Terminal) -> Unit raise Refused

    Stops the command without giving the terminal back.

    Terminal::output

    source
    async fn Terminal::output(self : Terminal) -> TerminalOutput raise Refused

    Everything the command has printed so far.

    Terminal::reference

    source
    fn Terminal::reference(self : Terminal) -> TerminalRef

    The terminal as a tool call refers to it, for ToolCallContent.

    Terminal::release

    source
    async fn Terminal::release(self : Terminal) -> Unit raise Refused

    Gives the terminal back. The client may reuse it for the next command.

    Terminal::wait

    source
    async fn Terminal::wait(self : Terminal) -> ExitStatus raise Refused

    Waits for the command to exit and reports how it did.

    TerminalCommand

    source
    pub(all) struct TerminalCommand {
      session_id : String
      command : String
      args : Array[String]?
      env : Array[EnvVariable]?
      cwd : String?
      output_byte_limit : Int64?
      meta : 
    Json    ?
    } derive(Eq)

    A command to run in a new terminal.

    TerminalCommand::equal

    source

    TerminalCommand::from_json

    source

    TerminalCommand::not_equal

    source
    fn TerminalCommand::not_equal(x : TerminalCommand, y : TerminalCommand) -> Bool

    TerminalCommand::to_json

    source

    TerminalOpened

    source
    pub(all) struct TerminalOpened {
      terminal_id : String
      meta : 
    Json    ?
    } derive(Eq)

    The identifier of the terminal the client opened.

    TerminalOpened::equal

    source

    TerminalOpened::from_json

    source

    TerminalOpened::not_equal

    source
    fn TerminalOpened::not_equal(x : TerminalOpened, y : TerminalOpened) -> Bool

    TerminalOpened::to_json

    source

    TerminalOutput

    source
    pub(all) struct TerminalOutput {
      output : String
      truncated : Bool
      exit_status : ExitStatus?
      meta : 
    Json    ?
    } derive(Eq)

    What a terminal has printed so far, and whether it has exited.

    TerminalOutput::equal

    source

    TerminalOutput::from_json

    source

    TerminalOutput::not_equal

    source
    fn TerminalOutput::not_equal(x : TerminalOutput, y : TerminalOutput) -> Bool

    TerminalOutput::to_json

    source

    TerminalRef

    source
    pub(all) struct TerminalRef {
      terminal_id : String
      meta : 
    Json    ?
    } derive(Eq)

    A reference to a terminal the client opened, embedded in a tool call.

    TerminalRef::equal

    source
    fn TerminalRef::equal(TerminalRef, TerminalRef) -> Bool

    TerminalRef::from_json

    source

    TerminalRef::new

    source
    fn TerminalRef::new(terminal_id : String) -> TerminalRef

    A reference to a terminal, as a tool call embeds it.

    TerminalRef::not_equal

    source
    fn TerminalRef::not_equal(x : TerminalRef, y : TerminalRef) -> Bool

    TerminalRef::to_json

    source

    TerminalRequest

    source
    pub(all) struct TerminalRequest {
      session_id : String
      terminal_id : String
      meta : 
    Json    ?
    } derive(Eq)

    Names an existing terminal, for terminal/output, terminal/wait_for_exit, terminal/kill and terminal/release.

    TerminalRequest::equal

    source

    TerminalRequest::from_json

    source

    TerminalRequest::not_equal

    source
    fn TerminalRequest::not_equal(x : TerminalRequest, y : TerminalRequest) -> Bool

    TerminalRequest::to_json

    source

    TextContent

    source
    pub(all) struct TextContent {
      text : String
      annotations : Annotations?
      meta : 
    Json    ?
    } derive(Eq)

    Text the model reads or writes.

    TextContent::equal

    source
    fn TextContent::equal(TextContent, TextContent) -> Bool

    TextContent::from_json

    source

    TextContent::not_equal

    source
    fn TextContent::not_equal(x : TextContent, y : TextContent) -> Bool

    TextContent::to_json

    source

    TextField

    source
    pub(all) struct TextField {
      title : String?
      description : String?
      min_length : Int64?
      max_length : Int64?
      pattern : String?
      format : StringFormat?
      default : String?
      choices : Array[String]?
      titled_choices : Array[EnumOption]?
      meta : 
    Json    ?
    } derive(Eq)

    TextResource

    source
    pub(all) struct TextResource {
      uri : String
      text : String
      mime_type : String?
      meta : 
    Json    ?
    } derive(Eq)

    Resource contents carried as text.

    TextResource::equal

    source

    TextResource::from_json

    source

    TextResource::not_equal

    source
    fn TextResource::not_equal(x : TextResource, y : TextResource) -> Bool

    TextResource::to_json

    source

    ToolCall

    source
    pub(all) struct ToolCall {
      tool_call_id : String
      title : String
      name : String?
      kind : ToolKind?
      status : ToolCallStatus?
      content : Array[ToolCallContent]?
      locations : Array[ToolCallLocation]?
      raw_input : 
    Json    ?
      raw_output : 
    Json    ?
      meta : 
    Json    ?
    } derive(Eq)

    A tool call the model has asked for.
    impl ToJson for ToolCall

    ToolCall::equal

    source
    fn ToolCall::equal(ToolCall, ToolCall) -> Bool

    ToolCall::from_json

    source

    ToolCall::not_equal

    source
    fn ToolCall::not_equal(x : ToolCall, y : ToolCall) -> Bool

    ToolCall::to_json

    source

    ToolCallContent

    source
    pub(all) enum ToolCallContent {
      Content(Content)
      Diff(Diff)
      Terminal(TerminalRef)
    } derive(Eq)

    What a tool call produced, tagged by type on the wire.

    ToolCallContent::equal

    source

    ToolCallContent::from_json

    source

    ToolCallContent::not_equal

    source
    fn ToolCallContent::not_equal(x : ToolCallContent, y : ToolCallContent) -> Bool

    ToolCallContent::to_json

    source

    ToolCallLocation

    source
    pub(all) struct ToolCallLocation {
      path : String
      line : Int64?
      meta : 
    Json    ?
    } derive(Eq)

    A place in the workspace a tool touched.

    ToolCallLocation::equal

    source

    ToolCallLocation::from_json

    source

    ToolCallLocation::not_equal

    source
    fn ToolCallLocation::not_equal(x : ToolCallLocation, y : ToolCallLocation) -> Bool

    ToolCallLocation::to_json

    source

    ToolCallStatus

    source
    pub(all) enum ToolCallStatus {
      Pending
      InProgress
      Completed
      Failed
    } derive(Eq)

    How far a tool call got.

    ToolCallStatus::equal

    source

    ToolCallStatus::from_json

    source

    ToolCallStatus::not_equal

    source
    fn ToolCallStatus::not_equal(x : ToolCallStatus, y : ToolCallStatus) -> Bool

    ToolCallStatus::of

    source
    fn ToolCallStatus::of(name : String) -> ToolCallStatus?

    The status with that name, or None.

    ToolCallStatus::to_json

    source

    ToolCallStatus::to_string

    source
    fn ToolCallStatus::to_string(self : ToolCallStatus) -> String

    The name the status travels as.

    ToolCallUpdate

    source
    pub(all) struct ToolCallUpdate {
      tool_call_id : String
      kind : ToolKind?
      status : ToolCallStatus?
      title : String?
      name : String?
      content : Array[ToolCallContent]?
      locations : Array[ToolCallLocation]?
      raw_input : 
    Json    ?
      raw_output : 
    Json    ?
      meta : 
    Json    ?
    } derive(Eq)

    A later change to a tool call: only what changed is present.

    ToolCallUpdate::equal

    source

    ToolCallUpdate::from_json

    source

    ToolCallUpdate::not_equal

    source
    fn ToolCallUpdate::not_equal(x : ToolCallUpdate, y : ToolCallUpdate) -> Bool

    ToolCallUpdate::to_json

    source

    ToolKind

    source
    pub(all) enum ToolKind {
      Read
      Edit
      Delete
      Move
      Search
      Execute
      Think
      Fetch
      SwitchMode
      Other
    } derive(Eq)

    What kind of thing a tool does, for a client that wants to pick an icon.
    impl ToJson for ToolKind

    ToolKind::equal

    source
    fn ToolKind::equal(ToolKind, ToolKind) -> Bool

    ToolKind::from_json

    source

    ToolKind::not_equal

    source
    fn ToolKind::not_equal(x : ToolKind, y : ToolKind) -> Bool

    ToolKind::of

    source
    fn ToolKind::of(name : String) -> ToolKind?

    The kind with that name, or None.

    ToolKind::to_json

    source

    ToolKind::to_string

    source
    fn ToolKind::to_string(self : ToolKind) -> String

    The name the kind travels as.

    UrlRequest

    source
    pub(all) struct UrlRequest {
      message : String
      elicitation_id : String
      url : String
      scope : ElicitScope
      meta : 
    Json    ?
    } derive(Eq)

    A link the user follows.

    UrlRequest::equal

    source
    fn UrlRequest::equal(UrlRequest, UrlRequest) -> Bool

    UrlRequest::from_json

    source

    UrlRequest::not_equal

    source
    fn UrlRequest::not_equal(x : UrlRequest, y : UrlRequest) -> Bool

    UrlRequest::to_json

    source

    Usage

    source
    pub(all) struct Usage {
      used : Int64
      size : Int64
      cost : Cost?
      meta : 
    Json    ?
    } derive(Eq)

    How much of the context window the conversation fills.
    impl FromJson for Usage
    impl ToJson for Usage

    Usage::equal

    source
    fn Usage::equal(Usage, Usage) -> Bool

    Usage::from_json

    source

    Usage::not_equal

    source
    fn Usage::not_equal(x : Usage, y : Usage) -> Bool

    Usage::to_json

    source

    WriteTextFile

    source
    pub(all) struct WriteTextFile {
      session_id : String
      path : String
      content : String
      meta : 
    Json    ?
    } derive(Eq)

    A text file to write, whole.

    WriteTextFile::equal

    source

    WriteTextFile::from_json

    source

    WriteTextFile::not_equal

    source
    fn WriteTextFile::not_equal(x : WriteTextFile, y : WriteTextFile) -> Bool

    WriteTextFile::to_json

    source

    authentication_required

    source
    let authentication_required : Int

    The client has to authenticate before this method works.

    connect

    source
    fn connect(client : &Client, frames : &
    Frames    ) -> Conn

    Wires a client to a transport. The caller runs the returned connection, which is what delivers updates and answers the agent's calls.

    failure_of

    source
    fn failure_of(error : Error) -> 
    Failure

    Turns anything a handler raised into the error object to send: the wire code is kept, and anything that is not a Refused becomes -32603 with no detail, because what a handler trips over is not the caller's to read.

    internal_error

    source
    let internal_error : Int

    The handler failed for its own reasons.

    invalid_params

    source
    let invalid_params : Int

    The parameters are not what the method takes.

    invalid_request

    source
    let invalid_request : Int

    The value is not a valid message.

    method_not_found

    source
    let method_not_found : Int

    Nobody handles that method.

    parse_error

    source
    let parse_error : Int

    The text is not JSON.

    protocol_version

    source
    let protocol_version : Int

    The protocol version this library speaks. It only changes when the protocol breaks.

    refused_of

    source

    The reverse, for a call that came back with an error object.

    request_cancelled

    source
    let request_cancelled : Int

    The caller asked for the work to stop.

    resource_not_found

    source
    let resource_not_found : Int

    A path, a session or a resource named in the request does not exist.

    serve

    source

    Serves an agent over any transport: the caller runs the returned peer. Messages are answered in the order they arrive, and batches are refused, because the protocol has none.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io