@assistant-ui/react-ag-ui 0.0.59 → 0.0.60

package/dist/runtime/adapter/subscriber.d.ts

@@ -110,8 +110,7 @@ type SubscriberOptions = {
   logger?: Logger;
   onRunFailed?: (error: Error) => void;
 };
-declare const createAgUiSubscriber: (options: SubscriberOptions) => Subscriber;
-type AgUiSubscriber = ReturnType<typeof createAgUiSubscriber>;
+export declare const createAgUiSubscriber: (options: SubscriberOptions) => Subscriber;
+export type AgUiSubscriber = ReturnType<typeof createAgUiSubscriber>;
 //#endregion
-export { AgUiSubscriber, createAgUiSubscriber };
 //# sourceMappingURL=subscriber.d.ts.map

package/dist/runtime/adapter/subscriber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscriber.d.ts","names":[],"sources":["../../../src/runtime/adapter/subscriber.ts"],"mappings":";;;KAMK,YAAY,OAAO;KAEnB;EACH,WAAW;IAAW;;EACtB,2BAA2B;IAAW;;EACtC,6BAA6B;IAAW;;EACxC,yBAAyB;IAAW;;EACpC,2BAA2B;IAAW;;EACtC,wBAAwB;IAAW;;EACnC,sBAAsB;IAAW;;EACjC,mCAAmC;IAAW;;EAC9C,qCAAqC;IAAW;;EAChD,iCAAiC;IAAW;;EAC5C,yBAAyB;IAAW;;EACpC,uBAAuB;IAAW;;EAClC,gCAAgC;IAAW;;EAC3C,kCAAkC;IAAW;;EAC7C,8BAA8B;IAAW;;EACzC,kCAAkC;IAAW;;EAC7C,wBAAwB;IAAW;;EACnC,uBAAuB;IAAW;;EAClC,sBAAsB;IAAW;;EACjC,wBAAwB;IAAW;;EACnC,yBAAyB;IAAW;;EACpC,2BAA2B;IAAW;;EACtC,wBAAwB;IAAW;;EACnC,qBAAqB;IAAW;;EAChC,2BAA2B;IAAW;;EACtC,iBAAiB;IAAW;;EAC5B,cAAc;IAAW;;EACzB,0BAA0B;IAAW;;EACrC,2BAA2B;IAAW;;EACtC,wBAAwB;IAAW;;EACnC,sBAAsB;IAAW;;EACjC,mBAAmB;IAAW;;EAC9B;EACA,eAAe;IAAW,OAAO;;;KAiC9B;EACH,UAAU;EACV;EACA,SAAS;EACT,eAAe,OAAO;;cAGX,uBACX,SAAS,sBACR;KAsHS,iBAAiB,kBAAkB"}
+{"version":3,"file":"subscriber.d.ts","names":[],"sources":["../../../src/runtime/adapter/subscriber.ts"],"mappings":";;;KAMK,YAAY,OAAO;KAEnB;EACH,WAAW;IAAW;;EACtB,2BAA2B;IAAW;;EACtC,6BAA6B;IAAW;;EACxC,yBAAyB;IAAW;;EACpC,2BAA2B;IAAW;;EACtC,wBAAwB;IAAW;;EACnC,sBAAsB;IAAW;;EACjC,mCAAmC;IAAW;;EAC9C,qCAAqC;IAAW;;EAChD,iCAAiC;IAAW;;EAC5C,yBAAyB;IAAW;;EACpC,uBAAuB;IAAW;;EAClC,gCAAgC;IAAW;;EAC3C,kCAAkC;IAAW;;EAC7C,8BAA8B;IAAW;;EACzC,kCAAkC;IAAW;;EAC7C,wBAAwB;IAAW;;EACnC,uBAAuB;IAAW;;EAClC,sBAAsB;IAAW;;EACjC,wBAAwB;IAAW;;EACnC,yBAAyB;IAAW;;EACpC,2BAA2B;IAAW;;EACtC,wBAAwB;IAAW;;EACnC,qBAAqB;IAAW;;EAChC,2BAA2B;IAAW;;EACtC,iBAAiB;IAAW;;EAC5B,cAAc;IAAW;;EACzB,0BAA0B;IAAW;;EACrC,2BAA2B;IAAW;;EACtC,wBAAwB;IAAW;;EACnC,sBAAsB;IAAW;;EACjC,mBAAmB;IAAW;;EAC9B;EACA,eAAe;IAAW,OAAO;;;KAiC9B;EACH,UAAU;EACV;EACA,SAAS;EACT,eAAe,OAAO;;qBAGX,uBACX,SAAS,sBACR;YAsHS,iBAAiB,kBAAkB"}

package/dist/runtime/adapter/tool-approval.d.ts

@@ -19,7 +19,7 @@ type ToolApproval = NonNullable<ToolCallMessagePart["approval"]>;
  * nested on ToolCallMessagePart.messages — so only a gate naming a call the
  * message renders nowhere leaves the batch bespoke.
  */
-declare const projectAgUiToolApprovals: (interrupts: readonly AgUiInterrupt[] | undefined, boundToolCallIds?: ReadonlySet<string>) => ReadonlyMap<string, ToolApproval>;
+export declare const projectAgUiToolApprovals: (interrupts: readonly AgUiInterrupt[] | undefined, boundToolCallIds?: ReadonlySet<string>) => ReadonlyMap<string, ToolApproval>;
 /**
  * Records a decision on the gated tool call. The decision is held on the part
  * until every gate in the batch is answered, because AG-UI resumes a run with
@@ -28,7 +28,7 @@ declare const projectAgUiToolApprovals: (interrupts: readonly AgUiInterrupt[] |
  * options, and core rejects an `optionId` absent from them, so no option can
  * reach this seam.
  */
-declare const withToolApprovalDecision: (content: readonly ThreadAssistantMessagePart[], { approvalId, approved, reason }: RespondToToolApprovalOptions) => readonly ThreadAssistantMessagePart[];
+export declare const withToolApprovalDecision: (content: readonly ThreadAssistantMessagePart[], { approvalId, approved, reason }: RespondToToolApprovalOptions) => readonly ThreadAssistantMessagePart[];
 /**
  * Maps the recorded decisions onto AG-UI resume entries, or `null` while the
  * batch is incomplete. A denial is a resolved response carrying
@@ -36,7 +36,7 @@ declare const withToolApprovalDecision: (content: readonly ThreadAssistantMessag
  * the interrupt without meaningful input and carries no payload, which would
  * drop the denial reason on the wire.
  */
-declare const buildToolApprovalResume: (content: readonly ThreadAssistantMessagePart[], interrupts: readonly AgUiInterrupt[]) => AgUiResumeEntry[] | null;
+export declare const buildToolApprovalResume: (content: readonly ThreadAssistantMessagePart[], interrupts: readonly AgUiInterrupt[]) => AgUiResumeEntry[] | null;
 /**
  * Settles every gate the submitted resume array names, so the displayed outcome
  * cannot contradict the wire. A decision recorded locally is not exempt: a gate
@@ -52,7 +52,6 @@ declare const buildToolApprovalResume: (content: readonly ThreadAssistantMessage
  * first settlement instead would mean treating an unsent local decision as
  * terminal, which is exactly what the cancellation case must override.
  */
-declare const withSettledToolApprovals: (content: readonly ThreadAssistantMessagePart[], resume: readonly AgUiResumeEntry[]) => readonly ThreadAssistantMessagePart[];
+export declare const withSettledToolApprovals: (content: readonly ThreadAssistantMessagePart[], resume: readonly AgUiResumeEntry[]) => readonly ThreadAssistantMessagePart[];
 //#endregion
-export { buildToolApprovalResume, projectAgUiToolApprovals, withSettledToolApprovals, withToolApprovalDecision };
 //# sourceMappingURL=tool-approval.d.ts.map

package/dist/runtime/adapter/tool-approval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-approval.d.ts","names":[],"sources":["../../../src/runtime/adapter/tool-approval.ts"],"mappings":";;;KAgBK,eAAe,YAAY;;;;;;;;;;;;;;;;;;cA2LnB,2BACX,qBAAqB,6BACrB,mBAAmB,wBAClB,oBAAoB;;;;;;;;;cAgCV,2BACX,kBAAkB,gCAClB,YAAA,UAAA,UAAkC,0CACxB;;;;;;;;cAuBC,0BACX,kBAAkB,8BAClB,qBAAqB,oBACpB;;;;;;;;;;;;;;;;cAuFU,2BACX,kBAAkB,8BAClB,iBAAiB,+BACP"}
+{"version":3,"file":"tool-approval.d.ts","names":[],"sources":["../../../src/runtime/adapter/tool-approval.ts"],"mappings":";;;KAgBK,eAAe,YAAY;;;;;;;;;;;;;;;;;;qBA2LnB,2BACX,qBAAqB,6BACrB,mBAAmB,wBAClB,oBAAoB;;;;;;;;;qBAgCV,2BACX,kBAAkB,gCAClB,YAAA,UAAA,UAAkC,0CACxB;;;;;;;;qBAuBC,0BACX,kBAAkB,8BAClB,qBAAqB,oBACpB;;;;;;;;;;;;;;;;qBAuFU,2BACX,kBAAkB,8BAClB,iBAAiB,+BACP"}

package/dist/runtime/event-parser.d.ts

@@ -1,10 +1,9 @@
 import { Logger } from "./logger.js";
 import { AgUiEvent } from "./types.js";
 //#region src/runtime/event-parser.d.ts
-type ParseAgUiEventOptions = {
+export type ParseAgUiEventOptions = {
   logger?: Logger;
 };
-declare const parseAgUiEvent: (event: unknown, options?: ParseAgUiEventOptions) => AgUiEvent | null;
+export declare const parseAgUiEvent: (event: unknown, options?: ParseAgUiEventOptions) => AgUiEvent | null;
 //#endregion
-export { ParseAgUiEventOptions, parseAgUiEvent };
 //# sourceMappingURL=event-parser.d.ts.map

package/dist/runtime/event-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-parser.d.ts","names":[],"sources":["../../src/runtime/event-parser.ts"],"mappings":";;;KAUY;EACV,SAAS;;cAmHE,iBACX,gBACA,UAAU,0BACT"}
+{"version":3,"file":"event-parser.d.ts","names":[],"sources":["../../src/runtime/event-parser.ts"],"mappings":";;;YAUY;EACV,SAAS;;qBAmHE,iBACX,gBACA,UAAU,0BACT"}

package/dist/runtime/interrupt-internals.d.ts

@@ -1,8 +1,7 @@
 import { AgUiInterrupt } from "./types.js";
 //#region src/runtime/interrupt-internals.d.ts
-declare const withRawResponseSchema: (interrupt: AgUiInterrupt, schema: unknown) => AgUiInterrupt;
-declare const readRawResponseSchema: (interrupt: AgUiInterrupt) => unknown;
-declare const withoutRawResponseSchema: <T extends AgUiInterrupt>(interrupt: T) => T;
+export declare const withRawResponseSchema: (interrupt: AgUiInterrupt, schema: unknown) => AgUiInterrupt;
+export declare const readRawResponseSchema: (interrupt: AgUiInterrupt) => unknown;
+export declare const withoutRawResponseSchema: <T extends AgUiInterrupt>(interrupt: T) => T;
 //#endregion
-export { readRawResponseSchema, withRawResponseSchema, withoutRawResponseSchema };
 //# sourceMappingURL=interrupt-internals.d.ts.map

package/dist/runtime/interrupt-internals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt-internals.d.ts","names":[],"sources":["../../src/runtime/interrupt-internals.ts"],"mappings":";;cAca,wBACX,WAAW,eACX,oBACC;cAQU,wBAAyB,WAAW;cAGpC,2BAA4B,UAAU,eACjD,WAAW,MACV"}
+{"version":3,"file":"interrupt-internals.d.ts","names":[],"sources":["../../src/runtime/interrupt-internals.ts"],"mappings":";;qBAca,wBACX,WAAW,eACX,oBACC;qBAQU,wBAAyB,WAAW;qBAGpC,2BAA4B,UAAU,eACjD,WAAW,MACV"}

package/dist/runtime/logger.d.ts

@@ -1,9 +1,8 @@
 //#region src/runtime/logger.d.ts
-type Logger = {
+export type Logger = {
   debug: (...a: any[]) => void;
   error: (...a: any[]) => void;
 };
-declare const makeLogger: (l?: Partial<Logger>) => Logger;
+export declare const makeLogger: (l?: Partial<Logger>) => Logger;
 //#endregion
-export { Logger, makeLogger };
 //# sourceMappingURL=logger.d.ts.map

package/dist/runtime/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/runtime/logger.ts"],"mappings":";KAAY;EACV,WAAW;EACX,WAAW;;cAGA,aAAc,IAAI,QAAQ,YAAU"}
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/runtime/logger.ts"],"mappings":";YAAY;EACV,WAAW;EACX,WAAW;;qBAGA,aAAc,IAAI,QAAQ,YAAU"}

package/dist/runtime/mcp-tool-result.d.ts

@@ -1,12 +1,11 @@
 //#region src/runtime/mcp-tool-result.d.ts
-type McpToolCallResult = Record<string, unknown> & {
+export type McpToolCallResult = Record<string, unknown> & {
   content: unknown[];
   structuredContent?: Record<string, unknown>;
   _meta?: Record<string, unknown>;
   isError?: boolean;
 };
-declare const parseMcpToolCallResult: (source: Record<string, unknown>, modelContent: string) => McpToolCallResult | undefined;
-declare const readMcpAppResourceUri: (meta: unknown) => string | undefined;
+export declare const parseMcpToolCallResult: (source: Record<string, unknown>, modelContent: string) => McpToolCallResult | undefined;
+export declare const readMcpAppResourceUri: (meta: unknown) => string | undefined;
 //#endregion
-export { McpToolCallResult, parseMcpToolCallResult, readMcpAppResourceUri };
 //# sourceMappingURL=mcp-tool-result.d.ts.map

package/dist/runtime/mcp-tool-result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-tool-result.d.ts","names":[],"sources":["../../src/runtime/mcp-tool-result.ts"],"mappings":";KAGY,oBAAoB;EAC9B;EACA,oBAAoB;EACpB,QAAQ;EACR;;cAGW,yBACX,QAAQ,yBACR,yBACC;cAkBU,wBAAyB"}
+{"version":3,"file":"mcp-tool-result.d.ts","names":[],"sources":["../../src/runtime/mcp-tool-result.ts"],"mappings":";YAGY,oBAAoB;EAC9B;EACA,oBAAoB;EACpB,QAAQ;EACR;;qBAGW,yBACX,QAAQ,yBACR,yBACC;qBAkBU,wBAAyB"}

package/dist/runtime/types.d.ts

@@ -20,10 +20,10 @@ type SwitchToThreadResult = {
    */
   unstable_resume?: boolean;
 };
-type UseAgUiThreadListAdapter = Omit<ExternalStoreThreadListAdapter, "onSwitchToThread"> & {
+export type UseAgUiThreadListAdapter = Omit<ExternalStoreThreadListAdapter, "onSwitchToThread"> & {
   onSwitchToThread?: ((threadId: string) => Promise<SwitchToThreadResult> | SwitchToThreadResult) | undefined;
 };
-type UseAgUiRuntimeAdapters = {
+export type UseAgUiRuntimeAdapters = {
   attachments?: AttachmentAdapter;
   speech?: SpeechSynthesisAdapter;
   dictation?: DictationAdapter;
@@ -35,8 +35,8 @@ type UseAgUiRuntimeAdapters = {
    */
   threadList?: UseAgUiThreadListAdapter;
 };
-type AgUiResumeTranscript = "full" | "appended";
-type UseAgUiRuntimeOptions = ExternalStoreSharedOptions & {
+export type AgUiResumeTranscript = "full" | "appended";
+export type UseAgUiRuntimeOptions = ExternalStoreSharedOptions & {
   agent: AbstractAgent;
   logger?: Partial<Logger>;
   showThinking?: boolean;
@@ -86,8 +86,8 @@ type UseAgUiRuntimeOptions = ExternalStoreSharedOptions & {
   onCancel?: () => void;
   adapters?: UseAgUiRuntimeAdapters;
 };
-type AgUiInterruptReason = "tool_call" | "input_required" | "confirmation" | (string & {});
-type AgUiInterrupt = {
+export type AgUiInterruptReason = "tool_call" | "input_required" | "confirmation" | (string & {});
+export type AgUiInterrupt = {
   id: string;
   reason: AgUiInterruptReason;
   message?: string;
@@ -96,12 +96,12 @@ type AgUiInterrupt = {
   expiresAt?: string;
   metadata?: Record<string, unknown>;
 };
-type AgUiResumeEntry = {
+export type AgUiResumeEntry = {
   interruptId: string;
   status: "resolved" | "cancelled";
   payload?: unknown;
 };
-type AgUiRuntimeExtras = {
+export type AgUiRuntimeExtras = {
   interrupts: readonly AgUiInterrupt[];
   sendA2uiAction: (action: Record<string, unknown>) => void;
   submitInterruptResponses: (responses: readonly AgUiResumeEntry[]) => Promise<void>;
@@ -109,19 +109,19 @@ type AgUiRuntimeExtras = {
   state: ReadonlyJSONValue | undefined;
   setState: (next: ReadonlyJSONValue | ((prev: ReadonlyJSONValue | undefined) => ReadonlyJSONValue)) => void;
 };
-type AgUiRunFinishedOutcome = {
+export type AgUiRunFinishedOutcome = {
   type: "success";
 } | {
   type: "interrupt";
   interrupts: AgUiInterrupt[];
 };
-type AgUiSubagentFinishedOutcome = {
+export type AgUiSubagentFinishedOutcome = {
   type: "success";
 } | {
   type: "suspended";
   interruptIds?: string[];
 };
-type AgUiEvent = {
+export type AgUiEvent = {
   type: "RUN_STARTED";
   runId: string;
 } | {
@@ -266,5 +266,4 @@ type AgUiEvent = {
   code?: string;
 };
 //#endregion
-export { AgUiEvent, AgUiInterrupt, AgUiInterruptReason, AgUiResumeEntry, AgUiResumeTranscript, AgUiRunFinishedOutcome, AgUiRuntimeExtras, AgUiSubagentFinishedOutcome, UseAgUiRuntimeAdapters, UseAgUiRuntimeOptions, UseAgUiThreadListAdapter };
 //# sourceMappingURL=types.d.ts.map

package/dist/runtime/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runtime/types.ts"],"mappings":";;;;;;;;;;;;KAuBK;EACH,mBAAmB;EACnB,QAAQ;;;;;;EAMR;;KAGU,2BAA2B,KACrC;EAGA,qBAEM,qBACG,QAAQ,wBAAwB;;KAI/B;EACV,cAAc;EACd,SAAS;EACT,YAAY;EACZ,QAAQ;EACR,WAAW;EACX,UAAU;;;;EAIV,aAAa;;KAGH;KAEA,wBAAwB;EAClC,OAAO;EACP,SAAS,QAAQ;EACjB;;;;;;;;;;;;;;;;;;;;;;;;EAwBA,mBAAmB;;;;;;;;;;;EAWnB;;;;;;;EAOA;EACA,WAAW,GAAG;EACd;EACA,WAAW;;KAGD;KAMA;EACV;EACA,QAAQ;EACR;EACA;EACA,iBAAiB;EACjB;EACA,WAAW;;KAGD;EACV;EACA;EACA;;KAGU;EACV,qBAAqB;EACrB,iBAAiB,QAAQ;EACzB,2BACE,oBAAoB,sBACjB;EACL,YACE,SAAS,qBACT,qBAAqB,sBAClB;EACL,OAAO;EACP,WACE,MACI,sBACE,MAAM,kCAAkC;;KAItC;EACN;;EACA;EAAmB,YAAY;;KAEzB;EACN;;EACA;EAAmB;;KAEb;EACN;EAAqB;;EAErB;EACA;EACA,UAAU;;EAEV;EAAuB;;EACvB;EAAmB;EAAkB;;EACrC;EAA4B;EAAoB;;EAEhD;EACA;EACA;EACA;;EAEA;EAA0B;EAAoB;;EAE9C;EACA;EACA;EACA;;EAEA;EAAwB;;EACxB;;EACA;EAAuC;;EACvC;;EACA;;EACA;EAAyB;EAAoB;;EAE7C;EACA;EACA;;EAGA;EACA;EACA;EACA;;EAGA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;;EAEA;EAAuB;EAAoB;;EAE3C;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;;EAEA;EAAuB;EAAoB;;EAE3C;EACA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA,YAAY;EACZ;;EAGA;EACA;EACA,SAAS;EACT;EACA;EACA;;EAEA;EAAa;EAAY;;EACzB;EAAgB;EAAc;;EAC9B;EAAwB;;EACxB;EAAqB;;EACrB;EAA2B;;EAE3B;EACA;EACA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA,UAAU;;EAGV;EACA;EACA;EACA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runtime/types.ts"],"mappings":";;;;;;;;;;;;KAuBK;EACH,mBAAmB;EACnB,QAAQ;;;;;;EAMR;;YAGU,2BAA2B,KACrC;EAGA,qBAEM,qBACG,QAAQ,wBAAwB;;YAI/B;EACV,cAAc;EACd,SAAS;EACT,YAAY;EACZ,QAAQ;EACR,WAAW;EACX,UAAU;;;;EAIV,aAAa;;YAGH;YAEA,wBAAwB;EAClC,OAAO;EACP,SAAS,QAAQ;EACjB;;;;;;;;;;;;;;;;;;;;;;;;EAwBA,mBAAmB;;;;;;;;;;;EAWnB;;;;;;;EAOA;EACA,WAAW,GAAG;EACd;EACA,WAAW;;YAGD;YAMA;EACV;EACA,QAAQ;EACR;EACA;EACA,iBAAiB;EACjB;EACA,WAAW;;YAGD;EACV;EACA;EACA;;YAGU;EACV,qBAAqB;EACrB,iBAAiB,QAAQ;EACzB,2BACE,oBAAoB,sBACjB;EACL,YACE,SAAS,qBACT,qBAAqB,sBAClB;EACL,OAAO;EACP,WACE,MACI,sBACE,MAAM,kCAAkC;;YAItC;EACN;;EACA;EAAmB,YAAY;;YAEzB;EACN;;EACA;EAAmB;;YAEb;EACN;EAAqB;;EAErB;EACA;EACA,UAAU;;EAEV;EAAuB;;EACvB;EAAmB;EAAkB;;EACrC;EAA4B;EAAoB;;EAEhD;EACA;EACA;EACA;;EAEA;EAA0B;EAAoB;;EAE9C;EACA;EACA;EACA;;EAEA;EAAwB;;EACxB;;EACA;EAAuC;;EACvC;;EACA;;EACA;EAAyB;EAAoB;;EAE7C;EACA;EACA;;EAGA;EACA;EACA;EACA;;EAGA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;;EAEA;EAAuB;EAAoB;;EAE3C;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;;EAEA;EAAuB;EAAoB;;EAE3C;EACA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA,YAAY;EACZ;;EAGA;EACA;EACA,SAAS;EACT;EACA;EACA;;EAEA;EAAa;EAAY;;EACzB;EAAgB;EAAc;;EAC9B;EAAwB;;EACxB;EAAqB;;EACrB;EAA2B;;EAE3B;EACA;EACA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA,UAAU;;EAGV;EACA;EACA;EACA"}

package/dist/useAgUiRuntime.d.ts

@@ -1,7 +1,7 @@
 import { AgUiInterrupt, AgUiResumeEntry, UseAgUiRuntimeOptions } from "./runtime/types.js";
 import { AssistantRuntime } from "@assistant-ui/core";
 //#region src/useAgUiRuntime.d.ts
-type AgUiAssistantRuntime = AssistantRuntime & {
+export type AgUiAssistantRuntime = AssistantRuntime & {
   /**
    * @deprecated Use the `useAgUiInterrupts()` hook instead. This method is kept
    * for backward compatibility and will be removed in a future major release.
@@ -14,7 +14,6 @@ type AgUiAssistantRuntime = AssistantRuntime & {
    */
   unstable_submitInterruptResponses: (responses: readonly AgUiResumeEntry[]) => Promise<void>;
 };
-declare function useAgUiRuntime(options: UseAgUiRuntimeOptions): AgUiAssistantRuntime;
+export declare function useAgUiRuntime(options: UseAgUiRuntimeOptions): AgUiAssistantRuntime;
 //#endregion
-export { AgUiAssistantRuntime, useAgUiRuntime };
 //# sourceMappingURL=useAgUiRuntime.d.ts.map

package/dist/useAgUiRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAgUiRuntime.d.ts","names":[],"sources":["../src/useAgUiRuntime.ts"],"mappings":";;;KA0CY,uBAAuB;;;;;EAKjC,8CAA8C;;;;;;EAM9C,oCACE,oBAAoB,sBACjB;;iBAGS,eACd,SAAS,wBACR"}
+{"version":3,"file":"useAgUiRuntime.d.ts","names":[],"sources":["../src/useAgUiRuntime.ts"],"mappings":";;;YA0CY,uBAAuB;;;;;EAKjC,8CAA8C;;;;;;EAM9C,oCACE,oBAAoB,sBACjB;;wBAGS,eACd,SAAS,wBACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-ag-ui",
-  "version": "0.0.59",
+  "version": "0.0.60",
   "description": "AG-UI protocol adapter for assistant-ui",
   "keywords": [
     "ag-ui",
@@ -30,10 +30,10 @@
   "sideEffects": false,
   "dependencies": {
     "@ag-ui/client": "^0.0.59",
-    "@assistant-ui/core": "^0.3.18",
-    "@assistant-ui/react-generative-ui": "^0.0.18",
-    "@assistant-ui/store": "^0.3.13",
-    "assistant-stream": "^0.3.42",
+    "@assistant-ui/core": "^0.3.20",
+    "@assistant-ui/react-generative-ui": "^0.0.19",
+    "@assistant-ui/store": "^0.3.14",
+    "assistant-stream": "^0.3.44",
     "fast-json-patch": "^3.1.1"
   },
   "peerDependencies": {
@@ -46,14 +46,14 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "0.0.26",
-    "@testing-library/dom": "^10.4.1",
+    "@assistant-ui/x-buildutils": "0.0.28",
+    "@testing-library/dom": "^10.4.2",
     "@testing-library/react": "^16.3.3",
-    "@types/react": "^19.2.18",
+    "@types/react": "^19.3.0",
     "jsdom": "^30.0.1",
-    "react": "^19.2.8",
-    "vitest": "^4.1.11",
-    "zod": "^4.5.4"
+    "react": "^19.3.0",
+    "vitest": "^5.0.1",
+    "zod": "^4.6.5"
   },
   "publishConfig": {
     "access": "public",
@@ -71,6 +71,7 @@
   "scripts": {
     "build": "aui-build",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "test:watch": "vitest"
   }
 }

package/src/runtime/AgUiThreadRuntimeCore.ts

@@ -871,11 +871,17 @@ export class AgUiThreadRuntimeCore {
       const { content } = mapToolCallPartsDeep(assistant.content, (part) => {
         if (part.toolCallId !== options.toolCallId) return part;
         matchedToolCall = true;
+        // artifact and modelContent are optional; only override when supplied
+        // so a later result that omits them keeps a stored value, and
+        // emitToolResult can forward the model-facing content to the agent.
         return {
           ...part,
           result: options.result,
-          artifact: options.artifact,
           isError: options.isError,
+          ...(options.artifact !== undefined && { artifact: options.artifact }),
+          ...(options.modelContent !== undefined && {
+            modelContent: options.modelContent,
+          }),
         };
       });
       if (!matchedToolCall) return message;
@@ -1602,6 +1608,9 @@ export class AgUiThreadRuntimeCore {
         result: prior.result,
         ...(prior.artifact !== undefined ? { artifact: prior.artifact } : {}),
         ...(prior.isError !== undefined ? { isError: prior.isError } : {}),
+        ...(prior.modelContent !== undefined
+          ? { modelContent: prior.modelContent }
+          : {}),
       };
     });
     return changed ? merged : next;

package/src/runtime/adapter/conversions.ts

@@ -5,6 +5,7 @@ import { generateId } from "@assistant-ui/core";
 import type {
   ThreadMessageLike as CoreThreadMessageLike,
   PartProviderMetadata,
+  ReasoningMessagePart,
   ThreadMessage,
   ToolCallMessagePartMcpMetadata,
   ToolModelContentPart,
@@ -44,14 +45,14 @@ type AttachmentLike = {
 };
 
 type ThreadMessageLike = {
-  id?: string;
+  id?: string | undefined;
   role: string;
   content: unknown;
   metadata?: unknown;
-  name?: string;
-  toolCallId?: string;
-  error?: string;
-  attachments?: readonly AttachmentLike[];
+  name?: string | undefined;
+  toolCallId?: string | undefined;
+  error?: string | undefined;
+  attachments?: readonly AttachmentLike[] | undefined;
 };
 
 type NormalizedThreadMessageLike = ThreadMessageLike & { id: string };
@@ -733,6 +734,112 @@ function attachA2uiSurfaces(
   return { ...message, content: [...preserved, ...a2uiParts] };
 }
 
+// A tool call that arrives without a `parentMessageId` has no record to join, so
+// the client opens one keyed by the call id. An assistant record whose own id is
+// a call it carries is that container: an id the client invented for the call
+// rather than a boundary an agent drew. The prose the run answers with lands in
+// a record of its own, and nothing on the wire binds the two to the run that
+// produced them.
+function isSyntheticToolCallContainer(message: CoreThreadMessageLike): boolean {
+  if (message.role !== "assistant" || !Array.isArray(message.content))
+    return false;
+  let carriesOwnId = false;
+  for (const part of message.content) {
+    if (!isObject(part)) continue;
+    // The container is opened empty, so text on the record means an agent
+    // addressed it and the id is one it chose.
+    if (part.type === "text") return false;
+    if (
+      part.type === "tool-call" &&
+      getString(part, "toolCallId") === message.id
+    ) {
+      carriesOwnId = true;
+    }
+  }
+  return carriesOwnId;
+}
+
+function carriesText(message: CoreThreadMessageLike): boolean {
+  return (
+    Array.isArray(message.content) &&
+    message.content.some((part) => isObject(part) && part.type === "text")
+  );
+}
+
+// What the run put after the container folds onto it: another container for a
+// parallel call, or the parts of the answer. A record carrying a tool call an
+// agent addressed is a boundary of its own and keeps its message.
+function foldsOntoToolCallContainer(message: CoreThreadMessageLike): boolean {
+  if (message.role !== "assistant" || !Array.isArray(message.content))
+    return false;
+  if (message.content.length === 0) return false;
+  return (
+    isSyntheticToolCallContainer(message) ||
+    !message.content.some((part) => isObject(part) && part.type === "tool-call")
+  );
+}
+
+function readCustomMetadata(metadata: unknown): Record<string, unknown> {
+  if (!isObject(metadata) || !isObject(metadata.custom)) return {};
+  return metadata.custom;
+}
+
+function readNamespacedMetadata(metadata: unknown): Record<string, unknown> {
+  const namespaced = readCustomMetadata(metadata)[AG_UI_METADATA_NAMESPACE];
+  return isObject(namespaced) ? namespaced : {};
+}
+
+function foldOntoToolCallContainer(
+  container: CoreThreadMessageLike,
+  message: CoreThreadMessageLike,
+): CoreThreadMessageLike {
+  const interrupts = [
+    ...(readPersistedInterrupts(container.metadata) ?? []),
+    ...(readPersistedInterrupts(message.metadata) ?? []),
+  ];
+  // An entry that rode the folded record sat ahead of content that now follows
+  // the container's calls, so it is replayed after the merged record and its
+  // tool results rather than ahead of a message that no longer starts there.
+  const opaqueReasoning = [
+    ...readOpaqueReasoning(container.metadata),
+    ...readOpaqueReasoning(message.metadata).map((entry) => ({
+      ...entry,
+      after: true,
+    })),
+  ];
+  const namespaced = {
+    ...readNamespacedMetadata(container.metadata),
+    ...readNamespacedMetadata(message.metadata),
+    ...(interrupts.length > 0 ? { interrupts } : {}),
+    ...(opaqueReasoning.length > 0 ? { opaqueReasoning } : {}),
+  } satisfies AgUiCustomMetadata & Record<string, unknown>;
+  const custom = {
+    ...readCustomMetadata(container.metadata),
+    ...readCustomMetadata(message.metadata),
+    ...(Object.keys(namespaced).length > 0
+      ? { [AG_UI_METADATA_NAMESPACE]: namespaced }
+      : {}),
+  };
+  const metadata = {
+    ...(isObject(container.metadata) ? container.metadata : {}),
+    ...(isObject(message.metadata) ? message.metadata : {}),
+    ...(Object.keys(custom).length > 0 ? { custom } : {}),
+  };
+  return {
+    ...container,
+    ...message,
+    // The container's id names a call rather than the turn, so the record the
+    // agent addressed its prose to wins: that is the id the next run has to
+    // carry for the agent to recognize the message it wrote.
+    id: carriesText(message) ? message.id : container.id,
+    content: [
+      ...(Array.isArray(container.content) ? container.content : []),
+      ...(Array.isArray(message.content) ? message.content : []),
+    ],
+    ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+  } as CoreThreadMessageLike;
+}
+
 export type FromAgUiMessagesOptions = {
   /**
    * Whether to convert `reasoning` messages into visible reasoning parts.
@@ -754,6 +861,40 @@ export function fromAgUiMessages(
   // neighbouring message instead of being dropped. The anchor is the index the
   // next pushed message will occupy, which is where it sat on the wire.
   const opaqueReasoning: (AgUiOpaqueReasoning & { anchor: number })[] = [];
+  // A reasoning record belongs to the assistant record that follows it, which is
+  // the binding the export writes and the one the reference integrations read
+  // back. Holding it until that assistant arrives rebuilds the pair as the
+  // single message the live run produced.
+  const pendingReasoning: {
+    id: string | undefined;
+    part: ReasoningMessagePart;
+  }[] = [];
+
+  const flushPendingReasoning = () => {
+    for (const { id, part } of pendingReasoning) {
+      converted.push({
+        id: id ?? generateId(),
+        role: "assistant",
+        content: [part],
+      });
+    }
+    pendingReasoning.length = 0;
+  };
+
+  const withPendingReasoning = (
+    message: CoreThreadMessageLike,
+  ): CoreThreadMessageLike => {
+    if (pendingReasoning.length === 0) return message;
+    const parts = pendingReasoning.map(({ part }) => part);
+    pendingReasoning.length = 0;
+    return {
+      ...message,
+      content: [
+        ...parts,
+        ...(Array.isArray(message.content) ? message.content : []),
+      ],
+    };
+  };
 
   for (const rawMessage of messages) {
     if (!isObject(rawMessage)) continue;
@@ -761,6 +902,7 @@ export function fromAgUiMessages(
     if (!role) continue;
 
     if (role === "tool") {
+      flushPendingReasoning();
       const toolCallId = getToolCallId(rawMessage) ?? `tool-${generateId()}`;
       const toolMessageId = getString(rawMessage, "id");
       const modelContent = extractText(rawMessage.content);
@@ -872,6 +1014,11 @@ export function fromAgUiMessages(
       const operations = activityContent?.["a2ui_operations"];
       if (!Array.isArray(operations)) continue;
 
+      // A surface belongs to the turn that painted it, and held reasoning is a
+      // nearer antecedent than the previous turn's assistant record, so it is
+      // released here rather than folded past this record.
+      flushPendingReasoning();
+
       let ownerIndex = -1;
       for (let i = converted.length - 1; i >= 0; i--) {
         const candidate = converted[i];
@@ -903,7 +1050,9 @@ export function fromAgUiMessages(
     }
 
     if (role === "assistant") {
-      converted.push(toAssistantSnapshotMessage(rawMessage));
+      converted.push(
+        withPendingReasoning(toAssistantSnapshotMessage(rawMessage)),
+      );
       continue;
     }
 
@@ -916,6 +1065,9 @@ export function fromAgUiMessages(
         // accept the next run.
         const opaqueId = getString(rawMessage, "id");
         if (opaqueId?.trim() && encryptedValue?.trim()) {
+          // The anchor counts materialized messages, so anything still held
+          // takes its own slot rather than folding past this record.
+          flushPendingReasoning();
           opaqueReasoning.push({
             id: opaqueId,
             encryptedValue,
@@ -939,31 +1091,37 @@ export function fromAgUiMessages(
         }
         continue;
       }
-      converted.push({
-        id: getString(rawMessage, "id") ?? generateId(),
-        role: "assistant",
-        content: [
-          {
-            type: "reasoning",
-            text,
-            ...(encryptedValue !== undefined
-              ? {
-                  providerMetadata: {
-                    [AG_UI_METADATA_NAMESPACE]: { encryptedValue },
-                  },
-                }
-              : {}),
-          },
-        ],
+      const rawReasoningId = getString(rawMessage, "id");
+      // A blank id still wins over a synthesized one on export, which would put
+      // an unaddressable record on the wire.
+      const reasoningId = rawReasoningId?.trim() ? rawReasoningId : undefined;
+      // The fold costs the record its own message id, so it rides the part
+      // instead: the export re-emits each block under the id it arrived with.
+      const meta = {
+        ...(reasoningId !== undefined ? { reasoningId } : {}),
+        ...(encryptedValue !== undefined ? { encryptedValue } : {}),
+      };
+      pendingReasoning.push({
+        id: reasoningId,
+        part: {
+          type: "reasoning",
+          text,
+          ...(Object.keys(meta).length > 0
+            ? { providerMetadata: { [AG_UI_METADATA_NAMESPACE]: meta } }
+            : {}),
+        },
       });
       continue;
     }
 
     if (role === "user" || role === "system" || role === "developer") {
+      flushPendingReasoning();
       converted.push(toUserOrSystemSnapshotMessage(role, rawMessage));
     }
   }
 
+  flushPendingReasoning();
+
   for (const { anchor, ...entry } of opaqueReasoning) {
     // Nothing followed it on the wire, so it trails the last message instead.
     const trailing = anchor >= converted.length;
@@ -976,8 +1134,24 @@ export function fromAgUiMessages(
     ]);
   }
 
-  for (let i = 0; i < converted.length; i++) {
-    const message = converted[i]!;
+  // A turn that called a tool before answering sits on the wire as a container
+  // and the records that follow it, which the live run renders as one message.
+  const folded: CoreThreadMessageLike[] = [];
+  for (const message of converted) {
+    const previous = folded[folded.length - 1];
+    if (
+      previous !== undefined &&
+      isSyntheticToolCallContainer(previous) &&
+      foldsOntoToolCallContainer(message)
+    ) {
+      folded[folded.length - 1] = foldOntoToolCallContainer(previous, message);
+      continue;
+    }
+    folded.push(message);
+  }
+
+  for (let i = 0; i < folded.length; i++) {
+    const message = folded[i]!;
     if (message.role !== "assistant") continue;
 
     const hasInterrupt =
@@ -992,7 +1166,7 @@ export function fromAgUiMessages(
       );
 
     if (hasInterrupt || hasPendingToolCall) {
-      converted[i] = {
+      folded[i] = {
         ...message,
         status: getAutoStatus(
           false,
@@ -1005,7 +1179,7 @@ export function fromAgUiMessages(
     }
   }
 
-  return converted;
+  return folded;
 }
 
 function convertAssistantMessage(