@assistant-ui/core 0.3.19 → 0.3.20

package/dist/react/types/MessagePartComponentTypes.d.ts

@@ -5,38 +5,38 @@ import "../../index.js";
 import { ToolResponse } from "assistant-stream";
 import { ComponentType, PropsWithChildren } from "react";
 //#region src/react/types/MessagePartComponentTypes.d.ts
-type EmptyMessagePartProps = {
+export type EmptyMessagePartProps = {
   status: MessagePartStatus;
 };
-type EmptyMessagePartComponent = ComponentType<EmptyMessagePartProps>;
-type TextMessagePartProps = MessagePartState & TextMessagePart;
-type TextMessagePartComponent = ComponentType<TextMessagePartProps>;
-type ReasoningMessagePartProps = MessagePartState & ReasoningMessagePart;
-type ReasoningMessagePartComponent = ComponentType<ReasoningMessagePartProps>;
-type ReasoningGroupProps = PropsWithChildren<{
+export type EmptyMessagePartComponent = ComponentType<EmptyMessagePartProps>;
+export type TextMessagePartProps = MessagePartState & TextMessagePart;
+export type TextMessagePartComponent = ComponentType<TextMessagePartProps>;
+export type ReasoningMessagePartProps = MessagePartState & ReasoningMessagePart;
+export type ReasoningMessagePartComponent = ComponentType<ReasoningMessagePartProps>;
+export type ReasoningGroupProps = PropsWithChildren<{
   startIndex: number;
   endIndex: number;
 }>;
-type ReasoningGroupComponent = ComponentType<ReasoningGroupProps>;
-type SourceMessagePartProps = MessagePartState & SourceMessagePart;
-type SourceMessagePartComponent = ComponentType<SourceMessagePartProps>;
-type ImageMessagePartProps = MessagePartState & ImageMessagePart;
-type ImageMessagePartComponent = ComponentType<ImageMessagePartProps>;
-type FileMessagePartProps = MessagePartState & FileMessagePart;
-type FileMessagePartComponent = ComponentType<FileMessagePartProps>;
+export type ReasoningGroupComponent = ComponentType<ReasoningGroupProps>;
+export type SourceMessagePartProps = MessagePartState & SourceMessagePart;
+export type SourceMessagePartComponent = ComponentType<SourceMessagePartProps>;
+export type ImageMessagePartProps = MessagePartState & ImageMessagePart;
+export type ImageMessagePartComponent = ComponentType<ImageMessagePartProps>;
+export type FileMessagePartProps = MessagePartState & FileMessagePart;
+export type FileMessagePartComponent = ComponentType<FileMessagePartProps>;
 /**
  * @deprecated Use {@link FileMessagePartProps} and render `audio/*` mime types
  * from the `File` slot.
  */
-type Unstable_AudioMessagePartProps = MessagePartState & Unstable_AudioMessagePart;
+export type Unstable_AudioMessagePartProps = MessagePartState & Unstable_AudioMessagePart;
 /**
  * @deprecated Use {@link FileMessagePartComponent} and render `audio/*` mime
  * types from the `File` slot.
  */
-type Unstable_AudioMessagePartComponent = ComponentType<Unstable_AudioMessagePartProps>;
-type DataMessagePartProps<T = any> = MessagePartState & DataMessagePart<T>;
-type DataMessagePartComponent<T = any> = ComponentType<DataMessagePartProps<T>>;
-type ToolCallMessagePartProps<TArgs = any, TResult = unknown> = MessagePartState & ToolCallMessagePart<TArgs, TResult> & {
+export type Unstable_AudioMessagePartComponent = ComponentType<Unstable_AudioMessagePartProps>;
+export type DataMessagePartProps<T = any> = MessagePartState & DataMessagePart<T>;
+export type DataMessagePartComponent<T = any> = ComponentType<DataMessagePartProps<T>>;
+export type ToolCallMessagePartProps<TArgs = any, TResult = unknown> = MessagePartState & ToolCallMessagePart<TArgs, TResult> & {
   /**
    * Sets the result for this tool-call message part.
    *
@@ -62,9 +62,9 @@ type ToolCallMessagePartProps<TArgs = any, TResult = unknown> = MessagePartState
   respondToApproval: (response: ToolApprovalResponse) => Promise<void>;
 };
 /** Component used to render a tool-call message part. */
-type ToolCallMessagePartComponent<TArgs = any, TResult = any> = ComponentType<ToolCallMessagePartProps<TArgs, TResult>>;
-type QuoteMessagePartProps = QuoteInfo;
-type QuoteMessagePartComponent = ComponentType<QuoteMessagePartProps>;
+export type ToolCallMessagePartComponent<TArgs = any, TResult = any> = ComponentType<ToolCallMessagePartProps<TArgs, TResult>>;
+export type QuoteMessagePartProps = QuoteInfo;
+export type QuoteMessagePartComponent = ComponentType<QuoteMessagePartProps>;
 /**
  * The consumer-provided allowlist of components a generative-ui spec is
  * permitted to render. Keys are the component names referenced in the spec
@@ -73,10 +73,10 @@ type QuoteMessagePartComponent = ComponentType<QuoteMessagePartProps>;
  * This registry is the security boundary in the same-realm rendering path —
  * any name not present in the registry is rejected with a typed error.
  */
-type GenerativeUIComponentRegistry = Record<string, ComponentType<any>>;
-type GenerativeUIMessagePartProps = MessagePartState & GenerativeUIMessagePart;
-type GenerativeUIMessagePartComponent = ComponentType<GenerativeUIMessagePartProps>;
-type GenerativeUIRenderProps = {
+export type GenerativeUIComponentRegistry = Record<string, ComponentType<any>>;
+export type GenerativeUIMessagePartProps = MessagePartState & GenerativeUIMessagePart;
+export type GenerativeUIMessagePartComponent = ComponentType<GenerativeUIMessagePartProps>;
+export type GenerativeUIRenderProps = {
   /** The JSON spec to render. */
   spec: GenerativeUISpec;
   /** The component allowlist. */
@@ -88,5 +88,4 @@ type GenerativeUIRenderProps = {
   }> | undefined;
 };
 //#endregion
-export { DataMessagePartComponent, DataMessagePartProps, EmptyMessagePartComponent, EmptyMessagePartProps, FileMessagePartComponent, FileMessagePartProps, GenerativeUIComponentRegistry, GenerativeUIMessagePartComponent, GenerativeUIMessagePartProps, GenerativeUIRenderProps, ImageMessagePartComponent, ImageMessagePartProps, QuoteMessagePartComponent, QuoteMessagePartProps, ReasoningGroupComponent, ReasoningGroupProps, ReasoningMessagePartComponent, ReasoningMessagePartProps, SourceMessagePartComponent, SourceMessagePartProps, TextMessagePartComponent, TextMessagePartProps, ToolCallMessagePartComponent, ToolCallMessagePartProps, Unstable_AudioMessagePartComponent, Unstable_AudioMessagePartProps };
 //# sourceMappingURL=MessagePartComponentTypes.d.ts.map

package/dist/react/types/MessagePartComponentTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessagePartComponentTypes.d.ts","names":[],"sources":["../../../src/react/types/MessagePartComponentTypes.ts"],"mappings":";;;;;;;KAmBY;EACV,QAAQ;;KAEE,4BAA4B,cAAc;KAE1C,uBAAuB,mBAAmB;KAC1C,2BAA2B,cAAc;KAEzC,4BAA4B,mBAAmB;KAC/C,gCACV,cAAc;KAEJ,sBAAsB;EAChC;EACA;;KAEU,0BAA0B,cAAc;KAExC,yBAAyB,mBAAmB;KAC5C,6BAA6B,cAAc;KAE3C,wBAAwB,mBAAmB;KAC3C,4BAA4B,cAAc;KAE1C,uBAAuB,mBAAmB;KAC1C,2BAA2B,cAAc;;;;;KAMzC,iCAAiC,mBAC3C;;;;;KAKU,qCACV,cAAc;KAEJ,qBAAqB,WAAW,mBAC1C,gBAAgB;KACN,yBAAyB,WAAW,cAC9C,qBAAqB;KAGX,yBACV,aACA,qBACE,mBACF,oBAAoB,OAAO;;;;;;;EAOzB,YAAY,QAAQ,UAAU,aAAa;;;;;EAK3C,SAAS;;;;;;;;;;;EAWT,oBAAoB,UAAU,yBAAyB;;;KAI/C,6BACV,aACA,iBACE,cAAc,yBAAyB,OAAO;KAEtC,wBAAwB;KACxB,4BAA4B,cAAc;;;;;;;;;KAU1C,gCAAgC,eAAe;KAE/C,+BAA+B,mBACzC;KACU,mCACV,cAAc;KAEJ;;EAEV,MAAM;;EAEN,YAAY;;EAEZ,WAAW;IAAgB;IAAmB"}
+{"version":3,"file":"MessagePartComponentTypes.d.ts","names":[],"sources":["../../../src/react/types/MessagePartComponentTypes.ts"],"mappings":";;;;;;;YAmBY;EACV,QAAQ;;YAEE,4BAA4B,cAAc;YAE1C,uBAAuB,mBAAmB;YAC1C,2BAA2B,cAAc;YAEzC,4BAA4B,mBAAmB;YAC/C,gCACV,cAAc;YAEJ,sBAAsB;EAChC;EACA;;YAEU,0BAA0B,cAAc;YAExC,yBAAyB,mBAAmB;YAC5C,6BAA6B,cAAc;YAE3C,wBAAwB,mBAAmB;YAC3C,4BAA4B,cAAc;YAE1C,uBAAuB,mBAAmB;YAC1C,2BAA2B,cAAc;;;;;YAMzC,iCAAiC,mBAC3C;;;;;YAKU,qCACV,cAAc;YAEJ,qBAAqB,WAAW,mBAC1C,gBAAgB;YACN,yBAAyB,WAAW,cAC9C,qBAAqB;YAGX,yBACV,aACA,qBACE,mBACF,oBAAoB,OAAO;;;;;;;EAOzB,YAAY,QAAQ,UAAU,aAAa;;;;;EAK3C,SAAS;;;;;;;;;;;EAWT,oBAAoB,UAAU,yBAAyB;;;YAI/C,6BACV,aACA,iBACE,cAAc,yBAAyB,OAAO;YAEtC,wBAAwB;YACxB,4BAA4B,cAAc;;;;;;;;;YAU1C,gCAAgC,eAAe;YAE/C,+BAA+B,mBACzC;YACU,mCACV,cAAc;YAEJ;;EAEV,MAAM;;EAEN,YAAY;;EAEZ,WAAW;IAAgB;IAAmB"}

package/dist/react/types/scopes/dataRenderers.d.ts

@@ -2,18 +2,17 @@ import { Unsubscribe } from "../../../types/unsubscribe.js";
 import { DataMessagePartComponent } from "../MessagePartComponentTypes.js";
 import "../../../index.js";
 //#region src/react/types/scopes/dataRenderers.d.ts
-type DataRenderersState = {
+export type DataRenderersState = {
   renderers: Record<string, DataMessagePartComponent[]>;
   fallbacks: DataMessagePartComponent[];
 };
-type DataRenderersMethods = {
+export type DataRenderersMethods = {
   getState(): DataRenderersState;
   setDataUI(name: string, render: DataMessagePartComponent): Unsubscribe;
   setFallbackDataUI(render: DataMessagePartComponent): Unsubscribe;
 };
-type DataRenderersClientSchema = {
+export type DataRenderersClientSchema = {
   methods: DataRenderersMethods;
 };
 //#endregion
-export { DataRenderersClientSchema, DataRenderersMethods, DataRenderersState };
 //# sourceMappingURL=dataRenderers.d.ts.map

package/dist/react/types/scopes/dataRenderers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataRenderers.d.ts","names":[],"sources":["../../../../src/react/types/scopes/dataRenderers.ts"],"mappings":";;;;KAGY;EACV,WAAW,eAAe;EAC1B,WAAW;;KAGD;EACV,YAAY;EACZ,UAAU,cAAc,QAAQ,2BAA2B;EAC3D,kBAAkB,QAAQ,2BAA2B;;KAG3C;EACV,SAAS"}
+{"version":3,"file":"dataRenderers.d.ts","names":[],"sources":["../../../../src/react/types/scopes/dataRenderers.ts"],"mappings":";;;;YAGY;EACV,WAAW,eAAe;EAC1B,WAAW;;YAGD;EACV,YAAY;EACZ,UAAU,cAAc,QAAQ,2BAA2B;EAC3D,kBAAkB,QAAQ,2BAA2B;;YAG3C;EACV,SAAS"}

package/dist/react/types/scopes/interactables.d.ts

@@ -7,11 +7,11 @@ import { Tool } from "assistant-stream";
  * Schema type matching Tool["parameters"] from assistant-stream.
  * Accepts both StandardSchemaV1 and JSONSchema7.
  */
-type Unstable_InteractableStateSchema = NonNullable<Extract<Tool, {
+export type Unstable_InteractableStateSchema = NonNullable<Extract<Tool, {
   parameters: unknown;
 }>["parameters"]>;
 type InteractableScope = "app" | "thread";
-type Unstable_InteractableDefinition = {
+export type Unstable_InteractableDefinition = {
   id: string;
   name: string;
   description: string;
@@ -20,7 +20,7 @@ type Unstable_InteractableDefinition = {
   initialState: unknown;
   scope?: InteractableScope | undefined;
 };
-type Unstable_InteractableRegistration = {
+export type Unstable_InteractableRegistration = {
   id: string;
   name: string;
   description: string;
@@ -33,21 +33,21 @@ type Unstable_InteractableRegistration = {
    */
   updateRender?: ToolCallMessagePartComponent | undefined;
 };
-type Unstable_InteractablePersistenceStatus = {
+export type Unstable_InteractablePersistenceStatus = {
   isPending: boolean;
   error: unknown;
 };
-type Unstable_InteractablesState = {
+export type Unstable_InteractablesState = {
   /** Keyed by instance id */
   definitions: Record<string, Unstable_InteractableDefinition>;
   /** Per-id persistence sync status */
   persistence: Record<string, Unstable_InteractablePersistenceStatus>;
 };
-type Unstable_InteractablePersistedState = Record<string, {
+export type Unstable_InteractablePersistedState = Record<string, {
   name: string;
   state: unknown;
 }>;
-type Unstable_InteractablePersistenceAdapter = {
+export type Unstable_InteractablePersistenceAdapter = {
   save(state: Unstable_InteractablePersistedState): void | Promise<void>;
   /**
    * Restores previously saved state. Called when the adapter is attached;
@@ -56,10 +56,10 @@ type Unstable_InteractablePersistenceAdapter = {
    */
   load?(): Unstable_InteractablePersistedState | null | undefined | Promise<Unstable_InteractablePersistedState | null | undefined>;
 };
-type Unstable_InteractablesConfig = {
+export type Unstable_InteractablesConfig = {
   persistence?: Unstable_InteractablePersistenceAdapter | undefined;
 };
-type Unstable_InteractablesMethods = {
+export type Unstable_InteractablesMethods = {
   getState(): Unstable_InteractablesState;
   register(def: Unstable_InteractableRegistration): Unsubscribe;
   setState(id: string, updater: (prev: unknown) => unknown): void;
@@ -68,9 +68,8 @@ type Unstable_InteractablesMethods = {
   setPersistenceAdapter(adapter: Unstable_InteractablePersistenceAdapter | undefined): void;
   flush(): Promise<void>;
 };
-type Unstable_InteractablesClientSchema = {
+export type Unstable_InteractablesClientSchema = {
   methods: Unstable_InteractablesMethods;
 };
 //#endregion
-export { Unstable_InteractableDefinition, Unstable_InteractablePersistedState, Unstable_InteractablePersistenceAdapter, Unstable_InteractablePersistenceStatus, Unstable_InteractableRegistration, Unstable_InteractableStateSchema, Unstable_InteractablesClientSchema, Unstable_InteractablesConfig, Unstable_InteractablesMethods, Unstable_InteractablesState };
 //# sourceMappingURL=interactables.d.ts.map

package/dist/react/types/scopes/interactables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactables.d.ts","names":[],"sources":["../../../../src/react/types/scopes/interactables.ts"],"mappings":";;;;;;;;;KAQY,mCAAmC,YAC7C,QAAQ;EAAQ;;KAGb;KAEO;EACV;EACA;EACA;EACA,aAAa;EACb;EACA;EACA,QAAQ;;KAGE;EACV;EACA;EACA;EACA,aAAa;EACb;;;;;;EAMA,eAAe;;KAGL;EACV;EACA;;KAGU;;EAEV,aAAa,eAAe;;EAE5B,aAAa,eAAe;;KAGlB,sCAAsC;EAE9C;EAAc;;KAGN;EACV,KAAK,OAAO,6CAA6C;;;;;;EAMzD,SACI,yDAGA,QAAQ;;KAGF;EACV,cAAc;;KAGJ;EACV,YAAY;EACZ,SAAS,KAAK,oCAAoC;EAClD,SAAS,YAAY,UAAU;EAC/B,eAAe;EACf,YAAY,OAAO;EACnB,sBACE,SAAS;EAEX,SAAS;;KAGC;EACV,SAAS"}
+{"version":3,"file":"interactables.d.ts","names":[],"sources":["../../../../src/react/types/scopes/interactables.ts"],"mappings":";;;;;;;;;YAQY,mCAAmC,YAC7C,QAAQ;EAAQ;;KAGb;YAEO;EACV;EACA;EACA;EACA,aAAa;EACb;EACA;EACA,QAAQ;;YAGE;EACV;EACA;EACA;EACA,aAAa;EACb;;;;;;EAMA,eAAe;;YAGL;EACV;EACA;;YAGU;;EAEV,aAAa,eAAe;;EAE5B,aAAa,eAAe;;YAGlB,sCAAsC;EAE9C;EAAc;;YAGN;EACV,KAAK,OAAO,6CAA6C;;;;;;EAMzD,SACI,yDAGA,QAAQ;;YAGF;EACV,cAAc;;YAGJ;EACV,YAAY;EACZ,SAAS,KAAK,oCAAoC;EAClD,SAAS,YAAY,UAAU;EAC/B,eAAe;EACf,YAAY,OAAO;EACnB,sBACE,SAAS;EAEX,SAAS;;YAGC;EACV,SAAS"}

package/dist/react/types/scopes/tools.d.ts

@@ -3,7 +3,7 @@ import { ToolCallText } from "../../../model-context/tool-call-text.js";
 import { ToolCallMessagePartComponent } from "../MessagePartComponentTypes.js";
 import "../../../index.js";
 //#region src/react/types/scopes/tools.d.ts
-type McpAppResourceOutput = {
+export type McpAppResourceOutput = {
   readonly render: ToolCallMessagePartComponent;
 };
 /**
@@ -17,20 +17,19 @@ type ToolRegistration = {
   /** Whether this UI renders standalone, outside the chain-of-thought trace. */
   readonly standalone: boolean;
 };
-type ToolsState = {
+export type ToolsState = {
   /** Registered tool UIs (renderer + presentation options) keyed by tool name. */
   toolUIs: Record<string, readonly ToolRegistration[]>;
   mcpApp?: McpAppResourceOutput | undefined;
 };
-type ToolsMethods = {
+export type ToolsMethods = {
   getState(): ToolsState;
   setToolUI(toolName: string, render: ToolCallMessagePartComponent, options?: {
     standalone?: boolean;
   }): Unsubscribe;
 };
-type ToolsClientSchema = {
+export type ToolsClientSchema = {
   methods: ToolsMethods;
 };
 //#endregion
-export { McpAppResourceOutput, ToolsClientSchema, ToolsMethods, ToolsState };
 //# sourceMappingURL=tools.d.ts.map

package/dist/react/types/scopes/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","names":[],"sources":["../../../../src/react/types/scopes/tools.ts"],"mappings":";;;;;KAIY;WACD,QAAQ;;;;;;;KAQd;WACM,QAAQ;WACR,aAAa;;WAEb;;KAGC;;EAEV,SAAS,wBAAwB;EACjC,SAAS;;KAGC;EACV,YAAY;EACZ,UACE,kBACA,QAAQ,8BACR;IAAY;MACX;;KAGO;EACV,SAAS"}
+{"version":3,"file":"tools.d.ts","names":[],"sources":["../../../../src/react/types/scopes/tools.ts"],"mappings":";;;;;YAIY;WACD,QAAQ;;;;;;;KAQd;WACM,QAAQ;WACR,aAAa;;WAEb;;YAGC;;EAEV,SAAS,wBAAwB;EACjC,SAAS;;YAGC;EACV,YAAY;EACZ,UACE,kBACA,QAAQ,8BACR;IAAY;MACX;;YAGO;EACV,SAAS"}

package/dist/react/utils/getMessageQuote.d.ts

@@ -5,7 +5,6 @@ type MessageQuoteState = {
     metadata?: unknown;
   };
 };
-declare const getMessageQuote: (state: MessageQuoteState) => QuoteInfo | undefined;
+export declare const getMessageQuote: (state: MessageQuoteState) => QuoteInfo | undefined;
 //#endregion
-export { getMessageQuote };
 //# sourceMappingURL=getMessageQuote.d.ts.map

package/dist/react/utils/getMessageQuote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMessageQuote.d.ts","names":[],"sources":["../../../src/react/utils/getMessageQuote.ts"],"mappings":";;KAEK;EACH;IACE;;;cAIS,kBACX,OAAO,sBACN"}
+{"version":3,"file":"getMessageQuote.d.ts","names":[],"sources":["../../../src/react/utils/getMessageQuote.ts"],"mappings":";;KAEK;EACH;IACE;;;qBAIS,kBACX,OAAO,sBACN"}

package/dist/react/utils/groupParts.d.ts

@@ -7,7 +7,7 @@ import { ToolsState } from "../types/scopes/tools.js";
  * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)
  * without the part itself having to carry that information.
  */
-type GroupByContext = {
+export type GroupByContext = {
   /** Tool UIs registered in the tool-UI registry, keyed by tool name. */
   readonly toolUIs?: ToolsState["toolUIs"];
 };
@@ -29,7 +29,7 @@ type GroupByContext = {
  * `[parts, memoKey]` across renders — even when the helper call site
  * reconstructs the function each render.
  */
-declare const GROUPBY_MEMO_KEY: unique symbol;
+export declare const GROUPBY_MEMO_KEY: unique symbol;
 /**
  * Synthetic part-type keys recognized by {@link groupPartByType}, in
  * addition to real {@link PartState} types:
@@ -74,9 +74,9 @@ type GroupPartType = PartState["type"] | "standalone-tool-call" | `tool-call:${s
  * </MessagePrimitive.GroupedParts>
  * ```
  */
-declare const groupPartByType: <TKey extends `group-${string}`>(map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>) => ((part: PartState, context?: GroupByContext) => readonly TKey[]);
-type GroupNode = GroupNodeGroup | GroupNodePart;
-interface GroupNodeGroup {
+export declare const groupPartByType: <TKey extends `group-${string}`>(map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>) => ((part: PartState, context?: GroupByContext) => readonly TKey[]);
+export type GroupNode = GroupNodeGroup | GroupNodePart;
+export interface GroupNodeGroup {
   readonly type: "group";
   /** Current-level group key (last segment of the path). */
   readonly key: string;
@@ -91,7 +91,7 @@ interface GroupNodeGroup {
   readonly indices: readonly number[];
   readonly children: readonly GroupNode[];
 }
-interface GroupNodePart {
+export interface GroupNodePart {
   readonly type: "part";
   /** Index of the part in the message. */
   readonly index: number;
@@ -110,7 +110,6 @@ interface GroupNodePart {
  * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a
  * tool call id), from which nodes derive an `idKey`.
  */
-declare const buildGroupTree: (paths: readonly (readonly string[])[], partIds?: readonly (string | undefined)[]) => readonly GroupNode[];
+export declare const buildGroupTree: (paths: readonly (readonly string[])[], partIds?: readonly (string | undefined)[]) => readonly GroupNode[];
 //#endregion
-export { GROUPBY_MEMO_KEY, GroupByContext, GroupNode, GroupNodeGroup, GroupNodePart, buildGroupTree, groupPartByType };
 //# sourceMappingURL=groupParts.d.ts.map

package/dist/react/utils/groupParts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"groupParts.d.ts","names":[],"sources":["../../../src/react/utils/groupParts.ts"],"mappings":";;;;;;;;;KAUY;;WAED,UAAU;;;;;;;;;;;;;;;;;;;;cAsBR;;;;;;;;;;;;;;;KAkBR,gBACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCS,kBAAmB,gCAC9B,KAAK,QAAQ,SAAS,OAAO,wBAAwB,gBAClD,MAAM,WAAW,UAAU,4BAA4B;KA8BhD,YAAY,iBAAiB;UAExB;WACN;;WAEA;;WAEA;;;;;WAKA;;WAEA;WACA,mBAAmB;;UAGb;WACN;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;cAiCE,iBACX,uCACA,uDACU"}
+{"version":3,"file":"groupParts.d.ts","names":[],"sources":["../../../src/react/utils/groupParts.ts"],"mappings":";;;;;;;;;YAUY;;WAED,UAAU;;;;;;;;;;;;;;;;;;;;qBAsBR;;;;;;;;;;;;;;;KAkBR,gBACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiCS,kBAAmB,gCAC9B,KAAK,QAAQ,SAAS,OAAO,wBAAwB,gBAClD,MAAM,WAAW,UAAU,4BAA4B;YA8BhD,YAAY,iBAAiB;iBAExB;WACN;;WAEA;;WAEA;;;;;WAKA;;WAEA;WACA,mBAAmB;;iBAGb;WACN;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;qBAiCE,iBACX,uCACA,uDACU"}

package/dist/react/utils/useJSONEqual.d.ts

@@ -1,13 +1,12 @@
 import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/react/utils/useJSONEqual.d.ts
-declare function useJSONEqualValue<T extends ReadonlyJSONValue>(value: T): T;
+export declare function useJSONEqualValue<T extends ReadonlyJSONValue>(value: T): T;
 /**
  * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an
  * equal-but-fresh value on every store update — e.g. folding over
  * `thread.messages`, whose identity changes on every streaming token — where a
  * shallow compare would re-render regardless.
  */
-declare function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U;
+export declare function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U;
 //#endregion
-export { useJSONEqual, useJSONEqualValue };
 //# sourceMappingURL=useJSONEqual.d.ts.map

package/dist/react/utils/useJSONEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useJSONEqual.d.ts","names":[],"sources":["../../../src/react/utils/useJSONEqual.ts"],"mappings":";;iBAIgB,kBAAkB,UAAU,mBAAmB,OAAO,IAAI;;;;;;;iBAc1D,aAAa,GAAG,GAAG,WAAW,OAAO,MAAM,KAAK,OAAO,MAAM"}
+{"version":3,"file":"useJSONEqual.d.ts","names":[],"sources":["../../../src/react/utils/useJSONEqual.ts"],"mappings":";;wBAIgB,kBAAkB,UAAU,mBAAmB,OAAO,IAAI;;;;;;;wBAc1D,aAAa,GAAG,GAAG,WAAW,OAAO,MAAM,KAAK,OAAO,MAAM"}

package/dist/react/utils/useJSONSchemaDependency.d.ts

@@ -1,7 +1,6 @@
 import { Unstable_InteractableStateSchema } from "../types/scopes/interactables.js";
 import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/react/utils/useJSONSchemaDependency.d.ts
-declare function useJSONSchemaDependency(schema: Unstable_InteractableStateSchema): ReadonlyJSONValue;
+export declare function useJSONSchemaDependency(schema: Unstable_InteractableStateSchema): ReadonlyJSONValue;
 //#endregion
-export { useJSONSchemaDependency };
 //# sourceMappingURL=useJSONSchemaDependency.d.ts.map

package/dist/react/utils/useJSONSchemaDependency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useJSONSchemaDependency.d.ts","names":[],"sources":["../../../src/react/utils/useJSONSchemaDependency.ts"],"mappings":";;;iBAOgB,wBACd,QAAQ,mCACP"}
+{"version":3,"file":"useJSONSchemaDependency.d.ts","names":[],"sources":["../../../src/react/utils/useJSONSchemaDependency.ts"],"mappings":";;;wBAOgB,wBACd,QAAQ,mCACP"}

package/dist/runtime/api/assistant-runtime.d.ts

@@ -4,7 +4,7 @@ import { AssistantRuntimeCore } from "../interfaces/assistant-runtime-core.js";
 import { ThreadListRuntime, ThreadListRuntimeImpl } from "./thread-list-runtime.js";
 import { ThreadRuntime } from "./thread-runtime.js";
 //#region src/runtime/api/assistant-runtime.d.ts
-type AssistantRuntime = {
+export type AssistantRuntime = {
   /**
    * The threads in this assistant.
    */
@@ -20,7 +20,7 @@ type AssistantRuntime = {
    */
   registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
 };
-declare class AssistantRuntimeImpl implements AssistantRuntime {
+export declare class AssistantRuntimeImpl implements AssistantRuntime {
   readonly threads: ThreadListRuntimeImpl;
   readonly _thread: ThreadRuntime;
   private readonly _core;
@@ -30,5 +30,4 @@ declare class AssistantRuntimeImpl implements AssistantRuntime {
   registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
 }
 //#endregion
-export { AssistantRuntime, AssistantRuntimeImpl };
 //# sourceMappingURL=assistant-runtime.d.ts.map

package/dist/runtime/api/assistant-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assistant-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/assistant-runtime.ts"],"mappings":";;;;;;KASY;;;;WAID,SAAS;;;;WAKT,QAAQ;;;;;;EAOjB,6BAA6B,UAAU,uBAAuB;;cAGnD,gCAAgC;WAC3B,SAAO;WAEP,SAAS;mBAER;EAEL,YAAA,OAAO;YAQT;MAKC,UAAM;EAIV,6BAA6B,UAAU,uBAAoB"}
+{"version":3,"file":"assistant-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/assistant-runtime.ts"],"mappings":";;;;;;YASY;;;;WAID,SAAS;;;;WAKT,QAAQ;;;;;;EAOjB,6BAA6B,UAAU,uBAAuB;;qBAGnD,gCAAgC;WAC3B,SAAO;WAEP,SAAS;mBAER;EAEL,YAAA,OAAO;YAQT;MAKC,UAAM;EAIV,6BAA6B,UAAU,uBAAoB"}

package/dist/runtime/api/attachment-runtime.d.ts

@@ -13,14 +13,14 @@ type ThreadComposerAttachmentState = Attachment & {
 type EditComposerAttachmentState = Attachment & {
   readonly source: "edit-composer";
 };
-type AttachmentState = ThreadComposerAttachmentState | EditComposerAttachmentState | MessageAttachmentState;
+export type AttachmentState = ThreadComposerAttachmentState | EditComposerAttachmentState | MessageAttachmentState;
 type AttachmentSnapshotBinding<Source extends AttachmentRuntimeSource> = SubscribableWithState<AttachmentState & {
   source: Source;
 }, AttachmentRuntimePath & {
   attachmentSource: Source;
 }>;
 type AttachmentRuntimeSource = AttachmentState["source"];
-type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource> = {
+export type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource> = {
   readonly path: AttachmentRuntimePath & {
     attachmentSource: TSource;
   };
@@ -31,7 +31,7 @@ type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRunti
   remove(): Promise<void>;
   subscribe(callback: () => void): Unsubscribe;
 };
-declare abstract class AttachmentRuntimeImpl<Source extends AttachmentRuntimeSource = AttachmentRuntimeSource> implements AttachmentRuntime {
+export declare abstract class AttachmentRuntimeImpl<Source extends AttachmentRuntimeSource = AttachmentRuntimeSource> implements AttachmentRuntime {
   get path(): AttachmentRuntimePath & {
     attachmentSource: Source;
   };
@@ -50,16 +50,15 @@ declare abstract class ComposerAttachmentRuntime<Source extends "thread-composer
   constructor(core: AttachmentSnapshotBinding<Source>, _composerApi: ComposerRuntimeCoreBinding);
   remove(): Promise<void>;
 }
-declare class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
+export declare class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
   get source(): "thread-composer";
 }
-declare class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
+export declare class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
   get source(): "edit-composer";
 }
-declare class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
+export declare class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
   get source(): "message";
   remove(): never;
 }
 //#endregion
-export { AttachmentRuntime, AttachmentRuntimeImpl, AttachmentState, EditComposerAttachmentRuntimeImpl, MessageAttachmentRuntimeImpl, ThreadComposerAttachmentRuntimeImpl };
 //# sourceMappingURL=attachment-runtime.d.ts.map

package/dist/runtime/api/attachment-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attachment-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/attachment-runtime.ts"],"mappings":";;;;;;KAOK,yBAAyB;WACnB;;KAGN,gCAAgC;WAC1B;;KAGN,8BAA8B;WACxB;;KAGC,kBACR,gCACA,8BACA;KAEC,0BAA0B,eAAe,2BAC5C,sBACE;EAAoB,QAAQ;GAC5B;EAA0B,kBAAkB;;KAG3C,0BAA0B;KAEnB,kBACV,gBAAgB,0BAA0B;WAEjC,MAAM;IAA0B,kBAAkB;;WAClD,QAAQ;EACjB,YAAY;IAAoB,QAAQ;;EACxC,UAAU;EACV,UAAU,uBAAuB;;uBAGb,sBACpB,eAAe,0BAA0B,oCAC9B;MACA,QAAI;;;eAIK,UAAU;UAEtB;EAEI,YAAA,OAAO,0BAA0B;YAKnC;EAMH,YAAY;IAAoB,QAAQ;;WAI/B,UAAU;EAEnB,UAAU,uBAAoB;;uBAKxB,0BACb,4DACQ,sBAAsB;UACtB;EAGN,YAAA,MAAM,0BAA0B,SAChC,cAAc;EAMT,UAAM;;cAOF,4CAA4C;MAC5C;;cAKA,0CAA0C;MAC1C;;cAKA,qCAAqC;MACrC;EAIJ"}
+{"version":3,"file":"attachment-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/attachment-runtime.ts"],"mappings":";;;;;;KAOK,yBAAyB;WACnB;;KAGN,gCAAgC;WAC1B;;KAGN,8BAA8B;WACxB;;YAGC,kBACR,gCACA,8BACA;KAEC,0BAA0B,eAAe,2BAC5C,sBACE;EAAoB,QAAQ;GAC5B;EAA0B,kBAAkB;;KAG3C,0BAA0B;YAEnB,kBACV,gBAAgB,0BAA0B;WAEjC,MAAM;IAA0B,kBAAkB;;WAClD,QAAQ;EACjB,YAAY;IAAoB,QAAQ;;EACxC,UAAU;EACV,UAAU,uBAAuB;;8BAGb,sBACpB,eAAe,0BAA0B,oCAC9B;MACA,QAAI;;;eAIK,UAAU;UAEtB;EAEI,YAAA,OAAO,0BAA0B;YAKnC;EAMH,YAAY;IAAoB,QAAQ;;WAI/B,UAAU;EAEnB,UAAU,uBAAoB;;uBAKxB,0BACb,4DACQ,sBAAsB;UACtB;EAGN,YAAA,MAAM,0BAA0B,SAChC,cAAc;EAMT,UAAM;;qBAOF,4CAA4C;MAC5C;;qBAKA,0CAA0C;MAC1C;;qBAKA,qCAAqC;MACrC;EAIJ"}

package/dist/runtime/api/bindings.d.ts

@@ -5,14 +5,14 @@ import { ComposerRuntimePath, MessageRuntimePath } from "./paths.js";
 import { ThreadListItemStatus } from "../interfaces/thread-list-runtime-core.js";
 import { SubscribableWithState } from "../../subscribable/subscribable.js";
 //#region src/runtime/api/bindings.d.ts
-type ComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined, ComposerRuntimePath>;
-type ThreadComposerRuntimeCoreBinding = SubscribableWithState<ThreadComposerRuntimeCore | undefined, ComposerRuntimePath & {
+export type ComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined, ComposerRuntimePath>;
+export type ThreadComposerRuntimeCoreBinding = SubscribableWithState<ThreadComposerRuntimeCore | undefined, ComposerRuntimePath & {
   composerSource: "thread";
 }>;
-type EditComposerRuntimeCoreBinding = SubscribableWithState<EditComposerRuntimeCore | undefined, ComposerRuntimePath & {
+export type EditComposerRuntimeCoreBinding = SubscribableWithState<EditComposerRuntimeCore | undefined, ComposerRuntimePath & {
   composerSource: "edit";
 }>;
-type MessageStateBinding = SubscribableWithState<ThreadMessage & {
+export type MessageStateBinding = SubscribableWithState<ThreadMessage & {
   readonly parentId: string | null;
   readonly index: number;
   readonly isLast: boolean;
@@ -20,7 +20,7 @@ type MessageStateBinding = SubscribableWithState<ThreadMessage & {
   readonly branchCount: number;
   readonly speech: SpeechState | undefined;
 }, MessageRuntimePath>;
-type ThreadListItemState = {
+export type ThreadListItemState = {
   readonly isMain: boolean;
   /**
    * Whether this thread has a run in progress, including a run that continues
@@ -36,5 +36,4 @@ type ThreadListItemState = {
   readonly custom?: Record<string, unknown> | undefined;
 };
 //#endregion
-export { ComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, MessageStateBinding, ThreadComposerRuntimeCoreBinding, ThreadListItemState };
 //# sourceMappingURL=bindings.d.ts.map

package/dist/runtime/api/bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bindings.d.ts","names":[],"sources":["../../../src/runtime/api/bindings.ts"],"mappings":";;;;;;;KAUY,6BAA6B,sBACvC,iCACA;KAGU,mCAAmC,sBAC7C,uCACA;EAAwB;;KAGd,iCAAiC,sBAC3C,qCACA;EAAwB;;KAGd,sBAAsB,sBAChC;WACW;WACA;WACA;WACA;WACA;WACA,QAAQ;GAEnB;KAGU;WACD;;;;;WAKA;WACA;WACA;WACA;WACA,QAVC;WAWD;WACA,gBAAgB;WAChB,SAAS"}
+{"version":3,"file":"bindings.d.ts","names":[],"sources":["../../../src/runtime/api/bindings.ts"],"mappings":";;;;;;;YAUY,6BAA6B,sBACvC,iCACA;YAGU,mCAAmC,sBAC7C,uCACA;EAAwB;;YAGd,iCAAiC,sBAC3C,qCACA;EAAwB;;YAGd,sBAAsB,sBAChC;WACW;WACA;WACA;WACA;WACA;WACA,QAAQ;GAEnB;YAGU;WACD;;;;;WAKA;WACA;WACA;WACA;WACA,QAVC;WAWD;WACA,gBAAgB;WAChB,SAAS"}

package/dist/runtime/api/composer-runtime.d.ts

@@ -37,16 +37,16 @@ type BaseComposerState = {
   /** Messages waiting to be processed. Empty unless the `queue` capability is set. */
   readonly queue: readonly QueueItemState[];
 };
-type ThreadComposerState = BaseComposerState & {
+export type ThreadComposerState = BaseComposerState & {
   readonly type: "thread";
 };
-type EditComposerState = BaseComposerState & {
+export type EditComposerState = BaseComposerState & {
   readonly type: "edit";
   readonly parentId: string | null;
   readonly sourceId: string | null;
 };
-type ComposerState = ThreadComposerState | EditComposerState;
-type ComposerRuntime = {
+export type ComposerState = ThreadComposerState | EditComposerState;
+export type ComposerRuntime = {
   readonly path: ComposerRuntimePath;
   readonly type: "edit" | "thread";
   /**
@@ -137,7 +137,7 @@ type ComposerRuntime = {
    */
   unstable_on<E extends ComposerRuntimeEventType>(event: E, callback: ComposerRuntimeEventCallback<E>): Unsubscribe;
 };
-declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
+export declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
   get path(): ComposerRuntimePath;
   abstract get type(): "edit" | "thread";
   protected _core: ComposerRuntimeCoreBinding;
@@ -163,7 +163,7 @@ declare abstract class ComposerRuntimeImpl implements ComposerRuntime {
   unstable_on<E extends ComposerRuntimeEventType>(event: E, callback: ComposerRuntimeEventCallback<E>): Unsubscribe;
   abstract getAttachmentByIndex(idx: number): AttachmentRuntime;
 }
-type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+export type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
   readonly path: ComposerRuntimePath & {
     composerSource: "thread";
   };
@@ -173,7 +173,7 @@ type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentBy
     source: "thread-composer";
   };
 };
-declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements ThreadComposerRuntime {
+export declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements ThreadComposerRuntime {
   get path(): ComposerRuntimePath & {
     composerSource: "thread";
   };
@@ -183,7 +183,7 @@ declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements T
   getState(): ThreadComposerState;
   getAttachmentByIndex(idx: number): ThreadComposerAttachmentRuntimeImpl;
 }
-type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+export type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
   readonly path: ComposerRuntimePath & {
     composerSource: "edit";
   };
@@ -194,7 +194,7 @@ type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIn
     source: "edit-composer";
   };
 };
-declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements EditComposerRuntime {
+export declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements EditComposerRuntime {
   get path(): ComposerRuntimePath & {
     composerSource: "edit";
   };
@@ -208,5 +208,5 @@ declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements Edi
   getAttachmentByIndex(idx: number): EditComposerAttachmentRuntimeImpl;
 }
 //#endregion
-export { ComposerRuntime, type ComposerRuntimeCoreBinding, ComposerRuntimeImpl, ComposerState, EditComposerRuntime, type EditComposerRuntimeCoreBinding, EditComposerRuntimeImpl, EditComposerState, ThreadComposerRuntime, type ThreadComposerRuntimeCoreBinding, ThreadComposerRuntimeImpl, ThreadComposerState };
+export type { ComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, ThreadComposerRuntimeCoreBinding };
 //# sourceMappingURL=composer-runtime.d.ts.map

package/dist/runtime/api/composer-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composer-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/composer-runtime.ts"],"mappings":";;;;;;;;;;;KA2CK;;;;;;WAMM;WACA;WACA;WACA;WAEA;WACA,MAAM;WACN,sBAAsB;WACtB,WAAW;WAEX;;;;;WAMA,WAAW;;;;;WAMX,OAAO;;WAGP,gBAAgB;;KAGf,sBAAsB;WACvB;;KAGC,oBAAoB;WACrB;WACA;WACA;;KAGC,gBAAgB,sBAAsB;KAuDtC;WACD,MAAM;WACN;;;;EAKT,YAAY;;;;;;;;;;EAWZ,cAAc,kBAAkB,OAAO,mBAAmB;;;;;EAM1D,QAAQ;;;;;EAMR,QAAQ,MAAM;;;;;;;;;;;;EAad,aAAa,WAAW;;;;EAKxB,SAAS;;;;EAKT,oBAAoB;;;;;EAMpB,KAAK,UAAU;;;;EAKf;;EAGA,eAAe;;EAGf,cAAc,qBAAqB,WAAW;;EAG9C,gBAAgB;;;;;EAMhB,UAAU,uBAAuB;;;;;EAMjC,qBAAqB,cAAc;;;;;EAMnC;;;;EAKA;;;;;EAMA,SAAS,OAAO;;;;EAKhB,YAAY,UAAU,0BACpB,OAAO,GACP,UAAU,6BAA6B,KACtC;;uBAGiB,+BAA+B;MACxC,QAAI;eAIK;YAEV,OAAO;EAEL,YAAA,OAAO;YAIT;WAqBM,YAAY;EAErB,QAAQ;EAMR,aAAa,WAAW;EAMxB,cAAc,kBAAkB,OAAO,mBAAgB;EAMvD,SAAK;EAML,oBAAgB;EAMhB,KAAK,UAAU;EAMf;EAMA,eAAe;EAIf,cAAc,qBAAqB,WAAW;EAM9C,gBAAgB;EAMhB,QAAQ,MAAM;EAMd;EAMA;EAMA,SAAS,OAAO;EAMhB,UAAU,uBAAoB;UAI7B;EAKD,YAAY,UAAU,0BAC3B,OAAO,GACP,UAAU,6BAA6B,KACtC;WAYa,qBAAqB,cAAc;;KAGzC,wBAAwB,KAClC;WAGS,MAAM;IAAwB;;WAC9B;EACT,YAAY;EAEZ,qBACE,cACC;IAAsB;;;cAGd,kCACH,+BACG;MAES,QACQ;IACxB;;MAIO;UAIH;EAEI,YAAA,MAAM;EAgBF,YAAY;EAIrB,qBAAqB,cAAW;;KA0B7B,sBAAsB,KAChC;WAGS,MAAM;IAAwB;;WAC9B;EAET,YAAY;EACZ;EAEA,qBACE,cACC;IAAsB;;;cAGd,gCACH,+BACG;MAES,QACQ;IAAwB;;MAGzC;UAIH;UACA;EAEI,YAAA,MAAM,gCAAgC;EAmBlC;EAKA,YAAY;EAIrB;EAIA,qBAAqB,cAAW"}
+{"version":3,"file":"composer-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/composer-runtime.ts"],"mappings":";;;;;;;;;;;KA2CK;;;;;;WAMM;WACA;WACA;WACA;WAEA;WACA,MAAM;WACN,sBAAsB;WACtB,WAAW;WAEX;;;;;WAMA,WAAW;;;;;WAMX,OAAO;;WAGP,gBAAgB;;YAGf,sBAAsB;WACvB;;YAGC,oBAAoB;WACrB;WACA;WACA;;YAGC,gBAAgB,sBAAsB;YAuDtC;WACD,MAAM;WACN;;;;EAKT,YAAY;;;;;;;;;;EAWZ,cAAc,kBAAkB,OAAO,mBAAmB;;;;;EAM1D,QAAQ;;;;;EAMR,QAAQ,MAAM;;;;;;;;;;;;EAad,aAAa,WAAW;;;;EAKxB,SAAS;;;;EAKT,oBAAoB;;;;;EAMpB,KAAK,UAAU;;;;EAKf;;EAGA,eAAe;;EAGf,cAAc,qBAAqB,WAAW;;EAG9C,gBAAgB;;;;;EAMhB,UAAU,uBAAuB;;;;;EAMjC,qBAAqB,cAAc;;;;;EAMnC;;;;EAKA;;;;;EAMA,SAAS,OAAO;;;;EAKhB,YAAY,UAAU,0BACpB,OAAO,GACP,UAAU,6BAA6B,KACtC;;8BAGiB,+BAA+B;MACxC,QAAI;eAIK;YAEV,OAAO;EAEL,YAAA,OAAO;YAIT;WAqBM,YAAY;EAErB,QAAQ;EAMR,aAAa,WAAW;EAMxB,cAAc,kBAAkB,OAAO,mBAAgB;EAMvD,SAAK;EAML,oBAAgB;EAMhB,KAAK,UAAU;EAMf;EAMA,eAAe;EAIf,cAAc,qBAAqB,WAAW;EAM9C,gBAAgB;EAMhB,QAAQ,MAAM;EAMd;EAMA;EAMA,SAAS,OAAO;EAMhB,UAAU,uBAAoB;UAI7B;EAKD,YAAY,UAAU,0BAC3B,OAAO,GACP,UAAU,6BAA6B,KACtC;WAYa,qBAAqB,cAAc;;YAGzC,wBAAwB,KAClC;WAGS,MAAM;IAAwB;;WAC9B;EACT,YAAY;EAEZ,qBACE,cACC;IAAsB;;;qBAGd,kCACH,+BACG;MAES,QACQ;IACxB;;MAIO;UAIH;EAEI,YAAA,MAAM;EAgBF,YAAY;EAIrB,qBAAqB,cAAW;;YA0B7B,sBAAsB,KAChC;WAGS,MAAM;IAAwB;;WAC9B;EAET,YAAY;EACZ;EAEA,qBACE,cACC;IAAsB;;;qBAGd,gCACH,+BACG;MAES,QACQ;IAAwB;;MAGzC;UAIH;UACA;EAEI,YAAA,MAAM,gCAAgC;EAmBlC;EAKA,YAAY;EAIrB;EAIA,qBAAqB,cAAW"}

package/dist/runtime/api/message-part-runtime.d.ts

@@ -6,11 +6,11 @@ import { MessageStateBinding } from "./bindings.js";
 import { ThreadRuntimeCoreBinding } from "./thread-runtime.js";
 import { ToolResponse } from "assistant-stream";
 //#region src/runtime/api/message-part-runtime.d.ts
-type MessagePartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
+export type MessagePartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
   readonly status: MessagePartStatus | ToolCallMessagePartStatus;
 };
 type MessagePartSnapshotBinding = SubscribableWithState<MessagePartState, MessagePartRuntimePath>;
-type MessagePartRuntime = {
+export type MessagePartRuntime = {
   addToolResult(result: any | ToolResponse<any>): void;
   resumeToolCall(payload: unknown): void;
   respondToToolApproval(response: ToolApprovalResponse): Promise<void>;
@@ -18,7 +18,7 @@ type MessagePartRuntime = {
   getState(): MessagePartState;
   subscribe(callback: () => void): Unsubscribe;
 };
-declare class MessagePartRuntimeImpl implements MessagePartRuntime {
+export declare class MessagePartRuntimeImpl implements MessagePartRuntime {
   get path(): MessagePartRuntimePath;
   private contentBinding;
   private messageApi;
@@ -32,5 +32,4 @@ declare class MessagePartRuntimeImpl implements MessagePartRuntime {
   subscribe(callback: () => void): Unsubscribe;
 }
 //#endregion
-export { MessagePartRuntime, MessagePartRuntimeImpl, MessagePartState };
 //# sourceMappingURL=message-part-runtime.d.ts.map

package/dist/runtime/api/message-part-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-part-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/message-part-runtime.ts"],"mappings":";;;;;;;;KAeY,oBACR,wBACA;WAEO,QAAQ,oBAAoB;;KAGlC,6BAA6B,sBAChC,kBACA;KAGU;EACV,cAAc,cAAc;EAC5B,eAAe;EACf,sBAAsB,UAAU,uBAAuB;WAE9C,MAAM;EACf,YAAY;EACZ,UAAU,uBAAuB;;cAGtB,kCAAkC;MAClC,QAAI;UAIP;UACA;UACA;EAGN,YAAA,gBAAgB,4BAChB,aAAa,qBACb,YAAY;YAQJ;EAQH,YAAQ;EAIR,cAAc,cAAc;EA8B5B,eAAe;EAgBf,sBAAsB,UAAU,uBAAuB;EAyBvD,UAAU,uBAAoB"}
+{"version":3,"file":"message-part-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/message-part-runtime.ts"],"mappings":";;;;;;;;YAeY,oBACR,wBACA;WAEO,QAAQ,oBAAoB;;KAGlC,6BAA6B,sBAChC,kBACA;YAGU;EACV,cAAc,cAAc;EAC5B,eAAe;EACf,sBAAsB,UAAU,uBAAuB;WAE9C,MAAM;EACf,YAAY;EACZ,UAAU,uBAAuB;;qBAGtB,kCAAkC;MAClC,QAAI;UAIP;UACA;UACA;EAGN,YAAA,gBAAgB,4BAChB,aAAa,qBACb,YAAY;YAQJ;EAQH,YAAQ;EAIR,cAAc,cAAc;EAiC5B,eAAe;EAgBf,sBAAsB,UAAU,uBAAuB;EAyBvD,UAAU,uBAAoB"}

package/dist/runtime/api/message-part-runtime.js

@@ -40,8 +40,9 @@ var MessagePartRuntimeImpl = class {
 			toolName,
 			toolCallId,
 			result: response.result,
-			artifact: response.artifact,
-			isError: response.isError
+			isError: response.isError,
+			...response.artifact !== void 0 && { artifact: response.artifact },
+			...response.modelContent !== void 0 && { modelContent: response.modelContent }
 		});
 	}
 	resumeToolCall(payload) {