@bike4mind/cli 0.2.21-feat-github-actions-tool.18145 → 0.2.21-feat-parallel-tool-execution.18205

package/dist/{artifactExtractor-XANU5PEF.js → artifactExtractor-Q3U32BGB.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-5KL57ZUQ.js";
+} from "./chunk-VDLQKG5O.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
 var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;

package/dist/{chunk-LPCUVTNE.js → chunk-HERXMXE5.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-JX2UMMZA.js";
+} from "./chunk-QKJ4CHK6.js";
 import {
   CompletionApiUsageTransaction,
   GenericCreditDeductTransaction,
@@ -12,7 +12,7 @@ import {
   TextGenerationUsageTransaction,
   TransferCreditTransaction,
   VideoGenerationUsageTransaction
-} from "./chunk-5KL57ZUQ.js";
+} from "./chunk-VDLQKG5O.js";
 
 // ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
 import { z } from "zod";

package/dist/{chunk-K47YN3CC.js → chunk-JDCBPT4Y.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-JX2UMMZA.js";
+} from "./chunk-QKJ4CHK6.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-5KL57ZUQ.js";
+} from "./chunk-VDLQKG5O.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{chunk-JX2UMMZA.js → chunk-QKJ4CHK6.js}

@@ -15,7 +15,7 @@ import {
   dayjsConfig_default,
   extractSnippetMeta,
   settingsMap
-} from "./chunk-5KL57ZUQ.js";
+} from "./chunk-VDLQKG5O.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -1946,6 +1946,9 @@ var TEMPERATURE_ONLY_MODELS = [
   ChatModels.CLAUDE_4_5_HAIKU,
   ChatModels.CLAUDE_4_5_OPUS
 ];
+var INITIAL_TIMEOUT_MS = 3e4;
+var DEFAULT_IDLE_TIMEOUT_MS = 9e4;
+var THINKING_IDLE_TIMEOUT_MS = 18e4;
 var AnthropicBackend = class {
   _api;
   logger;
@@ -1993,6 +1996,42 @@ var AnthropicBackend = class {
       });
     }
   }
+  /**
+   * Emit a CloudWatch metric when a stream idle timeout occurs.
+   * This helps monitor and alert on Anthropic API streaming hang issues.
+   */
+  async emitIdleTimeoutMetric(model, toolCount, eventCount) {
+    try {
+      const client = new CloudWatchClient({
+        region: process.env.AWS_REGION || "us-east-2"
+      });
+      const command = new PutMetricDataCommand({
+        Namespace: "Lumina5/LLMStreaming",
+        MetricData: [
+          {
+            MetricName: "StreamIdleTimeoutTriggered",
+            Value: 1,
+            Unit: StandardUnit.Count,
+            Timestamp: /* @__PURE__ */ new Date(),
+            Dimensions: [
+              { Name: "Model", Value: model },
+              { Name: "Stage", Value: process.env.SEED_STAGE_NAME || "local" }
+            ]
+          }
+        ]
+      });
+      await client.send(command);
+      this.logger.info("[AnthropicBackend] Emitted StreamIdleTimeoutTriggered metric to CloudWatch", {
+        model,
+        toolCount,
+        eventCount
+      });
+    } catch (metricsError) {
+      this.logger.warn("[AnthropicBackend] Failed to emit idle timeout CloudWatch metric", {
+        error: metricsError instanceof Error ? metricsError.message : String(metricsError)
+      });
+    }
+  }
   /**
    * Get thinking blocks from the last assistant content.
    * Filters to only include thinking/redacted_thinking blocks.
@@ -2331,75 +2370,111 @@ var AnthropicBackend = class {
             const stream = await this._api.messages.create({ ...apiParams, stream: true }, { signal: options.abortSignal });
             let isInThinkingBlock = false;
             const collectedContent = [];
-            for await (const event of stream) {
-              const streamedText = [];
-              if (event.type === "content_block_start") {
-                if ("content_block" in event && event.content_block.type === "thinking") {
-                  isInThinkingBlock = true;
-                  collectedContent[event.index] = {
-                    type: "thinking",
-                    thinking: "",
-                    ...event.content_block
-                    // Preserve all fields including signature
-                  };
-                  streamedText[event.index] = "<think>";
-                  await cb(streamedText, { toolsUsed });
-                } else if ("content_block" in event && event.content_block.type === "tool_use") {
-                  const toolBlock = event.content_block;
-                  func[event.index] ||= {};
-                  func[event.index].name = toolBlock.name;
-                  func[event.index].id = toolBlock.id;
-                  func[event.index].parameters = "";
-                  collectedContent[event.index] = {
-                    type: "tool_use",
-                    id: toolBlock.id,
-                    name: toolBlock.name,
-                    input: {}
-                  };
-                }
-              } else if (event.type === "content_block_delta") {
-                if ("delta" in event && event.delta.type === "thinking_delta") {
-                  const thinkingText = event.delta.thinking;
-                  if (collectedContent[event.index]) {
-                    collectedContent[event.index].thinking += thinkingText;
-                  }
-                  streamedText[event.index] = thinkingText;
-                  await cb(streamedText, { toolsUsed });
-                } else if ("delta" in event && event.delta.type === "text_delta") {
-                  streamedText[event.index] = event.delta.text;
-                  await cb(streamedText, { toolsUsed });
-                } else if ("delta" in event && event.delta.type === "input_json_delta") {
-                  if (func[event.index]) {
-                    func[event.index].parameters += event.delta.partial_json || "";
-                  }
-                  if (collectedContent[event.index] && collectedContent[event.index].type === "tool_use") {
+            const enableIdleTimeout = options._internal?.enableIdleTimeout ?? false;
+            const configuredIdleTimeoutMs = options._internal?.idleTimeoutMs;
+            const idleTimeoutMs = this.isThinkingEnabled ? THINKING_IDLE_TIMEOUT_MS : configuredIdleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+            let idleTimer;
+            let eventCount = 0;
+            let lastEventType = "";
+            const resetIdleTimer = () => {
+              if (!enableIdleTimeout)
+                return;
+              if (idleTimer)
+                clearTimeout(idleTimer);
+              const timeoutMs = eventCount === 0 ? INITIAL_TIMEOUT_MS : idleTimeoutMs;
+              idleTimer = setTimeout(() => {
+                this.logger.error("[AnthropicBackend] Stream idle timeout - no events received", {
+                  model,
+                  eventCount,
+                  lastEventType,
+                  timeoutMs,
+                  toolCount: options.tools?.length || 0,
+                  mcpToolCount: options.tools?.filter((t) => t._isMcpTool).length || 0
+                });
+                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();
+            try {
+              for await (const event of stream) {
+                eventCount++;
+                lastEventType = event.type;
+                resetIdleTimer();
+                const streamedText = [];
+                if (event.type === "content_block_start") {
+                  if ("content_block" in event && event.content_block.type === "thinking") {
+                    isInThinkingBlock = true;
+                    collectedContent[event.index] = {
+                      type: "thinking",
+                      thinking: "",
+                      ...event.content_block
+                      // Preserve all fields including signature
+                    };
+                    streamedText[event.index] = "<think>";
+                    await cb(streamedText, { toolsUsed });
+                  } else if ("content_block" in event && event.content_block.type === "tool_use") {
+                    const toolBlock = event.content_block;
+                    func[event.index] ||= {};
+                    func[event.index].name = toolBlock.name;
+                    func[event.index].id = toolBlock.id;
+                    func[event.index].parameters = "";
+                    collectedContent[event.index] = {
+                      type: "tool_use",
+                      id: toolBlock.id,
+                      name: toolBlock.name,
+                      input: {}
+                    };
                   }
-                } else if ("delta" in event && event.delta.type === "signature_delta") {
-                  if (collectedContent[event.index] && collectedContent[event.index].type === "thinking") {
-                    collectedContent[event.index].signature = event.delta.signature;
+                } else if (event.type === "content_block_delta") {
+                  if ("delta" in event && event.delta.type === "thinking_delta") {
+                    const thinkingText = event.delta.thinking;
+                    if (collectedContent[event.index]) {
+                      collectedContent[event.index].thinking += thinkingText;
+                    }
+                    streamedText[event.index] = thinkingText;
+                    await cb(streamedText, { toolsUsed });
+                  } else if ("delta" in event && event.delta.type === "text_delta") {
+                    streamedText[event.index] = event.delta.text;
+                    await cb(streamedText, { toolsUsed });
+                  } else if ("delta" in event && event.delta.type === "input_json_delta") {
+                    if (func[event.index]) {
+                      func[event.index].parameters += event.delta.partial_json || "";
+                    }
+                    if (collectedContent[event.index] && collectedContent[event.index].type === "tool_use") {
+                    }
+                  } else if ("delta" in event && event.delta.type === "signature_delta") {
+                    if (collectedContent[event.index] && collectedContent[event.index].type === "thinking") {
+                      collectedContent[event.index].signature = event.delta.signature;
+                    }
                   }
-                }
-              } else if (event.type === "content_block_stop") {
-                if (isInThinkingBlock) {
-                  isInThinkingBlock = false;
-                  streamedText[event.index] = "</think>";
-                  await cb(streamedText, { toolsUsed });
-                } else if (collectedContent[event.index] && collectedContent[event.index].type === "tool_use") {
-                  if (func[event.index] && func[event.index].parameters) {
-                    try {
-                      collectedContent[event.index].input = JSON.parse(func[event.index].parameters || "{}");
-                    } catch (e) {
-                      collectedContent[event.index].input = {};
+                } else if (event.type === "content_block_stop") {
+                  if (isInThinkingBlock) {
+                    isInThinkingBlock = false;
+                    streamedText[event.index] = "</think>";
+                    await cb(streamedText, { toolsUsed });
+                  } else if (collectedContent[event.index] && collectedContent[event.index].type === "tool_use") {
+                    if (func[event.index] && func[event.index].parameters) {
+                      try {
+                        collectedContent[event.index].input = JSON.parse(func[event.index].parameters || "{}");
+                      } catch (e) {
+                        collectedContent[event.index].input = {};
+                      }
                     }
                   }
+                } else if (this.isToolUseEvent(event)) {
+                  func[0] ||= {};
+                  const toolEvent = event;
+                  func[0].name = toolEvent.name;
+                  func[0].parameters = JSON.stringify(toolEvent.input);
+                  func[0].id = toolEvent.id;
                 }
-              } else if (this.isToolUseEvent(event)) {
-                func[0] ||= {};
-                const toolEvent = event;
-                func[0].name = toolEvent.name;
-                func[0].parameters = JSON.stringify(toolEvent.input);
-                func[0].id = toolEvent.id;
               }
+            } finally {
+              if (idleTimer)
+                clearTimeout(idleTimer);
             }
             if (this.isThinkingEnabled && collectedContent.length > 0) {
               this.lastAssistantContent = collectedContent.filter((c) => c != null);

package/dist/{chunk-5KL57ZUQ.js → chunk-VDLQKG5O.js}

@@ -285,6 +285,7 @@ var b4mLLMTools = z5.enum([
   "edit_image",
   "weather_info",
   "web_search",
+  "web_fetch",
   "math_evaluate",
   "mermaid_chart",
   "current_datetime",
@@ -2236,7 +2237,14 @@ var SettingKeySchema = z21.enum([
   // TIME MACHINE & NIGHT SKY SETTINGS
   "EnableEnhancedDateTime",
   "EnableHistoricalFeatures",
-  "EnableAstronomyFeatures"
+  "EnableAstronomyFeatures",
+  // STREAMING RESILIENCE SETTINGS
+  "EnableStreamIdleTimeout",
+  "StreamIdleTimeoutSeconds",
+  "EnableMcpToolFiltering",
+  "McpToolFilteringMaxTools",
+  // PARALLEL TOOL EXECUTION SETTINGS
+  "EnableParallelToolExecution"
 ]);
 var CategoryOrder = [
   "AI",
@@ -2610,7 +2618,12 @@ var API_SERVICE_GROUPS = {
       { key: "EnableResearchEngine", order: 8 },
       { key: "EnableReactViewer", order: 9 },
       { key: "EnableDeepResearch", order: 10 },
-      { key: "EnableKnowledgeBaseSearch", order: 11 }
+      { key: "EnableKnowledgeBaseSearch", order: 11 },
+      { key: "EnableStreamIdleTimeout", order: 12 },
+      { key: "StreamIdleTimeoutSeconds", order: 13 },
+      { key: "EnableMcpToolFiltering", order: 14 },
+      { key: "McpToolFilteringMaxTools", order: 15 },
+      { key: "EnableParallelToolExecution", order: 16 }
     ]
   },
   NOTEBOOK: {
@@ -3713,6 +3726,53 @@ var settingsMap = {
     category: "Tools",
     group: API_SERVICE_GROUPS.DATETIME_ASTRONOMY.id,
     order: 3
+  }),
+  // Streaming Resilience Settings
+  EnableStreamIdleTimeout: makeBooleanSetting({
+    key: "EnableStreamIdleTimeout",
+    name: "Enable Stream Idle Timeout",
+    defaultValue: false,
+    description: "Detect and abort hanging Anthropic streams when no events are received within the timeout period. Experimental feature to address SDK streaming hang issues.",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 12
+  }),
+  StreamIdleTimeoutSeconds: makeNumberSetting({
+    key: "StreamIdleTimeoutSeconds",
+    name: "Stream Idle Timeout (seconds)",
+    defaultValue: 90,
+    description: "Seconds to wait between stream events before aborting. Use 180 for thinking models (Claude 4.x with extended thinking). Default: 90 seconds.",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 13
+  }),
+  EnableMcpToolFiltering: makeBooleanSetting({
+    key: "EnableMcpToolFiltering",
+    name: "Enable MCP Tool Filtering",
+    defaultValue: false,
+    description: "Filter MCP tools by relevance to user query to reduce payload size. Experimental feature to reduce streaming hangs with large tool sets (e.g., Jira with 44 tools).",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 14
+  }),
+  McpToolFilteringMaxTools: makeNumberSetting({
+    key: "McpToolFilteringMaxTools",
+    name: "Max MCP Tools After Filtering",
+    defaultValue: 20,
+    description: "Maximum number of MCP tools to send after relevance filtering. Only applies when EnableMcpToolFiltering is enabled.",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 15
+  }),
+  // Parallel Tool Execution Settings
+  EnableParallelToolExecution: makeBooleanSetting({
+    key: "EnableParallelToolExecution",
+    name: "Enable Parallel Tool Execution",
+    defaultValue: false,
+    description: "Execute read-only tools (file reads, searches) in parallel for 2-3x speed improvement. Write tools still execute sequentially for safety.",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 16
   })
   // Add more settings as needed
 };

package/dist/{chunk-54MIWLFL.js → chunk-YLRAYIDX.js}

@@ -6,12 +6,12 @@ import {
   getSettingsByNames,
   obfuscateApiKey,
   secureParameters
-} from "./chunk-JX2UMMZA.js";
+} from "./chunk-QKJ4CHK6.js";
 import {
   ApiKeyType,
   MementoTier,
   isSupportedEmbeddingModel
-} from "./chunk-5KL57ZUQ.js";
+} from "./chunk-VDLQKG5O.js";
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/get.js
 import { z } from "zod";

package/dist/{create-DI6IQP5P.js → create-BORKSAPA.js}

@@ -2,9 +2,9 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-K47YN3CC.js";
-import "./chunk-JX2UMMZA.js";
-import "./chunk-5KL57ZUQ.js";
+} from "./chunk-JDCBPT4Y.js";
+import "./chunk-QKJ4CHK6.js";
+import "./chunk-VDLQKG5O.js";
 import "./chunk-OCYRD7D6.js";
 export {
   createFabFile,