@threadplane/langgraph 0.0.59 → 0.0.61

package/fesm2022/threadplane-langgraph.mjs

@@ -243,6 +243,18 @@ class SubagentTracker {
     onSubagentChange;
     subagents = new Map();
     namespaceToToolCallId = new Map();
+    /**
+     * Child messages received under a namespace that is not yet attributed to a
+     * registered subagent. LangGraph's `tools:<id>` namespace carries an internal
+     * run UUID, not the parent's tool-call id, and the two are only reconciled
+     * once a `values` event arrives carrying the child's first human message. Any
+     * chunk streamed before that point would otherwise be dropped — which is what
+     * made subagent cards render "0 message(s)" despite a full child transcript.
+     *
+     * Merged by id like a real transcript, so this stays bounded by the child's
+     * distinct message count rather than by chunk volume.
+     */
+    unattributedMessages = new Map();
     pendingMatches = new Map();
     constructor(options = {}) {
         this.subagentToolNames = new Set(options.subagentToolNames ?? DEFAULT_SUBAGENT_TOOL_NAMES);
@@ -252,6 +264,7 @@ class SubagentTracker {
         this.subagents.clear();
         this.namespaceToToolCallId.clear();
         this.pendingMatches.clear();
+        this.unattributedMessages.clear();
         this.onSubagentChange?.();
     }
     getSubagents() {
@@ -320,10 +333,13 @@ class SubagentTracker {
             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?.();
             return toolCallId;
@@ -345,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);
@@ -377,6 +407,27 @@ class SubagentTracker {
         });
         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.
+     *
+     * The description ladder needs two things this repo's own graphs don't
+     * reliably provide: a delegation tool that names its argument `description`,
+     * and a child whose first message is the human task. `cockpit/chat/subagents`
+     * has neither — it uses `task_description`, and its child's messages begin
+     * with the AI reply. Attribution therefore never ran, so the child's
+     * transcript was never claimed and every card rendered "0 message(s)".
+     *
+     * Calling the ladder with no description skips both description rungs and
+     * lands on the positional fallback (first unmapped pending/running tool
+     * child), which is correct for sequential dispatch and is the same heuristic
+     * the ladder already relied on in practice.
+     */
+    ensureToolStreamAttribution(namespaceId) {
+        if (this.namespaceToToolCallId.has(namespaceId))
+            return;
+        this.matchSubgraphToSubagent(namespaceId, '');
+    }
     /**
      * Register a plain-subgraph child stream on its first namespaced event.
      *
@@ -432,8 +483,12 @@ class SubagentTracker {
     addMessageToSubagent(namespaceId, message) {
         const toolCallId = this.resolveToolCallId(namespaceId);
         const subagent = this.subagents.get(toolCallId);
-        if (!subagent)
+        if (!subagent) {
+            // Not attributed yet — hold it rather than drop it. `establish()` will
+            // replay the buffer the moment this namespace is matched to a tool call.
+            this.unattributedMessages.set(namespaceId, mergeMessages$1(this.unattributedMessages.get(namespaceId) ?? [], [message]));
             return;
+        }
         this.subagents.set(toolCallId, {
             ...subagent,
             status: subagent.status === 'complete' || subagent.status === 'error' ? subagent.status : 'running',
@@ -558,7 +613,7 @@ function mergeMessages$1(existing, incoming) {
         const id = getMessageId(msg);
         const idx = id ? merged.findIndex(m => getMessageId(m) === id) : -1;
         if (idx >= 0) {
-            merged[idx] = msg;
+            merged[idx] = accumulateChunk(merged[idx], msg);
         }
         else {
             merged.push(msg);
@@ -566,6 +621,57 @@ function mergeMessages$1(existing, incoming) {
     }
     return merged;
 }
+/**
+ * Fold a streamed chunk into the message it belongs to.
+ *
+ * A child graph streams `AIMessageChunk`s that are *deltas* — a handful of
+ * characters each, hundreds per message. Replacing by id (the previous
+ * behavior) therefore kept only the final delta, so a fully attributed
+ * subagent still rendered a near-empty message. Snapshots, which carry the
+ * message-so-far, still replace.
+ *
+ * This mirrors the parent transcript's delta handling: append unconditionally
+ * rather than comparing text, because a prefix-style "dedupe" silently eats
+ * legitimate tokens that happen to repeat the accumulated prefix.
+ */
+function accumulateChunk(existing, incoming) {
+    if (!isChunkMessage(incoming))
+        return incoming;
+    const previousText = extractText$1(existing['content']);
+    const incomingText = extractText$1(incoming['content']);
+    if (!incomingText)
+        return existing;
+    if (!previousText)
+        return incoming;
+    return { ...incoming, content: previousText + incomingText };
+}
+function isChunkMessage(message) {
+    const type = message['type'];
+    return typeof type === 'string' && type.endsWith('Chunk');
+}
+function extractText$1(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    let out = '';
+    for (const block of content) {
+        if (typeof block === 'string') {
+            out += block;
+            continue;
+        }
+        if (block == null || typeof block !== 'object')
+            continue;
+        const record = block;
+        const blockType = record['type'];
+        if (blockType === 'text' || blockType === 'output_text' || blockType === undefined) {
+            const text = record['text'];
+            if (typeof text === 'string')
+                out += text;
+        }
+    }
+    return out;
+}
 function getMessageId(message) {
     return message.id;
 }
@@ -1208,6 +1314,10 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                     if (child.kind === 'subgraph') {
                         subagentManager.ensureSubgraphStream(child.key, child.name);
                     }
+                    else {
+                        // Claim the stream for its tool call before its tokens arrive.
+                        subagentManager.ensureToolStreamAttribution(child.key);
+                    }
                     for (const msg of normalized) {
                         subagentManager.addMessageToSubagent(child.key, msg);
                     }
@@ -1410,14 +1520,16 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         if (!child)
             return;
         if (child.kind === 'tool') {
-            // Attribution ladder applies to tool children only: their namespace id
-            // may need mapping onto a registered tool call.
+            // Prefer the precise description match when the child's first message is
+            // the human task; otherwise claim the stream positionally so a graph that
+            // doesn't fit that shape still gets attributed.
             const messages = values['messages'];
-            if (Array.isArray(messages) && messages.length > 0) {
-                const first = messages[0];
-                if (isRecord$1(first) && (first['type'] === 'human' || first['type'] === 'user') && typeof first['content'] === 'string') {
-                    subagentManager.matchSubgraphToSubagent(child.key, first['content']);
-                }
+            const first = Array.isArray(messages) && messages.length > 0 ? messages[0] : undefined;
+            if (isRecord$1(first) && (first['type'] === 'human' || first['type'] === 'user') && typeof first['content'] === 'string') {
+                subagentManager.matchSubgraphToSubagent(child.key, first['content']);
+            }
+            else {
+                subagentManager.ensureToolStreamAttribution(child.key);
             }
         }
         else {