@lucascouts/claude-agent-acp-plus 0.8.0 → 0.9.0

package/dist/session-failure-extension.js

@@ -0,0 +1,352 @@
+import { USAGE_LIMIT_ERROR_PREFIXES, } from "@anthropic-ai/claude-agent-sdk";
+import { randomUUID } from "node:crypto";
+const JETBRAINS_META_KEY = "jetbrains";
+const AIR_META_KEY = "air";
+const AIR_EXTENSION_VERSION_KEY = "version";
+const AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
+const AIR_SESSION_FAILURE_KEY = "sessionFailure";
+const AIR_EXTENSION_VERSION = 1;
+export function airSessionFailureCapabilityMeta(...additionalCapabilities) {
+    return {
+        [JETBRAINS_META_KEY]: {
+            [AIR_META_KEY]: {
+                [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+                [AIR_EXTENSION_CAPABILITIES_KEY]: [AIR_SESSION_FAILURE_KEY, ...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 {
+        [JETBRAINS_META_KEY]: {
+            [AIR_META_KEY]: {
+                [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+                [AIR_SESSION_FAILURE_KEY]: {
+                    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) {
+    const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
+    const air = jetbrains?.[AIR_META_KEY];
+    const version = air?.[AIR_EXTENSION_VERSION_KEY];
+    const advertised = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
+    return (typeof version === "number" &&
+        Number.isFinite(version) &&
+        Number.isInteger(version) &&
+        version >= AIR_EXTENSION_VERSION &&
+        Array.isArray(advertised) &&
+        advertised.some((capability) => capability === AIR_SESSION_FAILURE_KEY));
+}
+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/dist/session-mode.d.ts

@@ -0,0 +1,66 @@
+import { type SessionConfigOption, type SessionModeState, type SessionNotification, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import type { ModelInfo, PermissionMode, PermissionResult, Query } from "@anthropic-ai/claude-agent-sdk";
+export declare const MODE_CONFIG_ID = "mode";
+export declare const AUTO_MODE_FALLBACK: PermissionMode;
+export type SessionMode = {
+    query: Pick<Query, "setPermissionMode">;
+    queryClosed?: boolean;
+    modes: SessionModeState;
+    models: {
+        currentModelId: string;
+    };
+    modelInfos: ModelInfo[];
+    /** Prevents the model-specific Auto fallback from spamming the transcript. */
+    autoModeFallbackWarningShown?: boolean;
+    /** Initial mode fallback is reported after session/new, on the first prompt. */
+    autoModeFallbackWarningPending?: boolean;
+};
+export type SessionModeManagerOptions<S extends SessionMode> = {
+    getSession(sessionId: string): S | undefined;
+    sessionEndedMessage: string;
+    updateConfigOption(sessionId: string, configId: string, value: string): Promise<void>;
+    sessionUpdate(params: SessionNotification): Promise<void>;
+    logError(...args: unknown[]): void;
+};
+type ModeConfigSession = SessionMode & {
+    configOptions: SessionConfigOption[];
+};
+type InitializeSessionModeParams = {
+    query: Pick<Query, "setPermissionMode">;
+    requestedMode: PermissionMode;
+    currentModelInfo?: ModelInfo;
+    currentModelId: string;
+};
+/** Owns session-mode policy and the ACP/SDK synchronization it requires. */
+export declare class SessionModeManager<S extends SessionMode> {
+    private readonly options;
+    constructor(options: SessionModeManagerOptions<S>);
+    initialize({ query, requestedMode, currentModelInfo, currentModelId, }: InitializeSessionModeParams): Promise<{
+        modes: SessionModeState;
+        autoModeFallbackWarningPending: boolean;
+    }>;
+    static configOption(modes: SessionModeState): SessionConfigOption;
+    syncConfig(session: ModeConfigSession, mode: string): void;
+    availableModeIds(modes: SessionModeState): string[];
+    effectiveMode(session: SessionMode, requestedMode: PermissionMode): PermissionMode;
+    applyPermissionFallback(session: SessionMode, permissionResult: PermissionResult): {
+        permissionResult: PermissionResult;
+        fallbackApplied: boolean;
+    };
+    /** Reconcile mode after a model switch. The caller rebuilds config options
+     * before publishing the returned state change. */
+    reconcileForModel(session: SessionMode, model: ModelInfo | undefined): Promise<boolean>;
+    selectMode(sessionId: string, modeId: string): Promise<PermissionMode>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    publishCurrent(sessionId: string, mode: string): Promise<void>;
+    publishFallbackWarning(sessionId: string, session: SessionMode): Promise<void>;
+    publishFallbackState(sessionId: string, session: SessionMode): Promise<void>;
+    private requireOpenSession;
+    private isAutoUnavailable;
+    private isAvailable;
+    private parseMode;
+    private buildAvailableModes;
+    private trySyncMode;
+}
+export {};
+//# sourceMappingURL=session-mode.d.ts.map

package/dist/session-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-mode.d.ts","sourceRoot":"","sources":["../src/session-mode.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,KAAK,EACN,MAAM,gCAAgC,CAAC;AAGxC,eAAO,MAAM,cAAc,SAAS,CAAC;AACrC,eAAO,MAAM,kBAAkB,EAAE,cAA8B,CAAC;AAKhE,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,8EAA8E;IAC9E,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,gFAAgF;IAChF,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,WAAW,IAAI;IAC7D,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAC7C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtF,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,QAAQ,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CACpC,CAAC;AAEF,KAAK,iBAAiB,GAAG,WAAW,GAAG;IACrC,aAAa,EAAE,mBAAmB,EAAE,CAAC;CACtC,CAAC;AAEF,KAAK,2BAA2B,GAAG;IACjC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;IACxC,aAAa,EAAE,cAAc,CAAC;IAC9B,gBAAgB,CAAC,EAAE,SAAS,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,4EAA4E;AAC5E,qBAAa,kBAAkB,CAAC,CAAC,SAAS,WAAW;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,yBAAyB,CAAC,CAAC,CAAC;IAE5D,UAAU,CAAC,EACf,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,cAAc,GACf,EAAE,2BAA2B,GAAG,OAAO,CAAC;QACvC,KAAK,EAAE,gBAAgB,CAAC;QACxB,8BAA8B,EAAE,OAAO,CAAC;KACzC,CAAC;IAgCF,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,mBAAmB;IAiBjE,UAAU,CAAC,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAS1D,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,EAAE;IAInD,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,GAAG,cAAc;IAMlF,uBAAuB,CACrB,OAAO,EAAE,WAAW,EACpB,gBAAgB,EAAE,gBAAgB,GACjC;QAAE,gBAAgB,EAAE,gBAAgB,CAAC;QAAC,eAAe,EAAE,OAAO,CAAA;KAAE;IAwBnE;sDACkD;IAC5C,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS;IAqBpE,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAyBtE,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAS9E,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO9D,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB9E,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAKlF,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,mBAAmB;YAkDb,WAAW;CAW1B"}

package/dist/session-mode.js

@@ -0,0 +1,246 @@
+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" },
+            },
+            // Fork override, re-implanted here from the pre-merge `buildAvailableModes`
+            // in `acp-agent.ts`: upstream accepts `dontAsk` in `parseMode` but never
+            // advertises it, so adopting upstream's catalog wholesale would silently
+            // drop a mode the fork has offered since story 006 (R2.5 names it).
+            // No `_meta.kind` is set: upstream's four kinds all describe a mode that
+            // asks or auto-approves, and `dontAsk` denies instead — claiming any of
+            // them would assert a semantic upstream has not defined for this mode.
+            {
+                id: "dontAsk",
+                name: "Don't Ask",
+                description: "Don't prompt for permissions, deny if not pre-approved",
+            },
+        ];
+        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);
+        }
+    }
+}