zidane 9.1.1 → 9.1.4

package/dist/ipc/browser-types.d.ts

@@ -1711,6 +1711,19 @@ interface ContextMount {
 }
 /** Kind of execution context: `process`, `docker` or `sandbox`. */
 type ContextType = 'process' | 'docker' | 'sandbox';
+/** Options of {@link ExecutionContext.exec}. */
+interface ExecOptions {
+  /** Folder to run in, resolved against the handle's. Default: the handle's folder. */
+  cwd?: string;
+  /** Variables added to the command's environment. */
+  env?: Record<string, string>;
+  /** Seconds. Default 30. */
+  timeout?: number;
+  /** Kills the command (its whole process group, in the process context) when aborted. */
+  signal?: AbortSignal;
+  /** Output as it arrives, decoded per stream. A chunk can end mid-line. */
+  onOutput?: (stream: 'stdout' | 'stderr', text: string) => void;
+}
 /** An environment where an agent runs commands and reads and writes files: the host process, a Docker container or a remote sandbox. */
 interface ExecutionContext {
   /** Context type identifier */
@@ -1740,13 +1753,12 @@ interface ExecutionContext {
    * with coreutils `timeout`, sandbox SDKs take seconds/ms per their API).
    * Documented here because the unit is invisible at call sites and a
    * caller assuming milliseconds would set an instant-kill timeout.
+   *
+   * `onOutput` hears the output as it arrives, decoded, before the result
+   * settles (a UI showing a running command). Optional for implementations:
+   * one that cannot stream calls it never, and the result is the same.
    */
-  exec: (handle: ExecutionHandle, command: string, options?: {
-    cwd?: string;
-    env?: Record<string, string>;
-    timeout?: number;
-    signal?: AbortSignal;
-  }) => Promise<ExecResult>;
+  exec: (handle: ExecutionHandle, command: string, options?: ExecOptions) => Promise<ExecResult>;
   /**
    * Start a process in the background. Settles as soon as `spawn` returns
    * — does NOT wait for the child to exit. Stdout + stderr stream
@@ -3465,6 +3477,15 @@ interface AgentHooks {
     reason: string;
     runToolCounts: Readonly<Record<string, number>>;
   }) => void;
+  /**
+   * Live output of a running tool (`ToolContext.reportProgress`): a codemode
+   * script's printed items, a command's output chunks. Fires between
+   * `tool:before` and the call's terminal event, never on replay of a
+   * recorded call. Nothing here reaches the model or the session.
+   */
+  'tool:progress': (ctx: ToolHookContext & {
+    progress: ToolProgress;
+  }) => void;
   /**
    * Fires when `validateToolArgs` rejects an input that could not be auto-coerced
    * to satisfy the tool's `inputSchema`. Observational — the tool call still
@@ -3748,6 +3769,12 @@ interface AgentHooks {
     childId: string;
     depth: number;
   }) => void;
+  /** Bubbled `tool:progress` from a subagent, with `childId` and `depth`. */
+  'child:tool:progress': (ctx: ToolHookContext & {
+    progress: ToolProgress;
+    childId: string;
+    depth: number;
+  }) => void;
   /** Bubbled from a subagent's `background:start`. Same payload + `childId` / `depth`. */
   'child:background:start': (ctx: {
     taskId: string;
@@ -5638,6 +5665,96 @@ interface SessionScope {
   sessionIds?: readonly string[];
 }
 //#endregion
+//#region src/chat/ansi.d.ts
+/**
+ * Terminal output as styled lines: ANSI SGR codes (colors, bold, dim, italic,
+ * underline, inverse) become styles on spans of text; every other escape
+ * (cursor moves, titles, charsets) is dropped; a carriage return rewrites its
+ * line as a terminal does (a progress bar keeps its last state), backspace
+ * erases. One incremental parser ({@link createAnsiLines}) serves the whole
+ * text ({@link parseAnsi}) and plain text ({@link stripAnsi}). A line cut
+ * out of a stream keeps its spans, so it renders with the colors it had.
+ *
+ * Node-free (exported from `zidane/chat/pure`).
+ */
+/** A color: one of the 256 palette entries (0 to 15 are the theme's), or `#rrggbb`. */
+type AnsiColor = number | `#${string}`;
+/** How a span of text is drawn. Absent fields are the default. */
+interface AnsiStyle {
+  /** Text color. */
+  fg?: AnsiColor;
+  /** Background color. */
+  bg?: AnsiColor;
+  /** Bold (SGR 1). */
+  bold?: true;
+  /** Faint (SGR 2). */
+  dim?: true;
+  /** Italic (SGR 3). */
+  italic?: true;
+  /** Underlined (SGR 4). */
+  underline?: true;
+  /** Foreground and background swapped. */
+  inverse?: true;
+}
+/** Text in one style. `style` is absent for plain text. */
+interface AnsiSpan {
+  /** The text, without escapes. */
+  text: string;
+  /** Its style, absent for plain text. */
+  style?: AnsiStyle;
+}
+//#endregion
+//#region src/chat/output-tail.d.ts
+/** Where an output line came from: a printed item (`output`, `console`) or a command's `stdout` / `stderr`. */
+type OutputStream = 'output' | 'console' | 'stdout' | 'stderr';
+/** One line of output. */
+interface OutputLine {
+  /**
+   * The line's number in the whole output, from 0: the same while the line
+   * shows (a command's line keeps its id as it is written, then ended), so a
+   * view can key on it and animate only what is new.
+   */
+  id: number;
+  /** Where it came from. */
+  stream: OutputStream;
+  /** The line's visible text, without its newline, cut to the tail's width. */
+  text: string;
+  /** The same text in styled spans, when it had colors or styles (ANSI codes). */
+  spans?: AnsiSpan[];
+  /** Script line of the call that wrote it (codemode). */
+  line?: number;
+}
+//#endregion
+//#region src/chat/script-progress.d.ts
+/** How the latest call of a script line stands. */
+type ScriptCallStatus = 'running' | 'ok' | 'error';
+/** A script line that made calls. */
+interface ScriptLineProgress {
+  /** 1-based line in the script as the model wrote it. */
+  line: number;
+  /** State of the latest call made from this line. */
+  status: ScriptCallStatus;
+  /** Calls made from this line so far. */
+  calls: number;
+}
+/** One line of what a script printed or its shell calls wrote. */
+type ScriptOutputLine = OutputLine;
+/** A script's progress as a `tool-progress` event carries it. */
+interface ScriptProgress {
+  /** Lines that made calls, by line. */
+  lines: ScriptLineProgress[];
+  /** Calls that ended, failed ones included. */
+  done: number;
+  /** Calls still running. */
+  running: number;
+  /** Calls that failed. */
+  failed: number;
+  /** The last lines of output, oldest first. A command's line still being written comes last. */
+  output: ScriptOutputLine[];
+  /** How the script ended, once it did: its last line shows done when it ended without error. */
+  ended?: 'ok' | 'error';
+}
+//#endregion
 //#region src/chat/context-breakdown.d.ts
 /**
  * Stable identifiers for each breakdown category. Drives swatch color +
@@ -7198,6 +7315,8 @@ interface WireSettingsExtension {
     gui?: string;
     tui?: string;
   };
+  /** What it does (`ExtensionDefinition.description`): the line under its name atop its settings. */
+  description?: string;
 }
 //#endregion
 //#region src/extensions/settings/domain.d.ts
@@ -8005,6 +8124,14 @@ interface StreamEvent {
    * the call as waiting until its worker starts, and draw no row of its own.
    */
   'spawn-queued' |
+  /**
+   * A codemode script's progress (`scriptProgress`), for its call
+   * (`callId`), with `Settings.codemodeStreamProgress`. Each one replaces
+   * the last for the same call (`upsertToolProgress`). Live, and rebuilt
+   * from the saved call records on reload. Renderers show it on the
+   * script's row and draw no row of its own.
+   */
+  'tool-progress' |
   /**
    * Compaction boundary — produced by `eventsFromTurns` when a turn
    * carries a `compact-summary` block. Marks the point at which the
@@ -8278,6 +8405,8 @@ interface StreamEvent {
     active: number;
     max: number;
   };
+  /** On `tool-progress`: the script's progress. */
+  scriptProgress?: ScriptProgress;
   /**
    * `tool-result` only: the call failed (the wire error bit of its result).
    * Absent on success. Lets a renderer mark the call failed from its one
@@ -8977,6 +9106,14 @@ interface Settings {
    * that run a subagent show either way, since their worker attaches there.
    */
   codemodeShowCalls: boolean;
+  /**
+   * Show each codemode script's progress while it runs: the line each call
+   * came from (running, done, failed), a count of its calls, and the last
+   * lines it printed or its shell calls wrote. Sets
+   * `behavior.codemode.streamProgress`; toggling it rebuilds live agents.
+   * The model's result does not change. Off by default.
+   */
+  codemodeStreamProgress: boolean;
   /**
    * Run the model's `shell` tool commands under the OS sandbox: macOS
    * Seatbelt (`sandbox-exec`) or Linux bubblewrap (`bwrap`). Writes are
@@ -10373,6 +10510,14 @@ interface ToolContext {
    * (`ctx.reportStructured?.(…)`).
    */
   reportStructured?: (value: unknown) => void;
+  /**
+   * Report live output of this call (a command's output chunks, a script's
+   * printed items) as the `tool:progress` hook, for a UI to show while the
+   * call runs. It never reaches the model or the session. Present only when
+   * someone shows it: on a tool that calls others (codemode), and on a nested
+   * call whose caller asked for it (`NestedToolCallOptions.streamProgress`).
+   */
+  reportProgress?: (progress: ToolProgress) => void;
   /**
    * Call another tool of this run from inside this tool, through the same
    * gate / validation / hooks pipeline as a model-issued call (see
@@ -10406,6 +10551,13 @@ interface ToolContext {
 interface NestedToolCallOptions {
   /** Aborts the nested call, in addition to the calling tool's own signal. */
   signal?: AbortSignal;
+  /**
+   * Line of the calling script that makes this call. Lands on the call's
+   * hooks (`scriptLine`) and its record (`NestedToolCallRecord.line`).
+   */
+  line?: number;
+  /** Give the call a `ToolContext.reportProgress`, so its live output fires `tool:progress`. */
+  streamProgress?: boolean;
 }
 /** Result of a nested call made through {@link ToolContext.callTool}. */
 interface NestedToolCallResult {
@@ -12404,6 +12556,11 @@ interface AgentBehavior {
    *   form (at most twice per tool in a conversation; never on `read_file` or
    *   JSON results). `false` leaves results as the tools return them.
    *   Default: `true`.
+   * - `streamProgress`: report each script's progress live (`tool:progress`):
+   *   what it prints, the output of its shell calls as they run, and the
+   *   script line of each call (`scriptLine` on the nested calls' hooks,
+   *   `line` on their records). The model's result does not change.
+   *   Default: `false`.
    *
    * Not injected when `AgentRunOptions.tools` replaces the registry, or when
    * the host registers its own `codemode`. Default: off.
@@ -12413,6 +12570,7 @@ interface AgentBehavior {
     inlineBudget?: number;
     catalog?: 'names' | 'full';
     directCallNotes?: boolean;
+    streamProgress?: boolean;
   };
   /**
    * Render the per-server `instructions` payload from the MCP `initialize`
@@ -12903,6 +13061,20 @@ type ToolResultContent = ToolResultTextContent | ToolResultImageContent | ToolRe
  *               wire result; reported explicitly so guards don't have to infer.
  */
 type ToolOutcome = 'created' | 'updated' | 'edited' | 'noop' | 'failed';
+/**
+ * Live output a running tool reports through `ToolContext.reportProgress`, as
+ * the `tool:progress` hook. It never reaches the model or the session: the
+ * tool's result is unchanged.
+ */
+interface ToolProgress {
+  /**
+   * `output` and `console`: an item a codemode script printed (`text()`,
+   * `console.*`). `stdout` and `stderr`: a chunk of a running command.
+   */
+  stream: 'output' | 'console' | 'stdout' | 'stderr';
+  /** The new text. A chunk of a command can end mid-line. */
+  text: string;
+}
 /** JSON scalar: a string, number, boolean or `null`. */
 type JsonPrimitive = string | number | boolean | null;
 /** Any value that survives `JSON.stringify` and `JSON.parse` unchanged. */
@@ -13787,6 +13959,8 @@ interface NestedToolCallRecord {
   outputTruncated?: boolean;
   /** The called tool runs a subagent (`DurableToolDef.runsNestedAgent`): its worker attaches to this call. */
   runsNestedAgent?: true;
+  /** Line of the calling script that made the call, when the caller tracked lines (`NestedToolCallOptions.line`). */
+  line?: number;
 }
 /**
  * Base context for tool execution hooks: the tool call a `tool:*` hook fires
@@ -13859,6 +14033,11 @@ interface ToolHookContext {
    * them should skip these.
    */
   parentToolCallId?: string;
+  /**
+   * On a nested call: the line of the calling script that made it
+   * (`NestedToolCallOptions.line`). Absent when the caller tracks no lines.
+   */
+  scriptLine?: number;
   /** Set when the called tool runs a subagent (`DurableToolDef.runsNestedAgent`, e.g. `spawn`). */
   runsNestedAgent?: true;
   /**
@@ -15795,6 +15974,36 @@ interface RunEstimateView {
   waitingSince?: number;
 }
 //#endregion
+//#region src/chat/shell-blocks.d.ts
+/** What a window asks the host to run. */
+interface BlockRunRequest {
+  /** The reply the block is in. */
+  turnId: string;
+  /** The block's text. */
+  code: string;
+  /** The fence's language. */
+  language: string;
+}
+/** The last run of a block, as the session keeps it. */
+interface BlockRun {
+  /** {@link blockRunKey} of the block. */
+  key: string;
+  /** The reply the block is in: a run whose reply is gone is dropped. */
+  turnId: string;
+  /** What it wrote, stdout and stderr in arrival order, raw (ANSI codes kept): the last {@link BLOCK_RUN_OUTPUT_CAP} characters. */
+  output: string;
+  /** Output was cut at its start. */
+  truncated?: true;
+  /** `null` when it was stopped or could not start. */
+  exitCode: number | null;
+  /** Why it ended early. */
+  stopped?: 'cancelled' | 'timeout';
+  /** How long it ran. */
+  durationMs: number;
+  /** When it ended, epoch milliseconds. */
+  finishedAt: number;
+}
+//#endregion
 //#region src/chat/terminal/protocol.d.ts
 /**
  * Terminals: the contract between the host that runs them (the daemon) and
@@ -16860,6 +17069,20 @@ type HostSignal = {
   truncated?: true;
   cancelled?: true;
 } |
+/** A chunk of a Run here's output (`sessions.runBlock`), to the connection that started it only. */
+{
+  kind: 'block-run:data';
+  runId: string;
+  stream: 'stdout' | 'stderr';
+  chunk: string;
+} |
+/** A Run here ended: the saved run, or why it could not run. To the connection that started it only. */
+{
+  kind: 'block-run:end';
+  runId: string;
+  run?: BlockRun;
+  error?: string;
+} |
 /** Git's progress on the connection's `git.clone`, to that connection only. */
 {
   kind: 'git:clone:progress';
@@ -16929,6 +17152,11 @@ type HostSignal = {
   op: 'create' | 'update' | 'delete';
   sessionId: string;
 } |
+/** A session's saved block runs changed (a Run here ended, a run was removed): windows read them again. */
+{
+  kind: 'block-runs:changed';
+  sessionId: string;
+} |
 /**
  * A session's facet values changed (`ctx.sessions.facets`): every facet
  * it holds now, keyed `<extensionId>.<key>`, the same as `SessionRow.facets`.
@@ -18499,6 +18727,49 @@ interface IpcMethods {
       cancelled: boolean;
     };
   };
+  /**
+   * Runs a shell block of a reply (Run here) in the session's folder, with no input. The reply names the run; its
+   * output follows as `block-run:data` signals and ends with one `block-run:end` carrying the saved run, to this
+   * connection only. Nothing enters the conversation; the run becomes the block's last (`sessions.blockRuns`),
+   * announced to every window by `block-runs:changed`. A dropped connection stops what it started.
+   */
+  'sessions.runBlock': {
+    params: {
+      sessionId: string;
+      turnId: string;
+      code: string;
+      language: string;
+    };
+    result: {
+      runId: string;
+    };
+  };
+  /** Stops a Run here this connection started (`cancelled: false` when it is not running). */
+  'sessions.runBlockCancel': {
+    params: {
+      runId: string;
+    };
+    result: {
+      cancelled: boolean;
+    };
+  };
+  /** The session's saved block runs, by key (`blockRunKey`). */
+  'sessions.blockRuns': {
+    params: {
+      sessionId: string;
+    };
+    result: {
+      runs: Record<string, BlockRun>;
+    };
+  };
+  /** Forgets a block's saved run. */
+  'sessions.removeBlockRun': {
+    params: {
+      sessionId: string;
+      key: string;
+    };
+    result: void;
+  };
   /** Reads a text file from the session's workspace. */
   'sessions.workspaceReadFile': {
     params: {
@@ -21970,6 +22241,32 @@ interface ClaudeImportSelection {
   allProjects: boolean;
 }
 //#endregion
+//#region src/ipc/block-run.d.ts
+/** What {@link runBlockOnHost} needs of a client: a call (a server client's `call`, an IPC client's `request`) and its signals. */
+interface BlockRunClient {
+  /** Calls a method on the host. */
+  call: <M extends 'sessions.runBlock' | 'sessions.runBlockCancel'>(method: M, params: IpcParams<M>) => Promise<IpcResult<M>>;
+  /** Hears the host's signals; returns the unsubscribe. */
+  onSignal: (listener: (signal: HostSignal) => void) => () => void;
+}
+/** Options for {@link runBlockOnHost}. */
+interface BlockRunOnHostOptions {
+  /** Output as it arrives. */
+  onOutput?: (stream: 'stdout' | 'stderr', text: string) => void;
+  /** Stops the run on the host. */
+  signal?: AbortSignal;
+}
+/**
+ * Runs a reply's shell block on a host and resolves with the saved run. Rejects with the host's reason when the
+ * block could not run.
+ *
+ * @param client - The host's client.
+ * @param sessionId - The session the reply is in.
+ * @param request - The block.
+ * @param options - Output listener and stop signal.
+ */
+declare function runBlockOnHost(client: BlockRunClient, sessionId: string, request: BlockRunRequest, options?: BlockRunOnHostOptions): Promise<BlockRun>;
+//#endregion
 //#region src/ipc/browser-pair.d.ts
 /** Where a browser trades a pairing code for a device token (`POST`, JSON), relative to the server's origin. */
 declare const SERVER_PAIR_PATH = "/zidane/pair";
@@ -22382,5 +22679,5 @@ interface ServerClient {
  */
 declare function createServerClient(options: ServerClientOptions): ServerClient;
 //#endregion
-export { CLIENT_SCOPES, type ClientScope, type ExtensionInstallErrorData, type ExtensionsClient, type ExtensionsTransport, type ExtensionsUiServer, type HelloResult, type HostSignal, IPC_MIN_PROTOCOL_VERSION, IPC_PROTOCOL_VERSION, IpcErrorCode, type IpcMethodName, type IpcMethods, type IpcParams, type IpcResult, METHOD_SCOPES, type PairBrowserOptions, type PairedBrowser, SERVER_AUTH_CHECK_PATH, SERVER_AUTH_PATH, SERVER_EXTENSIONS_UI_PATH, SERVER_EXTENSIONS_WEBVIEW_PATH, SERVER_MEDIA_PATH, SERVER_OAUTH_CALLBACK_PATH, SERVER_PAIR_PATH, ServerCallError, ServerClient, ServerClientOptions, ServerClientState, ServerConnectionError, ServerPairError, type ServerPairFailure, ServerRefusal, type SignalMeta, createExtensionsClient, createServerClient, extensionInstallErrorData, formatJoinString, methodScope, pairBrowser, parseJoinString, scopeAllows };
+export { type BlockRunClient, type BlockRunOnHostOptions, CLIENT_SCOPES, type ClientScope, type ExtensionInstallErrorData, type ExtensionsClient, type ExtensionsTransport, type ExtensionsUiServer, type HelloResult, type HostSignal, IPC_MIN_PROTOCOL_VERSION, IPC_PROTOCOL_VERSION, IpcErrorCode, type IpcMethodName, type IpcMethods, type IpcParams, type IpcResult, METHOD_SCOPES, type PairBrowserOptions, type PairedBrowser, SERVER_AUTH_CHECK_PATH, SERVER_AUTH_PATH, SERVER_EXTENSIONS_UI_PATH, SERVER_EXTENSIONS_WEBVIEW_PATH, SERVER_MEDIA_PATH, SERVER_OAUTH_CALLBACK_PATH, SERVER_PAIR_PATH, ServerCallError, ServerClient, ServerClientOptions, ServerClientState, ServerConnectionError, ServerPairError, type ServerPairFailure, ServerRefusal, type SignalMeta, createExtensionsClient, createServerClient, extensionInstallErrorData, formatJoinString, methodScope, pairBrowser, parseJoinString, runBlockOnHost, scopeAllows };
 //# sourceMappingURL=browser-types.d.ts.map