@agentclientprotocol/claude-agent-acp 0.74.0 → 0.75.1

package/dist/fork-session.js

@@ -1,41 +1,143 @@
 import { RequestError } from "@agentclientprotocol/sdk";
-import { forkSession as forkClaudeSession, getSessionMessages, } from "@anthropic-ai/claude-agent-sdk";
-function forkPointMessageId(meta) {
+import { forkSession as forkClaudeSession, getSessionMessages, importSessionToStore, } from "@anthropic-ai/claude-agent-sdk";
+import { createHash } from "node:crypto";
+import { assistantMessageText } from "./session-failure-extension.js";
+import { SessionTiming } from "./session-timing.js";
+function forkPoint(meta) {
     const fork = meta?.jetbrains?.air?.fork;
     if (fork?.version !== 1)
         return undefined;
     const messageId = fork.messageId?.trim();
-    return messageId || undefined;
+    if (!messageId)
+        return undefined;
+    const messageFingerprint = fork.messageFingerprint?.trim();
+    const messageOccurrence = fork.messageOccurrence;
+    return {
+        messageId,
+        ...(messageFingerprint ? { messageFingerprint } : {}),
+        // AIR computes this with count(...) over the visible prefix, so it is 1-based.
+        ...(typeof messageOccurrence === "number" &&
+            Number.isSafeInteger(messageOccurrence) &&
+            messageOccurrence > 0
+            ? { messageOccurrence }
+            : {}),
+    };
 }
 function forkPointMessageIdCandidates(messageId) {
     // Older AIR builds sent their visible segment id. Prefer the exact id before its ACP source id.
     const protocolMessageId = messageId.replace(/:segment:\d+$/, "");
     return protocolMessageId === messageId ? [messageId] : [messageId, protocolMessageId];
 }
+async function loadFullSessionHistory(sessionId, cwd) {
+    // getSessionMessages returns only the active parentUuid chain. The import keeps inactive branches that AIR can still reference.
+    const entries = [];
+    const store = {
+        append: async (_key, batch) => {
+            entries.push(...batch);
+        },
+        load: async () => null,
+    };
+    await importSessionToStore(sessionId, store, { dir: cwd, includeSubagents: false });
+    return entries;
+}
+function assistantGroups(entries, messageIdForGrouping) {
+    const groups = new Map();
+    for (const entry of entries) {
+        if (entry.type !== "assistant" ||
+            entry.isSidechain === true ||
+            entry.parent_tool_use_id != null ||
+            entry.parent_agent_id != null) {
+            continue;
+        }
+        const messageId = messageIdForGrouping(entry);
+        if (!messageId)
+            continue;
+        const group = groups.get(messageId) ?? { text: "" };
+        if (typeof entry.uuid === "string" && entry.uuid.length > 0)
+            group.uuid = entry.uuid;
+        group.text += assistantMessageText(entry.message) ?? "";
+        groups.set(messageId, group);
+    }
+    return groups;
+}
+function fingerprint(text) {
+    return `sha256:${createHash("sha256").update(text).digest("hex")}`;
+}
+function fingerprintOccurrenceOnBranch(targetUuid, expectedFingerprint, entries, groups, messageIdForGrouping) {
+    const entriesByUuid = new Map(entries.flatMap((entry) => (typeof entry.uuid === "string" ? [[entry.uuid, entry]] : [])));
+    const seenGroups = new Set();
+    let occurrence = 0;
+    let cursor = targetUuid;
+    while (cursor) {
+        const entry = entriesByUuid.get(cursor);
+        if (!entry)
+            break;
+        if (entry.type === "assistant" &&
+            entry.isSidechain !== true &&
+            entry.parent_tool_use_id == null &&
+            entry.parent_agent_id == null) {
+            const messageId = messageIdForGrouping(entry);
+            if (messageId && !seenGroups.has(messageId)) {
+                seenGroups.add(messageId);
+                const group = groups.get(messageId);
+                if (group && fingerprint(group.text) === expectedFingerprint)
+                    occurrence++;
+            }
+        }
+        cursor = typeof entry.parentUuid === "string" ? entry.parentUuid : undefined;
+    }
+    return occurrence;
+}
+function resolveFromFullHistory(entries, candidates, point, messageIdForGrouping) {
+    const groups = assistantGroups(entries, messageIdForGrouping);
+    const exact = candidates.map((candidate) => groups.get(candidate)?.uuid).find(Boolean);
+    if (exact)
+        return exact;
+    if (!point.messageFingerprint || !point.messageOccurrence)
+        return undefined;
+    const fingerprintMatches = [...groups.values()].filter((group) => group.uuid && fingerprint(group.text) === point.messageFingerprint);
+    // If only one persisted message has this content, the fingerprint already
+    // identifies it even when an older client supplied an incompatible index.
+    if (fingerprintMatches.length === 1)
+        return fingerprintMatches[0]?.uuid;
+    const occurrenceMatches = fingerprintMatches.filter((group) => group.uuid &&
+        fingerprintOccurrenceOnBranch(group.uuid, point.messageFingerprint, entries, groups, messageIdForGrouping) === point.messageOccurrence);
+    return occurrenceMatches.length === 1 ? occurrenceMatches[0]?.uuid : undefined;
+}
 export async function forkSession(params, dependencies) {
-    const messageId = forkPointMessageId(params._meta);
-    if (!messageId) {
+    const timing = new SessionTiming(dependencies.logger, "fork", params.sessionId);
+    const point = forkPoint(params._meta);
+    if (!point) {
         const forked = await forkClaudeSession(params.sessionId, { dir: params.cwd });
+        timing.phase("sdk-fork", " resolution=latest");
         return { sessionId: forked.sessionId };
     }
-    const candidateIds = forkPointMessageIdCandidates(messageId);
+    const candidateIds = forkPointMessageIdCandidates(point.messageId);
     const liveUuid = candidateIds
         .map((candidateId) => dependencies.liveMessageIdToUuid?.get(candidateId))
         .find(Boolean);
     const history = liveUuid
         ? undefined
         : await getSessionMessages(params.sessionId, { dir: params.cwd });
+    timing.phase("active-history", ` resolution=${liveUuid ? "live" : "pending"}`);
     const messageUuid = liveUuid ??
         candidateIds
-            .map((candidateId) => history?.find((message) => dependencies.messageIdForGrouping(message) === candidateId)
-            ?.uuid)
+            .map((candidateId) => history
+            ?.slice()
+            .reverse()
+            .find((message) => dependencies.messageIdForGrouping(message) === candidateId)?.uuid)
             .find(Boolean);
-    if (!messageUuid) {
-        throw RequestError.invalidParams({ messageId }, `Fork point message ${messageId} was not found in session ${params.sessionId}`);
+    const fullHistoryUuid = messageUuid
+        ? undefined
+        : resolveFromFullHistory(await loadFullSessionHistory(params.sessionId, params.cwd), candidateIds, point, dependencies.messageIdForGrouping);
+    timing.phase("full-history", ` resolution=${liveUuid ? "live" : messageUuid ? "active" : fullHistoryUuid ? "full" : "missing"}`);
+    if (!messageUuid && !fullHistoryUuid) {
+        throw RequestError.invalidParams({ messageId: point.messageId }, `Fork point message ${point.messageId} was not found in session ${params.sessionId}`);
     }
     const forked = await forkClaudeSession(params.sessionId, {
         dir: params.cwd,
-        upToMessageId: messageUuid,
+        upToMessageId: messageUuid ?? fullHistoryUuid,
     });
+    timing.phase("sdk-fork");
     return { sessionId: forked.sessionId };
 }

package/dist/hide-claude-auth.d.ts

@@ -21,13 +21,14 @@
  *    one, because the first turn was the one that signed out, the recreation
  *    starts a fresh query under the same session id instead.
  *
- * One case is left open. The CLI re-reads its credential store on its own. A
- * file-based credential can therefore be removed and replaced by a claude.ai
- * subscription between two turns. This covers a managed Console key and a key
- * from a settings helper. No turn fails in between, so nothing ends the query,
- * and the cached account still names the key that is gone. Closing this case
- * would cost one `initialize` control request per turn. That buys too little
- * for the price.
+ * A file-based credential replaced by a subscription between two turns is seen
+ * by the CLI probe the agent fires at the START of every user prompt. That read
+ * is never awaited, so it usually lands mid-turn; all it does there is mark the
+ * session. The guard consumes the mark at the turn boundary — the next prompt
+ * recreates the query and layer 1 judges the account the new `initialize`
+ * reports — so a probe never interrupts a running turn. A swap that happens
+ * after the last probe stays unseen until the next prompt reads the store
+ * again. Closing that window would cost a blocking read per turn.
  */
 import { RequestError } from "@agentclientprotocol/sdk";
 import type { AccountInfo, Query } from "@anthropic-ai/claude-agent-sdk";
@@ -114,6 +115,12 @@ type GuardOptions = {
     /** Built lazily: most turns pass and never need a controller. */
     sessionFailures: () => SessionFailureController;
     logger: GuardLogger;
+    /** Display hook: called with the account the guard just read, before the
+     *  guard decides on it. It exists so a refused turn still reports which
+     *  account it was refused for. Purely observational — this module knows
+     *  nothing about what the caller does with it, and a throw from here never
+     *  changes the verdict. */
+    onAccount?: (account: AccountInfo) => void;
 };
 /**
  * The per-turn guard for a live session.

package/dist/hide-claude-auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hide-claude-auth.d.ts","sourceRoot":"","sources":["../src/hide-claude-auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAE/E,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wCAAwC,sCAAsC,CAAC;AAC5F,MAAM,MAAM,kBAAkB,GAAG,OAAO,wCAAwC,CAAC;AAEjF,eAAO,MAAM,yCAAyC,qEACc,CAAC;AAErE;;qEAEqE;AACrE,eAAO,MAAM,6BAA6B,0EAC+B,CAAC;AAmB1E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAWjF;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAWxF;AAED,wBAAgB,mCAAmC,IAAI,YAAY,CAKlE;AAED;oEACoE;AACpE,wBAAgB,wBAAwB,IAAI,YAAY,CAEvD;AAED;;;;GAIG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;IAC/C,8EAA8E;IAC9E,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACrC,CAAC;AAMF;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,4BAA4B,CAAC;IACzC,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,IAAI,CAWP;AAED,KAAK,YAAY,GAAG;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IAClC,UAAU,EAAE,4BAA4B,CAAC;IACzC,iEAAiE;IACjE,eAAe,EAAE,MAAM,wBAAwB,CAAC;IAChD,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAavF"}
+{"version":3,"file":"hide-claude-auth.d.ts","sourceRoot":"","sources":["../src/hide-claude-auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAE/E,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wCAAwC,sCAAsC,CAAC;AAC5F,MAAM,MAAM,kBAAkB,GAAG,OAAO,wCAAwC,CAAC;AAEjF,eAAO,MAAM,yCAAyC,qEACc,CAAC;AAErE;;qEAEqE;AACrE,eAAO,MAAM,6BAA6B,0EAC+B,CAAC;AAmB1E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAWjF;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAWxF;AAED,wBAAgB,mCAAmC,IAAI,YAAY,CAKlE;AAED;oEACoE;AACpE,wBAAgB,wBAAwB,IAAI,YAAY,CAEvD;AAED;;;;GAIG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;IAC/C,8EAA8E;IAC9E,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACrC,CAAC;AAMF;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,4BAA4B,CAAC;IACzC,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,IAAI,CAWP;AAED,KAAK,YAAY,GAAG;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IAClC,UAAU,EAAE,4BAA4B,CAAC;IACzC,iEAAiE;IACjE,eAAe,EAAE,MAAM,wBAAwB,CAAC;IAChD,MAAM,EAAE,WAAW,CAAC;IACpB;;;;+BAI2B;IAC3B,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;CAC5C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAavF"}

package/dist/hide-claude-auth.js

@@ -21,13 +21,14 @@
  *    one, because the first turn was the one that signed out, the recreation
  *    starts a fresh query under the same session id instead.
  *
- * One case is left open. The CLI re-reads its credential store on its own. A
- * file-based credential can therefore be removed and replaced by a claude.ai
- * subscription between two turns. This covers a managed Console key and a key
- * from a settings helper. No turn fails in between, so nothing ends the query,
- * and the cached account still names the key that is gone. Closing this case
- * would cost one `initialize` control request per turn. That buys too little
- * for the price.
+ * A file-based credential replaced by a subscription between two turns is seen
+ * by the CLI probe the agent fires at the START of every user prompt. That read
+ * is never awaited, so it usually lands mid-turn; all it does there is mark the
+ * session. The guard consumes the mark at the turn boundary — the next prompt
+ * recreates the query and layer 1 judges the account the new `initialize`
+ * reports — so a probe never interrupts a running turn. A swap that happens
+ * after the last probe stays unseen until the next prompt reads the store
+ * again. Closing that window would cost a blocking read per turn.
  */
 import { RequestError } from "@agentclientprotocol/sdk";
 export function shouldHideClaudeAuth() {
@@ -185,6 +186,14 @@ async function evaluateGuard(options) {
     if (!account) {
         return undefined;
     }
+    // Before the decision, so the client learns the identity even when the next
+    // lines refuse the turn. A display hook must never fail a guard.
+    try {
+        options.onAccount?.(account);
+    }
+    catch (error) {
+        options.logger.error(`Session ${options.sessionId}: the guard's onAccount hook threw:`, error instanceof Error ? error.message : String(error));
+    }
     if (billsClaudeSubscription(account)) {
         await publishRefusal(options.sessionFailures(), {
             details: CLAUDE_SUBSCRIPTION_NOT_SUPPORTED_MESSAGE,

package/dist/lib.d.ts

@@ -2,5 +2,6 @@ export { ClaudeAcpAgent, isLocalCommandMetadata, stripLocalCommandMetadata, runA
 export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 export { toolInfoFromToolUse, toDisplayPath, planEntries, toolUpdateFromToolResult, } from "./tools.js";
 export { SettingsManager, type SettingsManagerOptions } from "./settings.js";
+export { AUTH_STATUS_UPDATE_METHOD, type AuthStatus, type AuthStatusAccount, type AuthStatusKind, type AuthStatusUpdateNotification, } from "./auth-status.js";
 export type { ClaudePlanEntry } from "./tools.js";
 //# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,yBAAyB,EACzB,MAAM,EACN,kBAAkB,EAClB,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,wBAAwB,GACzB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG7E,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,yBAAyB,EACzB,MAAM,EACN,kBAAkB,EAClB,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,wBAAwB,GACzB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG7E,OAAO,EACL,yBAAyB,EACzB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,4BAA4B,GAClC,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/lib.js

@@ -3,3 +3,6 @@ export { ClaudeAcpAgent, isLocalCommandMetadata, stripLocalCommandMetadata, runA
 export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 export { toolInfoFromToolUse, toDisplayPath, planEntries, toolUpdateFromToolResult, } from "./tools.js";
 export { SettingsManager } from "./settings.js";
+// The `authStatus` extension's wire surface: the notification's method name and
+// the payload types needed to read the traffic. The mappers stay internal.
+export { AUTH_STATUS_UPDATE_METHOD, } from "./auth-status.js";

package/dist/resumed-session.d.ts

@@ -0,0 +1,19 @@
+import { type SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+type ResumeLogger = {
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export type ResumedSessionSnapshot = {
+    messages?: SessionMessage[];
+    model?: string;
+};
+/** Return the concrete model recorded by the last real assistant response.
+ * Claude Code restores a resumed query from this same transcript field.
+ * Synthetic assistant records use angle-bracket placeholders and do not
+ * describe a model the resumed query can run. */
+export declare function resumedModelFromTranscript(messages: SessionMessage[]): string | undefined;
+/** Read the resume model from the local transcript without starting a Claude
+ * control request. This is intentionally on the load critical path. */
+export declare function readResumedSession(sessionId: string, logger?: ResumeLogger): Promise<ResumedSessionSnapshot>;
+export {};
+//# sourceMappingURL=resumed-session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resumed-session.d.ts","sourceRoot":"","sources":["../src/resumed-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGzF,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAClC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;iDAGiD;AACjD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,GAAG,SAAS,CAkBzF;AAED;uEACuE;AACvE,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,sBAAsB,CAAC,CAejC"}

package/dist/resumed-session.js

@@ -0,0 +1,42 @@
+import { getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
+import { SessionTiming } from "./session-timing.js";
+/** Return the concrete model recorded by the last real assistant response.
+ * Claude Code restores a resumed query from this same transcript field.
+ * Synthetic assistant records use angle-bracket placeholders and do not
+ * describe a model the resumed query can run. */
+export function resumedModelFromTranscript(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const entry = messages[index];
+        if (entry?.type !== "assistant" ||
+            entry.parent_tool_use_id != null ||
+            entry.parent_agent_id != null ||
+            !entry.message ||
+            typeof entry.message !== "object") {
+            continue;
+        }
+        const model = entry.message.model;
+        if (typeof model === "string" && model.trim().length > 0 && !/^<[^>]+>$/.test(model.trim())) {
+            return model.trim();
+        }
+    }
+    return undefined;
+}
+/** Read the resume model from the local transcript without starting a Claude
+ * control request. This is intentionally on the load critical path. */
+export async function readResumedSession(sessionId, logger) {
+    const timing = new SessionTiming(logger, "models", sessionId);
+    try {
+        // Deliberately search all project directories, matching replaySessionHistory.
+        // A client may reopen a session from a worktree or normalized path that is
+        // different from the directory under which Claude persisted the transcript.
+        const messages = await getSessionMessages(sessionId);
+        const model = resumedModelFromTranscript(messages);
+        timing.phase("read-transcript", ` messages=${messages.length} model=${model ?? "unknown"}`);
+        return { messages, model };
+    }
+    catch (error) {
+        timing.phase("read-transcript", " outcome=error");
+        logger?.error(`Failed to read transcript for resumed session ${sessionId}:`, error);
+        return {};
+    }
+}

package/dist/session-timing.d.ts

@@ -0,0 +1,15 @@
+type TimingLogger = {
+    log: (...args: unknown[]) => void;
+};
+/** Small phase timer for session lifecycle diagnostics. */
+export declare class SessionTiming {
+    private readonly logger;
+    private readonly operation;
+    private readonly sessionId;
+    private readonly startedAt;
+    private phaseStartedAt;
+    constructor(logger: TimingLogger | undefined, operation: string, sessionId: string, startedAt?: number);
+    phase(name: string, detail?: string): void;
+}
+export {};
+//# sourceMappingURL=session-timing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-timing.d.ts","sourceRoot":"","sources":["../src/session-timing.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACnC,CAAC;AAEF,2DAA2D;AAC3D,qBAAa,aAAa;IAKtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,cAAc,CAAS;gBAGZ,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EAClC,SAAS,SAAoB;IAM/B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAK,GAAG,IAAI;CAOvC"}

package/dist/session-timing.js

@@ -0,0 +1,20 @@
+/** Small phase timer for session lifecycle diagnostics. */
+export class SessionTiming {
+    logger;
+    operation;
+    sessionId;
+    startedAt;
+    phaseStartedAt;
+    constructor(logger, operation, sessionId, startedAt = performance.now()) {
+        this.logger = logger;
+        this.operation = operation;
+        this.sessionId = sessionId;
+        this.startedAt = startedAt;
+        this.phaseStartedAt = startedAt;
+    }
+    phase(name, detail = "") {
+        const finishedAt = performance.now();
+        this.logger?.log(`[session/${this.operation}] sessionId=${this.sessionId} phase=${name} durationMs=${Math.round(finishedAt - this.phaseStartedAt)} totalMs=${Math.round(finishedAt - this.startedAt)}${detail}`);
+        this.phaseStartedAt = finishedAt;
+    }
+}

package/dist/usage-markdown.d.ts

@@ -0,0 +1,7 @@
+import type { SDKControlGetUsageResponse } from "@anthropic-ai/claude-agent-sdk";
+/** Validate the experimental SDK response at the runtime boundary. */
+export declare function parseUsageResponse(value: unknown): SDKControlGetUsageResponse | null;
+export declare function isUsageCommandText(text: string): boolean;
+/** Render the SDK's structured `/usage` response as Markdown. */
+export declare function formatUsageResponse(usage: SDKControlGetUsageResponse): string;
+//# sourceMappingURL=usage-markdown.d.ts.map

package/dist/usage-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-markdown.d.ts","sourceRoot":"","sources":["../src/usage-markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AA8DjF,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,0BAA0B,GAAG,IAAI,CAMpF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AA0ED,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,CAiE7E"}

package/dist/usage-markdown.js

@@ -0,0 +1,154 @@
+import { z } from "zod";
+const countSchema = z.number().finite().nonnegative();
+const percentSchema = countSchema.max(100);
+const usageWindowSchema = z
+    .object({ utilization: percentSchema.nullable(), resets_at: z.string().nullable() })
+    .nullable()
+    .optional();
+const contributionSchema = z.object({ name: z.string(), pct: percentSchema });
+const behaviorPeriodSchema = z.object({
+    request_count: countSchema,
+    session_count: countSchema,
+    mcp_servers: z.array(contributionSchema),
+});
+const modelUsageSchema = z.object({
+    inputTokens: countSchema,
+    outputTokens: countSchema,
+    cacheReadInputTokens: countSchema,
+    cacheCreationInputTokens: countSchema,
+});
+const usageResponseSchema = z.object({
+    session: z.object({
+        total_cost_usd: countSchema,
+        total_api_duration_ms: countSchema,
+        total_duration_ms: countSchema,
+        model_usage: z.record(z.string(), modelUsageSchema),
+    }),
+    subscription_type: z.string().nullable(),
+    rate_limits_available: z.boolean(),
+    rate_limits: z
+        .object({
+        five_hour: usageWindowSchema,
+        seven_day: usageWindowSchema,
+        seven_day_oauth_apps: usageWindowSchema,
+        seven_day_opus: usageWindowSchema,
+        seven_day_sonnet: usageWindowSchema,
+        model_scoped: z
+            .array(z.object({
+            display_name: z.string(),
+            utilization: percentSchema.nullable(),
+            resets_at: z.string().nullable(),
+        }))
+            .optional(),
+        extra_usage: z
+            .object({
+            is_enabled: z.boolean(),
+            monthly_limit: countSchema.nullable(),
+            used_credits: countSchema.nullable(),
+            utilization: percentSchema.nullable(),
+            currency: z.string().nullable().optional(),
+        })
+            .nullable()
+            .optional(),
+    })
+        .nullable(),
+    behaviors: z.object({ day: behaviorPeriodSchema, week: behaviorPeriodSchema }).nullable(),
+});
+/** Validate the experimental SDK response at the runtime boundary. */
+export function parseUsageResponse(value) {
+    const parsed = usageResponseSchema.safeParse(value);
+    // Validate only the fields the renderer reads, but preserve the complete
+    // response. The experimental API may add values to unused subtrees without
+    // making the useful, already-validated portion unsafe to render.
+    return parsed.success ? value : null;
+}
+export function isUsageCommandText(text) {
+    return text.trim() === "/usage";
+}
+function usageBar(percent) {
+    const cells = 20;
+    const clamped = Math.max(0, Math.min(100, percent));
+    const filled = clamped === 0 ? 0 : Math.max(1, Math.round((clamped / 100) * cells));
+    return `${"█".repeat(filled)}${"░".repeat(cells - filled)}`;
+}
+function escapeMarkdown(value) {
+    return value.replace(/([\\`*_[\]<>|])/g, "\\$1").replace(/[\r\n]+/g, " ");
+}
+function formatDuration(milliseconds) {
+    const seconds = Math.max(0, Math.round(milliseconds / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+}
+function formatCount(value) {
+    return new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value);
+}
+function formatReset(value) {
+    if (!value)
+        return "";
+    const reset = new Date(value);
+    if (Number.isNaN(reset.getTime()))
+        return ` · Resets ${escapeMarkdown(value)}`;
+    return ` · Resets ${new Intl.DateTimeFormat("en", {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        timeZoneName: "short",
+    }).format(reset)}`;
+}
+function appendLimit(lines, label, window) {
+    if (!window || window.utilization === null)
+        return;
+    lines.push(`**${escapeMarkdown(label)}** — **${window.utilization}%**${formatReset(window.resets_at)}`, "", `\`${usageBar(window.utilization)}\``, "");
+}
+function appendContributions(lines, label, period) {
+    lines.push("", `**${label}** · ${period.request_count} requests · ${period.session_count} sessions`);
+    if (period.mcp_servers.length === 0)
+        return;
+    lines.push("", "| MCP server | Usage |", "|:--|--:|");
+    for (const server of [...period.mcp_servers].sort((a, b) => b.pct - a.pct).slice(0, 3)) {
+        lines.push(`| ${escapeMarkdown(server.name)} | \`${usageBar(server.pct)}\` ${server.pct}% |`);
+    }
+}
+/** Render the SDK's structured `/usage` response as Markdown. */
+export function formatUsageResponse(usage) {
+    const lines = ["## Usage"];
+    if (usage.subscription_type) {
+        lines.push("", `> Claude ${escapeMarkdown(usage.subscription_type)} subscription usage`);
+    }
+    if (usage.rate_limits_available && usage.rate_limits) {
+        const limitLines = [];
+        appendLimit(limitLines, "5-hour limit", usage.rate_limits.five_hour);
+        appendLimit(limitLines, "Weekly · all models", usage.rate_limits.seven_day);
+        const modelWindows = usage.rate_limits.model_scoped ?? [];
+        for (const model of modelWindows) {
+            appendLimit(limitLines, `Weekly · ${model.display_name}`, model);
+        }
+        if (modelWindows.length === 0) {
+            appendLimit(limitLines, "Weekly · Opus", usage.rate_limits.seven_day_opus);
+            appendLimit(limitLines, "Weekly · Sonnet", usage.rate_limits.seven_day_sonnet);
+        }
+        if (limitLines.length > 0) {
+            if (limitLines.at(-1) === "")
+                limitLines.pop();
+            lines.push("", "### Limits", "", ...limitLines);
+        }
+    }
+    const models = Object.values(usage.session.model_usage);
+    const totals = models.reduce((sum, model) => ({
+        input: sum.input + model.inputTokens,
+        output: sum.output + model.outputTokens,
+        cacheRead: sum.cacheRead + model.cacheReadInputTokens,
+        cacheWrite: sum.cacheWrite + model.cacheCreationInputTokens,
+    }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    lines.push("", "---", "", "### This session", "", "| Cost | API time | Active |", "|:--|:--|:--|", `| $${usage.session.total_cost_usd.toFixed(2)} | ${formatDuration(usage.session.total_api_duration_ms)} | ${formatDuration(usage.session.total_duration_ms)} |`, "", "| Breakdown | Tokens |", "|:--|--:|", `| Input | ${formatCount(totals.input)} |`, `| Output | ${formatCount(totals.output)} |`, `| Cache read | ${formatCount(totals.cacheRead)} |`, `| Cache write | ${formatCount(totals.cacheWrite)} |`);
+    if (usage.behaviors) {
+        lines.push("", "---", "", "### What’s using your limits?", "", "> Approximate, overlapping measures · this machine only · excludes claude.ai");
+        appendContributions(lines, "Last 24h", usage.behaviors.day);
+        appendContributions(lines, "Last 7d", usage.behaviors.week);
+    }
+    return lines.join("\n");
+}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.74.0",
+  "version": "0.75.1",
   "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",