viberoom 0.3.0 → 0.4.0

package/vendor/acp/claude-agent-acp/dist/permissions/response.js

@@ -0,0 +1,19 @@
+import { applyClaudePermissionSelection, parseClaudePermissionSelection } from "./effects.js";
+/** Decode, validate, and interpret an ACP response exactly once. */
+export function decodeClaudePermissionResponse(response, toolName, input, toolUseID, offeredOptions, durableChangeSet) {
+    const selection = parseClaudePermissionSelection(response, toolName);
+    const offeredOption = offeredOptions.find((option) => option.optionId === selection.optionId);
+    if (!offeredOption) {
+        throw new Error(`Permission option was not offered: ${selection.optionId}`);
+    }
+    const permissionResult = applyClaudePermissionSelection(selection, {
+        toolName,
+        input,
+        toolUseID,
+        durableChangeSet,
+    });
+    return {
+        permissionResult,
+        ...(selection.contextResetMode ? { contextResetMode: selection.contextResetMode } : {}),
+    };
+}

package/vendor/acp/claude-agent-acp/dist/session-config-ids.js

@@ -0,0 +1,4 @@
+/** Shared sentinels and ids for session preferences managed by the adapter. */
+export const DEFAULT_MODEL_ID = "default";
+export const DEFAULT_AGENT_ID = "default";
+export const EFFORT_CONFIG_ID = "effort";

package/vendor/acp/claude-agent-acp/dist/session-failure-extension.js

@@ -0,0 +1,324 @@
+import { USAGE_LIMIT_ERROR_PREFIXES, } from "../../claude-agent-sdk/sdk.mjs";
+import { randomUUID } from "node:crypto";
+import { AIR_SESSION_FAILURE_CAPABILITY, airCapabilityMeta, clientSupportsAirCapability, withAirMeta, } from "./air-extension.js";
+export function airSessionFailureCapabilityMeta(...additionalCapabilities) {
+    return airCapabilityMeta(AIR_SESSION_FAILURE_CAPABILITY, ...additionalCapabilities);
+}
+export function createSessionFailureState() {
+    return {
+        epoch: randomUUID(),
+        revisions: new Map(),
+        active: new Map(),
+    };
+}
+const AIR_FAILURE_POLICY = {
+    advisory: {
+        category: "unknown",
+        actions: [],
+        fallbackTitle: "Claude reported a notice.",
+    },
+    auth_required: {
+        category: "access",
+        actions: ["login"],
+        fallbackTitle: "Sign in to continue using Claude.",
+    },
+    bad_request: {
+        category: "request",
+        actions: [],
+        fallbackTitle: "Claude could not process this request.",
+    },
+    budget_exhausted: {
+        category: "limit",
+        actions: ["new_session"],
+        fallbackTitle: "This Claude session reached its configured budget.",
+    },
+    context_exhausted: {
+        category: "limit",
+        actions: ["new_session"],
+        fallbackTitle: "This Claude turn reached its configured limit.",
+    },
+    internal_error: {
+        category: "service",
+        actions: ["retry", "new_session"],
+        fallbackTitle: "Claude Agent encountered an internal error.",
+    },
+    overloaded: {
+        category: "service",
+        actions: ["retry"],
+        fallbackTitle: "Claude is temporarily overloaded.",
+    },
+    provider_error: {
+        category: "service",
+        actions: ["retry"],
+        fallbackTitle: "The model provider reported an error.",
+    },
+    quota_exhausted: {
+        category: "limit",
+        actions: [],
+        fallbackTitle: "The Claude account has no available quota.",
+    },
+    rate_limited: {
+        category: "limit",
+        actions: ["retry"],
+        fallbackTitle: "Claude is temporarily rate limited.",
+    },
+    transport_lost: {
+        category: "connection",
+        actions: ["new_session"],
+        fallbackTitle: "The connection to Claude was lost.",
+    },
+    worker_shutdown: {
+        category: "connection",
+        actions: ["new_session"],
+        fallbackTitle: "The Claude worker is shutting down.",
+    },
+};
+export function sessionFailureMeta(failure) {
+    return withAirMeta(undefined, AIR_SESSION_FAILURE_CAPABILITY, {
+        id: failure.id,
+        revision: failure.revision,
+        category: failure.category,
+        severity: failure.severity,
+        title: failure.title,
+        ...(failure.details ? { details: failure.details } : {}),
+        actions: failure.actions,
+    });
+}
+/** `getSessionMessages` deliberately exposes only the API message and strips
+ *  transcript-level `error` / `isApiErrorMessage` fields. The SDK exports the
+ *  exact stable prefixes used by its synthetic usage-limit errors, so replay
+ *  can recover this one typed failure without matching arbitrary model prose. */
+export function assistantMessageText(apiMessage) {
+    if (!apiMessage || typeof apiMessage !== "object")
+        return undefined;
+    const { content } = apiMessage;
+    if (typeof content === "string")
+        return content || undefined;
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .map((block) => block &&
+        typeof block === "object" &&
+        "type" in block &&
+        block.type === "text" &&
+        "text" in block &&
+        typeof block.text === "string"
+        ? block.text
+        : "")
+        .join("");
+    return text || undefined;
+}
+export function isSyntheticUsageLimitMessage(apiMessage) {
+    if (!apiMessage || typeof apiMessage !== "object")
+        return false;
+    const { model } = apiMessage;
+    if (model !== "<synthetic>")
+        return false;
+    const text = assistantMessageText(apiMessage);
+    if (!text)
+        return false;
+    return USAGE_LIMIT_ERROR_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+export function activeUsageLimitMessage(messages) {
+    let active;
+    for (const message of messages) {
+        if (message.type !== "assistant" || message.parent_tool_use_id !== null)
+            continue;
+        if (isSyntheticUsageLimitMessage(message.message)) {
+            const title = assistantMessageText(message.message);
+            if (title)
+                active = { uuid: message.uuid, title };
+            continue;
+        }
+        const model = message.message && typeof message.message === "object" && "model" in message.message
+            ? message.message.model
+            : undefined;
+        // A later real model answer proves the account recovered. Synthetic
+        // local-command/interruption messages do not: they can be appended while
+        // the provider remains unavailable.
+        if (model !== undefined && model !== "<synthetic>")
+            active = undefined;
+    }
+    return active;
+}
+export function supportsAirSessionFailures(capabilities) {
+    return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_CAPABILITY);
+}
+function sessionFailureRecoveryPolicy(kind, turnId) {
+    switch (kind) {
+        case "advisory":
+            return "never";
+        case "auth_required":
+            return "auth_status";
+        case "transport_lost":
+        case "worker_shutdown":
+            return "runtime_rebind";
+        case "quota_exhausted":
+            return "real_model_success";
+        default:
+            return turnId ? "next_attempt" : "real_model_success";
+    }
+}
+/** Owns the AIR failure lifecycle for both the live consumer and history replay.
+ *  Published revisions become active only after delivery succeeds; recovery only
+ *  removes internal active state because transcript records are historical. */
+export class SessionFailureController {
+    sessionId;
+    state;
+    capabilities;
+    isCurrent;
+    sendUpdate;
+    logger;
+    constructor(options) {
+        this.sessionId = options.sessionId;
+        this.state = options.state;
+        this.capabilities = options.capabilities;
+        this.isCurrent = options.isCurrent;
+        this.sendUpdate = options.sendUpdate;
+        this.logger = options.logger;
+    }
+    isSupported() {
+        return supportsAirSessionFailures(this.capabilities);
+    }
+    async emit(failure) {
+        if (!this.isCurrent()) {
+            this.logger.error(`Session ${this.sessionId}: ignored AIR session failure from a stale consumer`);
+            return false;
+        }
+        try {
+            await this.sendUpdate({
+                sessionId: this.sessionId,
+                update: {
+                    sessionUpdate: "session_info_update",
+                    _meta: sessionFailureMeta(failure),
+                },
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Session ${this.sessionId}: failed to publish AIR session failure: ${error}`);
+            return false;
+        }
+    }
+    recordActive(failure) {
+        this.state.revisions.set(failure.id, failure.revision);
+        this.state.active.set(failure.id, failure);
+        this.state.lastNotice =
+            failure.kind === "advisory" ? { title: failure.title, id: failure.id } : undefined;
+    }
+    async clear(shouldClear = () => true) {
+        if (!this.isSupported())
+            return true;
+        this.state.lastNotice = undefined;
+        for (const failure of [...this.state.active.values()]) {
+            if (!shouldClear(failure))
+                continue;
+            this.state.active.delete(failure.id);
+        }
+        return true;
+    }
+    async prepare(kind, failureOptions = {}) {
+        if (!this.isSupported() || !this.isCurrent())
+            return undefined;
+        const policy = AIR_FAILURE_POLICY[kind];
+        const title = failureOptions.title || policy.fallbackTitle;
+        if (kind === "advisory") {
+            const id = this.state.lastNotice?.title === title
+                ? this.state.lastNotice.id
+                : `${this.sessionId}:notice:${this.state.epoch}:${this.state.nextIncident ?? 1}`;
+            if (this.state.lastNotice?.title !== title) {
+                this.state.nextIncident = (this.state.nextIncident ?? 1) + 1;
+            }
+            return {
+                id,
+                revision: (this.state.revisions.get(id) ?? 0) + 1,
+                kind,
+                category: policy.category,
+                severity: "warning",
+                title,
+                ...(failureOptions.details ? { details: failureOptions.details } : {}),
+                actions: policy.actions,
+                recoveryPolicy: sessionFailureRecoveryPolicy(kind),
+            };
+        }
+        const id = failureOptions.turnId && !failureOptions.sessionScoped
+            ? `${failureOptions.turnId}:error`
+            : `${this.sessionId}:session-error:${this.state.epoch}:${this.state.nextIncident ?? 1}`;
+        if (!failureOptions.turnId || failureOptions.sessionScoped) {
+            this.state.nextIncident = (this.state.nextIncident ?? 1) + 1;
+        }
+        return {
+            id,
+            revision: (this.state.revisions.get(id) ?? 0) + 1,
+            kind,
+            category: policy.category,
+            severity: failureOptions.severity ?? "error",
+            title,
+            ...(failureOptions.details ? { details: failureOptions.details } : {}),
+            actions: failureOptions.severity === "warning" ? [] : policy.actions,
+            recoveryPolicy: sessionFailureRecoveryPolicy(kind, failureOptions.turnId && !failureOptions.sessionScoped ? failureOptions.turnId : undefined),
+            ...(failureOptions.turnId && !failureOptions.sessionScoped
+                ? { turnId: failureOptions.turnId }
+                : {}),
+        };
+    }
+    async publish(kind, failureOptions = {}) {
+        const failure = await this.prepare(kind, failureOptions);
+        if (!failure)
+            return;
+        if (await this.emit(failure))
+            this.recordActive(failure);
+    }
+    async restore(id, kind, title, active = true) {
+        if (!this.isSupported() || !this.isCurrent())
+            return false;
+        const policy = AIR_FAILURE_POLICY[kind];
+        const failure = {
+            id,
+            revision: (this.state.revisions.get(id) ?? 0) + 1,
+            kind,
+            category: policy.category,
+            severity: "error",
+            title,
+            actions: policy.actions,
+            recoveryPolicy: sessionFailureRecoveryPolicy(kind),
+        };
+        if (!(await this.emit(failure)))
+            return false;
+        this.state.revisions.set(failure.id, failure.revision);
+        if (active) {
+            this.state.active.set(failure.id, failure);
+        }
+        else {
+            this.state.active.delete(failure.id);
+        }
+        return true;
+    }
+}
+export function providerFailureCategory(errorKind, isUsageLimit = false) {
+    if (isUsageLimit)
+        return "quota_exhausted";
+    switch (errorKind) {
+        case "authentication_failed":
+        case "oauth_org_not_allowed":
+            return "auth_required";
+        case "billing_error":
+        case "account_on_hold":
+            return "quota_exhausted";
+        case "rate_limit":
+            return "rate_limited";
+        case "overloaded":
+            return "overloaded";
+        case "invalid_request":
+        case "model_not_found":
+            return "bad_request";
+        case "max_output_tokens":
+            return "context_exhausted";
+        case "server_error":
+        case "unknown":
+        case undefined:
+            return "provider_error";
+        default:
+            return "provider_error";
+    }
+}

package/vendor/acp/claude-agent-acp/dist/session-mode.js

@@ -0,0 +1,234 @@
+import { RequestError, } from "@agentclientprotocol/sdk";
+import { ALLOW_BYPASS } from "./permissions/modes.js";
+export const MODE_CONFIG_ID = "mode";
+export const AUTO_MODE_FALLBACK = "acceptEdits";
+const AUTO_MODE_FALLBACK_NOTICE = "**Auto mode unavailable:** the selected model does not support Auto mode; using Accept edits instead.";
+/** Owns session-mode policy and the ACP/SDK synchronization it requires. */
+export class SessionModeManager {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async initialize({ query, requestedMode, currentModelInfo, currentModelId, }) {
+        const availableModes = this.buildAvailableModes();
+        let effectiveMode = requestedMode;
+        let autoModeFallbackWarningPending = false;
+        if (effectiveMode === "auto" &&
+            currentModelInfo !== undefined &&
+            currentModelInfo.supportsAutoMode !== true) {
+            this.options.logError(`permissions.defaultMode "auto" is not available for model ` +
+                `"${currentModelId}"; falling back to "${AUTO_MODE_FALLBACK}".`);
+            effectiveMode = AUTO_MODE_FALLBACK;
+            autoModeFallbackWarningPending = true;
+            await this.trySyncMode(query, effectiveMode, "Failed to sync clamped permissionMode to SDK:");
+        }
+        else if (!this.isAvailable(availableModes, effectiveMode)) {
+            this.options.logError(`permissions.defaultMode "${effectiveMode}" is not available in ` +
+                `this session; falling back to "default".`);
+            effectiveMode = "default";
+            await this.trySyncMode(query, effectiveMode, "Failed to sync clamped permissionMode to SDK:");
+        }
+        return {
+            modes: { currentModeId: effectiveMode, availableModes },
+            autoModeFallbackWarningPending,
+        };
+    }
+    static configOption(modes) {
+        return {
+            id: MODE_CONFIG_ID,
+            name: "Mode",
+            description: "Session permission mode",
+            category: "mode",
+            type: "select",
+            currentValue: modes.currentModeId,
+            options: modes.availableModes.map((mode) => ({
+                value: mode.id,
+                name: mode.name,
+                description: mode.description,
+                _meta: mode._meta,
+            })),
+        };
+    }
+    syncConfig(session, mode) {
+        session.modes = { ...session.modes, currentModeId: mode };
+        session.configOptions = session.configOptions.map((option) => option.id === MODE_CONFIG_ID && typeof option.currentValue === "string"
+            ? { ...option, currentValue: mode }
+            : option);
+    }
+    availableModeIds(modes) {
+        return modes.availableModes.map((mode) => mode.id);
+    }
+    effectiveMode(session, requestedMode) {
+        return requestedMode === "auto" && this.isAutoUnavailable(session)
+            ? AUTO_MODE_FALLBACK
+            : requestedMode;
+    }
+    applyPermissionFallback(session, permissionResult) {
+        const fallbackApplied = this.isAutoUnavailable(session) &&
+            permissionResult.behavior === "allow" &&
+            permissionResult.updatedPermissions?.some((update) => update.type === "setMode" && update.mode === "auto") === true;
+        if (!fallbackApplied || permissionResult.behavior !== "allow") {
+            return { permissionResult, fallbackApplied: false };
+        }
+        return {
+            permissionResult: {
+                ...permissionResult,
+                updatedPermissions: permissionResult.updatedPermissions?.map((update) => update.type === "setMode" && update.mode === "auto"
+                    ? { ...update, mode: AUTO_MODE_FALLBACK }
+                    : update),
+            },
+            fallbackApplied: true,
+        };
+    }
+    /** Reconcile mode after a model switch. The caller rebuilds config options
+     * before publishing the returned state change. */
+    async reconcileForModel(session, model) {
+        if (session.modes.currentModeId !== "auto" ||
+            model === undefined ||
+            model.supportsAutoMode === true) {
+            return false;
+        }
+        session.modes = {
+            availableModes: session.modes.availableModes,
+            currentModeId: AUTO_MODE_FALLBACK,
+        };
+        await this.trySyncMode(session.query, AUTO_MODE_FALLBACK, `Failed to sync permissionMode to "${AUTO_MODE_FALLBACK}" after model switch invalidated "auto":`);
+        return true;
+    }
+    async selectMode(sessionId, modeId) {
+        const session = this.requireOpenSession(sessionId);
+        const requestedMode = this.parseMode(modeId);
+        if (!this.isAvailable(session.modes.availableModes, requestedMode)) {
+            throw new Error(`Mode ${modeId} is not available in this session`);
+        }
+        const effectiveMode = this.effectiveMode(session, requestedMode);
+        try {
+            await session.query.setPermissionMode(effectiveMode);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (!error.message)
+                    error.message = "Invalid Mode";
+                throw error;
+            }
+            // eslint-disable-next-line preserve-caught-error
+            throw new Error("Invalid Mode");
+        }
+        if (effectiveMode !== requestedMode) {
+            await this.publishFallbackWarning(sessionId, session);
+        }
+        return effectiveMode;
+    }
+    async setSessionMode(params) {
+        const effectiveMode = await this.selectMode(params.sessionId, params.modeId);
+        if (effectiveMode !== params.modeId) {
+            await this.publishCurrent(params.sessionId, effectiveMode);
+        }
+        await this.options.updateConfigOption(params.sessionId, MODE_CONFIG_ID, effectiveMode);
+        return {};
+    }
+    async publishCurrent(sessionId, mode) {
+        await this.options.sessionUpdate({
+            sessionId,
+            update: { sessionUpdate: "current_mode_update", currentModeId: mode },
+        });
+    }
+    async publishFallbackWarning(sessionId, session) {
+        session.autoModeFallbackWarningPending = false;
+        if (session.autoModeFallbackWarningShown)
+            return;
+        session.autoModeFallbackWarningShown = true;
+        try {
+            await this.options.sessionUpdate({
+                sessionId,
+                update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: { type: "text", text: AUTO_MODE_FALLBACK_NOTICE },
+                },
+            });
+        }
+        catch (error) {
+            // The fallback has already been applied; a failed advisory must not turn
+            // the successful mode change into a failed request.
+            this.options.logError(`Failed to publish Auto mode fallback warning: ${error}`);
+        }
+    }
+    async publishFallbackState(sessionId, session) {
+        await this.publishCurrent(sessionId, AUTO_MODE_FALLBACK);
+        await this.publishFallbackWarning(sessionId, session);
+    }
+    requireOpenSession(sessionId) {
+        const session = this.options.getSession(sessionId);
+        if (!session)
+            throw new Error("Session not found");
+        if (session.queryClosed) {
+            throw RequestError.internalError(undefined, this.options.sessionEndedMessage);
+        }
+        return session;
+    }
+    isAutoUnavailable(session, modelId = session.models.currentModelId) {
+        const modelInfo = session.modelInfos.find((model) => model.value === modelId);
+        return modelInfo !== undefined && modelInfo.supportsAutoMode !== true;
+    }
+    isAvailable(availableModes, modeId) {
+        return availableModes.some((mode) => mode.id === modeId);
+    }
+    parseMode(modeId) {
+        switch (modeId) {
+            case "auto":
+            case "default":
+            case "acceptEdits":
+            case "bypassPermissions":
+            case "dontAsk":
+            case "plan":
+                return modeId;
+            default:
+                throw new Error("Invalid Mode");
+        }
+    }
+    buildAvailableModes() {
+        const modes = [
+            {
+                id: "default",
+                name: "Manual",
+                description: "Always ask before making changes",
+                _meta: { kind: "standard" },
+            },
+            {
+                id: "acceptEdits",
+                name: "Accept edits",
+                description: "Automatically accept all file edits",
+                _meta: { kind: "standard" },
+            },
+            {
+                id: "plan",
+                name: "Plan",
+                description: "Create a plan before making changes",
+                _meta: { kind: "plan" },
+            },
+            {
+                id: "auto",
+                name: "Auto",
+                description: "Claude handles permission decisions",
+                _meta: { kind: "auto_review" },
+            },
+        ];
+        if (ALLOW_BYPASS) {
+            modes.push({
+                id: "bypassPermissions",
+                name: "Bypass permissions",
+                description: "Accepts all permissions",
+                _meta: { kind: "full_access" },
+            });
+        }
+        return modes;
+    }
+    async trySyncMode(query, mode, errorMessage) {
+        try {
+            await query.setPermissionMode(mode);
+        }
+        catch (error) {
+            this.options.logError(errorMessage, error);
+        }
+    }
+}