@getpaseo/server 0.1.16 → 0.1.17

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

@@ -6,23 +6,16 @@ import os from "node:os";
 import path from "node:path";
 import { query, } from "@anthropic-ai/claude-agent-sdk";
 import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./claude/tool-call-mapper.js";
+import { isTaskNotificationUserContent, mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
+import { buildClaudeModelFamilyAliases, buildClaudeSelectableModelIds, listClaudeCatalogModels, } from "./claude/model-catalog.js";
 import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
 import { applyProviderEnv, isProviderCommandAvailable, } from "../provider-launch-config.js";
 import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
 const fsPromises = promises;
-function normalizeClaudeModelLabel(model) {
-    const fallback = model.displayName?.trim() || model.value;
-    const prefix = model.description?.split(/[·•]/)[0]?.trim() || "";
-    if (!prefix)
-        return fallback;
-    // Prefer concrete versioned labels from description (e.g. "Opus 4.6",
-    // "Sonnet 4.5"), especially when displayName is generic like
-    // "Default (recommended)".
-    if (/\d/.test(prefix)) {
-        return prefix;
-    }
-    return fallback;
-}
+const CLAUDE_SETTING_SOURCES = [
+    "user",
+    "project",
+];
 function normalizeModelIdCandidate(modelId) {
     if (typeof modelId !== "string") {
         return null;
@@ -37,6 +30,28 @@ function pickSupportedModelId(supportedModelIds, candidate) {
     }
     return supportedModelIds.has(normalizedCandidate) ? normalizedCandidate : null;
 }
+function inferClaudeModelFamilyFromText(text) {
+    if (typeof text !== "string") {
+        return null;
+    }
+    const lowerText = text.toLowerCase();
+    if (lowerText.includes("sonnet")) {
+        return "sonnet";
+    }
+    if (lowerText.includes("opus")) {
+        return "opus";
+    }
+    if (lowerText.includes("haiku")) {
+        return "haiku";
+    }
+    return null;
+}
+function pickFamilyAliasModelId(familyAliases, family) {
+    if (!familyAliases) {
+        return null;
+    }
+    return normalizeModelIdCandidate(familyAliases.get(family) ?? null);
+}
 export function normalizeClaudeRuntimeModelId(options) {
     const runtimeModel = options.runtimeModelId.trim();
     if (!runtimeModel) {
@@ -46,31 +61,43 @@ export function normalizeClaudeRuntimeModelId(options) {
     if (!supportedModelIds || supportedModelIds.size === 0) {
         return runtimeModel;
     }
-    const lowerRuntimeModel = runtimeModel.toLowerCase();
-    if (lowerRuntimeModel.includes("sonnet")) {
+    if (supportedModelIds.has(runtimeModel)) {
+        return runtimeModel;
+    }
+    const runtimeFamily = inferClaudeModelFamilyFromText(runtimeModel);
+    const familyAlias = runtimeFamily
+        ? pickFamilyAliasModelId(options.supportedModelFamilyAliases, runtimeFamily)
+        : null;
+    if (runtimeFamily === "sonnet") {
         const explicitSonnet = pickSupportedModelId(supportedModelIds, "sonnet");
         if (explicitSonnet) {
             return explicitSonnet;
         }
+        if (familyAlias && supportedModelIds.has(familyAlias)) {
+            return familyAlias;
+        }
         const defaultAlias = pickSupportedModelId(supportedModelIds, "default");
         if (defaultAlias) {
             return defaultAlias;
         }
     }
-    if (lowerRuntimeModel.includes("opus")) {
+    if (runtimeFamily === "opus") {
         const alias = pickSupportedModelId(supportedModelIds, "opus");
         if (alias) {
             return alias;
         }
+        if (familyAlias && supportedModelIds.has(familyAlias)) {
+            return familyAlias;
+        }
     }
-    if (lowerRuntimeModel.includes("haiku")) {
+    if (runtimeFamily === "haiku") {
         const alias = pickSupportedModelId(supportedModelIds, "haiku");
         if (alias) {
             return alias;
         }
-    }
-    if (supportedModelIds.has(runtimeModel)) {
-        return runtimeModel;
+        if (familyAlias && supportedModelIds.has(familyAlias)) {
+            return familyAlias;
+        }
     }
     const configuredModelId = pickSupportedModelId(supportedModelIds, options.configuredModelId);
     if (configuredModelId) {
@@ -80,6 +107,15 @@ export function normalizeClaudeRuntimeModelId(options) {
     if (currentModelId) {
         return currentModelId;
     }
+    // If Claude reports a concrete family ID we can't map directly, prefer the
+    // provider default alias for unconfigured sessions so UI model/thinking state
+    // can still reconcile against the current model catalog.
+    const defaultAlias = pickSupportedModelId(supportedModelIds, "default");
+    const hasConfiguredModel = normalizeModelIdCandidate(options.configuredModelId) !== null;
+    const hasCurrentModel = normalizeModelIdCandidate(options.currentModelId) !== null;
+    if (runtimeFamily && defaultAlias && !hasConfiguredModel && !hasCurrentModel) {
+        return defaultAlias;
+    }
     return runtimeModel;
 }
 const CLAUDE_CAPABILITIES = {
@@ -172,6 +208,7 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings) {
         },
     };
 }
+const MAX_RECENT_STDERR_CHARS = 4000;
 function summarizeClaudeOptionsForLog(options) {
     const systemPromptRaw = options.systemPrompt;
     const systemPromptSummary = (() => {
@@ -860,8 +897,17 @@ function isMetadataOnlySdkMessage(message) {
     if (message.type !== "user") {
         return false;
     }
+    if (isSyntheticUserEntry(message)) {
+        return true;
+    }
     return isTaskNotificationUserContent(message.message?.content);
 }
+function isSyntheticUserEntry(entry) {
+    if (!entry || typeof entry !== "object") {
+        return false;
+    }
+    return entry.isSynthetic === true;
+}
 export function readEventIdentifiers(message) {
     const root = message;
     const messageType = readTrimmedString(root.type);
@@ -889,23 +935,6 @@ export function readEventIdentifiers(message) {
             null,
     };
 }
-function isTaskNotificationUserContent(content) {
-    if (typeof content === "string") {
-        return content.includes("<task-notification>");
-    }
-    if (!Array.isArray(content)) {
-        return false;
-    }
-    for (const block of content) {
-        if (block &&
-            typeof block === "object" &&
-            typeof block.text === "string" &&
-            block.text.includes("<task-notification>")) {
-            return true;
-        }
-    }
-    return false;
-}
 export class ClaudeAgentClient {
     constructor(options) {
         this.provider = "claude";
@@ -920,9 +949,6 @@ export class ClaudeAgentClient {
             this.claudePath = null;
         }
     }
-    applyRuntimeSettings(options) {
-        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings);
-    }
     async createSession(config) {
         const claudeConfig = this.assertConfig(config);
         return new ClaudeAgentSession(claudeConfig, {
@@ -948,45 +974,8 @@ export class ClaudeAgentClient {
             logger: this.logger,
         });
     }
-    async listModels(options) {
-        const prompt = (async function* empty() { })();
-        const claudeOptions = {
-            cwd: options?.cwd ?? process.cwd(),
-            permissionMode: "plan",
-            includePartialMessages: false,
-            ...(this.claudePath ? { pathToClaudeCodeExecutable: this.claudePath } : {}),
-        };
-        const claudeQuery = query({
-            prompt,
-            options: this.applyRuntimeSettings(claudeOptions),
-        });
-        try {
-            const models = await claudeQuery.supportedModels();
-            return models.map((model) => ({
-                provider: "claude",
-                id: model.value,
-                label: normalizeClaudeModelLabel(model),
-                description: model.description,
-                thinkingOptions: [
-                    { id: "off", label: "Off", isDefault: true },
-                    { id: "on", label: "On" },
-                ],
-                defaultThinkingOptionId: "off",
-                metadata: {
-                    description: model.description,
-                },
-            }));
-        }
-        finally {
-            if (typeof claudeQuery.return === "function") {
-                try {
-                    await claudeQuery.return();
-                }
-                catch {
-                    // ignore shutdown errors
-                }
-            }
-        }
+    async listModels(_options) {
+        return listClaudeCatalogModels();
     }
     async listPersistedAgents(options) {
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
@@ -1048,7 +1037,8 @@ class ClaudeAgentSession {
         this.activeTurnPromise = null;
         this.cachedRuntimeInfo = null;
         this.lastOptionsModel = null;
-        this.selectableModelIds = null;
+        this.selectableModelIds = buildClaudeSelectableModelIds();
+        this.selectableModelFamilyAliases = buildClaudeModelFamilyAliases();
         this.activeSidechains = new Map();
         this.compacting = false;
         this.queryPumpPromise = null;
@@ -1056,6 +1046,7 @@ class ClaudeAgentSession {
         this.userMessageIds = [];
         this.localUserMessageIds = new Set();
         this.suppressLocalReplayActivity = false;
+        this.recentStderr = "";
         this.closed = false;
         this.handlePermissionRequest = async (toolName, input, options) => {
             const requestId = `permission-${randomUUID()}`;
@@ -1236,6 +1227,7 @@ class ClaudeAgentSession {
         this.activeForegroundTurn = foregroundTurn;
         this.preReplayMetadataSeen = false;
         this.transitionTurnState("foreground", "foreground stream started");
+        this.clearRecentStderr();
         let finishedNaturally = false;
         let cancelIssued = false;
         let queueDrainedWithoutTerminal = false;
@@ -1458,6 +1450,13 @@ class ClaudeAgentSession {
         return this.persistence;
     }
     async close() {
+        this.logger.trace({
+            claudeSessionId: this.claudeSessionId,
+            turnState: this.turnState,
+            hasQuery: Boolean(this.query),
+            hasInput: Boolean(this.input),
+            hasActiveForegroundTurn: Boolean(this.activeForegroundTurn),
+        }, "Claude session close: start");
         this.closed = true;
         this.rejectAllPendingPermissions(new Error("Claude session closed"));
         this.cancelCurrentTurn?.();
@@ -1474,6 +1473,7 @@ class ClaudeAgentSession {
         await this.awaitWithTimeout(this.query?.return?.(), "close query return");
         this.query = null;
         this.input = null;
+        this.logger.trace({ claudeSessionId: this.claudeSessionId, turnState: this.turnState }, "Claude session close: completed");
     }
     async listCommands() {
         const q = await this.ensureQuery();
@@ -1708,20 +1708,6 @@ class ClaudeAgentSession {
         }
         this.userMessageIds.push(messageId);
     }
-    async primeSelectableModelIds(query) {
-        try {
-            const models = await query.supportedModels();
-            const ids = models
-                .map((model) => model.value?.trim())
-                .filter((id) => typeof id === "string" && id.length > 0);
-            this.selectableModelIds = new Set(ids);
-            this.logger.debug({ modelIds: ids }, "Primed Claude selectable model IDs");
-        }
-        catch (error) {
-            this.selectableModelIds = null;
-            this.logger.warn({ err: error }, "Failed to prime Claude selectable model IDs");
-        }
-    }
     async ensureQuery() {
         if (this.query && !this.queryRestartNeeded) {
             return this.query;
@@ -1741,15 +1727,19 @@ class ClaudeAgentSession {
         this.logger.debug({ options: summarizeClaudeOptionsForLog(options) }, "claude query");
         this.input = input;
         this.query = query({ prompt: input, options });
-        // Do not block query readiness on control-plane calls. We need `next()` to
-        // start immediately so autonomous wake events are not missed between turns.
-        void this.awaitWithTimeout(this.primeSelectableModelIds(this.query), "prime selectable model ids");
+        // Do not kick off background control-plane queries here. Methods like
+        // supportedCommands()/setPermissionMode() may execute immediately after
+        // ensureQuery() (for listCommands()/setMode()), and sharing the same query
+        // control plane can cause those calls to wait behind supportedModels().
         return this.query;
     }
     async awaitWithTimeout(promise, label) {
         if (!promise) {
+            this.logger.trace({ label }, "Claude query operation skipped (no promise)");
             return;
         }
+        const startedAt = Date.now();
+        this.logger.trace({ label }, "Claude query operation wait start");
         try {
             await Promise.race([
                 promise,
@@ -1757,6 +1747,7 @@ class ClaudeAgentSession {
                     setTimeout(() => reject(new Error("timeout")), 3000);
                 }),
             ]);
+            this.logger.trace({ label, durationMs: Date.now() - startedAt }, "Claude query operation settled");
         }
         catch (error) {
             this.logger.warn({ err: error, label }, "Claude query operation did not settle cleanly");
@@ -1794,8 +1785,9 @@ class ClaudeAgentSession {
                 preset: "claude_code",
                 append: appendedSystemPrompt,
             },
-            settingSources: ["user", "project"],
+            settingSources: CLAUDE_SETTING_SOURCES,
             stderr: (data) => {
+                this.captureStderr(data);
                 this.logger.error({ stderr: data.trim() }, "Claude Agent SDK stderr");
             },
             env: {
@@ -1907,17 +1899,53 @@ class ClaudeAgentSession {
         this.transitionTurnState("idle", reason);
     }
     failRun(run, errorMessage) {
-        this.emitRunEvent(run, {
+        this.emitRunEvent(run, this.buildTurnFailedEvent(errorMessage));
+    }
+    buildTurnFailedEvent(errorMessage) {
+        const normalized = errorMessage.trim() || "Claude run failed";
+        const exitCodeMatch = normalized.match(/\bcode\s+(\d+)\b/i);
+        const code = exitCodeMatch ? exitCodeMatch[1] : undefined;
+        const diagnostic = this.getRecentStderrDiagnostic();
+        return {
             type: "turn_failed",
             provider: "claude",
-            error: errorMessage,
-        });
+            error: normalized,
+            ...(code ? { code } : {}),
+            ...(diagnostic ? { diagnostic } : {}),
+        };
+    }
+    captureStderr(data) {
+        const text = data.trim();
+        if (!text) {
+            return;
+        }
+        const combined = this.recentStderr ? `${this.recentStderr}\n${text}` : text;
+        this.recentStderr = combined.slice(-MAX_RECENT_STDERR_CHARS);
+    }
+    clearRecentStderr() {
+        this.recentStderr = "";
+    }
+    getRecentStderrDiagnostic() {
+        const text = this.recentStderr.trim();
+        return text.length > 0 ? text : undefined;
     }
     cancelRun(run, event) {
         this.flushPendingToolCalls();
         this.emitRunEvent(run, event);
     }
     emitRunEvent(run, event) {
+        if (event.type === "turn_started" ||
+            event.type === "turn_completed" ||
+            event.type === "turn_failed" ||
+            event.type === "turn_canceled") {
+            this.logger.trace({
+                runId: run.id,
+                owner: run.owner,
+                runState: run.state,
+                eventType: event.type,
+                routedTo: run.owner === "foreground" && run.queue ? "foreground_queue" : "live_queue",
+            }, "Claude run event emitted");
+        }
         if (run.owner === "foreground" && run.queue) {
             run.queue.push(event);
             if (event.type === "turn_completed" ||
@@ -1948,6 +1976,13 @@ class ClaudeAgentSession {
             this.activeForegroundTurn = null;
             this.preReplayMetadataSeen = false;
         }
+        this.logger.trace({
+            runId: run.id,
+            owner: run.owner,
+            eventType: event.type,
+            runState: run.state,
+            hasActiveForegroundTurn: Boolean(this.activeForegroundTurn),
+        }, "Claude run terminal event handled");
         this.transitionTurnStateFromActiveRuns(`run ${run.id} terminal`);
     }
     async transitionAutonomousToForeground() {
@@ -2056,6 +2091,9 @@ class ClaudeAgentSession {
         // first turn cannot be stranded in autonomous fallback. If metadata churn
         // was observed pre-replay, stay conservative and wait for replay.
         if (!run.promptReplaySeen) {
+            if (this.isToolUseBoundaryStreamEvent(input.message)) {
+                return true;
+            }
             // Keep pre-replay result events with the foreground run so stale result
             // bursts cannot consume autonomous wake reservations.
             if (message.type === "result") {
@@ -2074,6 +2112,19 @@ class ClaudeAgentSession {
         }
         return true;
     }
+    isToolUseBoundaryStreamEvent(message) {
+        if (message.type !== "stream_event") {
+            return false;
+        }
+        const event = message.event;
+        if (!event || event.type !== "message_delta") {
+            return false;
+        }
+        const delta = "delta" in event && event.delta && typeof event.delta === "object"
+            ? event.delta
+            : null;
+        return delta?.stop_reason === "tool_use";
+    }
     notePreReplayMetadata(message) {
         if (this.turnState !== "foreground") {
             return;
@@ -2153,6 +2204,7 @@ class ClaudeAgentSession {
             let next;
             try {
                 next = await q.next();
+                this.logger.info({ claudeSessionId: this.claudeSessionId, next }, "Claude query pump raw next()");
             }
             catch (error) {
                 this.logger.warn({ err: error }, "Claude query pump next() failed");
@@ -2169,6 +2221,10 @@ class ClaudeAgentSession {
                 continue;
             }
             if (next.done) {
+                this.logger.trace({
+                    claudeSessionId: this.claudeSessionId,
+                    activeRunCount: this.runTracker.listActiveRuns().length,
+                }, "Claude query pump next() returned done");
                 this.input?.end();
                 await this.awaitWithTimeout(q.return?.(), "query pump return on done");
                 if (this.query === q) {
@@ -2211,6 +2267,15 @@ class ClaudeAgentSession {
             run: route.run,
             message,
         });
+        this.logger.trace({
+            claudeSessionId: this.claudeSessionId,
+            messageType: message.type,
+            routeReason: route.reason,
+            runId: route.run?.id ?? null,
+            runOwner: route.run?.owner ?? null,
+            suppressTerminalEvents,
+            metadataOnly,
+        }, "Claude query pump routed SDK message");
         if (route.run) {
             this.transitionTurnStateFromActiveRuns(`routed via ${route.reason}`);
             this.runTracker.bindIdentifiers(route.run, identifiers);
@@ -2262,6 +2327,13 @@ class ClaudeAgentSession {
         // Pre-replay success results are stale in practice (leftover from an
         // earlier query segment) and must not end the current foreground run.
         if (resultSubtype === "success") {
+            this.logger.trace({
+                runId: run.id,
+                runOwner: run.owner,
+                runState: run.state,
+                promptReplaySeen: run.promptReplaySeen,
+                resultSubtype,
+            }, "Suppressing pre-replay foreground success result terminal event");
             return true;
         }
         // For non-success results, keep the metadata-churn guard to avoid
@@ -2274,6 +2346,7 @@ class ClaudeAgentSession {
         }
     }
     updateRunLifecycleForMessage(run, message, identifiers) {
+        const previousState = run.state;
         if (message.type === "user" &&
             identifiers.messageId &&
             run.messageIds.has(identifiers.messageId)) {
@@ -2291,8 +2364,22 @@ class ClaudeAgentSession {
         }
         if (message.type === "result") {
             this.runTracker.transition(run, "finalizing");
+        }
+        else {
             return;
         }
+        if (run.state !== previousState) {
+            this.logger.trace({
+                runId: run.id,
+                owner: run.owner,
+                messageType: message.type,
+                previousState,
+                nextState: run.state,
+                taskId: identifiers.taskId,
+                parentMessageId: identifiers.parentMessageId,
+                messageId: identifiers.messageId,
+            }, "Updated Claude run lifecycle from SDK message");
+        }
     }
     shouldSuppressLocalReplayActivity(message) {
         const localReplay = this.isLocalReplayUserMessage(message);
@@ -2631,8 +2718,21 @@ class ClaudeAgentSession {
                         provider: "claude",
                     });
                 }
+                else if (message.subtype === "task_notification") {
+                    const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
+                    if (taskNotificationItem) {
+                        events.push({
+                            type: "timeline",
+                            item: taskNotificationItem,
+                            provider: "claude",
+                        });
+                    }
+                }
                 break;
             case "user": {
+                if (isSyntheticUserEntry(message)) {
+                    break;
+                }
                 if (this.compacting) {
                     this.compacting = false;
                     break;
@@ -2642,6 +2742,18 @@ class ClaudeAgentSession {
                     : undefined;
                 this.rememberUserMessageId(messageId);
                 const content = message.message?.content;
+                const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
+                    content,
+                    messageId,
+                });
+                if (taskNotificationItem) {
+                    events.push({
+                        type: "timeline",
+                        item: taskNotificationItem,
+                        provider: "claude",
+                    });
+                    break;
+                }
                 if (typeof content === "string" && content.length > 0) {
                     // String content from user messages (e.g., local command output)
                     events.push({
@@ -2702,7 +2814,7 @@ class ClaudeAgentSession {
                     const errorMessage = "errors" in message && Array.isArray(message.errors) && message.errors.length > 0
                         ? message.errors.join("\n")
                         : "Claude run failed";
-                    events.push({ type: "turn_failed", provider: "claude", error: errorMessage });
+                    events.push(this.buildTurnFailedEvent(errorMessage));
                 }
                 break;
             }
@@ -2779,6 +2891,7 @@ class ClaudeAgentSession {
             const normalizedModel = normalizeClaudeRuntimeModelId({
                 runtimeModelId: message.model,
                 supportedModelIds: this.selectableModelIds,
+                supportedModelFamilyAliases: this.selectableModelFamilyAliases,
                 configuredModelId: this.config.model ?? null,
                 currentModelId: this.lastOptionsModel,
             });
@@ -3379,9 +3492,18 @@ export function convertClaudeHistoryEntry(entry, mapBlocks) {
                 preTokens: compactMetadata?.preTokens,
             }];
     }
+    if (entry.type === "system") {
+        const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(entry);
+        if (taskNotificationItem) {
+            return [taskNotificationItem];
+        }
+    }
     if (entry.isCompactSummary) {
         return [];
     }
+    if (entry.type === "user" && isSyntheticUserEntry(entry)) {
+        return [];
+    }
     const message = entry?.message;
     if (!message || !("content" in message)) {
         return [];
@@ -3392,17 +3514,26 @@ export function convertClaudeHistoryEntry(entry, mapBlocks) {
         ? content
         : normalizedBlocks;
     const hasToolBlock = normalizedBlocks?.some((block) => hasToolLikeBlock(block)) ?? false;
+    const userMessageId = entry.type === "user" && typeof entry.uuid === "string" && entry.uuid.length > 0
+        ? entry.uuid
+        : null;
+    if (entry.type === "user") {
+        const taskNotificationItem = mapTaskNotificationUserContentToToolCall({
+            content,
+            messageId: userMessageId,
+        });
+        if (taskNotificationItem) {
+            return [taskNotificationItem];
+        }
+    }
     const timeline = [];
     if (entry.type === "user") {
         const text = extractUserMessageText(content);
         if (text) {
-            const messageId = typeof entry.uuid === "string" && entry.uuid.length > 0
-                ? entry.uuid
-                : undefined;
             timeline.push({
                 type: "user_message",
                 text,
-                ...(messageId ? { messageId } : {}),
+                ...(userMessageId ? { messageId: userMessageId } : {}),
             });
         }
     }
@@ -3544,6 +3675,9 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
         if (entry?.isSidechain) {
             continue;
         }
+        if (entry?.type === "user" && isSyntheticUserEntry(entry)) {
+            continue;
+        }
         if (!sessionId && typeof entry.sessionId === "string") {
             sessionId = entry.sessionId;
         }