@within-7/minto 0.4.2 → 0.4.3

package/dist/utils/messageGroupManager.js

@@ -1,274 +0,0 @@
-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 === "Agent" || 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

@@ -1,7 +0,0 @@
-{
-  "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 (\n            block.type === 'tool_use' &&\n            (block.name === 'Agent' || block.name === 'Task')\n          ) {\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": []
-}