@threadplane/langgraph 0.0.54 → 0.0.55

package/README.md

@@ -147,7 +147,7 @@ import { provideAgent, LangGraphThreadsAdapter, LANGGRAPH_THREADS_CONFIG } from
 
 export const appConfig: ApplicationConfig = {
   providers: [
-    provideAgent({ apiUrl: 'https://your-langgraph-platform.com' }),
+    provideAgent({ apiUrl: 'https://your-langgraph-platform.com', assistantId: 'my-agent' }),
     { provide: LANGGRAPH_THREADS_CONFIG, useValue: { apiUrl: 'https://your-langgraph-platform.com' } },
     LangGraphThreadsAdapter,
   ],

package/fesm2022/threadplane-langgraph.mjs

@@ -540,6 +540,10 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
     /** True when the current abort was user-initiated (via stop()). Reset at the start of every new runStream(). */
     let userAbortRequested = false;
     const toolProgressMap = new Map();
+    // Message ids whose content is known-final (installed by a canonical
+    // replacement). Late streamed deltas for these ids are stale stragglers and
+    // are ignored — decided by identity, never by comparing text to text.
+    const canonicalMessageIds = new Set();
     const queuedRuns = [];
     let drainingQueue = false;
     const subagentManager = new SubagentTracker({
@@ -579,6 +583,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         toolProgressMap.clear();
         subagentManager.clear();
         reasoningTimingMap.clear();
+        canonicalMessageIds.clear();
     }
     function setThreadId(id, resetState) {
         if (resetState) {
@@ -782,6 +787,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         subjects.custom$.next([]);
         subjects.toolProgress$.next([]);
         toolProgressMap.clear();
+        canonicalMessageIds.clear();
         lastPayload = payload;
         lastOptions = opts;
         // Tracks whether at least one stream event has been processed this run.
@@ -881,7 +887,8 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             // Partial and message-tuple events are incremental. Merge them by id
             // so optimistic human messages and earlier tool messages are preserved.
             if (event.type === 'messages/partial' || event.messageMetadata) {
-                subjects.messages$.next(mergeMessages(subjects.messages$.value, normalized, reasoningTimingMap));
+                const mode = event.messageMetadata ? 'delta' : 'snapshot';
+                subjects.messages$.next(mergeMessages(subjects.messages$.value, normalized, reasoningTimingMap, mode, canonicalMessageIds));
                 if (isLgTraceEnabled()) {
                     const msgs = subjects.messages$.value;
                     const last = msgs[msgs.length - 1];
@@ -950,7 +957,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                         // drop the partial AI (or even the optimistic human) and
                         // tear down their DOM mid-stream. Merge by id keeps both,
                         // updates content where ids match, preserves the rest.
-                        subjects.messages$.next(mergeMessages(subjects.messages$.value, remapped, reasoningTimingMap));
+                        subjects.messages$.next(mergeMessages(subjects.messages$.value, remapped, reasoningTimingMap, 'snapshot', canonicalMessageIds));
                         if (isLgTraceEnabled()) {
                             lgTrace('bridge.values-sync', {
                                 incomingLength: stateMessages.length,
@@ -1360,7 +1367,7 @@ function collapseAdjacentAi(messages) {
     }
     return out;
 }
-function mergeMessages(existing, incoming, reasoningTimingMap) {
+function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot', canonicalMessageIds) {
     const merged = [...existing];
     for (const msg of incoming) {
         const rawIn = msg;
@@ -1400,6 +1407,13 @@ function mergeMessages(existing, incoming, reasoningTimingMap) {
             const existing = merged[idx];
             const existingId = existing['id'];
             const incomingRaw = msg;
+            const targetId = (existingId ?? incomingRaw['id']);
+            // Identity backstop: once a message's content is known-final, late
+            // streamed deltas for it are stale stragglers — ignore them outright.
+            if (mode === 'delta' && targetId && canonicalMessageIds?.has(targetId)
+                && !isFinalCanonicalReasoningContent(incomingRaw['content'])) {
+                continue;
+            }
             // Keep the *existing* id so downstream track-by-id sees stable identity.
             // For complex-content streaming (OpenAI gpt-5/o-series, Anthropic) the
             // SDK emits per-chunk *delta* arrays — not accumulated arrays — so a
@@ -1407,7 +1421,10 @@ function mergeMessages(existing, incoming, reasoningTimingMap) {
             // latest token. Accumulate text-bearing content across chunks here
             // and hand a string to consumers; downstream code already handles
             // string content uniformly.
-            const accumulatedContent = accumulateContent(existing.content, incomingRaw['content']);
+            const accumulatedContent = accumulateContent(existing.content, incomingRaw['content'], mode);
+            if (targetId && isFinalCanonicalReasoningContent(incomingRaw['content'])) {
+                canonicalMessageIds?.add(targetId);
+            }
             // Only accumulate reasoning when the incoming message explicitly carries
             // a `reasoning` field or complex-content array blocks with
             // type='reasoning'/'thinking'. Never use a plain string content value
@@ -1456,12 +1473,22 @@ function mergeMessages(existing, incoming, reasoningTimingMap) {
 }
 /**
  * Merge an incoming chunk's content into prior accumulated content for the
- * same message id.
+ * same message id. Behavior is governed by `mode`, which reflects the
+ * DECLARED kind of the source event rather than a guess from comparing text:
+ *
+ * - mode 'delta' (messages-tuple / `event.messageMetadata` truthy): the
+ *   payload is a genuine per-chunk delta. Append unconditionally — a
+ *   prefix-comparison "dedupe" here would silently drop legitimate tokens
+ *   that coincide with the message-so-far (e.g. every bare "|" while
+ *   streaming a markdown table). Staleness after the message goes canonical
+ *   is instead handled by identity in `mergeMessages` (canonicalMessageIds).
+ * - mode 'snapshot' (messages/partial, values-sync): the payload carries the
+ *   message-so-far, not a delta, so mutual prefix comparison picks the
+ *   longer state and ignores stale shorter snapshots.
  *
- * - string + string → concat (delta append)
- * - array + array  → concat extracted text from existing + incoming blocks
- * - array + string → use the string (server final-id swap)
- * - empty existing → use incoming as-is
+ * In both modes, a "final canonical" reasoning+text array (see
+ * `isFinalCanonicalReasoningContent`) always replaces whatever was
+ * accumulated — it's the authoritative final message, not another chunk.
  *
  * We deliberately collapse complex content arrays to a string at this layer.
  * The langgraph-sdk client does not accumulate complex-content arrays the
@@ -1493,7 +1520,7 @@ function isFinalCanonicalReasoningContent(content) {
     }
     return hasReasoning && hasText;
 }
-function accumulateContent(existing, incoming) {
+function accumulateContent(existing, incoming, mode = 'snapshot') {
     const existingText = extractText(existing);
     const incomingText = extractText(incoming);
     // Always return a string. We never want array content escaping the bridge:
@@ -1504,23 +1531,24 @@ function accumulateContent(existing, incoming) {
         return incomingText;
     if (incomingText.length === 0)
         return existingText;
-    // Incoming is a strict-superset of accumulated (final-id swap with full content).
+    // Final-canonical detection applies in both modes: the authoritative
+    // "reasoning + text" array replaces whatever was accumulated.
+    if (isFinalCanonicalReasoningContent(incoming))
+        return incomingText;
+    if (mode === 'delta') {
+        // Tuple chunks are declared deltas. Append unconditionally — any
+        // text-comparison "dedupe" here can silently drop legitimate tokens
+        // that coincide with the message prefix (e.g. every bare "|" in a
+        // markdown table). Staleness is handled by identity in mergeMessages.
+        return existingText + incomingText;
+    }
+    // Snapshot mode (messages/partial, values-sync): payloads carry the
+    // message-so-far, so mutual prefix comparison picks the longer state and
+    // ignores stale shorter snapshots.
     if (incomingText.startsWith(existingText))
         return incomingText;
-    // Existing already a strict-superset — chunk arrived after the canonical
-    // message merged in via values-sync. Keep what we have.
     if (existingText.startsWith(incomingText))
         return existingText;
-    // Final-canonical detection: when incoming is the "reasoning + text"
-    // array shape that ships the authoritative final message after a
-    // streaming run, replace the partial streamed accumulator with the
-    // canonical text instead of appending. Without this branch a small
-    // formatting difference between the streamed accumulator and the
-    // canonical text breaks the prefix checks above and visible content
-    // is duplicated (`existingText + incomingText`).
-    if (isFinalCanonicalReasoningContent(incoming))
-        return incomingText;
-    // Otherwise treat incoming as a delta and append.
     return existingText + incomingText;
 }
 function extractText(content) {