claude-code-rust 0.6.0 → 0.7.1

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { CACHE_SPLIT_POLICY, buildRateLimitUpdate, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, mapAvailableAgents, mapSessionMessagesToUpdates, mapSdkSessions, agentSdkVersionCompatibilityError, looksLikeAuthRequired, normalizeToolResultText, parseFastModeState, parseRateLimitStatus, 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",
@@ -19,6 +19,13 @@ test("parseCommandEnvelope validates resume_session command without cwd", () =>
         request_id: "req-2",
         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, "resume_session");
@@ -26,6 +33,97 @@ test("parseCommandEnvelope validates resume_session command without cwd", () =>
         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/);
@@ -311,7 +409,7 @@ test("permissionResultFromOutcome keeps Bash allow_always suggestions unchanged"
         {
             type: "addRules",
             behavior: "allow",
-            destination: "projectSettings",
+            destination: "localSettings",
             rules: [
                 { toolName: "Bash", ruleContent: "npm install" },
                 { toolName: "WebFetch", ruleContent: "https://example.com" },
@@ -327,7 +425,7 @@ test("permissionResultFromOutcome keeps Bash allow_always suggestions unchanged"
         {
             type: "addRules",
             behavior: "allow",
-            destination: "projectSettings",
+            destination: "localSettings",
             rules: [
                 { toolName: "Bash", ruleContent: "npm install" },
                 { toolName: "WebFetch", ruleContent: "https://example.com" },
@@ -367,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",
@@ -380,45 +478,14 @@ 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);
@@ -486,15 +553,6 @@ test("mapSessionMessagesToUpdates maps message content blocks", () => {
     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,
-    });
 });
 test("mapSessionMessagesToUpdates ignores unsupported records", () => {
     const updates = mapSessionMessagesToUpdates([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-rust",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Claude Code Rust - native Rust terminal interface for Claude Code",
   "keywords": [
     "cli",
@@ -33,7 +33,7 @@
   },
   "scripts": {
     "postinstall": "node ./scripts/postinstall.js",
-    "prepack": "pnpm -C agent-sdk run build"
+    "prepack": "npm --prefix agent-sdk run build"
   },
   "engines": {
     "node": ">=18"

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-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/dist/bridge/usage.js

@@ -1,95 +0,0 @@
-import { asRecordOrNull } from "./shared.js";
-function numberField(record, ...keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === "number" && Number.isFinite(value)) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function selectModelUsageRecord(session, message) {
-    const modelUsageRaw = asRecordOrNull(message.modelUsage);
-    if (!modelUsageRaw) {
-        return null;
-    }
-    const sortedKeys = Object.keys(modelUsageRaw).sort();
-    if (sortedKeys.length === 0) {
-        return null;
-    }
-    const preferredKeys = new Set();
-    if (session?.model) {
-        preferredKeys.add(session.model);
-    }
-    if (typeof message.model === "string") {
-        preferredKeys.add(message.model);
-    }
-    for (const key of preferredKeys) {
-        const value = asRecordOrNull(modelUsageRaw[key]);
-        if (value) {
-            return value;
-        }
-    }
-    for (const key of sortedKeys) {
-        const value = asRecordOrNull(modelUsageRaw[key]);
-        if (value) {
-            return value;
-        }
-    }
-    return null;
-}
-export function buildUsageUpdateFromResultForSession(session, message) {
-    const usage = asRecordOrNull(message.usage);
-    const inputTokens = usage ? numberField(usage, "inputTokens", "input_tokens") : undefined;
-    const outputTokens = usage ? numberField(usage, "outputTokens", "output_tokens") : undefined;
-    const cacheReadTokens = usage
-        ? numberField(usage, "cacheReadInputTokens", "cache_read_input_tokens", "cache_read_tokens")
-        : undefined;
-    const cacheWriteTokens = usage
-        ? numberField(usage, "cacheCreationInputTokens", "cache_creation_input_tokens", "cache_write_tokens")
-        : undefined;
-    const totalCostUsd = numberField(message, "total_cost_usd", "totalCostUsd");
-    let turnCostUsd;
-    if (totalCostUsd !== undefined && session) {
-        if (session.lastTotalCostUsd === undefined) {
-            turnCostUsd = totalCostUsd;
-        }
-        else {
-            turnCostUsd = Math.max(0, totalCostUsd - session.lastTotalCostUsd);
-        }
-        session.lastTotalCostUsd = totalCostUsd;
-    }
-    const modelUsage = selectModelUsageRecord(session, message);
-    const contextWindow = modelUsage
-        ? numberField(modelUsage, "contextWindow", "context_window")
-        : undefined;
-    const maxOutputTokens = modelUsage
-        ? numberField(modelUsage, "maxOutputTokens", "max_output_tokens")
-        : undefined;
-    if (inputTokens === undefined &&
-        outputTokens === undefined &&
-        cacheReadTokens === undefined &&
-        cacheWriteTokens === undefined &&
-        totalCostUsd === undefined &&
-        turnCostUsd === undefined &&
-        contextWindow === undefined &&
-        maxOutputTokens === undefined) {
-        return null;
-    }
-    return {
-        type: "usage_update",
-        usage: {
-            ...(inputTokens !== undefined ? { input_tokens: inputTokens } : {}),
-            ...(outputTokens !== undefined ? { output_tokens: outputTokens } : {}),
-            ...(cacheReadTokens !== undefined ? { cache_read_tokens: cacheReadTokens } : {}),
-            ...(cacheWriteTokens !== undefined ? { cache_write_tokens: cacheWriteTokens } : {}),
-            ...(totalCostUsd !== undefined ? { total_cost_usd: totalCostUsd } : {}),
-            ...(turnCostUsd !== undefined ? { turn_cost_usd: turnCostUsd } : {}),
-            ...(contextWindow !== undefined ? { context_window: contextWindow } : {}),
-            ...(maxOutputTokens !== undefined ? { max_output_tokens: maxOutputTokens } : {}),
-        },
-    };
-}
-export function buildUsageUpdateFromResult(message) {
-    return buildUsageUpdateFromResultForSession(undefined, message);
-}