@linkshell/wire 0.2.19 → 0.2.21

package/dist/rpc.d.ts

@@ -59,11 +59,18 @@ export declare const rpcMessageSchema: z.ZodObject<{
 }>;
 export type RpcMessage = z.infer<typeof rpcMessageSchema>;
 /** Application error codes carried in `error.data.code`. */
-export declare const appErrorCodeSchema: z.ZodEnum<["invalid_params", "not_found", "agent_unavailable", "not_supported", "not_ready", "busy", "offline", "internal"]>;
+export declare const appErrorCodeSchema: z.ZodEnum<["invalid_params", "not_found", "agent_unavailable", "not_supported", "not_ready", "busy", "offline", "locked", "internal"]>;
 export type AppErrorCode = z.infer<typeof appErrorCodeSchema>;
 export declare const RPC_INVALID_PARAMS = -32602;
 export declare const RPC_METHOD_NOT_FOUND = -32601;
 export declare const RPC_APP_ERROR = -32000;
+/**
+ * The host's RPC revision, in `machine.info`. Goes up when the host gains
+ * methods or notifications an app may rely on, so an app can tell the
+ * computer is older than itself and say so (an absent revision is 0).
+ * 1: side conversations (`sessions.side`), `machine.info.protocol` itself.
+ */
+export declare const HOST_PROTOCOL = 1;
 export declare const directoryEntrySchema: z.ZodObject<{
     name: z.ZodString;
     path: z.ZodString;
@@ -3898,6 +3905,7 @@ declare const coreMethods: {
             hostname: z.ZodString;
             platform: z.ZodString;
             hostVersion: z.ZodString;
+            protocol: z.ZodOptional<z.ZodNumber>;
             home: z.ZodOptional<z.ZodString>;
             agents: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -3928,6 +3936,7 @@ declare const coreMethods: {
                     embeddedContext: z.ZodOptional<z.ZodBoolean>;
                     acp: z.ZodOptional<z.ZodBoolean>;
                     fork: z.ZodBoolean;
+                    side: z.ZodOptional<z.ZodBoolean>;
                     models: z.ZodBoolean;
                     modes: z.ZodBoolean;
                 }, "strip", z.ZodTypeAny, {
@@ -3941,6 +3950,7 @@ declare const coreMethods: {
                     acp?: boolean | undefined;
                     audio?: boolean | undefined;
                     embeddedContext?: boolean | undefined;
+                    side?: boolean | undefined;
                 }, {
                     interrupt: boolean;
                     steer: boolean;
@@ -3952,6 +3962,7 @@ declare const coreMethods: {
                     acp?: boolean | undefined;
                     audio?: boolean | undefined;
                     embeddedContext?: boolean | undefined;
+                    side?: boolean | undefined;
                 }>;
             }, "strip", z.ZodTypeAny, {
                 id: string;
@@ -3969,6 +3980,7 @@ declare const coreMethods: {
                     acp?: boolean | undefined;
                     audio?: boolean | undefined;
                     embeddedContext?: boolean | undefined;
+                    side?: boolean | undefined;
                 };
                 version?: string | undefined;
                 problem?: string | undefined;
@@ -3993,6 +4005,7 @@ declare const coreMethods: {
                     acp?: boolean | undefined;
                     audio?: boolean | undefined;
                     embeddedContext?: boolean | undefined;
+                    side?: boolean | undefined;
                 };
                 version?: string | undefined;
                 problem?: string | undefined;
@@ -4009,6 +4022,7 @@ declare const coreMethods: {
             }, {
                 iceServers: string[];
             }>>;
+            locked: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             agents: {
                 id: string;
@@ -4026,6 +4040,7 @@ declare const coreMethods: {
                     acp?: boolean | undefined;
                     audio?: boolean | undefined;
                     embeddedContext?: boolean | undefined;
+                    side?: boolean | undefined;
                 };
                 version?: string | undefined;
                 problem?: string | undefined;
@@ -4039,10 +4054,12 @@ declare const coreMethods: {
             hostname: string;
             platform: string;
             hostVersion: string;
+            protocol?: number | undefined;
             home?: string | undefined;
             direct?: {
                 iceServers: string[];
             } | undefined;
+            locked?: boolean | undefined;
         }, {
             agents: {
                 id: string;
@@ -4060,6 +4077,7 @@ declare const coreMethods: {
                     acp?: boolean | undefined;
                     audio?: boolean | undefined;
                     embeddedContext?: boolean | undefined;
+                    side?: boolean | undefined;
                 };
                 version?: string | undefined;
                 problem?: string | undefined;
@@ -4073,10 +4091,12 @@ declare const coreMethods: {
             hostname: string;
             platform: string;
             hostVersion: string;
+            protocol?: number | undefined;
             home?: string | undefined;
             direct?: {
                 iceServers: string[];
             } | undefined;
+            locked?: boolean | undefined;
         }>;
     };
     readonly "projects.list": {
@@ -21672,6 +21692,223 @@ declare const coreMethods: {
             }[];
         }>;
     };
+    /**
+     * Asks in a side conversation of the session (a new one without `sideId`):
+     * answered from what the session knows, never added to it. Returns once the
+     * question is on its way; the answer comes in `session.side`. Only for an
+     * agent whose capabilities say `side`.
+     */
+    readonly "sessions.side": {
+        readonly params: z.ZodObject<{
+            sessionId: z.ZodString;
+            sideId: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            sessionId: string;
+            sideId?: string | undefined;
+        }, {
+            text: string;
+            sessionId: string;
+            sideId?: string | undefined;
+        }>;
+        readonly result: z.ZodObject<{
+            side: z.ZodObject<{
+                sideId: z.ZodString;
+                createdAt: z.ZodNumber;
+                running: z.ZodBoolean;
+                revision: z.ZodNumber;
+                messages: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    role: z.ZodEnum<["user", "assistant"]>;
+                    text: z.ZodString;
+                    activity: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    error: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }, {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            }, {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            side: {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            };
+        }, {
+            side: {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            };
+        }>;
+    };
+    /** The session's open side conversations, oldest first. */
+    readonly "sessions.sides": {
+        readonly params: z.ZodObject<{
+            sessionId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            sessionId: string;
+        }, {
+            sessionId: string;
+        }>;
+        readonly result: z.ZodObject<{
+            sides: z.ZodArray<z.ZodObject<{
+                sideId: z.ZodString;
+                createdAt: z.ZodNumber;
+                running: z.ZodBoolean;
+                revision: z.ZodNumber;
+                messages: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    role: z.ZodEnum<["user", "assistant"]>;
+                    text: z.ZodString;
+                    activity: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                    error: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }, {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            }, {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            sides: {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            }[];
+        }, {
+            sides: {
+                running: boolean;
+                createdAt: number;
+                sideId: string;
+                revision: number;
+                messages: {
+                    id: string;
+                    text: string;
+                    role: "user" | "assistant";
+                    error?: string | undefined;
+                    activity?: string[] | undefined;
+                }[];
+            }[];
+        }>;
+    };
+    /** Stops the answer under way. */
+    readonly "sessions.sideCancel": {
+        readonly params: z.ZodObject<{
+            sessionId: z.ZodString;
+            sideId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            sessionId: string;
+            sideId: string;
+        }, {
+            sessionId: string;
+            sideId: string;
+        }>;
+        readonly result: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+    };
+    /** Ends a side conversation: it is forgotten, and whatever the agent kept for it let go. */
+    readonly "sessions.sideClose": {
+        readonly params: z.ZodObject<{
+            sessionId: z.ZodString;
+            sideId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            sessionId: string;
+            sideId: string;
+        }, {
+            sessionId: string;
+            sideId: string;
+        }>;
+        readonly result: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+    };
     /** The commands this session left running in the background, and the ones that have ended; newest first. */
     readonly "sessions.tasks": {
         readonly params: z.ZodObject<{
@@ -25266,6 +25503,61 @@ declare const coreMethods: {
         }>;
         readonly result: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
     };
+    /**
+     * Unlocks this connection with the password, or with a `token` an earlier unlock returned (so a
+     * reconnect doesn't ask again). Hosts without the method have no password. Wrong guesses are
+     * throttled per device (`busy`).
+     */
+    readonly "access.unlock": {
+        readonly params: z.ZodObject<{
+            password: z.ZodOptional<z.ZodString>;
+            token: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            token?: string | undefined;
+            password?: string | undefined;
+        }, {
+            token?: string | undefined;
+            password?: string | undefined;
+        }>;
+        readonly result: z.ZodObject<{
+            token: z.ZodString;
+            expiresAt: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            expiresAt: number;
+            token: string;
+        }, {
+            expiresAt: number;
+            token: string;
+        }>;
+    };
+    /** Whether this computer has a password (local only). */
+    readonly "access.status": {
+        readonly params: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+        readonly result: z.ZodObject<{
+            password: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            password: boolean;
+        }, {
+            password: boolean;
+        }>;
+    };
+    /** Sets the password, or removes it when none is given (local only). Remote connections reconnect. */
+    readonly "access.set": {
+        readonly params: z.ZodObject<{
+            password: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            password?: string | undefined;
+        }, {
+            password?: string | undefined;
+        }>;
+        readonly result: z.ZodObject<{
+            password: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            password: boolean;
+        }, {
+            password: boolean;
+        }>;
+    };
     /** What git says about `path`; no `git` when it isn't in a repository. */
     readonly "git.info": {
         readonly params: z.ZodObject<{
@@ -25512,9 +25804,9 @@ declare const coreMethods: {
             revision?: string | undefined;
         }, {
             path: string;
+            revision?: string | undefined;
             offset?: number | undefined;
             maxBytes?: number | undefined;
-            revision?: string | undefined;
         }>;
         readonly result: z.ZodObject<{
             size: z.ZodNumber;
@@ -25525,14 +25817,14 @@ declare const coreMethods: {
         }, "strip", z.ZodTypeAny, {
             data: string;
             size: number;
-            nextOffset: number;
             revision: string;
+            nextOffset: number;
             done: boolean;
         }, {
             data: string;
             size: number;
-            nextOffset: number;
             revision: string;
+            nextOffset: number;
             done: boolean;
         }>;
     };
@@ -26303,6 +26595,7 @@ export declare const notifications: {
                 embeddedContext: z.ZodOptional<z.ZodBoolean>;
                 acp: z.ZodOptional<z.ZodBoolean>;
                 fork: z.ZodBoolean;
+                side: z.ZodOptional<z.ZodBoolean>;
                 models: z.ZodBoolean;
                 modes: z.ZodBoolean;
             }, "strip", z.ZodTypeAny, {
@@ -26316,6 +26609,7 @@ export declare const notifications: {
                 acp?: boolean | undefined;
                 audio?: boolean | undefined;
                 embeddedContext?: boolean | undefined;
+                side?: boolean | undefined;
             }, {
                 interrupt: boolean;
                 steer: boolean;
@@ -26327,6 +26621,7 @@ export declare const notifications: {
                 acp?: boolean | undefined;
                 audio?: boolean | undefined;
                 embeddedContext?: boolean | undefined;
+                side?: boolean | undefined;
             }>;
         }, "strip", z.ZodTypeAny, {
             id: string;
@@ -26344,6 +26639,7 @@ export declare const notifications: {
                 acp?: boolean | undefined;
                 audio?: boolean | undefined;
                 embeddedContext?: boolean | undefined;
+                side?: boolean | undefined;
             };
             version?: string | undefined;
             problem?: string | undefined;
@@ -26368,6 +26664,7 @@ export declare const notifications: {
                 acp?: boolean | undefined;
                 audio?: boolean | undefined;
                 embeddedContext?: boolean | undefined;
+                side?: boolean | undefined;
             };
             version?: string | undefined;
             problem?: string | undefined;
@@ -26394,6 +26691,7 @@ export declare const notifications: {
                 acp?: boolean | undefined;
                 audio?: boolean | undefined;
                 embeddedContext?: boolean | undefined;
+                side?: boolean | undefined;
             };
             version?: string | undefined;
             problem?: string | undefined;
@@ -26420,6 +26718,7 @@ export declare const notifications: {
                 acp?: boolean | undefined;
                 audio?: boolean | undefined;
                 embeddedContext?: boolean | undefined;
+                side?: boolean | undefined;
             };
             version?: string | undefined;
             problem?: string | undefined;
@@ -33196,6 +33495,92 @@ export declare const notifications: {
             } | undefined;
         };
     }>;
+    /** A side conversation changed (to every client), or ended (`closed`). */
+    readonly "session.side": z.ZodObject<{
+        sessionId: z.ZodString;
+        side: z.ZodObject<{
+            sideId: z.ZodString;
+            createdAt: z.ZodNumber;
+            running: z.ZodBoolean;
+            revision: z.ZodNumber;
+            messages: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                role: z.ZodEnum<["user", "assistant"]>;
+                text: z.ZodString;
+                activity: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                error: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                text: string;
+                role: "user" | "assistant";
+                error?: string | undefined;
+                activity?: string[] | undefined;
+            }, {
+                id: string;
+                text: string;
+                role: "user" | "assistant";
+                error?: string | undefined;
+                activity?: string[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            running: boolean;
+            createdAt: number;
+            sideId: string;
+            revision: number;
+            messages: {
+                id: string;
+                text: string;
+                role: "user" | "assistant";
+                error?: string | undefined;
+                activity?: string[] | undefined;
+            }[];
+        }, {
+            running: boolean;
+            createdAt: number;
+            sideId: string;
+            revision: number;
+            messages: {
+                id: string;
+                text: string;
+                role: "user" | "assistant";
+                error?: string | undefined;
+                activity?: string[] | undefined;
+            }[];
+        }>;
+        closed: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        side: {
+            running: boolean;
+            createdAt: number;
+            sideId: string;
+            revision: number;
+            messages: {
+                id: string;
+                text: string;
+                role: "user" | "assistant";
+                error?: string | undefined;
+                activity?: string[] | undefined;
+            }[];
+        };
+        sessionId: string;
+        closed?: boolean | undefined;
+    }, {
+        side: {
+            running: boolean;
+            createdAt: number;
+            sideId: string;
+            revision: number;
+            messages: {
+                id: string;
+                text: string;
+                role: "user" | "assistant";
+                error?: string | undefined;
+                activity?: string[] | undefined;
+            }[];
+        };
+        sessionId: string;
+        closed?: boolean | undefined;
+    }>;
     /** A session was deleted (from any device, or natively by the agent). */
     readonly "session.removed": z.ZodObject<{
         sessionId: z.ZodString;

package/dist/rpc.js

@@ -6,6 +6,7 @@ import { editorRequestSchema, editorResultSchema } from "./editor.js";
 import { liveActivityIdSchema, liveActivitySubscriptionSchema } from "./live-activity.js";
 import { backgroundTaskSchema, agentInfoSchema, gatewayStatusSchema, machineInfoSchema, portInfoSchema, projectSummarySchema, terminalInfoSchema, sessionDriverSchema, sessionSummarySchema, subagentInfoSchema, gitInfoSchema, worktreeEntrySchema, questionAnswerSchema, pendingPermissionSchema, } from "./model.js";
 import { contentBlockSchema, sessionEventSchema, sessionNoticeSchema } from "./updates.js";
+import { sideChatSchema } from "./side.js";
 // ── JSON-RPC 2.0 framing ─────────────────────────────────────────────
 export const rpcIdSchema = z.union([z.string(), z.number()]);
 export const rpcErrorSchema = z.object({
@@ -32,12 +33,21 @@ export const appErrorCodeSchema = z.enum([
     "busy",
     /** Client side: the link to the computer is down. */
     "offline",
+    /** The computer has an access password and this connection hasn't been unlocked (`access.unlock`). */
+    "locked",
     "internal",
 ]);
 export const RPC_INVALID_PARAMS = -32602;
 export const RPC_METHOD_NOT_FOUND = -32601;
 export const RPC_APP_ERROR = -32000;
 // ── Methods (client → host) ──────────────────────────────────────────
+/**
+ * The host's RPC revision, in `machine.info`. Goes up when the host gains
+ * methods or notifications an app may rely on, so an app can tell the
+ * computer is older than itself and say so (an absent revision is 0).
+ * 1: side conversations (`sessions.side`), `machine.info.protocol` itself.
+ */
+export const HOST_PROTOCOL = 1;
 const empty = z.object({}).passthrough();
 export const directoryEntrySchema = z.object({
     name: z.string(),
@@ -185,6 +195,31 @@ const coreMethods = {
         params: z.object({ sessionId: z.string().min(1), toolCallId: z.string().min(1), lazyImages: z.boolean().optional() }),
         result: z.object({ events: z.array(sessionEventSchema) }),
     },
+    /**
+     * Asks in a side conversation of the session (a new one without `sideId`):
+     * answered from what the session knows, never added to it. Returns once the
+     * question is on its way; the answer comes in `session.side`. Only for an
+     * agent whose capabilities say `side`.
+     */
+    "sessions.side": {
+        params: z.object({ sessionId: z.string().min(1), sideId: z.string().min(1).optional(), text: z.string().min(1).max(20_000) }),
+        result: z.object({ side: sideChatSchema }),
+    },
+    /** The session's open side conversations, oldest first. */
+    "sessions.sides": {
+        params: z.object({ sessionId: z.string().min(1) }),
+        result: z.object({ sides: z.array(sideChatSchema) }),
+    },
+    /** Stops the answer under way. */
+    "sessions.sideCancel": {
+        params: z.object({ sessionId: z.string().min(1), sideId: z.string().min(1) }),
+        result: empty,
+    },
+    /** Ends a side conversation: it is forgotten, and whatever the agent kept for it let go. */
+    "sessions.sideClose": {
+        params: z.object({ sessionId: z.string().min(1), sideId: z.string().min(1) }),
+        result: empty,
+    },
     /** The commands this session left running in the background, and the ones that have ended; newest first. */
     "sessions.tasks": {
         params: z.object({ sessionId: z.string().min(1) }),
@@ -382,6 +417,23 @@ const coreMethods = {
         result: z.object({ link: z.string(), code: z.string(), expiresAt: z.number(), gateway: z.string() }),
     },
     "devices.revoke": { params: z.object({ deviceId: z.string().min(1) }), result: empty },
+    // ── Access password: optional, set on the computer itself ──
+    /**
+     * Unlocks this connection with the password, or with a `token` an earlier unlock returned (so a
+     * reconnect doesn't ask again). Hosts without the method have no password. Wrong guesses are
+     * throttled per device (`busy`).
+     */
+    "access.unlock": {
+        params: z.object({ password: z.string().max(256).optional(), token: z.string().max(512).optional() }),
+        result: z.object({ token: z.string(), expiresAt: z.number() }),
+    },
+    /** Whether this computer has a password (local only). */
+    "access.status": { params: empty, result: z.object({ password: z.boolean() }) },
+    /** Sets the password, or removes it when none is given (local only). Remote connections reconnect. */
+    "access.set": {
+        params: z.object({ password: z.string().min(4).max(128).optional() }),
+        result: z.object({ password: z.boolean() }),
+    },
     // ── Git: sessions in worktrees ──
     /** What git says about `path`; no `git` when it isn't in a repository. */
     "git.info": { params: z.object({ path: z.string().min(1) }), result: z.object({ git: gitInfoSchema.optional() }) },
@@ -632,6 +684,8 @@ export const notifications = {
      */
     "session.window": z.object({ sessionId: z.string(), startSeq: z.number().int().nonnegative() }),
     "session.summary": z.object({ session: sessionSummarySchema }),
+    /** A side conversation changed (to every client), or ended (`closed`). */
+    "session.side": z.object({ sessionId: z.string(), side: sideChatSchema, closed: z.boolean().optional() }),
     /** A session was deleted (from any device, or natively by the agent). */
     "session.removed": z.object({ sessionId: z.string() }),
     "session.preview.show": z.object({ sessionId: z.string() }),