claude-code-rust 0.12.2 → 0.12.4

package/README.md

@@ -38,12 +38,8 @@ claude-rs
 
 Full documentation is available at [srothgan.github.io/claude-code-rust](https://srothgan.github.io/claude-code-rust/).
 
-> [!WARNING]
-> **Agent SDK billing changes on June 15, 2026.** Anthropic says Agent SDK usage, `claude -p`, Claude Code GitHub Actions, and third-party Agent SDK apps will use a separate monthly Agent SDK credit instead of normal interactive Claude or Claude Code subscription limits. Because Claude Code Rust wraps the Agent SDK, treat usage through this project as Agent SDK usage. If that credit is exhausted, continued use may require enabling extra usage billed at standard API rates, or requests may pause until the credit refreshes.
->
-> Sources:
-> - [Anthropic support: Use the Claude Agent SDK with your Claude plan](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan)
-> - [ClaudeDevs announcement](https://x.com/ClaudeDevs/status/2054610152817619388)
+> [!NOTE]
+> **Agent SDK billing unchanged.** Anthropic has paused the previously announced Agent SDK credit change. For now nothing changes: Claude Agent SDK usage — including `claude -p` and third-party apps like this one — still draws from your normal Claude subscription limits. See [Use the Claude Agent SDK with your Claude plan](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan).
 
 ## Why
 
@@ -85,7 +81,7 @@ This project is not affiliated with, endorsed by, or supported by Anthropic.
 
 A quick note on where this project stands, since I know people worry about this kind of thing: claude-code-rust is a terminal UI that I wrote from scratch in Rust. It is not a fork, copy or port of the latest Claude Code source leak -- it talks to Anthropic's official [Agent SDK](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/agent-sdk) as a runtime dependency instead, the same way any other third-party tool would. No Anthropic source code was read or used as reference at any point during development.
 
-The project authenticates through your existing Claude Code account via the Agent SDK, and the Agent SDK's terms allow building on top of it. Billing, credits, limits, and overage behavior are controlled by Anthropic, including the Agent SDK credit change noted above. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
+The project authenticates through your existing Claude Code account via the Agent SDK, and the Agent SDK's terms allow building on top of it. Billing, credits, limits, and overage behavior are controlled by Anthropic, including any future changes Anthropic may make to how Agent SDK usage is metered. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
 
 This project's source code is licensed under [Apache-2.0](LICENSE). The Agent SDK itself is proprietary and governed by [Anthropic's Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms).
 

package/agent-sdk/dist/bridge/commands.js

@@ -95,6 +95,13 @@ function expectEffortLevel(record, key, context) {
     }
     return value;
 }
+function expectRewindRestoreMode(record, key, context) {
+    const value = expectString(record, key, context);
+    if (value === "both" || value === "conversation" || value === "code") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be one of both, conversation, code`);
+}
 function expectNonEmptyStringOrNull(record, key, context) {
     const value = record[key];
     if (value === null) {
@@ -281,6 +288,19 @@ export function parseCommandEnvelope(line) {
                     command: "get_context_usage",
                     session_id: expectString(raw, "session_id", "get_context_usage"),
                 };
+            case "get_rewind_targets":
+                return {
+                    command: "get_rewind_targets",
+                    session_id: expectString(raw, "session_id", "get_rewind_targets"),
+                };
+            case "rewind":
+                return {
+                    command: "rewind",
+                    session_id: expectString(raw, "session_id", "rewind"),
+                    target_user_message_id: expectString(raw, "target_user_message_id", "rewind"),
+                    restore_mode: expectRewindRestoreMode(raw, "restore_mode", "rewind"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "rewind"),
+                };
             case "reload_plugins":
                 return {
                     command: "reload_plugins",

package/agent-sdk/dist/bridge/events.js

@@ -6,7 +6,9 @@ import { resolveCurrentModel } from "./session_lifecycle.js";
 const SESSION_LIST_LIMIT = 50;
 let sessionListingDir;
 export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
-    return dir ? { dir, includeWorktrees: true, limit } : { limit };
+    return dir
+        ? { dir, includeProgrammatic: true, includeWorktrees: true, limit }
+        : { includeProgrammatic: true, limit };
 }
 export function setSessionListingDir(dir) {
     sessionListingDir = dir;
@@ -121,6 +123,7 @@ function buildConnectBridgeEvent(session, eventName) {
             available_models: session.availableModels,
             mode: session.mode ? buildModeState(session, session.mode) : null,
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+            ...(session.restoredInput !== undefined ? { restored_input: session.restoredInput } : {}),
         }
         : {
             event: "connected",
@@ -144,6 +147,7 @@ function logConnectEventEmission(session, eventName, requestId) {
             history_update_count: session.resumeUpdates?.length ?? 0,
             available_model_count: session.availableModels.length,
             stale_session_count: session.sessionsToCloseAfterConnect?.length ?? 0,
+            has_restored_input: session.restoredInput !== undefined,
         },
     });
 }
@@ -151,10 +155,15 @@ export function emitConnectEvent(session) {
     const bridgeEvent = buildConnectBridgeEvent(session, session.connectEvent);
     logConnectEventEmission(session, session.connectEvent, session.connectRequestId);
     writeEvent(bridgeEvent, session.connectRequestId);
+    if (session.pendingRewindResult) {
+        writeEvent({ ...session.pendingRewindResult, session_id: session.sessionId }, session.connectRequestId);
+        session.pendingRewindResult = undefined;
+    }
     session.connectRequestId = undefined;
     session.connected = true;
     session.authHintSent = false;
     session.resumeUpdates = undefined;
+    session.restoredInput = undefined;
     const staleSessions = session.sessionsToCloseAfterConnect;
     session.sessionsToCloseAfterConnect = undefined;
     if (!staleSessions || staleSessions.length === 0) {
@@ -180,7 +189,12 @@ export function emitSessionReplacedEvent(session, requestId) {
     const bridgeEvent = buildConnectBridgeEvent(session, "session_replaced");
     logConnectEventEmission(session, "session_replaced", requestId);
     writeEvent(bridgeEvent, requestId);
+    if (session.pendingRewindResult) {
+        writeEvent({ ...session.pendingRewindResult, session_id: session.sessionId }, requestId);
+        session.pendingRewindResult = undefined;
+    }
     session.resumeUpdates = undefined;
+    session.restoredInput = undefined;
     refreshSessionsList();
 }
 export async function emitSessionsList(requestId) {

package/agent-sdk/dist/bridge/logger.js

@@ -71,6 +71,10 @@ function commandSessionId(command) {
         case "question_response":
         case "elicitation_response":
         case "get_status_snapshot":
+        case "get_context_usage":
+        case "get_rewind_targets":
+        case "rewind":
+        case "reload_plugins":
         case "mcp_status":
         case "mcp_reconnect":
         case "mcp_toggle":
@@ -105,6 +109,8 @@ function commandToolCallId(command) {
         case "elicitation_response":
         case "get_status_snapshot":
         case "get_context_usage":
+        case "get_rewind_targets":
+        case "rewind":
         case "reload_plugins":
         case "mcp_status":
         case "mcp_reconnect":
@@ -141,6 +147,8 @@ function eventToolCallId(event) {
         case "sessions_listed":
         case "status_snapshot":
         case "context_usage":
+        case "rewind_targets":
+        case "rewind_result":
         case "mcp_snapshot":
             return undefined;
     }
@@ -183,6 +191,8 @@ function protocolEventLevel(event) {
         case "sessions_listed":
         case "status_snapshot":
         case "context_usage":
+        case "rewind_targets":
+        case "rewind_result":
         case "runtime_reload_completed":
         case "mcp_set_servers_result":
         case "mcp_snapshot":

package/agent-sdk/dist/bridge/message_handlers.js

@@ -90,6 +90,162 @@ function emitSystemNoticeUpdate(session, severity, message) {
     }
     emitSessionUpdate(session.sessionId, { type: "system_notice_update", severity, message: trimmed });
 }
+const MAX_INFORMATIONAL_DEDUP_KEYS = 256;
+function shouldEmitInformationalMessage(session, level, content, toolUseId) {
+    if (!toolUseId) {
+        return true;
+    }
+    const key = `${toolUseId}\u0000${level}\u0000${content}`;
+    if (session.informationalDedupKeys.has(key)) {
+        return false;
+    }
+    session.informationalDedupKeys.add(key);
+    while (session.informationalDedupKeys.size > MAX_INFORMATIONAL_DEDUP_KEYS) {
+        const first = session.informationalDedupKeys.values().next().value;
+        if (typeof first !== "string") {
+            break;
+        }
+        session.informationalDedupKeys.delete(first);
+    }
+    return true;
+}
+function handleInformationalSystemMessage(session, msg) {
+    const content = typeof msg.content === "string" ? msg.content.trim() : "";
+    if (!content) {
+        return;
+    }
+    const level = typeof msg.level === "string" ? msg.level : "info";
+    const toolUseId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
+    if (!shouldEmitInformationalMessage(session, level, content, toolUseId)) {
+        return;
+    }
+    switch (level) {
+        case "notice":
+            emitSystemNoticeUpdate(session, "info", content);
+            return;
+        case "suggestion":
+            emitSystemNoticeUpdate(session, "info", `Suggestion: ${content}`);
+            return;
+        case "warning":
+            emitSystemNoticeUpdate(session, "warning", content);
+            return;
+        case "info":
+            if (msg.prevent_continuation === true) {
+                emitSystemNoticeUpdate(session, "warning", content);
+            }
+            return;
+        default:
+            bridgeLogger.debug({
+                target: LOG_TARGETS.BRIDGE_SDK,
+                eventName: "sdk_informational_level_unhandled",
+                message: "SDK informational message ignored for unknown level",
+                outcome: "ignored",
+                sessionId: session.sessionId,
+                toolCallId: toolUseId || undefined,
+                fields: {
+                    informational_level: level,
+                },
+            });
+    }
+}
+function trimmedStringField(msg, field) {
+    const value = msg[field];
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function ensureSentencePunctuation(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function modelRefusalNoFallbackMessage(msg) {
+    const model = trimmedStringField(msg, "original_model") ?? "the selected model";
+    const base = `Could not continue with ${model}: model refused the request and no fallback model is configured.`;
+    const explanation = trimmedStringField(msg, "api_refusal_explanation");
+    const category = trimmedStringField(msg, "api_refusal_category");
+    const content = trimmedStringField(msg, "content");
+    const detail = explanation
+        ? `Reason: ${explanation}`
+        : category
+            ? `Refusal category: ${category}`
+            : content;
+    const detailSentence = detail ? ensureSentencePunctuation(detail) : "";
+    return detailSentence ? `${base} ${detailSentence}` : base;
+}
+function handleModelRefusalNoFallbackMessage(session, msg) {
+    const message = modelRefusalNoFallbackMessage(msg);
+    emitSystemNoticeUpdate(session, "warning", message);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "sdk_model_refusal_no_fallback_received",
+        message: "SDK model refusal without fallback received",
+        outcome: "success",
+        sessionId: session.sessionId,
+        requestId: trimmedStringField(msg, "request_id"),
+        fields: {
+            original_model: trimmedStringField(msg, "original_model"),
+            api_refusal_category: trimmedStringField(msg, "api_refusal_category"),
+            refused_user_message_uuid: trimmedStringField(msg, "refused_user_message_uuid"),
+            sdk_message_uuid: trimmedStringField(msg, "uuid"),
+            sdk_message_session_id: trimmedStringField(msg, "session_id"),
+            has_api_refusal_explanation: trimmedStringField(msg, "api_refusal_explanation") !== undefined,
+            has_content: trimmedStringField(msg, "content") !== undefined,
+        },
+    });
+}
+function workerShutdownMessage(reason) {
+    const trimmed = reason.trim();
+    return trimmed ? `Claude worker is shutting down: ${trimmed}` : "Claude worker is shutting down.";
+}
+function handleWorkerShuttingDownSystemMessage(session, msg) {
+    const reason = typeof msg.reason === "string" ? msg.reason.trim() : "";
+    if (!session.connected) {
+        bridgeLogger.debug({
+            target: LOG_TARGETS.BRIDGE_SDK,
+            eventName: "sdk_worker_shutdown_preconnect_ignored",
+            message: "SDK worker shutdown ignored before session connect",
+            outcome: "ignored",
+            sessionId: session.sessionId,
+            fields: {
+                reason: reason || undefined,
+            },
+        });
+        return;
+    }
+    session.pendingWorkerShutdown = { reason };
+}
+function cancelPendingWorkerShutdown(session) {
+    if (!session.pendingWorkerShutdown) {
+        return;
+    }
+    bridgeLogger.debug({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_worker_shutdown_cancelled",
+        message: "SDK worker shutdown ignored after later stream activity",
+        outcome: "ignored",
+        sessionId: session.sessionId,
+        fields: {
+            reason: session.pendingWorkerShutdown.reason || undefined,
+        },
+    });
+    session.pendingWorkerShutdown = undefined;
+}
+export function flushPendingWorkerShutdown(session) {
+    const pending = session.pendingWorkerShutdown;
+    if (!pending) {
+        return;
+    }
+    session.pendingWorkerShutdown = undefined;
+    if (!session.connected) {
+        return;
+    }
+    emitSystemNoticeUpdate(session, "warning", workerShutdownMessage(pending.reason));
+}
 function notificationSeverity(priority) {
     return priority === "high" || priority === "immediate" ? "warning" : "info";
 }
@@ -675,12 +831,19 @@ function terminalReasonFromValue(value) {
 export function handleSdkMessage(session, message) {
     const msg = message;
     const type = typeof msg.type === "string" ? msg.type : "";
+    const subtype = type === "system" && typeof msg.subtype === "string" ? msg.subtype : "";
+    if (subtype !== "worker_shutting_down") {
+        cancelPendingWorkerShutdown(session);
+    }
     logSdkMessageOrigin(session, msg);
     if (type === "system") {
-        const subtype = typeof msg.subtype === "string" ? msg.subtype : "";
         if (handleFallbackRetractionMessage(session, subtype, msg)) {
             return;
         }
+        if (subtype === "model_refusal_no_fallback") {
+            handleModelRefusalNoFallbackMessage(session, msg);
+            return;
+        }
         if (subtype === "commands_changed") {
             updateAvailableCommands(session, "commands_changed", mapSdkSlashCommands(msg.commands));
             return;
@@ -690,6 +853,14 @@ export function handleSdkMessage(session, message) {
             emitSystemNoticeUpdate(session, notificationSeverity(msg.priority), text);
             return;
         }
+        if (subtype === "informational") {
+            handleInformationalSystemMessage(session, msg);
+            return;
+        }
+        if (subtype === "worker_shutting_down") {
+            handleWorkerShuttingDownSystemMessage(session, msg);
+            return;
+        }
         if (subtype === "mirror_error") {
             const error = typeof msg.error === "string" ? msg.error : "";
             const key = asRecordOrNull(msg.key);

package/agent-sdk/dist/bridge/session_lifecycle.js

@@ -162,6 +162,23 @@ export async function closeSessionWithLogging(session, options = {}) {
         fields: { reason: options.reason ?? "unspecified" },
     });
 }
+export async function closeSessionsBeforeRegister(replacementSession, staleSessions, requestId) {
+    if (!staleSessions || staleSessions.length === 0) {
+        return;
+    }
+    for (const stale of staleSessions) {
+        if (stale === replacementSession) {
+            continue;
+        }
+        if (sessions.get(stale.sessionId) === stale) {
+            sessions.delete(stale.sessionId);
+        }
+        await closeSessionWithLogging(stale, {
+            reason: "stale_before_register",
+            requestId,
+        });
+    }
+}
 export async function closeAllSessions(options = {}) {
     const active = Array.from(sessions.values());
     sessions.clear();
@@ -187,6 +204,7 @@ export async function createSession(params) {
     const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings).allowDangerouslySkipPermissions === true;
     const historyUpdateCount = params.resumeUpdates?.length ?? 0;
     const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
+    const staleSessionBeforeRegisterCount = params.sessionsToCloseBeforeRegister?.length ?? 0;
     let session;
     const sessionIdForLogs = () => session?.sessionId ?? provisionalSessionId;
     const canUseTool = async (toolName, inputData, options) => {
@@ -253,8 +271,10 @@ export async function createSession(params) {
             cwd: params.cwd,
             connect_event: params.connectEvent,
             resume_requested: params.resume !== undefined,
+            resume_session_at: params.resumeSessionAt ?? "<none>",
             history_update_count: historyUpdateCount,
             stale_session_count: staleSessionCount,
+            stale_session_before_register_count: staleSessionBeforeRegisterCount,
         },
     });
     try {
@@ -263,6 +283,7 @@ export async function createSession(params) {
             options: buildQueryOptions({
                 cwd: params.cwd,
                 resume: params.resume,
+                resumeSessionAt: params.resumeSessionAt,
                 launchSettings: params.launchSettings,
                 provisionalSessionId,
                 input,
@@ -287,6 +308,7 @@ export async function createSession(params) {
             fields: {
                 cwd: params.cwd,
                 resume_requested: params.resume !== undefined,
+                resume_session_at: params.resumeSessionAt ?? "<none>",
                 error_message: message,
             },
         });
@@ -319,12 +341,17 @@ export async function createSession(params) {
         pendingQuestions: new Map(),
         pendingUserDialogs: new Map(),
         pendingElicitations: new Map(),
+        informationalDedupKeys: new Set(),
         mcpStatusRevalidatedAt: new Map(),
         hiddenToolUseIds: new Set(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
             ? { resumeUpdates: params.resumeUpdates }
             : {}),
+        ...(params.restoredInput !== undefined ? { restoredInput: params.restoredInput } : {}),
+        ...(params.pendingRewindResult !== undefined
+            ? { pendingRewindResult: params.pendingRewindResult }
+            : {}),
         ...(params.sessionsToCloseAfterConnect
             ? { sessionsToCloseAfterConnect: params.sessionsToCloseAfterConnect }
             : {}),
@@ -332,6 +359,7 @@ export async function createSession(params) {
     refreshCurrentModel(session);
     const { refreshSupportedModesForSession } = await import("./commands.js");
     refreshSupportedModesForSession(session);
+    await closeSessionsBeforeRegister(session, params.sessionsToCloseBeforeRegister, params.requestId);
     sessions.set(provisionalSessionId, session);
     bridgeLogger.info({
         target: LOG_TARGETS.APP_SESSION,
@@ -344,6 +372,7 @@ export async function createSession(params) {
             cwd: session.cwd,
             connect_event: session.connectEvent,
             resume_requested: params.resume !== undefined,
+            resume_session_at: params.resumeSessionAt ?? "<none>",
         },
     });
     bridgeLogger.info({
@@ -430,6 +459,11 @@ export async function createSession(params) {
                 const { handleSdkMessage } = await import("./message_handlers.js");
                 handleSdkMessage(session, message);
             }
+            {
+                // Lazy import to break circular dependency at module-evaluation time.
+                const { flushPendingWorkerShutdown } = await import("./message_handlers.js");
+                flushPendingWorkerShutdown(session);
+            }
             if (!session.connected) {
                 bridgeLogger.error({
                     target: LOG_TARGETS.APP_SESSION,
@@ -456,6 +490,7 @@ export async function createSession(params) {
             failConnection(`agent stream failed: ${message}`, params.requestId);
         }
     })();
+    return session;
 }
 function logSdkProcessSpawnStarted(options, includeArgsPreview) {
     bridgeLogger.info({
@@ -570,6 +605,7 @@ export function buildQueryOptions(params) {
         cwd: params.cwd,
         includePartialMessages: true,
         promptSuggestions: true,
+        enableFileCheckpointing: true,
         executable: "node",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
         ...(settings ? { settings } : {}),
@@ -621,6 +657,7 @@ export function buildQueryOptions(params) {
         // --setting-sources argument.
         settingSources: DEFAULT_SETTING_SOURCES,
         resume: params.resume,
+        ...(params.resumeSessionAt ? { resumeSessionAt: params.resumeSessionAt } : {}),
         canUseTool: params.canUseTool,
         onElicitation: async (request) => {
             const requestId = randomUUID();

package/agent-sdk/dist/bridge/state_parsing.js

@@ -62,6 +62,9 @@ export function buildRateLimitUpdate(rateLimitInfo) {
         type: "rate_limit_update",
         status,
     };
+    if (info.errorCode === "credits_required") {
+        update.error_code = "credits_required";
+    }
     const resetsAt = numberField(info, "resetsAt");
     if (resetsAt !== undefined) {
         update.resets_at = resetsAt;
@@ -94,6 +97,12 @@ export function buildRateLimitUpdate(rateLimitInfo) {
     if (surpassedThreshold !== undefined) {
         update.surpassed_threshold = surpassedThreshold;
     }
+    if (typeof info.canUserPurchaseCredits === "boolean") {
+        update.can_user_purchase_credits = info.canUserPurchaseCredits;
+    }
+    if (typeof info.hasChargeableSavedPaymentMethod === "boolean") {
+        update.has_chargeable_saved_payment_method = info.hasChargeableSavedPaymentMethod;
+    }
     return update;
 }
 export function buildApiRetryUpdate(message) {