claude-code-rust 0.4.1 → 0.5.1

package/README.md

@@ -50,7 +50,7 @@ Three-layer design:
 
 **Presentation** (Rust/Ratatui) - Single binary with an async event loop (Tokio) handling keyboard input and bridge client events concurrently. Virtual-scrolled chat history with syntax-highlighted code blocks.
 
-**Protocol Bridge** (stdio JSON envelopes) - Spawns `agent-sdk/dist/bridge.js` as a child process and communicates via line-delimited JSON envelopes over stdin/stdout. Bidirectional streaming for user messages, tool updates, and permission requests.
+**Agent SDK Bridge** (stdio JSON envelopes) - Spawns `agent-sdk/dist/bridge.js` as a child process and communicates via line-delimited JSON envelopes over stdin/stdout. Bidirectional streaming for user messages, tool updates, and permission requests.
 
 **Agent Runtime** (Anthropic Agent SDK) - The TypeScript bridge drives `@anthropic-ai/claude-agent-sdk`, which manages authentication, session/query lifecycle, and tool execution.
 
@@ -67,7 +67,7 @@ This project is pre-1.0 and under active development. See [CONTRIBUTING.md](CONT
 ## License
 
 This project is licensed under the [GNU Affero General Public License v3.0 or later](LICENSE).
-This license was chosen because Claude Code is not open-source and this license allows everyone to use it while stopping Antrophic from implementing it in their clsosed-source version.
+This license was chosen because Claude Code is not open-source and this license allows everyone to use it while stopping Anthropic from implementing it in their closed-source version.
 
 By using this software, you agree to the terms of the AGPL-3.0. If you modify this software and make it available over a network, you must offer the source code to users of that service.
 

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

@@ -0,0 +1,9 @@
+export const CACHE_SPLIT_POLICY = Object.freeze({
+    softLimitBytes: 1536,
+    hardLimitBytes: 4096,
+    previewLimitBytes: 2048,
+});
+export function previewKilobyteLabel(policy = CACHE_SPLIT_POLICY) {
+    const kb = policy.previewLimitBytes / 1024;
+    return Number.isInteger(kb) ? `${kb}KB` : `${kb.toFixed(1)}KB`;
+}

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

@@ -1,4 +1,5 @@
 import { asRecordOrNull } from "./shared.js";
+import { CACHE_SPLIT_POLICY, previewKilobyteLabel } from "./cache_policy.js";
 export const TOOL_RESULT_TYPES = new Set([
     "tool_result",
     "tool_search_tool_result",
@@ -138,6 +139,7 @@ export function extractText(value) {
 }
 const PERSISTED_OUTPUT_OPEN_TAG = "<persisted-output>";
 const PERSISTED_OUTPUT_CLOSE_TAG = "</persisted-output>";
+const EXPECTED_PREVIEW_LINE = `preview (first ${previewKilobyteLabel(CACHE_SPLIT_POLICY).toLowerCase()}):`;
 function extractPersistedOutputInnerText(text) {
     const lower = text.toLowerCase();
     const openIdx = lower.indexOf(PERSISTED_OUTPUT_OPEN_TAG);
@@ -159,6 +161,9 @@ function persistedOutputFirstLine(text) {
     for (const line of inner.split(/\r?\n/)) {
         const cleaned = line.replace(/^[\s|│┃║]+/u, "").trim();
         if (cleaned.length > 0) {
+            if (cleaned.toLowerCase() === EXPECTED_PREVIEW_LINE) {
+                continue;
+            }
             return cleaned;
         }
     }

package/agent-sdk/dist/bridge.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { spawn as spawnChild } from "node:child_process";
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import readline from "node:readline";
 import { pathToFileURL } from "node:url";
 import { query, } from "@anthropic-ai/claude-agent-sdk";
@@ -8,12 +9,36 @@ import { parseCommandEnvelope, toPermissionMode, buildModeState } from "./bridge
 import { asRecordOrNull } from "./bridge/shared.js";
 import { looksLikeAuthRequired } from "./bridge/auth.js";
 import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, normalizeToolKind, normalizeToolResultText, unwrapToolUseResult, } from "./bridge/tooling.js";
+import { CACHE_SPLIT_POLICY, previewKilobyteLabel } from "./bridge/cache_policy.js";
 import { buildUsageUpdateFromResult, buildUsageUpdateFromResultForSession } from "./bridge/usage.js";
 import { formatPermissionUpdates, permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./bridge/permissions.js";
 import { extractSessionHistoryUpdatesFromJsonl, listRecentPersistedSessions, resolvePersistedSessionEntry, } from "./bridge/history.js";
-export { buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, looksLikeAuthRequired, normalizeToolKind, normalizeToolResultText, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, unwrapToolUseResult, };
+export { CACHE_SPLIT_POLICY, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, looksLikeAuthRequired, normalizeToolKind, normalizeToolResultText, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, unwrapToolUseResult, };
 const sessions = new Map();
+const EXPECTED_AGENT_SDK_VERSION = "0.2.52";
+const require = createRequire(import.meta.url);
 const permissionDebugEnabled = process.env.CLAUDE_RS_SDK_PERMISSION_DEBUG === "1" || process.env.CLAUDE_RS_SDK_DEBUG === "1";
+export function resolveInstalledAgentSdkVersion() {
+    try {
+        const pkg = require("@anthropic-ai/claude-agent-sdk/package.json");
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function agentSdkVersionCompatibilityError() {
+    const installed = resolveInstalledAgentSdkVersion();
+    if (!installed) {
+        return (`Agent SDK version check failed: unable to resolve installed ` +
+            `@anthropic-ai/claude-agent-sdk package.json (expected ${EXPECTED_AGENT_SDK_VERSION}).`);
+    }
+    if (installed === EXPECTED_AGENT_SDK_VERSION) {
+        return undefined;
+    }
+    return (`Unsupported @anthropic-ai/claude-agent-sdk version: expected ${EXPECTED_AGENT_SDK_VERSION}, ` +
+        `found ${installed}.`);
+}
 function logPermissionDebug(message) {
     if (!permissionDebugEnabled) {
         return;
@@ -447,6 +472,10 @@ function handleStreamEvent(session, event) {
     }
 }
 function handleAssistantMessage(session, message) {
+    const assistantError = typeof message.error === "string" ? message.error : "";
+    if (assistantError.length > 0) {
+        session.lastAssistantError = assistantError;
+    }
     const messageObject = message.message && typeof message.message === "object"
         ? message.message
         : null;
@@ -500,6 +529,36 @@ function emitAuthRequired(session, detail) {
             : "Run `claude /login` in a terminal, then retry.",
     });
 }
+function looksLikePlanLimitError(input) {
+    const normalized = input.toLowerCase();
+    return (normalized.includes("rate limit") ||
+        normalized.includes("rate-limit") ||
+        normalized.includes("max turns") ||
+        normalized.includes("max budget") ||
+        normalized.includes("quota") ||
+        normalized.includes("plan limit") ||
+        normalized.includes("too many requests") ||
+        normalized.includes("insufficient quota") ||
+        normalized.includes("429"));
+}
+function classifyTurnErrorKind(subtype, errors, assistantError) {
+    const combined = errors.join("\n");
+    if (subtype === "error_max_turns" ||
+        subtype === "error_max_budget_usd" ||
+        assistantError === "billing_error" ||
+        assistantError === "rate_limit" ||
+        (combined.length > 0 && looksLikePlanLimitError(combined))) {
+        return "plan_limit";
+    }
+    if (assistantError === "authentication_failed" ||
+        errors.some((entry) => looksLikeAuthRequired(entry))) {
+        return "auth_required";
+    }
+    if (assistantError === "server_error") {
+        return "internal";
+    }
+    return "other";
+}
 function numberField(record, ...keys) {
     for (const key of keys) {
         const value = record[key];
@@ -516,6 +575,7 @@ function handleResultMessage(session, message) {
     }
     const subtype = typeof message.subtype === "string" ? message.subtype : "";
     if (subtype === "success") {
+        session.lastAssistantError = undefined;
         finalizeOpenToolCalls(session, "completed");
         writeEvent({ event: "turn_complete", session_id: session.sessionId });
         return;
@@ -523,17 +583,26 @@ function handleResultMessage(session, message) {
     const errors = Array.isArray(message.errors) && message.errors.every((entry) => typeof entry === "string")
         ? message.errors
         : [];
+    const assistantError = session.lastAssistantError;
     const authHint = errors.find((entry) => looksLikeAuthRequired(entry));
     if (authHint) {
         emitAuthRequired(session, authHint);
     }
+    if (assistantError === "authentication_failed") {
+        emitAuthRequired(session);
+    }
     finalizeOpenToolCalls(session, "failed");
+    const errorKind = classifyTurnErrorKind(subtype, errors, assistantError);
     const fallback = subtype ? `turn failed: ${subtype}` : "turn failed";
     writeEvent({
         event: "turn_error",
         session_id: session.sessionId,
         message: errors.length > 0 ? errors.join("\n") : fallback,
+        error_kind: errorKind,
+        ...(subtype ? { sdk_result_subtype: subtype } : {}),
+        ...(assistantError ? { assistant_error: assistantError } : {}),
     });
+    session.lastAssistantError = undefined;
 }
 function handleSdkMessage(session, message) {
     const msg = message;
@@ -1034,8 +1103,17 @@ function handlePermissionResponse(command) {
     resolver.resolve(permissionResult);
 }
 async function handleCommand(command, requestId) {
+    const sdkVersionError = agentSdkVersionCompatibilityError();
+    if (sdkVersionError && command.command !== "initialize" && command.command !== "shutdown") {
+        failConnection(sdkVersionError, requestId);
+        return;
+    }
     switch (command.command) {
         case "initialize":
+            if (sdkVersionError) {
+                failConnection(sdkVersionError, requestId);
+                return;
+            }
             writeEvent({
                 event: "initialized",
                 result: {

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

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, looksLikeAuthRequired, normalizeToolResultText, normalizeToolKind, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, unwrapToolUseResult, } from "./bridge.js";
+import { CACHE_SPLIT_POLICY, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, agentSdkVersionCompatibilityError, looksLikeAuthRequired, normalizeToolResultText, normalizeToolKind, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, resolveInstalledAgentSdkVersion, unwrapToolUseResult, } from "./bridge.js";
 test("parseCommandEnvelope validates initialize command", () => {
     const parsed = parseCommandEnvelope(JSON.stringify({
         request_id: "req-1",
@@ -100,6 +100,12 @@ test("normalizeToolResultText collapses persisted-output payload to first meanin
 `);
     assert.equal(normalized, "Output too large (132.5KB). Full output saved to: C:\\tmp\\tool-results\\bbf63b9.txt");
 });
+test("cache split policy defaults stay aligned with UI thresholds", () => {
+    assert.equal(CACHE_SPLIT_POLICY.softLimitBytes, 1536);
+    assert.equal(CACHE_SPLIT_POLICY.hardLimitBytes, 4096);
+    assert.equal(CACHE_SPLIT_POLICY.previewLimitBytes, 2048);
+    assert.equal(previewKilobyteLabel(CACHE_SPLIT_POLICY), "2KB");
+});
 test("buildToolResultFields uses normalized persisted-output text", () => {
     const fields = buildToolResultFields(false, `<persisted-output>
       │ Output too large (14KB). Full output saved to: C:\\tmp\\tool-results\\x.txt
@@ -327,6 +333,10 @@ test("looksLikeAuthRequired detects login hints", () => {
     assert.equal(looksLikeAuthRequired("Please run /login to continue"), true);
     assert.equal(looksLikeAuthRequired("normal tool output"), false);
 });
+test("agent sdk version compatibility check matches pinned version", () => {
+    assert.equal(resolveInstalledAgentSdkVersion(), "0.2.52");
+    assert.equal(agentSdkVersionCompatibilityError(), undefined);
+});
 function withTempJsonl(lines, run) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-rs-resume-test-"));
     const filePath = path.join(dir, "session.jsonl");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-rust",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Claude Code Rust - native Rust terminal interface for Claude Code",
   "keywords": [
     "cli",