@av-pi-studio/server 0.0.93 → 0.0.94

package/dist/agent/providers/mock/mock-provider.d.ts

@@ -1,5 +1,5 @@
-import type { AgentCapabilityFlags, AgentSessionConfig } from "@av-pi-studio/protocol";
-import type { AgentClient, AgentModeDefinition, AgentModelDefinition, AgentSession, CreateSessionOptions, LaunchContext, PersistenceHandle } from "../../provider-contract.js";
+import type { AgentCapabilityFlags, AgentSessionConfig, AgentStreamEvent } from "@av-pi-studio/protocol";
+import type { AgentClient, AgentCommandDefinition, AgentModeDefinition, AgentModelDefinition, AgentSession, CreateSessionOptions, LaunchContext, PendingPermission, PersistenceHandle, ProviderRuntimeInfo, ProviderUiRequest, ProviderUiResponse, Unsubscribe } from "../../provider-contract.js";
 /**
  * In-process `mock` provider (features/agent-providers.md § Provider entry — dev/test only). It
  * implements the `AgentClient`/`AgentSession` contracts in memory and emits a scripted turn. Never
@@ -10,6 +10,124 @@ export interface MockSessionOptions {
     /** Delay before a started turn completes (ms). Small but non-zero so `interrupt` can win. */
     turnDelayMs?: number;
 }
+/** Exported so tests (this file's, and downstream sprint-066 task-003/004 daemon-level tests) can
+ *  cast a created session to reach `emitUiRequest`/`uiResponses`, which are deliberately not part
+ *  of the provider-neutral `AgentSession` contract. */
+export declare class MockAgentSession implements AgentSession {
+    private readonly config;
+    readonly provider = "mock";
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly capabilities: import("zod").objectOutputType<{
+        supportsStreaming: import("zod").ZodBoolean;
+        supportsSessionPersistence: import("zod").ZodBoolean;
+        supportsDynamicModes: import("zod").ZodBoolean;
+        supportsMcpServers: import("zod").ZodBoolean;
+        supportsReasoningStream: import("zod").ZodBoolean;
+        supportsToolInvocations: import("zod").ZodBoolean;
+        supportsRewindConversation: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        supportsRewindFiles: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        supportsRewindBoth: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        supportsSteering: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        supportsExtensionUi: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod").ZodTypeAny, "passthrough">;
+    private readonly subscribers;
+    private readonly history;
+    private readonly turnDelayMs;
+    private activeTurn;
+    private completionTimer;
+    private mode;
+    private closed;
+    private readonly uiSubscribers;
+    readonly uiResponses: {
+        providerRequestId: string;
+        response: ProviderUiResponse;
+    }[];
+    private readonly pendingScriptedResponses;
+    constructor(config: AgentSessionConfig, options?: MockSessionOptions);
+    private emit;
+    subscribe(cb: (event: AgentStreamEvent) => void): Unsubscribe;
+    streamHistory(): AsyncGenerator<AgentStreamEvent>;
+    startTurn(prompt: string): Promise<{
+        turnId: string;
+    }>;
+    /** `#ui ...` prompt (task-001): raise the scripted dialog(s) through the same `uiSubscribers`
+     *  channel `emitUiRequest` uses, instead of the normal echoed turn. Resolves immediately with the
+     *  turn id, exactly like the normal path — the dialog(s) and the eventual echo/`turn_completed`
+     *  happen asynchronously as `runUiScript` progresses. */
+    private startUiScriptTurn;
+    private runUiScript;
+    /** Raises one scripted step. A dialog (`expectsResponse: true`) returns a promise that resolves
+     *  once `respondToUi` is called for its (mock-minted) `requestId`. A transient
+     *  (`expectsResponse: false`, e.g. `notify`) resolves immediately with `null` — it is never
+     *  answered, so waiting on `pendingScriptedResponses` for one would hang `runUiScript`'s
+     *  `Promise.all` forever. Deliberately separate from the public `emitUiRequest` — that method
+     *  fills defaults for ad-hoc test use and tracks nothing. */
+    private raiseScriptedDialog;
+    /** Convenience: start a turn and resolve when it reaches a terminal event. */
+    run(prompt: string): Promise<void>;
+    interrupt(): Promise<void>;
+    private readonly steeringQueue;
+    private readonly followUpQueue;
+    steer(message: string): Promise<void>;
+    followUp(message: string): Promise<void>;
+    getRuntimeInfo(): ProviderRuntimeInfo;
+    getAvailableModes(): AgentModeDefinition[];
+    getCurrentMode(): string | null;
+    setMode(id: string): Promise<void>;
+    getPendingPermissions(): PendingPermission[];
+    respondToPermission(): Promise<void>;
+    onUiRequest(cb: (req: ProviderUiRequest) => void): Unsubscribe;
+    respondToUi(providerRequestId: string, response: ProviderUiResponse): void;
+    /** Test-only: push a scripted UI request to every subscriber, with sensible defaults for any
+     *  field the caller omits. Returns the request actually emitted (its `requestId` in particular),
+     *  so a test can answer it via `respondToUi` or assert against it directly. */
+    emitUiRequest(partial?: Partial<ProviderUiRequest>): ProviderUiRequest;
+    describePersistence(): PersistenceHandle | null;
+    private sessionName;
+    getSessionStats(): Promise<{
+        sessionId: string;
+        totalMessages: number;
+        tokens: {
+            total: number;
+        };
+    }>;
+    compact(): Promise<{
+        summary: string;
+        firstKeptEntryId: string;
+        tokensBefore: number;
+    }>;
+    newSession(): Promise<{
+        cancelled: boolean;
+    }>;
+    switchSession(): Promise<{
+        cancelled: boolean;
+    }>;
+    fork(entryId: string): Promise<{
+        text: string;
+        cancelled: boolean;
+    }>;
+    getForkMessages(): Promise<{
+        entryId: string;
+        text: string;
+    }[]>;
+    clone(): Promise<{
+        cancelled: boolean;
+    }>;
+    setSessionName(name: string): Promise<void>;
+    cycleModel(): Promise<{
+        model: {
+            id: string;
+        };
+        thinkingLevel: string;
+    }>;
+    getLastAssistantText(): Promise<string | null>;
+    /** Command discovery (sprint-040): a deterministic, dependency-free multi-source list — one
+     * each of extension/prompt/skill — covering `agent_list_commands_request` without needing a
+     * real `pi` binary. */
+    listCommands(): Promise<AgentCommandDefinition[]>;
+    close(): Promise<void>;
+    isClosed(): boolean;
+}
 export declare class MockAgentClient implements AgentClient {
     private readonly options;
     readonly provider = "mock";
@@ -24,6 +142,7 @@ export declare class MockAgentClient implements AgentClient {
         supportsRewindFiles: import("zod").ZodOptional<import("zod").ZodBoolean>;
         supportsRewindBoth: import("zod").ZodOptional<import("zod").ZodBoolean>;
         supportsSteering: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        supportsExtensionUi: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, import("zod").ZodTypeAny, "passthrough">;
     constructor(options?: MockSessionOptions);
     createSession(config: AgentSessionConfig, _launchContext?: LaunchContext, _options?: CreateSessionOptions): Promise<AgentSession>;

package/dist/agent/providers/mock/mock-provider.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { getUiScriptHelpText, parseUiScript } from "./ui-script.js";
 /**
  * In-process `mock` provider (features/agent-providers.md § Provider entry — dev/test only). It
  * implements the `AgentClient`/`AgentSession` contracts in memory and emits a scripted turn. Never
@@ -12,12 +13,16 @@ export const MOCK_CAPABILITIES = {
     supportsReasoningStream: true,
     supportsToolInvocations: true,
     supportsSteering: true,
+    supportsExtensionUi: true,
 };
 const MOCK_MODES = [
     { id: "default", label: "Default" },
     { id: "plan", label: "Plan" },
 ];
-class MockAgentSession {
+/** Exported so tests (this file's, and downstream sprint-066 task-003/004 daemon-level tests) can
+ *  cast a created session to reach `emitUiRequest`/`uiResponses`, which are deliberately not part
+ *  of the provider-neutral `AgentSession` contract. */
+export class MockAgentSession {
     config;
     provider = "mock";
     id = randomUUID();
@@ -29,6 +34,16 @@ class MockAgentSession {
     completionTimer = null;
     mode = "default";
     closed = false;
+    // Extension UI (features/extension-ui-rpc.md, sprint-066): no `pi` process exists to script this
+    // family, so the mock provider exposes a scripted emitter (`emitUiRequest`) plus a recorder for
+    // `respondToUi` calls, letting tasks 003-004 drive/assert the whole family without a child process.
+    uiSubscribers = new Set();
+    uiResponses = [];
+    // #ui script support (sprint-068/task-001): a scripted dialog raised via `startTurn` is tracked
+    // here so `respondToUi` can resolve the promise `runUiScript` is awaiting, in addition to (not
+    // instead of) its existing `uiResponses` recording used by direct `emitUiRequest`/`respondToUi`
+    // callers.
+    pendingScriptedResponses = new Map();
     constructor(config, options = {}) {
         this.config = config;
         this.turnDelayMs = options.turnDelayMs ?? 5;
@@ -47,6 +62,9 @@ class MockAgentSession {
             yield event;
     }
     startTurn(prompt) {
+        const script = parseUiScript(prompt);
+        if (script !== null)
+            return this.startUiScriptTurn(script);
         const turnId = randomUUID();
         this.activeTurn = turnId;
         this.emit({ kind: "turn_started", turnId });
@@ -65,6 +83,75 @@ class MockAgentSession {
         }, this.turnDelayMs);
         return Promise.resolve({ turnId });
     }
+    /** `#ui ...` prompt (task-001): raise the scripted dialog(s) through the same `uiSubscribers`
+     *  channel `emitUiRequest` uses, instead of the normal echoed turn. Resolves immediately with the
+     *  turn id, exactly like the normal path — the dialog(s) and the eventual echo/`turn_completed`
+     *  happen asynchronously as `runUiScript` progresses. */
+    startUiScriptTurn(steps) {
+        const turnId = randomUUID();
+        this.activeTurn = turnId;
+        this.emit({ kind: "turn_started", turnId });
+        if (steps.length === 0) {
+            // `#ui help` — no dialog, just the recipe list as assistant text.
+            setTimeout(() => {
+                if (this.activeTurn !== turnId)
+                    return;
+                this.emit({
+                    kind: "assistant_message",
+                    messageId: randomUUID(),
+                    text: getUiScriptHelpText(),
+                    final: true,
+                });
+                this.emit({ kind: "turn_completed", turnId });
+                this.activeTurn = null;
+            }, this.turnDelayMs);
+            return Promise.resolve({ turnId });
+        }
+        void this.runUiScript(turnId, steps);
+        return Promise.resolve({ turnId });
+    }
+    async runUiScript(turnId, steps) {
+        const responses = await Promise.all(steps.map((step) => this.raiseScriptedDialog(step)));
+        if (this.activeTurn !== turnId)
+            return; // interrupted while dialogs were pending
+        for (let i = 0; i < steps.length; i++) {
+            const response = responses[i];
+            // `null`: a transient step (e.g. `notify`) — fire-and-forget, never resolved, nothing to
+            // echo. Only a real answered dialog gets an "ui X resolved: …" line.
+            if (response === null || response === undefined)
+                continue;
+            this.emit({
+                kind: "assistant_message",
+                messageId: randomUUID(),
+                text: `ui ${steps[i].method} resolved: ${describeUiResponse(response)}`,
+                final: true,
+            });
+        }
+        this.emit({ kind: "turn_completed", turnId });
+        this.activeTurn = null;
+    }
+    /** Raises one scripted step. A dialog (`expectsResponse: true`) returns a promise that resolves
+     *  once `respondToUi` is called for its (mock-minted) `requestId`. A transient
+     *  (`expectsResponse: false`, e.g. `notify`) resolves immediately with `null` — it is never
+     *  answered, so waiting on `pendingScriptedResponses` for one would hang `runUiScript`'s
+     *  `Promise.all` forever. Deliberately separate from the public `emitUiRequest` — that method
+     *  fills defaults for ad-hoc test use and tracks nothing. */
+    raiseScriptedDialog(step) {
+        const req = {
+            requestId: randomUUID(),
+            method: step.method,
+            expectsResponse: step.expectsResponse,
+            payload: step.payload,
+            ...(step.timeoutMs !== undefined ? { timeoutMs: step.timeoutMs } : {}),
+        };
+        for (const cb of this.uiSubscribers)
+            cb(req);
+        if (!step.expectsResponse)
+            return Promise.resolve(null);
+        const { promise, resolve } = Promise.withResolvers();
+        this.pendingScriptedResponses.set(req.requestId, resolve);
+        return promise;
+    }
     /** Convenience: start a turn and resolve when it reaches a terminal event. */
     run(prompt) {
         return new Promise((resolve) => {
@@ -137,6 +224,35 @@ class MockAgentSession {
     respondToPermission() {
         return Promise.resolve();
     }
+    onUiRequest(cb) {
+        this.uiSubscribers.add(cb);
+        return () => this.uiSubscribers.delete(cb);
+    }
+    respondToUi(providerRequestId, response) {
+        this.uiResponses.push({ providerRequestId, response });
+        const resolve = this.pendingScriptedResponses.get(providerRequestId);
+        if (resolve) {
+            this.pendingScriptedResponses.delete(providerRequestId);
+            resolve(response);
+        }
+    }
+    /** Test-only: push a scripted UI request to every subscriber, with sensible defaults for any
+     *  field the caller omits. Returns the request actually emitted (its `requestId` in particular),
+     *  so a test can answer it via `respondToUi` or assert against it directly. */
+    emitUiRequest(partial = {}) {
+        const req = {
+            requestId: partial.requestId ?? randomUUID(),
+            method: partial.method ?? "confirm",
+            expectsResponse: partial.expectsResponse ?? true,
+            payload: partial.payload ?? {},
+            ...(partial.surfaceKey !== undefined ? { surfaceKey: partial.surfaceKey } : {}),
+            ...(partial.removed !== undefined ? { removed: partial.removed } : {}),
+            ...(partial.timeoutMs !== undefined ? { timeoutMs: partial.timeoutMs } : {}),
+        };
+        for (const cb of this.uiSubscribers)
+            cb(req);
+        return req;
+    }
     describePersistence() {
         return { provider: this.provider, sessionId: this.id, nativeHandle: `mock:${this.id}` };
     }
@@ -268,4 +384,17 @@ export class MockAgentClient {
 export function createMockClient(options) {
     return new MockAgentClient(options);
 }
+/** Renders a scripted dialog's answer as short, human-readable assistant text (task-001: "the mock
+ *  echoes what it received"). Dev/test-only tooling — unlike the web-client's presentation rules
+ *  (sprint-068/task-004), this deliberately may name a typed value, since it exists to prove the
+ *  round trip during manual verification. */
+function describeUiResponse(response) {
+    if (response.cancelled)
+        return "cancelled: true";
+    if (response.confirmed !== undefined)
+        return `confirmed: ${response.confirmed}`;
+    if (response.value !== undefined)
+        return `value: ${JSON.stringify(response.value)}`;
+    return "no answer";
+}
 //# sourceMappingURL=mock-provider.js.map

package/dist/agent/providers/mock/ui-script.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Scripted UI-dialog trigger for the mock provider (sprint-068/task-001). Lets a browser-connected
+ * client raise every `agent_ui_*` dialog state by typing a `#ui ...` prompt, so the extension-UI
+ * dialog rendering shipped in this sprint can be visually signed off against a running dev daemon
+ * with no real `pi` process and no real interactive extension.
+ *
+ * `parseUiScript` is a **pure** parser with a cheap prefix check: it returns `null` for the
+ * overwhelmingly common case (an ordinary prompt, including one that merely mentions `#ui` later in
+ * the text), and a list of `UiScriptStep`s to raise for a recognised `#ui ...` prompt. Wiring the
+ * result into a turn — raising the dialogs, waiting for answers, echoing them as assistant text — is
+ * `MockAgentSession`'s job, not this module's; this module only decides *what* to raise.
+ *
+ * Grammar (also echoed verbatim by `#ui help`):
+ *
+ *   #ui select                one dialog, two short options (Allow / Block)
+ *   #ui confirm                title + message
+ *   #ui input                  single-line field with a placeholder
+ *   #ui editor                 multi-line field, prefilled
+ *   #ui unknown                a method Pi has never defined, still answerable (Cancel only)
+ *   #ui select:9               nine options — past the § 12 stacking+scroll threshold
+ *   #ui select:empty           an empty `options` array
+ *   #ui select:long            self-numbered options, captured verbatim from a live run
+ *   #ui input:multiline        a title with a hard line break and a bracketed extension prefix
+ *   #ui notify                 a transient info-level `notify` — no dialog, no answer, no echo
+ *   #ui notify:warning         a transient warning-level `notify`
+ *   #ui notify:error           a transient error-level `notify`
+ *   #ui set_editor_text        a transient `set_editor_text` — replaces the composer draft
+ *   #ui <method> timeout=<s>   adds a deadline in seconds (rejected for `editor` — see Notes)
+ *
+ * Notes: `editor` has no `timeout` field on Pi's real wire (the visual spec's § 00 wire table lists
+ * one in error — sprint-068/task-009 files the correction), so `#ui editor timeout=5` is rejected
+ * (parses to `null`, falling through to an ordinary echoed turn) rather than emit a field Pi could
+ * never actually send.
+ */
+/** One dialog to raise. `payload` field names match the visual spec's § 00 wire table exactly. */
+export interface UiScriptStep {
+    method: string;
+    payload: Record<string, unknown>;
+    expectsResponse: boolean;
+    timeoutMs?: number;
+    /** True: this dialog is raised and its answer is awaited before the turn can complete — the
+     *  normal, single-dialog case. False: raised without individually waiting — used only by
+     *  `#ui multi`, where every step is raised up front and the turn waits on all of them together.
+     *  Unrelated to `expectsResponse: false` (a transient like `notify`) — those never produce an
+     *  answer to await regardless of this field; see `mock-provider.ts`'s `raiseScriptedDialog`. */
+    await: boolean;
+}
+export declare function getUiScriptHelpText(): string;
+/** Parses a `#ui ...` prompt into the dialog(s) it describes. Returns `null` when `prompt` is not a
+ *  recognised script — the overwhelmingly common case, kept a cheap prefix check. */
+export declare function parseUiScript(prompt: string): UiScriptStep[] | null;
+//# sourceMappingURL=ui-script.d.ts.map

package/dist/agent/providers/mock/ui-script.js

@@ -0,0 +1,224 @@
+/**
+ * Scripted UI-dialog trigger for the mock provider (sprint-068/task-001). Lets a browser-connected
+ * client raise every `agent_ui_*` dialog state by typing a `#ui ...` prompt, so the extension-UI
+ * dialog rendering shipped in this sprint can be visually signed off against a running dev daemon
+ * with no real `pi` process and no real interactive extension.
+ *
+ * `parseUiScript` is a **pure** parser with a cheap prefix check: it returns `null` for the
+ * overwhelmingly common case (an ordinary prompt, including one that merely mentions `#ui` later in
+ * the text), and a list of `UiScriptStep`s to raise for a recognised `#ui ...` prompt. Wiring the
+ * result into a turn — raising the dialogs, waiting for answers, echoing them as assistant text — is
+ * `MockAgentSession`'s job, not this module's; this module only decides *what* to raise.
+ *
+ * Grammar (also echoed verbatim by `#ui help`):
+ *
+ *   #ui select                one dialog, two short options (Allow / Block)
+ *   #ui confirm                title + message
+ *   #ui input                  single-line field with a placeholder
+ *   #ui editor                 multi-line field, prefilled
+ *   #ui unknown                a method Pi has never defined, still answerable (Cancel only)
+ *   #ui select:9               nine options — past the § 12 stacking+scroll threshold
+ *   #ui select:empty           an empty `options` array
+ *   #ui select:long            self-numbered options, captured verbatim from a live run
+ *   #ui input:multiline        a title with a hard line break and a bracketed extension prefix
+ *   #ui notify                 a transient info-level `notify` — no dialog, no answer, no echo
+ *   #ui notify:warning         a transient warning-level `notify`
+ *   #ui notify:error           a transient error-level `notify`
+ *   #ui set_editor_text        a transient `set_editor_text` — replaces the composer draft
+ *   #ui <method> timeout=<s>   adds a deadline in seconds (rejected for `editor` — see Notes)
+ *
+ * Notes: `editor` has no `timeout` field on Pi's real wire (the visual spec's § 00 wire table lists
+ * one in error — sprint-068/task-009 files the correction), so `#ui editor timeout=5` is rejected
+ * (parses to `null`, falling through to an ordinary echoed turn) rather than emit a field Pi could
+ * never actually send.
+ */
+const SELECT_ALLOW_BLOCK = {
+    title: "Allow this extension to modify /etc/hosts?",
+    options: ["Allow", "Block"],
+};
+const CONFIRM_CLEAR_SESSION = {
+    title: "Clear session?",
+    message: "All messages will be lost. The transcript can't be recovered afterwards.",
+};
+const INPUT_RELEASE_TAG = {
+    title: "Enter a release tag",
+    placeholder: "v2.4.1",
+};
+const EDITOR_COMMIT_MESSAGE = {
+    title: "Edit commit message before pushing",
+    prefill: "fix: retry dns lookups with backoff\n\nAdds exponential backoff to the connectivity\ncheck skill after repeated timeouts.",
+};
+// Verbatim from the visual spec § 05 (unrecognised-method card) — a method Pi has never defined.
+const UNKNOWN_METHOD_PAYLOAD = {
+    title: "Select a window",
+    min: 0,
+    max: 240,
+};
+// Verbatim from § 12 "NINE OPTIONS · SCROLLS AT SIX".
+const SELECT_NINE_OPTIONS = {
+    title: "Pick a target",
+    options: [
+        "staging-eu",
+        "staging-us",
+        "prod-eu",
+        "prod-us",
+        "prod-apac",
+        "canary-1",
+        "canary-2",
+        "local",
+        "dry-run",
+    ],
+};
+const SELECT_EMPTY_OPTIONS = {
+    title: "Pick a window",
+    options: [],
+};
+// Verbatim from § 03 "SELECT · STACKED, THE COMMON CASE" — a live capture: the extension numbered
+// its own options and prefixed its own title. Never rewritten (§ 03/§ 12).
+const SELECT_LONG_LABELS = {
+    title: "[Color] Which color do you pick?",
+    options: ["1. Red — Pick the color red.", "2. Blue — Pick the color blue.", "3. Type something."],
+};
+// Verbatim from § 03 "INPUT · HARD BREAK, BRACKETED PREFIX" — also a live capture.
+const INPUT_MULTILINE = {
+    title: "[Color] Which color do you pick?\n\nType your answer:",
+};
+// § 00's wire table: `notify`'s `message` is required, `level` optional (absent ⇒ the client
+// normalizes to "info" — `agent-ui-state.ts`'s `buildTransientEffects`). These three exercise all
+// three levels § 11 treats distinctly.
+const NOTIFY_INFO = {
+    message: "Sync complete.",
+};
+const NOTIFY_WARNING = {
+    message: "Rate limit approaching — 80% of quota used.",
+    level: "warning",
+};
+const NOTIFY_ERROR = {
+    message: "Failed to reach the remote index.",
+    level: "error",
+};
+// § 00's wire table: `set_editor_text` carries only `text` — captured verbatim from § 11's own
+// mock ("REPLACEMENT LANDED").
+const SET_EDITOR_TEXT = {
+    text: "retry the dns lookups with a 2s backoff",
+};
+const HELP_TEXT = `#ui script recipes:
+  #ui select                one dialog, two short options (Allow / Block)
+  #ui confirm                title + message
+  #ui input                  single-line field with a placeholder
+  #ui editor                 multi-line field, prefilled
+  #ui unknown                a method Pi has never defined, still answerable (Cancel only)
+  #ui select:9               nine options — past the stacking+scroll threshold
+  #ui select:empty           an empty options array
+  #ui select:long            self-numbered options, captured verbatim from a live run
+  #ui input:multiline        a title with a hard break and a bracketed extension prefix
+  #ui notify                 a transient info-level notify — no dialog, no answer, no echo
+  #ui notify:warning         a transient warning-level notify
+  #ui notify:error           a transient error-level notify
+  #ui set_editor_text        a transient set_editor_text — replaces the composer draft
+  #ui <method> timeout=<s>   adds a deadline in seconds (rejected for editor)
+  #ui multi <n>              raises n dialogs at once, none awaited individually
+  #ui help                   this list`;
+export function getUiScriptHelpText() {
+    return HELP_TEXT;
+}
+function buildStep(method, payload, timeoutMs) {
+    return {
+        method,
+        payload,
+        expectsResponse: true,
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        await: true,
+    };
+}
+/** Like `buildStep`, but for a fire-and-forget transient (`notify`) — `expectsResponse: false`,
+ *  no `timeoutMs` (transients have no deadline field on the real wire). */
+function buildTransientStep(method, payload) {
+    return { method, payload, expectsResponse: false, await: true };
+}
+/** Parses a `#ui ...` prompt into the dialog(s) it describes. Returns `null` when `prompt` is not a
+ *  recognised script — the overwhelmingly common case, kept a cheap prefix check. */
+export function parseUiScript(prompt) {
+    const trimmed = prompt.trim();
+    if (!/^#ui(\s|$)/i.test(trimmed))
+        return null;
+    const rest = trimmed.slice(3).trim();
+    if (rest === "")
+        return null;
+    if (rest === "help")
+        return [];
+    const multiMatch = /^multi\s+(\d+)$/.exec(rest);
+    if (multiMatch) {
+        const n = Number(multiMatch[1]);
+        if (!Number.isInteger(n) || n < 1)
+            return null;
+        return Array.from({ length: n }, (_, i) => ({
+            method: "select",
+            payload: { title: `Question ${i + 1} of ${n}`, options: ["Allow", "Block"] },
+            expectsResponse: true,
+            await: false,
+        }));
+    }
+    const tokens = rest.split(/\s+/);
+    const recipe = tokens[0];
+    const extraTokens = tokens.slice(1);
+    if (extraTokens.some((t) => !/^timeout=\d+$/.test(t)))
+        return null;
+    const timeoutToken = extraTokens[0];
+    const timeoutMs = timeoutToken ? Number(timeoutToken.slice("timeout=".length)) * 1000 : undefined;
+    const [method, variant] = recipe.split(":");
+    switch (method) {
+        case "unknown":
+            if (variant !== undefined || timeoutMs !== undefined)
+                return null;
+            return [buildStep("pickRange", UNKNOWN_METHOD_PAYLOAD, undefined)];
+        case "editor":
+            // Pi's editor has no `timeout` field on the real wire — reject rather than fabricate one.
+            if (variant !== undefined || timeoutMs !== undefined)
+                return null;
+            return [buildStep("editor", EDITOR_COMMIT_MESSAGE, undefined)];
+        case "select": {
+            let payload = SELECT_ALLOW_BLOCK;
+            if (variant === "9")
+                payload = SELECT_NINE_OPTIONS;
+            else if (variant === "empty")
+                payload = SELECT_EMPTY_OPTIONS;
+            else if (variant === "long")
+                payload = SELECT_LONG_LABELS;
+            else if (variant !== undefined)
+                return null;
+            return [buildStep("select", payload, timeoutMs)];
+        }
+        case "confirm":
+            if (variant !== undefined)
+                return null;
+            return [buildStep("confirm", CONFIRM_CLEAR_SESSION, timeoutMs)];
+        case "input": {
+            let payload = INPUT_RELEASE_TAG;
+            if (variant === "multiline")
+                payload = INPUT_MULTILINE;
+            else if (variant !== undefined)
+                return null;
+            return [buildStep("input", payload, timeoutMs)];
+        }
+        case "notify": {
+            if (timeoutMs !== undefined)
+                return null; // transients have no deadline field on the wire
+            let payload = NOTIFY_INFO;
+            if (variant === "warning")
+                payload = NOTIFY_WARNING;
+            else if (variant === "error")
+                payload = NOTIFY_ERROR;
+            else if (variant !== undefined)
+                return null;
+            return [buildTransientStep("notify", payload)];
+        }
+        case "set_editor_text":
+            if (variant !== undefined || timeoutMs !== undefined)
+                return null;
+            return [buildTransientStep("set_editor_text", SET_EDITOR_TEXT)];
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=ui-script.js.map

package/dist/agent/providers/pi/agent.d.ts

@@ -51,6 +51,7 @@ export declare class PiAgentClient implements AgentClient {
         supportsRewindFiles: import("zod").ZodOptional<import("zod").ZodBoolean>;
         supportsRewindBoth: import("zod").ZodOptional<import("zod").ZodBoolean>;
         supportsSteering: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        supportsExtensionUi: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, import("zod").ZodTypeAny, "passthrough">;
     private readonly command;
     private readonly factory;