@visorcraft/idlehands 2.2.3 → 2.2.5

package/dist/agent.js

@@ -14,6 +14,7 @@ import { buildDefaultSystemPrompt } from './agent/prompt-builder.js';
 import { LeakDetector } from './security/leak-detector.js';
 import { PromptGuard } from './security/prompt-guard.js';
 import { ResponseCache } from './agent/response-cache.js';
+import { resilientCall } from './agent/resilient-provider.js';
 import { ToolLoopGuard } from './agent/tool-loop-guard.js';
 import { isLspTool, isMutationTool, isReadOnlyTool, planModeSummary } from './agent/tool-policy.js';
 import { buildToolsSchema } from './agent/tools-schema.js';
@@ -31,6 +32,7 @@ import { MCPManager } from './mcp.js';
 import { BASE_MAX_TOKENS, deriveContextWindow, deriveGenerationParams, supportsVisionModel, } from './model-customization.js';
 import { ReplayStore } from './replay.js';
 import { checkExecSafety, checkPathSafety } from './safety.js';
+import { decideTurnRoute } from './routing/turn-router.js';
 import { normalizeApprovalMode } from './shared/config-utils.js';
 import { collectSnapshot } from './sys/context.js';
 import { ToolError, ValidationError } from './tools/tool-error.js';
@@ -1078,6 +1080,9 @@ export async function createSession(opts) {
     let captureEnabled = false;
     let capturePath;
     let lastCaptureRecord = null;
+    const routedClients = new Map();
+    const probedEndpoints = new Set();
+    const normalizeEndpoint = (endpoint) => endpoint.trim().replace(/\/+$/, '');
     const defaultCapturePath = () => {
         const stamp = new Date().toISOString().replace(/[:.]/g, '-');
         return path.join(capturesDir, `${stamp}.jsonl`);
@@ -1086,18 +1091,135 @@ export async function createSession(opts) {
         await fs.mkdir(path.dirname(outPath), { recursive: true });
         await fs.appendFile(outPath, JSON.stringify(record) + '\n', 'utf8');
     };
-    const wireCaptureHook = () => {
-        if (typeof client.setExchangeHook !== 'function')
+    const applyClientRuntimeOptions = (target) => {
+        if (typeof target.setVerbose === 'function') {
+            target.setVerbose(cfg.verbose);
+        }
+        if (typeof cfg.response_timeout === 'number' && cfg.response_timeout > 0) {
+            target.setResponseTimeout(cfg.response_timeout);
+        }
+        if (typeof target.setConnectionTimeout === 'function' &&
+            typeof cfg.connection_timeout === 'number' &&
+            cfg.connection_timeout > 0) {
+            target.setConnectionTimeout(cfg.connection_timeout);
+        }
+        if (typeof target.setInitialConnectionCheck === 'function' &&
+            typeof cfg.initial_connection_check === 'boolean') {
+            target.setInitialConnectionCheck(cfg.initial_connection_check);
+        }
+        if (typeof target.setInitialConnectionProbeTimeout === 'function' &&
+            typeof cfg.initial_connection_timeout === 'number' &&
+            cfg.initial_connection_timeout > 0) {
+            target.setInitialConnectionProbeTimeout(cfg.initial_connection_timeout);
+        }
+    };
+    const attachCaptureHook = (target) => {
+        if (typeof target.setExchangeHook !== 'function')
             return;
-        client.setExchangeHook(async (record) => {
+        target.setExchangeHook(async (record) => {
             lastCaptureRecord = record;
             if (!captureEnabled)
                 return;
-            const target = capturePath || defaultCapturePath();
-            capturePath = target;
-            await appendCaptureRecord(record, target);
+            const outFile = capturePath || defaultCapturePath();
+            capturePath = outFile;
+            await appendCaptureRecord(record, outFile);
         });
     };
+    const getClientForEndpoint = (endpoint) => {
+        if (!endpoint)
+            return client;
+        const normalized = normalizeEndpoint(endpoint);
+        if (!normalized || normalized === normalizeEndpoint(cfg.endpoint))
+            return client;
+        const existing = routedClients.get(normalized);
+        if (existing)
+            return existing;
+        const routed = new OpenAIClient(normalized, opts.apiKey, cfg.verbose);
+        applyClientRuntimeOptions(routed);
+        attachCaptureHook(routed);
+        routedClients.set(normalized, routed);
+        return routed;
+    };
+    let runtimeRoutingModules = null;
+    let runtimeRoutingUnavailable = false;
+    let runtimeModelIdsCache = null;
+    const loadRuntimeRoutingModules = async () => {
+        if (runtimeRoutingUnavailable)
+            return null;
+        if (runtimeRoutingModules)
+            return runtimeRoutingModules;
+        try {
+            const [planner, executor, store] = await Promise.all([
+                import('./runtime/planner.js'),
+                import('./runtime/executor.js'),
+                import('./runtime/store.js'),
+            ]);
+            runtimeRoutingModules = { planner, executor, store };
+            return runtimeRoutingModules;
+        }
+        catch {
+            runtimeRoutingUnavailable = true;
+            return null;
+        }
+    };
+    const loadRuntimeModelIds = async () => {
+        if (runtimeModelIdsCache)
+            return runtimeModelIdsCache;
+        const mods = await loadRuntimeRoutingModules();
+        if (!mods) {
+            runtimeModelIdsCache = new Set();
+            return runtimeModelIdsCache;
+        }
+        try {
+            const runtimes = await mods.store.loadRuntimes();
+            runtimeModelIdsCache = new Set(runtimes.models.filter((m) => m.enabled !== false).map((m) => m.id));
+            return runtimeModelIdsCache;
+        }
+        catch {
+            runtimeModelIdsCache = new Set();
+            return runtimeModelIdsCache;
+        }
+    };
+    const ensureRuntimeModelActive = async (runtimeModelId) => {
+        const mods = await loadRuntimeRoutingModules();
+        if (!mods)
+            throw new Error('Runtime routing is unavailable in this build/environment');
+        const runtimes = await mods.store.loadRuntimes();
+        runtimeModelIdsCache = new Set(runtimes.models.filter((m) => m.enabled !== false).map((m) => m.id));
+        const modelExists = runtimes.models.some((m) => m.enabled !== false && m.id === runtimeModelId);
+        if (!modelExists) {
+            throw new Error(`Runtime model not found or disabled: ${runtimeModelId}`);
+        }
+        let active = await mods.executor.loadActiveRuntime();
+        if (active?.healthy && active.modelId === runtimeModelId && active.endpoint) {
+            if (normalizeEndpoint(active.endpoint) !== normalizeEndpoint(cfg.endpoint)) {
+                await setEndpoint(active.endpoint);
+            }
+            return;
+        }
+        const planResult = mods.planner.plan({ modelId: runtimeModelId, mode: 'live' }, runtimes, active);
+        if (!planResult.ok) {
+            throw new Error(`Runtime switch plan failed for ${runtimeModelId}: ${planResult.reason}`);
+        }
+        if (!planResult.reuse) {
+            const execResult = await mods.executor.execute(planResult, {
+                confirm: async () => false,
+            });
+            if (!execResult.ok) {
+                throw new Error(`Runtime switch failed for ${runtimeModelId}: ${execResult.error ?? 'unknown error'}`);
+            }
+        }
+        active = await mods.executor.loadActiveRuntime();
+        if (!active?.endpoint || active.healthy !== true) {
+            throw new Error(`Runtime did not become healthy for ${runtimeModelId}`);
+        }
+        if (normalizeEndpoint(active.endpoint) !== normalizeEndpoint(cfg.endpoint)) {
+            await setEndpoint(active.endpoint);
+        }
+    };
+    const wireCaptureHook = () => {
+        attachCaptureHook(client);
+    };
     wireCaptureHook();
     const replayEnabled = cfg.trifecta?.enabled !== false && cfg.trifecta?.replay?.enabled !== false;
     const replay = replayEnabled ? (opts.runtime?.replay ?? new ReplayStore()) : undefined;
@@ -1228,9 +1350,9 @@ export async function createSession(opts) {
         else {
             client = new OpenAIClient(normalized, opts.apiKey, cfg.verbose);
         }
-        if (typeof client.setVerbose === 'function') {
-            client.setVerbose(cfg.verbose);
-        }
+        applyClientRuntimeOptions(client);
+        routedClients.clear();
+        probedEndpoints.clear();
         wireCaptureHook();
         modelsList = normalizeModelsResponse(await client.models());
         const chosen = modelName?.trim()
@@ -1288,6 +1410,7 @@ export async function createSession(opts) {
     const close = async () => {
         await mcpManager?.close().catch(() => { });
         await lspManager?.close().catch(() => { });
+        routedClients.clear();
         vault?.close();
         lens?.close();
     };
@@ -1575,6 +1698,9 @@ export async function createSession(opts) {
             if (typeof client.probeConnection === 'function') {
                 await client.probeConnection();
                 initialConnectionProbeDone = true;
+                if (typeof client.getEndpoint === 'function') {
+                    probedEndpoints.add(normalizeEndpoint(client.getEndpoint()));
+                }
             }
         }
         if (retrievalRequested) {
@@ -1621,6 +1747,38 @@ export async function createSession(opts) {
             });
             return await finalizeAsk(miss);
         }
+        const turnRoute = decideTurnRoute(cfg, rawInstructionText, model);
+        const primaryRoute = turnRoute.providerTargets[0];
+        const runtimeModelIds = await loadRuntimeModelIds();
+        const routeRuntimeFallbackModels = (primaryRoute?.fallbackModels ?? []).filter((m) => runtimeModelIds.has(m));
+        const routeApiFallbackModels = (primaryRoute?.fallbackModels ?? []).filter((m) => !runtimeModelIds.has(m));
+        const primaryUsesRuntimeModel = !!primaryRoute?.model && runtimeModelIds.has(primaryRoute.model);
+        // Non-runtime route models can be selected directly in-session.
+        if (!primaryUsesRuntimeModel && primaryRoute?.model && primaryRoute.model !== model) {
+            setModel(primaryRoute.model);
+        }
+        if (cfg.verbose) {
+            const routeParts = [
+                `requested=${turnRoute.requestedMode}`,
+                `selected=${turnRoute.selectedMode}`,
+                `source=${turnRoute.selectedModeSource}`,
+                `hint=${turnRoute.classificationHint ?? 'none'}`,
+                `provider=${primaryRoute?.name ?? 'default'}`,
+                `model=${primaryRoute?.model ?? model}`,
+            ];
+            if (turnRoute.heuristicDecision)
+                routeParts.push(`heuristic=${turnRoute.heuristicDecision}`);
+            if (primaryUsesRuntimeModel) {
+                const runtimeChain = [primaryRoute?.model, ...routeRuntimeFallbackModels]
+                    .filter(Boolean)
+                    .join(' -> ');
+                routeParts.push(`runtime_chain=${runtimeChain || 'none'}`);
+            }
+            else if (routeApiFallbackModels.length) {
+                routeParts.push(`api_fallbacks=${routeApiFallbackModels.join(',')}`);
+            }
+            console.error(`[routing] ${routeParts.join(' ')}`);
+        }
         const persistReviewArtifact = async (finalText) => {
             if (!vault || !shouldPersistReviewArtifact)
                 return;
@@ -2045,8 +2203,7 @@ export async function createSession(opts) {
                             }
                         }
                         if (!resp) {
-                            resp = await client.chatStream({
-                                model,
+                            const chatOptsBase = {
                                 messages,
                                 tools: toolsForTurn,
                                 tool_choice: toolChoiceForTurn,
@@ -2055,9 +2212,10 @@ export async function createSession(opts) {
                                 max_tokens: maxTokens,
                                 extra: {
                                     cache_prompt: cfg.cache_prompt ?? true,
-                                    // Speculative decoding: draft model params for llama-server
                                     ...(cfg.draft_model ? { draft_model: cfg.draft_model } : {}),
-                                    ...(cfg.draft_n ? { speculative: { n: cfg.draft_n, p_min: cfg.draft_p_min ?? 0.5 } } : {}),
+                                    ...(cfg.draft_n
+                                        ? { speculative: { n: cfg.draft_n, p_min: cfg.draft_p_min ?? 0.5 } }
+                                        : {}),
                                     ...(frequencyPenalty && { frequency_penalty: frequencyPenalty }),
                                     ...(presencePenalty && { presence_penalty: presencePenalty }),
                                 },
@@ -2065,7 +2223,73 @@ export async function createSession(opts) {
                                 requestId: `r${reqCounter}`,
                                 onToken: hookObj.onToken,
                                 onFirstDelta,
-                            });
+                            };
+                            if (primaryUsesRuntimeModel && primaryRoute?.model) {
+                                // Runtime-native routing: lane model/fallbacks reference runtime model IDs.
+                                const runtimePrimaryModel = primaryRoute.model;
+                                const runtimeFallbackMap = {};
+                                if (routeRuntimeFallbackModels.length > 0) {
+                                    runtimeFallbackMap[runtimePrimaryModel] = routeRuntimeFallbackModels;
+                                }
+                                resp = await resilientCall([
+                                    {
+                                        name: 'runtime-router',
+                                        execute: async (runtimeModelId) => {
+                                            await ensureRuntimeModelActive(runtimeModelId);
+                                            const runtimeClient = getClientForEndpoint();
+                                            const runtimeModel = model;
+                                            return runtimeClient.chatStream({ ...chatOptsBase, model: runtimeModel });
+                                        },
+                                    },
+                                ], runtimePrimaryModel, {
+                                    maxRetries: 0,
+                                    modelFallbacks: runtimeFallbackMap,
+                                    onRetry: (info) => {
+                                        if (cfg.verbose) {
+                                            console.error(`[routing] runtime-fallback: model=${info.model} attempt=${info.attempt}/${info.maxAttempts} reason=${info.reason}`);
+                                        }
+                                    },
+                                });
+                            }
+                            else {
+                                const routeEndpoint = primaryRoute?.endpoint;
+                                const activeClient = getClientForEndpoint(routeEndpoint);
+                                const endpointKey = routeEndpoint ? normalizeEndpoint(routeEndpoint) : undefined;
+                                if (endpointKey && !probedEndpoints.has(endpointKey)) {
+                                    if (typeof activeClient.probeConnection === 'function') {
+                                        try {
+                                            await activeClient.probeConnection();
+                                        }
+                                        catch {
+                                            // best-effort: if probe fails we still try the call
+                                        }
+                                        probedEndpoints.add(endpointKey);
+                                    }
+                                }
+                                const routeModel = primaryRoute?.model ?? model;
+                                if (routeApiFallbackModels.length > 0) {
+                                    const modelFallbackMap = {
+                                        [routeModel]: routeApiFallbackModels,
+                                    };
+                                    resp = await resilientCall([
+                                        {
+                                            name: primaryRoute?.name ?? 'default',
+                                            execute: (m) => activeClient.chatStream({ ...chatOptsBase, model: m }),
+                                        },
+                                    ], routeModel, {
+                                        maxRetries: 1,
+                                        modelFallbacks: modelFallbackMap,
+                                        onRetry: (info) => {
+                                            if (cfg.verbose) {
+                                                console.error(`[routing] retry: provider=${info.provider} model=${info.model} attempt=${info.attempt}/${info.maxAttempts} reason=${info.reason}`);
+                                            }
+                                        },
+                                    });
+                                }
+                                else {
+                                    resp = await activeClient.chatStream({ ...chatOptsBase, model: routeModel });
+                                }
+                            }
                         } // end if (!resp) — cache miss path
                         // Successful response resets overflow recovery budget.
                         overflowCompactionAttempts = 0;
@@ -3533,6 +3757,9 @@ export async function createSession(opts) {
         refreshServerHealth,
         getPerfSummary,
         getToolLoopStats: () => lastToolLoopStats,
+        get lastAskInstructionText() {
+            return lastAskInstructionText;
+        },
         captureOn,
         captureOff,
         captureLast,