@agentclientprotocol/claude-agent-acp 0.74.0 → 0.75.1

package/dist/auth-status.d.ts

@@ -0,0 +1,140 @@
+/**
+ * `authStatus` — interim `_meta`-based ACP extension that reports which auth
+ * identity the agent process itself uses (Claude subscription, API key,
+ * gateway, external cloud credentials, or nothing).
+ *
+ * Push only. One carrier, connection-scoped (never per session): the
+ * notification `_auth/status_update` → `{authStatus}`. The client never asks;
+ * there is no request method. The empty `agentCapabilities._meta.authStatus`
+ * marker means "this agent pushes its identity", nothing more.
+ *
+ * The agent reads the identity at these moments:
+ * - `initialize`, with an asynchronous CLI probe. Nothing waits for it, and its
+ *   result is the first push of the connection;
+ * - a completed `authenticate` or a `logout`;
+ * - each `createSession`, from the session account. A refused session reports
+ *   too: the client must know which account was refused;
+ * - each turn the `--hide-claude-auth` guard checks. The guard reads the
+ *   account anyway, so this costs nothing;
+ * - the START of each user prompt, with an asynchronous CLI probe. This finds a
+ *   login or a logout done in another terminal, including the sign-in a client
+ *   performs after a refusal, because the retried prompt is a new prompt.
+ *   Nothing waits for it and the push goes out mid-turn if that is when the
+ *   read lands.
+ *
+ * A probe whose kind differs from a live session's account marks that session
+ * for recreation under `--hide-claude-auth`. The mark is a flag, consumed at
+ * the next turn boundary: a running turn is never interrupted. The probe judges
+ * nothing itself — the next turn runs a new `initialize`, and the creation
+ * guard decides on the account it reports.
+ *
+ * A read does not always cause a push. The agent sends `_auth/status_update`
+ * only when the payload is different from the last one it sent.
+ *
+ * "Cannot determine" is expressed by silence: an agent that cannot read its own
+ * identity pushes nothing, and the client shows "not reported". A known
+ * logged-out state is a payload of its own (`kind: "none"`), which is what
+ * distinguishes the two.
+ *
+ * Reporting only — there is no write path in v1. When the upstream RFD lands,
+ * the same payload moves from `_meta` to first-class fields and this module
+ * is retired.
+ */
+import type { AccountInfo } from "@anthropic-ai/claude-agent-sdk";
+/** Change notification, agent → client. Fire and forget: clients that do not
+ *  know the method drop it silently, so it is sent unconditionally. */
+export declare const AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
+/** Upper bound on one `claude auth status --json` run, so a hung CLI cannot
+ *  wedge every later probe that joins it. */
+export declare const AUTH_STATUS_PROBE_TIMEOUT_MS = 5000;
+export type AuthStatusKind = "account" | "api_key" | "gateway" | "external" | "none";
+export type AuthStatusAccount = {
+    email?: string;
+    organization?: string;
+    /** Vendor plan/license string, not normalized. */
+    plan?: string;
+};
+export type AuthStatus = {
+    kind: AuthStatusKind;
+    /** Human-readable and usable as a UI string on its own. The "type" line:
+     *  "Claude Max", "Anthropic API key", "AWS Bedrock". */
+    label: string;
+    /** Optional second line carrying the specifics (key source, gateway host, …).
+     *  Clients render it under `label`, falling back to `account.email`. */
+    detail?: string;
+    account?: AuthStatusAccount;
+    /** Vendor-namespaced extras, e.g. `{claudeCode: {...}}`. */
+    vendor?: Record<string, unknown>;
+};
+export type AuthStatusUpdateNotification = {
+    authStatus: AuthStatus;
+};
+/** Advertisement carried in `agentCapabilities._meta.authStatus`, never a
+ *  status payload: its mere presence means "this agent pushes its identity",
+ *  and it stays empty. Informational — a client that never saw it still
+ *  accepts `_auth/status_update`, because there is nothing to ask for. */
+export type AuthStatusCapability = Record<string, never>;
+export declare function authStatusCapability(): AuthStatusCapability;
+/** Shape of `claude auth status --json`. Absent fields are omitted, not null,
+ *  and the logged-out case exits 1 while still printing valid JSON. */
+export type CliAuthStatus = {
+    loggedIn?: boolean;
+    authMethod?: string;
+    apiProvider?: string;
+    apiKeySource?: string;
+    email?: string;
+    orgId?: string;
+    orgName?: string;
+    subscriptionType?: string;
+};
+export declare function notLoggedInAuthStatus(): AuthStatus;
+/** ACP-level gateway auth (`authenticate` with `gateway`/`gateway-bedrock`).
+ *  The gateway owns the credentials, so it wins over anything the CLI reports. */
+export declare function gatewayAuthStatus(baseUrl?: string): AuthStatus;
+/**
+ * Does this `AccountInfo` say anything about the identity?
+ *
+ * The SDK always fills `apiProvider`, but the identity fields come from the
+ * claude.ai profile: with an `apiKeyHelper` and no subscription login the
+ * session reports `{apiProvider: "firstParty"}` and nothing else. That is "no
+ * information", not "logged out" — an empty read must never be mapped to
+ * `none`, or it destroys what the CLI probe already established.
+ *
+ * `tokenSource` is deliberately not a signal: the CLI sets it to the OAuth
+ * token's origin (`CLAUDE_CODE_OAUTH_TOKEN`,
+ * `CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR`, …), never to a key source, so it
+ * cannot attribute a key and carries no plan of its own.
+ */
+export declare function accountInfoHasIdentitySignal(account: AccountInfo | undefined): boolean;
+/** Session-time mapping from the SDK's `AccountInfo`, the richest source when
+ *  it is populated. Returns `undefined` when the account carries no identity
+ *  signal, so callers keep the status they already know. */
+export declare function fromAccountInfo(account: AccountInfo | undefined): AuthStatus | undefined;
+/** Pre-session mapping from `claude auth status --json` stdout. Returns
+ *  `undefined` when the output is not the expected JSON object, so callers can
+ *  report "not known" instead of guessing. */
+export declare function fromCliStatus(stdout: string): AuthStatus | undefined;
+/**
+ * Do two payloads describe the same login? Compared on the field that
+ * identifies each kind — the key source for `api_key`, the email for
+ * `account`, the kind alone for the rest, which carry no per-identity key.
+ */
+export declare function sameIdentity(a: AuthStatus, b: AuthStatus): boolean;
+/**
+ * Folds a fresh read into what is already known. Sources differ in richness for
+ * the very same login: the SDK's session `AccountInfo` can carry an
+ * organization the CLI probe omits. So when the read describes the same
+ * identity, its values win field by field but the fields it lacks are kept;
+ * when it describes a different identity, it replaces the old one wholesale.
+ */
+export declare function mergeAuthStatus(previous: AuthStatus | undefined, next: AuthStatus): AuthStatus;
+/**
+ * Do two payloads carry the same information? Unlike {@link sameIdentity},
+ * which asks "is this the same login", this compares every rendered field, so
+ * a richer read of one login is NOT the same. Callers use it to suppress a
+ * push that would tell the client nothing new.
+ *
+ * `a` undefined means "nothing reported yet", which never equals a payload.
+ */
+export declare function sameAuthStatus(a: AuthStatus | undefined, b: AuthStatus): boolean;
+//# sourceMappingURL=auth-status.d.ts.map

package/dist/auth-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-status.d.ts","sourceRoot":"","sources":["../src/auth-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE;uEACuE;AACvE,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D;6CAC6C;AAC7C,eAAO,MAAM,4BAA4B,OAAO,CAAC;AAEjD,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;AAErF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,cAAc,CAAC;IACrB;4DACwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd;4EACwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IAAE,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAEtE;;;0EAG0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEzD,wBAAgB,oBAAoB,IAAI,oBAAoB,CAE3D;AAED;uEACuE;AACvE,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkBF,wBAAgB,qBAAqB,IAAI,UAAU,CAElD;AAED;kFACkF;AAClF,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAc9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAOtF;AAED;;4DAE4D;AAC5D,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAWxF;AAED;;8CAE8C;AAC9C,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CA4BpE;AA6DD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAYlE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,GAAG,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAe9F;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAgBhF"}

package/dist/auth-status.js

@@ -0,0 +1,271 @@
+/**
+ * `authStatus` — interim `_meta`-based ACP extension that reports which auth
+ * identity the agent process itself uses (Claude subscription, API key,
+ * gateway, external cloud credentials, or nothing).
+ *
+ * Push only. One carrier, connection-scoped (never per session): the
+ * notification `_auth/status_update` → `{authStatus}`. The client never asks;
+ * there is no request method. The empty `agentCapabilities._meta.authStatus`
+ * marker means "this agent pushes its identity", nothing more.
+ *
+ * The agent reads the identity at these moments:
+ * - `initialize`, with an asynchronous CLI probe. Nothing waits for it, and its
+ *   result is the first push of the connection;
+ * - a completed `authenticate` or a `logout`;
+ * - each `createSession`, from the session account. A refused session reports
+ *   too: the client must know which account was refused;
+ * - each turn the `--hide-claude-auth` guard checks. The guard reads the
+ *   account anyway, so this costs nothing;
+ * - the START of each user prompt, with an asynchronous CLI probe. This finds a
+ *   login or a logout done in another terminal, including the sign-in a client
+ *   performs after a refusal, because the retried prompt is a new prompt.
+ *   Nothing waits for it and the push goes out mid-turn if that is when the
+ *   read lands.
+ *
+ * A probe whose kind differs from a live session's account marks that session
+ * for recreation under `--hide-claude-auth`. The mark is a flag, consumed at
+ * the next turn boundary: a running turn is never interrupted. The probe judges
+ * nothing itself — the next turn runs a new `initialize`, and the creation
+ * guard decides on the account it reports.
+ *
+ * A read does not always cause a push. The agent sends `_auth/status_update`
+ * only when the payload is different from the last one it sent.
+ *
+ * "Cannot determine" is expressed by silence: an agent that cannot read its own
+ * identity pushes nothing, and the client shows "not reported". A known
+ * logged-out state is a payload of its own (`kind: "none"`), which is what
+ * distinguishes the two.
+ *
+ * Reporting only — there is no write path in v1. When the upstream RFD lands,
+ * the same payload moves from `_meta` to first-class fields and this module
+ * is retired.
+ */
+/** Change notification, agent → client. Fire and forget: clients that do not
+ *  know the method drop it silently, so it is sent unconditionally. */
+export const AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
+/** Upper bound on one `claude auth status --json` run, so a hung CLI cannot
+ *  wedge every later probe that joins it. */
+export const AUTH_STATUS_PROBE_TIMEOUT_MS = 5000;
+export function authStatusCapability() {
+    return {};
+}
+const NOT_LOGGED_IN = {
+    kind: "none",
+    label: "Not logged in",
+};
+/** Display names for the non-firstParty backends, where auth lives outside the
+ *  agent (AWS credentials, gcloud ADC, …). */
+const EXTERNAL_PROVIDER_LABELS = {
+    bedrock: "AWS Bedrock",
+    vertex: "Google Vertex AI",
+    foundry: "Azure AI Foundry",
+    anthropicAws: "Anthropic on AWS",
+    anthropicGoogleCloud: "Anthropic on Google Cloud",
+    mantle: "Mantle",
+};
+export function notLoggedInAuthStatus() {
+    return { ...NOT_LOGGED_IN };
+}
+/** ACP-level gateway auth (`authenticate` with `gateway`/`gateway-bedrock`).
+ *  The gateway owns the credentials, so it wins over anything the CLI reports. */
+export function gatewayAuthStatus(baseUrl) {
+    let host;
+    if (baseUrl) {
+        try {
+            host = new URL(baseUrl).host;
+        }
+        catch {
+            host = baseUrl;
+        }
+    }
+    return {
+        kind: "gateway",
+        label: "Custom model gateway",
+        ...(host ? { detail: host } : {}),
+    };
+}
+/**
+ * Does this `AccountInfo` say anything about the identity?
+ *
+ * The SDK always fills `apiProvider`, but the identity fields come from the
+ * claude.ai profile: with an `apiKeyHelper` and no subscription login the
+ * session reports `{apiProvider: "firstParty"}` and nothing else. That is "no
+ * information", not "logged out" — an empty read must never be mapped to
+ * `none`, or it destroys what the CLI probe already established.
+ *
+ * `tokenSource` is deliberately not a signal: the CLI sets it to the OAuth
+ * token's origin (`CLAUDE_CODE_OAUTH_TOKEN`,
+ * `CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR`, …), never to a key source, so it
+ * cannot attribute a key and carries no plan of its own.
+ */
+export function accountInfoHasIdentitySignal(account) {
+    if (!account)
+        return false;
+    return Boolean(account.apiKeySource ||
+        account.subscriptionType ||
+        (account.apiProvider && account.apiProvider !== "firstParty"));
+}
+/** Session-time mapping from the SDK's `AccountInfo`, the richest source when
+ *  it is populated. Returns `undefined` when the account carries no identity
+ *  signal, so callers keep the status they already know. */
+export function fromAccountInfo(account) {
+    if (!account || !accountInfoHasIdentitySignal(account)) {
+        return undefined;
+    }
+    return mapAuthFields({
+        apiProvider: account.apiProvider,
+        subscriptionType: account.subscriptionType,
+        apiKeySource: account.apiKeySource,
+        email: account.email,
+        organization: account.organization,
+    });
+}
+/** Pre-session mapping from `claude auth status --json` stdout. Returns
+ *  `undefined` when the output is not the expected JSON object, so callers can
+ *  report "not known" instead of guessing. */
+export function fromCliStatus(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const status = parsed;
+    if (typeof status.loggedIn !== "boolean") {
+        return undefined;
+    }
+    // `loggedIn` tracks the claude.ai login only. On a 3P backend (Bedrock,
+    // Vertex, …) it is false while the credentials live outside the agent, so the
+    // backend must decide the kind before the logged-out shortcut runs.
+    const externalBackend = Boolean(status.apiProvider && status.apiProvider !== "firstParty");
+    if (!externalBackend && !status.loggedIn && !status.apiKeySource) {
+        return notLoggedInAuthStatus();
+    }
+    return mapAuthFields({
+        apiProvider: status.apiProvider,
+        subscriptionType: status.subscriptionType,
+        apiKeySource: status.apiKeySource,
+        email: status.email,
+        organization: status.orgName,
+    });
+}
+/** Single mapping table shared by both sources; see the `kind`/`label` table in
+ *  `extension-authstatus-meta.md`. Order matters: a 3P backend or a gateway
+ *  decides the kind before any firstParty identity fields are considered, and
+ *  an API key outranks a stored subscription login.
+ *
+ *  Both can be reported at once — an `apiKeyHelper` in settings.json next to a
+ *  claude.ai OAuth login yields `apiKeySource` AND `subscriptionType`. Claude
+ *  Code's authentication precedence puts `apiKeyHelper` above the `/login`
+ *  subscription, so the key is what actually pays for the turn and is what we
+ *  report. */
+function mapAuthFields(fields) {
+    const { apiProvider, subscriptionType, apiKeySource, email, organization } = fields;
+    if (apiProvider === "gateway") {
+        return gatewayAuthStatus();
+    }
+    if (apiProvider && apiProvider !== "firstParty") {
+        return {
+            kind: "external",
+            label: EXTERNAL_PROVIDER_LABELS[apiProvider] ?? apiProvider,
+        };
+    }
+    if (apiKeySource) {
+        return {
+            kind: "api_key",
+            label: "Anthropic API key",
+            // The source ("apiKeyHelper", "env", …) is the specifics line.
+            detail: apiKeySource,
+        };
+    }
+    if (subscriptionType) {
+        // `account.plan` keeps the raw vendor string; only the label is titled.
+        const account = { plan: subscriptionType };
+        if (email)
+            account.email = email;
+        if (organization)
+            account.organization = organization;
+        return {
+            kind: "account",
+            label: planLabel(subscriptionType),
+            // No detail: the client falls back to `account.email` for line 2.
+            account,
+        };
+    }
+    return notLoggedInAuthStatus();
+}
+/** Names the plan with exactly one "Claude". A newer CLI already reports
+ *  "Claude Max", an older one reports "max", and both must read "Claude Max".
+ *  Each word is title-cased; a word that already carries capitals is kept. */
+function planLabel(plan) {
+    const titled = plan.replace(/\S+/g, (word) => word.charAt(0).toUpperCase() + word.slice(1));
+    return /^claude(\s|$)/i.test(plan) ? titled : `Claude ${titled}`;
+}
+/**
+ * Do two payloads describe the same login? Compared on the field that
+ * identifies each kind — the key source for `api_key`, the email for
+ * `account`, the kind alone for the rest, which carry no per-identity key.
+ */
+export function sameIdentity(a, b) {
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    switch (a.kind) {
+        case "api_key":
+            return a.detail === b.detail;
+        case "account":
+            return (a.account?.email ?? "") === (b.account?.email ?? "");
+        default:
+            return true;
+    }
+}
+/**
+ * Folds a fresh read into what is already known. Sources differ in richness for
+ * the very same login: the SDK's session `AccountInfo` can carry an
+ * organization the CLI probe omits. So when the read describes the same
+ * identity, its values win field by field but the fields it lacks are kept;
+ * when it describes a different identity, it replaces the old one wholesale.
+ */
+export function mergeAuthStatus(previous, next) {
+    if (!previous || !sameIdentity(previous, next)) {
+        return next;
+    }
+    const merged = { ...next };
+    if (merged.detail === undefined && previous.detail !== undefined) {
+        merged.detail = previous.detail;
+    }
+    if (previous.account || next.account) {
+        merged.account = { ...previous.account, ...next.account };
+    }
+    if (merged.vendor === undefined && previous.vendor !== undefined) {
+        merged.vendor = previous.vendor;
+    }
+    return merged;
+}
+/**
+ * Do two payloads carry the same information? Unlike {@link sameIdentity},
+ * which asks "is this the same login", this compares every rendered field, so
+ * a richer read of one login is NOT the same. Callers use it to suppress a
+ * push that would tell the client nothing new.
+ *
+ * `a` undefined means "nothing reported yet", which never equals a payload.
+ */
+export function sameAuthStatus(a, b) {
+    if (!a) {
+        return false;
+    }
+    return (a.kind === b.kind &&
+        a.label === b.label &&
+        a.detail === b.detail &&
+        a.account?.email === b.account?.email &&
+        a.account?.organization === b.account?.organization &&
+        a.account?.plan === b.account?.plan &&
+        // Vendor extras are an open bag, so compare them structurally. Both sides
+        // are built by this module from the same key order, so a string compare is
+        // enough and costs nothing on the usual `undefined`/`undefined` pair.
+        JSON.stringify(a.vendor) === JSON.stringify(b.vendor));
+}

package/dist/context-compaction-meta.d.ts

@@ -0,0 +1,18 @@
+export declare const CONTEXT_COMPACTION_META_KEY = "contextCompaction";
+export declare const CONTEXT_COMPACTION_META_VERSION = 1;
+export type ContextCompactionTrigger = "manual" | "automatic";
+export interface ContextCompactionMetadata {
+    version: typeof CONTEXT_COMPACTION_META_VERSION;
+    trigger?: ContextCompactionTrigger;
+    preTokens?: number;
+    postTokens?: number;
+    durationMs?: number;
+    error?: string;
+}
+/**
+ * Provider-neutral metadata for a synthetic ACP context-compaction tool call.
+ * The standard toolCallId and status fields own lifecycle identity and phase;
+ * this extension carries only compaction-specific facts.
+ */
+export declare function createContextCompactionMeta(metadata?: Omit<ContextCompactionMetadata, "version">): Record<typeof CONTEXT_COMPACTION_META_KEY, ContextCompactionMetadata>;
+//# sourceMappingURL=context-compaction-meta.d.ts.map

package/dist/context-compaction-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-compaction-meta.d.ts","sourceRoot":"","sources":["../src/context-compaction-meta.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD,MAAM,MAAM,wBAAwB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,+BAA+B,CAAC;IAChD,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,GAAE,IAAI,CAAC,yBAAyB,EAAE,SAAS,CAAM,GACxD,MAAM,CAAC,OAAO,2BAA2B,EAAE,yBAAyB,CAAC,CAOvE"}

package/dist/context-compaction-meta.js

@@ -0,0 +1,15 @@
+export const CONTEXT_COMPACTION_META_KEY = "contextCompaction";
+export const CONTEXT_COMPACTION_META_VERSION = 1;
+/**
+ * Provider-neutral metadata for a synthetic ACP context-compaction tool call.
+ * The standard toolCallId and status fields own lifecycle identity and phase;
+ * this extension carries only compaction-specific facts.
+ */
+export function createContextCompactionMeta(metadata = {}) {
+    return {
+        [CONTEXT_COMPACTION_META_KEY]: {
+            version: CONTEXT_COMPACTION_META_VERSION,
+            ...metadata,
+        },
+    };
+}

package/dist/context-compaction.d.ts

@@ -0,0 +1,43 @@
+import { SessionNotification } from "@agentclientprotocol/sdk";
+import { ContextCompactionMetadata } from "./context-compaction-meta.js";
+type CompactionStatus = "completed" | "failed";
+type CompactionState = {
+    toolCallId: string;
+    terminalStatus?: CompactionStatus;
+    heartbeatSent: boolean;
+};
+type SendUpdate = (notification: SessionNotification) => Promise<void>;
+/**
+ * Translates Claude's compaction signals into one idempotent ACP tool lifecycle.
+ *
+ * The SDK can duplicate terminal compact_result messages and can omit the
+ * opening status on replay. State therefore lives until the owning turn's
+ * result (or abort), while a new compacting status after a terminal outcome
+ * starts a fresh lifecycle.
+ */
+export declare class ContextCompactionLifecycle {
+    private readonly sendUpdate;
+    private activeCompaction;
+    private outputDelivered;
+    private duplicateErrorOutput;
+    constructor(sendUpdate: SendUpdate);
+    get hasDeliveredOutput(): boolean;
+    reset(): void;
+    /**
+     * Claude also emits a failed manual compaction's error as local-command
+     * stdout. Consume that one duplicate after the tool lifecycle carried it,
+     * without hiding unrelated command output.
+     */
+    consumeDuplicateErrorOutput(content: string): boolean;
+    start(sessionId: string, toolCallId: string): Promise<CompactionState>;
+    heartbeat(sessionId: string, fallbackId: string): Promise<void>;
+    finish(sessionId: string, fallbackId: string, status: CompactionStatus, metadata?: Omit<ContextCompactionMetadata, "version">, enrichTerminal?: boolean): Promise<void>;
+}
+export declare function contextCompactionMetadataFromBoundary(compactMetadata: {
+    trigger: "manual" | "auto";
+    pre_tokens: number;
+    post_tokens?: number;
+    duration_ms?: number;
+}): Omit<ContextCompactionMetadata, "version">;
+export {};
+//# sourceMappingURL=context-compaction.d.ts.map

package/dist/context-compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-compaction.d.ts","sourceRoot":"","sources":["../src/context-compaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EACL,yBAAyB,EAE1B,MAAM,8BAA8B,CAAC;AAEtC,KAAK,gBAAgB,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE/C,KAAK,eAAe,GAAG;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAClC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,UAAU,GAAG,CAAC,YAAY,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvE;;;;;;;GAOG;AACH,qBAAa,0BAA0B;IAKzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJvC,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,oBAAoB,CAAqB;gBAEpB,UAAU,EAAE,UAAU;IAEnD,IAAI,kBAAkB,IAAI,OAAO,CAEhC;IAED,KAAK,IAAI,IAAI;IAMb;;;;OAIG;IACH,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAW/C,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAqBtE,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB/D,MAAM,CACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,gBAAgB,EACxB,QAAQ,GAAE,IAAI,CAAC,yBAAyB,EAAE,SAAS,CAAM,EACzD,cAAc,UAAQ,GACrB,OAAO,CAAC,IAAI,CAAC;CAoDjB;AAED,wBAAgB,qCAAqC,CAAC,eAAe,EAAE;IACrE,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAAC,yBAAyB,EAAE,SAAS,CAAC,CAW7C"}

package/dist/context-compaction.js

@@ -0,0 +1,152 @@
+import { createContextCompactionMeta, } from "./context-compaction-meta.js";
+/**
+ * Translates Claude's compaction signals into one idempotent ACP tool lifecycle.
+ *
+ * The SDK can duplicate terminal compact_result messages and can omit the
+ * opening status on replay. State therefore lives until the owning turn's
+ * result (or abort), while a new compacting status after a terminal outcome
+ * starts a fresh lifecycle.
+ */
+export class ContextCompactionLifecycle {
+    sendUpdate;
+    activeCompaction;
+    outputDelivered = false;
+    duplicateErrorOutput;
+    constructor(sendUpdate) {
+        this.sendUpdate = sendUpdate;
+    }
+    get hasDeliveredOutput() {
+        return this.outputDelivered;
+    }
+    reset() {
+        this.activeCompaction = undefined;
+        this.outputDelivered = false;
+        this.duplicateErrorOutput = undefined;
+    }
+    /**
+     * Claude also emits a failed manual compaction's error as local-command
+     * stdout. Consume that one duplicate after the tool lifecycle carried it,
+     * without hiding unrelated command output.
+     */
+    consumeDuplicateErrorOutput(content) {
+        if (this.duplicateErrorOutput === undefined ||
+            content.trim() !== this.duplicateErrorOutput.trim()) {
+            return false;
+        }
+        this.duplicateErrorOutput = undefined;
+        return true;
+    }
+    async start(sessionId, toolCallId) {
+        if (this.activeCompaction && !this.activeCompaction.terminalStatus) {
+            return this.activeCompaction;
+        }
+        this.activeCompaction = { toolCallId, heartbeatSent: false };
+        this.outputDelivered = true;
+        await this.sendUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "tool_call",
+                toolCallId,
+                title: "Compact conversation",
+                kind: "think",
+                status: "in_progress",
+                _meta: compactionToolMeta(),
+            },
+        });
+        return this.activeCompaction;
+    }
+    async heartbeat(sessionId, fallbackId) {
+        const state = this.activeCompaction ?? (await this.start(sessionId, fallbackId));
+        if (state.terminalStatus || state.heartbeatSent)
+            return;
+        state.heartbeatSent = true;
+        await this.sendUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "tool_call_update",
+                toolCallId: state.toolCallId,
+                status: "in_progress",
+                _meta: compactionToolMeta(),
+            },
+        });
+    }
+    async finish(sessionId, fallbackId, status, metadata = {}, enrichTerminal = false) {
+        const rawOutput = Object.keys(metadata).length > 0 ? metadata : undefined;
+        if (!this.activeCompaction) {
+            this.activeCompaction = {
+                toolCallId: fallbackId,
+                heartbeatSent: false,
+                terminalStatus: status,
+            };
+            this.outputDelivered = true;
+            if (status === "failed" && metadata.error) {
+                this.duplicateErrorOutput = metadata.error;
+            }
+            await this.sendUpdate({
+                sessionId,
+                update: {
+                    sessionUpdate: "tool_call",
+                    toolCallId: fallbackId,
+                    title: "Compact conversation",
+                    kind: "think",
+                    status,
+                    ...(status === "failed" && metadata.error
+                        ? { content: [compactionErrorContent(metadata.error)] }
+                        : {}),
+                    ...(rawOutput ? { rawOutput } : {}),
+                    _meta: compactionToolMeta(metadata),
+                },
+            });
+            return;
+        }
+        const state = this.activeCompaction;
+        if (state.terminalStatus && !enrichTerminal)
+            return;
+        const firstTerminal = state.terminalStatus === undefined;
+        if (firstTerminal)
+            state.terminalStatus = status;
+        if (status === "failed" && metadata.error) {
+            this.duplicateErrorOutput = metadata.error;
+        }
+        await this.sendUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "tool_call_update",
+                toolCallId: state.toolCallId,
+                ...(firstTerminal ? { status } : {}),
+                ...(status === "failed" && metadata.error
+                    ? { content: [compactionErrorContent(metadata.error)] }
+                    : {}),
+                ...(rawOutput ? { rawOutput } : {}),
+                _meta: compactionToolMeta(metadata),
+            },
+        });
+    }
+}
+export function contextCompactionMetadataFromBoundary(compactMetadata) {
+    return {
+        trigger: compactMetadata.trigger === "auto" ? "automatic" : "manual",
+        preTokens: compactMetadata.pre_tokens,
+        ...(compactMetadata.post_tokens !== undefined
+            ? { postTokens: compactMetadata.post_tokens }
+            : {}),
+        ...(compactMetadata.duration_ms !== undefined
+            ? { durationMs: compactMetadata.duration_ms }
+            : {}),
+    };
+}
+function compactionToolMeta(metadata = {}) {
+    return {
+        ...createContextCompactionMeta(metadata),
+        claudeCode: { toolName: "compact" },
+    };
+}
+function compactionErrorContent(error) {
+    return {
+        type: "content",
+        content: {
+            type: "text",
+            text: `Compaction failed: ${error}`,
+        },
+    };
+}

package/dist/fork-session.d.ts

@@ -1,6 +1,9 @@
 import { ForkSessionRequest, ForkSessionResponse } from "@agentclientprotocol/sdk";
 type ForkSessionDependencies = {
     liveMessageIdToUuid?: ReadonlyMap<string, string>;
+    logger?: {
+        log: (...args: unknown[]) => void;
+    };
     messageIdForGrouping: (message: {
         type?: string;
         uuid?: string | null;

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

@@ -1 +1 @@
-{"version":3,"file":"fork-session.d.ts","sourceRoot":"","sources":["../src/fork-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAgB,MAAM,0BAA0B,CAAC;AAkBjG,KAAK,uBAAuB,GAAG;IAC7B,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,oBAAoB,EAAE,CAAC,OAAO,EAAE;QAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,KAAK,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAeF,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAoC9B"}
+{"version":3,"file":"fork-session.d.ts","sourceRoot":"","sources":["../src/fork-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAgB,MAAM,0BAA0B,CAAC;AA0BjG,KAAK,uBAAuB,GAAG;IAC7B,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;KAAE,CAAC;IAC/C,oBAAoB,EAAE,CAAC,OAAO,EAAE;QAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,KAAK,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AA+IF,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAsD9B"}