@getpaseo/server 0.1.75 → 0.1.76

package/dist/server/server/agent/providers/claude/agent.js

@@ -5,13 +5,14 @@ import os from "node:os";
 import path from "node:path";
 import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./tool-call-mapper.js";
 import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./task-notification-tool-call.js";
-import { getClaudeModels, normalizeClaudeRuntimeModelId } from "./models.js";
+import { getClaudeModelsWithSettings, normalizeClaudeRuntimeModelId } from "./models.js";
 import { parsePartialJsonObject } from "./partial-json.js";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { claudeQuery } from "./query.js";
+import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
 import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
 import { createProviderEnv, createProviderEnvSpec, } from "../../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../../utils/executable.js";
@@ -19,7 +20,11 @@ import { withTimeout } from "../../../../utils/promise-timeout.js";
 import { execCommand } from "../../../../utils/spawn.js";
 import { getOrchestratorModeInstructions } from "../../orchestrator-instructions.js";
 const fsPromises = promises;
-const CLAUDE_SETTING_SOURCES = ["user", "project"];
+const CLAUDE_SETTING_SOURCES = [
+    "user",
+    "project",
+    "local",
+];
 function readNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
@@ -91,6 +96,11 @@ const DEFAULT_MODES = [
         label: "Always Ask",
         description: "Prompts for permission the first time a tool is used",
     },
+    {
+        id: "auto",
+        label: "Auto mode",
+        description: "Uses a model classifier to review permission prompts automatically",
+    },
     {
         id: "acceptEdits",
         label: "Accept File Edits",
@@ -434,6 +444,34 @@ function isMcpServersRecord(value) {
 function isPermissionMode(value) {
     return typeof value === "string" && VALID_CLAUDE_MODES.has(value);
 }
+function isTruthyEnvValue(value) {
+    const normalized = value?.trim().toLowerCase();
+    return (normalized !== undefined &&
+        normalized.length > 0 &&
+        normalized !== "0" &&
+        normalized !== "false" &&
+        normalized !== "no" &&
+        normalized !== "off");
+}
+function detectIneligibleAutoModeTransport(env) {
+    if (isTruthyEnvValue(env.CLAUDE_CODE_USE_BEDROCK)) {
+        return "Bedrock";
+    }
+    if (isTruthyEnvValue(env.CLAUDE_CODE_USE_VERTEX)) {
+        return "Vertex";
+    }
+    return null;
+}
+function assertClaudeAutoModeEligible(mode, env) {
+    if (mode !== "auto") {
+        return;
+    }
+    const transport = detectIneligibleAutoModeTransport(env);
+    if (transport === null) {
+        return;
+    }
+    throw new Error(`Claude Auto mode requires the Anthropic API and is not supported when Claude Code uses ${transport}. Select another permission mode or unset the ${transport === "Bedrock" ? "CLAUDE_CODE_USE_BEDROCK" : "CLAUDE_CODE_USE_VERTEX"} environment variable.`);
+}
 function coerceSessionMetadata(metadata) {
     if (!isMetadata(metadata)) {
         return {};
@@ -885,8 +923,8 @@ export class ClaudeAgentClient {
         });
     }
     async listModels(_options) {
-        // Claude exposes a static catalog here; cwd/force are intentionally irrelevant.
-        return getClaudeModels();
+        // Claude exposes a global catalog here; cwd/force are intentionally irrelevant.
+        return await getClaudeModelsWithSettings(this.logger);
     }
     async listPersistedAgents(options) {
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
@@ -1360,8 +1398,13 @@ class ClaudeAgentSession {
         const history = this.persistedHistory;
         this.persistedHistory = [];
         this.historyPending = false;
-        for (const item of history) {
-            yield { type: "timeline", item, provider: "claude" };
+        for (const entry of history) {
+            yield {
+                type: "timeline",
+                item: entry.item,
+                provider: "claude",
+                timestamp: entry.timestamp,
+            };
         }
     }
     async getAvailableModes() {
@@ -1377,6 +1420,7 @@ class ClaudeAgentSession {
             throw new Error(`Invalid mode '${modeId}' for Claude provider. Valid modes: ${validModesList}`);
         }
         const normalized = isPermissionMode(modeId) ? modeId : "default";
+        assertClaudeAutoModeEligible(normalized, this.buildSdkEnv(this.config.extra?.claude));
         const previousMode = this.currentMode;
         const activeQuery = await this.ensureQuery();
         await activeQuery.setPermissionMode(normalized);
@@ -1681,9 +1725,9 @@ class ClaudeAgentSession {
             pushUnique(historyIds[idx]);
         }
         for (let idx = this.persistedHistory.length - 1; idx >= 0; idx -= 1) {
-            const item = this.persistedHistory[idx];
-            if (item?.type === "user_message") {
-                pushUnique(item.messageId);
+            const entry = this.persistedHistory[idx];
+            if (entry?.item.type === "user_message") {
+                pushUnique(entry.item.messageId);
             }
         }
         for (let idx = this.userMessageIds.length - 1; idx >= 0; idx -= 1) {
@@ -1820,11 +1864,8 @@ class ClaudeAgentSession {
             .filter((entry) => typeof entry === "string" && entry.length > 0)
             .join("\n\n");
     }
-    async buildOptions() {
-        const { thinking, effort } = this.resolveThinkingConfig();
-        const appendedSystemPrompt = this.buildAppendedSystemPrompt();
-        const extraClaudeOptions = this.config.extra?.claude;
-        const sdkEnv = createProviderEnv({
+    buildSdkEnv(extraClaudeOptions) {
+        return createProviderEnv({
             baseEnv: process.env,
             runtimeSettings: this.runtimeSettings,
             overlays: [
@@ -1837,6 +1878,13 @@ class ClaudeAgentSession {
                 this.launchEnv,
             ],
         });
+    }
+    async buildOptions() {
+        const { thinking, effort } = this.resolveThinkingConfig();
+        const appendedSystemPrompt = this.buildAppendedSystemPrompt();
+        const extraClaudeOptions = this.config.extra?.claude;
+        const sdkEnv = this.buildSdkEnv(extraClaudeOptions);
+        assertClaudeAutoModeEligible(this.currentMode, sdkEnv);
         const claudeBinary = await this.resolveBinary();
         this.logger.debug({
             claudeBinary,
@@ -2464,29 +2512,7 @@ class ClaudeAgentSession {
             return;
         }
         if (message.subtype === "task_notification") {
-            // TODO: subagent timelines are best-effort. Subagent task_notifications
-            // arrive without parent_tool_use_id but with tool_use_id pointing at the
-            // parent's Task call, so they slip past the sidechain router and pollute
-            // the parent timeline. Drop them here; eventually thread them into the
-            // parent Task tool call's sub_agent log instead.
-            const taskUseId = message.tool_use_id;
-            const cachedTool = taskUseId ? this.toolUseCache.get(taskUseId) : undefined;
-            if (cachedTool?.name === "Task") {
-                return;
-            }
-            const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
-            if (taskNotificationItem) {
-                events.push({
-                    type: "timeline",
-                    item: taskNotificationItem,
-                    provider: "claude",
-                });
-            }
-            const usage = readUsageFromTaskNotification(message);
-            if (typeof usage === "number") {
-                this.lastContextWindowUsedTokens = usage;
-                events.push(this.createUsageUpdatedEvent(usage));
-            }
+            this.appendTaskNotificationEvents(message, events);
             return;
         }
         if (message.subtype === "task_progress") {
@@ -2497,6 +2523,31 @@ class ClaudeAgentSession {
             }
         }
     }
+    appendTaskNotificationEvents(message, events) {
+        // TODO: subagent timelines are best-effort. Subagent task_notifications
+        // arrive without parent_tool_use_id but with tool_use_id pointing at the
+        // parent's Task call, so they slip past the sidechain router and pollute
+        // the parent timeline. Drop them here; eventually thread them into the
+        // parent Task tool call's sub_agent log instead.
+        const taskUseId = message.tool_use_id;
+        const cachedTool = taskUseId ? this.toolUseCache.get(taskUseId) : undefined;
+        if (cachedTool?.name === "Task") {
+            return;
+        }
+        const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
+        if (taskNotificationItem) {
+            events.push({
+                type: "timeline",
+                item: taskNotificationItem,
+                provider: "claude",
+            });
+        }
+        const usage = readUsageFromTaskNotification(message);
+        if (typeof usage === "number") {
+            this.lastContextWindowUsedTokens = usage;
+            events.push(this.createUsageUpdatedEvent(usage));
+        }
+    }
     appendUserMessageEvents(message, events) {
         if (isSyntheticUserEntry(message)) {
             return;
@@ -2570,6 +2621,24 @@ class ClaudeAgentSession {
     appendResultEvents(message, events) {
         const usage = this.convertUsage(message, message.modelUsage);
         if (message.subtype === "success") {
+            // Built-in slash commands (e.g. /voice, /usage, "Unknown command: …")
+            // run client-side in the Claude CLI with no model turn — output_tokens
+            // is 0 and the user-visible text is carried in `result`. Surface it as
+            // an assistant message so the turn doesn't end silently. Normal turns
+            // have output_tokens > 0 and their text is already in the stream.
+            const resultText = typeof message.result === "string" ? message.result.trim() : "";
+            const outputTokens = message.usage?.output_tokens;
+            if (resultText.length > 0 && outputTokens === 0) {
+                events.push({
+                    type: "timeline",
+                    provider: "claude",
+                    item: {
+                        type: "assistant_message",
+                        text: resultText,
+                        messageId: message.uuid,
+                    },
+                });
+            }
             events.push({ type: "turn_completed", provider: "claude", usage });
             return;
         }
@@ -2886,9 +2955,13 @@ class ClaudeAgentSession {
         if (entry.type === "user" && typeof entry.uuid === "string") {
             this.rememberUserMessageId(entry.uuid);
         }
+        const historyTimestamp = normalizeProviderReplayTimestamp(entry.timestamp);
         const items = this.convertHistoryEntry(entry);
         if (items.length > 0) {
-            timeline.push(...items);
+            timeline.push(...items.map((item) => ({
+                item,
+                timestamp: historyTimestamp ?? undefined,
+            })));
         }
     }
     resolveHistoryPath(sessionId) {