tiny.acp.Client

1/// A caller owns a client for the life of one agent program, to send it prompts and get replies2/// back. The instance holds one agent process, the pipes to it, the reader for its output, and the3/// state of one session. The order of use is `init`, `start`, any number of prompt calls, then4/// `deinit`. The client writes each message to the agent as one line of JSON and reads the agent's5/// messages one line at a time. Each call writes one request and then reads the agent's messages6/// until the matching response arrives. While it waits, the call hands updates to the observer,7/// answers permission requests, answers any other request from the agent with a "method not found"8/// error, and drops other notifications. A line of invalid JSON, any other message, or the end of9/// the agent's output before the response fails the call with `error.AgentProtocolError`. The10/// fields hold the client's working state, and the package tests read `initialize`, `modes` and11/// `child` directly.12pub const Client = struct {13    /// The allocator for everything the client owns: the argument list, the directory copy, the14    /// reader's buffer, parsed messages, reply text and the session id.15    allocator: std.mem.Allocator,16    /// The argument list the agent started with: the command, then its arguments. The client owns17    /// the list, and the strings in it are borrowed from `Options`.18    argv: []const []const u8,19    /// The client's own copy of `Options.cwd`, or null. The method `start` reads it for20    /// `session/new`, and `deinit` frees it.21    cwd: ?[]u8,22    /// The name, title and version from `Options.client`, sent by `start`.23    info: ClientInfo,24    /// The MCP servers from `Options.mcp_servers`, sent by `start`.25    mcp_servers: []const McpServer,26    /// The permission lists from `Options.permission_policy`.27    permission_policy: PermissionPolicy,28    /// The callbacks from `Options.observer`, or null.29    observer: ?Observer,30    /// The traffic caps from `Options.transfer_limits`.31    transfer_limits: TransferLimits,32    /// The caller's number for this client from `Options.transport_epoch`, stamped on every update.33    transport_epoch: u64,34    /// The number the next update gets. The value starts at 1 and rises by one for each update, and35    /// nothing resets it.36    next_update_sequence: u64 = 1,37    /// The Zig standard library's thread-based I/O (`std.Io.Threaded`) the client created for the38    /// agent's process and pipes. The state carries the environment the agent started with. The39    /// method `deinit` frees it.40    io_state: sys.thread.ThreadedIo,41    /// The agent process, with the pipes to its standard input and output. The agent runs in a42    /// process group of its own, and its standard error is discarded.43    child: sys.process.Child,44    /// The line reader over the agent's standard output, which holds the reader's buffer.45    reader: LineReader,46    /// The id the next request gets. The value starts at 0 and rises by one per request, so47    /// `initialize` gets 0, `session/new` gets 1, and the first prompt gets 2.48    next_id: i64 = 0,49    /// The agent's id for the current session, taken from the `session/new` answer. The field is50    /// null before `start`, and every prompt call fails with `error.AgentProtocolError` while it is51    /// null. The client owns it.52    session_id: ?[]u8 = null,53    /// The agent's answer to `initialize`, set by `start`. The field holds the empty defaults54    /// before `start`. Callers read the protocol version, capability flags and authentication55    /// methods from it.56    initialize: protocol.Initialize = .{},57    /// The session's modes from the `session/new` answer, set by `start`. The field is empty when58    /// the agent reports no modes.59    modes: protocol.Modes = .{},60    /// The client's own copy of the message in the latest JSON-RPC error answer from the agent, or61    /// null. Each later error answer replaces it, and a later success leaves it in place. Callers62    /// read it through `agentError`.63    agent_error: ?[]u8 = null,6465    /// A caller calls `init` to start the agent and prepare everything the conversation needs, so66    /// later calls only exchange messages. The function checks the limits, allocates the reader's67    /// buffer, copies the argument list and the working directory, then starts the agent. The68    /// function returns `error.InvalidLimits` before it allocates anything when a traffic cap or69    /// the transport epoch is zero. The call allocates the reader's buffer, the line limit plus one70    /// byte, before the agent starts, so a limit too large to add one to fails with71    /// `error.CapacityOverflow` and no process starts. The agent starts in a new process group of72    /// its own, with pipes on standard input and output and standard error discarded. The call73    /// returns allocation errors, errors from starting the process, and74    /// `error.AgentTransportFailed` when the process has no output pipe. On an error after the75    /// agent starts, the function signals the agent's process group to terminate and then to die,76    /// and waits for the agent to exit. The call sends the agent no message: the conversation77    /// begins with `start`. The caller owns the result and ends it with `deinit`.78    pub fn init(allocator: std.mem.Allocator, options: Options) !Client {79        if (!options.transfer_limits.valid() or options.transport_epoch == 0) {80            return error.InvalidLimits;81        }82        var reader_storage = try reader.Storage.init(allocator, options.reader_limits);83        errdefer reader_storage.deinit(allocator);84        const argv = try allocator.alloc([]const u8, options.args.len + 1);85        errdefer allocator.free(argv);86        argv[0] = options.command;87        @memcpy(argv[1..], options.args);88        const cwd = if (options.cwd) |value| try allocator.dupe(u8, value) else null;89        errdefer if (cwd) |value| allocator.free(value);90        var io_state = sys.thread.initThreadedIo(allocator, .{ .environ = options.environ orelse sys.env.current() });91        errdefer io_state.deinit();92        const io = io_state.io();93        var child = try sys.process.spawn(io, .{94            .argv = argv,95            .stdin = .pipe,96            .stdout = .pipe,97            .stderr = .ignore,98            .cwd = if (cwd) |value| .{ .path = value } else .inherit,99            .pgid = 0,100        });101        errdefer stopChildAndReap(&child, io);102        const stdout = child.stdout orelse return error.AgentTransportFailed;103        reader_storage.activate();104        return .{105            .allocator = allocator,106            .argv = argv,107            .cwd = cwd,108            .info = options.client,109            .mcp_servers = options.mcp_servers,110            .permission_policy = options.permission_policy,111            .observer = options.observer,112            .transfer_limits = options.transfer_limits,113            .transport_epoch = options.transport_epoch,114            .io_state = io_state,115            .child = child,116            .reader = LineReader.init(io, stdout, reader_storage),117        };118    }119120    /// A caller calls `deinit` once to end the agent and free what the client owns when done with121    /// the client. The function frees the reader's buffer, the stored `initialize` answer, the122    /// modes, the error message, the session id and the directory copy. The client signals the123    /// agent's whole process group to terminate and then to die, and waits for the agent to exit.124    /// The client sends the agent no message first, `session/cancel` included. The call frees the125    /// I/O instance and the argument list.126    pub fn deinit(self: *Client) void {127        self.reader.deinit(self.allocator);128        self.initialize.deinit(self.allocator);129        self.modes.deinit(self.allocator);130        if (self.agent_error) |value| self.allocator.free(value);131        if (self.session_id) |value| self.allocator.free(value);132        if (self.cwd) |value| self.allocator.free(value);133        stopChildAndReap(&self.child, self.io_state.io());134        self.io_state.deinit();135        self.allocator.free(self.argv);136    }137138    /// A caller reads the status to learn why reading stopped after139    /// `error.ReaderMessageCapacityExceeded`, or to watch how close the agent's lines come to the140    /// limit. The call returns a snapshot of the reader's limit, buffer size, bytes waiting,141    /// longest line seen, rejected lines, and whether reading has stopped. The package test reads142    /// it after an overlong line.143    pub fn readerStatus(self: *const Client) reader.Status {144        return self.reader.storage.status();145    }146147    /// A caller uses this call to stop the agent and everything it started at once. The client148    /// signals the agent's whole process group to terminate and then to die, so tools the agent149    /// started stop too. The call falls back to signalling the agent alone when signalling the150    /// group fails. The function sends no `session/cancel` message: the client sends that message151    /// only when a reply reaches a limit. The function returns without waiting for the agent to152    /// exit, and `deinit` waits for it later. The call returns at once when the process has already153    /// been reaped. A later call that reads from the agent finds its output closed and fails with154    /// `error.AgentProtocolError`.155    pub fn requestCancel(self: *Client) void {156        stopChild(&self.child, self.io_state.io());157    }158159    /// A caller calls `start` once after `init` and before the first prompt to open the160    /// conversation. The call sends `initialize` with protocol version 1, an empty set of client161    /// capabilities and the client's name, title and version, then waits for the answer. The162    /// function fails with `error.AgentProtocolError` when the agent answers with an error, a163    /// malformed result, or a protocol version other than 1. The client keeps the message of an164    /// error answer for `agentError`. The call stores the answer in the `initialize` field. The165    /// function then sends `session/new` with the working directory and the MCP servers, and stores166    /// the session id and the modes from the answer. Updates and permission requests that arrive167    /// meanwhile go through the observer as they do during a prompt. Calling it again runs both168    /// steps again and replaces the stored answer, session id and modes. The call can also fail169    /// with `error.RequestCapacityExceeded`, `error.ReaderMessageCapacityExceeded` and the errors170    /// listed at `promptDetailedContent` for messages that arrive meanwhile.171    pub fn start(self: *Client) !void {172        const initialize_id = self.nextRequestId();173        try self.writeInitialize(initialize_id);174        var initialize_capture = PromptCapture{};175        defer initialize_capture.deinit(self.allocator);176        var initialized = try self.readResponse(initialize_id, &initialize_capture);177        defer initialized.deinit();178        _ = try self.responseResult(initialized.value);179        var initialize = try protocol.Initialize.fromResponse(self.allocator, initialized.value);180        errdefer initialize.deinit(self.allocator);181        if (initialize.protocol_version != 1) return error.AgentProtocolError;182        self.initialize.deinit(self.allocator);183        self.initialize = initialize;184185        const session_id_request = self.nextRequestId();186        if (self.cwd) |cwd| {187            try self.writeSessionNew(session_id_request, cwd);188        } else {189            const cwd = try sys.fs.cwdAlloc(self.allocator);190            defer self.allocator.free(cwd);191            try self.writeSessionNew(session_id_request, cwd);192        }193        var session_capture = PromptCapture{};194        defer session_capture.deinit(self.allocator);195        var session = try self.readResponse(session_id_request, &session_capture);196        defer session.deinit();197        _ = try self.responseResult(session.value);198        var modes = try protocol.Modes.fromResponse(self.allocator, session.value) orelse protocol.Modes{};199        errdefer modes.deinit(self.allocator);200        if (self.session_id) |value| {201            self.allocator.free(value);202            self.session_id = null;203        }204        self.session_id = try self.extractSessionId(session.value);205        self.modes.deinit(self.allocator);206        self.modes = modes;207    }208209    /// A caller uses this call for the common case of sending text and getting the reply text back.210    /// The call sends the text as one prompt and returns the reply: the text of the agent's message211    /// chunks, joined in arrival order. The caller owns the returned bytes and frees them with the212    /// client's allocator. The call drops the stop reason and any overflow record, which213    /// `promptDetailed` returns. The function fails as `promptDetailedContent` does.214    pub fn prompt(self: *Client, text: []const u8) ![]u8 {215        var result = try self.promptDetailed(text);216        const response = result.response;217        result.response = &.{};218        result.deinit(self.allocator);219        return response;220    }221222    /// A caller uses this call to send text and also learn why the agent stopped and whether the223    /// reply was cut short. The call sends the text as one text block and returns the reply, the224    /// stop reason and any overflow record. The caller frees the result with `PromptResult.deinit`225    /// and the client's allocator. The function fails as `promptDetailedContent` does.226    pub fn promptDetailed(self: *Client, text: []const u8) !protocol.PromptResult {227        const content = [_]protocol.PromptContent{.{ .text = text }};228        return try self.promptDetailedContent(content[0..]);229    }230231    /// A caller uses this call to send a prompt that carries files, links or media alongside text.232    /// The call sends one `session/prompt` request for the current session with the given blocks in233    /// order. The function fails with `error.AgentProtocolError` before `start` has set a session.234    /// The call reads until the prompt's response: each update goes to the observer, and agent235    /// message chunks join the reply within the reply limits. When one more chunk would pass a236    /// reply limit, the reply keeps what came before it, the result records the overflow, and the237    /// client sends one `session/cancel` and keeps waiting for the agent's final response. The call238    /// returns the reply, the agent's stop reason and the overflow record, and the caller frees the239    /// result with `PromptResult.deinit`. The function fails with `error.RequestCapacityExceeded`240    /// when the request is too large to send, and nothing is sent. The call fails with241    /// `error.UpdateCapacityExceeded` or `error.UpdateCountCapacityExceeded` for an update past a242    /// limit, `error.ReaderMessageCapacityExceeded` for a line past the line limit,243    /// `error.MissingDurableObserver` when a callback it needs is missing, and any error an244    /// observer callback returns. The call fails with `error.AgentProtocolError` for an error245    /// answer, a malformed message, or a response without a `stopReason`. The call reads the blocks246    /// and their strings only during the call.247    pub fn promptDetailedContent(self: *Client, content: []const protocol.PromptContent) !protocol.PromptResult {248        const session_id = self.session_id orelse return error.AgentProtocolError;249        const prompt_id = self.nextRequestId();250        try self.writePrompt(prompt_id, session_id, content);251        var capture = PromptCapture{};252        defer capture.deinit(self.allocator);253        var response = try self.readResponse(prompt_id, &capture);254        defer response.deinit();255        const response_text = try capture.chunks.toOwnedSlice(self.allocator);256        errdefer self.allocator.free(response_text);257        const stop_reason = try self.extractPromptStop(response.value);258        errdefer self.allocator.free(stop_reason);259        return .{260            .response = response_text,261            .stop_reason = stop_reason,262            .overflow = capture.overflow,263        };264    }265266    fn nextRequestId(self: *Client) i64 {267        const id = self.next_id;268        self.next_id += 1;269        return id;270    }271272    /// A caller uses this call to show what the agent said after a call fails with273    /// `error.AgentProtocolError`. The call returns the message of the latest JSON-RPC error answer274    /// from the agent, or null when there has been none. The message stays until a later error275    /// answer replaces it, so a later success leaves it in place. When copying a new message fails276    /// for lack of memory, the client keeps the older message. The slice belongs to the client and277    /// stays valid until the next error answer or `deinit`.278    pub fn agentError(self: *const Client) ?[]const u8 {279        return self.agent_error;280    }281282    fn recordAgentError(self: *Client, error_value: std.json.Value) void {283        const object = json.getObject(error_value) orelse return;284        const message = json.objectString(object, "message") orelse return;285        const owned = self.allocator.dupe(u8, message) catch return;286        if (self.agent_error) |previous| self.allocator.free(previous);287        self.agent_error = owned;288    }289290    fn responseResult(self: *Client, value: std.json.Value) !std.json.ObjectMap {291        const object = json.getObject(value) orelse return error.AgentProtocolError;292        if (object.get("error")) |error_value| {293            self.recordAgentError(error_value);294            return error.AgentProtocolError;295        }296        const result = object.get("result") orelse return error.AgentProtocolError;297        return json.getObject(result) orelse return error.AgentProtocolError;298    }299300    fn extractSessionId(self: *Client, value: std.json.Value) ![]u8 {301        const result = try self.responseResult(value);302        const session_id = json.objectString(result, "sessionId") orelse return error.AgentProtocolError;303        return try self.allocator.dupe(u8, session_id);304    }305306    fn extractPromptStop(self: *Client, value: std.json.Value) ![]u8 {307        const result = try self.responseResult(value);308        const reason = json.objectString(result, "stopReason") orelse return error.AgentProtocolError;309        return try self.allocator.dupe(u8, reason);310    }311312    fn writeInitialize(self: *Client, id: i64) !void {313        var out: std.Io.Writer.Allocating = .init(self.allocator);314        defer out.deinit();315        var stream = pretty_json.Writer.init(&out.writer, .minified);316        const root = try stream.object();317        try root.field("jsonrpc", "2.0");318        try root.field("id", id);319        try root.field("method", "initialize");320        const params = try root.object("params");321        try params.field("protocolVersion", 1);322        try params.field("clientCapabilities", .{});323        const client_info = try params.object("clientInfo");324        try client_info.field("name", self.info.name);325        try client_info.field("title", self.info.title);326        try client_info.field("version", self.info.version);327        try client_info.end();328        try params.end();329        try root.endLine();330        try self.send(out.written());331    }332333    fn writeSessionNew(self: *Client, id: i64, cwd: []const u8) !void {334        var out: std.Io.Writer.Allocating = .init(self.allocator);335        defer out.deinit();336        var stream = pretty_json.Writer.init(&out.writer, .minified);337        const root = try stream.object();338        try root.field("jsonrpc", "2.0");339        try root.field("id", id);340        try root.field("method", "session/new");341        const params = try root.object("params");342        try params.field("cwd", cwd);343        try writeMcpServers(try params.array("mcpServers"), self.mcp_servers);344        try params.end();345        try root.endLine();346        try self.send(out.written());347    }348349    fn writePrompt(350        self: *Client,351        id: i64,352        session_id: []const u8,353        content: []const protocol.PromptContent,354    ) !void {355        var out: std.Io.Writer.Allocating = .init(self.allocator);356        defer out.deinit();357        var stream = pretty_json.Writer.init(&out.writer, .minified);358        const root = try stream.object();359        try root.field("jsonrpc", "2.0");360        try root.field("id", id);361        try root.field("method", "session/prompt");362        const params = try root.object("params");363        try params.field("sessionId", session_id);364        try writePromptContent(try params.array("prompt"), content);365        try params.end();366        try root.endLine();367        try self.send(out.written());368    }369370    fn writePromptContent(array: pretty_json.Array, content: []const protocol.PromptContent) !void {371        for (content) |item| try writePromptContentItem(array, item);372        try array.end();373    }374375    fn writePromptContentItem(array: pretty_json.Array, item: protocol.PromptContent) !void {376        switch (item) {377            .text => |text| {378                const object = try array.object();379                try object.field("type", "text");380                try object.field("text", text);381                try object.end();382            },383            .image => |media| try writePromptMedia(array, "image", media),384            .audio => |media| try writePromptMedia(array, "audio", media),385            .resource_text => |resource| try writePromptTextResource(array, resource),386            .resource_blob => |resource| try writePromptBlobResource(array, resource),387            .resource_link => |link| try writePromptResourceLink(array, link),388        }389    }390391    fn writePromptMedia(392        array: pretty_json.Array,393        content_type: []const u8,394        media: protocol.PromptMedia,395    ) !void {396        const object = try array.object();397        try object.field("type", content_type);398        try object.field("mimeType", media.mime_type);399        try object.field("data", media.data);400        try writeOptionalStringField(object, "uri", media.uri);401        try object.end();402    }403404    fn writePromptTextResource(405        array: pretty_json.Array,406        resource: protocol.PromptTextResource,407    ) !void {408        const object = try array.object();409        try object.field("type", "resource");410        const value = try object.object("resource");411        try value.field("uri", resource.uri);412        try value.field("text", resource.text);413        try writeOptionalStringField(value, "mimeType", resource.mime_type);414        try value.end();415        try object.end();416    }417418    fn writePromptBlobResource(419        array: pretty_json.Array,420        resource: protocol.PromptBlobResource,421    ) !void {422        const object = try array.object();423        try object.field("type", "resource");424        const value = try object.object("resource");425        try value.field("uri", resource.uri);426        try value.field("blob", resource.blob);427        try writeOptionalStringField(value, "mimeType", resource.mime_type);428        try value.end();429        try object.end();430    }431432    fn writePromptResourceLink(array: pretty_json.Array, link: protocol.PromptResourceLink) !void {433        const object = try array.object();434        try object.field("type", "resource_link");435        try object.field("uri", link.uri);436        try object.field("name", link.name);437        try writeOptionalStringField(object, "mimeType", link.mime_type);438        try writeOptionalStringField(object, "title", link.title);439        try writeOptionalStringField(object, "description", link.description);440        if (link.size) |size| try object.field("size", size);441        try object.end();442    }443444    fn writeOptionalStringField(445        object: pretty_json.Object,446        name: []const u8,447        value: []const u8,448    ) !void {449        if (value.len == 0) return;450        try object.field(name, value);451    }452453    fn writeErrorResponse(self: *Client, id_value: std.json.Value) !void {454        var out: std.Io.Writer.Allocating = .init(self.allocator);455        defer out.deinit();456        var stream = pretty_json.Writer.init(&out.writer, .minified);457        const root = try stream.object();458        try root.field("jsonrpc", "2.0");459        try root.field("id", id_value);460        const error_value = try root.object("error");461        try error_value.field("code", -32601);462        try error_value.field("message", "method not found");463        try error_value.end();464        try root.endLine();465        try self.send(out.written());466    }467468    fn writePermissionResponse(469        self: *Client,470        id_value: std.json.Value,471        selection: PermissionSelection,472    ) !void {473        var out: std.Io.Writer.Allocating = .init(self.allocator);474        defer out.deinit();475        var stream = pretty_json.Writer.init(&out.writer, .minified);476        const root = try stream.object();477        try root.field("jsonrpc", "2.0");478        try root.field("id", id_value);479        const result = try root.object("result");480        const outcome = try result.object("outcome");481        try outcome.field("outcome", selection.outcome);482        try writeOptionalStringField(outcome, "optionId", selection.option_id);483        try outcome.end();484        try result.end();485        try root.endLine();486        try self.send(out.written());487    }488489    fn writeCancel(self: *Client) !void {490        const session_id = self.session_id orelse return error.AgentProtocolError;491        var out: std.Io.Writer.Allocating = .init(self.allocator);492        defer out.deinit();493        var stream = pretty_json.Writer.init(&out.writer, .minified);494        const root = try stream.object();495        try root.field("jsonrpc", "2.0");496        try root.field("method", "session/cancel");497        const params = try root.object("params");498        try params.field("sessionId", session_id);499        try params.end();500        try root.endLine();501        try self.send(out.written());502    }503504    fn send(self: *Client, bytes: []const u8) !void {505        if (bytes.len > self.transfer_limits.request_bytes) {506            return error.RequestCapacityExceeded;507        }508        const stdin = self.child.stdin orelse return error.AgentTransportFailed;509        try fileWriteAll(self.io_state.io(), stdin, bytes);510    }511512    fn selectPermission(self: *Client, object: std.json.ObjectMap) !OwnedSelection {513        if (self.observer) |observer| {514            if (observer.permissionFn != null) {515                var preview = try protocol.PermissionRequest.fromClientRequest(516                    self.allocator,517                    object,518                    "",519                    "pending",520                    "",521                    "",522                );523                defer preview.deinit(self.allocator);524                if (observer.permission(preview)) |reply| {525                    var owned = OwnedSelection{ .allocator = self.allocator, .selection = .{ .outcome = "cancelled" } };526                    errdefer owned.deinit();527                    owned.outcome = try self.allocator.dupe(u8, reply.outcome);528                    owned.option_id = try self.allocator.dupe(u8, reply.option_id);529                    owned.option_kind = try self.allocator.dupe(u8, reply.option_kind);530                    owned.selection = .{531                        .outcome = owned.outcome.?,532                        .option_id = owned.option_id.?,533                        .option_kind = owned.option_kind.?,534                    };535                    return owned;536                }537            }538        }539        return .{ .allocator = self.allocator, .selection = permissionSelection(object, self.permission_policy) };540    }541542    fn readResponse(self: *Client, id: i64, capture: *PromptCapture) !std.json.Parsed(std.json.Value) {543        while (try self.reader.nextLine()) |line| {544            const trimmed = std.mem.trim(u8, line, " \t\r\n");545            if (trimmed.len == 0) continue;546            var parsed = std.json.parseFromSlice(std.json.Value, self.allocator, trimmed, .{}) catch return error.AgentProtocolError;547            if (isResponseFor(parsed.value, id)) return parsed;548            if (try self.handleIncoming(parsed.value, trimmed, capture)) {549                parsed.deinit();550                continue;551            }552            parsed.deinit();553            return error.AgentProtocolError;554        }555        return error.AgentProtocolError;556    }557558    fn handleIncoming(559        self: *Client,560        value: std.json.Value,561        envelope: []const u8,562        capture: *PromptCapture,563    ) !bool {564        const object = json.getObject(value) orelse return false;565        if (json.objectString(object, "method")) |method| {566            if (std.mem.eql(u8, method, "session/update")) {567                const update_sequence = self.next_update_sequence;568                if (update_sequence > self.transfer_limits.update_count) {569                    return error.UpdateCountCapacityExceeded;570                }571                if (envelope.len > self.transfer_limits.update_bytes) {572                    return error.UpdateCapacityExceeded;573                }574                self.next_update_sequence = std.math.add(575                    u64,576                    update_sequence,577                    1,578                ) catch return error.UpdateCountCapacityExceeded;579                var update = (try protocol.Update.fromSessionNotification(580                    self.allocator,581                    object,582                    self.transport_epoch,583                    update_sequence,584                    envelope,585                )) orelse return error.AgentProtocolError;586                defer update.deinit(self.allocator);587                const observer = self.observer orelse588                    return error.MissingDurableObserver;589                try observer.update(update);590                if (try capture.appendResponse(591                    self.allocator,592                    update,593                    self.transfer_limits,594                )) try self.writeCancel();595                return true;596            }597            if (std.mem.eql(u8, method, "session/request_permission")) {598                const id_value = object.get("id") orelse return false;599                var selection = try self.selectPermission(object);600                defer selection.deinit();601                var request = try protocol.PermissionRequest.fromClientRequest(602                    self.allocator,603                    object,604                    envelope,605                    selection.selection.outcome,606                    selection.selection.option_id,607                    selection.selection.option_kind,608                );609                defer request.deinit(self.allocator);610                const observer = self.observer orelse611                    return error.MissingDurableObserver;612                try observer.commitPermission(request);613                try self.writePermissionResponse(id_value, selection.reply());614                return true;615            }616            if (object.get("id")) |id_value| {617                try self.writeErrorResponse(id_value);618                return true;619            }620            return true;621        }622        return false;623    }624};

1pub const Client = client.Client;