@assistant-ui/react-langchain 0.0.31 → 0.0.32

package/dist/attachSubagentTranscripts.d.ts

@@ -1,16 +1,24 @@
-import { ThreadMessage } from "@assistant-ui/core";
+import { ThreadMessage, ToolCallTiming } from "@assistant-ui/core";
 //#region src/attachSubagentTranscripts.d.ts
-type AttachedTranscript = readonly [string, readonly ThreadMessage[]];
+export type SubagentTranscript = {
+  readonly messages: readonly ThreadMessage[];
+  /**
+   * Only present when the client watched the task run: the discovery
+   * timestamps are stamped when the task call is first seen, so a thread
+   * seeded from a checkpoint would report a duration of zero.
+   */
+  readonly timing?: ToolCallTiming;
+};
+type AttachedTranscript = readonly [string, SubagentTranscript];
 type AttachedMessage = {
   transcripts: readonly AttachedTranscript[];
   attached: ThreadMessage;
 };
-type AttachMemo = {
+export type AttachMemo = {
   messages: WeakMap<ThreadMessage, AttachedMessage>;
   results: WeakMap<readonly ThreadMessage[], readonly ThreadMessage[]>;
 };
-declare const createAttachMemo: () => AttachMemo;
-declare const attachSubagentTranscripts: (messages: readonly ThreadMessage[], transcripts: ReadonlyMap<string, readonly ThreadMessage[]>, memo: AttachMemo) => readonly ThreadMessage[];
+export declare const createAttachMemo: () => AttachMemo;
+export declare const attachSubagentTranscripts: (messages: readonly ThreadMessage[], transcripts: ReadonlyMap<string, SubagentTranscript>, memo: AttachMemo) => readonly ThreadMessage[];
 //#endregion
-export { AttachMemo, attachSubagentTranscripts, createAttachMemo };
 //# sourceMappingURL=attachSubagentTranscripts.d.ts.map

package/dist/attachSubagentTranscripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attachSubagentTranscripts.d.ts","names":[],"sources":["../src/attachSubagentTranscripts.ts"],"mappings":";;KAMK,gDAAgD;KAEhD;EACH,sBAAsB;EACtB,UAAU;;KAGA;EACV,UAAU,QAAQ,eAAe;EACjC,SAAS,iBAAiB,0BAA0B;;cAGzC,wBAAuB;cAevB,4BACX,mBAAmB,iBACnB,aAAa,6BAA6B,kBAC1C,MAAM,wBACI"}
+{"version":3,"file":"attachSubagentTranscripts.d.ts","names":[],"sources":["../src/attachSubagentTranscripts.ts"],"mappings":";;YAOY;WACD,mBAAmB;;;;;;WAMnB,SAAS;;KAGf,uCAAuC;KAEvC;EACH,sBAAsB;EACtB,UAAU;;YAGA;EACV,UAAU,QAAQ,eAAe;EACjC,SAAS,iBAAiB,0BAA0B;;qBAGzC,wBAAuB;qBAevB,4BACX,mBAAmB,iBACnB,aAAa,oBAAoB,qBACjC,MAAM,wBACI"}

package/dist/attachSubagentTranscripts.js

@@ -15,10 +15,14 @@ const attachSubagentTranscripts = (messages, transcripts, memo) => {
 		if (cached && sameTranscripts(cached.transcripts, attachedTranscripts)) return cached.attached;
 		const attached = {
 			...message,
-			content: message.content.map((part) => part.type === "tool-call" && transcripts.has(part.toolCallId) ? {
-				...part,
-				messages: transcripts.get(part.toolCallId)
-			} : part)
+			content: message.content.map((part) => {
+				const transcript = part.type === "tool-call" ? transcripts.get(part.toolCallId) : void 0;
+				return transcript ? {
+					...part,
+					messages: transcript.messages,
+					...transcript.timing && { timing: transcript.timing }
+				} : part;
+			})
 		};
 		memo.messages.set(message, {
 			transcripts: attachedTranscripts,

package/dist/attachSubagentTranscripts.js.map

@@ -1 +1 @@
-{"version":3,"file":"attachSubagentTranscripts.js","names":[],"sources":["../src/attachSubagentTranscripts.ts"],"sourcesContent":["import {\n  bindExternalStoreMessage,\n  getExternalStoreMessages,\n  type ThreadMessage,\n} from \"@assistant-ui/core\";\n\ntype AttachedTranscript = readonly [string, readonly ThreadMessage[]];\n\ntype AttachedMessage = {\n  transcripts: readonly AttachedTranscript[];\n  attached: ThreadMessage;\n};\n\nexport type AttachMemo = {\n  messages: WeakMap<ThreadMessage, AttachedMessage>;\n  results: WeakMap<readonly ThreadMessage[], readonly ThreadMessage[]>;\n};\n\nexport const createAttachMemo = (): AttachMemo => ({\n  messages: new WeakMap(),\n  results: new WeakMap(),\n});\n\nconst sameTranscripts = (\n  a: readonly AttachedTranscript[],\n  b: readonly AttachedTranscript[],\n) =>\n  a.length === b.length &&\n  a.every(\n    ([toolCallId, transcript], index) =>\n      toolCallId === b[index]![0] && transcript === b[index]![1],\n  );\n\nexport const attachSubagentTranscripts = (\n  messages: readonly ThreadMessage[],\n  transcripts: ReadonlyMap<string, readonly ThreadMessage[]>,\n  memo: AttachMemo,\n): readonly ThreadMessage[] => {\n  let attachedAny = false;\n  const next = messages.map((message) => {\n    const attachedTranscripts = message.content.flatMap((part) =>\n      part.type === \"tool-call\" && transcripts.has(part.toolCallId)\n        ? [[part.toolCallId, transcripts.get(part.toolCallId)!] as const]\n        : [],\n    );\n    if (attachedTranscripts.length === 0) return message;\n    attachedAny = true;\n\n    const cached = memo.messages.get(message);\n    if (cached && sameTranscripts(cached.transcripts, attachedTranscripts))\n      return cached.attached;\n\n    const attached = {\n      ...message,\n      content: message.content.map((part) =>\n        part.type === \"tool-call\" && transcripts.has(part.toolCallId)\n          ? { ...part, messages: transcripts.get(part.toolCallId)! }\n          : part,\n      ),\n    } as ThreadMessage;\n    memo.messages.set(message, { transcripts: attachedTranscripts, attached });\n    return attached;\n  });\n\n  if (!attachedAny) return messages;\n  const previous = memo.results.get(messages);\n  if (previous && previous.every((message, index) => message === next[index]))\n    return previous;\n  bindExternalStoreMessage(next, getExternalStoreMessages({ messages }));\n  memo.results.set(messages, next);\n  return next;\n};\n"],"mappings":";;AAkBA,MAAa,0BAAsC;CACjD,0BAAU,IAAI,QAAQ;CACtB,yBAAS,IAAI,QAAQ;AACvB;AAEA,MAAM,mBACJ,GACA,MAEA,EAAE,WAAW,EAAE,UACf,EAAE,OACC,CAAC,YAAY,aAAa,UACzB,eAAe,EAAE,MAAM,CAAE,MAAM,eAAe,EAAE,MAAM,CAAE,EAC5D;AAEF,MAAa,6BACX,UACA,aACA,SAC6B;CAC7B,IAAI,cAAc;CAClB,MAAM,OAAO,SAAS,KAAK,YAAY;EACrC,MAAM,sBAAsB,QAAQ,QAAQ,SAAS,SACnD,KAAK,SAAS,eAAe,YAAY,IAAI,KAAK,UAAU,IACxD,CAAC,CAAC,KAAK,YAAY,YAAY,IAAI,KAAK,UAAU,CAAE,CAAU,IAC9D,CAAC,CACP;EACA,IAAI,oBAAoB,WAAW,GAAG,OAAO;EAC7C,cAAc;EAEd,MAAM,SAAS,KAAK,SAAS,IAAI,OAAO;EACxC,IAAI,UAAU,gBAAgB,OAAO,aAAa,mBAAmB,GACnE,OAAO,OAAO;EAEhB,MAAM,WAAW;GACf,GAAG;GACH,SAAS,QAAQ,QAAQ,KAAK,SAC5B,KAAK,SAAS,eAAe,YAAY,IAAI,KAAK,UAAU,IACxD;IAAE,GAAG;IAAM,UAAU,YAAY,IAAI,KAAK,UAAU;GAAG,IACvD,IACN;EACF;EACA,KAAK,SAAS,IAAI,SAAS;GAAE,aAAa;GAAqB;EAAS,CAAC;EACzE,OAAO;CACT,CAAC;CAED,IAAI,CAAC,aAAa,OAAO;CACzB,MAAM,WAAW,KAAK,QAAQ,IAAI,QAAQ;CAC1C,IAAI,YAAY,SAAS,OAAO,SAAS,UAAU,YAAY,KAAK,MAAM,GACxE,OAAO;CACT,yBAAyB,MAAM,yBAAyB,EAAE,SAAS,CAAC,CAAC;CACrE,KAAK,QAAQ,IAAI,UAAU,IAAI;CAC/B,OAAO;AACT"}
+{"version":3,"file":"attachSubagentTranscripts.js","names":[],"sources":["../src/attachSubagentTranscripts.ts"],"sourcesContent":["import {\n  bindExternalStoreMessage,\n  getExternalStoreMessages,\n  type ThreadMessage,\n  type ToolCallTiming,\n} from \"@assistant-ui/core\";\n\nexport type SubagentTranscript = {\n  readonly messages: readonly ThreadMessage[];\n  /**\n   * Only present when the client watched the task run: the discovery\n   * timestamps are stamped when the task call is first seen, so a thread\n   * seeded from a checkpoint would report a duration of zero.\n   */\n  readonly timing?: ToolCallTiming;\n};\n\ntype AttachedTranscript = readonly [string, SubagentTranscript];\n\ntype AttachedMessage = {\n  transcripts: readonly AttachedTranscript[];\n  attached: ThreadMessage;\n};\n\nexport type AttachMemo = {\n  messages: WeakMap<ThreadMessage, AttachedMessage>;\n  results: WeakMap<readonly ThreadMessage[], readonly ThreadMessage[]>;\n};\n\nexport const createAttachMemo = (): AttachMemo => ({\n  messages: new WeakMap(),\n  results: new WeakMap(),\n});\n\nconst sameTranscripts = (\n  a: readonly AttachedTranscript[],\n  b: readonly AttachedTranscript[],\n) =>\n  a.length === b.length &&\n  a.every(\n    ([toolCallId, transcript], index) =>\n      toolCallId === b[index]![0] && transcript === b[index]![1],\n  );\n\nexport const attachSubagentTranscripts = (\n  messages: readonly ThreadMessage[],\n  transcripts: ReadonlyMap<string, SubagentTranscript>,\n  memo: AttachMemo,\n): readonly ThreadMessage[] => {\n  let attachedAny = false;\n  const next = messages.map((message) => {\n    const attachedTranscripts = message.content.flatMap((part) =>\n      part.type === \"tool-call\" && transcripts.has(part.toolCallId)\n        ? [[part.toolCallId, transcripts.get(part.toolCallId)!] as const]\n        : [],\n    );\n    if (attachedTranscripts.length === 0) return message;\n    attachedAny = true;\n\n    const cached = memo.messages.get(message);\n    if (cached && sameTranscripts(cached.transcripts, attachedTranscripts))\n      return cached.attached;\n\n    const attached = {\n      ...message,\n      content: message.content.map((part) => {\n        const transcript =\n          part.type === \"tool-call\"\n            ? transcripts.get(part.toolCallId)\n            : undefined;\n        return transcript\n          ? {\n              ...part,\n              messages: transcript.messages,\n              ...(transcript.timing && { timing: transcript.timing }),\n            }\n          : part;\n      }),\n    } as ThreadMessage;\n    memo.messages.set(message, { transcripts: attachedTranscripts, attached });\n    return attached;\n  });\n\n  if (!attachedAny) return messages;\n  const previous = memo.results.get(messages);\n  if (previous && previous.every((message, index) => message === next[index]))\n    return previous;\n  bindExternalStoreMessage(next, getExternalStoreMessages({ messages }));\n  memo.results.set(messages, next);\n  return next;\n};\n"],"mappings":";;AA6BA,MAAa,0BAAsC;CACjD,0BAAU,IAAI,QAAQ;CACtB,yBAAS,IAAI,QAAQ;AACvB;AAEA,MAAM,mBACJ,GACA,MAEA,EAAE,WAAW,EAAE,UACf,EAAE,OACC,CAAC,YAAY,aAAa,UACzB,eAAe,EAAE,MAAM,CAAE,MAAM,eAAe,EAAE,MAAM,CAAE,EAC5D;AAEF,MAAa,6BACX,UACA,aACA,SAC6B;CAC7B,IAAI,cAAc;CAClB,MAAM,OAAO,SAAS,KAAK,YAAY;EACrC,MAAM,sBAAsB,QAAQ,QAAQ,SAAS,SACnD,KAAK,SAAS,eAAe,YAAY,IAAI,KAAK,UAAU,IACxD,CAAC,CAAC,KAAK,YAAY,YAAY,IAAI,KAAK,UAAU,CAAE,CAAU,IAC9D,CAAC,CACP;EACA,IAAI,oBAAoB,WAAW,GAAG,OAAO;EAC7C,cAAc;EAEd,MAAM,SAAS,KAAK,SAAS,IAAI,OAAO;EACxC,IAAI,UAAU,gBAAgB,OAAO,aAAa,mBAAmB,GACnE,OAAO,OAAO;EAEhB,MAAM,WAAW;GACf,GAAG;GACH,SAAS,QAAQ,QAAQ,KAAK,SAAS;IACrC,MAAM,aACJ,KAAK,SAAS,cACV,YAAY,IAAI,KAAK,UAAU,IAC/B,KAAA;IACN,OAAO,aACH;KACE,GAAG;KACH,UAAU,WAAW;KACrB,GAAI,WAAW,UAAU,EAAE,QAAQ,WAAW,OAAO;IACvD,IACA;GACN,CAAC;EACH;EACA,KAAK,SAAS,IAAI,SAAS;GAAE,aAAa;GAAqB;EAAS,CAAC;EACzE,OAAO;CACT,CAAC;CAED,IAAI,CAAC,aAAa,OAAO;CACzB,MAAM,WAAW,KAAK,QAAQ,IAAI,QAAQ;CAC1C,IAAI,YAAY,SAAS,OAAO,SAAS,UAAU,YAAY,KAAK,MAAM,GACxE,OAAO;CACT,yBAAyB,MAAM,yBAAyB,EAAE,SAAS,CAAC,CAAC;CACrE,KAAK,QAAQ,IAAI,UAAU,IAAI;CAC/B,OAAO;AACT"}

package/dist/convertMessages.d.ts

@@ -7,8 +7,8 @@ type LangChainMessageConverterMetadata = useExternalMessageConverter.Metadata &
   uiMessagesByParent?: Map<string, UIMessage[]>;
   messageTiming?: Record<string, MessageTiming>;
 };
-declare const getMessageType: (message: LangChainBaseMessage) => string;
-declare const convertLangChainBaseMessage: (message: LangChainBaseMessage, metadata?: LangChainMessageConverterMetadata) => useExternalMessageConverter.Message;
+export declare const getMessageType: (message: LangChainBaseMessage) => string;
+export declare const convertLangChainBaseMessage: (message: LangChainBaseMessage, metadata?: LangChainMessageConverterMetadata) => useExternalMessageConverter.Message;
 //#endregion
-export { convertLangChainBaseMessage, getMessageContent, getMessageType };
+export { getMessageContent };
 //# sourceMappingURL=convertMessages.d.ts.map

package/dist/convertMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertMessages.d.ts","names":[],"sources":["../src/convertMessages.ts"],"mappings":";;;;;KAiBK,oCACH,4BAA4B;EAC1B,qBAAqB,YAAY;EACjC,gBAAgB,eAAe;;cAetB,iBAAkB,SAAS;cAuC3B,8BACX,SAAS,sBACT,WAAU,sCACT,4BAA4B"}
+{"version":3,"file":"convertMessages.d.ts","names":[],"sources":["../src/convertMessages.ts"],"mappings":";;;;;KAiBK,oCACH,4BAA4B;EAC1B,qBAAqB,YAAY;EACjC,gBAAgB,eAAe;;qBAetB,iBAAkB,SAAS;qBAuC3B,8BACX,SAAS,sBACT,WAAU,sCACT,4BAA4B"}

package/dist/converter.d.ts

@@ -2,7 +2,7 @@ import { AppendMessage, DataMessagePart, ThreadAssistantMessage, ThreadUserMessa
 import { StreamingTimingAccessors } from "@assistant-ui/core/react";
 //#region src/converter.d.ts
 /** Known content block types from @langchain/core messages. */
-type LangChainContentBlock = {
+export type LangChainContentBlock = {
   type: "text";
   text: string;
 } | {
@@ -56,26 +56,26 @@ type LangChainContentBlock = {
   type: "tool_use" | "input_json_delta";
 };
 type ConvertedContentPart = ThreadUserMessage["content"][number] | ThreadAssistantMessage["content"][number];
-declare const convertLangChainContentBlock: (part: LangChainContentBlock) => ConvertedContentPart | null | undefined;
+export declare const convertLangChainContentBlock: (part: LangChainContentBlock) => ConvertedContentPart | null | undefined;
 /**
  * Audio output arrives outside the content array: providers leave `content`
  * empty and put the spoken text in `additional_kwargs.audio.transcript`. The
  * audio bytes stay behind because no provider reports their media type, and a
  * streamed response carries raw PCM rather than a playable file.
  */
-declare const withAudioTranscript: <T extends {
+export declare const withAudioTranscript: <T extends {
   type: string;
   text?: unknown;
 }>(parts: readonly T[], additionalKwargs: Record<string, unknown> | undefined) => readonly (T | {
   type: "text";
   text: string;
 })[];
-declare const getCustomMetadata: (additionalKwargs: Record<string, unknown> | undefined) => Record<string, unknown>;
-declare const uiMessageToDataPart: <TUIMessage extends {
+export declare const getCustomMetadata: (additionalKwargs: Record<string, unknown> | undefined) => Record<string, unknown>;
+export declare const uiMessageToDataPart: <TUIMessage extends {
   name: string;
   props: Record<string, unknown>;
 }>(ui: TUIMessage) => DataMessagePart;
-declare const getMessageContent: (msg: AppendMessage) => string | ({
+export declare const getMessageContent: (msg: AppendMessage) => string | ({
   type: "text";
   text: string;
   image_url?: never;
@@ -150,7 +150,7 @@ declare const getMessageContent: (msg: AppendMessage) => string | ({
   metadata?: never;
   url?: never;
 })[];
-declare const createLangChainStreamingTimingAccessors: <TMessage extends {
+export declare const createLangChainStreamingTimingAccessors: <TMessage extends {
   id?: string | undefined;
   content?: unknown;
   tool_calls?: readonly unknown[] | undefined;
@@ -159,7 +159,7 @@ declare const createLangChainStreamingTimingAccessors: <TMessage extends {
  * Resolve the assistant message a `UIMessage` belongs to: the parent id comes
  * from `metadata.message_id` (Python SDK) or `metadata.id` (JS SDK).
  */
-declare const getUIMessageParentId: (ui: {
+export declare const getUIMessageParentId: (ui: {
   metadata?: {
     message_id?: string;
     id?: string;
@@ -169,12 +169,11 @@ declare const getUIMessageParentId: (ui: {
  * Group the graph's accumulated `UIMessage`s by the assistant message they
  * belong to. Non-array state and entries without a parent link are dropped.
  */
-declare const groupUIMessagesByParent: <T extends {
+export declare const groupUIMessagesByParent: <T extends {
   metadata?: {
     message_id?: string;
     id?: string;
   } | undefined;
 }>(value: unknown) => Map<string, T[]>;
 //#endregion
-export { LangChainContentBlock, convertLangChainContentBlock, createLangChainStreamingTimingAccessors, getCustomMetadata, getMessageContent, getUIMessageParentId, groupUIMessagesByParent, uiMessageToDataPart, withAudioTranscript };
 //# sourceMappingURL=converter.d.ts.map

package/dist/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","names":[],"sources":["../src/converter.ts"],"mappings":";;;;KAaY;EACN;EAAc;;EACd;EAAoB;;EACpB;EAAmB;IAAsB;;;EACzC;EAAkB;;EAElB;EACA,UAAU;IAAQ;IAAsB;;EACxC;;EAGA;EACA;EACA;EACA;EACA;IAAa;;;EAGb;EACA;EACA;EACA;EACA;IAAa;;;EAGb;EACA;EACA;EACA;EACA;IAAa;;;EAGb;EACA;EACA;EACA;;EAEA;;KAED,uBACD,uCACA;cAES,+BACX,MAAM,0BACL;;;;;;;cAqEU,sBAAuB;EAAY;EAAc;GAC5D,gBAAgB,KAChB,kBAAkB,kDACP;EAAM;EAAc;;cAapB,oBACX,kBAAkB,wCACjB;cAGU,sBACX;EAAqB;EAAc,OAAO;GAE1C,IAAI,eACH;cAoBU,oBAAqB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuG1B,0CACX;EACE;EACA;EACA;GAGF,UAAU,SAAS,wBAClB,yBAAyB;;;;;cA+Df,uBAAwB;EACnC;IAAa;IAAqB;;;;;;;cAOvB,0BACX;EACE;IAAa;IAAqB;;GAGpC,mBACC,YAAY"}
+{"version":3,"file":"converter.d.ts","names":[],"sources":["../src/converter.ts"],"mappings":";;;;YAaY;EACN;EAAc;;EACd;EAAoB;;EACpB;EAAmB;IAAsB;;;EACzC;EAAkB;;EAElB;EACA,UAAU;IAAQ;IAAsB;;EACxC;;EAGA;EACA;EACA;EACA;EACA;IAAa;;;EAGb;EACA;EACA;EACA;EACA;IAAa;;;EAGb;EACA;EACA;EACA;EACA;IAAa;;;EAGb;EACA;EACA;EACA;;EAEA;;KAED,uBACD,uCACA;qBAES,+BACX,MAAM,0BACL;;;;;;;qBAqEU,sBAAuB;EAAY;EAAc;GAC5D,gBAAgB,KAChB,kBAAkB,kDACP;EAAM;EAAc;;qBAapB,oBACX,kBAAkB,wCACjB;qBAGU,sBACX;EAAqB;EAAc,OAAO;GAE1C,IAAI,eACH;qBAoBU,oBAAqB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuG1B,0CACX;EACE;EACA;EACA;GAGF,UAAU,SAAS,wBAClB,yBAAyB;;;;;qBA+Df,uBAAwB;EACnC;IAAa;IAAqB;;;;;;;qBAOvB,0BACX;EACE;IAAa;IAAqB;;GAGpC,mBACC,YAAY"}

package/dist/findForkCheckpointInHistory.d.ts

@@ -11,7 +11,7 @@ type ForkHistoryCursor = {
     checkpoint_id: string;
   };
 };
-type ForkCheckpointClient = {
+export type ForkCheckpointClient = {
   threads: {
     getHistory: (threadId: string, options?: {
       limit?: number;
@@ -19,7 +19,6 @@ type ForkCheckpointClient = {
     }) => Promise<readonly ForkCheckpointHistoryState[]>;
   };
 };
-declare const findForkCheckpointInHistory: (client: ForkCheckpointClient, threadId: string, messagesUpToParent: readonly LangChainBaseMessage[], messagesKey: string, pageSize?: number) => Promise<string | null>;
+export declare const findForkCheckpointInHistory: (client: ForkCheckpointClient, threadId: string, messagesUpToParent: readonly LangChainBaseMessage[], messagesKey: string, pageSize?: number) => Promise<string | null>;
 //#endregion
-export { ForkCheckpointClient, findForkCheckpointInHistory };
 //# sourceMappingURL=findForkCheckpointInHistory.d.ts.map

package/dist/findForkCheckpointInHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findForkCheckpointInHistory.d.ts","names":[],"sources":["../src/findForkCheckpointInHistory.ts"],"mappings":";;KAEK;EACH,SAAS;EACT;IAAe;;;KAGZ;EAAsB;IAAgB;;;KAE/B;EACV;IACE,aACE,kBACA;MAAY;MAAgB,SAAS;UAClC,iBAAiB;;;cAIb,8BACX,QAAQ,sBACR,kBACA,6BAA6B,wBAC7B,qBACA,sBACC"}
+{"version":3,"file":"findForkCheckpointInHistory.d.ts","names":[],"sources":["../src/findForkCheckpointInHistory.ts"],"mappings":";;KAEK;EACH,SAAS;EACT;IAAe;;;KAGZ;EAAsB;IAAgB;;;YAE/B;EACV;IACE,aACE,kBACA;MAAY;MAAgB,SAAS;UAClC,iBAAiB;;;qBAIb,8BACX,QAAQ,sBACR,kBACA,6BAA6B,wBAC7B,qBACA,sBACC"}

package/dist/hooks.d.ts

@@ -4,7 +4,7 @@ import { AssembledToolCall, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot
 /**
  * Read the current LangGraph interrupt state from the runtime extras.
  */
-declare const useLangChainInterruptState: () => {
+export declare const useLangChainInterruptState: () => {
   value?: unknown;
 } | undefined;
 /**
@@ -12,55 +12,55 @@ declare const useLangChainInterruptState: () => {
  * and `value`. Defaults to an empty array. Pair with `useLangChainRespondAll`
  * (keyed by interrupt id) to resolve several at once.
  */
-declare const useLangChainInterrupts: () => readonly {
+export declare const useLangChainInterrupts: () => readonly {
   id?: string;
   value?: unknown;
 }[];
 /** Read the last run/hydration error from the runtime extras. */
-declare const useLangChainError: () => unknown;
+export declare const useLangChainError: () => unknown;
 /**
  * Read the root tool calls assembled by `useStream` from the `tools`
  * channel. Defaults to an empty array, so consumers can `.map` without
  * a guard. Useful for rendering pending/streamed tool calls and
  * approval UIs.
  */
-declare const useLangChainToolCalls: () => readonly AssembledToolCall<string, unknown, unknown>[];
+export declare const useLangChainToolCalls: () => readonly AssembledToolCall<string, unknown, unknown>[];
 /** Subagents discovered on the current run (multi-agent graphs). */
-declare const useLangChainSubagents: () => ReadonlyMap<string, SubagentDiscoverySnapshot>;
+export declare const useLangChainSubagents: () => ReadonlyMap<string, SubagentDiscoverySnapshot>;
 /** Subgraphs discovered on the current run. */
-declare const useLangChainSubgraphs: () => ReadonlyMap<string, SubgraphDiscoverySnapshot>;
+export declare const useLangChainSubgraphs: () => ReadonlyMap<string, SubgraphDiscoverySnapshot>;
 /**
  * The underlying `useStream` handle, for advanced views — pass it to v1's
  * `useMessages(stream, target)` / `useToolCalls(stream, target)` with a
  * subagent/subgraph from `useLangChainSubagents` / `useLangChainSubgraphs`.
  * `undefined` outside the runtime provider.
  */
-declare const useLangChainStream: () => import("@langchain/react").AnyStream | undefined;
+export declare const useLangChainStream: () => import("@langchain/react").AnyStream | undefined;
 /**
  * Returns a function to submit raw state updates to the LangGraph agent,
  * bypassing the normal message flow. Useful for sending interrupt resume
  * commands.
  */
-declare const useLangChainSubmit: () => (values: Record<string, unknown> | null | undefined, options?: Record<string, unknown>) => Promise<void>;
+export declare const useLangChainSubmit: () => (values: Record<string, unknown> | null | undefined, options?: Record<string, unknown>) => Promise<void>;
 /**
  * Resume a LangGraph interrupt with a response payload via
  * `useStream().respond`. Preferred over `useLangChainSendCommand`; it
  * carries the response cleanly and handles interrupt namespaces.
  */
-declare const useLangChainRespond: () => (response: unknown, options?: Record<string, unknown>) => Promise<void>;
+export declare const useLangChainRespond: () => (response: unknown, options?: Record<string, unknown>) => Promise<void>;
 /**
  * Resume several LangGraph interrupts pending at the same checkpoint in
  * one run via `useStream().respondAll`. Use when a run pauses on multiple
  * interrupts at once; sequential `useLangChainRespond` calls can't service
  * them (the first resume starts a run, stranding the rest).
  */
-declare const useLangChainRespondAll: () => (responsesById: Record<string, unknown>, options?: Record<string, unknown>) => Promise<void>;
+export declare const useLangChainRespondAll: () => (responsesById: Record<string, unknown>, options?: Record<string, unknown>) => Promise<void>;
 /**
  * Submit a list of LangChain-shaped messages on the current thread.
  * Parity helper for migrating from `useLangGraphSend`. Routes to
  * `useStream().submit({ [messagesKey]: messages }, options)`.
  */
-declare const useLangChainSend: () => (messages: readonly LangChainBaseMessage[], options?: Record<string, unknown>) => Promise<void>;
+export declare const useLangChainSend: () => (messages: readonly LangChainBaseMessage[], options?: Record<string, unknown>) => Promise<void>;
 /**
  * Submit a `useStream` command (e.g. interrupt resume). Parity helper
  * for migrating from `useLangGraphSendCommand`. Note that v1's command
@@ -68,7 +68,7 @@ declare const useLangChainSend: () => (messages: readonly LangChainBaseMessage[]
  * `{ resume: string }` form; to carry a payload, use the input or
  * `stream.respond` instead.
  */
-declare const useLangChainSendCommand: () => (command: Record<string, unknown>) => Promise<void>;
+export declare const useLangChainSendCommand: () => (command: Record<string, unknown>) => Promise<void>;
 /**
  * Read a custom LangGraph state key from the current thread. Mirrors
  * `useStream().values[key]` from `@langchain/react` and updates when the
@@ -80,8 +80,7 @@ declare const useLangChainSendCommand: () => (command: Record<string, unknown>)
  * const files = useLangChainState<Record<string, string>>("files", {});
  * ```
  */
-declare function useLangChainState<T>(key: string): T | undefined;
-declare function useLangChainState<T>(key: string, defaultValue: T): T;
+export declare function useLangChainState<T>(key: string): T | undefined;
+export declare function useLangChainState<T>(key: string, defaultValue: T): T;
 //#endregion
-export { useLangChainError, useLangChainInterruptState, useLangChainInterrupts, useLangChainRespond, useLangChainRespondAll, useLangChainSend, useLangChainSendCommand, useLangChainState, useLangChainStream, useLangChainSubagents, useLangChainSubgraphs, useLangChainSubmit, useLangChainToolCalls };
 //# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"mappings":";;;;;;cAwBa;EAAA;;;;;;;cAQA;EAAA;EAAA;;;cAOA;;;;;;;cASA,sCAAqB;;cAIrB,6BAAqB,oBAAA;;cAIrB,6BAAqB,oBAAA;;;;;;;cASrB,qDAAkB;;;;;;cAQlB,2BAGT,QAAQ,4CACR,UAAU,4BAAuB;;;;;;cASxB,4BAEH,mBAAmB,UAAU,4BAAuB;;;;;;;cAUjD,+BAGT,eAAe,yBACf,UAAU,4BAAuB;;;;;;cASxB,yBAGT,mBAAmB,wBACnB,UAAU,4BAAuB;;;;;;;;cAcxB,gCAEH,SAAS,4BAAuB;;;;;;;;;;;;iBAc1B,kBAAkB,GAAG,cAAc;iBACnC,kBAAkB,GAAG,aAAa,cAAc,IAAI"}
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"mappings":";;;;;;qBAwBa;EAAA;;;;;;;qBAQA;EAAA;EAAA;;;qBAOA;;;;;;;qBASA,sCAAqB;;qBAIrB,6BAAqB,oBAAA;;qBAIrB,6BAAqB,oBAAA;;;;;;;qBASrB,qDAAkB;;;;;;qBAQlB,2BAGT,QAAQ,4CACR,UAAU,4BAAuB;;;;;;qBASxB,4BAEH,mBAAmB,UAAU,4BAAuB;;;;;;;qBAUjD,+BAGT,eAAe,yBACf,UAAU,4BAAuB;;;;;;qBASxB,yBAGT,mBAAmB,wBACnB,UAAU,4BAAuB;;;;;;;;qBAcxB,gCAEH,SAAS,4BAAuB;;;;;;;;;;;;wBAc1B,kBAAkB,GAAG,cAAc;wBACnC,kBAAkB,GAAG,aAAa,cAAc,IAAI"}

package/dist/resolveForkCheckpoint.d.ts

@@ -10,7 +10,6 @@ type MessageMetadataSnapshot = ReadonlyMap<string, {
  * server history by message id. A `null` `parentId` edits the first human
  * message and forks from the thread's initial (empty-message) checkpoint.
  */
-declare const resolveForkCheckpoint: (client: ForkCheckpointClient, threadId: string, messages: readonly LangChainBaseMessage[], parentId: string | null, sourceId: string | null | undefined, metadata: MessageMetadataSnapshot, messagesKey: string) => Promise<string | null>;
+export declare const resolveForkCheckpoint: (client: ForkCheckpointClient, threadId: string, messages: readonly LangChainBaseMessage[], parentId: string | null, sourceId: string | null | undefined, metadata: MessageMetadataSnapshot, messagesKey: string) => Promise<string | null>;
 //#endregion
-export { resolveForkCheckpoint };
 //# sourceMappingURL=resolveForkCheckpoint.d.ts.map

package/dist/resolveForkCheckpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveForkCheckpoint.d.ts","names":[],"sources":["../src/resolveForkCheckpoint.ts"],"mappings":";;;KAMK,0BACD;WAA+B;;;;;;;;cAStB,wBACX,QAAQ,sBACR,kBACA,mBAAmB,wBACnB,yBACA,qCACA,UAAU,yBACV,wBACC"}
+{"version":3,"file":"resolveForkCheckpoint.d.ts","names":[],"sources":["../src/resolveForkCheckpoint.ts"],"mappings":";;;KAMK,0BACD;WAA+B;;;;;;;;qBAStB,wBACX,QAAQ,sBACR,kBACA,mBAAmB,wBACnB,yBACA,qCACA,UAAU,yBACV,wBACC"}

package/dist/runtimeExtras.d.ts

@@ -1,6 +1,5 @@
 import { LangChainRuntimeExtras } from "./types.js";
 //#region src/runtimeExtras.d.ts
-declare const langChainExtras: import("@assistant-ui/core/react").RuntimeExtras<LangChainRuntimeExtras>;
+export declare const langChainExtras: import("@assistant-ui/core/react").RuntimeExtras<LangChainRuntimeExtras>;
 //#endregion
-export { langChainExtras };
 //# sourceMappingURL=runtimeExtras.d.ts.map

package/dist/runtimeExtras.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeExtras.d.ts","names":[],"sources":["../src/runtimeExtras.ts"],"mappings":";;cAGa,oDAAe,cAAA"}
+{"version":3,"file":"runtimeExtras.d.ts","names":[],"sources":["../src/runtimeExtras.ts"],"mappings":";;qBAGa,oDAAe,cAAA"}

package/dist/sdkIdentity.d.ts

@@ -1,6 +1,5 @@
 import { SdkIdentity } from "assistant-cloud";
 //#region src/sdkIdentity.d.ts
-declare const LANGCHAIN_SDK: SdkIdentity;
+export declare const LANGCHAIN_SDK: SdkIdentity;
 //#endregion
-export { LANGCHAIN_SDK };
 //# sourceMappingURL=sdkIdentity.d.ts.map

package/dist/sdkIdentity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdkIdentity.d.ts","names":[],"sources":["../src/sdkIdentity.ts"],"mappings":";;cAEa,eAAe"}
+{"version":3,"file":"sdkIdentity.d.ts","names":[],"sources":["../src/sdkIdentity.ts"],"mappings":";;qBAEa,eAAe"}

package/dist/sdkIdentity.js

@@ -1,7 +1,7 @@
 //#region src/sdkIdentity.ts
 const LANGCHAIN_SDK = {
 	name: "@assistant-ui/react-langchain",
-	version: "0.0.31"
+	version: "0.0.32"
 };
 //#endregion
 export { LANGCHAIN_SDK };

package/dist/streamingTiming.d.ts

@@ -1,14 +1,13 @@
 import { LangChainBaseMessage } from "./types.js";
 import { MessageTiming } from "@assistant-ui/core";
 //#region src/streamingTiming.d.ts
-declare const langChainStreamingTimingAccessors: import("@assistant-ui/core").StreamingTimingAccessors<LangChainBaseMessage>;
+export declare const langChainStreamingTimingAccessors: import("@assistant-ui/core").StreamingTimingAccessors<LangChainBaseMessage>;
 /**
  * Tracks per-message streaming timing for LangChain messages. Delegates to
  * the shared `useStreamingTiming` primitive in `@assistant-ui/core/react`,
  * adapted to the `LangChainBaseMessage` shape (`_getType() -> "ai"`, content
  * blocks including text/thinking/reasoning, `tool_calls`).
  */
-declare const useLangChainStreamingTiming: (messages: readonly LangChainBaseMessage[], isRunning: boolean) => Record<string, MessageTiming>;
+export declare const useLangChainStreamingTiming: (messages: readonly LangChainBaseMessage[], isRunning: boolean) => Record<string, MessageTiming>;
 //#endregion
-export { langChainStreamingTimingAccessors, useLangChainStreamingTiming };
 //# sourceMappingURL=streamingTiming.d.ts.map

package/dist/streamingTiming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamingTiming.d.ts","names":[],"sources":["../src/streamingTiming.ts"],"mappings":";;;cAQa,gEAAiC,yBAAA;;;;;;;cASjC,8BACX,mBAAmB,wBACnB,uBACC,eAAe"}
+{"version":3,"file":"streamingTiming.d.ts","names":[],"sources":["../src/streamingTiming.ts"],"mappings":";;;qBAQa,gEAAiC,yBAAA;;;;;;;qBASjC,8BACX,mBAAmB,wBACnB,uBACC,eAAe"}

package/dist/types.d.ts

@@ -3,7 +3,7 @@ import { AttachmentAdapter, DictationAdapter, ExternalStoreSharedOptions, Feedba
 import { AnyStream, AssembledToolCall, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions } from "@langchain/react";
 import { AssistantCloud } from "assistant-cloud";
 //#region src/types.d.ts
-type LangChainToolCall = {
+export type LangChainToolCall = {
   id: string;
   name: string;
   args: Record<string, unknown>;
@@ -15,7 +15,7 @@ type LangChainToolCall = {
  * The parent assistant message is carried in `metadata.message_id` by the
  * Python SDK and in `metadata.id` by the JS SDK; the runtime reads either.
  */
-type UIMessage<TName extends string = string, TProps extends Record<string, unknown> = Record<string, unknown>> = {
+export type UIMessage<TName extends string = string, TProps extends Record<string, unknown> = Record<string, unknown>> = {
   type: "ui";
   id: string;
   name: TName;
@@ -34,7 +34,7 @@ type UIMessage<TName extends string = string, TProps extends Record<string, unkn
  * Emitted on the live `custom` channel by the graph's `remove_ui_message`
  * helper to drop a pushed `UIMessage` by id.
  */
-type RemoveUIMessage = {
+export type RemoveUIMessage = {
   type: "remove-ui";
   id: string;
 };
@@ -45,7 +45,7 @@ type RemoveUIMessage = {
  * Uses `unknown` for `content` to remain compatible with
  * `@langchain/core`'s `MessageContent` union.
  */
-type LangChainBaseMessage = {
+export type LangChainBaseMessage = {
   _getType: () => string;
   content: unknown;
   id?: string | undefined;
@@ -60,7 +60,7 @@ type LangChainBaseMessage = {
   /** Present on ToolMessage */
   artifact?: unknown;
 };
-type LangChainRuntimeExtras = {
+export type LangChainRuntimeExtras = {
   interrupt: {
     value?: unknown;
   } | undefined;
@@ -79,7 +79,7 @@ type LangChainRuntimeExtras = {
   values: Record<string, unknown>;
   messagesKey: string;
 };
-type LangChainRuntimeExtraOptions = ExternalStoreSharedOptions & {
+export type LangChainRuntimeExtraOptions = ExternalStoreSharedOptions & {
   /**
    * Called whenever the active thread's canonical (remote) ID changes, so the
    * value can be treated as a managed/controlled variable (e.g. synced to a URL
@@ -128,7 +128,7 @@ type LangChainRuntimeExtraOptions = ExternalStoreSharedOptions & {
    */
   uiStateKey?: string | undefined;
 };
-type UseStreamRuntimeOptions = UseStreamOptions extends (infer O) ? O extends UseStreamOptions ? O & LangChainRuntimeExtraOptions : never : never;
+export type UseStreamRuntimeOptions = UseStreamOptions extends (infer O) ? O extends UseStreamOptions ? O & LangChainRuntimeExtraOptions : never : never;
 //#endregion
-export { LangChainBaseMessage, type LangChainContentBlock, LangChainRuntimeExtraOptions, LangChainRuntimeExtras, LangChainToolCall, RemoveUIMessage, UIMessage, UseStreamRuntimeOptions };
+export type { LangChainContentBlock };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;KAqBY;EACV;EACA;EACA,MAAM;;;;;;;;;KAUI,UACV,+BACA,eAAe,0BAA0B;EAEzC;EACA;EACA,MAAM;EACN,OAAO;EACP;IACE;IACA;IACA;IACA;IACA;IACA;KACC;;;;;;;KAQO;EACV;EACA;;;;;;;;;KAUU;EACV;EACA;EACA;EACA;EACA,oBAAoB;;EAEpB,sBAAsB;;EAEtB;;EAEA,SAAS;;EAET;;KAGU;EACV;IAAa;;EACb;IAAuB;IAAa;;EACpC,oBAAoB;EACpB,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,QAAQ;EACR;EACA,SACE,QAAQ,4CACR,UAAU,4BACP;EACL,UACE,mBACA,UAAU,4BACP;EACL,aACE,eAAe,yBACf,UAAU,4BACP;EACL,QAAQ;EACR;;KAGU,+BAA+B;;;;;;;;;EASzC,qBAAqB;EACrB,QAAQ;EACR;IAEM,cAAc;IACd,SAAS;IACT,YAAY;IACZ,QAAQ;IACR,WAAW;;;;;;;;EASjB;;;;;EAKA;;;;;EAKA,6BAA6B;;EAE7B,gBAAgB;IAAU;;;EAE1B,WAAW,qBAAqB;;;;;;;EAOhC;;KAOU,0BAA0B,gCAA+B,KACjE,UAAU,mBACR,IAAI"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;YAqBY;EACV;EACA;EACA,MAAM;;;;;;;;;YAUI,UACV,+BACA,eAAe,0BAA0B;EAEzC;EACA;EACA,MAAM;EACN,OAAO;EACP;IACE;IACA;IACA;IACA;IACA;IACA;KACC;;;;;;;YAQO;EACV;EACA;;;;;;;;;YAUU;EACV;EACA;EACA;EACA;EACA,oBAAoB;;EAEpB,sBAAsB;;EAEtB;;EAEA,SAAS;;EAET;;YAGU;EACV;IAAa;;EACb;IAAuB;IAAa;;EACpC,oBAAoB;EACpB,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,QAAQ;EACR;EACA,SACE,QAAQ,4CACR,UAAU,4BACP;EACL,UACE,mBACA,UAAU,4BACP;EACL,aACE,eAAe,yBACf,UAAU,4BACP;EACL,QAAQ;EACR;;YAGU,+BAA+B;;;;;;;;;EASzC,qBAAqB;EACrB,QAAQ;EACR;IAEM,cAAc;IACd,SAAS;IACT,YAAY;IACZ,QAAQ;IACR,WAAW;;;;;;;;EASjB;;;;;EAKA;;;;;EAKA,6BAA6B;;EAE7B,gBAAgB;IAAU;;;EAE1B,WAAW,qBAAqB;;;;;;;EAOhC;;YAOU,0BAA0B,gCAA+B,KACjE,UAAU,mBACR,IAAI"}

package/dist/uiMessages.d.ts

@@ -1,15 +1,31 @@
 import { RemoveUIMessage, UIMessage } from "./types.js";
+import { Channel } from "@langchain/react";
 //#region src/uiMessages.d.ts
-type UIUpdate = UIMessage | RemoveUIMessage;
-declare const isUIUpdate: (value: unknown) => value is UIUpdate | readonly UIUpdate[];
-declare const applyUIUpdate: (list: readonly UIMessage[], update: UIUpdate | readonly UIUpdate[]) => UIMessage[];
+/** Channels the generative-UI fold reads, at the root and per subagent. */
+export declare const UI_CUSTOM_CHANNELS: readonly Channel[];
+export type UIUpdate = UIMessage | RemoveUIMessage;
+export declare const isUIUpdate: (value: unknown) => value is UIUpdate | readonly UIUpdate[];
+export declare const applyUIUpdate: (list: readonly UIMessage[], update: UIUpdate | readonly UIUpdate[]) => UIMessage[];
 /**
  * Pulls a UI update out of a raw `custom`-channel event. The graph writes the
  * `UIMessage` straight to the channel, so it lands at `params.data`; some
  * transports wrap it one level deeper at `params.data.payload`.
  */
-declare const extractUIUpdate: (event: unknown) => UIUpdate | readonly UIUpdate[] | undefined;
-declare const foldUIUpdates: (events: readonly unknown[]) => UIMessage[];
+export declare const extractUIUpdate: (event: unknown) => UIUpdate | readonly UIUpdate[] | undefined;
+export type UIFoldMemo = {
+  events: readonly unknown[];
+  messages: UIMessage[];
+};
+export declare const createUIFoldMemo: () => UIFoldMemo;
+/**
+ * Folds `custom`-channel events into UI messages, continuing the fold held in
+ * `memo`. The channel buffer holds each event object once, appends new events
+ * and drops its oldest ones once full, so only events after the previously
+ * folded last event are applied, and entries no later event touches keep
+ * their identity. A buffer that no longer contains that event was replaced
+ * and is folded from scratch.
+ */
+export declare const foldUIUpdates: (events: readonly unknown[], memo?: UIFoldMemo) => UIMessage[];
 /**
  * Merges live-streamed UI with the state snapshot. The snapshot is
  * authoritative by id: once a UI lands in graph state it supersedes its live
@@ -17,7 +33,6 @@ declare const foldUIUpdates: (events: readonly unknown[]) => UIMessage[];
  * snapshot still contains that id; the removal only takes visible effect once
  * the snapshot catches up.
  */
-declare const mergeUIMessages: (live: readonly UIMessage[], snapshot: unknown) => UIMessage[];
+export declare const mergeUIMessages: (live: readonly UIMessage[], snapshot: unknown) => UIMessage[];
 //#endregion
-export { UIUpdate, applyUIUpdate, extractUIUpdate, foldUIUpdates, isUIUpdate, mergeUIMessages };
 //# sourceMappingURL=uiMessages.d.ts.map

package/dist/uiMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uiMessages.d.ts","names":[],"sources":["../src/uiMessages.ts"],"mappings":";;KAEY,WAAW,YAAY;cAEtB,aACX,mBACC,SAAS,oBAAoB;cAmBnB,gBACX,eAAe,aACf,QAAQ,oBAAoB,eAC3B;;;;;;cA0BU,kBACX,mBACC,oBAAoB;cAQV,gBAAiB,+BAA6B;;;;;;;;cAgB9C,kBACX,eAAe,aACf,sBACC"}
+{"version":3,"file":"uiMessages.d.ts","names":[],"sources":["../src/uiMessages.ts"],"mappings":";;;;qBAIa,6BAA6B;YAE9B,WAAW,YAAY;qBAEtB,aACX,mBACC,SAAS,oBAAoB;qBAmBnB,gBACX,eAAe,aACf,QAAQ,oBAAoB,eAC3B;;;;;;qBA0BU,kBACX,mBACC,oBAAoB;YAQX;EACV;EACA,UAAU;;qBAGC,wBAAuB;;;;;;;;;qBAavB,gBACX,4BACA,OAAM,eACL;;;;;;;;qBAuBU,kBACX,eAAe,aACf,sBACC"}

package/dist/uiMessages.js

@@ -1,4 +1,6 @@
 //#region src/uiMessages.ts
+/** Channels the generative-UI fold reads, at the root and per subagent. */
+const UI_CUSTOM_CHANNELS = ["custom"];
 const isUIUpdate = (value) => {
 	if (Array.isArray(value)) return value.length > 0 && value.every(isUIUpdate);
 	if (value == null || typeof value !== "object") return false;
@@ -41,12 +43,28 @@ const extractUIUpdate = (event) => {
 	const payload = data?.payload;
 	if (isUIUpdate(payload)) return payload;
 };
-const foldUIUpdates = (events) => {
-	let acc = [];
-	for (const event of events) {
-		const update = extractUIUpdate(event);
+const createUIFoldMemo = () => ({
+	events: [],
+	messages: []
+});
+/**
+* Folds `custom`-channel events into UI messages, continuing the fold held in
+* `memo`. The channel buffer holds each event object once, appends new events
+* and drops its oldest ones once full, so only events after the previously
+* folded last event are applied, and entries no later event touches keep
+* their identity. A buffer that no longer contains that event was replaced
+* and is folded from scratch.
+*/
+const foldUIUpdates = (events, memo = createUIFoldMemo()) => {
+	const previous = memo.events;
+	const resumeAt = previous.length === 0 ? 0 : events.lastIndexOf(previous.at(-1), previous.length - 1) + 1;
+	let acc = previous.length > 0 && resumeAt === 0 ? [] : memo.messages;
+	for (let i = resumeAt; i < events.length; i++) {
+		const update = extractUIUpdate(events[i]);
 		if (update) acc = applyUIUpdate(acc, update);
 	}
+	memo.events = events;
+	memo.messages = acc;
 	return acc;
 };
 /**
@@ -63,6 +81,6 @@ const mergeUIMessages = (live, snapshot) => {
 	return [...byId.values()];
 };
 //#endregion
-export { applyUIUpdate, extractUIUpdate, foldUIUpdates, isUIUpdate, mergeUIMessages };
+export { UI_CUSTOM_CHANNELS, applyUIUpdate, createUIFoldMemo, extractUIUpdate, foldUIUpdates, isUIUpdate, mergeUIMessages };
 
 //# sourceMappingURL=uiMessages.js.map

package/dist/uiMessages.js.map

@@ -1 +1 @@
-{"version":3,"file":"uiMessages.js","names":[],"sources":["../src/uiMessages.ts"],"sourcesContent":["import type { RemoveUIMessage, UIMessage } from \"./types\";\n\nexport type UIUpdate = UIMessage | RemoveUIMessage;\n\nexport const isUIUpdate = (\n  value: unknown,\n): value is UIUpdate | readonly UIUpdate[] => {\n  if (Array.isArray(value)) return value.length > 0 && value.every(isUIUpdate);\n  if (value == null || typeof value !== \"object\") return false;\n  const v = value as {\n    type?: unknown;\n    id?: unknown;\n    name?: unknown;\n    props?: unknown;\n  };\n  if (typeof v.id !== \"string\") return false;\n  if (v.type === \"remove-ui\") return true;\n  return (\n    v.type === \"ui\" &&\n    typeof v.name === \"string\" &&\n    typeof v.props === \"object\" &&\n    v.props !== null\n  );\n};\n\nexport const applyUIUpdate = (\n  list: readonly UIMessage[],\n  update: UIUpdate | readonly UIUpdate[],\n): UIMessage[] => {\n  const events = Array.isArray(update) ? update : [update as UIUpdate];\n  let next = list.slice();\n  for (const event of events) {\n    if (event.type === \"remove-ui\") {\n      next = next.filter((ui) => ui.id !== event.id);\n      continue;\n    }\n    const index = next.findIndex((ui) => ui.id === event.id);\n    if (index === -1) {\n      next.push(event);\n      continue;\n    }\n    next[index] =\n      event.metadata?.merge === true\n        ? { ...event, props: { ...next[index]!.props, ...event.props } }\n        : event;\n  }\n  return next;\n};\n\n/**\n * Pulls a UI update out of a raw `custom`-channel event. The graph writes the\n * `UIMessage` straight to the channel, so it lands at `params.data`; some\n * transports wrap it one level deeper at `params.data.payload`.\n */\nexport const extractUIUpdate = (\n  event: unknown,\n): UIUpdate | readonly UIUpdate[] | undefined => {\n  const data = (event as { params?: { data?: unknown } } | null)?.params?.data;\n  if (isUIUpdate(data)) return data;\n  const payload = (data as { payload?: unknown } | undefined)?.payload;\n  if (isUIUpdate(payload)) return payload;\n  return undefined;\n};\n\nexport const foldUIUpdates = (events: readonly unknown[]): UIMessage[] => {\n  let acc: UIMessage[] = [];\n  for (const event of events) {\n    const update = extractUIUpdate(event);\n    if (update) acc = applyUIUpdate(acc, update);\n  }\n  return acc;\n};\n\n/**\n * Merges live-streamed UI with the state snapshot. The snapshot is\n * authoritative by id: once a UI lands in graph state it supersedes its live\n * copy. A consequence is that a live `remove-ui` is overridden while the\n * snapshot still contains that id; the removal only takes visible effect once\n * the snapshot catches up.\n */\nexport const mergeUIMessages = (\n  live: readonly UIMessage[],\n  snapshot: unknown,\n): UIMessage[] => {\n  const byId = new Map<string, UIMessage>();\n  for (const ui of live) byId.set(ui.id, ui);\n  if (Array.isArray(snapshot)) {\n    for (const ui of snapshot as UIMessage[]) byId.set(ui.id, ui);\n  }\n  return [...byId.values()];\n};\n"],"mappings":";AAIA,MAAa,cACX,UAC4C;CAC5C,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,SAAS,KAAK,MAAM,MAAM,UAAU;CAC3E,IAAI,SAAS,QAAQ,OAAO,UAAU,UAAU,OAAO;CACvD,MAAM,IAAI;CAMV,IAAI,OAAO,EAAE,OAAO,UAAU,OAAO;CACrC,IAAI,EAAE,SAAS,aAAa,OAAO;CACnC,OACE,EAAE,SAAS,QACX,OAAO,EAAE,SAAS,YAClB,OAAO,EAAE,UAAU,YACnB,EAAE,UAAU;AAEhB;AAEA,MAAa,iBACX,MACA,WACgB;CAChB,MAAM,SAAS,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAkB;CACnE,IAAI,OAAO,KAAK,MAAM;CACtB,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,MAAM,SAAS,aAAa;GAC9B,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,EAAE;GAC7C;EACF;EACA,MAAM,QAAQ,KAAK,WAAW,OAAO,GAAG,OAAO,MAAM,EAAE;EACvD,IAAI,UAAU,IAAI;GAChB,KAAK,KAAK,KAAK;GACf;EACF;EACA,KAAK,SACH,MAAM,UAAU,UAAU,OACtB;GAAE,GAAG;GAAO,OAAO;IAAE,GAAG,KAAK,MAAM,CAAE;IAAO,GAAG,MAAM;GAAM;EAAE,IAC7D;CACR;CACA,OAAO;AACT;;;;;;AAOA,MAAa,mBACX,UAC+C;CAC/C,MAAM,OAAQ,OAAkD,QAAQ;CACxE,IAAI,WAAW,IAAI,GAAG,OAAO;CAC7B,MAAM,UAAW,MAA4C;CAC7D,IAAI,WAAW,OAAO,GAAG,OAAO;AAElC;AAEA,MAAa,iBAAiB,WAA4C;CACxE,IAAI,MAAmB,CAAC;CACxB,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,SAAS,gBAAgB,KAAK;EACpC,IAAI,QAAQ,MAAM,cAAc,KAAK,MAAM;CAC7C;CACA,OAAO;AACT;;;;;;;;AASA,MAAa,mBACX,MACA,aACgB;CAChB,MAAM,uBAAO,IAAI,IAAuB;CACxC,KAAK,MAAM,MAAM,MAAM,KAAK,IAAI,GAAG,IAAI,EAAE;CACzC,IAAI,MAAM,QAAQ,QAAQ,GACxB,KAAK,MAAM,MAAM,UAAyB,KAAK,IAAI,GAAG,IAAI,EAAE;CAE9D,OAAO,CAAC,GAAG,KAAK,OAAO,CAAC;AAC1B"}
+{"version":3,"file":"uiMessages.js","names":[],"sources":["../src/uiMessages.ts"],"sourcesContent":["import type { Channel } from \"@langchain/react\";\nimport type { RemoveUIMessage, UIMessage } from \"./types\";\n\n/** Channels the generative-UI fold reads, at the root and per subagent. */\nexport const UI_CUSTOM_CHANNELS: readonly Channel[] = [\"custom\"];\n\nexport type UIUpdate = UIMessage | RemoveUIMessage;\n\nexport const isUIUpdate = (\n  value: unknown,\n): value is UIUpdate | readonly UIUpdate[] => {\n  if (Array.isArray(value)) return value.length > 0 && value.every(isUIUpdate);\n  if (value == null || typeof value !== \"object\") return false;\n  const v = value as {\n    type?: unknown;\n    id?: unknown;\n    name?: unknown;\n    props?: unknown;\n  };\n  if (typeof v.id !== \"string\") return false;\n  if (v.type === \"remove-ui\") return true;\n  return (\n    v.type === \"ui\" &&\n    typeof v.name === \"string\" &&\n    typeof v.props === \"object\" &&\n    v.props !== null\n  );\n};\n\nexport const applyUIUpdate = (\n  list: readonly UIMessage[],\n  update: UIUpdate | readonly UIUpdate[],\n): UIMessage[] => {\n  const events = Array.isArray(update) ? update : [update as UIUpdate];\n  let next = list.slice();\n  for (const event of events) {\n    if (event.type === \"remove-ui\") {\n      next = next.filter((ui) => ui.id !== event.id);\n      continue;\n    }\n    const index = next.findIndex((ui) => ui.id === event.id);\n    if (index === -1) {\n      next.push(event);\n      continue;\n    }\n    next[index] =\n      event.metadata?.merge === true\n        ? { ...event, props: { ...next[index]!.props, ...event.props } }\n        : event;\n  }\n  return next;\n};\n\n/**\n * Pulls a UI update out of a raw `custom`-channel event. The graph writes the\n * `UIMessage` straight to the channel, so it lands at `params.data`; some\n * transports wrap it one level deeper at `params.data.payload`.\n */\nexport const extractUIUpdate = (\n  event: unknown,\n): UIUpdate | readonly UIUpdate[] | undefined => {\n  const data = (event as { params?: { data?: unknown } } | null)?.params?.data;\n  if (isUIUpdate(data)) return data;\n  const payload = (data as { payload?: unknown } | undefined)?.payload;\n  if (isUIUpdate(payload)) return payload;\n  return undefined;\n};\n\nexport type UIFoldMemo = {\n  events: readonly unknown[];\n  messages: UIMessage[];\n};\n\nexport const createUIFoldMemo = (): UIFoldMemo => ({\n  events: [],\n  messages: [],\n});\n\n/**\n * Folds `custom`-channel events into UI messages, continuing the fold held in\n * `memo`. The channel buffer holds each event object once, appends new events\n * and drops its oldest ones once full, so only events after the previously\n * folded last event are applied, and entries no later event touches keep\n * their identity. A buffer that no longer contains that event was replaced\n * and is folded from scratch.\n */\nexport const foldUIUpdates = (\n  events: readonly unknown[],\n  memo: UIFoldMemo = createUIFoldMemo(),\n): UIMessage[] => {\n  const previous = memo.events;\n  const resumeAt =\n    previous.length === 0\n      ? 0\n      : events.lastIndexOf(previous.at(-1), previous.length - 1) + 1;\n  let acc = previous.length > 0 && resumeAt === 0 ? [] : memo.messages;\n  for (let i = resumeAt; i < events.length; i++) {\n    const update = extractUIUpdate(events[i]);\n    if (update) acc = applyUIUpdate(acc, update);\n  }\n  memo.events = events;\n  memo.messages = acc;\n  return acc;\n};\n\n/**\n * Merges live-streamed UI with the state snapshot. The snapshot is\n * authoritative by id: once a UI lands in graph state it supersedes its live\n * copy. A consequence is that a live `remove-ui` is overridden while the\n * snapshot still contains that id; the removal only takes visible effect once\n * the snapshot catches up.\n */\nexport const mergeUIMessages = (\n  live: readonly UIMessage[],\n  snapshot: unknown,\n): UIMessage[] => {\n  const byId = new Map<string, UIMessage>();\n  for (const ui of live) byId.set(ui.id, ui);\n  if (Array.isArray(snapshot)) {\n    for (const ui of snapshot as UIMessage[]) byId.set(ui.id, ui);\n  }\n  return [...byId.values()];\n};\n"],"mappings":";;AAIA,MAAa,qBAAyC,CAAC,QAAQ;AAI/D,MAAa,cACX,UAC4C;CAC5C,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,SAAS,KAAK,MAAM,MAAM,UAAU;CAC3E,IAAI,SAAS,QAAQ,OAAO,UAAU,UAAU,OAAO;CACvD,MAAM,IAAI;CAMV,IAAI,OAAO,EAAE,OAAO,UAAU,OAAO;CACrC,IAAI,EAAE,SAAS,aAAa,OAAO;CACnC,OACE,EAAE,SAAS,QACX,OAAO,EAAE,SAAS,YAClB,OAAO,EAAE,UAAU,YACnB,EAAE,UAAU;AAEhB;AAEA,MAAa,iBACX,MACA,WACgB;CAChB,MAAM,SAAS,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAkB;CACnE,IAAI,OAAO,KAAK,MAAM;CACtB,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,MAAM,SAAS,aAAa;GAC9B,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,EAAE;GAC7C;EACF;EACA,MAAM,QAAQ,KAAK,WAAW,OAAO,GAAG,OAAO,MAAM,EAAE;EACvD,IAAI,UAAU,IAAI;GAChB,KAAK,KAAK,KAAK;GACf;EACF;EACA,KAAK,SACH,MAAM,UAAU,UAAU,OACtB;GAAE,GAAG;GAAO,OAAO;IAAE,GAAG,KAAK,MAAM,CAAE;IAAO,GAAG,MAAM;GAAM;EAAE,IAC7D;CACR;CACA,OAAO;AACT;;;;;;AAOA,MAAa,mBACX,UAC+C;CAC/C,MAAM,OAAQ,OAAkD,QAAQ;CACxE,IAAI,WAAW,IAAI,GAAG,OAAO;CAC7B,MAAM,UAAW,MAA4C;CAC7D,IAAI,WAAW,OAAO,GAAG,OAAO;AAElC;AAOA,MAAa,0BAAsC;CACjD,QAAQ,CAAC;CACT,UAAU,CAAC;AACb;;;;;;;;;AAUA,MAAa,iBACX,QACA,OAAmB,iBAAiB,MACpB;CAChB,MAAM,WAAW,KAAK;CACtB,MAAM,WACJ,SAAS,WAAW,IAChB,IACA,OAAO,YAAY,SAAS,GAAG,EAAE,GAAG,SAAS,SAAS,CAAC,IAAI;CACjE,IAAI,MAAM,SAAS,SAAS,KAAK,aAAa,IAAI,CAAC,IAAI,KAAK;CAC5D,KAAK,IAAI,IAAI,UAAU,IAAI,OAAO,QAAQ,KAAK;EAC7C,MAAM,SAAS,gBAAgB,OAAO,EAAE;EACxC,IAAI,QAAQ,MAAM,cAAc,KAAK,MAAM;CAC7C;CACA,KAAK,SAAS;CACd,KAAK,WAAW;CAChB,OAAO;AACT;;;;;;;;AASA,MAAa,mBACX,MACA,aACgB;CAChB,MAAM,uBAAO,IAAI,IAAuB;CACxC,KAAK,MAAM,MAAM,MAAM,KAAK,IAAI,GAAG,IAAI,EAAE;CACzC,IAAI,MAAM,QAAQ,QAAQ,GACxB,KAAK,MAAM,MAAM,UAAyB,KAAK,IAAI,GAAG,IAAI,EAAE;CAE9D,OAAO,CAAC,GAAG,KAAK,OAAO,CAAC;AAC1B"}

package/dist/useStreamRuntime.d.ts

@@ -3,7 +3,7 @@ import { groupUIMessagesByParent } from "./converter.js";
 import { UseStreamRuntimeOptions } from "./types.js";
 import { AppendMessage } from "@assistant-ui/core";
 //#region src/useStreamRuntime.d.ts
-declare const runConfigToSubmitOptions: (runConfig: AppendMessage["runConfig"]) => {
+export declare const runConfigToSubmitOptions: (runConfig: AppendMessage["runConfig"]) => {
   config: {
     configurable: Record<string, unknown>;
   };
@@ -32,7 +32,7 @@ declare const runConfigToSubmitOptions: (runConfig: AppendMessage["runConfig"])
  * }
  * ```
  */
-declare const useStreamRuntime: (rawOptions: UseStreamRuntimeOptions) => import("@assistant-ui/core").AssistantRuntime;
+export declare const useStreamRuntime: (rawOptions: UseStreamRuntimeOptions) => import("@assistant-ui/core").AssistantRuntime;
 //#endregion
-export { groupUIMessagesByParent, runConfigToSubmitOptions, useStreamRuntime };
+export { groupUIMessagesByParent };
 //# sourceMappingURL=useStreamRuntime.d.ts.map

package/dist/useStreamRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStreamRuntime.d.ts","names":[],"sources":["../src/useStreamRuntime.ts"],"mappings":";;;;cA0Da,2BACX,WAAW;;kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAskBA,mBAAoB,YAAY,yDAAuB"}
+{"version":3,"file":"useStreamRuntime.d.ts","names":[],"sources":["../src/useStreamRuntime.ts"],"mappings":";;;;qBA4Da,2BACX,WAAW;;kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAukBA,mBAAoB,YAAY,yDAAuB"}