viberoom 0.3.0 → 0.4.0

package/vendor/acp/claude-agent-acp/dist/clear-context-coordinator.js

@@ -0,0 +1,80 @@
+import { DEFAULT_AGENT_ID, DEFAULT_MODEL_ID, EFFORT_CONFIG_ID } from "./session-config-ids.js";
+function restartParams(session) {
+    const originalParams = session.creationParams ?? { cwd: session.cwd, mcpServers: [] };
+    const currentEffort = session.configOptions.find((option) => option.id === EFFORT_CONFIG_ID)?.currentValue;
+    const originalMeta = originalParams._meta;
+    const originalOptions = originalMeta?.claudeCode?.options;
+    const unmanagedOptions = { ...(originalOptions ?? {}) };
+    delete unmanagedOptions.model;
+    delete unmanagedOptions.agent;
+    delete unmanagedOptions.effort;
+    return {
+        ...originalParams,
+        _meta: {
+            ...(originalMeta ?? {}),
+            claudeCode: {
+                ...(originalMeta?.claudeCode ?? {}),
+                options: {
+                    ...unmanagedOptions,
+                    ...(session.models.currentModelId !== DEFAULT_MODEL_ID
+                        ? { model: session.models.currentModelId }
+                        : {}),
+                    ...(session.currentAgent !== DEFAULT_AGENT_ID ? { agent: session.currentAgent } : {}),
+                    ...(typeof currentEffort === "string" && currentEffort !== "default"
+                        ? { effort: currentEffort }
+                        : {}),
+                },
+            },
+        },
+    };
+}
+/** Replace Claude's private conversation and attach the still-pending ACP turn
+ * to it. The host owns provider-specific creation and stream mechanics; this
+ * coordinator owns the ordering and state transfer invariants. */
+export async function continuePlanInFreshContext(sessionId, oldSession, reset, host, signal) {
+    const assertRestartActive = (session) => {
+        if (signal?.aborted || (session && host.currentSession(sessionId) !== session)) {
+            throw new Error("Clear-context restart aborted");
+        }
+    };
+    assertRestartActive();
+    const turn = oldSession.activeTurn;
+    if (!turn || turn.settled || host.currentSession(sessionId) !== oldSession) {
+        throw new Error("Cannot clear context without an active ACP turn");
+    }
+    const params = restartParams(oldSession);
+    host.closeQueryStream(oldSession);
+    const freshSession = await host.restartSession(params, {
+        publicSessionId: sessionId,
+        permissionMode: reset.mode,
+    });
+    assertRestartActive(freshSession);
+    // Do not consume the reset or mutate the turn until a replacement exists.
+    // A failed restart must remain distinguishable from a lost query transport.
+    turn.carriedUsage = { ...oldSession.accumulatedUsage };
+    turn.carriedModelUsage = { ...oldSession.accumulatedModelUsage };
+    oldSession.pendingExitPlanContextReset = undefined;
+    if (oldSession.fastModeEnabled !== freshSession.fastModeEnabled) {
+        try {
+            await host.applyFastMode(freshSession, oldSession.fastModeEnabled);
+        }
+        catch (error) {
+            host.logError("Failed to restore Fast mode after clearing context:", error);
+        }
+        assertRestartActive(freshSession);
+    }
+    oldSession.activeTurn = null;
+    oldSession.turnQueue = [];
+    freshSession.turnQueue = [turn];
+    freshSession.contextUsedTokens = 0;
+    try {
+        await host.publishSessionState(sessionId, reset.mode, freshSession.configOptions);
+    }
+    catch (error) {
+        host.logError("Failed to publish clear-context session state:", error);
+    }
+    assertRestartActive(freshSession);
+    freshSession.input.push(host.continuationMessage(sessionId, reset.plan, turn.promptUuid));
+    assertRestartActive(freshSession);
+    host.ensureConsumer(freshSession, sessionId);
+}

package/vendor/acp/claude-agent-acp/dist/elicitation.js

@@ -0,0 +1,304 @@
+import { randomUUID } from "node:crypto";
+import { CreateElicitationResponse } from "@agentclientprotocol/sdk";
+/**
+ * Convert an MCP elicitation request (from the SDK's `onElicitation` callback)
+ * into an ACP `CreateElicitationRequest`. Returns `null` when the request can't
+ * be represented (e.g. a url-mode request with no url).
+ */
+export function mcpElicitationToCreateRequest(request, sessionId) {
+    if (request.mode === "url") {
+        if (!request.url) {
+            return null;
+        }
+        return {
+            mode: "url",
+            sessionId,
+            message: request.message,
+            url: request.url,
+            // URL elicitations need a stable id so the client can correlate the
+            // later `session/complete_elicitation` notification. MCP servers usually
+            // provide one; fall back to a generated id if not.
+            elicitationId: request.elicitationId ?? randomUUID(),
+        };
+    }
+    // Form mode (the default). The MCP `requestedSchema` is already a JSON Schema
+    // with primitive-typed properties, which is structurally what ACP expects.
+    return {
+        mode: "form",
+        sessionId,
+        message: request.message,
+        requestedSchema: normalizeElicitationSchema(request.requestedSchema),
+    };
+}
+/**
+ * Content of an accepted elicitation response.
+ *
+ * Uses the SDK's validating guard rather than an `action === "accept"` check:
+ * the guard both narrows past the union's custom/future variant and validates
+ * the payload, so a malformed accept (right tag, ill-typed content) yields
+ * empty content — the same classification the SDK's wire validators apply.
+ */
+function acceptedElicitationContent(response) {
+    return CreateElicitationResponse.isAccept(response) ? (response.content ?? {}) : {};
+}
+/**
+ * Map an ACP elicitation response back to the MCP `ElicitResult` the SDK expects
+ * to hand back to the requesting server.
+ */
+export function createElicitationResponseToElicitResult(response) {
+    switch (response.action) {
+        case "accept":
+            return { action: "accept", content: acceptedElicitationContent(response) };
+        case "decline":
+            return { action: "decline" };
+        case "cancel":
+        default:
+            return { action: "cancel" };
+    }
+}
+/**
+ * Pull the well-formed questions out of an AskUserQuestion tool input. Returns
+ * `null` when there are no usable questions — including the case where every
+ * entry is malformed and filtering leaves an empty list — so callers can treat
+ * "nothing to ask" uniformly.
+ */
+export function extractAskUserQuestions(input) {
+    const questions = input.questions;
+    if (!Array.isArray(questions)) {
+        return null;
+    }
+    const valid = questions.filter((q) => !!q && typeof q.question === "string" && Array.isArray(q.options) && q.options.length > 0);
+    return valid.length > 0 ? valid : null;
+}
+/** Stable form-field key for the question at the given index. */
+function questionFieldKey(index) {
+    return `question_${index}`;
+}
+/**
+ * Form-field key for the per-question free-text "custom answer" field that sits
+ * alongside `question_<n>`. Mirrors the first-party clients, where every
+ * question carries its own "Other" box rather than one form-level field.
+ */
+function questionCustomFieldKey(index) {
+    return `question_${index}_custom`;
+}
+/**
+ * `_meta` key under which a bridged enum option carries its `preview`, the one
+ * option field ACP's `EnumOption` still has no slot for (descriptions are
+ * first-class as of schema 1.19). Namespaced like the agent's other `_meta`
+ * extensions (`_claude/...`).
+ */
+const OPTION_META_KEY = "_claude/askUserQuestionOption";
+/**
+ * Shared `_meta` key for marking a per-question free-text field as the custom
+ * answer companion for a select question. This intentionally has no
+ * agent-specific namespace so ACP clients can recognize the same marker across
+ * Codex, Claude, and other AskUserQuestion bridges.
+ */
+const CUSTOM_ANSWER_META_KEY = "_askUserQuestionCustomAnswer";
+/**
+ * Render the AskUserQuestion tool's questions as an ACP form elicitation.
+ *
+ * Fields are keyed by a short stable id (`question_<n>`) rather than the full
+ * question text, so the question text appears in exactly one place per field.
+ * Single-select questions use a titled `oneOf` enum; multi-select questions use
+ * an array with a titled `anyOf` item enum. The enum `const` is always the
+ * option label, since that is what the tool records as the answer; an option's
+ * secondary text travels in the enum option's own `description` field.
+ *
+ * Each question is followed by its own optional free-text "custom answer" field
+ * (`question_<n>_custom`), mirroring the CLI's per-question "Other" box: the
+ * user can type their own answer instead of picking an option, scoped to that
+ * specific question. Nothing is marked required, so the user can also just skip
+ * — matching the built-in tool, which always offers Skip + a free-text box.
+ */
+export function askUserQuestionsToCreateRequest(questions, sessionId, toolCallId) {
+    const single = questions.length === 1;
+    const properties = {};
+    questions.forEach((question, index) => {
+        const options = question.options.map((option) => {
+            const enumOption = {
+                const: option.label,
+                title: option.label,
+            };
+            if (option.description) {
+                enumOption.description = option.description;
+            }
+            // The SDK option's `preview` (mockups, code snippets, comparisons shown
+            // on focus) still has no structural slot in `EnumOption`, so forward it
+            // under ACP's reserved `_meta` extension point for clients that render it.
+            if (option.preview) {
+                enumOption._meta = { [OPTION_META_KEY]: { preview: option.preview } };
+            }
+            return enumOption;
+        });
+        // For a single question the prompt is carried by `message`, so we don't
+        // repeat it in the field description. With multiple questions each field
+        // needs its own question text.
+        const description = single ? undefined : question.question;
+        const title = question.header || undefined;
+        properties[questionFieldKey(index)] = question.multiSelect
+            ? { type: "array", title, description, items: { anyOf: options } }
+            : { type: "string", title, description, oneOf: options };
+        properties[questionCustomFieldKey(index)] = {
+            type: "string",
+            title: "Other",
+            description: "Type your own answer instead of choosing an option above (optional).",
+            _meta: {
+                [CUSTOM_ANSWER_META_KEY]: {
+                    questionId: questionFieldKey(index),
+                    isCustomAnswer: true,
+                },
+            },
+        };
+    });
+    const requestedSchema = {
+        type: "object",
+        properties,
+    };
+    const message = single ? questions[0].question : "Please answer the following questions.";
+    return {
+        mode: "form",
+        sessionId,
+        ...(toolCallId ? { toolCallId } : {}),
+        message,
+        requestedSchema,
+    };
+}
+/**
+ * Fold an ACP elicitation response into the AskUserQuestion tool's input.
+ *
+ * Selected labels are read back from the indexed form fields and written into
+ * `answers` as a `{ [questionText]: label }` map (comma-joining multi-selects)
+ * — the key shape the tool's own `call()` reads. A non-empty per-question
+ * custom-answer field (`question_<n>_custom`) takes precedence over that
+ * question's selection, since the user typed their own answer instead of
+ * picking one. Decline yields empty answers (the model is told the user skipped
+ * rather than the turn aborting); cancel — and any custom/future action we
+ * don't understand — aborts the tool call.
+ */
+export function applyAskElicitationResponse(response, toolInput, questions) {
+    if (response.action === "decline") {
+        return { action: "answered", updatedInput: { ...toolInput, answers: {} } };
+    }
+    if (response.action !== "accept") {
+        return { action: "cancel" };
+    }
+    const content = acceptedElicitationContent(response);
+    // Typed against the tool's own output schema so the answer/response shapes
+    // stay in sync with what the built-in tool's call() expects to read back.
+    const answers = {};
+    questions.forEach((question, index) => {
+        // A typed custom answer wins over the selection: the user chose to write
+        // their own answer for this question instead of picking an option.
+        const custom = content[questionCustomFieldKey(index)];
+        if (typeof custom === "string" && custom.trim() !== "") {
+            answers[question.question] = custom.trim();
+            return;
+        }
+        const value = content[questionFieldKey(index)];
+        if (value === undefined || value === null) {
+            return;
+        }
+        const text = Array.isArray(value) ? value.join(", ") : String(value);
+        if (text === "") {
+            return;
+        }
+        answers[question.question] = text;
+    });
+    return { action: "answered", updatedInput: { ...toolInput, answers } };
+}
+/**
+ * Coerce an arbitrary MCP `requestedSchema` into an ACP `ElicitationSchema`.
+ * The two are structurally compatible JSON Schemas; we just guarantee the
+ * `type: "object"` discriminator is present.
+ */
+function normalizeElicitationSchema(schema) {
+    if (!schema || typeof schema !== "object") {
+        return { type: "object", properties: {} };
+    }
+    return { ...schema, type: "object" };
+}
+/**
+ * The `request_user_dialog` kind the CLI emits when a model refusal has a
+ * fallback available but needs user consent before retrying (e.g. Claude Fable
+ * declining a request with Opus available as the fallback). Declaring this
+ * kind in `supportedDialogKinds` is the opt-in: the CLI fails closed and never
+ * emits an undeclared kind — the flow degrades to the classic refusal error
+ * ending the turn.
+ */
+export const REFUSAL_FALLBACK_DIALOG_KIND = "refusal_fallback_prompt";
+/**
+ * Validate the opaque dialog payload into a {@link RefusalFallbackPrompt}.
+ * Returns `null` when the required fields are missing or mistyped (a newer CLI
+ * may reshape the payload), so the caller can cancel the dialog and let the
+ * CLI apply its default behavior instead of rendering something misleading.
+ */
+export function extractRefusalFallbackPrompt(payload) {
+    const { originalModel, fallbackModel, apiRefusalCategory, guidanceText } = payload;
+    if (typeof originalModel !== "string" || typeof fallbackModel !== "string") {
+        return null;
+    }
+    return {
+        originalModel,
+        fallbackModel,
+        apiRefusalCategory: typeof apiRefusalCategory === "string" ? apiRefusalCategory : null,
+        ...(typeof guidanceText === "string" && guidanceText ? { guidanceText } : {}),
+    };
+}
+/** Form-field key carrying the user's choice in the refusal-fallback form. */
+const REFUSAL_FALLBACK_CHOICE_KEY = "choice";
+/** Wire values of the dialog's result enum (CLI schema). `edit_prompt` is
+ *  deliberately not offered: in the CLI it prefills the composer with the
+ *  refused prompt for edit-and-retry, and ACP has no composer-prefill surface
+ *  — the user can simply edit and resend on their own. */
+const RETRY_FALLBACK_RESULT = "retry_fallback";
+const KEEP_REFUSAL_RESULT = "cancelled";
+/**
+ * Render the refusal-fallback consent prompt as an ACP form elicitation: a
+ * single-select between retrying on the fallback model and keeping the
+ * refusal. The enum `const`s are the dialog's wire result values, so the
+ * response maps back without a translation table.
+ */
+export function refusalFallbackToCreateRequest(prompt, sessionId) {
+    const category = prompt.apiRefusalCategory ? ` (${prompt.apiRefusalCategory})` : "";
+    const guidance = prompt.guidanceText ? `\n\n${prompt.guidanceText}` : "";
+    return {
+        mode: "form",
+        sessionId,
+        message: `${prompt.originalModel} declined this request${category}. ` +
+            `Retry with ${prompt.fallbackModel}?` +
+            guidance,
+        requestedSchema: {
+            type: "object",
+            properties: {
+                [REFUSAL_FALLBACK_CHOICE_KEY]: {
+                    type: "string",
+                    oneOf: [
+                        {
+                            const: RETRY_FALLBACK_RESULT,
+                            title: `Retry with ${prompt.fallbackModel}`,
+                            description: `The session continues on ${prompt.fallbackModel}.`,
+                        },
+                        {
+                            const: KEEP_REFUSAL_RESULT,
+                            title: "Keep the refusal",
+                            description: "You can send a new message.",
+                        },
+                    ],
+                },
+            },
+        },
+    };
+}
+/**
+ * Map the elicitation response back to the dialog's result enum. Only an
+ * explicit accept-with-retry resolves to `retry_fallback`; decline, cancel, a
+ * skipped field, or an unrecognized value all keep the refusal — the dialog's
+ * own default — so a dismissed or half-filled form can never trigger a model
+ * switch the user didn't ask for.
+ */
+export function refusalFallbackResultFromResponse(response) {
+    const choice = acceptedElicitationContent(response)[REFUSAL_FALLBACK_CHOICE_KEY];
+    return choice === RETRY_FALLBACK_RESULT ? RETRY_FALLBACK_RESULT : KEEP_REFUSAL_RESULT;
+}

package/vendor/acp/claude-agent-acp/dist/exit-plan.js

@@ -0,0 +1,154 @@
+import { continuePlanInFreshContext, } from "./clear-context-coordinator.js";
+import { parseToolResultMeta } from "./tool-result-meta.js";
+export function acceptedPlanToolResult(notification, toolUseId) {
+    const update = notification.update;
+    if (!toolUseId ||
+        update.sessionUpdate !== "tool_call_update" ||
+        update.toolCallId !== toolUseId) {
+        return notification;
+    }
+    const completed = { ...update };
+    delete completed.rawOutput;
+    delete completed.content;
+    return { ...notification, update: { ...completed, status: "completed" } };
+}
+function containsToolResultFor(content, toolUseId) {
+    return (Array.isArray(content) &&
+        content.some((block) => typeof block === "object" &&
+            block !== null &&
+            block.type === "tool_result" &&
+            block.tool_use_id === toolUseId));
+}
+function rejectedExitPlanToolUseId(content, toolUseCache, rawToolResultMeta) {
+    if (!Array.isArray(content))
+        return undefined;
+    const toolResultMeta = parseToolResultMeta(rawToolResultMeta);
+    if (!toolResultMeta)
+        return undefined;
+    for (const block of content) {
+        if (typeof block !== "object" || block === null)
+            continue;
+        const { type, tool_use_id: toolUseId, is_error: isError } = block;
+        if (type === "tool_result" &&
+            typeof toolUseId === "string" &&
+            isError === true &&
+            toolResultMeta.get(toolUseId)?.nonExecutionKind === "user-rejected" &&
+            toolUseCache[toolUseId]?.name === "ExitPlanMode") {
+            return toolUseId;
+        }
+    }
+    return undefined;
+}
+/** Reconcile an SDK user message with the two pending ExitPlanMode lanes and
+ * return the accepted plan tool id whose rendered update must be completed. */
+export function observeExitPlanToolResults(message, content, state) {
+    if (message.type !== "user")
+        return undefined;
+    const rejectedToolUseId = rejectedExitPlanToolUseId(content, state.toolUseCache, message.tool_result_meta);
+    if (rejectedToolUseId) {
+        // The stream is authoritative: resumed queries can lose the short-lived
+        // marker installed by canUseTool, while metadata preserves correlation.
+        state.pendingExitPlanModeInterruption = {
+            toolUseId: rejectedToolUseId,
+            toolResultSeen: true,
+        };
+    }
+    const pendingInterruption = state.pendingExitPlanModeInterruption;
+    if (pendingInterruption && containsToolResultFor(content, pendingInterruption.toolUseId)) {
+        pendingInterruption.toolResultSeen = true;
+    }
+    const pendingReset = state.pendingExitPlanContextReset;
+    return pendingReset && containsToolResultFor(content, pendingReset.toolUseId)
+        ? pendingReset.toolUseId
+        : undefined;
+}
+export function executionDiagnostic(message) {
+    if (message.subtype === "success") {
+        return message.result.startsWith("[ede_diagnostic]") ? message.result : undefined;
+    }
+    return message.errors.find((error) => error.startsWith("[ede_diagnostic]"));
+}
+/** Claude wraps a rejected ExitPlanMode explanation in a Markdown code fence.
+ * Strip exactly one complete outer fence for that tool only. */
+export function exitPlanModeRawOutput(toolName, content) {
+    if (toolName !== "ExitPlanMode" || typeof content !== "string") {
+        return content;
+    }
+    const fenced = /^\s*```[^\r\n]*\r?\n([\s\S]*?)\r?\n```\s*$/.exec(content);
+    return fenced?.[1] ?? content;
+}
+/** Owns the lifetime of accepted-plan context replacements. In particular, a
+ * session cancellation invalidates an in-progress async restart so a late
+ * restartSession result cannot recreate a closed public session. */
+export class ExitPlanCoordinator {
+    host;
+    restarts = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    cancel(sessionId) {
+        this.restarts.get(sessionId)?.abort();
+    }
+    async restart(sessionId, oldSession, reset) {
+        this.cancel(sessionId);
+        const controller = new AbortController();
+        this.restarts.set(sessionId, controller);
+        try {
+            const clearContextHost = {
+                ...this.host,
+                publishSessionState: async (id, mode, configOptions) => {
+                    await this.host.sessionUpdate({
+                        sessionId: id,
+                        update: { sessionUpdate: "current_mode_update", currentModeId: mode },
+                    });
+                    await this.host.sessionUpdate({
+                        sessionId: id,
+                        update: { sessionUpdate: "config_option_update", configOptions },
+                    });
+                },
+                continuationMessage: (id, plan, promptUuid) => ({
+                    type: "user",
+                    message: {
+                        role: "user",
+                        content: [{ type: "text", text: `Implement the following plan:\n\n${plan}` }],
+                    },
+                    session_id: id,
+                    parent_tool_use_id: null,
+                    origin: { kind: "human" },
+                    uuid: promptUuid,
+                }),
+            };
+            await continuePlanInFreshContext(sessionId, oldSession, reset, clearContextHost, controller.signal);
+        }
+        catch (error) {
+            const currentSession = this.host.currentSession(sessionId);
+            const replacement = currentSession !== oldSession ? currentSession : undefined;
+            if (replacement)
+                this.host.destroyReplacement(sessionId, replacement);
+            const turn = replacement?.activeTurn ?? oldSession.activeTurn;
+            if (turn && !turn.settled) {
+                const turnSession = replacement?.activeTurn === turn ? replacement : oldSession;
+                if (controller.signal.aborted) {
+                    this.host.settleCancelledTurn(oldSession, turnSession, turn);
+                }
+                else {
+                    // A provider/session-creation failure is turn-scoped. Settling it
+                    // here keeps it out of the query consumer's transport-loss catch.
+                    this.host.settleFailedTurn(turnSession, turn, error);
+                }
+                oldSession.activeTurn = null;
+                oldSession.turnQueue = (oldSession.turnQueue ?? []).filter((queued) => queued !== turn);
+                if (replacement) {
+                    replacement.activeTurn = null;
+                    replacement.turnQueue = (replacement.turnQueue ?? []).filter((queued) => queued !== turn);
+                }
+            }
+            oldSession.pendingExitPlanContextReset = undefined;
+        }
+        finally {
+            if (this.restarts.get(sessionId) === controller) {
+                this.restarts.delete(sessionId);
+            }
+        }
+    }
+}