@bike4mind/cli 0.2.21-fix-cli-subagent-model-alias-resolution.18205 → 0.2.21-fix-idle-timeout-error-message.18217

package/dist/{chunk-NAIQUTDD.js → chunk-FGNCVUBR.js}

@@ -6,7 +6,7 @@ import {
   getSettingsByNames,
   obfuscateApiKey,
   secureParameters
-} from "./chunk-HXWD4UGK.js";
+} from "./chunk-RQRJNE4K.js";
 import {
   ApiKeyType,
   MementoTier,

package/dist/{chunk-3NN5PD22.js → chunk-KUGWFEGL.js}

@@ -7,7 +7,7 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-HXWD4UGK.js";
+} from "./chunk-RQRJNE4K.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes

package/dist/{chunk-HXWD4UGK.js → chunk-RQRJNE4K.js}

@@ -1949,6 +1949,7 @@ var TEMPERATURE_ONLY_MODELS = [
 var INITIAL_TIMEOUT_MS = 3e4;
 var DEFAULT_IDLE_TIMEOUT_MS = 9e4;
 var THINKING_IDLE_TIMEOUT_MS = 18e4;
+var REQUEST_TIMEOUT_MS = 6e4;
 var AnthropicBackend = class {
   _api;
   logger;
@@ -1964,8 +1965,10 @@ var AnthropicBackend = class {
   /**
    * Emit a CloudWatch metric when a rate limit error occurs.
    * This helps monitor and alert on Anthropic API rate limiting issues.
+   * @param model - The model that triggered the rate limit
+   * @param featureArea - The feature area (mcp-tools, chat, built-in-tools, etc.) for filtering (#6413)
    */
-  async emitRateLimitMetric(model) {
+  async emitRateLimitMetric(model, featureArea = "unknown") {
     try {
       const client = new CloudWatchClient({
         region: process.env.AWS_REGION || "us-east-2"
@@ -1983,13 +1986,15 @@ var AnthropicBackend = class {
               // SEED_STAGE_NAME is set via DEFAULT_LAMBDA_ENVIRONMENT in infra/constants.ts
               // and maps to $app.stage. The alarm in infra/alarms.ts filters by Stage dimension.
               // Fallback to 'local' for non-Lambda contexts (local dev, tests).
-              { Name: "Stage", Value: process.env.SEED_STAGE_NAME || "local" }
+              { Name: "Stage", Value: process.env.SEED_STAGE_NAME || "local" },
+              // Feature area helps identify which feature is causing rate limits (#6413)
+              { Name: "FeatureArea", Value: featureArea }
             ]
           }
         ]
       });
       await client.send(command);
-      this.logger.info("[AnthropicBackend] Emitted RateLimitError metric to CloudWatch", { model });
+      this.logger.info("[AnthropicBackend] Emitted RateLimitError metric to CloudWatch", { model, featureArea });
     } catch (metricsError) {
       this.logger.warn("[AnthropicBackend] Failed to emit CloudWatch metric", {
         error: metricsError instanceof Error ? metricsError.message : String(metricsError)
@@ -2289,9 +2294,29 @@ var AnthropicBackend = class {
       ...options
     };
     const toolCallCount = options._internal?.toolCallCount ?? 0;
-    if (toolCallCount >= DEFAULT_MAX_TOOL_CALLS) {
-      this.logger.warn(`\u26A0\uFE0F Max tool calls limit (${DEFAULT_MAX_TOOL_CALLS}) reached. Disabling tools to prevent infinite loops.`);
-      await this.complete(model, messages, { ...options, tools: void 0, _internal: void 0 }, cb, toolsUsed);
+    if (toolCallCount >= DEFAULT_MAX_TOOL_CALLS && options.tools?.length) {
+      const mcpTools = options.tools?.filter((t) => t._isMcpTool) || [];
+      const builtInTools = options.tools?.filter((t) => !t._isMcpTool) || [];
+      this.logger.warn(`\u26A0\uFE0F Max tool calls limit (${DEFAULT_MAX_TOOL_CALLS}) reached. Disabling tools to prevent infinite loops.`, {
+        model,
+        toolCallCount,
+        toolsUsedSoFar: toolsUsed.map((t) => t.name),
+        availableToolCount: options.tools?.length || 0,
+        mcpToolCount: mcpTools.length,
+        mcpToolNames: mcpTools.map((t) => t.toolSchema.name).slice(0, 10),
+        builtInToolCount: builtInTools.length,
+        builtInToolNames: builtInTools.map((t) => t.toolSchema.name).slice(0, 10),
+        messageCount: messages.length
+      });
+      await this.complete(model, messages, {
+        ...options,
+        tools: void 0,
+        _internal: {
+          ...options._internal
+          // Preserve enableIdleTimeout, idleTimeoutMs
+          // Keep toolCallCount at the limit - no need to increment when tools are removed
+        }
+      }, cb, toolsUsed);
       return;
     }
     const rawTools = options.tools;
@@ -2366,8 +2391,44 @@ var AnthropicBackend = class {
       const func = [];
       if (options.stream) {
         await new Promise(async (resolve, reject) => {
+          const enableRequestTimeout = options._internal?.enableRequestTimeout ?? false;
+          const requestAbortController = new AbortController();
+          let requestTimeout;
+          if (enableRequestTimeout) {
+            requestTimeout = setTimeout(() => {
+              this.logger.error("[AnthropicBackend] Request timeout - API call did not start streaming", {
+                model,
+                toolCount: options.tools?.length || 0,
+                mcpToolCount: options.tools?.filter((t) => t._isMcpTool).length || 0,
+                timeoutMs: REQUEST_TIMEOUT_MS
+              });
+              this.emitIdleTimeoutMetric(model, options.tools?.length || 0, 0).catch(() => {
+              });
+              requestAbortController.abort();
+            }, REQUEST_TIMEOUT_MS);
+          }
+          const combinedSignal = enableRequestTimeout ? options.abortSignal ? AbortSignal.any([options.abortSignal, requestAbortController.signal]) : requestAbortController.signal : options.abortSignal;
+          let isIdleTimeout = false;
+          let idleTimeoutMsForError = 0;
           try {
-            const stream = await this._api.messages.create({ ...apiParams, stream: true }, { signal: options.abortSignal });
+            const payloadForSize = { ...apiParams, stream: true };
+            const payloadSizeBytes = Buffer.byteLength(JSON.stringify(payloadForSize), "utf8");
+            const toolsSizeBytes = apiParams.tools ? Buffer.byteLength(JSON.stringify(apiParams.tools), "utf8") : 0;
+            const messagesSizeBytes = apiParams.messages ? Buffer.byteLength(JSON.stringify(apiParams.messages), "utf8") : 0;
+            this.logger.info("[AnthropicBackend] API request payload diagnostics", {
+              model,
+              totalPayloadSizeKB: Math.round(payloadSizeBytes / 1024),
+              toolsSizeKB: Math.round(toolsSizeBytes / 1024),
+              messagesSizeKB: Math.round(messagesSizeBytes / 1024),
+              toolCount: apiParams.tools?.length || 0,
+              messageCount: apiParams.messages?.length || 0,
+              mcpToolCount: options.tools?.filter((t) => t._isMcpTool).length || 0,
+              hasThinking: !!apiParams.thinking,
+              thinkingBudget: apiParams.thinking?.budget_tokens
+            });
+            const stream = await this._api.messages.create({ ...apiParams, stream: true }, { signal: combinedSignal });
+            if (requestTimeout)
+              clearTimeout(requestTimeout);
             let isInThinkingBlock = false;
             const collectedContent = [];
             const enableIdleTimeout = options._internal?.enableIdleTimeout ?? false;
@@ -2383,6 +2444,8 @@ var AnthropicBackend = class {
                 clearTimeout(idleTimer);
               const timeoutMs = eventCount === 0 ? INITIAL_TIMEOUT_MS : idleTimeoutMs;
               idleTimer = setTimeout(() => {
+                isIdleTimeout = true;
+                idleTimeoutMsForError = timeoutMs;
                 this.logger.error("[AnthropicBackend] Stream idle timeout - no events received", {
                   model,
                   eventCount,
@@ -2394,7 +2457,6 @@ var AnthropicBackend = class {
                 this.emitIdleTimeoutMetric(model, options.tools?.length || 0, eventCount).catch(() => {
                 });
                 stream.controller?.abort?.();
-                reject(new Error(`Stream idle timeout after ${timeoutMs}ms - no events received`));
               }, timeoutMs);
             };
             resetIdleTimer();
@@ -2492,16 +2554,42 @@ var AnthropicBackend = class {
             }
             resolve();
           } catch (error) {
+            if (requestTimeout)
+              clearTimeout(requestTimeout);
             const isAbortError = error instanceof Error && (error.message.includes("aborted") || error.message.includes("AbortError") || error.name === "AbortError");
+            const isRequestTimeout = requestAbortController.signal.aborted;
             if (isAbortError) {
-              this.logger.debug("Anthropic request was aborted (likely client disconnect or timeout)");
-              resolve();
+              if (isRequestTimeout) {
+                this.logger.error("[AnthropicBackend] Request aborted due to timeout", {
+                  model,
+                  toolCount: options.tools?.length || 0
+                });
+                reject(new Error(`Anthropic API request timeout after ${REQUEST_TIMEOUT_MS}ms - no streaming response received`));
+              } else if (isIdleTimeout) {
+                this.logger.error("[AnthropicBackend] Stream aborted due to idle timeout", {
+                  model,
+                  toolCount: options.tools?.length || 0,
+                  idleTimeoutMs: idleTimeoutMsForError
+                });
+                reject(new Error(`Anthropic API stream timeout - no response received within ${idleTimeoutMsForError / 1e3} seconds. The model may be overloaded. Try simplifying your request or using fewer tools.`));
+              } else {
+                this.logger.debug("Anthropic request was aborted (likely client disconnect)");
+                resolve();
+              }
             } else {
               reject(error);
             }
           }
         });
         if (func.some((f) => f && f.name)) {
+          const toolCallNames = func.filter((t) => t?.name).map((t) => t.name);
+          this.logger.info("[Tool Execution] Model requested tool calls", {
+            model,
+            toolCallCount,
+            toolsRequested: toolCallNames,
+            toolCount: toolCallNames.length,
+            messageCountBefore: messages.length
+          });
           for (const tool of func) {
             if (!tool || !tool.name || !tool.parameters)
               continue;
@@ -2515,14 +2603,31 @@ var AnthropicBackend = class {
               if (!tool || !tool.name || !tool.parameters)
                 continue;
               const { id, name, parameters } = tool;
-              const toolFn = options.tools?.find((tool2) => tool2.toolSchema.name === name)?.toolFn;
+              const toolDef = options.tools?.find((tool2) => tool2.toolSchema.name === name);
+              const toolFn = toolDef?.toolFn;
+              const isMcpTool = toolDef?._isMcpTool ?? false;
               if (name && parameters && toolFn) {
-                this.logger.debug("Using tool:", name);
-                this.logger.debug("Tool arguments:", parameters);
+                this.logger.info("[Tool Execution] Executing tool", {
+                  model,
+                  toolName: name,
+                  isMcpTool,
+                  toolCallIteration: toolCallCount + 1,
+                  parameterKeys: Object.keys(JSON.parse(parameters || "{}"))
+                });
+                const toolStartTime = Date.now();
                 try {
                   const parsedParams = JSON.parse(parameters);
                   const result = await toolFn(parsedParams);
-                  this.logger.debug(`[Tool Result] Tool executed for ${name}:`, result.toString().substring(0, 200) + "...");
+                  const resultStr = result.toString();
+                  const toolDuration = Date.now() - toolStartTime;
+                  this.logger.info("[Tool Execution] Tool completed successfully", {
+                    model,
+                    toolName: name,
+                    isMcpTool,
+                    durationMs: toolDuration,
+                    resultLength: resultStr.length,
+                    resultPreview: resultStr.substring(0, 100) + (resultStr.length > 100 ? "..." : "")
+                  });
                   await handleToolResultStreaming(name, result, async (results) => {
                     await cb(results, {
                       inputTokens: 0,
@@ -2531,21 +2636,63 @@ var AnthropicBackend = class {
                     });
                   });
                   const toolId = id || `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                  this.pushToolMessages(messages, { id: toolId, name, parameters }, result.toString());
+                  this.pushToolMessages(messages, { id: toolId, name, parameters }, resultStr);
                 } catch (error) {
+                  const toolDuration = Date.now() - toolStartTime;
                   if (error instanceof PermissionDeniedError) {
                     throw error;
                   }
-                  this.logger.error(`Error processing ${name} tool:`, error);
+                  this.logger.error("[Tool Execution] Tool failed", {
+                    model,
+                    toolName: name,
+                    isMcpTool,
+                    durationMs: toolDuration,
+                    error: error instanceof Error ? error.message : "Unknown error"
+                  });
                   const toolId = id || `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
                   this.pushToolMessages(messages, { id: toolId, name, parameters }, `Error processing ${name} tool: ${error instanceof Error ? error.message : "Unknown error"}`);
                 }
+              } else if (name && parameters && !toolFn) {
+                this.logger.warn("[Tool Execution] Tool function not found", {
+                  model,
+                  toolName: name,
+                  availableTools: options.tools?.map((t) => t.toolSchema.name) || []
+                });
               }
             }
             await cb(["\n\n"], { toolsUsed });
-            this.logger.debug(`[Tool Execution] Making recursive call with ${messages.length} messages`);
-            this.logger.debug(`[Tool Execution] Last few messages:`, JSON.stringify(messages.slice(-3), null, 2));
-            await this.complete(model, messages, options, cb, toolsUsed);
+            const hasMcpTool = func.some((tool) => {
+              if (!tool?.name)
+                return false;
+              return options.tools?.find((t) => t.toolSchema.name === tool.name)?._isMcpTool;
+            });
+            this.logger.info("[Tool Execution] Making recursive call after tool execution", {
+              model,
+              toolCallIteration: toolCallCount + 1,
+              messageCountAfter: messages.length,
+              toolsExecuted: func.filter((t) => t?.name).map((t) => t.name),
+              hasMcpTool,
+              willKeepTools: hasMcpTool,
+              totalToolsUsed: toolsUsed.length
+            });
+            if (hasMcpTool) {
+              await this.complete(model, messages, {
+                ...options,
+                _internal: {
+                  ...options._internal,
+                  toolCallCount: toolCallCount + 1
+                }
+              }, cb, toolsUsed);
+            } else {
+              await this.complete(model, messages, {
+                ...options,
+                tools: void 0,
+                _internal: {
+                  ...options._internal,
+                  toolCallCount: toolCallCount + 1
+                }
+              }, cb, toolsUsed);
+            }
           } else {
             const thinkingBlocks = this.getThinkingBlocks();
             this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback with ${thinkingBlocks?.length || 0} thinking blocks`);
@@ -2587,32 +2734,70 @@ var AnthropicBackend = class {
         }
         await cb(streamedText, { toolsUsed });
         if (func.some((f) => f && f.name)) {
+          const toolCallNames = func.filter((t) => t?.name).map((t) => t.name);
+          this.logger.info("[Tool Execution] Model requested tool calls (non-streaming)", {
+            model,
+            toolCallCount,
+            toolsRequested: toolCallNames,
+            toolCount: toolCallNames.length,
+            messageCountBefore: messages.length
+          });
           if (options.executeTools !== false) {
             for (const tool of func) {
               if (!tool || !tool.name || !tool.parameters)
                 continue;
               const { id, name, parameters } = tool;
-              const toolFn = options.tools?.find((tool2) => tool2.toolSchema.name === name)?.toolFn;
+              const toolDef = options.tools?.find((tool2) => tool2.toolSchema.name === name);
+              const toolFn = toolDef?.toolFn;
+              const isMcpTool = toolDef?._isMcpTool ?? false;
               if (name && parameters && toolFn) {
-                this.logger.debug("Using tool:", name);
-                this.logger.debug("Tool arguments:", parameters);
+                this.logger.info("[Tool Execution] Executing tool (non-streaming)", {
+                  model,
+                  toolName: name,
+                  isMcpTool,
+                  toolCallIteration: toolCallCount + 1,
+                  parameterKeys: Object.keys(JSON.parse(parameters || "{}"))
+                });
+                const toolStartTime = Date.now();
                 try {
                   const parsedParams = JSON.parse(parameters);
                   const result = await toolFn(parsedParams);
-                  this.logger.debug(`[Tool Result] Tool executed for ${name}:`, result.toString().substring(0, 200) + "...");
+                  const resultStr = result.toString();
+                  const toolDuration = Date.now() - toolStartTime;
+                  this.logger.info("[Tool Execution] Tool completed successfully (non-streaming)", {
+                    model,
+                    toolName: name,
+                    isMcpTool,
+                    durationMs: toolDuration,
+                    resultLength: resultStr.length,
+                    resultPreview: resultStr.substring(0, 100) + (resultStr.length > 100 ? "..." : "")
+                  });
                   await handleToolResultStreaming(name, result, async (results) => {
                     await cb(results, { toolsUsed });
                   });
                   const toolId = id || `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                  this.pushToolMessages(messages, { id: toolId, name, parameters }, result.toString());
+                  this.pushToolMessages(messages, { id: toolId, name, parameters }, resultStr);
                 } catch (error) {
+                  const toolDuration = Date.now() - toolStartTime;
                   if (error instanceof PermissionDeniedError) {
                     throw error;
                   }
-                  this.logger.error(`Error processing ${name} tool:`, error);
+                  this.logger.error("[Tool Execution] Tool failed (non-streaming)", {
+                    model,
+                    toolName: name,
+                    isMcpTool,
+                    durationMs: toolDuration,
+                    error: error instanceof Error ? error.message : "Unknown error"
+                  });
                   const toolId = id || `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
                   this.pushToolMessages(messages, { id: toolId, name, parameters }, `Error processing ${name} tool: ${error instanceof Error ? error.message : "Unknown error"}`);
                 }
+              } else if (name && parameters && !toolFn) {
+                this.logger.warn("[Tool Execution] Tool function not found (non-streaming)", {
+                  model,
+                  toolName: name,
+                  availableTools: options.tools?.map((t) => t.toolSchema.name) || []
+                });
               }
             }
             const hasMcpTool = func.some((tool) => {
@@ -2620,16 +2805,35 @@ var AnthropicBackend = class {
                 return false;
               return options.tools?.find((t) => t.toolSchema.name === tool.name)?._isMcpTool;
             });
+            this.logger.info("[Tool Execution] Making recursive call after tool execution (non-streaming)", {
+              model,
+              toolCallIteration: toolCallCount + 1,
+              messageCountAfter: messages.length,
+              toolsExecuted: func.filter((t) => t?.name).map((t) => t.name),
+              hasMcpTool,
+              willKeepTools: hasMcpTool,
+              totalToolsUsed: toolsUsed.length
+            });
             await cb(["\n\n"], { toolsUsed });
             if (hasMcpTool) {
               await this.complete(model, messages, {
                 ...options,
                 _internal: {
+                  ...options._internal,
+                  // Preserve enableIdleTimeout, idleTimeoutMs
                   toolCallCount: toolCallCount + 1
                 }
               }, cb, toolsUsed);
             } else {
-              await this.complete(model, messages, { ...options, tools: void 0, _internal: void 0 }, cb, toolsUsed);
+              await this.complete(model, messages, {
+                ...options,
+                tools: void 0,
+                _internal: {
+                  ...options._internal,
+                  // Preserve enableIdleTimeout, idleTimeoutMs
+                  toolCallCount: toolCallCount + 1
+                }
+              }, cb, toolsUsed);
             }
           } else {
             const thinkingBlocks = this.getThinkingBlocks();
@@ -2644,12 +2848,41 @@ var AnthropicBackend = class {
       }
     } catch (error) {
       if (error instanceof RateLimitError) {
+        const mcpTools = options.tools?.filter((t) => t._isMcpTool) || [];
+        const builtInTools = options.tools?.filter((t) => !t._isMcpTool) || [];
+        const hasMcpTools = mcpTools.length > 0;
+        const hasBuiltInTools = builtInTools.length > 0;
+        let featureArea = "chat";
+        if (hasMcpTools && !hasBuiltInTools) {
+          featureArea = "mcp-tools";
+        } else if (hasMcpTools && hasBuiltInTools) {
+          featureArea = "mcp-tools+built-in";
+        } else if (hasBuiltInTools) {
+          featureArea = "built-in-tools";
+        }
+        let requestType = "initial-chat";
+        if (toolCallCount > 0) {
+          requestType = `tool-continuation-${toolCallCount}`;
+        } else if (options.tools?.length) {
+          requestType = "initial-with-tools";
+        }
         this.logger.error("[AnthropicBackend] Rate limit error after all retries exhausted", {
           model,
           status: error.status,
-          message: error.message
+          message: error.message,
+          // Context for ops (#6413)
+          featureArea,
+          requestType,
+          toolCallIteration: toolCallCount,
+          toolsUsedSoFar: toolsUsed.map((t) => t.name),
+          availableToolCount: options.tools?.length || 0,
+          mcpToolCount: mcpTools.length,
+          mcpToolNames: mcpTools.map((t) => t.toolSchema.name).slice(0, 10),
+          builtInToolCount: builtInTools.length,
+          builtInToolNames: builtInTools.map((t) => t.toolSchema.name).slice(0, 10),
+          messageCount: messages.length
         });
-        this.emitRateLimitMetric(model).catch(() => {
+        this.emitRateLimitMetric(model, featureArea).catch(() => {
         });
       } else {
         this.logger.debug("Error in complete:", error);
@@ -5975,9 +6208,14 @@ var OpenAIBackend = class {
       ...options
     };
     const toolCallCount = options._internal?.toolCallCount ?? 0;
-    if (toolCallCount >= DEFAULT_MAX_TOOL_CALLS) {
+    if (toolCallCount >= DEFAULT_MAX_TOOL_CALLS && options.tools?.length) {
       this.logger.warn(`\u26A0\uFE0F Max tool calls limit (${DEFAULT_MAX_TOOL_CALLS}) reached. Disabling tools to prevent infinite loops.`);
-      await this.complete(model, messages, { ...options, tools: void 0, _internal: void 0 }, callback, toolsUsed);
+      await this.complete(model, messages, {
+        ...options,
+        tools: void 0,
+        _internal: options._internal
+        // Preserve any internal settings
+      }, callback, toolsUsed);
       return;
     }
     const rawTools = options.tools;
@@ -6484,9 +6722,14 @@ var XAIBackend = class {
       ...options
     };
     const toolCallCount = options._internal?.toolCallCount ?? 0;
-    if (toolCallCount >= DEFAULT_MAX_TOOL_CALLS) {
+    if (toolCallCount >= DEFAULT_MAX_TOOL_CALLS && options.tools?.length) {
       this.logger.warn(`\u26A0\uFE0F Max tool calls limit (${DEFAULT_MAX_TOOL_CALLS}) reached. Disabling tools to prevent infinite loops.`);
-      await this.complete(model, messages, { ...options, tools: void 0, _internal: void 0 }, callback, toolsUsed);
+      await this.complete(model, messages, {
+        ...options,
+        tools: void 0,
+        _internal: options._internal
+        // Preserve any internal settings
+      }, callback, toolsUsed);
       return;
     }
     const rawTools = options.tools;

package/dist/{chunk-4UPFBOWT.js → chunk-ZXXSKLZA.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-HXWD4UGK.js";
+} from "./chunk-RQRJNE4K.js";
 import {
   CompletionApiUsageTransaction,
   GenericCreditDeductTransaction,

package/dist/{create-EZHKFCZQ.js → create-QDEJLD6X.js}

@@ -2,8 +2,8 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-3NN5PD22.js";
-import "./chunk-HXWD4UGK.js";
+} from "./chunk-KUGWFEGL.js";
+import "./chunk-RQRJNE4K.js";
 import "./chunk-QZAVSLFW.js";
 import "./chunk-OCYRD7D6.js";
 export {

package/dist/index.js

@@ -4,12 +4,12 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-NAIQUTDD.js";
+} from "./chunk-FGNCVUBR.js";
 import {
   ConfigStore
 } from "./chunk-VFQF2JIT.js";
-import "./chunk-4UPFBOWT.js";
-import "./chunk-3NN5PD22.js";
+import "./chunk-ZXXSKLZA.js";
+import "./chunk-KUGWFEGL.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -21,7 +21,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-HXWD4UGK.js";
+} from "./chunk-RQRJNE4K.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -12262,7 +12262,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.21-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
+  version: "0.2.21-fix-idle-timeout-error-message.18217+987e50b8a",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -12369,10 +12369,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.45.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
-    "@bike4mind/mcp": "1.25.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
-    "@bike4mind/services": "2.43.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
-    "@bike4mind/utils": "2.3.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
+    "@bike4mind/common": "2.45.1-fix-idle-timeout-error-message.18217+987e50b8a",
+    "@bike4mind/mcp": "1.25.1-fix-idle-timeout-error-message.18217+987e50b8a",
+    "@bike4mind/services": "2.43.1-fix-idle-timeout-error-message.18217+987e50b8a",
+    "@bike4mind/utils": "2.3.1-fix-idle-timeout-error-message.18217+987e50b8a",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -12389,7 +12389,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "bc1a718d076e2d84796f8b7157953656477adfd9"
+  gitHead: "987e50b8a7e8d0a0e3b9ef708138d3c6182560be"
 };
 
 // src/config/constants.ts
@@ -12623,139 +12623,6 @@ import fs13 from "fs/promises";
 import path16 from "path";
 import os3 from "os";
 import matter2 from "gray-matter";
-var FULL_MODEL_ID_PREFIXES = [
-  "claude-",
-  "gpt-",
-  "gemini-",
-  "grok-",
-  "meta.",
-  "anthropic.",
-  "us.anthropic.",
-  "global.anthropic.",
-  "amazon.",
-  "ai21.",
-  "deepseek",
-  "whisper",
-  "flux-",
-  "sora-"
-];
-var MODEL_ALIASES = {
-  // ===================
-  // Anthropic/Claude Models
-  // ===================
-  // Short aliases (most common)
-  opus: "claude-opus-4-5-20251101",
-  sonnet: "claude-sonnet-4-5-20250929",
-  haiku: "claude-3-5-haiku-20241022",
-  // Claude-prefixed aliases
-  "claude-opus": "claude-opus-4-5-20251101",
-  "claude-sonnet": "claude-sonnet-4-5-20250929",
-  "claude-haiku": "claude-3-5-haiku-20241022",
-  // Version-specific Claude aliases
-  "claude-4.5-opus": "claude-opus-4-5-20251101",
-  "claude-4.5-sonnet": "claude-sonnet-4-5-20250929",
-  "claude-4.5-haiku": "claude-haiku-4-5-20251001",
-  "claude-4-opus": "claude-opus-4-20250514",
-  "claude-4-sonnet": "claude-sonnet-4-20250514",
-  "claude-4.1-opus": "claude-opus-4-1-20250805",
-  "claude-3.7-sonnet": "claude-3-7-sonnet-20250219",
-  "claude-3.5-sonnet": "claude-3-5-sonnet-20241022",
-  "claude-3.5-haiku": "claude-3-5-haiku-20241022",
-  "claude-3-opus": "claude-3-opus-20240229",
-  // ===================
-  // OpenAI Models
-  // ===================
-  // GPT-4 family
-  "gpt-4": "gpt-4",
-  "gpt-4o": "gpt-4o",
-  "gpt-4o-mini": "gpt-4o-mini",
-  "gpt-4-turbo": "gpt-4-turbo",
-  "gpt-4.1": "gpt-4.1-2025-04-14",
-  "gpt-4.1-mini": "gpt-4.1-mini-2025-04-14",
-  "gpt-4.1-nano": "gpt-4.1-nano-2025-04-14",
-  "gpt-4.5": "gpt-4.5-preview-2025-02-27",
-  // GPT-5 family
-  "gpt-5": "gpt-5",
-  "gpt-5-mini": "gpt-5-mini",
-  "gpt-5-nano": "gpt-5-nano",
-  "gpt-5.1": "gpt-5.1",
-  "gpt-5.2": "gpt-5.2",
-  // OpenAI reasoning models (o-series)
-  o1: "o1-2024-12-17",
-  "o1-preview": "o1-preview-2024-09-12",
-  "o1-mini": "o1-mini-2024-09-12",
-  o3: "o3-2025-04-16",
-  "o3-mini": "o3-mini-2025-01-31",
-  "o4-mini": "o4-mini-2025-04-16",
-  // ===================
-  // Google Gemini Models
-  // ===================
-  gemini: "gemini-2.5-pro",
-  "gemini-pro": "gemini-2.5-pro",
-  "gemini-flash": "gemini-2.5-flash-preview-09-2025",
-  "gemini-flash-lite": "gemini-2.5-flash-lite-preview-09-2025",
-  // Gemini 3 (preview)
-  "gemini-3": "gemini-3-pro-preview",
-  "gemini-3-pro": "gemini-3-pro-preview",
-  "gemini-3-flash": "gemini-3-flash-preview",
-  // Gemini 2.5
-  "gemini-2.5": "gemini-2.5-pro",
-  "gemini-2.5-pro": "gemini-2.5-pro",
-  "gemini-2.5-flash": "gemini-2.5-flash-preview-09-2025",
-  // Gemini 2.0
-  "gemini-2.0-flash": "gemini-2.0-flash-exp",
-  // Gemini 1.5 (legacy)
-  "gemini-1.5-pro": "gemini-1.5-pro",
-  "gemini-1.5-flash": "gemini-1.5-flash",
-  "gemini-1.5-flash-8b": "gemini-1.5-flash-8b",
-  // ===================
-  // xAI Grok Models
-  // ===================
-  grok: "grok-3",
-  "grok-3": "grok-3",
-  "grok-3-fast": "grok-3-fast",
-  "grok-3-mini": "grok-3-mini",
-  "grok-3-mini-fast": "grok-3-mini-fast",
-  "grok-2": "grok-2-1212",
-  "grok-2-vision": "grok-2-vision-1212",
-  // ===================
-  // DeepSeek Models
-  // ===================
-  deepseek: "deepseek-r1:latest",
-  "deepseek-r1": "deepseek-r1:latest",
-  // ===================
-  // Llama Models (Ollama local)
-  // ===================
-  llama: "llama3.3",
-  llama3: "llama3.3",
-  "llama3.3": "llama3.3",
-  tinyllama: "tinyllama"
-};
-function getAvailableModelAliases() {
-  return Object.keys(MODEL_ALIASES).sort();
-}
-function resolveModelAlias(modelInput, agentName, filePath) {
-  const normalizedInput = modelInput.toLowerCase();
-  if (MODEL_ALIASES[normalizedInput]) {
-    return { model: MODEL_ALIASES[normalizedInput], resolved: true };
-  }
-  const hasDatePattern = /\d{8}|\d{4}-\d{2}-\d{2}/.test(modelInput);
-  const hasBedrockSuffix = modelInput.includes(":0");
-  const hasKnownPrefix = FULL_MODEL_ID_PREFIXES.some((prefix) => modelInput.startsWith(prefix));
-  if (hasDatePattern || hasBedrockSuffix || hasKnownPrefix) {
-    return { model: modelInput, resolved: true };
-  }
-  const availableAliases = getAvailableModelAliases();
-  const suggestions = availableAliases.filter((alias) => alias.includes(normalizedInput) || normalizedInput.includes(alias)).slice(0, 5);
-  let warning = `Unknown model "${modelInput}" in agent "${agentName}" (${filePath}). Using inherited model instead.
-`;
-  if (suggestions.length > 0) {
-    warning += `Did you mean: ${suggestions.join(", ")}?
-`;
-  }
-  warning += `Available aliases: opus, sonnet, haiku, gpt-4o, gemini, grok, etc. Run with --verbose for full list.`;
-  return { model: DEFAULT_AGENT_MODEL, resolved: false, warning };
-}
 var AgentStore = class {
   /**
    * Creates a new AgentStore
@@ -12846,17 +12713,10 @@ var AgentStore = class {
     const { data: frontmatter, content: body } = matter2(content);
     const parsed = AgentFrontmatterSchema.parse(frontmatter);
     const name = path16.basename(filePath, ".md");
-    const modelInput = parsed.model || DEFAULT_AGENT_MODEL;
-    const resolution = resolveModelAlias(modelInput, name, filePath);
-    if (!resolution.resolved && resolution.warning) {
-      console.warn(`
-\u26A0\uFE0F  ${resolution.warning}
-`);
-    }
     return {
       name,
       description: parsed.description,
-      model: resolution.model,
+      model: parsed.model || DEFAULT_AGENT_MODEL,
       systemPrompt: body.trim(),
       allowedTools: parsed["allowed-tools"],
       deniedTools: parsed["denied-tools"],

package/dist/{mementoService-C34LNDCN.js → mementoService-KSDOJKMT.js}

@@ -2,8 +2,8 @@
 import {
   findMostSimilarMemento,
   getRelevantMementos
-} from "./chunk-NAIQUTDD.js";
-import "./chunk-HXWD4UGK.js";
+} from "./chunk-FGNCVUBR.js";
+import "./chunk-RQRJNE4K.js";
 import "./chunk-QZAVSLFW.js";
 import "./chunk-OCYRD7D6.js";
 export {

package/dist/{src-2ENQ4HWZ.js → src-XY56MWV2.js}

@@ -132,7 +132,7 @@ import {
   validateMermaidSyntax,
   warmUpSettingsCache,
   withRetry
-} from "./chunk-HXWD4UGK.js";
+} from "./chunk-RQRJNE4K.js";
 import "./chunk-QZAVSLFW.js";
 import {
   Logger,

package/dist/{subtractCredits-5SDCKUXU.js → subtractCredits-3VRXFXK3.js}

@@ -2,8 +2,8 @@
 import {
   SubtractCreditsSchema,
   subtractCredits
-} from "./chunk-4UPFBOWT.js";
-import "./chunk-HXWD4UGK.js";
+} from "./chunk-ZXXSKLZA.js";
+import "./chunk-RQRJNE4K.js";
 import "./chunk-QZAVSLFW.js";
 import "./chunk-OCYRD7D6.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.21-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
+  "version": "0.2.21-fix-idle-timeout-error-message.18217+987e50b8a",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -107,10 +107,10 @@
   },
   "devDependencies": {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.45.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
-    "@bike4mind/mcp": "1.25.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
-    "@bike4mind/services": "2.43.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
-    "@bike4mind/utils": "2.3.1-fix-cli-subagent-model-alias-resolution.18205+bc1a718d0",
+    "@bike4mind/common": "2.45.1-fix-idle-timeout-error-message.18217+987e50b8a",
+    "@bike4mind/mcp": "1.25.1-fix-idle-timeout-error-message.18217+987e50b8a",
+    "@bike4mind/services": "2.43.1-fix-idle-timeout-error-message.18217+987e50b8a",
+    "@bike4mind/utils": "2.3.1-fix-idle-timeout-error-message.18217+987e50b8a",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -127,5 +127,5 @@
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.17.0"
   },
-  "gitHead": "bc1a718d076e2d84796f8b7157953656477adfd9"
+  "gitHead": "987e50b8a7e8d0a0e3b9ef708138d3c6182560be"
 }