claude-code-rust 0.3.0 → 0.4.1

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

@@ -0,0 +1,99 @@
+const SESSION_PERMISSION_DESTINATIONS = new Set(["session", "cliArg"]);
+const PERSISTENT_PERMISSION_DESTINATIONS = new Set(["userSettings", "projectSettings", "localSettings"]);
+function formatPermissionRule(rule) {
+    return rule.ruleContent === undefined ? rule.toolName : `${rule.toolName}(${rule.ruleContent})`;
+}
+export function formatPermissionUpdates(updates) {
+    if (!updates || updates.length === 0) {
+        return "<none>";
+    }
+    return updates
+        .map((update) => {
+        if (update.type === "addRules" || update.type === "replaceRules" || update.type === "removeRules") {
+            const rules = update.rules.map((rule) => formatPermissionRule(rule)).join(", ");
+            return `${update.type}:${update.behavior}:${update.destination}=[${rules}]`;
+        }
+        if (update.type === "setMode") {
+            return `${update.type}:${update.mode}:${update.destination}`;
+        }
+        return `${update.type}:${update.destination}=[${update.directories.join(", ")}]`;
+    })
+        .join(" | ");
+}
+function splitPermissionSuggestionsByScope(suggestions) {
+    if (!suggestions || suggestions.length === 0) {
+        return { session: [], persistent: [] };
+    }
+    const session = [];
+    const persistent = [];
+    for (const suggestion of suggestions) {
+        if (SESSION_PERMISSION_DESTINATIONS.has(suggestion.destination)) {
+            session.push(suggestion);
+            continue;
+        }
+        if (PERSISTENT_PERMISSION_DESTINATIONS.has(suggestion.destination)) {
+            persistent.push(suggestion);
+            continue;
+        }
+        session.push(suggestion);
+    }
+    return { session, persistent };
+}
+export function permissionOptionsFromSuggestions(suggestions) {
+    const scoped = splitPermissionSuggestionsByScope(suggestions);
+    const hasSessionScoped = scoped.session.length > 0;
+    const hasPersistentScoped = scoped.persistent.length > 0;
+    const sessionOnly = hasSessionScoped && !hasPersistentScoped;
+    const options = [{ option_id: "allow_once", name: "Allow once", kind: "allow_once" }];
+    options.push({
+        option_id: sessionOnly ? "allow_session" : "allow_always",
+        name: sessionOnly ? "Allow for session" : "Always allow",
+        kind: sessionOnly ? "allow_session" : "allow_always",
+    });
+    options.push({ option_id: "reject_once", name: "Deny", kind: "reject_once" });
+    return options;
+}
+export function permissionResultFromOutcome(outcome, toolCallId, inputData, suggestions, toolName) {
+    const scopedSuggestions = splitPermissionSuggestionsByScope(suggestions);
+    if (outcome.outcome === "selected") {
+        if (outcome.option_id === "allow_once") {
+            return { behavior: "allow", updatedInput: inputData, toolUseID: toolCallId };
+        }
+        if (outcome.option_id === "allow_session") {
+            const sessionSuggestions = scopedSuggestions.session;
+            const fallbackSuggestions = sessionSuggestions.length > 0
+                ? sessionSuggestions
+                : toolName
+                    ? [
+                        {
+                            type: "addRules",
+                            rules: [{ toolName }],
+                            behavior: "allow",
+                            destination: "session",
+                        },
+                    ]
+                    : undefined;
+            return {
+                behavior: "allow",
+                updatedInput: inputData,
+                ...(fallbackSuggestions && fallbackSuggestions.length > 0
+                    ? { updatedPermissions: fallbackSuggestions }
+                    : {}),
+                toolUseID: toolCallId,
+            };
+        }
+        if (outcome.option_id === "allow_always") {
+            const suggestionsForAlways = scopedSuggestions.persistent;
+            return {
+                behavior: "allow",
+                updatedInput: inputData,
+                ...(suggestionsForAlways && suggestionsForAlways.length > 0
+                    ? { updatedPermissions: suggestionsForAlways }
+                    : {}),
+                toolUseID: toolCallId,
+            };
+        }
+        return { behavior: "deny", message: "Permission denied", toolUseID: toolCallId };
+    }
+    return { behavior: "deny", message: "Permission cancelled", toolUseID: toolCallId };
+}

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

@@ -0,0 +1,6 @@
+export function asRecordOrNull(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}

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

@@ -0,0 +1,290 @@
+import { asRecordOrNull } from "./shared.js";
+export const TOOL_RESULT_TYPES = new Set([
+    "tool_result",
+    "tool_search_tool_result",
+    "web_fetch_tool_result",
+    "web_search_tool_result",
+    "code_execution_tool_result",
+    "bash_code_execution_tool_result",
+    "text_editor_code_execution_tool_result",
+    "mcp_tool_result",
+]);
+export function isToolUseBlockType(blockType) {
+    return blockType === "tool_use" || blockType === "server_tool_use" || blockType === "mcp_tool_use";
+}
+export function normalizeToolKind(name) {
+    switch (name) {
+        case "Bash":
+            return "execute";
+        case "Read":
+            return "read";
+        case "Write":
+        case "Edit":
+            return "edit";
+        case "Delete":
+            return "delete";
+        case "Move":
+            return "move";
+        case "Glob":
+        case "Grep":
+            return "search";
+        case "WebFetch":
+            return "fetch";
+        case "TodoWrite":
+            return "other";
+        case "Task":
+            return "think";
+        case "ExitPlanMode":
+            return "switch_mode";
+        default:
+            return "think";
+    }
+}
+export function toolTitle(name, input) {
+    if (name === "Bash") {
+        const command = typeof input.command === "string" ? input.command : "";
+        return command || "Terminal";
+    }
+    if (name === "Glob") {
+        const pattern = typeof input.pattern === "string" ? input.pattern : "";
+        const path = typeof input.path === "string" ? input.path : "";
+        if (pattern && path) {
+            return `Glob ${pattern} in ${path}`;
+        }
+        if (pattern) {
+            return `Glob ${pattern}`;
+        }
+        if (path) {
+            return `Glob ${path}`;
+        }
+    }
+    if (name === "WebFetch") {
+        const url = typeof input.url === "string" ? input.url : "";
+        if (url) {
+            return `WebFetch ${url}`;
+        }
+    }
+    if (name === "WebSearch") {
+        const query = typeof input.query === "string" ? input.query : "";
+        if (query) {
+            return `WebSearch ${query}`;
+        }
+    }
+    if ((name === "Read" || name === "Write" || name === "Edit") && typeof input.file_path === "string") {
+        return `${name} ${input.file_path}`;
+    }
+    return name;
+}
+function editDiffContent(name, input) {
+    const filePath = typeof input.file_path === "string" ? input.file_path : "";
+    if (!filePath) {
+        return [];
+    }
+    if (name === "Edit") {
+        const oldText = typeof input.old_string === "string" ? input.old_string : "";
+        const newText = typeof input.new_string === "string" ? input.new_string : "";
+        if (!oldText && !newText) {
+            return [];
+        }
+        return [{ type: "diff", old_path: filePath, new_path: filePath, old: oldText, new: newText }];
+    }
+    if (name === "Write") {
+        const newText = typeof input.content === "string" ? input.content : "";
+        if (!newText) {
+            return [];
+        }
+        return [{ type: "diff", old_path: filePath, new_path: filePath, old: "", new: newText }];
+    }
+    return [];
+}
+export function createToolCall(toolUseId, name, input) {
+    return {
+        tool_call_id: toolUseId,
+        title: toolTitle(name, input),
+        kind: normalizeToolKind(name),
+        status: "pending",
+        content: editDiffContent(name, input),
+        raw_input: input,
+        locations: typeof input.file_path === "string" ? [{ path: input.file_path }] : [],
+        meta: {
+            claudeCode: {
+                toolName: name,
+            },
+        },
+    };
+}
+export function extractText(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => {
+            if (typeof entry === "string") {
+                return entry;
+            }
+            if (entry && typeof entry === "object" && "text" in entry && typeof entry.text === "string") {
+                return entry.text;
+            }
+            return "";
+        })
+            .filter((part) => part.length > 0)
+            .join("\n");
+    }
+    if (value && typeof value === "object" && "text" in value && typeof value.text === "string") {
+        return value.text;
+    }
+    return "";
+}
+const PERSISTED_OUTPUT_OPEN_TAG = "<persisted-output>";
+const PERSISTED_OUTPUT_CLOSE_TAG = "</persisted-output>";
+function extractPersistedOutputInnerText(text) {
+    const lower = text.toLowerCase();
+    const openIdx = lower.indexOf(PERSISTED_OUTPUT_OPEN_TAG);
+    if (openIdx < 0) {
+        return null;
+    }
+    const bodyStart = openIdx + PERSISTED_OUTPUT_OPEN_TAG.length;
+    const closeIdx = lower.indexOf(PERSISTED_OUTPUT_CLOSE_TAG, bodyStart);
+    if (closeIdx < 0) {
+        return null;
+    }
+    return text.slice(bodyStart, closeIdx);
+}
+function persistedOutputFirstLine(text) {
+    const inner = extractPersistedOutputInnerText(text);
+    if (inner === null) {
+        return null;
+    }
+    for (const line of inner.split(/\r?\n/)) {
+        const cleaned = line.replace(/^[\s|│┃║]+/u, "").trim();
+        if (cleaned.length > 0) {
+            return cleaned;
+        }
+    }
+    return null;
+}
+export function normalizeToolResultText(value) {
+    const text = extractText(value);
+    if (!text) {
+        return "";
+    }
+    const persistedLine = persistedOutputFirstLine(text);
+    if (persistedLine) {
+        return persistedLine;
+    }
+    return text;
+}
+function resolveToolName(toolCall) {
+    const meta = asRecordOrNull(toolCall?.meta);
+    const claudeCode = asRecordOrNull(meta?.claudeCode);
+    const toolName = claudeCode?.toolName;
+    return typeof toolName === "string" ? toolName : "";
+}
+function writeDiffFromInput(rawInput) {
+    const input = asRecordOrNull(rawInput);
+    if (!input) {
+        return [];
+    }
+    const filePath = typeof input.file_path === "string" ? input.file_path : "";
+    const content = typeof input.content === "string" ? input.content : "";
+    if (!filePath || !content) {
+        return [];
+    }
+    return [{ type: "diff", old_path: filePath, new_path: filePath, old: "", new: content }];
+}
+function editDiffFromInput(rawInput) {
+    const input = asRecordOrNull(rawInput);
+    if (!input) {
+        return [];
+    }
+    const filePath = typeof input.file_path === "string" ? input.file_path : "";
+    const oldText = typeof input.old_string === "string"
+        ? input.old_string
+        : typeof input.oldString === "string"
+            ? input.oldString
+            : "";
+    const newText = typeof input.new_string === "string"
+        ? input.new_string
+        : typeof input.newString === "string"
+            ? input.newString
+            : "";
+    if (!filePath || (!oldText && !newText)) {
+        return [];
+    }
+    return [{ type: "diff", old_path: filePath, new_path: filePath, old: oldText, new: newText }];
+}
+function writeDiffFromResult(rawContent) {
+    const candidates = Array.isArray(rawContent) ? rawContent : [rawContent];
+    for (const candidate of candidates) {
+        const record = asRecordOrNull(candidate);
+        if (!record) {
+            continue;
+        }
+        const filePath = typeof record.filePath === "string"
+            ? record.filePath
+            : typeof record.file_path === "string"
+                ? record.file_path
+                : "";
+        const content = typeof record.content === "string" ? record.content : "";
+        const originalRaw = "originalFile" in record ? record.originalFile : "original_file" in record ? record.original_file : undefined;
+        if (!filePath || !content || originalRaw === undefined) {
+            continue;
+        }
+        const original = typeof originalRaw === "string" ? originalRaw : originalRaw === null ? "" : "";
+        return [{ type: "diff", old_path: filePath, new_path: filePath, old: original, new: content }];
+    }
+    return [];
+}
+export function buildToolResultFields(isError, rawContent, base) {
+    const rawOutput = normalizeToolResultText(rawContent);
+    const toolName = resolveToolName(base);
+    const fields = {
+        status: isError ? "failed" : "completed",
+        raw_output: rawOutput || JSON.stringify(rawContent),
+    };
+    if (!isError && toolName === "Write") {
+        const structuredDiff = writeDiffFromResult(rawContent);
+        if (structuredDiff.length > 0) {
+            fields.content = structuredDiff;
+            return fields;
+        }
+        const inputDiff = writeDiffFromInput(base?.raw_input);
+        if (inputDiff.length > 0) {
+            fields.content = inputDiff;
+            return fields;
+        }
+    }
+    if (!isError && toolName === "Edit") {
+        const inputDiff = editDiffFromInput(base?.raw_input);
+        if (inputDiff.length > 0) {
+            fields.content = inputDiff;
+            return fields;
+        }
+        if (base?.content.some((entry) => entry.type === "diff")) {
+            return fields;
+        }
+    }
+    if (rawOutput) {
+        fields.content = [{ type: "content", content: { type: "text", text: rawOutput } }];
+    }
+    return fields;
+}
+export function unwrapToolUseResult(rawResult) {
+    if (!rawResult || typeof rawResult !== "object") {
+        return { isError: false, content: rawResult };
+    }
+    const record = rawResult;
+    const isError = (typeof record.is_error === "boolean" && record.is_error) ||
+        (typeof record.error === "boolean" && record.error);
+    if ("content" in record) {
+        return { isError: Boolean(isError), content: record.content };
+    }
+    if ("result" in record) {
+        return { isError: Boolean(isError), content: record.result };
+    }
+    if ("text" in record) {
+        return { isError: Boolean(isError), content: record.text };
+    }
+    return { isError: Boolean(isError), content: rawResult };
+}

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

@@ -0,0 +1,95 @@
+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);
+}