@agentclientprotocol/claude-agent-acp 0.70.0 → 0.71.0

package/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);
+        }
+    }
+}

package/dist/session-titles.d.ts

@@ -0,0 +1,77 @@
+/**
+ * AI-generated session titles.
+ *
+ * Claude Code's own auto-title generation never runs under the Agent SDK — the
+ * latch that arms it is pre-set in the headless path — so `SDKSessionInfo.summary`
+ * degrades to the raw first prompt. This module asks the CLI for a real title
+ * instead, via the `generate_session_title` control request, and publishes it
+ * over ACP as a `session_info_update`.
+ *
+ * {@link SessionTitles} holds the per-session state and is owned by `Session`.
+ * `acp-agent.ts` drives it from four places: {@link SessionTitles.onPrompt} and
+ * {@link SessionTitles.onAssistantText} to collect text,
+ * {@link SessionTitles.onTurnEnd} at `session_state_changed: idle`, and
+ * {@link SessionTitles.reset} on `conversation_reset`.
+ */
+import type { ContentBlock, PromptRequest } from "@agentclientprotocol/sdk";
+import type { ClaudeAcpAgent, Session } from "./acp-agent.js";
+export declare function sanitizeTitle(text: string): string;
+/** Rolling text a title is generated from: `previous` plus `text`, keeping only
+ *  the trailing {@link MAX_TITLE_CONTEXT_LENGTH} characters. */
+export declare function appendTitleContext(previous: string | undefined, text: string): string;
+/** One session's title: the text a generated title is derived from, whether a
+ *  title has been settled on, and the last one published. Created with the
+ *  session and reachable as `session.titles`. */
+export declare class SessionTitles {
+    private readonly agent;
+    private readonly sessionId;
+    /** Last title pushed to the client via `session_info_update`, so an unchanged
+     *  title is never re-notified. Undefined until the first push. */
+    private lastTitle?;
+    /** Rolling tail of this session's own user + assistant text, capped at
+     *  {@link MAX_TITLE_CONTEXT_LENGTH}. Dropped once a title exists. */
+    private context?;
+    /** Set once this session has a title or has asked for one. A title is
+     *  generated at most once per session: the SDK reports a generated title in
+     *  the same field as a user `/rename`, so re-titling could silently overwrite
+     *  one. Released by {@link reset}, and when generation yields nothing. */
+    private settled;
+    constructor(agent: ClaudeAcpAgent, sessionId: string);
+    /** Collect a prompt's own text for the title, skipping openers not worth
+     *  titling after. No-op once the title is settled. */
+    onPrompt(prompt: PromptRequest["prompt"]): void;
+    /** Collect the assistant's own answer for the title. Chunks are appended
+     *  verbatim so streamed text reassembles. No-op once the title is settled. */
+    onAssistantText(content: ContentBlock): void;
+    /** Drop the title state so the next turn re-evaluates. Used on
+     *  `conversation_reset`, which mounts a fresh transcript. */
+    reset(): void;
+    /** Turn-end title handling. `idle` is the SDK's turn-over signal, so it is
+     *  when a title may have landed or become generatable.
+     *
+     *  `info.customTitle` is non-empty only once the session file holds a real
+     *  title — a user `/rename` or one generated earlier; the SDK folds both into
+     *  that one field. Adopt it and latch, so neither is ever titled over.
+     *
+     *  With no title yet, ask the SDK to generate one in the background: it is a
+     *  ~2s small-model call and turn-end must not wait on it. Only when that is
+     *  not possible do we fall back to `summary`, which for an SDK-driven session
+     *  is just the raw first prompt. */
+    onTurnEnd(session: Session): Promise<void>;
+    /** Read the SDK's stored info for this session. A missing session file or read
+     *  error is non-fatal: the title is best-effort and another turn will retry. */
+    private readSessionInfo;
+    /** Notify the client of a title, unless it is the one we last sent. */
+    private publish;
+    /** Whether to ask the SDK for a generated title now: once per session, on a
+     *  live query, with enough collected text for the generator to work with. */
+    private canRequest;
+    /** Generate a title from the session's own text and publish it. `persist`
+     *  writes it to the session file, which is what carries it into
+     *  `session/list` and `session/load`. A null or failed generation releases the
+     *  latch so a later turn retries, and publishes `fallback` (the stored
+     *  summary) so a backend that can't generate titles is no worse off than
+     *  before. */
+    private requestGenerateTitle;
+}
+//# sourceMappingURL=session-titles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-titles.d.ts","sourceRoot":"","sources":["../src/session-titles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE5E,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AA0B9D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUlD;AAED;gEACgE;AAChE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrF;AAOD;;iDAEiD;AACjD,qBAAa,aAAa;IAgBtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAhB5B;sEACkE;IAClE,OAAO,CAAC,SAAS,CAAC,CAAS;IAE3B;yEACqE;IACrE,OAAO,CAAC,OAAO,CAAC,CAAS;IAEzB;;;8EAG0E;IAC1E,OAAO,CAAC,OAAO,CAAS;gBAGL,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,MAAM;IAGpC;0DACsD;IACtD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,IAAI;IAW/C;kFAC8E;IAC9E,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAO5C;iEAC6D;IAC7D,KAAK,IAAI,IAAI;IAMb;;;;;;;;;;wCAUoC;IAC9B,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BhD;oFACgF;YAClE,eAAe;IAS7B,uEAAuE;YACzD,OAAO;IAgBrB;iFAC6E;IAC7E,OAAO,CAAC,UAAU;IAUlB;;;;;kBAKc;YACA,oBAAoB;CAoCnC"}

package/dist/session-titles.js

@@ -0,0 +1,199 @@
+/**
+ * AI-generated session titles.
+ *
+ * Claude Code's own auto-title generation never runs under the Agent SDK — the
+ * latch that arms it is pre-set in the headless path — so `SDKSessionInfo.summary`
+ * degrades to the raw first prompt. This module asks the CLI for a real title
+ * instead, via the `generate_session_title` control request, and publishes it
+ * over ACP as a `session_info_update`.
+ *
+ * {@link SessionTitles} holds the per-session state and is owned by `Session`.
+ * `acp-agent.ts` drives it from four places: {@link SessionTitles.onPrompt} and
+ * {@link SessionTitles.onAssistantText} to collect text,
+ * {@link SessionTitles.onTurnEnd} at `session_state_changed: idle`, and
+ * {@link SessionTitles.reset} on `conversation_reset`.
+ */
+import { getSessionInfo } from "@anthropic-ai/claude-agent-sdk";
+const MAX_TITLE_LENGTH = 256;
+/** How much session text the title is generated from. The CLI caps its own
+ *  title input at the same 1000 trailing characters. */
+const MAX_TITLE_CONTEXT_LENGTH = 1000;
+/** Below this the generator returns null without calling the model, so there is
+ *  nothing to gain by asking yet. */
+const MIN_TITLE_CONTEXT_LENGTH = 10;
+export function sanitizeTitle(text) {
+    // Replace newlines and collapse whitespace
+    const sanitized = text
+        .replace(/[\r\n]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (sanitized.length <= MAX_TITLE_LENGTH) {
+        return sanitized;
+    }
+    return sanitized.slice(0, MAX_TITLE_LENGTH - 1) + "…";
+}
+/** Rolling text a title is generated from: `previous` plus `text`, keeping only
+ *  the trailing {@link MAX_TITLE_CONTEXT_LENGTH} characters. */
+export function appendTitleContext(previous, text) {
+    const next = (previous ?? "") + text;
+    return next.length > MAX_TITLE_CONTEXT_LENGTH ? next.slice(-MAX_TITLE_CONTEXT_LENGTH) : next;
+}
+/** Whether this SDK still offers on-demand title generation. */
+function supportsTitleGeneration(query) {
+    return typeof query.generateSessionTitle === "function";
+}
+/** One session's title: the text a generated title is derived from, whether a
+ *  title has been settled on, and the last one published. Created with the
+ *  session and reachable as `session.titles`. */
+export class SessionTitles {
+    agent;
+    sessionId;
+    /** Last title pushed to the client via `session_info_update`, so an unchanged
+     *  title is never re-notified. Undefined until the first push. */
+    lastTitle;
+    /** Rolling tail of this session's own user + assistant text, capped at
+     *  {@link MAX_TITLE_CONTEXT_LENGTH}. Dropped once a title exists. */
+    context;
+    /** Set once this session has a title or has asked for one. A title is
+     *  generated at most once per session: the SDK reports a generated title in
+     *  the same field as a user `/rename`, so re-titling could silently overwrite
+     *  one. Released by {@link reset}, and when generation yields nothing. */
+    settled = false;
+    constructor(agent, sessionId) {
+        this.agent = agent;
+        this.sessionId = sessionId;
+    }
+    /** Collect a prompt's own text for the title, skipping openers not worth
+     *  titling after. No-op once the title is settled. */
+    onPrompt(prompt) {
+        if (this.settled) {
+            return;
+        }
+        const promptText = prompt
+            .flatMap((chunk) => (chunk.type === "text" ? [chunk.text] : []))
+            .join("\n");
+        this.context = appendTitleContext(this.context, `\n${promptText}\n`);
+    }
+    /** Collect the assistant's own answer for the title. Chunks are appended
+     *  verbatim so streamed text reassembles. No-op once the title is settled. */
+    onAssistantText(content) {
+        if (this.settled || content.type !== "text") {
+            return;
+        }
+        this.context = appendTitleContext(this.context, content.text);
+    }
+    /** Drop the title state so the next turn re-evaluates. Used on
+     *  `conversation_reset`, which mounts a fresh transcript. */
+    reset() {
+        this.settled = false;
+        this.context = undefined;
+        this.lastTitle = undefined;
+    }
+    /** Turn-end title handling. `idle` is the SDK's turn-over signal, so it is
+     *  when a title may have landed or become generatable.
+     *
+     *  `info.customTitle` is non-empty only once the session file holds a real
+     *  title — a user `/rename` or one generated earlier; the SDK folds both into
+     *  that one field. Adopt it and latch, so neither is ever titled over.
+     *
+     *  With no title yet, ask the SDK to generate one in the background: it is a
+     *  ~2s small-model call and turn-end must not wait on it. Only when that is
+     *  not possible do we fall back to `summary`, which for an SDK-driven session
+     *  is just the raw first prompt. */
+    async onTurnEnd(session) {
+        const info = await this.readSessionInfo(session);
+        if (info?.customTitle) {
+            this.settled = true;
+            this.context = undefined;
+            await this.publish(info.customTitle, info.lastModified);
+            return;
+        }
+        const fallback = info?.summary
+            ? { title: info.summary, lastModified: info.lastModified }
+            : undefined;
+        if (this.canRequest(session)) {
+            this.settled = true;
+            void this.requestGenerateTitle(session, fallback).catch((error) => {
+                this.agent.logger.error(`Session ${this.sessionId}: session title update failed: ${error}`);
+            });
+            return;
+        }
+        // Only while this session has no title of its own: `summary` degrades to the
+        // raw first prompt, which must never overwrite a generated title if the
+        // persisted one is slow to show up in `info`.
+        if (fallback && !this.settled) {
+            await this.publish(fallback.title, fallback.lastModified);
+        }
+    }
+    /** Read the SDK's stored info for this session. A missing session file or read
+     *  error is non-fatal: the title is best-effort and another turn will retry. */
+    async readSessionInfo(session) {
+        try {
+            return await getSessionInfo(this.sessionId, { dir: session.cwd });
+        }
+        catch (error) {
+            this.agent.logger.error(`Session ${this.sessionId}: failed to read session info: ${error}`);
+            return undefined;
+        }
+    }
+    /** Notify the client of a title, unless it is the one we last sent. */
+    async publish(rawTitle, lastModified) {
+        const title = sanitizeTitle(rawTitle);
+        if (title === this.lastTitle) {
+            return;
+        }
+        this.lastTitle = title;
+        await this.agent.client.sessionUpdate({
+            sessionId: this.sessionId,
+            update: {
+                sessionUpdate: "session_info_update",
+                title,
+                updatedAt: new Date(lastModified).toISOString(),
+            },
+        });
+    }
+    /** Whether to ask the SDK for a generated title now: once per session, on a
+     *  live query, with enough collected text for the generator to work with. */
+    canRequest(session) {
+        if (this.settled || session.queryClosed || session.cancelled) {
+            return false;
+        }
+        if (!supportsTitleGeneration(session.query)) {
+            return false;
+        }
+        return (this.context?.trim().length ?? 0) >= MIN_TITLE_CONTEXT_LENGTH;
+    }
+    /** Generate a title from the session's own text and publish it. `persist`
+     *  writes it to the session file, which is what carries it into
+     *  `session/list` and `session/load`. A null or failed generation releases the
+     *  latch so a later turn retries, and publishes `fallback` (the stored
+     *  summary) so a backend that can't generate titles is no worse off than
+     *  before. */
+    async requestGenerateTitle(session, fallback) {
+        const description = this.context?.trim() ?? "";
+        let title = null;
+        try {
+            title =
+                (await session.query.generateSessionTitle?.(description, {
+                    persist: true,
+                })) ?? null;
+        }
+        catch (error) {
+            this.agent.logger.error(`Session ${this.sessionId}: failed to generate a session title: ${error}`);
+        }
+        // A session torn down or replaced while the title was in flight must not
+        // adopt it.
+        if (this.agent.sessions[this.sessionId] !== session) {
+            return;
+        }
+        if (!title) {
+            this.settled = false;
+            if (fallback) {
+                await this.publish(fallback.title, fallback.lastModified);
+            }
+            return;
+        }
+        this.context = undefined;
+        await this.publish(title, Date.now());
+    }
+}

package/dist/tool-result-meta.d.ts

@@ -0,0 +1,8 @@
+export type ToolResultMeta = {
+    nonExecutionKind: string;
+    userFeedback?: string;
+};
+/** Validate the SDK's currently untyped tool_result_meta sidecar. Unknown
+ * non-execution kinds are preserved so newer CLIs remain forward-compatible. */
+export declare function parseToolResultMeta(raw: unknown): Map<string, ToolResultMeta> | undefined;
+//# sourceMappingURL=tool-result-meta.d.ts.map

package/dist/tool-result-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-meta.d.ts","sourceRoot":"","sources":["../src/tool-result-meta.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;gFACgF;AAChF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,SAAS,CAczF"}

package/dist/tool-result-meta.js

@@ -0,0 +1,19 @@
+/** Validate the SDK's currently untyped tool_result_meta sidecar. Unknown
+ * non-execution kinds are preserved so newer CLIs remain forward-compatible. */
+export function parseToolResultMeta(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    let byToolUseId;
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const { id, non_execution_kind, user_feedback } = entry;
+        if (typeof id !== "string" || typeof non_execution_kind !== "string")
+            continue;
+        (byToolUseId ??= new Map()).set(id, {
+            nonExecutionKind: non_execution_kind,
+            ...(typeof user_feedback === "string" ? { userFeedback: user_feedback } : {}),
+        });
+    }
+    return byToolUseId;
+}

package/dist/tools.d.ts

@@ -78,7 +78,12 @@ export declare function toolUpdateFromDiffToolResponse(toolResponse: unknown): {
 };
 export declare const registerHookCallback: (toolUseID: string, { onPostToolUseHook, }: {
     onPostToolUseHook?: (toolUseID: string, toolInput: unknown, toolResponse: unknown) => Promise<void>;
-}) => void;
+}, ownerId?: string) => void;
+export declare function unregisterHookCallback(toolUseID: string): void;
+/** PostToolUse normally follows tool_result, so keep the callback for a short
+ * grace period while still bounding retention when the hook never arrives. */
+export declare function completeHookCallback(toolUseID: string): void;
+export declare function clearHookCallbacks(ownerId: string): void;
 export declare const createPostToolUseHook: (options?: {
     onEnterPlanMode?: () => Promise<void>;
 }) => HookCallback;

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}

package/dist/tools.js

@@ -211,15 +211,8 @@ export function toolInfoFromToolUse(toolUse, supportsTerminalOutput = false, cwd
         }
         case "WebSearch": {
             const input = toolUse.input;
-            let label = input?.query ? `"${input.query}"` : "Web search";
-            if (input?.allowed_domains && input.allowed_domains.length > 0) {
-                label += ` (allowed: ${input.allowed_domains.join(", ")})`;
-            }
-            if (input?.blocked_domains && input.blocked_domains.length > 0) {
-                label += ` (blocked: ${input.blocked_domains.join(", ")})`;
-            }
             return {
-                title: label,
+                title: input?.query ? `Search "${input.query}"` : "Web search",
                 kind: "fetch",
                 content: [],
             };
@@ -284,7 +277,7 @@ export function toolInfoFromToolUse(toolUse, supportsTerminalOutput = false, cwd
         case "ExitPlanMode": {
             const planInput = toolUse.input;
             return {
-                title: "Ready to code?",
+                title: "Approve Plan",
                 kind: "switch_mode",
                 content: planInput?.plan
                     ? [{ type: "content", content: { type: "text", text: planInput.plan } }]
@@ -1047,14 +1040,38 @@ export function toolUpdateFromDiffToolResponse(toolResponse) {
         result.locations = locations;
     return result;
 }
-/* A global variable to store callbacks that should be executed when receiving hooks from Claude Code */
-const toolUseCallbacks = {};
+/* Callbacks are keyed globally because the SDK hook is process-wide, but each
+ * entry retains its owning ACP session so cancellation/teardown can release it. */
+const toolUseCallbacks = new Map();
 /* Setup callbacks that will be called when receiving hooks from Claude Code */
-export const registerHookCallback = (toolUseID, { onPostToolUseHook, }) => {
-    toolUseCallbacks[toolUseID] = {
+export const registerHookCallback = (toolUseID, { onPostToolUseHook, }, ownerId) => {
+    unregisterHookCallback(toolUseID);
+    toolUseCallbacks.set(toolUseID, {
+        ownerId,
         onPostToolUseHook,
-    };
+    });
 };
+export function unregisterHookCallback(toolUseID) {
+    const callback = toolUseCallbacks.get(toolUseID);
+    if (callback?.cleanupTimer)
+        clearTimeout(callback.cleanupTimer);
+    toolUseCallbacks.delete(toolUseID);
+}
+/** PostToolUse normally follows tool_result, so keep the callback for a short
+ * grace period while still bounding retention when the hook never arrives. */
+export function completeHookCallback(toolUseID) {
+    const callback = toolUseCallbacks.get(toolUseID);
+    if (!callback || callback.cleanupTimer)
+        return;
+    callback.cleanupTimer = setTimeout(() => unregisterHookCallback(toolUseID), 30_000);
+    callback.cleanupTimer.unref?.();
+}
+export function clearHookCallbacks(ownerId) {
+    for (const [toolUseID, callback] of toolUseCallbacks) {
+        if (callback.ownerId === ownerId)
+            unregisterHookCallback(toolUseID);
+    }
+}
 /* A callback for Claude Code that is called when receiving a PostToolUse hook */
 export const createPostToolUseHook = (options) => async (input, toolUseID) => {
     if (input.hook_event_name === "PostToolUse") {
@@ -1063,11 +1080,15 @@ export const createPostToolUseHook = (options) => async (input, toolUseID) => {
             await options.onEnterPlanMode();
         }
         if (toolUseID) {
-            const onPostToolUseHook = toolUseCallbacks[toolUseID]?.onPostToolUseHook;
-            if (onPostToolUseHook) {
-                await onPostToolUseHook(toolUseID, input.tool_input, input.tool_response);
+            const onPostToolUseHook = toolUseCallbacks.get(toolUseID)?.onPostToolUseHook;
+            try {
+                if (onPostToolUseHook) {
+                    await onPostToolUseHook(toolUseID, input.tool_input, input.tool_response);
+                }
+            }
+            finally {
+                unregisterHookCallback(toolUseID);
             }
-            delete toolUseCallbacks[toolUseID]; // Cleanup after execution
         }
     }
     return { continue: true };