@threadplane/langgraph 0.0.60 → 0.0.62

package/fesm2022/threadplane-langgraph.mjs

@@ -361,14 +361,28 @@ class SubagentTracker {
                 return establish(toolCallId);
             }
         }
-        // Last-resort fallback — tool children only. A subgraph child is keyed by
-        // its own namespace and must never absorb an unrelated child's events.
-        for (const [toolCallId, subagent] of this.subagents) {
-            if (subagent.kind !== 'tool')
-                continue;
-            if (!mapped.has(toolCallId) && (subagent.status === 'pending' || subagent.status === 'running')) {
-                return establish(toolCallId);
-            }
+        // Last-resort fallback — tool children only, and only when there is
+        // nothing to guess between.
+        //
+        // LangGraph's `tools:<uuid>` namespace is a checkpoint id assigned
+        // independently of the parent's `call_*` tool-call id; the two are not
+        // linked anywhere on the wire (verified against a live run). So when a
+        // delegation tool carries no matchable description, position is the only
+        // signal left.
+        //
+        // That is sound with exactly one outstanding child — the shape every graph
+        // in this repo produces, since each dispatches one tool call per assistant
+        // turn. With several outstanding at once (parallel fan-out) arrival order
+        // is NOT dispatch order, and claiming the first unmapped call cross-wires
+        // the children: one card renders another's output. Leaving the stream
+        // unattributed keeps its messages buffered instead, so an empty card is
+        // the worst case rather than a confidently wrong one. It can still resolve
+        // later: as siblings complete, the candidate set shrinks back to one.
+        const candidates = [...this.subagents].filter(([toolCallId, subagent]) => subagent.kind === 'tool' &&
+            !mapped.has(toolCallId) &&
+            (subagent.status === 'pending' || subagent.status === 'running'));
+        if (candidates.length === 1) {
+            return establish(candidates[0][0]);
         }
         if (description) {
             this.pendingMatches.set(namespaceId, description);
@@ -393,6 +407,32 @@ class SubagentTracker {
         });
         this.onSubagentChange?.();
     }
+    /**
+     * Authoritative namespace→tool-call binding, from the server.
+     *
+     * `threadplane.middleware.langgraph.announce_subagent` emits a custom event
+     * pairing the child's checkpoint namespace with its tool-call id — the two
+     * halves that are never linked on the wire otherwise. Unlike the matching
+     * ladder this is not a heuristic: it overrides nothing that is already
+     * mapped, works with any number of children outstanding, and replays any
+     * chunks that streamed before the binding arrived.
+     */
+    bindChildStream(namespaceId, toolCallId) {
+        if (this.namespaceToToolCallId.get(namespaceId) === toolCallId)
+            return;
+        this.namespaceToToolCallId.set(namespaceId, toolCallId);
+        const subagent = this.subagents.get(toolCallId);
+        if (subagent) {
+            const buffered = this.unattributedMessages.get(namespaceId);
+            this.subagents.set(toolCallId, {
+                ...subagent,
+                status: subagent.status === 'complete' || subagent.status === 'error' ? subagent.status : 'running',
+                messages: buffered ? mergeMessages$1(subagent.messages, buffered) : subagent.messages,
+            });
+            this.unattributedMessages.delete(namespaceId);
+        }
+        this.onSubagentChange?.();
+    }
     /**
      * Attribute a `tools:` child stream to its parent tool call as soon as the
      * child is seen, without requiring a description to match on.
@@ -1470,6 +1510,20 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 break;
             case 'custom': {
                 const eventData = event['data'];
+                // Server-announced subagent identity (threadplane-middleware's
+                // `announce_subagent`). Consumed here rather than forwarded: it is
+                // protocol chatter, not application data.
+                if (isRecord$1(eventData)
+                    && eventData['type'] === 'threadplane.subagent_binding'
+                    && typeof eventData['namespace'] === 'string'
+                    && typeof eventData['tool_call_id'] === 'string') {
+                    const bound = childStreamRefFromNamespace([eventData['namespace']]);
+                    if (bound?.kind === 'tool') {
+                        subagentManager.bindChildStream(bound.key, eventData['tool_call_id']);
+                        publishSubagents();
+                    }
+                    break;
+                }
                 const name = (event['name'] ?? eventData?.['name'] ?? '');
                 const data = eventData?.['data'] ?? eventData;
                 const current = subjects.custom$.value;