@within-7/minto 0.1.7 → 0.3.0

package/dist/utils/memSafety.js

@@ -0,0 +1,264 @@
+class TokenCounter {
+  inputTokens = 0;
+  outputTokens = 0;
+  cacheReadTokens = 0;
+  cacheCreationTokens = 0;
+  reasoningTokens = 0;
+  /**
+   * Add token usage from a streaming chunk or response.
+   * Thread-safe accumulation.
+   */
+  add(usage) {
+    if (usage.input_tokens !== void 0) {
+      this.inputTokens += usage.input_tokens;
+    }
+    if (usage.output_tokens !== void 0) {
+      this.outputTokens += usage.output_tokens;
+    }
+    if (usage.cache_read_input_tokens !== void 0) {
+      this.cacheReadTokens += usage.cache_read_input_tokens;
+    }
+    if (usage.cache_creation_input_tokens !== void 0) {
+      this.cacheCreationTokens += usage.cache_creation_input_tokens;
+    }
+    if (usage.reasoning_tokens !== void 0) {
+      this.reasoningTokens += usage.reasoning_tokens;
+    }
+    if (usage.prompt_tokens !== void 0 && usage.input_tokens === void 0) {
+      this.inputTokens += usage.prompt_tokens;
+    }
+    if (usage.completion_tokens !== void 0 && usage.output_tokens === void 0) {
+      this.outputTokens += usage.completion_tokens;
+    }
+  }
+  /**
+   * Get accumulated totals.
+   */
+  getTotal() {
+    return {
+      input_tokens: this.inputTokens,
+      output_tokens: this.outputTokens,
+      cache_read_input_tokens: this.cacheReadTokens,
+      cache_creation_input_tokens: this.cacheCreationTokens,
+      reasoning_tokens: this.reasoningTokens
+    };
+  }
+  /**
+   * Reset counters (useful for reusing counter instances).
+   */
+  reset() {
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.cacheReadTokens = 0;
+    this.cacheCreationTokens = 0;
+    this.reasoningTokens = 0;
+  }
+}
+function safeParseResponse(response) {
+  if (response === null || response === void 0) {
+    return {
+      success: false,
+      data: null,
+      error: "Response is null or undefined"
+    };
+  }
+  if (typeof response !== "object") {
+    return {
+      success: false,
+      data: null,
+      error: `Invalid response type: ${typeof response}`
+    };
+  }
+  const res = response;
+  let content = [];
+  if (res.content !== void 0) {
+    if (!Array.isArray(res.content)) {
+      if (typeof res.content === "string") {
+        content = [{ type: "text", text: res.content }];
+      } else {
+        return {
+          success: false,
+          data: null,
+          error: "Content is not an array or string"
+        };
+      }
+    } else {
+      content = res.content.map((block) => {
+        if (block === null || block === void 0) {
+          return { type: "text", text: "" };
+        }
+        if (typeof block !== "object") {
+          return { type: "text", text: String(block) };
+        }
+        return block;
+      });
+    }
+  }
+  const rawUsage = res.usage || {};
+  const usage = {
+    input_tokens: safeNumber(rawUsage.input_tokens, 0),
+    output_tokens: safeNumber(rawUsage.output_tokens, 0),
+    cache_read_input_tokens: safeNumber(rawUsage.cache_read_input_tokens),
+    cache_creation_input_tokens: safeNumber(
+      rawUsage.cache_creation_input_tokens
+    )
+  };
+  return {
+    success: true,
+    data: {
+      content,
+      usage,
+      stop_reason: safeString(res.stop_reason),
+      id: safeString(res.id),
+      model: safeString(res.model)
+    },
+    error: null
+  };
+}
+function safeParseOpenAIResponse(response) {
+  if (response === null || response === void 0) {
+    return {
+      success: false,
+      data: null,
+      error: "Response is null or undefined"
+    };
+  }
+  if (typeof response !== "object") {
+    return {
+      success: false,
+      data: null,
+      error: `Invalid response type: ${typeof response}`
+    };
+  }
+  const res = response;
+  const choices = res.choices;
+  const firstChoice = choices?.[0];
+  const message = firstChoice?.message || {};
+  const rawToolCalls = message.tool_calls;
+  const tool_calls = (rawToolCalls || []).map((tc) => {
+    if (!tc || typeof tc !== "object") return null;
+    const func = tc.function;
+    return {
+      id: safeString(tc.id) || "",
+      type: safeString(tc.type) || "function",
+      function: {
+        name: safeString(func?.name) || "",
+        arguments: safeString(func?.arguments) || "{}"
+      }
+    };
+  }).filter((tc) => tc !== null);
+  const rawUsage = res.usage || {};
+  const usage = {
+    prompt_tokens: safeNumber(rawUsage.prompt_tokens, 0),
+    completion_tokens: safeNumber(rawUsage.completion_tokens, 0),
+    total_tokens: safeNumber(rawUsage.total_tokens, 0)
+  };
+  return {
+    success: true,
+    data: {
+      content: safeString(message.content) || "",
+      tool_calls,
+      usage,
+      finish_reason: safeString(firstChoice?.finish_reason),
+      id: safeString(res.id),
+      model: safeString(res.model)
+    },
+    error: null
+  };
+}
+function safeNumber(value, defaultValue) {
+  if (typeof value === "number" && !isNaN(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (!isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return defaultValue ?? 0;
+}
+function safeString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value !== null && value !== void 0) {
+    return String(value);
+  }
+  return void 0;
+}
+function linkAbortSignal(externalSignal, controller) {
+  if (!externalSignal) {
+    return () => {
+    };
+  }
+  const onAbort = () => {
+    controller.abort();
+  };
+  externalSignal.addEventListener("abort", onAbort);
+  return () => {
+    externalSignal.removeEventListener("abort", onAbort);
+  };
+}
+function createLinkedAbortController(externalSignal) {
+  const controller = new AbortController();
+  if (externalSignal?.aborted) {
+    controller.abort();
+    return { controller, cleanup: () => {
+    } };
+  }
+  const cleanup = linkAbortSignal(externalSignal, controller);
+  return { controller, cleanup };
+}
+async function* safeStreamIterate(stream, signal) {
+  if (signal?.aborted) {
+    return;
+  }
+  const iterator = stream[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        break;
+      }
+      const result = await iterator.next();
+      if (result.done) {
+        break;
+      }
+      if (signal?.aborted) {
+        break;
+      }
+      yield result.value;
+    }
+  } finally {
+    if (iterator.return) {
+      await iterator.return();
+    }
+  }
+}
+function extractTextContent(content) {
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+}
+function extractToolUses(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter((block) => block?.type === "tool_use").map((block) => ({
+    id: block.id || "",
+    name: block.name || "",
+    input: block.input || {}
+  }));
+}
+export {
+  TokenCounter,
+  createLinkedAbortController,
+  extractTextContent,
+  extractToolUses,
+  linkAbortSignal,
+  safeParseOpenAIResponse,
+  safeParseResponse,
+  safeStreamIterate
+};
+//# sourceMappingURL=memSafety.js.map

package/dist/utils/memSafety.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/memSafety.ts"],
+  "sourcesContent": ["/**\n * Memory Safety Utilities for Minto\n *\n * Provides thread-safe token counting, response parsing with null guards,\n * and stream abort signal handling to prevent race conditions and memory leaks.\n *\n * Part of Phase 1.2: Memory Safety Fixes\n */\n\n/**\n * Thread-safe token counter for accumulating usage across streaming chunks.\n * Prevents race conditions when multiple chunks arrive concurrently.\n */\nexport class TokenCounter {\n  private inputTokens = 0\n  private outputTokens = 0\n  private cacheReadTokens = 0\n  private cacheCreationTokens = 0\n  private reasoningTokens = 0\n\n  /**\n   * Add token usage from a streaming chunk or response.\n   * Thread-safe accumulation.\n   */\n  add(usage: {\n    input_tokens?: number\n    output_tokens?: number\n    cache_read_input_tokens?: number\n    cache_creation_input_tokens?: number\n    reasoning_tokens?: number\n    // OpenAI format\n    prompt_tokens?: number\n    completion_tokens?: number\n  }): void {\n    // Anthropic format\n    if (usage.input_tokens !== undefined) {\n      this.inputTokens += usage.input_tokens\n    }\n    if (usage.output_tokens !== undefined) {\n      this.outputTokens += usage.output_tokens\n    }\n    if (usage.cache_read_input_tokens !== undefined) {\n      this.cacheReadTokens += usage.cache_read_input_tokens\n    }\n    if (usage.cache_creation_input_tokens !== undefined) {\n      this.cacheCreationTokens += usage.cache_creation_input_tokens\n    }\n    if (usage.reasoning_tokens !== undefined) {\n      this.reasoningTokens += usage.reasoning_tokens\n    }\n\n    // OpenAI format (fallback)\n    if (usage.prompt_tokens !== undefined && usage.input_tokens === undefined) {\n      this.inputTokens += usage.prompt_tokens\n    }\n    if (\n      usage.completion_tokens !== undefined &&\n      usage.output_tokens === undefined\n    ) {\n      this.outputTokens += usage.completion_tokens\n    }\n  }\n\n  /**\n   * Get accumulated totals.\n   */\n  getTotal(): {\n    input_tokens: number\n    output_tokens: number\n    cache_read_input_tokens: number\n    cache_creation_input_tokens: number\n    reasoning_tokens: number\n  } {\n    return {\n      input_tokens: this.inputTokens,\n      output_tokens: this.outputTokens,\n      cache_read_input_tokens: this.cacheReadTokens,\n      cache_creation_input_tokens: this.cacheCreationTokens,\n      reasoning_tokens: this.reasoningTokens,\n    }\n  }\n\n  /**\n   * Reset counters (useful for reusing counter instances).\n   */\n  reset(): void {\n    this.inputTokens = 0\n    this.outputTokens = 0\n    this.cacheReadTokens = 0\n    this.cacheCreationTokens = 0\n    this.reasoningTokens = 0\n  }\n}\n\n/**\n * Result type for safe response parsing.\n */\nexport interface ParsedResponse<T = unknown> {\n  success: boolean\n  data: T | null\n  error: string | null\n}\n\n/**\n * Safe content block type.\n */\nexport interface ContentBlock {\n  type: string\n  text?: string\n  id?: string\n  name?: string\n  input?: unknown\n  thinking?: string\n  signature?: string\n}\n\n/**\n * Safely parse an API response with comprehensive null checks.\n * Prevents crashes from malformed or empty responses.\n */\nexport function safeParseResponse(response: unknown): ParsedResponse<{\n  content: ContentBlock[]\n  usage: {\n    input_tokens: number\n    output_tokens: number\n    cache_read_input_tokens?: number\n    cache_creation_input_tokens?: number\n  }\n  stop_reason?: string\n  id?: string\n  model?: string\n}> {\n  // Null/undefined check\n  if (response === null || response === undefined) {\n    return {\n      success: false,\n      data: null,\n      error: 'Response is null or undefined',\n    }\n  }\n\n  // Type check\n  if (typeof response !== 'object') {\n    return {\n      success: false,\n      data: null,\n      error: `Invalid response type: ${typeof response}`,\n    }\n  }\n\n  const res = response as Record<string, unknown>\n\n  // Content array check\n  let content: ContentBlock[] = []\n  if (res.content !== undefined) {\n    if (!Array.isArray(res.content)) {\n      // Some APIs return content as string\n      if (typeof res.content === 'string') {\n        content = [{ type: 'text', text: res.content }]\n      } else {\n        return {\n          success: false,\n          data: null,\n          error: 'Content is not an array or string',\n        }\n      }\n    } else {\n      content = res.content.map((block: unknown) => {\n        if (block === null || block === undefined) {\n          return { type: 'text', text: '' }\n        }\n        if (typeof block !== 'object') {\n          return { type: 'text', text: String(block) }\n        }\n        return block as ContentBlock\n      })\n    }\n  }\n\n  // Usage parsing with defaults\n  const rawUsage = (res.usage as Record<string, unknown>) || {}\n  const usage = {\n    input_tokens: safeNumber(rawUsage.input_tokens, 0),\n    output_tokens: safeNumber(rawUsage.output_tokens, 0),\n    cache_read_input_tokens: safeNumber(rawUsage.cache_read_input_tokens),\n    cache_creation_input_tokens: safeNumber(\n      rawUsage.cache_creation_input_tokens,\n    ),\n  }\n\n  return {\n    success: true,\n    data: {\n      content,\n      usage,\n      stop_reason: safeString(res.stop_reason),\n      id: safeString(res.id),\n      model: safeString(res.model),\n    },\n    error: null,\n  }\n}\n\n/**\n * Safely parse OpenAI format response.\n */\nexport function safeParseOpenAIResponse(response: unknown): ParsedResponse<{\n  content: string\n  tool_calls: Array<{\n    id: string\n    type: string\n    function: { name: string; arguments: string }\n  }>\n  usage: {\n    prompt_tokens: number\n    completion_tokens: number\n    total_tokens: number\n  }\n  finish_reason?: string\n  id?: string\n  model?: string\n}> {\n  if (response === null || response === undefined) {\n    return {\n      success: false,\n      data: null,\n      error: 'Response is null or undefined',\n    }\n  }\n\n  if (typeof response !== 'object') {\n    return {\n      success: false,\n      data: null,\n      error: `Invalid response type: ${typeof response}`,\n    }\n  }\n\n  const res = response as Record<string, unknown>\n\n  // Get first choice\n  const choices = res.choices as Array<Record<string, unknown>> | undefined\n  const firstChoice = choices?.[0]\n  const message = (firstChoice?.message as Record<string, unknown>) || {}\n\n  // Parse tool calls\n  const rawToolCalls = message.tool_calls as\n    | Array<Record<string, unknown>>\n    | undefined\n  const tool_calls = (rawToolCalls || [])\n    .map(tc => {\n      if (!tc || typeof tc !== 'object') return null\n      const func = tc.function as Record<string, unknown> | undefined\n      return {\n        id: safeString(tc.id) || '',\n        type: safeString(tc.type) || 'function',\n        function: {\n          name: safeString(func?.name) || '',\n          arguments: safeString(func?.arguments) || '{}',\n        },\n      }\n    })\n    .filter((tc): tc is NonNullable<typeof tc> => tc !== null)\n\n  // Usage parsing\n  const rawUsage = (res.usage as Record<string, unknown>) || {}\n  const usage = {\n    prompt_tokens: safeNumber(rawUsage.prompt_tokens, 0),\n    completion_tokens: safeNumber(rawUsage.completion_tokens, 0),\n    total_tokens: safeNumber(rawUsage.total_tokens, 0),\n  }\n\n  return {\n    success: true,\n    data: {\n      content: safeString(message.content) || '',\n      tool_calls,\n      usage,\n      finish_reason: safeString(firstChoice?.finish_reason),\n      id: safeString(res.id),\n      model: safeString(res.model),\n    },\n    error: null,\n  }\n}\n\n/**\n * Safe number extraction with default value.\n */\nfunction safeNumber(value: unknown, defaultValue?: number): number {\n  if (typeof value === 'number' && !isNaN(value)) {\n    return value\n  }\n  if (typeof value === 'string') {\n    const parsed = parseFloat(value)\n    if (!isNaN(parsed)) {\n      return parsed\n    }\n  }\n  return defaultValue ?? 0\n}\n\n/**\n * Safe string extraction.\n */\nfunction safeString(value: unknown): string | undefined {\n  if (typeof value === 'string') {\n    return value\n  }\n  if (value !== null && value !== undefined) {\n    return String(value)\n  }\n  return undefined\n}\n\n/**\n * Link an external AbortSignal to an AbortController.\n * Ensures proper cleanup when the external signal is aborted.\n */\nexport function linkAbortSignal(\n  externalSignal: AbortSignal | undefined,\n  controller: AbortController,\n): () => void {\n  if (!externalSignal) {\n    return () => {}\n  }\n\n  const onAbort = () => {\n    controller.abort()\n  }\n\n  externalSignal.addEventListener('abort', onAbort)\n\n  // Return cleanup function\n  return () => {\n    externalSignal.removeEventListener('abort', onAbort)\n  }\n}\n\n/**\n * Create a linked abort controller that follows an external signal.\n */\nexport function createLinkedAbortController(externalSignal?: AbortSignal): {\n  controller: AbortController\n  cleanup: () => void\n} {\n  const controller = new AbortController()\n\n  // If already aborted, abort immediately\n  if (externalSignal?.aborted) {\n    controller.abort()\n    return { controller, cleanup: () => {} }\n  }\n\n  const cleanup = linkAbortSignal(externalSignal, controller)\n\n  return { controller, cleanup }\n}\n\n/**\n * Safe stream iteration with proper abort handling.\n * Ensures resources are cleaned up even if iteration is interrupted.\n */\nexport async function* safeStreamIterate<T>(\n  stream: AsyncIterable<T>,\n  signal?: AbortSignal,\n): AsyncGenerator<T, void, unknown> {\n  // Check if already aborted before starting\n  if (signal?.aborted) {\n    return\n  }\n\n  const iterator = stream[Symbol.asyncIterator]()\n\n  try {\n    while (true) {\n      // Check abort status before each iteration\n      if (signal?.aborted) {\n        break\n      }\n\n      const result = await iterator.next()\n\n      if (result.done) {\n        break\n      }\n\n      // Check abort status after receiving value\n      if (signal?.aborted) {\n        break\n      }\n\n      yield result.value\n    }\n  } finally {\n    // Ensure cleanup by calling return on iterator if it exists\n    if (iterator.return) {\n      await iterator.return()\n    }\n  }\n}\n\n/**\n * Safely extract text content from content blocks.\n */\nexport function extractTextContent(content: ContentBlock[]): string {\n  if (!Array.isArray(content)) {\n    return ''\n  }\n\n  return content\n    .filter(block => block?.type === 'text' && typeof block.text === 'string')\n    .map(block => block.text)\n    .join('\\n')\n}\n\n/**\n * Safely extract tool use blocks from content.\n */\nexport function extractToolUses(content: ContentBlock[]): Array<{\n  id: string\n  name: string\n  input: unknown\n}> {\n  if (!Array.isArray(content)) {\n    return []\n  }\n\n  return content\n    .filter(block => block?.type === 'tool_use')\n    .map(block => ({\n      id: block.id || '',\n      name: block.name || '',\n      input: block.input || {},\n    }))\n}\n"],
+  "mappings": "AAaO,MAAM,aAAa;AAAA,EAChB,cAAc;AAAA,EACd,eAAe;AAAA,EACf,kBAAkB;AAAA,EAClB,sBAAsB;AAAA,EACtB,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAM1B,IAAI,OASK;AAEP,QAAI,MAAM,iBAAiB,QAAW;AACpC,WAAK,eAAe,MAAM;AAAA,IAC5B;AACA,QAAI,MAAM,kBAAkB,QAAW;AACrC,WAAK,gBAAgB,MAAM;AAAA,IAC7B;AACA,QAAI,MAAM,4BAA4B,QAAW;AAC/C,WAAK,mBAAmB,MAAM;AAAA,IAChC;AACA,QAAI,MAAM,gCAAgC,QAAW;AACnD,WAAK,uBAAuB,MAAM;AAAA,IACpC;AACA,QAAI,MAAM,qBAAqB,QAAW;AACxC,WAAK,mBAAmB,MAAM;AAAA,IAChC;AAGA,QAAI,MAAM,kBAAkB,UAAa,MAAM,iBAAiB,QAAW;AACzE,WAAK,eAAe,MAAM;AAAA,IAC5B;AACA,QACE,MAAM,sBAAsB,UAC5B,MAAM,kBAAkB,QACxB;AACA,WAAK,gBAAgB,MAAM;AAAA,IAC7B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,WAME;AACA,WAAO;AAAA,MACL,cAAc,KAAK;AAAA,MACnB,eAAe,KAAK;AAAA,MACpB,yBAAyB,KAAK;AAAA,MAC9B,6BAA6B,KAAK;AAAA,MAClC,kBAAkB,KAAK;AAAA,IACzB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,cAAc;AACnB,SAAK,eAAe;AACpB,SAAK,kBAAkB;AACvB,SAAK,sBAAsB;AAC3B,SAAK,kBAAkB;AAAA,EACzB;AACF;AA4BO,SAAS,kBAAkB,UAW/B;AAED,MAAI,aAAa,QAAQ,aAAa,QAAW;AAC/C,WAAO;AAAA,MACL,SAAS;AAAA,MACT,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,EACF;AAGA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,MACL,SAAS;AAAA,MACT,MAAM;AAAA,MACN,OAAO,0BAA0B,OAAO,QAAQ;AAAA,IAClD;AAAA,EACF;AAEA,QAAM,MAAM;AAGZ,MAAI,UAA0B,CAAC;AAC/B,MAAI,IAAI,YAAY,QAAW;AAC7B,QAAI,CAAC,MAAM,QAAQ,IAAI,OAAO,GAAG;AAE/B,UAAI,OAAO,IAAI,YAAY,UAAU;AACnC,kBAAU,CAAC,EAAE,MAAM,QAAQ,MAAM,IAAI,QAAQ,CAAC;AAAA,MAChD,OAAO;AACL,eAAO;AAAA,UACL,SAAS;AAAA,UACT,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF,OAAO;AACL,gBAAU,IAAI,QAAQ,IAAI,CAAC,UAAmB;AAC5C,YAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,iBAAO,EAAE,MAAM,QAAQ,MAAM,GAAG;AAAA,QAClC;AACA,YAAI,OAAO,UAAU,UAAU;AAC7B,iBAAO,EAAE,MAAM,QAAQ,MAAM,OAAO,KAAK,EAAE;AAAA,QAC7C;AACA,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAAA,EACF;AAGA,QAAM,WAAY,IAAI,SAAqC,CAAC;AAC5D,QAAM,QAAQ;AAAA,IACZ,cAAc,WAAW,SAAS,cAAc,CAAC;AAAA,IACjD,eAAe,WAAW,SAAS,eAAe,CAAC;AAAA,IACnD,yBAAyB,WAAW,SAAS,uBAAuB;AAAA,IACpE,6BAA6B;AAAA,MAC3B,SAAS;AAAA,IACX;AAAA,EACF;AAEA,SAAO;AAAA,IACL,SAAS;AAAA,IACT,MAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA,aAAa,WAAW,IAAI,WAAW;AAAA,MACvC,IAAI,WAAW,IAAI,EAAE;AAAA,MACrB,OAAO,WAAW,IAAI,KAAK;AAAA,IAC7B;AAAA,IACA,OAAO;AAAA,EACT;AACF;AAKO,SAAS,wBAAwB,UAerC;AACD,MAAI,aAAa,QAAQ,aAAa,QAAW;AAC/C,WAAO;AAAA,MACL,SAAS;AAAA,MACT,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,EACF;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,MACL,SAAS;AAAA,MACT,MAAM;AAAA,MACN,OAAO,0BAA0B,OAAO,QAAQ;AAAA,IAClD;AAAA,EACF;AAEA,QAAM,MAAM;AAGZ,QAAM,UAAU,IAAI;AACpB,QAAM,cAAc,UAAU,CAAC;AAC/B,QAAM,UAAW,aAAa,WAAuC,CAAC;AAGtE,QAAM,eAAe,QAAQ;AAG7B,QAAM,cAAc,gBAAgB,CAAC,GAClC,IAAI,QAAM;AACT,QAAI,CAAC,MAAM,OAAO,OAAO,SAAU,QAAO;AAC1C,UAAM,OAAO,GAAG;AAChB,WAAO;AAAA,MACL,IAAI,WAAW,GAAG,EAAE,KAAK;AAAA,MACzB,MAAM,WAAW,GAAG,IAAI,KAAK;AAAA,MAC7B,UAAU;AAAA,QACR,MAAM,WAAW,MAAM,IAAI,KAAK;AAAA,QAChC,WAAW,WAAW,MAAM,SAAS,KAAK;AAAA,MAC5C;AAAA,IACF;AAAA,EACF,CAAC,EACA,OAAO,CAAC,OAAqC,OAAO,IAAI;AAG3D,QAAM,WAAY,IAAI,SAAqC,CAAC;AAC5D,QAAM,QAAQ;AAAA,IACZ,eAAe,WAAW,SAAS,eAAe,CAAC;AAAA,IACnD,mBAAmB,WAAW,SAAS,mBAAmB,CAAC;AAAA,IAC3D,cAAc,WAAW,SAAS,cAAc,CAAC;AAAA,EACnD;AAEA,SAAO;AAAA,IACL,SAAS;AAAA,IACT,MAAM;AAAA,MACJ,SAAS,WAAW,QAAQ,OAAO,KAAK;AAAA,MACxC;AAAA,MACA;AAAA,MACA,eAAe,WAAW,aAAa,aAAa;AAAA,MACpD,IAAI,WAAW,IAAI,EAAE;AAAA,MACrB,OAAO,WAAW,IAAI,KAAK;AAAA,IAC7B;AAAA,IACA,OAAO;AAAA,EACT;AACF;AAKA,SAAS,WAAW,OAAgB,cAA+B;AACjE,MAAI,OAAO,UAAU,YAAY,CAAC,MAAM,KAAK,GAAG;AAC9C,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,SAAS,WAAW,KAAK;AAC/B,QAAI,CAAC,MAAM,MAAM,GAAG;AAClB,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,gBAAgB;AACzB;AAKA,SAAS,WAAW,OAAoC;AACtD,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO;AAAA,EACT;AACA,MAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,WAAO,OAAO,KAAK;AAAA,EACrB;AACA,SAAO;AACT;AAMO,SAAS,gBACd,gBACA,YACY;AACZ,MAAI,CAAC,gBAAgB;AACnB,WAAO,MAAM;AAAA,IAAC;AAAA,EAChB;AAEA,QAAM,UAAU,MAAM;AACpB,eAAW,MAAM;AAAA,EACnB;AAEA,iBAAe,iBAAiB,SAAS,OAAO;AAGhD,SAAO,MAAM;AACX,mBAAe,oBAAoB,SAAS,OAAO;AAAA,EACrD;AACF;AAKO,SAAS,4BAA4B,gBAG1C;AACA,QAAM,aAAa,IAAI,gBAAgB;AAGvC,MAAI,gBAAgB,SAAS;AAC3B,eAAW,MAAM;AACjB,WAAO,EAAE,YAAY,SAAS,MAAM;AAAA,IAAC,EAAE;AAAA,EACzC;AAEA,QAAM,UAAU,gBAAgB,gBAAgB,UAAU;AAE1D,SAAO,EAAE,YAAY,QAAQ;AAC/B;AAMA,gBAAuB,kBACrB,QACA,QACkC;AAElC,MAAI,QAAQ,SAAS;AACnB;AAAA,EACF;AAEA,QAAM,WAAW,OAAO,OAAO,aAAa,EAAE;AAE9C,MAAI;AACF,WAAO,MAAM;AAEX,UAAI,QAAQ,SAAS;AACnB;AAAA,MACF;AAEA,YAAM,SAAS,MAAM,SAAS,KAAK;AAEnC,UAAI,OAAO,MAAM;AACf;AAAA,MACF;AAGA,UAAI,QAAQ,SAAS;AACnB;AAAA,MACF;AAEA,YAAM,OAAO;AAAA,IACf;AAAA,EACF,UAAE;AAEA,QAAI,SAAS,QAAQ;AACnB,YAAM,SAAS,OAAO;AAAA,IACxB;AAAA,EACF;AACF;AAKO,SAAS,mBAAmB,SAAiC;AAClE,MAAI,CAAC,MAAM,QAAQ,OAAO,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,QACJ,OAAO,WAAS,OAAO,SAAS,UAAU,OAAO,MAAM,SAAS,QAAQ,EACxE,IAAI,WAAS,MAAM,IAAI,EACvB,KAAK,IAAI;AACd;AAKO,SAAS,gBAAgB,SAI7B;AACD,MAAI,CAAC,MAAM,QAAQ,OAAO,GAAG;AAC3B,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,QACJ,OAAO,WAAS,OAAO,SAAS,UAAU,EAC1C,IAAI,YAAU;AAAA,IACb,IAAI,MAAM,MAAM;AAAA,IAChB,MAAM,MAAM,QAAQ;AAAA,IACpB,OAAO,MAAM,SAAS,CAAC;AAAA,EACzB,EAAE;AACN;",
+  "names": []
+}

package/dist/utils/messageGroupManager.js

@@ -0,0 +1,274 @@
+import { TaskGroupHandler } from "./groupHandlers/taskHandler.js";
+import { ParallelTasksHandler } from "./groupHandlers/parallelTasksHandler.js";
+import { getAgentIdByToolUseId, getAgentTranscript } from "./agentTranscripts.js";
+class MessageGroupManager {
+  groups = /* @__PURE__ */ new Map();
+  toolUseToGroup = /* @__PURE__ */ new Map();
+  messageToGroup = /* @__PURE__ */ new Map();
+  typeHandlers = /* @__PURE__ */ new Map();
+  messageIndexMap = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  constructor() {
+    this.registerHandler(new TaskGroupHandler());
+    this.registerHandler(new ParallelTasksHandler());
+  }
+  /**
+   * Register a group type handler (supports custom extensions)
+   */
+  registerHandler(handler) {
+    this.typeHandlers.set(handler.type, handler);
+  }
+  /**
+   * Identify all groups from message list
+   */
+  identifyGroups(messages) {
+    this.reset();
+    messages.forEach((msg, idx) => {
+      this.messageIndexMap.set(msg.uuid, idx);
+    });
+    const processingOrder = ["parallel-tasks", "task"];
+    const parallelGroupUuids = /* @__PURE__ */ new Set();
+    for (const type of processingOrder) {
+      const handler = this.typeHandlers.get(type);
+      if (!handler) continue;
+      const identified = handler.identify(messages);
+      for (const identifiedGroup of identified) {
+        if (type === "task") {
+          const msgUuid = identifiedGroup.messageUuids[0];
+          if (parallelGroupUuids.has(msgUuid)) {
+            continue;
+          }
+        }
+        if (type === "parallel-tasks") {
+          for (const uuid of identifiedGroup.messageUuids) {
+            parallelGroupUuids.add(uuid);
+          }
+        }
+        this.createGroup(identifiedGroup, handler, messages);
+      }
+    }
+  }
+  /**
+   * Create a group and compute initial state
+   */
+  createGroup(identified, handler, messages) {
+    const groupId = this.generateGroupId(identified.type);
+    const group = {
+      id: groupId,
+      type: identified.type,
+      childIds: identified.childIds || [],
+      messageUuids: identified.messageUuids,
+      status: "pending",
+      metadata: identified.metadata,
+      // V1+ new fields: will be computed
+      anchor: { anchorMessageUuid: "", anchorStrategy: "first" },
+      resolution: {
+        isSelfResolved: false,
+        isNestedResolved: true,
+        isFullyResolved: false,
+        unresolvedToolUseIds: []
+      }
+    };
+    group.anchor = handler.computeAnchor(group, messages);
+    this.groups.set(group.id, group);
+    for (const uuid of group.messageUuids) {
+      this.messageToGroup.set(uuid, group.id);
+    }
+    if (identified.metadata.toolUseId) {
+      this.toolUseToGroup.set(identified.metadata.toolUseId, group.id);
+    }
+    if (identified.metadata.siblingToolUseIds) {
+      for (const toolUseId of identified.metadata.siblingToolUseIds) {
+        this.toolUseToGroup.set(toolUseId, group.id);
+      }
+    }
+    return group;
+  }
+  /**
+   * Update resolution states for all groups
+   * This is the generalized version of V3's nested checking
+   */
+  updateResolutionStates(unresolvedToolUseIDs, inProgressToolUseIDs) {
+    for (const group of this.groups.values()) {
+      const handler = this.typeHandlers.get(group.type);
+      if (handler) {
+        group.resolution = handler.computeResolution(
+          group,
+          unresolvedToolUseIDs
+        );
+      }
+    }
+    for (const group of this.groups.values()) {
+      if (group.type === "parallel-tasks") {
+        this.updateParallelGroupResolution(group, unresolvedToolUseIDs);
+      }
+    }
+    for (const group of this.groups.values()) {
+      group.status = this.computeGroupStatus(group, inProgressToolUseIDs);
+    }
+  }
+  /**
+   * Update parallel group resolution by checking all member tasks
+   */
+  updateParallelGroupResolution(group, unresolvedToolUseIDs) {
+    const memberIds = group.metadata.siblingToolUseIds || [];
+    let allNestedResolved = true;
+    const allUnresolvedIds = [
+      ...group.resolution.unresolvedToolUseIds
+    ];
+    for (const toolUseId of memberIds) {
+      const agentId = getAgentIdByToolUseId(toolUseId);
+      if (agentId) {
+        const nestedResult = this.checkNestedTasksResolution(
+          agentId,
+          unresolvedToolUseIDs
+        );
+        if (nestedResult.hasUnresolved) {
+          allNestedResolved = false;
+          allUnresolvedIds.push(...nestedResult.unresolvedIds);
+        }
+      }
+    }
+    group.resolution.isNestedResolved = allNestedResolved;
+    group.resolution.isFullyResolved = group.resolution.isSelfResolved && allNestedResolved;
+    group.resolution.unresolvedToolUseIds = allUnresolvedIds;
+  }
+  /**
+   * Recursively check if all nested tasks are resolved
+   */
+  checkNestedTasksResolution(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.checkNestedTasksResolution(
+                nestedAgentId,
+                unresolvedToolUseIDs
+              );
+              unresolvedIds.push(...nested.unresolvedIds);
+            }
+          }
+        }
+      }
+    }
+    return {
+      hasUnresolved: unresolvedIds.length > 0,
+      unresolvedIds
+    };
+  }
+  /**
+   * Check if a group should be rendered as Static
+   * V1+ core: only fully resolved groups can be Static
+   */
+  shouldGroupBeStatic(group) {
+    return group.resolution.isFullyResolved;
+  }
+  /**
+   * Get ordered root groups (groups without parent)
+   * Sorted by anchor message position
+   */
+  getOrderedRootGroups() {
+    const roots = Array.from(this.groups.values()).filter((g) => !g.parentId);
+    return roots.sort((a, b) => {
+      const aIndex = this.messageIndexMap.get(a.anchor.anchorMessageUuid) ?? 0;
+      const bIndex = this.messageIndexMap.get(b.anchor.anchorMessageUuid) ?? 0;
+      return aIndex - bIndex;
+    });
+  }
+  /**
+   * Get all tool use IDs associated with a group
+   */
+  getGroupToolUseIds(group) {
+    const ids = [];
+    if (group.metadata.toolUseId) {
+      ids.push(group.metadata.toolUseId);
+    }
+    if (group.metadata.siblingToolUseIds) {
+      ids.push(...group.metadata.siblingToolUseIds);
+    }
+    return ids;
+  }
+  /**
+   * Compute group status based on resolution and progress
+   *
+   * IMPORTANT: For parallel tasks, we must check inProgressToolUseIDs BEFORE
+   * checking isFullyResolved, because tool uses may still be running even if
+   * they haven't received results yet. The resolution check only tells us if
+   * tool_results exist, not if agents are still running.
+   */
+  computeGroupStatus(group, inProgressToolUseIDs) {
+    const toolUseIds = this.getGroupToolUseIds(group);
+    if (toolUseIds.some((id) => inProgressToolUseIDs.has(id))) {
+      return "running";
+    }
+    if (group.resolution.isFullyResolved) {
+      return "completed";
+    }
+    return "pending";
+  }
+  generateGroupId(type) {
+    this.idCounter++;
+    return `${type}-${Date.now()}-${this.idCounter}`;
+  }
+  reset() {
+    this.groups.clear();
+    this.toolUseToGroup.clear();
+    this.messageToGroup.clear();
+    this.messageIndexMap.clear();
+    this.idCounter = 0;
+  }
+  getGroup(id) {
+    return this.groups.get(id);
+  }
+  getGroupByToolUseId(toolUseId) {
+    const groupId = this.toolUseToGroup.get(toolUseId);
+    return groupId ? this.groups.get(groupId) : void 0;
+  }
+  getGroupByMessageUuid(uuid) {
+    const groupId = this.messageToGroup.get(uuid);
+    return groupId ? this.groups.get(groupId) : void 0;
+  }
+  getAllGroups() {
+    return Array.from(this.groups.values());
+  }
+  /**
+   * Check if a toolUseId is the anchor of its group
+   */
+  isGroupAnchor(toolUseId) {
+    const group = this.getGroupByToolUseId(toolUseId);
+    if (!group) return false;
+    if (group.type === "parallel-tasks") {
+      const siblings = group.metadata.siblingToolUseIds;
+      return siblings?.[0] === toolUseId;
+    }
+    return group.metadata.toolUseId === toolUseId;
+  }
+}
+let globalManager = null;
+function getMessageGroupManager() {
+  if (!globalManager) {
+    globalManager = new MessageGroupManager();
+  }
+  return globalManager;
+}
+function resetMessageGroupManager() {
+  globalManager = null;
+}
+export {
+  MessageGroupManager,
+  getMessageGroupManager,
+  resetMessageGroupManager
+};
+//# sourceMappingURL=messageGroupManager.js.map

package/dist/utils/messageGroupManager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/messageGroupManager.ts"],
+  "sourcesContent": ["/**\n * V1+ Message Group Manager\n *\n * Unified manager combining V1's generality with V3's concrete solutions:\n * 1. Plugin-based type handlers for extensibility\n * 2. Unified recursive state computation\n * 3. Position anchoring mechanism\n */\n\nimport type { NormalizedMessage } from '@utils/messages'\nimport type {\n  MessageGroup,\n  MessageGroupType,\n  IdentifiedGroup,\n  PositionAnchor,\n  ResolutionState,\n} from '@minto-types/messageGroup'\nimport type { GroupTypeHandler } from './groupHandlers/types'\nimport { TaskGroupHandler } from './groupHandlers/taskHandler'\nimport { ParallelTasksHandler } from './groupHandlers/parallelTasksHandler'\nimport { getAgentIdByToolUseId, getAgentTranscript } from './agentTranscripts'\n\n/**\n * V1+ Message Group Manager\n *\n * Features:\n * 1. Plugin-based type handlers\n * 2. Unified recursive state computation\n * 3. Position anchoring mechanism\n */\nexport class MessageGroupManager {\n  private groups: Map<string, MessageGroup> = new Map()\n  private toolUseToGroup: Map<string, string> = new Map()\n  private messageToGroup: Map<string, string> = new Map()\n  private typeHandlers: Map<MessageGroupType, GroupTypeHandler> = new Map()\n  private messageIndexMap: Map<string, number> = new Map()\n  private idCounter = 0\n\n  constructor() {\n    // Register built-in type handlers\n    this.registerHandler(new TaskGroupHandler())\n    this.registerHandler(new ParallelTasksHandler())\n  }\n\n  /**\n   * Register a group type handler (supports custom extensions)\n   */\n  registerHandler(handler: GroupTypeHandler): void {\n    this.typeHandlers.set(handler.type, handler)\n  }\n\n  /**\n   * Identify all groups from message list\n   */\n  identifyGroups(messages: NormalizedMessage[]): void {\n    this.reset()\n\n    // Build message index map for sorting\n    messages.forEach((msg, idx) => {\n      this.messageIndexMap.set(msg.uuid, idx)\n    })\n\n    // Process in dependency order: parallel-tasks first (to exclude from task handler)\n    // Then task handler for remaining single tasks\n    const processingOrder: MessageGroupType[] = ['parallel-tasks', 'task']\n\n    // Track UUIDs that are part of parallel groups\n    const parallelGroupUuids = new Set<string>()\n\n    for (const type of processingOrder) {\n      const handler = this.typeHandlers.get(type)\n      if (!handler) continue\n\n      const identified = handler.identify(messages)\n\n      for (const identifiedGroup of identified) {\n        // For task groups, skip if the message is already in a parallel group\n        if (type === 'task') {\n          const msgUuid = identifiedGroup.messageUuids[0]\n          if (parallelGroupUuids.has(msgUuid)) {\n            continue\n          }\n        }\n\n        // Track parallel group UUIDs\n        if (type === 'parallel-tasks') {\n          for (const uuid of identifiedGroup.messageUuids) {\n            parallelGroupUuids.add(uuid)\n          }\n        }\n\n        this.createGroup(identifiedGroup, handler, messages)\n      }\n    }\n  }\n\n  /**\n   * Create a group and compute initial state\n   */\n  private createGroup(\n    identified: IdentifiedGroup,\n    handler: GroupTypeHandler,\n    messages: NormalizedMessage[],\n  ): MessageGroup {\n    const groupId = this.generateGroupId(identified.type)\n\n    const group: MessageGroup = {\n      id: groupId,\n      type: identified.type,\n      childIds: identified.childIds || [],\n      messageUuids: identified.messageUuids,\n      status: 'pending',\n      metadata: identified.metadata,\n      // V1+ new fields: will be computed\n      anchor: { anchorMessageUuid: '', anchorStrategy: 'first' },\n      resolution: {\n        isSelfResolved: false,\n        isNestedResolved: true,\n        isFullyResolved: false,\n        unresolvedToolUseIds: [],\n      },\n    }\n\n    // Compute anchor\n    group.anchor = handler.computeAnchor(group, messages)\n\n    // Register mappings\n    this.groups.set(group.id, group)\n    for (const uuid of group.messageUuids) {\n      this.messageToGroup.set(uuid, group.id)\n    }\n    if (identified.metadata.toolUseId) {\n      this.toolUseToGroup.set(identified.metadata.toolUseId, group.id)\n    }\n    // Also register sibling tool use IDs for parallel groups\n    if (identified.metadata.siblingToolUseIds) {\n      for (const toolUseId of identified.metadata.siblingToolUseIds) {\n        this.toolUseToGroup.set(toolUseId, group.id)\n      }\n    }\n\n    return group\n  }\n\n  /**\n   * Update resolution states for all groups\n   * This is the generalized version of V3's nested checking\n   */\n  updateResolutionStates(\n    unresolvedToolUseIDs: Set<string>,\n    inProgressToolUseIDs: Set<string>,\n  ): void {\n    // First pass: update all groups' resolution using their handlers\n    for (const group of this.groups.values()) {\n      const handler = this.typeHandlers.get(group.type)\n      if (handler) {\n        group.resolution = handler.computeResolution(\n          group,\n          unresolvedToolUseIDs,\n        )\n      }\n    }\n\n    // Second pass: for parallel groups, aggregate child resolutions\n    for (const group of this.groups.values()) {\n      if (group.type === 'parallel-tasks') {\n        this.updateParallelGroupResolution(group, unresolvedToolUseIDs)\n      }\n    }\n\n    // Third pass: update status based on resolution\n    for (const group of this.groups.values()) {\n      group.status = this.computeGroupStatus(group, inProgressToolUseIDs)\n    }\n  }\n\n  /**\n   * Update parallel group resolution by checking all member tasks\n   */\n  private updateParallelGroupResolution(\n    group: MessageGroup,\n    unresolvedToolUseIDs: Set<string>,\n  ): void {\n    const memberIds = (group.metadata.siblingToolUseIds as string[]) || []\n\n    // Check each member's nested resolution\n    let allNestedResolved = true\n    const allUnresolvedIds: string[] = [\n      ...group.resolution.unresolvedToolUseIds,\n    ]\n\n    for (const toolUseId of memberIds) {\n      const agentId = getAgentIdByToolUseId(toolUseId)\n      if (agentId) {\n        const nestedResult = this.checkNestedTasksResolution(\n          agentId,\n          unresolvedToolUseIDs,\n        )\n        if (nestedResult.hasUnresolved) {\n          allNestedResolved = false\n          allUnresolvedIds.push(...nestedResult.unresolvedIds)\n        }\n      }\n    }\n\n    group.resolution.isNestedResolved = allNestedResolved\n    group.resolution.isFullyResolved =\n      group.resolution.isSelfResolved && allNestedResolved\n    group.resolution.unresolvedToolUseIds = allUnresolvedIds\n  }\n\n  /**\n   * Recursively check if all nested tasks are resolved\n   */\n  private checkNestedTasksResolution(\n    agentId: string,\n    unresolvedToolUseIDs: Set<string>,\n  ): { hasUnresolved: boolean; unresolvedIds: string[] } {\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            if (unresolvedToolUseIDs.has(block.id)) {\n              unresolvedIds.push(block.id)\n            }\n\n            const nestedAgentId = getAgentIdByToolUseId(block.id)\n            if (nestedAgentId) {\n              const nested = this.checkNestedTasksResolution(\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  /**\n   * Check if a group should be rendered as Static\n   * V1+ core: only fully resolved groups can be Static\n   */\n  shouldGroupBeStatic(group: MessageGroup): boolean {\n    return group.resolution.isFullyResolved\n  }\n\n  /**\n   * Get ordered root groups (groups without parent)\n   * Sorted by anchor message position\n   */\n  getOrderedRootGroups(): MessageGroup[] {\n    const roots = Array.from(this.groups.values()).filter(g => !g.parentId)\n    return roots.sort((a, b) => {\n      const aIndex = this.messageIndexMap.get(a.anchor.anchorMessageUuid) ?? 0\n      const bIndex = this.messageIndexMap.get(b.anchor.anchorMessageUuid) ?? 0\n      return aIndex - bIndex\n    })\n  }\n\n  /**\n   * Get all tool use IDs associated with a group\n   */\n  getGroupToolUseIds(group: MessageGroup): string[] {\n    const ids: string[] = []\n    if (group.metadata.toolUseId) {\n      ids.push(group.metadata.toolUseId)\n    }\n    if (group.metadata.siblingToolUseIds) {\n      ids.push(...group.metadata.siblingToolUseIds)\n    }\n    return ids\n  }\n\n  /**\n   * Compute group status based on resolution and progress\n   *\n   * IMPORTANT: For parallel tasks, we must check inProgressToolUseIDs BEFORE\n   * checking isFullyResolved, because tool uses may still be running even if\n   * they haven't received results yet. The resolution check only tells us if\n   * tool_results exist, not if agents are still running.\n   */\n  private computeGroupStatus(\n    group: MessageGroup,\n    inProgressToolUseIDs: Set<string>,\n  ): 'pending' | 'running' | 'completed' | 'failed' {\n    const toolUseIds = this.getGroupToolUseIds(group)\n\n    // Check running status FIRST - if any toolUseId is in progress, the group is running\n    // This is critical for parallel tasks where agents may still be running\n    if (toolUseIds.some(id => inProgressToolUseIDs.has(id))) {\n      return 'running'\n    }\n\n    // Only after confirming nothing is running, check resolution\n    if (group.resolution.isFullyResolved) {\n      return 'completed'\n    }\n\n    return 'pending'\n  }\n\n  private generateGroupId(type: MessageGroupType): string {\n    this.idCounter++\n    return `${type}-${Date.now()}-${this.idCounter}`\n  }\n\n  reset(): void {\n    this.groups.clear()\n    this.toolUseToGroup.clear()\n    this.messageToGroup.clear()\n    this.messageIndexMap.clear()\n    this.idCounter = 0\n  }\n\n  getGroup(id: string): MessageGroup | undefined {\n    return this.groups.get(id)\n  }\n\n  getGroupByToolUseId(toolUseId: string): MessageGroup | undefined {\n    const groupId = this.toolUseToGroup.get(toolUseId)\n    return groupId ? this.groups.get(groupId) : undefined\n  }\n\n  getGroupByMessageUuid(uuid: string): MessageGroup | undefined {\n    const groupId = this.messageToGroup.get(uuid)\n    return groupId ? this.groups.get(groupId) : undefined\n  }\n\n  getAllGroups(): MessageGroup[] {\n    return Array.from(this.groups.values())\n  }\n\n  /**\n   * Check if a toolUseId is the anchor of its group\n   */\n  isGroupAnchor(toolUseId: string): boolean {\n    const group = this.getGroupByToolUseId(toolUseId)\n    if (!group) return false\n\n    // For parallel groups, check if this is the first sibling\n    if (group.type === 'parallel-tasks') {\n      const siblings = group.metadata.siblingToolUseIds as string[] | undefined\n      return siblings?.[0] === toolUseId\n    }\n\n    // For single task groups, the toolUseId is always the anchor\n    return group.metadata.toolUseId === toolUseId\n  }\n}\n\n// Singleton instance for global access\nlet globalManager: MessageGroupManager | null = null\n\nexport function getMessageGroupManager(): MessageGroupManager {\n  if (!globalManager) {\n    globalManager = new MessageGroupManager()\n  }\n  return globalManager\n}\n\nexport function resetMessageGroupManager(): void {\n  globalManager = null\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/utils/messages.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { getCommand, hasCommand } from "../commands.js";
 import { MalformedCommandError } from "./errors.js";
 import { logError } from "./log.js";
@@ -413,20 +413,29 @@ function isNotEmptyMessage(message) {
   }
   return message.message.content[0].text.trim().length > 0 && message.message.content[0].text !== NO_CONTENT_MESSAGE && message.message.content[0].text !== INTERRUPT_MESSAGE_FOR_TOOL_USE;
 }
+function deterministicUUID(seed) {
+  const hash = createHash("sha256").update(seed).digest("hex");
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-${(parseInt(hash.slice(16, 17), 16) & 3 | 8).toString(16)}${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+}
 function normalizeMessages(messages) {
-  return messages.flatMap((message) => {
+  return messages.flatMap((message, messageIndex) => {
     if (message.type === "progress") {
       return [message];
     }
     if (typeof message.message.content === "string") {
       return [message];
     }
-    return message.message.content.map((_) => {
+    return message.message.content.map((_, contentIndex) => {
       switch (message.type) {
         case "assistant":
+          const baseUuid = message.uuid || `msg-${messageIndex}`;
+          const contentId = _.type === "tool_use" ? _.id || contentIndex : contentIndex;
+          const stableUuid = deterministicUUID(`${baseUuid}-${contentId}`);
           return {
             type: "assistant",
-            uuid: randomUUID(),
+            uuid: stableUuid,
+            // Preserve original UUID for identifying parallel tool calls from same message
+            originalUuid: message.uuid,
             message: {
               ...message.message,
               content: [_]