@junctionpanel/server 0.1.31 → 0.1.32

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

@@ -7,7 +7,7 @@ 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 { buildClaudeModelDefinitions, buildClaudeModelFamilyAliases, buildClaudeSelectableModelIds, getClaudeFallbackModels, normalizeClaudeThinkingOptionId, resolveClaudeThinkingPreset, } 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";
@@ -265,6 +265,52 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings) {
         },
     };
 }
+function buildClaudeControlOptions(params) {
+    const baseOptions = {
+        ...(params.cwd ? { cwd: params.cwd } : {}),
+        ...(params.claudePath
+            ? { pathToClaudeCodeExecutable: params.claudePath }
+            : {}),
+        settingSources: CLAUDE_SETTING_SOURCES,
+        includePartialMessages: false,
+        stderr: (data) => {
+            params.logger.warn({ stderr: data.trim() }, "Claude Agent SDK stderr");
+        },
+        env: {
+            ...process.env,
+            MCP_TIMEOUT: "600000",
+            MCP_TOOL_TIMEOUT: "600000",
+        },
+    };
+    return applyRuntimeSettingsToClaudeOptions(baseOptions, params.runtimeSettings);
+}
+async function fetchClaudeSupportedModels(params) {
+    const abortController = new AbortController();
+    const controlQuery = query({
+        prompt: "",
+        options: {
+            ...buildClaudeControlOptions(params),
+            abortController,
+        },
+    });
+    try {
+        return await controlQuery.supportedModels();
+    }
+    finally {
+        abortController.abort();
+        try {
+            await Promise.race([
+                controlQuery.interrupt(),
+                new Promise((resolve) => {
+                    setTimeout(resolve, 1000);
+                }),
+            ]);
+        }
+        catch {
+            // Ignore teardown errors for short-lived control queries.
+        }
+    }
+}
 function summarizeClaudeOptionsForLog(options) {
     const systemPromptRaw = options.systemPrompt;
     const systemPromptSummary = (() => {
@@ -300,6 +346,12 @@ function summarizeClaudeOptionsForLog(options) {
             : [],
         enableFileCheckpointing: options.enableFileCheckpointing === true,
         hasResume: typeof options.resume === "string" && options.resume.length > 0,
+        thinkingMode: typeof options.thinking?.type === "string" ? options.thinking.type : null,
+        thinkingBudgetTokens: options.thinking?.type === "enabled" &&
+            typeof options.thinking.budgetTokens === "number"
+            ? options.thinking.budgetTokens
+            : null,
+        effort: typeof options.effort === "string" ? options.effort : null,
         maxThinkingTokens: typeof options.maxThinkingTokens === "number"
             ? options.maxThinkingTokens
             : null,
@@ -536,6 +588,20 @@ function isClaudeContentChunk(value) {
 function isClaudeExtra(value) {
     return isMetadata(value);
 }
+function readPreferredClaudeModeId(extra) {
+    const candidate = extra?.claude?.junctionPreferredModeId;
+    if (!isPermissionMode(candidate) || candidate === "plan") {
+        return null;
+    }
+    return candidate;
+}
+function getClaudeSdkExtraOptions(extra) {
+    if (!extra?.claude) {
+        return undefined;
+    }
+    const { junctionPreferredModeId: _junctionPreferredModeId, ...claudeOptions } = extra.claude;
+    return claudeOptions;
+}
 function isPermissionUpdate(value) {
     if (!isMetadata(value)) {
         return false;
@@ -1007,11 +1073,13 @@ export class ClaudeAgentClient {
     }
     async createSession(config) {
         const claudeConfig = this.assertConfig(config);
+        const knownModels = await this.discoverKnownModels(claudeConfig.cwd);
         return new ClaudeAgentSession(claudeConfig, {
             defaults: this.defaults,
             claudePath: this.claudePath,
             runtimeSettings: this.runtimeSettings,
             logger: this.logger,
+            knownModels,
         });
     }
     async resumeSession(handle, overrides) {
@@ -1022,16 +1090,33 @@ export class ClaudeAgentClient {
         }
         const mergedConfig = { ...merged, provider: "claude", cwd: merged.cwd };
         const claudeConfig = this.assertConfig(mergedConfig);
+        const knownModels = await this.discoverKnownModels(claudeConfig.cwd);
         return new ClaudeAgentSession(claudeConfig, {
             defaults: this.defaults,
             claudePath: this.claudePath,
             runtimeSettings: this.runtimeSettings,
             handle,
             logger: this.logger,
+            knownModels,
         });
     }
-    async listModels(_options) {
-        return listClaudeCatalogModels();
+    async listModels(options) {
+        return this.discoverKnownModels(options?.cwd);
+    }
+    async discoverKnownModels(cwd) {
+        try {
+            const models = await fetchClaudeSupportedModels({
+                cwd,
+                claudePath: this.claudePath,
+                runtimeSettings: this.runtimeSettings,
+                logger: this.logger,
+            });
+            return buildClaudeModelDefinitions(models);
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to discover Claude models dynamically; using fallback catalog");
+            return getClaudeFallbackModels();
+        }
     }
     async listPersistedAgents(options) {
         const configDir = resolveClaudeConfigDir();
@@ -1056,7 +1141,7 @@ export class ClaudeAgentClient {
     async isAvailable() {
         const commandConfig = this.runtimeSettings?.command;
         if (commandConfig?.mode === "replace") {
-            return isProviderCommandAvailable(commandConfig, resolveClaudeBinary);
+            return isProviderCommandAvailable(commandConfig, resolveClaudeBinary, applyProviderEnv(process.env, this.runtimeSettings));
         }
         return this.claudePath !== null;
     }
@@ -1073,6 +1158,7 @@ class ClaudeAgentSession {
         this.capabilities = CLAUDE_CAPABILITIES;
         this.query = null;
         this.input = null;
+        this.lastNonPlanMode = "default";
         this.availableModes = DEFAULT_MODES;
         this.toolUseCache = new Map();
         this.toolUseIndexToId = new Map();
@@ -1093,8 +1179,8 @@ class ClaudeAgentSession {
         this.activeTurnPromise = null;
         this.cachedRuntimeInfo = null;
         this.lastOptionsModel = null;
-        this.selectableModelIds = buildClaudeSelectableModelIds();
-        this.selectableModelFamilyAliases = buildClaudeModelFamilyAliases();
+        this.pendingExplicitModeSync = false;
+        this.runtimeReportedModelId = null;
         this.activeSidechains = new Map();
         this.compacting = false;
         this.queryPumpPromise = null;
@@ -1106,6 +1192,26 @@ class ClaudeAgentSession {
         this.handlePermissionRequest = async (toolName, input, options) => {
             const requestId = `permission-${randomUUID()}`;
             const kind = resolvePermissionKind(toolName, input);
+            if (kind === "plan" && this.lastNonPlanMode === "bypassPermissions") {
+                this.currentMode = "bypassPermissions";
+                this.cachedRuntimeInfo = null;
+                this.pushToolCall(mapClaudeCompletedToolCall({
+                    name: "plan_approval",
+                    callId: options.toolUseID ?? requestId,
+                    input,
+                    output: { approved: true, automatic: true },
+                }));
+                this.pushEvent({
+                    type: "permission_resolved",
+                    provider: "claude",
+                    requestId,
+                    resolution: { behavior: "allow" },
+                });
+                return {
+                    behavior: "allow",
+                    updatedInput: input,
+                };
+            }
             const metadata = {};
             if (options.toolUseID) {
                 metadata.toolUseId = options.toolUseID;
@@ -1190,6 +1296,21 @@ class ClaudeAgentSession {
             throw new Error(`Invalid mode '${config.modeId}' for Claude provider. Valid modes: ${validModesList}`);
         }
         this.currentMode = isPermissionMode(config.modeId) ? config.modeId : "default";
+        const preferredNonPlanMode = readPreferredClaudeModeId(config.extra);
+        if (this.currentMode !== "plan") {
+            this.lastNonPlanMode = this.currentMode;
+        }
+        else if (preferredNonPlanMode) {
+            this.lastNonPlanMode = preferredNonPlanMode;
+        }
+        this.knownModels =
+            options.knownModels && options.knownModels.length > 0
+                ? options.knownModels
+                : getClaudeFallbackModels();
+        this.selectableModelIds = buildClaudeSelectableModelIds(this.knownModels);
+        this.selectableModelFamilyAliases = buildClaudeModelFamilyAliases(this.knownModels);
+        this.config.thinkingOptionId =
+            normalizeClaudeThinkingOptionId(this.config.thinkingOptionId) ?? undefined;
     }
     get id() {
         return this.claudeSessionId;
@@ -1198,11 +1319,24 @@ class ClaudeAgentSession {
         if (this.cachedRuntimeInfo) {
             return { ...this.cachedRuntimeInfo };
         }
+        const thinkingOptionId = normalizeClaudeThinkingOptionId(this.config.thinkingOptionId) ?? "off";
         const info = {
             provider: "claude",
             sessionId: this.claudeSessionId,
             model: this.lastOptionsModel,
+            thinkingOptionId,
             modeId: this.currentMode ?? null,
+            extra: {
+                preferredModeId: this.lastNonPlanMode,
+                ...(this.runtimeReportedModelId
+                    ? { reportedModelId: this.runtimeReportedModelId }
+                    : {}),
+                ...(this.lastOptionsModel &&
+                    this.runtimeReportedModelId &&
+                    this.lastOptionsModel !== this.runtimeReportedModelId
+                    ? { resolvedModelId: this.lastOptionsModel }
+                    : {}),
+            },
         };
         this.cachedRuntimeInfo = info;
         return { ...info };
@@ -1238,7 +1372,19 @@ class ClaudeAgentSession {
             provider: "claude",
             sessionId: this.claudeSessionId,
             model: this.lastOptionsModel,
+            thinkingOptionId: normalizeClaudeThinkingOptionId(this.config.thinkingOptionId) ?? "off",
             modeId: this.currentMode ?? null,
+            extra: {
+                preferredModeId: this.lastNonPlanMode,
+                ...(this.runtimeReportedModelId
+                    ? { reportedModelId: this.runtimeReportedModelId }
+                    : {}),
+                ...(this.lastOptionsModel &&
+                    this.runtimeReportedModelId &&
+                    this.lastOptionsModel !== this.runtimeReportedModelId
+                    ? { resolvedModelId: this.lastOptionsModel }
+                    : {}),
+            },
         };
         if (!this.claudeSessionId) {
             throw new Error("Session ID not set after run completed");
@@ -1406,6 +1552,10 @@ class ClaudeAgentSession {
         const query = await this.ensureQuery();
         await query.setPermissionMode(normalized);
         this.currentMode = normalized;
+        if (normalized !== "plan") {
+            this.lastNonPlanMode = normalized;
+        }
+        this.cachedRuntimeInfo = null;
     }
     async setModel(modelId) {
         const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
@@ -1418,21 +1568,16 @@ class ClaudeAgentSession {
         this.persistence = null;
     }
     async setThinkingOption(thinkingOptionId) {
-        const normalizedThinkingOptionId = typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0
-            ? thinkingOptionId
-            : null;
-        if (!normalizedThinkingOptionId || normalizedThinkingOptionId === "default") {
-            this.config.thinkingOptionId = undefined;
-        }
-        else if (normalizedThinkingOptionId === "on") {
-            this.config.thinkingOptionId = "on";
-        }
-        else if (normalizedThinkingOptionId === "off") {
-            this.config.thinkingOptionId = "off";
-        }
-        else {
-            throw new Error(`Unknown thinking option: ${normalizedThinkingOptionId}`);
-        }
+        const normalizedThinkingOptionId = normalizeClaudeThinkingOptionId(thinkingOptionId);
+        if (thinkingOptionId !== null &&
+            typeof thinkingOptionId === "string" &&
+            thinkingOptionId.trim().length > 0 &&
+            thinkingOptionId !== "default" &&
+            !normalizedThinkingOptionId) {
+            throw new Error(`Unknown thinking option: ${thinkingOptionId}`);
+        }
+        this.config.thinkingOptionId = normalizedThinkingOptionId ?? undefined;
+        this.cachedRuntimeInfo = null;
         this.queryRestartNeeded = true;
     }
     getPendingPermissions() {
@@ -1447,7 +1592,8 @@ class ClaudeAgentSession {
         pending.cleanup?.();
         if (response.behavior === "allow") {
             if (pending.request.kind === "plan") {
-                await this.setMode("acceptEdits");
+                this.currentMode = this.lastNonPlanMode;
+                this.cachedRuntimeInfo = null;
                 this.pushToolCall(mapClaudeCompletedToolCall({
                     name: "plan_approval",
                     callId: pending.request.id,
@@ -1463,6 +1609,10 @@ class ClaudeAgentSession {
             pending.resolve(result);
         }
         else {
+            if (pending.request.kind === "plan") {
+                this.currentMode = "plan";
+                this.cachedRuntimeInfo = null;
+            }
             if (pending.request.kind === "tool") {
                 this.pushToolCall(mapClaudeFailedToolCall({
                     name: pending.request.name,
@@ -1773,6 +1923,10 @@ class ClaudeAgentSession {
         this.logger.debug({ options: summarizeClaudeOptionsForLog(options) }, "claude query");
         this.input = input;
         this.query = query({ prompt: input, options });
+        if (this.currentMode !== "default") {
+            this.pendingExplicitModeSync = true;
+            await this.query.setPermissionMode(this.currentMode);
+        }
         // 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
@@ -1796,17 +1950,8 @@ class ClaudeAgentSession {
         }
     }
     buildOptions() {
-        const configuredThinkingOptionId = this.config.thinkingOptionId;
-        const thinkingOptionId = configuredThinkingOptionId && configuredThinkingOptionId !== "default"
-            ? configuredThinkingOptionId
-            : "off";
-        let maxThinkingTokens;
-        if (thinkingOptionId === "on") {
-            maxThinkingTokens = 10000;
-        }
-        else if (thinkingOptionId === "off") {
-            maxThinkingTokens = 0;
-        }
+        const thinkingPreset = resolveClaudeThinkingPreset(this.config.thinkingOptionId) ??
+            resolveClaudeThinkingPreset("off");
         const appendedSystemPrompt = [
             getOrchestratorModeInstructions(),
             this.config.systemPrompt?.trim(),
@@ -1817,6 +1962,10 @@ class ClaudeAgentSession {
             cwd: this.config.cwd,
             includePartialMessages: true,
             permissionMode: this.currentMode,
+            ...(this.currentMode === "bypassPermissions" ||
+                this.lastNonPlanMode === "bypassPermissions"
+                ? { allowDangerouslySkipPermissions: true }
+                : {}),
             agents: this.defaults?.agents,
             canUseTool: this.handlePermissionRequest,
             ...(this.claudePath ? { pathToClaudeCodeExecutable: this.claudePath } : {}),
@@ -1842,8 +1991,9 @@ class ClaudeAgentSession {
             // If we have a session ID from a previous query (e.g., after interrupt),
             // resume that session to continue the conversation history.
             ...(this.claudeSessionId ? { resume: this.claudeSessionId } : {}),
-            ...(maxThinkingTokens !== undefined ? { maxThinkingTokens } : {}),
-            ...this.config.extra?.claude,
+            ...(thinkingPreset ? { thinking: thinkingPreset.thinking } : {}),
+            ...(thinkingPreset?.effort ? { effort: thinkingPreset.effort } : {}),
+            ...getClaudeSdkExtraOptions(this.config.extra),
         };
         if (this.config.mcpServers) {
             base.mcpServers = this.normalizeMcpServers(this.config.mcpServers);
@@ -2830,10 +2980,25 @@ class ClaudeAgentSession {
                 `This indicates a session identity corruption bug.`);
         }
         this.availableModes = DEFAULT_MODES;
-        this.currentMode = message.permissionMode;
+        if (this.pendingExplicitModeSync &&
+            this.currentMode !== "default" &&
+            message.permissionMode === "default") {
+            this.logger.debug({
+                reportedPermissionMode: message.permissionMode,
+                preservedPermissionMode: this.currentMode,
+            }, "Ignoring stale Claude init permission mode after explicit mode sync");
+        }
+        else {
+            this.currentMode = message.permissionMode;
+            if (message.permissionMode !== "plan") {
+                this.lastNonPlanMode = message.permissionMode;
+            }
+        }
+        this.pendingExplicitModeSync = false;
         this.persistence = null;
         // Capture actual model from SDK init message (not just the configured model)
         if (message.model) {
+            this.runtimeReportedModelId = message.model;
             const normalizedModel = normalizeClaudeRuntimeModelId({
                 runtimeModelId: message.model,
                 supportedModelIds: this.selectableModelIds,