@threadplane/langgraph 0.0.58 → 0.0.60

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() {
@@ -278,6 +291,7 @@ class SubagentTracker {
             this.subagents.set(id, {
                 id,
                 generation: existing?.generation ?? createSubagentGeneration(),
+                kind: 'tool',
                 status: existing?.status ?? 'pending',
                 toolCall: {
                     id,
@@ -319,23 +333,26 @@ 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;
         };
         for (const [toolCallId, subagent] of this.subagents) {
-            if (mapped.has(toolCallId))
+            if (subagent.kind !== 'tool' || mapped.has(toolCallId))
                 continue;
             if (subagent.toolCall.args['description'] === description) {
                 return establish(toolCallId);
             }
         }
         for (const [toolCallId, subagent] of this.subagents) {
-            if (mapped.has(toolCallId))
+            if (subagent.kind !== 'tool' || mapped.has(toolCallId))
                 continue;
             const subagentDescription = subagent.toolCall.args['description'];
             if (typeof subagentDescription !== 'string' || !subagentDescription)
@@ -344,7 +361,11 @@ 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);
             }
@@ -372,6 +393,67 @@ 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.
+     *
+     * Unlike tool children — announced ahead of time by the parent's tool call —
+     * a compiled child added as a plain node has no announcement: its existence
+     * is learned from the first event carrying its namespace. It starts
+     * 'running' because by the time we see an event, it is.
+     */
+    ensureSubgraphStream(key, name) {
+        if (this.subagents.has(key))
+            return;
+        this.subagents.set(key, {
+            id: key,
+            generation: createSubagentGeneration(),
+            kind: 'subgraph',
+            status: 'running',
+            toolCall: { id: key, name, args: {} },
+            values: {},
+            messages: [],
+        });
+        this.onSubagentChange?.();
+    }
+    /**
+     * Settle still-running subgraph children when the run reaches a terminal
+     * outcome. Tool children settle through their tool result
+     * (`processToolMessage`); subgraph children have no result message, so the
+     * run's own settle is their completion signal. Paused/interrupted runs must
+     * NOT call this — a child can resume with the thread.
+     */
+    settleRunningSubgraphs(outcome) {
+        let changed = false;
+        for (const [key, subagent] of this.subagents) {
+            if (subagent.kind !== 'subgraph' || subagent.status !== 'running')
+                continue;
+            this.subagents.set(key, { ...subagent, status: outcome });
+            changed = true;
+        }
+        if (changed)
+            this.onSubagentChange?.();
+    }
     updateSubagentValues(namespaceId, values) {
         const toolCallId = this.resolveToolCallId(namespaceId);
         const subagent = this.subagents.get(toolCallId);
@@ -387,8 +469,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',
@@ -437,12 +523,40 @@ class SubagentTracker {
         return this.namespaceToToolCallId.get(namespaceId) ?? namespaceId;
     }
 }
-function isSubagentNamespace(namespace) {
+/**
+ * True when a stream event belongs to a child graph rather than the parent —
+ * i.e. it carries any namespace at all. This is the single classification
+ * question; which child owns the event is a separate (attribution) question.
+ *
+ * Kept consistent with the terminal-evidence guard, which has always refused
+ * ANY namespaced event as proof the parent run finished.
+ */
+function isChildNamespace(namespace) {
     if (!namespace)
         return false;
     if (typeof namespace === 'string')
-        return namespace.includes('tools:');
-    return namespace.some(segment => segment.startsWith('tools:'));
+        return namespace.length > 0;
+    return namespace.length > 0;
+}
+/**
+ * Derive a child stream's identity from an event namespace.
+ *
+ * `tools:<id>` segments identify a tool-dispatched child by its tool-call id.
+ * Any other segment (e.g. `research:<uuid>` from a compiled graph added with
+ * `add_node`) identifies a plain subgraph child: the full segment is the key
+ * (unique per invocation) and the part before the first ':' is the node name.
+ */
+function childStreamRefFromNamespace(namespace) {
+    for (const segment of namespace) {
+        if (segment.startsWith('tools:')) {
+            return { key: segment.slice(6), name: '', kind: 'tool' };
+        }
+    }
+    const first = namespace[0];
+    if (!first)
+        return undefined;
+    const colon = first.indexOf(':');
+    return { key: first, name: colon > 0 ? first.slice(0, colon) : first, kind: 'subgraph' };
 }
 function extractToolCallIdFromNamespace(namespace) {
     if (!namespace)
@@ -485,7 +599,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);
@@ -493,6 +607,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;
 }
@@ -649,6 +814,13 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 continue;
             finalizeMessage(attempt, id, outcome);
         }
+        // Subgraph children have no tool result to settle them; the run's own
+        // terminal outcome is their completion signal. Paused/interrupted runs
+        // are excluded — a child can resume with the thread.
+        if (outcome === 'success' || outcome === 'error' || outcome === 'aborted') {
+            subagentManager.settleRunningSubgraphs(outcome === 'success' ? 'complete' : 'error');
+            publishSubagents();
+        }
     }
     function finishOutcome(attempt) {
         return attempt.terminalOutcome
@@ -1118,17 +1290,27 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             const normalized = options.toMessage
                 ? msgs.map(options.toMessage)
                 : msgs;
-            if (isSubagentNamespace(namespace)) {
-                const namespaceId = namespace ? extractToolCallIdFromNamespace(namespace) : undefined;
-                if (namespaceId) {
+            // Any namespaced message event is child content. It feeds the child's
+            // stream and never merges into the parent transcript — the parent
+            // transcript is what the parent graph says. Shared-state children still
+            // surface at settle through the authoritative top-level `values` sync.
+            if (isChildNamespace(namespace)) {
+                const child = namespace ? childStreamRefFromNamespace(namespace) : undefined;
+                if (child) {
+                    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(namespaceId, msg);
+                        subagentManager.addMessageToSubagent(child.key, msg);
                     }
                     publishSubagents();
                 }
-                if (options.filterSubagentMessages) {
-                    return;
-                }
+                storeMessageMetadata(normalized, event);
+                return;
             }
             // Partial and message-tuple events are incremental. Merge them by id
             // so optimistic human messages and earlier tool messages are preserved.
@@ -1143,7 +1325,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 const merged = mergeMessages(subjects.messages$.value, normalized, reasoningTimingMap, mode, canonicalMessageIds, affectedMessageIds, activeAttempt?.currentAssistantMessageId !== undefined
                     && activeAttempt.currentStepHasTerminalEvidence !== true);
                 subjects.messages$.next(merged);
-                if (!isSubagentNamespace(namespace)) {
+                {
                     trackAssistantMessages(merged.filter(message => {
                         const id = message['id'];
                         return typeof id === 'string' && affectedMessageIds.has(id);
@@ -1166,7 +1348,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 const affectedMessageIds = new Set();
                 const preserved = preserveIds(subjects.messages$.value, normalized, affectedMessageIds);
                 subjects.messages$.next(preserved);
-                if (!isSubagentNamespace(namespace)) {
+                {
                     trackAssistantMessages(preserved.filter(message => {
                         const id = message['id'];
                         return typeof id === 'string' && affectedMessageIds.has(id);
@@ -1185,8 +1367,11 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         switch (baseType) {
             case 'values': {
                 const vals = extractEventData(event);
-                if (isSubagentNamespace(namespace) && isRecord$1(vals)) {
-                    updateSubagentValues(namespace, vals);
+                if (isChildNamespace(namespace)) {
+                    // A child's state must not clobber the parent's `values$` — route it
+                    // to the child stream and stop.
+                    if (isRecord$1(vals))
+                        updateSubagentValues(namespace, vals);
                     break;
                 }
                 if ((namespace?.length ?? 0) === 0) {
@@ -1252,7 +1437,9 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             }
             case 'updates': {
                 const upd = extractEventData(event);
-                if (isSubagentNamespace(namespace)) {
+                if (isChildNamespace(namespace)) {
+                    // A child's updates must not spread-merge into the parent's
+                    // `values$` — they only mark the child stream running.
                     markSubagentRunning(namespace);
                     break;
                 }
@@ -1315,24 +1502,36 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         publishSubagents();
     }
     function updateSubagentValues(namespace, values) {
-        const namespaceId = namespace ? extractToolCallIdFromNamespace(namespace) : undefined;
-        if (!namespaceId)
+        const child = namespace ? childStreamRefFromNamespace(namespace) : undefined;
+        if (!child)
             return;
-        const messages = values['messages'];
-        if (Array.isArray(messages) && messages.length > 0) {
-            const first = messages[0];
+        if (child.kind === 'tool') {
+            // 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'];
+            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(namespaceId, first['content']);
+                subagentManager.matchSubgraphToSubagent(child.key, first['content']);
+            }
+            else {
+                subagentManager.ensureToolStreamAttribution(child.key);
             }
         }
-        subagentManager.updateSubagentValues(namespaceId, values);
+        else {
+            subagentManager.ensureSubgraphStream(child.key, child.name);
+        }
+        subagentManager.updateSubagentValues(child.key, values);
         publishSubagents();
     }
     function markSubagentRunning(namespace) {
-        const namespaceId = namespace ? extractToolCallIdFromNamespace(namespace) : undefined;
-        if (!namespaceId)
+        const child = namespace ? childStreamRefFromNamespace(namespace) : undefined;
+        if (!child)
             return;
-        subagentManager.markRunningFromNamespace(namespaceId, namespace);
+        if (child.kind === 'subgraph') {
+            subagentManager.ensureSubgraphStream(child.key, child.name);
+        }
+        subagentManager.markRunningFromNamespace(child.key, namespace);
         publishSubagents();
     }
     function publishSubagents() {
@@ -2130,9 +2329,13 @@ function toSubagentRefs(subagents) {
     subagents.forEach((subagent, key) => {
         refs.set(key, {
             toolCallId: subagent.id,
+            // Tool children are named by their `subagent_type` arg; subgraph
+            // children by their node name (stored as the synthetic toolCall name).
             name: typeof subagent.toolCall.args['subagent_type'] === 'string'
                 ? subagent.toolCall.args['subagent_type']
-                : undefined,
+                : subagent.kind === 'subgraph'
+                    ? subagent.toolCall.name
+                    : undefined,
             status: signal(subagent.status),
             values: signal(subagent.values),
             messages: signal(subagent.messages),
@@ -3424,7 +3627,6 @@ function agentFactory() {
         ...(config.transport !== undefined ? { transport: config.transport } : {}),
         ...(config.clientOptions !== undefined ? { clientOptions: config.clientOptions } : {}),
         ...(config.telemetry !== undefined ? { telemetry: config.telemetry } : {}),
-        ...(config.filterSubagentMessages !== undefined ? { filterSubagentMessages: config.filterSubagentMessages } : {}),
         ...(config.subagentToolNames !== undefined ? { subagentToolNames: config.subagentToolNames } : {}),
         ...(config.transcriptNodeNames !== undefined ? { transcriptNodeNames: config.transcriptNodeNames } : {}),
     });