@getpaseo/server 0.1.74 → 0.1.76

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

@@ -5,20 +5,26 @@ 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";
 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;
 }
@@ -90,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",
@@ -433,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 {};
@@ -837,7 +876,6 @@ export function readEventIdentifiers(message) {
         ]),
     };
 }
-const claudeDebug = process.env.PASEO_CLAUDE_DEBUG === "1";
 export class ClaudeAgentClient {
     constructor(options) {
         this.provider = "claude";
@@ -853,6 +891,7 @@ export class ClaudeAgentClient {
         return new ClaudeAgentSession(claudeConfig, {
             defaults: this.defaults,
             runtimeSettings: this.runtimeSettings,
+            agentId: launchContext?.agentId,
             launchEnv: launchContext?.env,
             persistSession: options?.persistSession,
             logger: this.logger,
@@ -876,6 +915,7 @@ export class ClaudeAgentClient {
             defaults: this.defaults,
             runtimeSettings: this.runtimeSettings,
             handle,
+            agentId: launchContext?.agentId,
             launchEnv: launchContext?.env,
             logger: this.logger,
             queryFactory: this.queryFactory,
@@ -883,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");
@@ -1202,10 +1242,11 @@ class ClaudeAgentSession {
         };
         this.config = config;
         this.launchEnv = options.launchEnv;
+        this.agentId = options.agentId;
         this.defaults = options.defaults;
         this.runtimeSettings = options.runtimeSettings;
         this.persistSession = options.persistSession;
-        this.logger = options.logger;
+        this.logger = options.logger.child({ agentId: this.agentId });
         this.queryFactory = options.queryFactory;
         this.resolveBinary = options.resolveBinary;
         const handle = options.handle;
@@ -1357,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() {
@@ -1374,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);
@@ -1494,12 +1541,15 @@ class ClaudeAgentSession {
     }
     async close() {
         this.logger.trace({
-            claudeSessionId: this.claudeSessionId,
+            agentId: this.agentId,
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
             turnState: this.turnState,
             hasQuery: Boolean(this.query),
             hasInput: Boolean(this.input),
             hasActiveForegroundTurnId: Boolean(this.activeForegroundTurnId),
-        }, "Claude session close: start");
+        }, "provider.claude.session_close.start");
         this.closed = true;
         this.rejectAllPendingPermissions(new Error("Claude session closed"));
         this.cancelCurrentTurn?.();
@@ -1530,7 +1580,12 @@ class ClaudeAgentSession {
                 }
             }
         }
-        this.logger.trace({ claudeSessionId: this.claudeSessionId, turnState: this.turnState }, "Claude session close: completed");
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            turnState: this.turnState,
+        }, "provider.claude.session_close.complete");
     }
     async listCommands() {
         const q = await this.ensureQuery();
@@ -1670,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) {
@@ -1763,14 +1818,33 @@ class ClaudeAgentSession {
     }
     async awaitWithTimeout(promise, label) {
         if (!promise) {
-            this.logger.trace({ label }, "Claude query operation skipped (no promise)");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: "claude",
+                sessionId: this.claudeSessionId,
+                turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
+                label,
+            }, "provider.claude.query_operation.skip");
             return;
         }
         const startedAt = Date.now();
-        this.logger.trace({ label }, "Claude query operation wait start");
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
+            label,
+        }, "provider.claude.query_operation.start");
         try {
             await withTimeout(promise, 3000, "timeout");
-            this.logger.trace({ label, durationMs: Date.now() - startedAt }, "Claude query operation settled");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: "claude",
+                sessionId: this.claudeSessionId,
+                turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
+                label,
+                durationMs: Date.now() - startedAt,
+            }, "provider.claude.query_operation.settled");
         }
         catch (error) {
             this.logger.warn({ err: error, label }, "Claude query operation did not settle cleanly");
@@ -1790,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: [
@@ -1807,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,
@@ -2107,7 +2185,13 @@ class ClaudeAgentSession {
             return;
         }
         const pump = this.runQueryPump().catch((error) => {
-            this.logger.trace({ err: error }, "Claude query pump exited unexpectedly");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: "claude",
+                sessionId: this.claudeSessionId,
+                turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
+                err: error,
+            }, "provider.claude.query_pump.exit_unexpected");
         });
         this.queryPumpPromise = pump;
         void pump.finally(() => {
@@ -2122,21 +2206,28 @@ class ClaudeAgentSession {
             activeQuery = await this.ensureQuery();
         }
         catch (error) {
-            this.logger.trace({ err: error }, "Failed to initialize Claude query pump");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: "claude",
+                sessionId: this.claudeSessionId,
+                turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
+                err: error,
+            }, "provider.claude.query_pump.init_failed");
             this.failActiveTurns(error instanceof Error ? error.message : "Claude stream failed");
             return;
         }
         let consecutiveInterruptAbortRecoveries = 0;
         const logRawMessage = (message) => {
-            if (!claudeDebug) {
-                return;
-            }
             this.logger.trace({
-                claudeSessionId: this.claudeSessionId,
+                agentId: this.agentId,
+                provider: "claude",
+                sessionId: this.claudeSessionId,
+                turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
                 messageType: message.type,
                 messageSubtype: "subtype" in message ? message.subtype : undefined,
                 messageUuid: "uuid" in message ? message.uuid : undefined,
-            }, "Claude query pump: raw SDK message");
+                rawEvent: message,
+            }, "provider.claude.raw_event");
         };
         const handlePumpedMessage = async (message) => {
             logRawMessage(message);
@@ -2234,13 +2325,15 @@ class ClaudeAgentSession {
         }
         const turnId = this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? null;
         const identifiers = readEventIdentifiers(message);
-        if (claudeDebug) {
-            this.logger.trace({
-                claudeSessionId: this.claudeSessionId,
-                messageType: message.type,
-                turnId,
-            }, "Claude query pump: SDK message");
-        }
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            turnId: turnId ?? undefined,
+            messageType: message.type,
+            identifiers,
+            rawEvent: message,
+        }, "provider.claude.parsed_event");
         const messageEvents = this.translateMessageToEvents(message, {
             suppressAssistantText: true,
             suppressReasoning: true,
@@ -2284,7 +2377,6 @@ class ClaudeAgentSession {
             return false;
         }
         this.logger.warn({
-            claudeSessionId: this.claudeSessionId,
             error: staleResumeError,
         }, "Claude resumed session no longer exists; invalidating persisted session");
         this.failActiveTurns(staleResumeError);
@@ -2307,7 +2399,12 @@ class ClaudeAgentSession {
     async interruptActiveTurn() {
         const queryToInterrupt = this.query;
         if (!queryToInterrupt || typeof queryToInterrupt.interrupt !== "function") {
-            this.logger.trace("interruptActiveTurn: no query to interrupt");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: "claude",
+                sessionId: this.claudeSessionId,
+                turnId: this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? undefined,
+            }, "provider.claude.interrupt.no_query");
             return;
         }
         this.pendingInterruptAbort = true;
@@ -2415,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") {
@@ -2448,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;
@@ -2521,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;
         }
@@ -2759,6 +2877,13 @@ class ClaudeAgentSession {
     notifySubscribers(event) {
         const turnId = this.activeForegroundTurnId ?? this.autonomousTurn?.id;
         const tagged = turnId ? { ...event, turnId } : event;
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: "claude",
+            sessionId: this.claudeSessionId,
+            turnId: getAgentStreamEventTurnId(tagged),
+            event: tagged,
+        }, "provider.claude.event_emit");
         for (const callback of this.subscribers) {
             try {
                 callback(tagged);
@@ -2830,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) {