claude-code-rust 0.5.1 → 0.7.0

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

@@ -1,9 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { CACHE_SPLIT_POLICY, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, agentSdkVersionCompatibilityError, looksLikeAuthRequired, normalizeToolResultText, normalizeToolKind, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, resolveInstalledAgentSdkVersion, unwrapToolUseResult, } from "./bridge.js";
+import { AsyncQueue, CACHE_SPLIT_POLICY, buildRateLimitUpdate, buildQueryOptions, buildToolResultFields, createToolCall, mapAvailableAgents, mapSessionMessagesToUpdates, mapSdkSessions, agentSdkVersionCompatibilityError, looksLikeAuthRequired, normalizeToolResultText, parseFastModeState, parseRateLimitStatus, normalizeToolKind, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, resolveInstalledAgentSdkVersion, unwrapToolUseResult, } from "./bridge.js";
 test("parseCommandEnvelope validates initialize command", () => {
     const parsed = parseCommandEnvelope(JSON.stringify({
         request_id: "req-1",
@@ -17,18 +14,116 @@ test("parseCommandEnvelope validates initialize command", () => {
     }
     assert.equal(parsed.command.cwd, "C:/work");
 });
-test("parseCommandEnvelope validates load_session command without cwd", () => {
+test("parseCommandEnvelope validates resume_session command without cwd", () => {
     const parsed = parseCommandEnvelope(JSON.stringify({
         request_id: "req-2",
-        command: "load_session",
+        command: "resume_session",
         session_id: "session-123",
+        launch_settings: {
+            model: "haiku",
+            language: "German",
+            permission_mode: "plan",
+            thinking_mode: "adaptive",
+            effort_level: "high",
+        },
     }));
     assert.equal(parsed.requestId, "req-2");
-    assert.equal(parsed.command.command, "load_session");
-    if (parsed.command.command !== "load_session") {
+    assert.equal(parsed.command.command, "resume_session");
+    if (parsed.command.command !== "resume_session") {
         throw new Error("unexpected command variant");
     }
     assert.equal(parsed.command.session_id, "session-123");
+    assert.equal(parsed.command.launch_settings.model, "haiku");
+    assert.equal(parsed.command.launch_settings.language, "German");
+    assert.equal(parsed.command.launch_settings.permission_mode, "plan");
+    assert.equal(parsed.command.launch_settings.thinking_mode, "adaptive");
+    assert.equal(parsed.command.launch_settings.effort_level, "high");
+});
+test("buildQueryOptions maps launch settings into sdk query options", () => {
+    const input = new AsyncQueue();
+    const options = buildQueryOptions({
+        cwd: "C:/work",
+        launchSettings: {
+            model: "haiku",
+            language: "German",
+            permission_mode: "plan",
+            thinking_mode: "adaptive",
+            effort_level: "medium",
+        },
+        provisionalSessionId: "session-1",
+        input,
+        canUseTool: async () => ({ behavior: "deny", message: "not used" }),
+        enableSdkDebug: false,
+        enableSpawnDebug: false,
+        sessionIdForLogs: () => "session-1",
+    });
+    assert.equal(options.model, "haiku");
+    assert.deepEqual(options.systemPrompt, {
+        type: "preset",
+        preset: "claude_code",
+        append: "Always respond to the user in German unless the user explicitly asks for a different language. " +
+            "Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.",
+    });
+    assert.equal(options.permissionMode, "plan");
+    assert.deepEqual(options.thinking, { type: "adaptive" });
+    assert.equal(options.effort, "medium");
+    assert.equal(options.sessionId, "session-1");
+    assert.deepEqual(options.settingSources, ["user", "project", "local"]);
+});
+test("buildQueryOptions maps disabled thinking mode into sdk query options", () => {
+    const input = new AsyncQueue();
+    const options = buildQueryOptions({
+        cwd: "C:/work",
+        launchSettings: {
+            thinking_mode: "disabled",
+            effort_level: "high",
+        },
+        provisionalSessionId: "session-3",
+        input,
+        canUseTool: async () => ({ behavior: "deny", message: "not used" }),
+        enableSdkDebug: false,
+        enableSpawnDebug: false,
+        sessionIdForLogs: () => "session-3",
+    });
+    assert.deepEqual(options.thinking, { type: "disabled" });
+    assert.equal("effort" in options, false);
+});
+test("buildQueryOptions omits startup overrides for default logout path", () => {
+    const input = new AsyncQueue();
+    const options = buildQueryOptions({
+        cwd: "C:/work",
+        launchSettings: {},
+        provisionalSessionId: "session-2",
+        input,
+        canUseTool: async () => ({ behavior: "deny", message: "not used" }),
+        enableSdkDebug: false,
+        enableSpawnDebug: false,
+        sessionIdForLogs: () => "session-2",
+    });
+    assert.equal("model" in options, false);
+    assert.equal("permissionMode" in options, false);
+    assert.equal("systemPrompt" in options, false);
+});
+test("buildQueryOptions trims language before appending system prompt", () => {
+    const input = new AsyncQueue();
+    const options = buildQueryOptions({
+        cwd: "C:/work",
+        launchSettings: {
+            language: "  German  ",
+        },
+        provisionalSessionId: "session-4",
+        input,
+        canUseTool: async () => ({ behavior: "deny", message: "not used" }),
+        enableSdkDebug: false,
+        enableSpawnDebug: false,
+        sessionIdForLogs: () => "session-4",
+    });
+    assert.deepEqual(options.systemPrompt, {
+        type: "preset",
+        preset: "claude_code",
+        append: "Always respond to the user in German unless the user explicitly asks for a different language. " +
+            "Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.",
+    });
 });
 test("parseCommandEnvelope rejects missing required fields", () => {
     assert.throws(() => parseCommandEnvelope(JSON.stringify({ command: "set_model", session_id: "s1" })), /set_model\.model must be a string/);
@@ -37,9 +132,76 @@ test("normalizeToolKind maps known tool names", () => {
     assert.equal(normalizeToolKind("Bash"), "execute");
     assert.equal(normalizeToolKind("Delete"), "delete");
     assert.equal(normalizeToolKind("Move"), "move");
+    assert.equal(normalizeToolKind("Task"), "think");
+    assert.equal(normalizeToolKind("Agent"), "think");
     assert.equal(normalizeToolKind("ExitPlanMode"), "switch_mode");
     assert.equal(normalizeToolKind("TodoWrite"), "other");
 });
+test("parseFastModeState accepts known values and rejects unknown values", () => {
+    assert.equal(parseFastModeState("off"), "off");
+    assert.equal(parseFastModeState("cooldown"), "cooldown");
+    assert.equal(parseFastModeState("on"), "on");
+    assert.equal(parseFastModeState("CD"), null);
+    assert.equal(parseFastModeState(undefined), null);
+});
+test("parseRateLimitStatus accepts known values and rejects unknown values", () => {
+    assert.equal(parseRateLimitStatus("allowed"), "allowed");
+    assert.equal(parseRateLimitStatus("allowed_warning"), "allowed_warning");
+    assert.equal(parseRateLimitStatus("rejected"), "rejected");
+    assert.equal(parseRateLimitStatus("warn"), null);
+    assert.equal(parseRateLimitStatus(undefined), null);
+});
+test("buildRateLimitUpdate maps SDK fields to wire shape", () => {
+    const update = buildRateLimitUpdate({
+        status: "allowed_warning",
+        resetsAt: 1_741_280_000,
+        utilization: 0.92,
+        rateLimitType: "five_hour",
+        overageStatus: "rejected",
+        overageResetsAt: 1_741_280_600,
+        overageDisabledReason: "out_of_credits",
+        isUsingOverage: false,
+        surpassedThreshold: 0.9,
+    });
+    assert.deepEqual(update, {
+        type: "rate_limit_update",
+        status: "allowed_warning",
+        resets_at: 1_741_280_000,
+        utilization: 0.92,
+        rate_limit_type: "five_hour",
+        overage_status: "rejected",
+        overage_resets_at: 1_741_280_600,
+        overage_disabled_reason: "out_of_credits",
+        is_using_overage: false,
+        surpassed_threshold: 0.9,
+    });
+});
+test("buildRateLimitUpdate rejects invalid payloads", () => {
+    assert.equal(buildRateLimitUpdate(null), null);
+    assert.equal(buildRateLimitUpdate({}), null);
+    assert.equal(buildRateLimitUpdate({ status: "warning" }), null);
+    assert.deepEqual(buildRateLimitUpdate({
+        status: "rejected",
+        overageStatus: "bad_status",
+    }), { type: "rate_limit_update", status: "rejected" });
+});
+test("mapAvailableAgents normalizes and deduplicates agents", () => {
+    const agents = mapAvailableAgents([
+        { name: "reviewer", description: "", model: "" },
+        { name: "reviewer", description: "Reviews code", model: "haiku" },
+        { name: "explore", description: "Explore codebase", model: "sonnet" },
+        { name: "  ", description: "ignored" },
+        {},
+    ]);
+    assert.deepEqual(agents, [
+        { name: "explore", description: "Explore codebase", model: "sonnet" },
+        { name: "reviewer", description: "Reviews code", model: "haiku" },
+    ]);
+});
+test("mapAvailableAgents rejects non-array payload", () => {
+    assert.deepEqual(mapAvailableAgents(null), []);
+    assert.deepEqual(mapAvailableAgents({}), []);
+});
 test("createToolCall builds edit diff content", () => {
     const toolCall = createToolCall("tc-1", "Edit", {
         file_path: "src/main.rs",
@@ -100,6 +262,26 @@ 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("normalizeToolResultText does not sanitize non-error output", () => {
+    const text = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+    assert.equal(normalizeToolResultText(text), text);
+});
+test("normalizeToolResultText sanitizes exact SDK rejection payloads for errors", () => {
+    const cancelledText = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+    assert.equal(normalizeToolResultText(cancelledText, true), "Cancelled by user.");
+    const deniedText = "Permission for this tool use was denied. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). Try a different approach or report the limitation to complete your task.";
+    assert.equal(normalizeToolResultText(deniedText, true), "Permission denied.");
+});
+test("normalizeToolResultText sanitizes SDK rejection prefixes with user follow-up", () => {
+    const cancelledWithUserMessage = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). To tell you how to proceed, the user said:\nPlease skip this";
+    assert.equal(normalizeToolResultText(cancelledWithUserMessage, true), "Cancelled by user.");
+    const deniedWithUserMessage = "Permission for this tool use was denied. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). The user said:\nNot now";
+    assert.equal(normalizeToolResultText(deniedWithUserMessage, true), "Permission denied.");
+});
+test("normalizeToolResultText does not sanitize substring matches in error output", () => {
+    const bashOutput = "grep output: doesn't want to proceed with this tool use";
+    assert.equal(normalizeToolResultText(bashOutput, true), bashOutput);
+});
 test("cache split policy defaults stay aligned with UI thresholds", () => {
     assert.equal(CACHE_SPLIT_POLICY.softLimitBytes, 1536);
     assert.equal(CACHE_SPLIT_POLICY.hardLimitBytes, 4096);
@@ -124,6 +306,13 @@ test("buildToolResultFields uses normalized persisted-output text", () => {
         },
     ]);
 });
+test("buildToolResultFields sanitizes SDK rejection text only for failed results", () => {
+    const sdkRejectionText = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+    const successFields = buildToolResultFields(false, sdkRejectionText);
+    assert.equal(successFields.raw_output, sdkRejectionText);
+    const errorFields = buildToolResultFields(true, sdkRejectionText);
+    assert.equal(errorFields.raw_output, "Cancelled by user.");
+});
 test("buildToolResultFields maps structured Write output to diff content", () => {
     const base = createToolCall("tc-w", "Write", {
         file_path: "src/main.ts",
@@ -206,7 +395,7 @@ test("permissionOptionsFromSuggestions uses persistent label when settings scope
             type: "addRules",
             behavior: "allow",
             destination: "localSettings",
-            rules: [{ toolName: "Bash", ruleContent: "npm install" }],
+            rules: [{ toolName: "Bash", ruleContent: "pnpm install" }],
         },
     ]);
     assert.deepEqual(options, [
@@ -216,13 +405,13 @@ test("permissionOptionsFromSuggestions uses persistent label when settings scope
     ]);
 });
 test("permissionResultFromOutcome keeps Bash allow_always suggestions unchanged", () => {
-    const allow = permissionResultFromOutcome({ outcome: "selected", option_id: "allow_always" }, "tool-1", { command: "npm install" }, [
+    const allow = permissionResultFromOutcome({ outcome: "selected", option_id: "allow_always" }, "tool-1", { command: "pnpm install" }, [
         {
             type: "addRules",
             behavior: "allow",
-            destination: "projectSettings",
+            destination: "localSettings",
             rules: [
-                { toolName: "Bash", ruleContent: "npm install" },
+                { toolName: "Bash", ruleContent: "pnpm install" },
                 { toolName: "WebFetch", ruleContent: "https://example.com" },
                 { toolName: "Bash", ruleContent: "dir /B" },
             ],
@@ -236,9 +425,9 @@ test("permissionResultFromOutcome keeps Bash allow_always suggestions unchanged"
         {
             type: "addRules",
             behavior: "allow",
-            destination: "projectSettings",
+            destination: "localSettings",
             rules: [
-                { toolName: "Bash", ruleContent: "npm install" },
+                { toolName: "Bash", ruleContent: "pnpm install" },
                 { toolName: "WebFetch", ruleContent: "https://example.com" },
                 { toolName: "Bash", ruleContent: "dir /B" },
             ],
@@ -276,7 +465,7 @@ test("permissionResultFromOutcome falls back to session tool rule for allow_sess
         },
     ]);
 });
-test("permissionResultFromOutcome does not apply session suggestions to allow_always", () => {
+test("permissionResultFromOutcome falls back to localSettings rule for allow_always when only session suggestions exist", () => {
     const allow = permissionResultFromOutcome({ outcome: "selected", option_id: "allow_always" }, "tool-4", { file_path: "C:\\work\\baz.txt" }, [
         {
             type: "addRules",
@@ -289,167 +478,132 @@ test("permissionResultFromOutcome does not apply session suggestions to allow_al
     if (allow.behavior !== "allow") {
         throw new Error("expected allow permission result");
     }
-    assert.equal(allow.updatedPermissions, undefined);
-});
-test("buildUsageUpdateFromResult maps SDK camelCase usage keys", () => {
-    const update = buildUsageUpdateFromResult({
-        usage: {
-            inputTokens: 12,
-            outputTokens: 34,
-            cacheReadInputTokens: 5,
-            cacheCreationInputTokens: 6,
-        },
-    });
-    assert.deepEqual(update, {
-        type: "usage_update",
-        usage: {
-            input_tokens: 12,
-            output_tokens: 34,
-            cache_read_tokens: 5,
-            cache_write_tokens: 6,
-        },
-    });
-});
-test("buildUsageUpdateFromResult includes cost and context window fields", () => {
-    const update = buildUsageUpdateFromResult({
-        total_cost_usd: 1.25,
-        modelUsage: {
-            "claude-sonnet-4-5": {
-                contextWindow: 200000,
-                maxOutputTokens: 64000,
-            },
-        },
-    });
-    assert.deepEqual(update, {
-        type: "usage_update",
-        usage: {
-            total_cost_usd: 1.25,
-            context_window: 200000,
-            max_output_tokens: 64000,
+    assert.deepEqual(allow.updatedPermissions, [
+        {
+            type: "addRules",
+            rules: [{ toolName: "Write" }],
+            behavior: "allow",
+            destination: "localSettings",
         },
-    });
+    ]);
 });
 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(resolveInstalledAgentSdkVersion(), "0.2.63");
     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");
-    fs.writeFileSync(filePath, `${lines.map((line) => JSON.stringify(line)).join("\n")}\n`, "utf8");
-    try {
-        run(filePath);
-    }
-    finally {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-}
-test("extractSessionHistoryUpdatesFromJsonl parses nested progress message records", () => {
-    const lines = [
+test("mapSessionMessagesToUpdates maps message content blocks", () => {
+    const updates = mapSessionMessagesToUpdates([
         {
             type: "user",
+            uuid: "u1",
+            session_id: "s1",
+            parent_tool_use_id: null,
             message: {
                 role: "user",
                 content: [{ type: "text", text: "Top-level user prompt" }],
             },
         },
         {
-            type: "progress",
-            data: {
-                message: {
-                    type: "assistant",
-                    message: {
-                        id: "msg-nested-1",
-                        role: "assistant",
-                        content: [
-                            {
-                                type: "tool_use",
-                                id: "tool-nested-1",
-                                name: "Bash",
-                                input: { command: "echo hello" },
-                            },
-                        ],
-                        usage: {
-                            input_tokens: 11,
-                            output_tokens: 7,
-                            cache_read_input_tokens: 5,
-                            cache_creation_input_tokens: 3,
-                        },
-                    },
+            type: "assistant",
+            uuid: "a1",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                id: "msg-1",
+                role: "assistant",
+                content: [
+                    { type: "tool_use", id: "tool-1", name: "Bash", input: { command: "echo hello" } },
+                    { type: "text", text: "Nested assistant final" },
+                ],
+                usage: {
+                    input_tokens: 11,
+                    output_tokens: 7,
+                    cache_read_input_tokens: 5,
+                    cache_creation_input_tokens: 3,
                 },
             },
         },
         {
-            type: "progress",
-            data: {
-                message: {
-                    type: "user",
-                    message: {
-                        role: "user",
-                        content: [
-                            {
-                                type: "tool_result",
-                                tool_use_id: "tool-nested-1",
-                                content: "ok",
-                                is_error: false,
-                            },
-                        ],
+            type: "user",
+            uuid: "u2",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "tool-1",
+                        content: "ok",
+                        is_error: false,
                     },
-                },
+                ],
             },
         },
+    ]);
+    const variantCounts = new Map();
+    for (const update of updates) {
+        variantCounts.set(update.type, (variantCounts.get(update.type) ?? 0) + 1);
+    }
+    assert.equal(variantCounts.get("user_message_chunk"), 1);
+    assert.equal(variantCounts.get("agent_message_chunk"), 1);
+    assert.equal(variantCounts.get("tool_call"), 1);
+    assert.equal(variantCounts.get("tool_call_update"), 1);
+});
+test("mapSessionMessagesToUpdates ignores unsupported records", () => {
+    const updates = mapSessionMessagesToUpdates([
         {
-            type: "progress",
-            data: {
-                message: {
-                    type: "assistant",
-                    message: {
-                        id: "msg-nested-1",
-                        role: "assistant",
-                        content: [{ type: "text", text: "Nested assistant final" }],
-                        usage: {
-                            input_tokens: 11,
-                            output_tokens: 7,
-                            cache_read_input_tokens: 5,
-                            cache_creation_input_tokens: 3,
-                        },
-                    },
-                },
+            type: "user",
+            uuid: "u1",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                role: "assistant",
+                content: [{ type: "thinking", thinking: "h" }],
             },
         },
-    ];
-    withTempJsonl(lines, (filePath) => {
-        const updates = extractSessionHistoryUpdatesFromJsonl(filePath);
-        const variantCounts = new Map();
-        for (const update of updates) {
-            variantCounts.set(update.type, (variantCounts.get(update.type) ?? 0) + 1);
-        }
-        assert.equal(variantCounts.get("user_message_chunk"), 1);
-        assert.equal(variantCounts.get("agent_message_chunk"), 1);
-        assert.equal(variantCounts.get("tool_call"), 1);
-        assert.equal(variantCounts.get("tool_call_update"), 1);
-        assert.equal(variantCounts.get("usage_update"), 1);
-        const usage = updates.find((update) => update.type === "usage_update");
-        assert.ok(usage && usage.type === "usage_update");
-        assert.deepEqual(usage.usage, {
-            input_tokens: 11,
-            output_tokens: 7,
-            cache_read_tokens: 5,
-            cache_write_tokens: 3,
-        });
-    });
+    ]);
+    assert.equal(updates.length, 0);
 });
-test("extractSessionHistoryUpdatesFromJsonl ignores invalid records", () => {
-    withTempJsonl([
-        { type: "queue-operation", operation: "enqueue" },
-        { type: "progress", data: { not_message: true } },
-        { type: "user", message: { role: "assistant", content: [{ type: "thinking", thinking: "h" }] } },
-    ], (filePath) => {
-        const updates = extractSessionHistoryUpdatesFromJsonl(filePath);
-        assert.equal(updates.length, 0);
-    });
+test("mapSdkSessions normalizes and sorts sessions", () => {
+    const mapped = mapSdkSessions([
+        {
+            sessionId: "older",
+            summary: " Older summary ",
+            lastModified: 100,
+            fileSize: 10,
+            cwd: "C:/work",
+        },
+        {
+            sessionId: "latest",
+            summary: "",
+            lastModified: 200,
+            fileSize: 20,
+            customTitle: "Custom title",
+            gitBranch: "main",
+            firstPrompt: "hello",
+        },
+    ]);
+    assert.deepEqual(mapped, [
+        {
+            session_id: "latest",
+            summary: "Custom title",
+            last_modified_ms: 200,
+            file_size_bytes: 20,
+            git_branch: "main",
+            custom_title: "Custom title",
+            first_prompt: "hello",
+        },
+        {
+            session_id: "older",
+            summary: "Older summary",
+            last_modified_ms: 100,
+            file_size_bytes: 10,
+            cwd: "C:/work",
+        },
+    ]);
 });

package/bin/claude-rs.js

@@ -24,7 +24,7 @@ function resolveInstall() {
     return {
       error:
         `Missing binary at ${binaryPath}\n` +
-        "Reinstall with `npm install -g claude-code-rust` to fetch release artifacts."
+        "Reinstall with `pnpm add -g claude-code-rust` to fetch release artifacts."
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-rust",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Claude Code Rust - native Rust terminal interface for Claude Code",
   "keywords": [
     "cli",
@@ -29,16 +29,15 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.52"
-  },
-  "scripts": {
-    "postinstall": "node ./scripts/postinstall.js",
-    "prepack": "npm --prefix agent-sdk run build"
+    "@anthropic-ai/claude-agent-sdk": "0.2.63"
   },
   "engines": {
     "node": ">=18"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "postinstall": "node ./scripts/postinstall.js"
   }
-}
+}

package/scripts/postinstall.js

@@ -27,7 +27,7 @@ async function downloadFile(url, outPath, redirects = 0) {
   await new Promise((resolve, reject) => {
     const req = https.get(
       url,
-      { headers: { "User-Agent": "claude-code-rust-npm-installer" } },
+      { headers: { "User-Agent": "claude-code-rust-pnpm-installer" } },
       (res) => {
         const status = res.statusCode ?? 0;
 
@@ -60,7 +60,7 @@ async function main() {
   const info = getTargetInfo();
   if (!info) {
     const key = `${process.platform}:${process.arch}`;
-    throw new Error(`Unsupported platform/arch for claude-code-rust npm install: ${key}`);
+    throw new Error(`Unsupported platform/arch for claude-code-rust package install: ${key}`);
   }
 
   const pkgJsonPath = path.join(__dirname, "..", "package.json");

package/agent-sdk/README.md

@@ -1,13 +0,0 @@
-# claude-rs agent-sdk bridge
-
-Initial scaffold for the NDJSON stdio bridge that will connect Rust (`claude-code-rust`) with `@anthropic-ai/claude-agent-sdk`.
-
-## Local build
-
-```bash
-npm install
-npm run build
-```
-
-Build output is written to `dist/bridge.mjs`.
-