@within-7/minto 0.1.7 → 0.2.0

package/dist/utils/generators.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/generators.ts"],
-  "sourcesContent": ["const NO_VALUE = Symbol('NO_VALUE')\n\nexport async function lastX<A>(as: AsyncGenerator<A>): Promise<A> {\n  let lastValue: A | typeof NO_VALUE = NO_VALUE\n  for await (const a of as) {\n    lastValue = a\n  }\n  if (lastValue === NO_VALUE) {\n    throw new Error('No items in generator')\n  }\n  return lastValue\n}\n\ntype QueuedGenerator<A> = {\n  done: boolean | void\n  value: A | void\n  generator: AsyncGenerator<A, void>\n  promise: Promise<QueuedGenerator<A>>\n}\n\n// Run all generators concurrently up to a concurrency cap, yielding values as they come in\nexport async function* all<A>(\n  generators: AsyncGenerator<A, void>[],\n  concurrencyCap = Infinity,\n): AsyncGenerator<A, void> {\n  const next = (generator: AsyncGenerator<A, void>) => {\n    const promise: Promise<QueuedGenerator<A>> = generator\n      .next()\n      .then(({ done, value }) => ({\n        done,\n        value,\n        generator,\n        promise,\n      }))\n    return promise\n  }\n  const waiting = [...generators]\n  const promises = new Set<Promise<QueuedGenerator<A>>>()\n\n  // Start initial batch up to concurrency cap\n  while (promises.size < concurrencyCap && waiting.length > 0) {\n    const gen = waiting.shift()!\n    promises.add(next(gen))\n  }\n\n  while (promises.size > 0) {\n    const { done, value, generator, promise } = await Promise.race(promises)\n    promises.delete(promise)\n\n    if (!done) {\n      promises.add(next(generator))\n      // Yield non-undefined values from the generator\n      if (value !== undefined) {\n        yield value as A\n      }\n    } else if (waiting.length > 0) {\n      // Start a new generator when one finishes\n      const nextGen = waiting.shift()!\n      promises.add(next(nextGen))\n    }\n  }\n}\n"],
-  "mappings": "AAAA,MAAM,WAAW,OAAO,UAAU;AAElC,eAAsB,MAAS,IAAmC;AAChE,MAAI,YAAiC;AACrC,mBAAiB,KAAK,IAAI;AACxB,gBAAY;AAAA,EACd;AACA,MAAI,cAAc,UAAU;AAC1B,UAAM,IAAI,MAAM,uBAAuB;AAAA,EACzC;AACA,SAAO;AACT;AAUA,gBAAuB,IACrB,YACA,iBAAiB,UACQ;AACzB,QAAM,OAAO,CAAC,cAAuC;AACnD,UAAM,UAAuC,UAC1C,KAAK,EACL,KAAK,CAAC,EAAE,MAAM,MAAM,OAAO;AAAA,MAC1B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,EAAE;AACJ,WAAO;AAAA,EACT;AACA,QAAM,UAAU,CAAC,GAAG,UAAU;AAC9B,QAAM,WAAW,oBAAI,IAAiC;AAGtD,SAAO,SAAS,OAAO,kBAAkB,QAAQ,SAAS,GAAG;AAC3D,UAAM,MAAM,QAAQ,MAAM;AAC1B,aAAS,IAAI,KAAK,GAAG,CAAC;AAAA,EACxB;AAEA,SAAO,SAAS,OAAO,GAAG;AACxB,UAAM,EAAE,MAAM,OAAO,WAAW,QAAQ,IAAI,MAAM,QAAQ,KAAK,QAAQ;AACvE,aAAS,OAAO,OAAO;AAEvB,QAAI,CAAC,MAAM;AACT,eAAS,IAAI,KAAK,SAAS,CAAC;AAE5B,UAAI,UAAU,QAAW;AACvB,cAAM;AAAA,MACR;AAAA,IACF,WAAW,QAAQ,SAAS,GAAG;AAE7B,YAAM,UAAU,QAAQ,MAAM;AAC9B,eAAS,IAAI,KAAK,OAAO,CAAC;AAAA,IAC5B;AAAA,EACF;AACF;",
+  "sourcesContent": ["import { debug } from './debugLogger'\n\nconst NO_VALUE = Symbol('NO_VALUE')\n\nexport async function lastX<A>(as: AsyncGenerator<A>): Promise<A> {\n  let lastValue: A | typeof NO_VALUE = NO_VALUE\n  for await (const a of as) {\n    lastValue = a\n  }\n  if (lastValue === NO_VALUE) {\n    throw new Error('No items in generator')\n  }\n  return lastValue\n}\n\ntype QueuedGenerator<A> = {\n  done: boolean | void\n  value: A | void\n  generator: AsyncGenerator<A, void>\n  promise: Promise<QueuedGenerator<A>>\n  id: number // Track generator ID for debugging\n}\n\n// Run all generators concurrently up to a concurrency cap, yielding values as they come in\n// Supports abort signal for graceful cancellation of all running generators\nexport async function* all<A>(\n  generators: AsyncGenerator<A, void>[],\n  concurrencyCap = Infinity,\n  abortSignal?: AbortSignal,\n): AsyncGenerator<A, void> {\n  let generatorIdCounter = 0\n  const generatorIds = new Map<AsyncGenerator<A, void>, number>()\n  const activeGenerators = new Set<AsyncGenerator<A, void>>()\n\n  const next = (generator: AsyncGenerator<A, void>) => {\n    let id = generatorIds.get(generator)\n    if (id === undefined) {\n      id = generatorIdCounter++\n      generatorIds.set(generator, id)\n    }\n    activeGenerators.add(generator)\n    const promise: Promise<QueuedGenerator<A>> = generator\n      .next()\n      .then(({ done, value }) => ({\n        done,\n        value,\n        generator,\n        promise,\n        id: id!,\n      }))\n    return promise\n  }\n\n  // Helper to gracefully terminate all active generators\n  const terminateAll = async () => {\n    debug.flow('ALL_GENERATORS_ABORT', {\n      activeCount: activeGenerators.size,\n    })\n    for (const gen of activeGenerators) {\n      try {\n        await gen.return(undefined)\n      } catch {\n        // Ignore errors during cleanup\n      }\n    }\n    activeGenerators.clear()\n  }\n\n  const waiting = [...generators]\n  const promises = new Set<Promise<QueuedGenerator<A>>>()\n\n  debug.flow('ALL_GENERATORS_START', {\n    totalGenerators: generators.length,\n    concurrencyCap,\n    hasAbortSignal: !!abortSignal,\n  })\n\n  // Check if already aborted\n  if (abortSignal?.aborted) {\n    debug.flow('ALL_GENERATORS_ALREADY_ABORTED', {})\n    return\n  }\n\n  // Start initial batch up to concurrency cap\n  while (promises.size < concurrencyCap && waiting.length > 0) {\n    const gen = waiting.shift()!\n    promises.add(next(gen))\n  }\n\n  debug.flow('ALL_GENERATORS_INITIAL_BATCH', {\n    activeCount: promises.size,\n    waitingCount: waiting.length,\n  })\n\n  let yieldCount = 0\n  let completedCount = 0\n\n  while (promises.size > 0) {\n    // Check for abort signal before each iteration\n    if (abortSignal?.aborted) {\n      debug.flow('ALL_GENERATORS_ABORT_DETECTED', {\n        completedCount,\n        remainingActive: promises.size,\n      })\n      await terminateAll()\n      return\n    }\n\n    const { done, value, generator, promise, id } = await Promise.race(promises)\n    promises.delete(promise)\n\n    // Check abort again after awaiting\n    if (abortSignal?.aborted) {\n      debug.flow('ALL_GENERATORS_ABORT_AFTER_RACE', {\n        completedCount,\n        remainingActive: promises.size,\n      })\n      await terminateAll()\n      return\n    }\n\n    if (!done) {\n      promises.add(next(generator))\n      // Yield non-undefined values from the generator\n      if (value !== undefined) {\n        yieldCount++\n        yield value as A\n      }\n    } else {\n      completedCount++\n      activeGenerators.delete(generator)\n      debug.flow('ALL_GENERATOR_COMPLETED', {\n        generatorId: id,\n        completedCount,\n        remainingActive: promises.size,\n        waitingCount: waiting.length,\n      })\n      if (waiting.length > 0) {\n        // Start a new generator when one finishes\n        const nextGen = waiting.shift()!\n        promises.add(next(nextGen))\n      }\n    }\n  }\n\n  debug.flow('ALL_GENERATORS_DONE', {\n    totalGenerators: generators.length,\n    totalYields: yieldCount,\n    totalCompleted: completedCount,\n  })\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/utils/globalErrorHandler.js

@@ -0,0 +1,149 @@
+import { captureException } from "../services/sentry.js";
+import { logError } from "./log.js";
+let isInitialized = false;
+let isShuttingDown = false;
+var ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
+  ErrorSeverity2["LOW"] = "low";
+  ErrorSeverity2["MEDIUM"] = "medium";
+  ErrorSeverity2["HIGH"] = "high";
+  ErrorSeverity2["CRITICAL"] = "critical";
+  return ErrorSeverity2;
+})(ErrorSeverity || {});
+function categorizeError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("out of memory") || message.includes("heap") || message.includes("stack overflow") || error.name === "RangeError") {
+      return "critical" /* CRITICAL */;
+    }
+    if (message.includes("api") || message.includes("network") || message.includes("econnrefused") || message.includes("timeout")) {
+      return "high" /* HIGH */;
+    }
+    if (error.name === "TypeError" || error.name === "ReferenceError" || message.includes("undefined") || message.includes("null")) {
+      return "medium" /* MEDIUM */;
+    }
+  }
+  return "low" /* LOW */;
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}
+${error.stack || ""}`;
+  }
+  return String(error);
+}
+function handleUnhandledRejection(reason, promise) {
+  if (isShuttingDown) return;
+  const severity = categorizeError(reason);
+  const formattedError = formatError(reason);
+  console.error(`
+[${severity.toUpperCase()}] Unhandled Promise Rejection:`);
+  console.error(formattedError);
+  try {
+    logError(reason instanceof Error ? reason : new Error(String(reason)));
+  } catch {
+  }
+  try {
+    captureException(
+      reason instanceof Error ? reason : new Error(String(reason))
+    );
+  } catch {
+  }
+  if (severity === "critical" /* CRITICAL */) {
+    console.error("\n\u26A0\uFE0F  Critical error detected. Consider restarting.");
+  }
+}
+function handleUncaughtException(error, origin) {
+  if (isShuttingDown) return;
+  const severity = categorizeError(error);
+  const formattedError = formatError(error);
+  console.error(`
+[${severity.toUpperCase()}] Uncaught Exception (${origin}):`);
+  console.error(formattedError);
+  try {
+    logError(error);
+  } catch {
+  }
+  try {
+    captureException(error);
+  } catch {
+  }
+  if (severity === "critical" /* CRITICAL */) {
+    console.error(
+      "\n\u{1F4A5} Critical uncaught exception. Shutting down gracefully..."
+    );
+    gracefulShutdown(1);
+  }
+}
+function handleWarning(warning) {
+  if (process.env.VERBOSE === "true" || warning.name === "DeprecationWarning" || warning.name === "ExperimentalWarning") {
+    console.warn(`
+\u26A0\uFE0F  Warning [${warning.name}]: ${warning.message}`);
+  }
+}
+const cleanupHandlers = [];
+function registerCleanupHandler(handler) {
+  cleanupHandlers.push(handler);
+}
+function unregisterCleanupHandler(handler) {
+  const index = cleanupHandlers.indexOf(handler);
+  if (index > -1) {
+    cleanupHandlers.splice(index, 1);
+  }
+}
+async function gracefulShutdown(exitCode = 0) {
+  if (isShuttingDown) return;
+  isShuttingDown = true;
+  console.error("\n\u{1F504} Running cleanup handlers...");
+  for (const handler of cleanupHandlers) {
+    try {
+      await handler();
+    } catch (error) {
+      console.error("Cleanup handler error:", error);
+    }
+  }
+  console.error("\u2705 Cleanup complete.");
+  process.exit(exitCode);
+}
+function initGlobalErrorHandlers() {
+  if (isInitialized) return;
+  isInitialized = true;
+  process.on("unhandledRejection", handleUnhandledRejection);
+  process.on("uncaughtException", handleUncaughtException);
+  process.on("warning", handleWarning);
+  process.on("SIGTERM", () => {
+    console.error("\nReceived SIGTERM signal.");
+    gracefulShutdown(0);
+  });
+  process.on("SIGINT", () => {
+  });
+  process.on("beforeExit", (code) => {
+    if (!isShuttingDown && cleanupHandlers.length > 0) {
+      gracefulShutdown(code);
+    }
+  });
+}
+function isGlobalErrorHandlersInitialized() {
+  return isInitialized;
+}
+function resetGlobalErrorHandlers() {
+  if (process.env.NODE_ENV !== "test") {
+    throw new Error("resetGlobalErrorHandlers can only be called in tests");
+  }
+  process.removeAllListeners("unhandledRejection");
+  process.removeAllListeners("uncaughtException");
+  process.removeAllListeners("warning");
+  process.removeAllListeners("SIGTERM");
+  process.removeAllListeners("beforeExit");
+  isInitialized = false;
+  isShuttingDown = false;
+  cleanupHandlers.length = 0;
+}
+export {
+  ErrorSeverity,
+  initGlobalErrorHandlers,
+  isGlobalErrorHandlersInitialized,
+  registerCleanupHandler,
+  resetGlobalErrorHandlers,
+  unregisterCleanupHandler
+};
+//# sourceMappingURL=globalErrorHandler.js.map

package/dist/utils/globalErrorHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/globalErrorHandler.ts"],
+  "sourcesContent": ["/**\n * Global Error Handler\n *\n * Handles unhandled promise rejections and uncaught exceptions\n * to prevent silent crashes and ensure proper cleanup.\n */\n\nimport { captureException } from '@services/sentry'\nimport { logError } from './log'\n\nlet isInitialized = false\nlet isShuttingDown = false\n\n/**\n * Error severity levels\n */\nexport enum ErrorSeverity {\n  LOW = 'low',\n  MEDIUM = 'medium',\n  HIGH = 'high',\n  CRITICAL = 'critical',\n}\n\n/**\n * Categorize error severity based on error type\n */\nfunction categorizeError(error: unknown): ErrorSeverity {\n  if (error instanceof Error) {\n    const message = error.message.toLowerCase()\n\n    // Critical: System-level failures\n    if (\n      message.includes('out of memory') ||\n      message.includes('heap') ||\n      message.includes('stack overflow') ||\n      error.name === 'RangeError'\n    ) {\n      return ErrorSeverity.CRITICAL\n    }\n\n    // High: API and network failures\n    if (\n      message.includes('api') ||\n      message.includes('network') ||\n      message.includes('econnrefused') ||\n      message.includes('timeout')\n    ) {\n      return ErrorSeverity.HIGH\n    }\n\n    // Medium: Logic errors\n    if (\n      error.name === 'TypeError' ||\n      error.name === 'ReferenceError' ||\n      message.includes('undefined') ||\n      message.includes('null')\n    ) {\n      return ErrorSeverity.MEDIUM\n    }\n  }\n\n  return ErrorSeverity.LOW\n}\n\n/**\n * Format error for logging\n */\nfunction formatError(error: unknown): string {\n  if (error instanceof Error) {\n    return `${error.name}: ${error.message}\\n${error.stack || ''}`\n  }\n  return String(error)\n}\n\n/**\n * Handle unhandled promise rejection\n */\nfunction handleUnhandledRejection(\n  reason: unknown,\n  promise: Promise<unknown>,\n): void {\n  if (isShuttingDown) return\n\n  const severity = categorizeError(reason)\n  const formattedError = formatError(reason)\n\n  // Log to console with severity indicator\n  console.error(`\\n[${severity.toUpperCase()}] Unhandled Promise Rejection:`)\n  console.error(formattedError)\n\n  // Log to file\n  try {\n    logError(reason instanceof Error ? reason : new Error(String(reason)))\n  } catch {\n    // Ignore logging errors during error handling\n  }\n\n  // Report to Sentry\n  try {\n    captureException(\n      reason instanceof Error ? reason : new Error(String(reason)),\n    )\n  } catch {\n    // Ignore Sentry errors\n  }\n\n  // For critical errors, consider graceful shutdown\n  if (severity === ErrorSeverity.CRITICAL) {\n    console.error('\\n\u26A0\uFE0F  Critical error detected. Consider restarting.')\n  }\n}\n\n/**\n * Handle uncaught exception\n */\nfunction handleUncaughtException(error: Error, origin: string): void {\n  if (isShuttingDown) return\n\n  const severity = categorizeError(error)\n  const formattedError = formatError(error)\n\n  // Log to console\n  console.error(`\\n[${severity.toUpperCase()}] Uncaught Exception (${origin}):`)\n  console.error(formattedError)\n\n  // Log to file\n  try {\n    logError(error)\n  } catch {\n    // Ignore logging errors during error handling\n  }\n\n  // Report to Sentry\n  try {\n    captureException(error)\n  } catch {\n    // Ignore Sentry errors\n  }\n\n  // For uncaught exceptions, we should exit gracefully\n  if (severity === ErrorSeverity.CRITICAL) {\n    console.error(\n      '\\n\uD83D\uDCA5 Critical uncaught exception. Shutting down gracefully...',\n    )\n    gracefulShutdown(1)\n  }\n}\n\n/**\n * Handle process warnings\n */\nfunction handleWarning(warning: Error): void {\n  // Only log in verbose mode or for specific warning types\n  if (\n    process.env.VERBOSE === 'true' ||\n    warning.name === 'DeprecationWarning' ||\n    warning.name === 'ExperimentalWarning'\n  ) {\n    console.warn(`\\n\u26A0\uFE0F  Warning [${warning.name}]: ${warning.message}`)\n  }\n}\n\n/**\n * Cleanup handlers for graceful shutdown\n */\nconst cleanupHandlers: Array<() => void | Promise<void>> = []\n\n/**\n * Register a cleanup handler to be called during shutdown\n */\nexport function registerCleanupHandler(\n  handler: () => void | Promise<void>,\n): void {\n  cleanupHandlers.push(handler)\n}\n\n/**\n * Unregister a cleanup handler\n */\nexport function unregisterCleanupHandler(\n  handler: () => void | Promise<void>,\n): void {\n  const index = cleanupHandlers.indexOf(handler)\n  if (index > -1) {\n    cleanupHandlers.splice(index, 1)\n  }\n}\n\n/**\n * Perform graceful shutdown\n */\nasync function gracefulShutdown(exitCode: number = 0): Promise<void> {\n  if (isShuttingDown) return\n  isShuttingDown = true\n\n  console.error('\\n\uD83D\uDD04 Running cleanup handlers...')\n\n  // Run all cleanup handlers\n  for (const handler of cleanupHandlers) {\n    try {\n      await handler()\n    } catch (error) {\n      console.error('Cleanup handler error:', error)\n    }\n  }\n\n  // Note: Sentry flush is handled by the sentry service if needed\n\n  console.error('\u2705 Cleanup complete.')\n  process.exit(exitCode)\n}\n\n/**\n * Initialize global error handlers\n * Should be called early in the application lifecycle\n */\nexport function initGlobalErrorHandlers(): void {\n  if (isInitialized) return\n  isInitialized = true\n\n  // Handle unhandled promise rejections\n  process.on('unhandledRejection', handleUnhandledRejection)\n\n  // Handle uncaught exceptions\n  process.on('uncaughtException', handleUncaughtException)\n\n  // Handle warnings\n  process.on('warning', handleWarning)\n\n  // Handle graceful shutdown signals\n  process.on('SIGTERM', () => {\n    console.error('\\nReceived SIGTERM signal.')\n    gracefulShutdown(0)\n  })\n\n  process.on('SIGINT', () => {\n    // Let the application handle SIGINT (Ctrl-C) normally\n    // Only intervene if pressed multiple times\n  })\n\n  // Handle beforeExit for cleanup\n  process.on('beforeExit', code => {\n    if (!isShuttingDown && cleanupHandlers.length > 0) {\n      gracefulShutdown(code)\n    }\n  })\n}\n\n/**\n * Check if global error handlers are initialized\n */\nexport function isGlobalErrorHandlersInitialized(): boolean {\n  return isInitialized\n}\n\n/**\n * Reset global error handlers (for testing)\n */\nexport function resetGlobalErrorHandlers(): void {\n  if (process.env.NODE_ENV !== 'test') {\n    throw new Error('resetGlobalErrorHandlers can only be called in tests')\n  }\n\n  process.removeAllListeners('unhandledRejection')\n  process.removeAllListeners('uncaughtException')\n  process.removeAllListeners('warning')\n  process.removeAllListeners('SIGTERM')\n  process.removeAllListeners('beforeExit')\n\n  isInitialized = false\n  isShuttingDown = false\n  cleanupHandlers.length = 0\n}\n"],
+  "mappings": "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",
+  "names": ["ErrorSeverity"]
+}

package/dist/utils/groupHandlers/index.js

@@ -0,0 +1,8 @@
+export * from "./types.js";
+import { TaskGroupHandler } from "./taskHandler.js";
+import { ParallelTasksHandler } from "./parallelTasksHandler.js";
+export {
+  ParallelTasksHandler,
+  TaskGroupHandler
+};
+//# sourceMappingURL=index.js.map

package/dist/utils/groupHandlers/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/groupHandlers/index.ts"],
+  "sourcesContent": ["/**\n * Group Handlers Module\n *\n * Exports all group type handlers for the V1+ framework.\n */\n\nexport * from './types'\nexport { TaskGroupHandler } from './taskHandler'\nexport { ParallelTasksHandler } from './parallelTasksHandler'\n"],
+  "mappings": "AAMA,cAAc;AACd,SAAS,wBAAwB;AACjC,SAAS,4BAA4B;",
+  "names": []
+}

package/dist/utils/groupHandlers/parallelTasksHandler.js

@@ -0,0 +1,140 @@
+import { getAgentIdByToolUseId } from "../agentTranscripts.js";
+class ParallelTasksHandler {
+  type = "parallel-tasks";
+  identify(messages) {
+    const groups = [];
+    const processedOriginalUuids = /* @__PURE__ */ new Set();
+    const tasksByOriginalUuid = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.type !== "assistant") continue;
+      if (!Array.isArray(msg.message.content)) continue;
+      const originalUuid = msg.originalUuid || msg.uuid;
+      const toolUse = msg.message.content.find(
+        (block) => block.type === "tool_use" && block.name === "Task"
+      );
+      if (toolUse) {
+        if (!tasksByOriginalUuid.has(originalUuid)) {
+          tasksByOriginalUuid.set(originalUuid, []);
+        }
+        tasksByOriginalUuid.get(originalUuid).push({
+          uuid: msg.uuid,
+          toolUseId: toolUse.id
+        });
+      }
+    }
+    for (const [originalUuid, tasks] of tasksByOriginalUuid) {
+      if (tasks.length > 1 && !processedOriginalUuids.has(originalUuid)) {
+        groups.push({
+          type: "parallel-tasks",
+          messageUuids: tasks.map((t) => t.uuid),
+          childIds: [],
+          metadata: {
+            siblingToolUseIds: tasks.map((t) => t.toolUseId)
+          }
+        });
+        processedOriginalUuids.add(originalUuid);
+      }
+    }
+    const processedSiblingKeys = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.type !== "progress") continue;
+      const siblingIds = msg.siblingToolUseIDs;
+      if (!siblingIds || siblingIds.size <= 1) continue;
+      const siblingKey = Array.from(siblingIds).sort().join(",");
+      if (processedSiblingKeys.has(siblingKey)) continue;
+      const alreadyGrouped = Array.from(siblingIds).every(
+        (id) => groups.some(
+          (g) => g.metadata.siblingToolUseIds?.includes(id)
+        )
+      );
+      if (alreadyGrouped) {
+        processedSiblingKeys.add(siblingKey);
+        continue;
+      }
+      const taskToolUseIds = [];
+      const messageUuids = /* @__PURE__ */ new Set();
+      for (const toolUseId of siblingIds) {
+        const assistantMsg = messages.find(
+          (m) => m.type === "assistant" && Array.isArray(m.message.content) && m.message.content.some(
+            (block) => block.type === "tool_use" && block.id === toolUseId
+          )
+        );
+        if (assistantMsg && assistantMsg.type === "assistant") {
+          const content = assistantMsg.message.content;
+          const toolUse = content.find(
+            (block) => block.type === "tool_use" && block.id === toolUseId
+          );
+          if (toolUse && toolUse.name === "Task") {
+            taskToolUseIds.push(toolUseId);
+            messageUuids.add(assistantMsg.uuid);
+          }
+        }
+      }
+      if (taskToolUseIds.length > 1) {
+        groups.push({
+          type: "parallel-tasks",
+          messageUuids: Array.from(messageUuids),
+          childIds: [],
+          metadata: {
+            siblingToolUseIds: taskToolUseIds
+          }
+        });
+        processedSiblingKeys.add(siblingKey);
+      }
+    }
+    return groups;
+  }
+  computeResolution(group, unresolvedToolUseIDs) {
+    const memberIds = group.metadata.siblingToolUseIds || [];
+    const unresolvedMembers = memberIds.filter(
+      (id) => unresolvedToolUseIDs.has(id)
+    );
+    const isSelfResolved = unresolvedMembers.length === 0;
+    return {
+      isSelfResolved,
+      isNestedResolved: true,
+      // Updated by parent computation
+      isFullyResolved: isSelfResolved,
+      unresolvedToolUseIds: unresolvedMembers
+    };
+  }
+  computeAnchor(group, _messages) {
+    return {
+      anchorMessageUuid: group.messageUuids[0],
+      anchorStrategy: "first"
+    };
+  }
+  /**
+   * Get task info for each member of the parallel group
+   */
+  static getMemberTaskInfo(group, messages) {
+    const memberIds = group.metadata.siblingToolUseIds || [];
+    const result = [];
+    for (const toolUseId of memberIds) {
+      const msg = messages.find(
+        (m) => m.type === "assistant" && Array.isArray(m.message.content) && m.message.content.some(
+          (block) => block.type === "tool_use" && block.id === toolUseId
+        )
+      );
+      if (!msg || msg.type !== "assistant") continue;
+      const content = msg.message.content;
+      const toolUse = content.find(
+        (block) => block.type === "tool_use" && block.id === toolUseId
+      );
+      if (toolUse) {
+        const input = toolUse.input;
+        result.push({
+          toolUseId,
+          agentId: getAgentIdByToolUseId(toolUseId),
+          description: input.description || "Task",
+          agentType: input.subagent_type || "general-purpose"
+        });
+      }
+    }
+    return result;
+  }
+}
+export {
+  ParallelTasksHandler
+};
+//# sourceMappingURL=parallelTasksHandler.js.map

package/dist/utils/groupHandlers/parallelTasksHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/groupHandlers/parallelTasksHandler.ts"],
+  "sourcesContent": ["/**\n * Parallel Tasks Group Handler\n *\n * Handles concurrent Task tool calls (multiple Tasks in same AssistantMessage).\n * Creates a group that contains multiple task groups as children.\n */\n\nimport type { ToolUseBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport type { NormalizedMessage } from '@utils/messages'\nimport type {\n  MessageGroup,\n  IdentifiedGroup,\n  ResolutionState,\n  PositionAnchor,\n} from '@minto-types/messageGroup'\nimport type { GroupTypeHandler } from './types'\nimport { getAgentIdByToolUseId } from '@utils/agentTranscripts'\n\nexport class ParallelTasksHandler implements GroupTypeHandler {\n  type = 'parallel-tasks' as const\n\n  identify(messages: NormalizedMessage[]): IdentifiedGroup[] {\n    const groups: IdentifiedGroup[] = []\n    const processedOriginalUuids = new Set<string>() // Track processed original message UUIDs\n\n    // Strategy 1 (Primary): Use originalUuid to identify parallel Task groups\n    // Normalized messages from the same original assistant message share the same originalUuid\n    // This is more reliable than depending on progress messages\n    const tasksByOriginalUuid = new Map<\n      string,\n      Array<{ uuid: string; toolUseId: string }>\n    >()\n\n    for (const msg of messages) {\n      if (msg.type !== 'assistant') continue\n      if (!Array.isArray(msg.message.content)) continue\n\n      // Get the originalUuid (falls back to uuid for non-split messages)\n      const originalUuid = msg.originalUuid || msg.uuid\n\n      const toolUse = msg.message.content.find(\n        (block): block is ToolUseBlockParam =>\n          block.type === 'tool_use' && block.name === 'Task',\n      )\n\n      if (toolUse) {\n        if (!tasksByOriginalUuid.has(originalUuid)) {\n          tasksByOriginalUuid.set(originalUuid, [])\n        }\n        tasksByOriginalUuid.get(originalUuid)!.push({\n          uuid: msg.uuid,\n          toolUseId: toolUse.id,\n        })\n      }\n    }\n\n    // Create groups for original messages that have multiple Task tool uses\n    for (const [originalUuid, tasks] of tasksByOriginalUuid) {\n      if (tasks.length > 1 && !processedOriginalUuids.has(originalUuid)) {\n        groups.push({\n          type: 'parallel-tasks',\n          messageUuids: tasks.map(t => t.uuid),\n          childIds: [],\n          metadata: {\n            siblingToolUseIds: tasks.map(t => t.toolUseId),\n          },\n        })\n        processedOriginalUuids.add(originalUuid)\n      }\n    }\n\n    // Strategy 2 (Fallback): Use progress messages for backward compatibility\n    // This handles cases where originalUuid might not be set (e.g., historical messages)\n    const processedSiblingKeys = new Set<string>()\n\n    for (const msg of messages) {\n      if (msg.type !== 'progress') continue\n\n      const siblingIds = msg.siblingToolUseIDs\n      if (!siblingIds || siblingIds.size <= 1) continue\n\n      // Create a stable key for this sibling set\n      const siblingKey = Array.from(siblingIds).sort().join(',')\n      if (processedSiblingKeys.has(siblingKey)) continue\n\n      // Check if this sibling set was already handled by Strategy 1\n      const alreadyGrouped = Array.from(siblingIds).every(id =>\n        groups.some(g =>\n          (g.metadata.siblingToolUseIds as string[])?.includes(id),\n        ),\n      )\n      if (alreadyGrouped) {\n        processedSiblingKeys.add(siblingKey)\n        continue\n      }\n\n      // Check if all siblings are Task tool uses\n      const taskToolUseIds: string[] = []\n      const messageUuids = new Set<string>()\n\n      for (const toolUseId of siblingIds) {\n        const assistantMsg = messages.find(\n          m =>\n            m.type === 'assistant' &&\n            Array.isArray(m.message.content) &&\n            m.message.content.some(\n              (block): block is ToolUseBlockParam =>\n                block.type === 'tool_use' && block.id === toolUseId,\n            ),\n        )\n\n        if (assistantMsg && assistantMsg.type === 'assistant') {\n          const content = assistantMsg.message.content\n          const toolUse = content.find(\n            (block): block is ToolUseBlockParam =>\n              block.type === 'tool_use' && block.id === toolUseId,\n          )\n\n          if (toolUse && toolUse.name === 'Task') {\n            taskToolUseIds.push(toolUseId)\n            messageUuids.add(assistantMsg.uuid)\n          }\n        }\n      }\n\n      // Only create parallel group if there are multiple Tasks\n      if (taskToolUseIds.length > 1) {\n        groups.push({\n          type: 'parallel-tasks',\n          messageUuids: Array.from(messageUuids),\n          childIds: [],\n          metadata: {\n            siblingToolUseIds: taskToolUseIds,\n          },\n        })\n        processedSiblingKeys.add(siblingKey)\n      }\n    }\n\n    return groups\n  }\n\n  computeResolution(\n    group: MessageGroup,\n    unresolvedToolUseIDs: Set<string>,\n  ): ResolutionState {\n    const memberIds = (group.metadata.siblingToolUseIds as string[]) || []\n\n    // All members need to be resolved\n    const unresolvedMembers = memberIds.filter(id =>\n      unresolvedToolUseIDs.has(id),\n    )\n    const isSelfResolved = unresolvedMembers.length === 0\n\n    // Note: isNestedResolved is computed by parent manager\n    // after all child groups have been processed\n    return {\n      isSelfResolved,\n      isNestedResolved: true, // Updated by parent computation\n      isFullyResolved: isSelfResolved,\n      unresolvedToolUseIds: unresolvedMembers,\n    }\n  }\n\n  computeAnchor(\n    group: MessageGroup,\n    _messages: NormalizedMessage[],\n  ): PositionAnchor {\n    // Parallel module's position = first member's position\n    return {\n      anchorMessageUuid: group.messageUuids[0],\n      anchorStrategy: 'first',\n    }\n  }\n\n  /**\n   * Get task info for each member of the parallel group\n   */\n  static getMemberTaskInfo(\n    group: MessageGroup,\n    messages: NormalizedMessage[],\n  ): Array<{\n    toolUseId: string\n    agentId: string | null\n    description: string\n    agentType: string\n  }> {\n    const memberIds = (group.metadata.siblingToolUseIds as string[]) || []\n    const result: Array<{\n      toolUseId: string\n      agentId: string | null\n      description: string\n      agentType: string\n    }> = []\n\n    // Since normalized messages split each content block into separate messages,\n    // we need to find the message for each toolUseId individually\n    for (const toolUseId of memberIds) {\n      // Find the assistant message containing this specific tool use\n      const msg = messages.find(\n        m =>\n          m.type === 'assistant' &&\n          Array.isArray(m.message.content) &&\n          m.message.content.some(\n            (block): block is ToolUseBlockParam =>\n              block.type === 'tool_use' && block.id === toolUseId,\n          ),\n      )\n\n      if (!msg || msg.type !== 'assistant') continue\n\n      const content = msg.message.content\n      const toolUse = content.find(\n        (block): block is ToolUseBlockParam =>\n          block.type === 'tool_use' && block.id === toolUseId,\n      )\n\n      if (toolUse) {\n        const input = toolUse.input as {\n          description?: string\n          subagent_type?: string\n        }\n\n        result.push({\n          toolUseId,\n          agentId: getAgentIdByToolUseId(toolUseId),\n          description: input.description || 'Task',\n          agentType: input.subagent_type || 'general-purpose',\n        })\n      }\n    }\n\n    return result\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/utils/groupHandlers/taskHandler.js

@@ -0,0 +1,104 @@
+import {
+  getAgentIdByToolUseId,
+  getAgentTranscript
+} from "../agentTranscripts.js";
+class TaskGroupHandler {
+  type = "task";
+  identify(messages) {
+    const groups = [];
+    const processedUuids = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.type !== "assistant") continue;
+      if (processedUuids.has(msg.uuid)) continue;
+      const content = msg.message.content;
+      if (!content || content.length === 0) continue;
+      const taskToolUses = content.filter(
+        (block) => block.type === "tool_use" && block.name === "Task"
+      );
+      if (taskToolUses.length !== 1) continue;
+      const taskToolUse = taskToolUses[0];
+      const input = taskToolUse.input;
+      const agentId = getAgentIdByToolUseId(taskToolUse.id);
+      groups.push({
+        type: "task",
+        messageUuids: [msg.uuid],
+        metadata: {
+          toolUseId: taskToolUse.id,
+          agentId: agentId || void 0,
+          description: input.description,
+          agentType: input.subagent_type
+        }
+      });
+      processedUuids.add(msg.uuid);
+    }
+    return groups;
+  }
+  computeResolution(group, unresolvedToolUseIDs) {
+    const toolUseId = group.metadata.toolUseId;
+    const agentId = group.metadata.agentId;
+    const isSelfResolved = !unresolvedToolUseIDs.has(toolUseId);
+    let isNestedResolved = true;
+    const unresolvedNested = [];
+    if (agentId) {
+      const nestedCheck = this.checkUnresolvedNestedTasks(
+        agentId,
+        unresolvedToolUseIDs
+      );
+      if (nestedCheck.hasUnresolved) {
+        isNestedResolved = false;
+        unresolvedNested.push(...nestedCheck.unresolvedIds);
+      }
+    }
+    return {
+      isSelfResolved,
+      isNestedResolved,
+      isFullyResolved: isSelfResolved && isNestedResolved,
+      unresolvedToolUseIds: isSelfResolved ? unresolvedNested : [toolUseId, ...unresolvedNested]
+    };
+  }
+  computeAnchor(group, _messages) {
+    return {
+      anchorMessageUuid: group.messageUuids[0],
+      anchorStrategy: "first"
+    };
+  }
+  /**
+   * Recursively check for unresolved nested tasks (from V3)
+   */
+  checkUnresolvedNestedTasks(agentId, unresolvedToolUseIDs) {
+    const transcript = getAgentTranscript(agentId);
+    if (!transcript) {
+      return { hasUnresolved: false, unresolvedIds: [] };
+    }
+    const unresolvedIds = [];
+    for (const message of transcript.messages) {
+      if (message.type === "assistant") {
+        const content = message.message.content;
+        if (!content || !Array.isArray(content)) continue;
+        for (const block of content) {
+          if (block.type === "tool_use" && block.name === "Task") {
+            if (unresolvedToolUseIDs.has(block.id)) {
+              unresolvedIds.push(block.id);
+            }
+            const nestedAgentId = getAgentIdByToolUseId(block.id);
+            if (nestedAgentId) {
+              const nested = this.checkUnresolvedNestedTasks(
+                nestedAgentId,
+                unresolvedToolUseIDs
+              );
+              unresolvedIds.push(...nested.unresolvedIds);
+            }
+          }
+        }
+      }
+    }
+    return {
+      hasUnresolved: unresolvedIds.length > 0,
+      unresolvedIds
+    };
+  }
+}
+export {
+  TaskGroupHandler
+};
+//# sourceMappingURL=taskHandler.js.map

package/dist/utils/groupHandlers/taskHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/groupHandlers/taskHandler.ts"],
+  "sourcesContent": ["/**\n * Task Group Handler\n *\n * Handles single Task tool calls (not part of concurrent groups).\n * Includes recursive nested task checking from V3.\n */\n\nimport type { ToolUseBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport type { NormalizedMessage } from '@utils/messages'\nimport type {\n  MessageGroup,\n  IdentifiedGroup,\n  ResolutionState,\n  PositionAnchor,\n} from '@minto-types/messageGroup'\nimport type { GroupTypeHandler, NestedTaskCheckResult } from './types'\nimport {\n  getAgentIdByToolUseId,\n  getAgentTranscript,\n} from '@utils/agentTranscripts'\n\nexport class TaskGroupHandler implements GroupTypeHandler {\n  type = 'task' as const\n\n  identify(messages: NormalizedMessage[]): IdentifiedGroup[] {\n    const groups: IdentifiedGroup[] = []\n    const processedUuids = new Set<string>()\n\n    for (const msg of messages) {\n      if (msg.type !== 'assistant') continue\n      if (processedUuids.has(msg.uuid)) continue\n\n      const content = msg.message.content\n      if (!content || content.length === 0) continue\n\n      // Find all Task tool uses in this message\n      const taskToolUses = content.filter(\n        (block): block is ToolUseBlockParam =>\n          block.type === 'tool_use' && block.name === 'Task',\n      )\n\n      // Skip if multiple Tasks (will be handled by parallel-tasks handler)\n      if (taskToolUses.length !== 1) continue\n\n      const taskToolUse = taskToolUses[0]\n      const input = taskToolUse.input as {\n        description?: string\n        subagent_type?: string\n      }\n      const agentId = getAgentIdByToolUseId(taskToolUse.id)\n\n      groups.push({\n        type: 'task',\n        messageUuids: [msg.uuid],\n        metadata: {\n          toolUseId: taskToolUse.id,\n          agentId: agentId || undefined,\n          description: input.description,\n          agentType: input.subagent_type,\n        },\n      })\n\n      processedUuids.add(msg.uuid)\n    }\n\n    return groups\n  }\n\n  computeResolution(\n    group: MessageGroup,\n    unresolvedToolUseIDs: Set<string>,\n  ): ResolutionState {\n    const toolUseId = group.metadata.toolUseId as string\n    const agentId = group.metadata.agentId as string | undefined\n\n    const isSelfResolved = !unresolvedToolUseIDs.has(toolUseId)\n\n    // V3's nested checking logic\n    let isNestedResolved = true\n    const unresolvedNested: string[] = []\n\n    if (agentId) {\n      const nestedCheck = this.checkUnresolvedNestedTasks(\n        agentId,\n        unresolvedToolUseIDs,\n      )\n      if (nestedCheck.hasUnresolved) {\n        isNestedResolved = false\n        unresolvedNested.push(...nestedCheck.unresolvedIds)\n      }\n    }\n\n    return {\n      isSelfResolved,\n      isNestedResolved,\n      isFullyResolved: isSelfResolved && isNestedResolved,\n      unresolvedToolUseIds: isSelfResolved\n        ? unresolvedNested\n        : [toolUseId, ...unresolvedNested],\n    }\n  }\n\n  computeAnchor(\n    group: MessageGroup,\n    _messages: NormalizedMessage[],\n  ): PositionAnchor {\n    return {\n      anchorMessageUuid: group.messageUuids[0],\n      anchorStrategy: 'first',\n    }\n  }\n\n  /**\n   * Recursively check for unresolved nested tasks (from V3)\n   */\n  private checkUnresolvedNestedTasks(\n    agentId: string,\n    unresolvedToolUseIDs: Set<string>,\n  ): NestedTaskCheckResult {\n    const transcript = getAgentTranscript(agentId)\n    if (!transcript) {\n      return { hasUnresolved: false, unresolvedIds: [] }\n    }\n\n    const unresolvedIds: string[] = []\n\n    for (const message of transcript.messages) {\n      if (message.type === 'assistant') {\n        const content = message.message.content\n        if (!content || !Array.isArray(content)) continue\n\n        for (const block of content) {\n          if (block.type === 'tool_use' && block.name === 'Task') {\n            // Check if this nested Task itself is complete\n            if (unresolvedToolUseIDs.has(block.id)) {\n              unresolvedIds.push(block.id)\n            }\n\n            // Recursively check nested agent\n            const nestedAgentId = getAgentIdByToolUseId(block.id)\n            if (nestedAgentId) {\n              const nested = this.checkUnresolvedNestedTasks(\n                nestedAgentId,\n                unresolvedToolUseIDs,\n              )\n              unresolvedIds.push(...nested.unresolvedIds)\n            }\n          }\n        }\n      }\n    }\n\n    return {\n      hasUnresolved: unresolvedIds.length > 0,\n      unresolvedIds,\n    }\n  }\n}\n"],
+  "mappings": "AAgBA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEA,MAAM,iBAA6C;AAAA,EACxD,OAAO;AAAA,EAEP,SAAS,UAAkD;AACzD,UAAM,SAA4B,CAAC;AACnC,UAAM,iBAAiB,oBAAI,IAAY;AAEvC,eAAW,OAAO,UAAU;AAC1B,UAAI,IAAI,SAAS,YAAa;AAC9B,UAAI,eAAe,IAAI,IAAI,IAAI,EAAG;AAElC,YAAM,UAAU,IAAI,QAAQ;AAC5B,UAAI,CAAC,WAAW,QAAQ,WAAW,EAAG;AAGtC,YAAM,eAAe,QAAQ;AAAA,QAC3B,CAAC,UACC,MAAM,SAAS,cAAc,MAAM,SAAS;AAAA,MAChD;AAGA,UAAI,aAAa,WAAW,EAAG;AAE/B,YAAM,cAAc,aAAa,CAAC;AAClC,YAAM,QAAQ,YAAY;AAI1B,YAAM,UAAU,sBAAsB,YAAY,EAAE;AAEpD,aAAO,KAAK;AAAA,QACV,MAAM;AAAA,QACN,cAAc,CAAC,IAAI,IAAI;AAAA,QACvB,UAAU;AAAA,UACR,WAAW,YAAY;AAAA,UACvB,SAAS,WAAW;AAAA,UACpB,aAAa,MAAM;AAAA,UACnB,WAAW,MAAM;AAAA,QACnB;AAAA,MACF,CAAC;AAED,qBAAe,IAAI,IAAI,IAAI;AAAA,IAC7B;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,kBACE,OACA,sBACiB;AACjB,UAAM,YAAY,MAAM,SAAS;AACjC,UAAM,UAAU,MAAM,SAAS;AAE/B,UAAM,iBAAiB,CAAC,qBAAqB,IAAI,SAAS;AAG1D,QAAI,mBAAmB;AACvB,UAAM,mBAA6B,CAAC;AAEpC,QAAI,SAAS;AACX,YAAM,cAAc,KAAK;AAAA,QACvB;AAAA,QACA;AAAA,MACF;AACA,UAAI,YAAY,eAAe;AAC7B,2BAAmB;AACnB,yBAAiB,KAAK,GAAG,YAAY,aAAa;AAAA,MACpD;AAAA,IACF;AAEA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,iBAAiB,kBAAkB;AAAA,MACnC,sBAAsB,iBAClB,mBACA,CAAC,WAAW,GAAG,gBAAgB;AAAA,IACrC;AAAA,EACF;AAAA,EAEA,cACE,OACA,WACgB;AAChB,WAAO;AAAA,MACL,mBAAmB,MAAM,aAAa,CAAC;AAAA,MACvC,gBAAgB;AAAA,IAClB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,2BACN,SACA,sBACuB;AACvB,UAAM,aAAa,mBAAmB,OAAO;AAC7C,QAAI,CAAC,YAAY;AACf,aAAO,EAAE,eAAe,OAAO,eAAe,CAAC,EAAE;AAAA,IACnD;AAEA,UAAM,gBAA0B,CAAC;AAEjC,eAAW,WAAW,WAAW,UAAU;AACzC,UAAI,QAAQ,SAAS,aAAa;AAChC,cAAM,UAAU,QAAQ,QAAQ;AAChC,YAAI,CAAC,WAAW,CAAC,MAAM,QAAQ,OAAO,EAAG;AAEzC,mBAAW,SAAS,SAAS;AAC3B,cAAI,MAAM,SAAS,cAAc,MAAM,SAAS,QAAQ;AAEtD,gBAAI,qBAAqB,IAAI,MAAM,EAAE,GAAG;AACtC,4BAAc,KAAK,MAAM,EAAE;AAAA,YAC7B;AAGA,kBAAM,gBAAgB,sBAAsB,MAAM,EAAE;AACpD,gBAAI,eAAe;AACjB,oBAAM,SAAS,KAAK;AAAA,gBAClB;AAAA,gBACA;AAAA,cACF;AACA,4BAAc,KAAK,GAAG,OAAO,aAAa;AAAA,YAC5C;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,MACL,eAAe,cAAc,SAAS;AAAA,MACtC;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/utils/groupHandlers/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/utils/groupHandlers/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}