@linkshell/gateway 0.5.2 → 0.6.0

package/dist/wire/src/model.d.ts

@@ -17,6 +17,12 @@ export declare const agentCapabilitiesSchema: z.ZodObject<{
     steer: z.ZodBoolean;
     permissions: z.ZodBoolean;
     images: z.ZodBoolean;
+    /**
+     * The agent forks sessions itself, keeping everything it knew. Every agent's
+     * sessions can be forked: without this (or from a single reply, where the
+     * agent only forks whole sessions) LinkShell makes the fork — the new session
+     * shows the conversation and its agent is told it as text.
+     */
     fork: z.ZodBoolean;
     models: z.ZodBoolean;
     modes: z.ZodBoolean;
@@ -88,6 +94,12 @@ export declare const agentInfoSchema: z.ZodObject<{
         steer: z.ZodBoolean;
         permissions: z.ZodBoolean;
         images: z.ZodBoolean;
+        /**
+         * The agent forks sessions itself, keeping everything it knew. Every agent's
+         * sessions can be forked: without this (or from a single reply, where the
+         * agent only forks whole sessions) LinkShell makes the fork — the new session
+         * shows the conversation and its agent is told it as text.
+         */
         fork: z.ZodBoolean;
         models: z.ZodBoolean;
         modes: z.ZodBoolean;
@@ -192,6 +204,80 @@ export declare const sessionActivitySchema: z.ZodObject<{
 }>;
 export type SessionActivity = z.infer<typeof sessionActivitySchema>;
 /** The oldest unanswered permission request, so lists can offer approval inline. Live only. */
+/**
+ * Something the agent asks the user rather than asks permission for: a choice
+ * among options, several of them, or something to type (Claude's
+ * AskUserQuestion, Codex's request_user_input, an MCP server's form).
+ */
+export declare const questionSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** A short label for the question ("Auth method"). */
+    header: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+    kind: z.ZodEnum<["choice", "choices", "text"]>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }, {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }>, "many">>;
+    /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+    other: z.ZodOptional<z.ZodBoolean>;
+    /** What is typed shouldn't be shown (a token). */
+    secret: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "text" | "choice" | "choices";
+    text: string;
+    options?: {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }[] | undefined;
+    other?: boolean | undefined;
+    header?: string | undefined;
+    secret?: boolean | undefined;
+    required?: boolean | undefined;
+}, {
+    id: string;
+    kind: "text" | "choice" | "choices";
+    text: string;
+    options?: {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }[] | undefined;
+    other?: boolean | undefined;
+    header?: string | undefined;
+    secret?: boolean | undefined;
+    required?: boolean | undefined;
+}>;
+export type Question = z.infer<typeof questionSchema>;
+export declare const questionAnswerSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** The values picked (`choice`: at most one), or what was typed for a `text` question. */
+    values: z.ZodArray<z.ZodString, "many">;
+    /** The user's own answer beside the options. */
+    other: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    values: string[];
+    id: string;
+    other?: string | undefined;
+}, {
+    values: string[];
+    id: string;
+    other?: string | undefined;
+}>;
+export type QuestionAnswer = z.infer<typeof questionAnswerSchema>;
 export declare const pendingPermissionSchema: z.ZodObject<{
     requestId: z.ZodString;
     toolCallId: z.ZodOptional<z.ZodString>;
@@ -210,6 +296,59 @@ export declare const pendingPermissionSchema: z.ZodObject<{
         name: string;
         kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
     }>, "many">;
+    /** Set when this is a question to answer (`sessions.answer`) rather than a permission to give. */
+    questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** A short label for the question ("Auth method"). */
+        header: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+        /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+        kind: z.ZodEnum<["choice", "choices", "text"]>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }, {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }>, "many">>;
+        /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+        other: z.ZodOptional<z.ZodBoolean>;
+        /** What is typed shouldn't be shown (a token). */
+        secret: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }, {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     options: {
         optionId: string;
@@ -220,6 +359,20 @@ export declare const pendingPermissionSchema: z.ZodObject<{
     requestId: string;
     toolCallId?: string | undefined;
     detail?: string | undefined;
+    questions?: {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }[] | undefined;
 }, {
     options: {
         optionId: string;
@@ -230,6 +383,20 @@ export declare const pendingPermissionSchema: z.ZodObject<{
     requestId: string;
     toolCallId?: string | undefined;
     detail?: string | undefined;
+    questions?: {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }[] | undefined;
 }>;
 export type PendingPermissionSummary = z.infer<typeof pendingPermissionSchema>;
 export declare const queuedMessageSchema: z.ZodObject<{
@@ -239,12 +406,12 @@ export declare const queuedMessageSchema: z.ZodObject<{
     images: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     images: number;
-    clientMessageId: string;
     text: string;
+    clientMessageId: string;
 }, {
     images: number;
-    clientMessageId: string;
     text: string;
+    clientMessageId: string;
 }>;
 export type QueuedMessage = z.infer<typeof queuedMessageSchema>;
 /** A sub-agent a session started: the tool call it runs under, and how it is doing. */
@@ -323,6 +490,59 @@ export declare const sessionSummarySchema: z.ZodObject<{
             name: string;
             kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
         }>, "many">;
+        /** Set when this is a question to answer (`sessions.answer`) rather than a permission to give. */
+        questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            /** A short label for the question ("Auth method"). */
+            header: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+            /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+            kind: z.ZodEnum<["choice", "choices", "text"]>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }, {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }>, "many">>;
+            /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+            other: z.ZodOptional<z.ZodBoolean>;
+            /** What is typed shouldn't be shown (a token). */
+            secret: z.ZodOptional<z.ZodBoolean>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }, {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options: {
             optionId: string;
@@ -333,6 +553,20 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     }, {
         options: {
             optionId: string;
@@ -343,6 +577,20 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     }>>;
     /**
      * Live only: messages waiting for the current turn to end, when the host
@@ -355,13 +603,29 @@ export declare const sessionSummarySchema: z.ZodObject<{
         images: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }, {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }>, "many">>;
+    /**
+     * The session works in a git worktree LinkShell made for it: its own
+     * checkout and branch, so it can't disturb the project's working directory.
+     * `cwd` is inside the worktree; `source` is the directory it was made from
+     * (the project the session belongs to).
+     */
+    worktree: z.ZodOptional<z.ZodObject<{
+        branch: z.ZodString;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        branch: string;
+        source: string;
+    }, {
+        branch: string;
+        source: string;
+    }>>;
     /** Live only, for sessions that started sub-agents: how many, and how many are working now (`sessions.subagents` lists them). */
     subagents: z.ZodOptional<z.ZodObject<{
         total: z.ZodNumber;
@@ -403,12 +667,30 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     } | undefined;
     queue?: {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }[] | undefined;
+    worktree?: {
+        branch: string;
+        source: string;
+    } | undefined;
     subagents?: {
         running: number;
         total: number;
@@ -443,12 +725,30 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     } | undefined;
     queue?: {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }[] | undefined;
+    worktree?: {
+        branch: string;
+        source: string;
+    } | undefined;
     subagents?: {
         running: number;
         total: number;
@@ -460,21 +760,79 @@ export declare function parseSessionId(id: string): {
     agent: string;
     nativeId: string;
 } | null;
+/** What git says about a directory, to offer starting a session in a worktree of it. */
+export declare const gitInfoSchema: z.ZodObject<{
+    /** The repository's top directory. */
+    root: z.ZodString;
+    /** The branch checked out; absent on a detached HEAD. */
+    branch: z.ZodOptional<z.ZodString>;
+    /** The commit checked out, abbreviated; absent before the first commit. */
+    head: z.ZodOptional<z.ZodString>;
+    /** Uncommitted changes in the working directory (a new worktree starts from the last commit, without them). */
+    dirty: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    dirty: boolean;
+    root: string;
+    branch?: string | undefined;
+    head?: string | undefined;
+}, {
+    dirty: boolean;
+    root: string;
+    branch?: string | undefined;
+    head?: string | undefined;
+}>;
+export type GitInfo = z.infer<typeof gitInfoSchema>;
+/** A worktree LinkShell made for sessions. */
+export declare const worktreeEntrySchema: z.ZodObject<{
+    /** The worktree's top directory. */
+    path: z.ZodString;
+    branch: z.ZodString;
+    /** The repository it belongs to. */
+    source: z.ZodString;
+    createdAt: z.ZodNumber;
+    /** Sessions working in it. */
+    sessions: z.ZodArray<z.ZodString, "many">;
+    /** Uncommitted changes in it. */
+    dirty: z.ZodBoolean;
+    /** Commits made in it since it was created. */
+    ahead: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    dirty: boolean;
+    path: string;
+    createdAt: number;
+    branch: string;
+    source: string;
+    sessions: string[];
+    ahead: number;
+}, {
+    dirty: boolean;
+    path: string;
+    createdAt: number;
+    branch: string;
+    source: string;
+    sessions: string[];
+    ahead: number;
+}>;
+export type WorktreeEntry = z.infer<typeof worktreeEntrySchema>;
 export declare const projectSummarySchema: z.ZodObject<{
     cwd: z.ZodString;
     name: z.ZodString;
     lastActiveAt: z.ZodNumber;
     sessionCount: z.ZodNumber;
+    /** For a git repository: the branch checked out there now (or the abbreviated commit, on a detached HEAD). */
+    branch: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     cwd: string;
     lastActiveAt: number;
     sessionCount: number;
+    branch?: string | undefined;
 }, {
     name: string;
     cwd: string;
     lastActiveAt: number;
     sessionCount: number;
+    branch?: string | undefined;
 }>;
 export type ProjectSummary = z.infer<typeof projectSummarySchema>;
 export declare const machineInfoSchema: z.ZodObject<{
@@ -513,6 +871,12 @@ export declare const machineInfoSchema: z.ZodObject<{
             steer: z.ZodBoolean;
             permissions: z.ZodBoolean;
             images: z.ZodBoolean;
+            /**
+             * The agent forks sessions itself, keeping everything it knew. Every agent's
+             * sessions can be forked: without this (or from a single reply, where the
+             * agent only forks whole sessions) LinkShell makes the fork — the new session
+             * shows the conversation and its agent is told it as text.
+             */
             fork: z.ZodBoolean;
             models: z.ZodBoolean;
             modes: z.ZodBoolean;
@@ -576,6 +940,17 @@ export declare const machineInfoSchema: z.ZodObject<{
             hint?: string | undefined;
         } | undefined;
     }>, "many">;
+    /**
+     * The host can send bulk streams peer to peer (`direct.offer`); `iceServers`
+     * are the STUN servers both sides use to find a path.
+     */
+    direct: z.ZodOptional<z.ZodObject<{
+        iceServers: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        iceServers: string[];
+    }, {
+        iceServers: string[];
+    }>>;
 }, "strip", z.ZodTypeAny, {
     machineId: string;
     hostname: string;
@@ -604,6 +979,9 @@ export declare const machineInfoSchema: z.ZodObject<{
         } | undefined;
     }[];
     home?: string | undefined;
+    direct?: {
+        iceServers: string[];
+    } | undefined;
 }, {
     machineId: string;
     hostname: string;
@@ -632,6 +1010,9 @@ export declare const machineInfoSchema: z.ZodObject<{
         } | undefined;
     }[];
     home?: string | undefined;
+    direct?: {
+        iceServers: string[];
+    } | undefined;
 }>;
 export type MachineInfo = z.infer<typeof machineInfoSchema>;
 /** A server listening on the host, which a device can preview through the encrypted channel. */

package/dist/wire/src/model.js

@@ -16,6 +16,12 @@ export const agentCapabilitiesSchema = z.object({
     steer: z.boolean(),
     permissions: z.boolean(),
     images: z.boolean(),
+    /**
+     * The agent forks sessions itself, keeping everything it knew. Every agent's
+     * sessions can be forked: without this (or from a single reply, where the
+     * agent only forks whole sessions) LinkShell makes the fork — the new session
+     * shows the conversation and its agent is told it as text.
+     */
     fork: z.boolean(),
     models: z.boolean(),
     modes: z.boolean(),
@@ -72,12 +78,40 @@ export const sessionActivitySchema = z.object({
     toolKind: toolKindSchema.optional(),
 });
 /** The oldest unanswered permission request, so lists can offer approval inline. Live only. */
+/**
+ * Something the agent asks the user rather than asks permission for: a choice
+ * among options, several of them, or something to type (Claude's
+ * AskUserQuestion, Codex's request_user_input, an MCP server's form).
+ */
+export const questionSchema = z.object({
+    id: z.string(),
+    /** A short label for the question ("Auth method"). */
+    header: z.string().optional(),
+    text: z.string(),
+    /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+    kind: z.enum(["choice", "choices", "text"]),
+    options: z.array(z.object({ value: z.string(), label: z.string(), description: z.string().optional() })).optional(),
+    /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+    other: z.boolean().optional(),
+    /** What is typed shouldn't be shown (a token). */
+    secret: z.boolean().optional(),
+    required: z.boolean().optional(),
+});
+export const questionAnswerSchema = z.object({
+    id: z.string(),
+    /** The values picked (`choice`: at most one), or what was typed for a `text` question. */
+    values: z.array(z.string().max(20_000)).max(50),
+    /** The user's own answer beside the options. */
+    other: z.string().max(20_000).optional(),
+});
 export const pendingPermissionSchema = z.object({
     requestId: z.string(),
     toolCallId: z.string().optional(),
     title: z.string(),
     detail: z.string().optional(),
     options: z.array(permissionOptionSchema).min(1),
+    /** Set when this is a question to answer (`sessions.answer`) rather than a permission to give. */
+    questions: z.array(questionSchema).optional(),
 });
 export const queuedMessageSchema = z.object({
     clientMessageId: z.string(),
@@ -120,6 +154,13 @@ export const sessionSummarySchema = z.object({
      * holds them (agents that can't take input mid-turn). Oldest first.
      */
     queue: z.array(queuedMessageSchema).optional(),
+    /**
+     * The session works in a git worktree LinkShell made for it: its own
+     * checkout and branch, so it can't disturb the project's working directory.
+     * `cwd` is inside the worktree; `source` is the directory it was made from
+     * (the project the session belongs to).
+     */
+    worktree: z.object({ branch: z.string(), source: z.string() }).optional(),
     /** Live only, for sessions that started sub-agents: how many, and how many are working now (`sessions.subagents` lists them). */
     subagents: z.object({ total: z.number().int(), running: z.number().int() }).optional(),
 });
@@ -132,11 +173,39 @@ export function parseSessionId(id) {
         return null;
     return { agent: id.slice(0, index), nativeId: id.slice(index + 1) };
 }
+/** What git says about a directory, to offer starting a session in a worktree of it. */
+export const gitInfoSchema = z.object({
+    /** The repository's top directory. */
+    root: z.string(),
+    /** The branch checked out; absent on a detached HEAD. */
+    branch: z.string().optional(),
+    /** The commit checked out, abbreviated; absent before the first commit. */
+    head: z.string().optional(),
+    /** Uncommitted changes in the working directory (a new worktree starts from the last commit, without them). */
+    dirty: z.boolean(),
+});
+/** A worktree LinkShell made for sessions. */
+export const worktreeEntrySchema = z.object({
+    /** The worktree's top directory. */
+    path: z.string(),
+    branch: z.string(),
+    /** The repository it belongs to. */
+    source: z.string(),
+    createdAt: z.number(),
+    /** Sessions working in it. */
+    sessions: z.array(z.string()),
+    /** Uncommitted changes in it. */
+    dirty: z.boolean(),
+    /** Commits made in it since it was created. */
+    ahead: z.number().int().nonnegative(),
+});
 export const projectSummarySchema = z.object({
     cwd: z.string(),
     name: z.string(),
     lastActiveAt: z.number(),
     sessionCount: z.number().int().nonnegative(),
+    /** For a git repository: the branch checked out there now (or the abbreviated commit, on a detached HEAD). */
+    branch: z.string().optional(),
 });
 export const machineInfoSchema = z.object({
     machineId: z.string().min(1),
@@ -146,6 +215,11 @@ export const machineInfoSchema = z.object({
     /** The host user's home directory, so apps can show paths as `~/…`. */
     home: z.string().optional(),
     agents: z.array(agentInfoSchema),
+    /**
+     * The host can send bulk streams peer to peer (`direct.offer`); `iceServers`
+     * are the STUN servers both sides use to find a path.
+     */
+    direct: z.object({ iceServers: z.array(z.string()) }).optional(),
 });
 /** A server listening on the host, which a device can preview through the encrypted channel. */
 export const portInfoSchema = z.object({