@assistant-ui/core 0.2.20 → 0.2.22

package/dist/model-context/registry.d.ts

@@ -1,7 +1,6 @@
 import { Unsubscribe } from "../types/unsubscribe.js";
 import { AssistantInstructionsConfig, AssistantToolProps, ModelContext, ModelContextProvider } from "./types.js";
 import { ModelContextRegistryInstructionHandle, ModelContextRegistryProviderHandle, ModelContextRegistryToolHandle } from "./registry-handles.js";
-
 //#region src/model-context/registry.d.ts
 declare class ModelContextRegistry implements ModelContextProvider {
   private _tools;

package/dist/model-context/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","names":[],"sources":["../../src/model-context/registry.ts"],"mappings":";;;;;cAea,oBAAA,YAAgC,oBAAA;EAAA,QACnC,MAAA;EAAA,QACA,aAAA;EAAA,QACA,UAAA;EAAA,QACA,YAAA;EAAA,QACA,qBAAA;EAER,eAAA,IAAmB,YAAA;EAiDnB,SAAA,CAAU,QAAA,eAAuB,WAAA;EAAA,QAKzB,iBAAA;EAMR,OAAA,eAAsB,MAAA,4BACpB,IAAA,EAAM,kBAAA,CAAmB,KAAA,EAAO,OAAA,IAC/B,8BAAA,CAA+B,KAAA,EAAO,OAAA;EAoBzC,cAAA,CACE,MAAA,WAAiB,2BAAA,GAChB,qCAAA;EAiCH,WAAA,CACE,QAAA,EAAU,oBAAA,GACT,kCAAA;AAAA"}
+{"version":3,"file":"registry.d.ts","names":[],"sources":["../../src/model-context/registry.ts"],"mappings":";;;;cAea,gCAAgC;UACnC;UACA;UACA;UACA;UACA;EAER,mBAAmB;EAiDnB,UAAU,uBAAuB;UAKzB;EAMR,QAAQ,cAAc,yBAAyB,SAC7C,MAAM,mBAAmB,OAAO,WAC/B,+BAA+B,OAAO;EAoBzC,eACE,iBAAiB,8BAChB;EAiCH,YACE,UAAU,uBACT"}

package/dist/model-context/tool.d.ts

@@ -1,31 +1,45 @@
 import { Tool } from "assistant-stream";
-
 //#region src/model-context/tool.d.ts
+type StandardSchemaInput<TSchema> = TSchema extends {
+  readonly "~standard": {
+    readonly types?: {
+      readonly input: infer TInput;
+    } | undefined;
+  };
+} ? TInput extends Record<string, unknown> ? TInput : Record<string, unknown> : Record<string, unknown>;
+type StandardSchemaParameters = Extract<NonNullable<Extract<Tool<any>, {
+  parameters: unknown;
+}>["parameters"]>, {
+  readonly "~standard": unknown;
+}>;
 /**
  * Defines a model tool with its argument schema, execution behavior, and
  * optional model-output conversion.
  *
  * This helper keeps reusable tool definitions type-checked and convenient to
  * export for a {@link Toolkit} registered with {@link Tools}.
- * Inference from parameter schemas is currently limited, so provide generic
- * arguments when you need precise args or result types.
+ * When `parameters` is a Standard Schema (for example Zod v4), its input type
+ * is inferred for `execute`, `streamCall`, and model-output callbacks. Plain
+ * JSON Schema objects do not carry TypeScript input types, so provide generic
+ * arguments or annotate callbacks when you need precise args for JSON Schema.
  *
  * @param tool - Tool definition to expose to the assistant model.
  *
  * @example
  * ```ts
- * const getWeather = tool<{ city: string }, string>({
+ * import { z } from "zod";
+ *
+ * const getWeather = tool({
  *   type: "frontend",
  *   description: "Get the weather for a city.",
- *   parameters: {
- *     type: "object",
- *     properties: { city: { type: "string" } },
- *     required: ["city"],
- *   },
+ *   parameters: z.object({ city: z.string() }),
  *   execute: async ({ city }) => `Sunny in ${city}`,
  * });
  * ```
  */
+declare function tool<const TSchema extends StandardSchemaParameters, TResult = any>(tool: Tool<StandardSchemaInput<TSchema>, TResult> & {
+  parameters: TSchema;
+}): Tool<StandardSchemaInput<TSchema>, TResult>;
 declare function tool<TArgs extends Record<string, unknown>, TResult = any>(tool: Tool<TArgs, TResult>): Tool<TArgs, TResult>;
 //#endregion
 export { tool };

package/dist/model-context/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","names":[],"sources":["../../src/model-context/tool.ts"],"mappings":";;;;;AA6BA;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,IAAA,eAAmB,MAAA,kCACjC,IAAA,EAAM,IAAA,CAAK,KAAA,EAAO,OAAA,IACjB,IAAA,CAAK,KAAA,EAAO,OAAA"}
+{"version":3,"file":"tool.d.ts","names":[],"sources":["../../src/model-context/tool.ts"],"mappings":";;KAEK,oBAAoB,WAAW;WACzB;aACE;eAAmB,aAAa;;;IAGzC,eAAe,0BACb,SACA,0BACF;KAEC,2BAA2B,QAC9B,YAAY,QAAQ;EAAa;;WACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BG,WACR,gBAAgB,0BACtB,eAEA,MAAM,KAAK,oBAAoB,UAAU;EAAa,YAAY;IACjE,KAAK,oBAAoB,UAAU;iBACtB,KAAK,cAAc,yBAAyB,eAC1D,MAAM,KAAK,OAAO,WACjB,KAAK,OAAO"}

package/dist/model-context/tool.js

@@ -1,29 +1,4 @@
 //#region src/model-context/tool.ts
-/**
-* Defines a model tool with its argument schema, execution behavior, and
-* optional model-output conversion.
-*
-* This helper keeps reusable tool definitions type-checked and convenient to
-* export for a {@link Toolkit} registered with {@link Tools}.
-* Inference from parameter schemas is currently limited, so provide generic
-* arguments when you need precise args or result types.
-*
-* @param tool - Tool definition to expose to the assistant model.
-*
-* @example
-* ```ts
-* const getWeather = tool<{ city: string }, string>({
-*   type: "frontend",
-*   description: "Get the weather for a city.",
-*   parameters: {
-*     type: "object",
-*     properties: { city: { type: "string" } },
-*     required: ["city"],
-*   },
-*   execute: async ({ city }) => `Sunny in ${city}`,
-* });
-* ```
-*/
 function tool(tool) {
 	return tool;
 }

package/dist/model-context/tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool.js","names":["Tool","tool","Record","TArgs","TResult"],"sources":["../../src/model-context/tool.ts"],"sourcesContent":["import type { Tool } from \"assistant-stream\";\n\n// TODO re-add the inferrence of the parameters\n\n/**\n * Defines a model tool with its argument schema, execution behavior, and\n * optional model-output conversion.\n *\n * This helper keeps reusable tool definitions type-checked and convenient to\n * export for a {@link Toolkit} registered with {@link Tools}.\n * Inference from parameter schemas is currently limited, so provide generic\n * arguments when you need precise args or result types.\n *\n * @param tool - Tool definition to expose to the assistant model.\n *\n * @example\n * ```ts\n * const getWeather = tool<{ city: string }, string>({\n *   type: \"frontend\",\n *   description: \"Get the weather for a city.\",\n *   parameters: {\n *     type: \"object\",\n *     properties: { city: { type: \"string\" } },\n *     required: [\"city\"],\n *   },\n *   execute: async ({ city }) => `Sunny in ${city}`,\n * });\n * ```\n */\nexport function tool<TArgs extends Record<string, unknown>, TResult = any>(\n  tool: Tool<TArgs, TResult>,\n): Tool<TArgs, TResult> {\n  return tool;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgBC,KACdA,MACsB;CACtB,OAAOA;AACT"}
+{"version":3,"file":"tool.js","names":["Tool","StandardSchemaInput","TSchema","types","input","TInput","Record","StandardSchemaParameters","Extract","NonNullable","parameters","tool","TResult","TArgs"],"sources":["../../src/model-context/tool.ts"],"sourcesContent":["import type { Tool } from \"assistant-stream\";\n\ntype StandardSchemaInput<TSchema> = TSchema extends {\n  readonly \"~standard\": {\n    readonly types?: { readonly input: infer TInput } | undefined;\n  };\n}\n  ? TInput extends Record<string, unknown>\n    ? TInput\n    : Record<string, unknown>\n  : Record<string, unknown>;\n\ntype StandardSchemaParameters = Extract<\n  NonNullable<Extract<Tool<any>, { parameters: unknown }>[\"parameters\"]>,\n  { readonly \"~standard\": unknown }\n>;\n\n/**\n * Defines a model tool with its argument schema, execution behavior, and\n * optional model-output conversion.\n *\n * This helper keeps reusable tool definitions type-checked and convenient to\n * export for a {@link Toolkit} registered with {@link Tools}.\n * When `parameters` is a Standard Schema (for example Zod v4), its input type\n * is inferred for `execute`, `streamCall`, and model-output callbacks. Plain\n * JSON Schema objects do not carry TypeScript input types, so provide generic\n * arguments or annotate callbacks when you need precise args for JSON Schema.\n *\n * @param tool - Tool definition to expose to the assistant model.\n *\n * @example\n * ```ts\n * import { z } from \"zod\";\n *\n * const getWeather = tool({\n *   type: \"frontend\",\n *   description: \"Get the weather for a city.\",\n *   parameters: z.object({ city: z.string() }),\n *   execute: async ({ city }) => `Sunny in ${city}`,\n * });\n * ```\n */\nexport function tool<\n  const TSchema extends StandardSchemaParameters,\n  TResult = any,\n>(\n  tool: Tool<StandardSchemaInput<TSchema>, TResult> & { parameters: TSchema },\n): Tool<StandardSchemaInput<TSchema>, TResult>;\nexport function tool<TArgs extends Record<string, unknown>, TResult = any>(\n  tool: Tool<TArgs, TResult>,\n): Tool<TArgs, TResult>;\nexport function tool<TArgs extends Record<string, unknown>, TResult = any>(\n  tool: Tool<TArgs, TResult>,\n): Tool<TArgs, TResult> {\n  return tool;\n}\n"],"mappings":";AAmDA,SAAgBW,KACdA,MACsB;CACtB,OAAOA;AACT"}

package/dist/model-context/types.d.ts

@@ -1,6 +1,5 @@
 import { Unsubscribe } from "../types/unsubscribe.js";
 import { Tool } from "assistant-stream";
-
 //#region src/model-context/types.d.ts
 type LanguageModelV1CallSettings = {
   maxTokens?: number;

package/dist/model-context/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/model-context/types.ts"],"mappings":";;;;KAGY,2BAAA;EACV,SAAA;EACA,WAAA;EACA,IAAA;EACA,eAAA;EACA,gBAAA;EACA,IAAA;EACA,OAAA,GAAU,MAAM;AAAA;AAAA,KAGN,mBAAA;EACV,MAAA;EACA,OAAA;EACA,SAAA;EACA,eAAA;AAAA;AAAA,KAGU,YAAA;EACV,QAAA;EACA,MAAA;EACA,KAAA,GAAQ,MAAA,SAAe,IAAA;EACvB,YAAA,GAAe,2BAAA;EACf,MAAA,GAAS,mBAAA;EAVT;;;;AAEe;EAcf,yBAAA,GAA4B,MAAA;AAAA;AAAA,KAGlB,oBAAA;EACV,eAAA,QAAuB,YAAA;EACvB,SAAA,IAAa,QAAA,iBAAyB,WAAW;AAAA;AAAA,KAGvC,kBAAA,eACI,MAAA,8BAEZ,IAAA,CAAK,KAAA,EAAO,OAAA;EACd,QAAA;EACA,MAAA;AAAA;AAAA,KAGU,2BAAA;EACV,QAAA;EACA,WAAW;AAAA;AAAA,KAGD,sBAAA;EACV,UAAA;EACA,QAAQ;AAAA;AAAA,cAGG,kBAAA,GACX,SAAA,EAAW,GAAA,CAAI,oBAAA,MACd,YAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/model-context/types.ts"],"mappings":";;;KAGY;EACV;EACA;EACA;EACA;EACA;EACA;EACA,UAAU;;KAGA;EACV;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA,QAAQ,eAAe;EACvB,eAAe;EACf,SAAS;;;;;;EAMT,4BAA4B;;KAGlB;EACV,uBAAuB;EACvB,aAAa,yBAAyB;;KAG5B,mBACV,cAAc,yBACd,WACE,KAAK,OAAO;EACd;EACA;;KAGU;EACV;EACA;;KAGU;EACV;EACA;;cAGW,qBACX,WAAW,IAAI,0BACd"}

package/dist/react/AssistantProvider.d.ts

@@ -1,7 +1,6 @@
 import { AssistantRuntime } from "../runtime/api/assistant-runtime.js";
 import { AssistantClient } from "@assistant-ui/store";
 import { ComponentType, FC, PropsWithChildren } from "react";
-
 //#region src/react/AssistantProvider.d.ts
 declare const getRenderComponent: (runtime: AssistantRuntime) => ComponentType | undefined;
 type AssistantProviderBaseProps = PropsWithChildren<{

package/dist/react/AssistantProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantProvider.d.ts","names":[],"sources":["../../src/react/AssistantProvider.tsx"],"mappings":";;;;;cAWa,kBAAA,GAAsB,OAAA,EAAS,gBAAA,KAEnB,aAAa;AAAA,KAG1B,0BAAA,GAA6B,iBAAA;EACvC,OAAA,EAAS,gBAAA;EACT,GAAA,GAAM,eAAA;AAAA;AAAA,cAGK,qBAAA,EAAuB,EAAE,CAAC,0BAAA"}
+{"version":3,"file":"AssistantProvider.d.ts","names":[],"sources":["../../src/react/AssistantProvider.tsx"],"mappings":";;;;cAWa,qBAAsB,SAAS,qBAEnB;KAGb,6BAA6B;EACvC,SAAS;EACT,MAAM;;cAGK,uBAAuB,GAAG"}

package/dist/react/AssistantProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantProvider.js","names":["memo","ComponentType","FC","PropsWithChildren","useAui","AuiProvider","AssistantClient","AssistantRuntime","AssistantRuntimeCore","RuntimeAdapter","getRenderComponent","runtime","_core","RenderComponent","AssistantProviderBaseProps","aui","AssistantProviderBase","parent","children","threads","inner"],"sources":["../../src/react/AssistantProvider.tsx"],"sourcesContent":["import {\n  memo,\n  type ComponentType,\n  type FC,\n  type PropsWithChildren,\n} from \"react\";\nimport { useAui, AuiProvider, type AssistantClient } from \"@assistant-ui/store\";\nimport type { AssistantRuntime } from \"../runtime/api/assistant-runtime\";\nimport type { AssistantRuntimeCore } from \"../runtime/interfaces/assistant-runtime-core\";\nimport { RuntimeAdapter } from \"./RuntimeAdapter\";\n\nexport const getRenderComponent = (runtime: AssistantRuntime) => {\n  return (runtime as { _core?: AssistantRuntimeCore })._core\n    ?.RenderComponent as ComponentType | undefined;\n};\n\nexport type AssistantProviderBaseProps = PropsWithChildren<{\n  runtime: AssistantRuntime;\n  aui?: AssistantClient | null;\n}>;\n\nexport const AssistantProviderBase: FC<AssistantProviderBaseProps> = memo(\n  ({ runtime, aui: parent = null, children }) => {\n    // The runtime has a stable identity but mutates in place: its options are\n    // pushed in by an unconditional effect inside <RenderComponent />, so that\n    // element must be re-created every commit for React to re-render it and\n    // re-run the effect. React Compiler caches <RenderComponent /> on the\n    // stable RenderComponent type, which silences the effect and stops option\n    // changes (e.g. unstable_enableMessageQueue) from reaching the runtime.\n    \"use no memo\";\n    const aui = useAui({ threads: RuntimeAdapter(runtime) }, { parent });\n    const RenderComponent = getRenderComponent(runtime);\n    const inner = (\n      <AuiProvider value={aui}>\n        {RenderComponent && <RenderComponent />}\n        {children}\n      </AuiProvider>\n    );\n    if (!parent) return inner;\n    return <AuiProvider value={parent}>{inner}</AuiProvider>;\n  },\n);\n"],"mappings":";;;;;AAWA,MAAaU,sBAAsBC,YAA8B;CAC/D,OAAQA,QAA6CC,OACjDC;AACN;AAOA,MAAaG,wBAAwDhB,MAClE,EAAEW,SAASI,KAAKE,SAAS,MAAMC,eAAe;CAO7C;CACA,MAAMH,MAAMX,OAAO,EAAEe,SAASV,eAAeE,OAAO,EAAE,GAAG,EAAEM,OAAO,CAAC;CACnE,MAAMJ,kBAAkBH,mBAAmBC,OAAO;CAClD,MAAMS,QACJ,qBAAC,aAAD;EAAa,OAAOL;YAApB,CACGF,mBAAmB,oBAAC,iBAAD,CAAgB,CAAA,GACnCK,QACU;;CAEf,IAAI,CAACD,QAAQ,OAAOG;CACpB,OAAO,oBAAC,aAAD;EAAa,OAAOH;YAASG;CAAmB,CAAA;AACzD,CACF"}
+{"version":3,"file":"AssistantProvider.js","names":["memo","ComponentType","FC","PropsWithChildren","useAui","AuiProvider","AssistantClient","AssistantRuntime","AssistantRuntimeCore","RuntimeAdapter","getRenderComponent","runtime","_core","RenderComponent","AssistantProviderBaseProps","aui","AssistantProviderBase","parent","children","threads","inner"],"sources":["../../src/react/AssistantProvider.tsx"],"sourcesContent":["import {\n  memo,\n  type ComponentType,\n  type FC,\n  type PropsWithChildren,\n} from \"react\";\nimport { useAui, AuiProvider, type AssistantClient } from \"@assistant-ui/store\";\nimport type { AssistantRuntime } from \"../runtime/api/assistant-runtime\";\nimport type { AssistantRuntimeCore } from \"../runtime/interfaces/assistant-runtime-core\";\nimport { RuntimeAdapter } from \"./RuntimeAdapter\";\n\nexport const getRenderComponent = (runtime: AssistantRuntime) => {\n  return (runtime as { _core?: AssistantRuntimeCore })._core\n    ?.RenderComponent as ComponentType | undefined;\n};\n\nexport type AssistantProviderBaseProps = PropsWithChildren<{\n  runtime: AssistantRuntime;\n  aui?: AssistantClient | null;\n}>;\n\nexport const AssistantProviderBase: FC<AssistantProviderBaseProps> = memo(\n  ({ runtime, aui: parent = null, children }) => {\n    // The runtime has a stable identity but mutates in place: its options are\n    // pushed in by an unconditional effect inside <RenderComponent />, so that\n    // element must be re-created every commit for React to re-render it and\n    // re-run the effect. React Compiler caches <RenderComponent /> on the\n    // stable RenderComponent type, which silences the effect and stops option\n    // changes (e.g. unstable_enableMessageQueue) from reaching the runtime.\n    \"use no memo\";\n    const aui = useAui({ threads: RuntimeAdapter(runtime) }, { parent });\n    const RenderComponent = getRenderComponent(runtime);\n    const inner = (\n      <AuiProvider value={aui}>\n        {RenderComponent && <RenderComponent />}\n        {children}\n      </AuiProvider>\n    );\n    if (!parent) return inner;\n    return <AuiProvider value={parent}>{inner}</AuiProvider>;\n  },\n);\n"],"mappings":";;;;;AAWA,MAAaU,sBAAsBC,YAA8B;CAC/D,OAAQA,QAA6CC,OACjDC;AACN;AAOA,MAAaG,wBAAwDhB,MAClE,EAAEW,SAASI,KAAKE,SAAS,MAAMC,eAAe;CAO7C;CACA,MAAMH,MAAMX,OAAO,EAAEe,SAASV,eAAeE,OAAO,EAAE,GAAG,EAAEM,OAAO,CAAC;CACnE,MAAMJ,kBAAkBH,mBAAmBC,OAAO;CAClD,MAAMS,QACJ,qBAAC,aAAD;EAAa,OAAOL;EAApB,UAAA,CACGF,mBAAmB,oBAAC,iBAAD,CAAgB,CAAA,GACnCK,QACU;;CAEf,IAAI,CAACD,QAAQ,OAAOG;CACpB,OAAO,oBAAC,aAAD;EAAa,OAAOH;EAASG,UAAAA;CAAmB,CAAA;AACzD,CACF"}

package/dist/react/AssistantRuntimeProvider.d.ts

@@ -1,7 +1,6 @@
 import { AssistantRuntime } from "../runtime/api/assistant-runtime.js";
 import { AssistantClient } from "@assistant-ui/store";
 import { ReactNode } from "react";
-
 //#region src/react/AssistantRuntimeProvider.d.ts
 /**
  * Mounts an `AssistantRuntime` into the React tree.
@@ -25,11 +24,7 @@ import { ReactNode } from "react";
  * }
  * ```
  */
-declare const AssistantRuntimeProvider: import("react").MemoExoticComponent<({
-  runtime,
-  aui,
-  children
-}: {
+declare const AssistantRuntimeProvider: import("react").MemoExoticComponent<({ runtime, aui, children }: {
   /**
    * The assistant runtime to expose to descendants. Build one with
    * `useLocalRuntime`, `useExternalStoreRuntime`, or

package/dist/react/AssistantRuntimeProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantRuntimeProvider.d.ts","names":[],"sources":["../../src/react/AssistantRuntimeProvider.tsx"],"mappings":";;;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;cAAa,wBAAA,kBAAwB,mBAAA;EAAA,OAAA;EAAA,GAAA;EAAA;AAAA;EAkB3B;;;;;EAPN,OAAA,EAAS,gBAAA;EASV;;;;;;EAFC,GAAA,GAAM,eAAA;EACN,QAAA,EAAU,SAAA;AAAA,sBACX,GAAA,CAAA,OAAA"}
+{"version":3,"file":"AssistantRuntimeProvider.d.ts","names":[],"sources":["../../src/react/AssistantRuntimeProvider.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA2Ba,0CAAwB,uBAAA,SAAA,KAAA;;;;;;EAWjC,SAAS;;;;;;;EAOT,MAAM;EACN,UAAU;sBACX,IAAA"}

package/dist/react/RuntimeAdapter.d.ts

@@ -1,4 +1,5 @@
 import { AssistantRuntime } from "../runtime/api/assistant-runtime.js";
+import "../index.js";
 //#region src/react/RuntimeAdapter.d.ts
 declare const RuntimeAdapter: import("@assistant-ui/tap").Resource<import("@assistant-ui/store").ClientOutput<"threads">, [runtime: AssistantRuntime]>;
 //#endregion

package/dist/react/RuntimeAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeAdapter.d.ts","names":[],"sources":["../../src/react/RuntimeAdapter.ts"],"mappings":";;cA+Ba,cAAA,8BAAc,QAAA,+BAAA,YAAA,cAAA,OAAA,EAAA,gBAAA"}
+{"version":3,"file":"RuntimeAdapter.d.ts","names":[],"sources":["../../src/react/RuntimeAdapter.ts"],"mappings":";;;cA+Ba,4CAAc,uCAAA,0BAAA,SAAA"}

package/dist/react/adapters/LocalStorageThreadListAdapter.d.ts

@@ -1,6 +1,8 @@
+import { ExportedMessageRepository } from "../../runtime/utils/message-repository.js";
 import { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types.js";
+import "../../internal.js";
+import "../../index.js";
 import { TitleGenerationAdapter } from "./TitleGenerationAdapter.js";
-
 //#region src/react/adapters/LocalStorageThreadListAdapter.d.ts
 type AsyncStorageLike = {
   getItem(key: string): Promise<string | null>;
@@ -12,7 +14,16 @@ type LocalStorageAdapterOptions = {
   prefix?: string | undefined;
   titleGenerator?: TitleGenerationAdapter | undefined;
 };
+type StoredThreadMetadata = {
+  remoteId: string;
+  externalId?: string;
+  status: "regular" | "archived";
+  title?: string;
+  custom?: Record<string, unknown> | undefined;
+};
+declare const parseStoredThreadMetadata: (raw: string | null) => StoredThreadMetadata[];
+declare const parseStoredMessageRepository: (raw: string | null) => ExportedMessageRepository;
 declare const createLocalStorageAdapter: (options: LocalStorageAdapterOptions) => RemoteThreadListAdapter;
 //#endregion
-export { AsyncStorageLike, createLocalStorageAdapter };
+export { AsyncStorageLike, createLocalStorageAdapter, parseStoredMessageRepository, parseStoredThreadMetadata };
 //# sourceMappingURL=LocalStorageThreadListAdapter.d.ts.map

package/dist/react/adapters/LocalStorageThreadListAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LocalStorageThreadListAdapter.d.ts","names":[],"sources":["../../../src/react/adapters/LocalStorageThreadListAdapter.tsx"],"mappings":";;;;KAkBY,gBAAA;EACV,OAAA,CAAQ,GAAA,WAAc,OAAA;EACtB,OAAA,CAAQ,GAAA,UAAa,KAAA,WAAgB,OAAA;EACrC,UAAA,CAAW,GAAA,WAAc,OAAA;AAAA;AAAA,KAGtB,0BAAA;EACH,OAAA,EAAS,gBAAA;EACT,MAAA;EACA,cAAA,GAAiB,sBAAsB;AAAA;AAAA,cA2E5B,yBAAA,GACX,OAAA,EAAS,0BAAA,KACR,uBAyIF"}
+{"version":3,"file":"LocalStorageThreadListAdapter.d.ts","names":[],"sources":["../../../src/react/adapters/LocalStorageThreadListAdapter.tsx"],"mappings":";;;;;;KAmBY;EACV,QAAQ,cAAc;EACtB,QAAQ,aAAa,gBAAgB;EACrC,WAAW,cAAc;;KAkCtB;EACH,SAAS;EACT;EACA,iBAAiB;;KAGd;EACH;EACA;EACA;EACA;EACA,SAAS;;cAwIE,4BACX,uBACC;cAoCU,+BACX,uBACC;cAkGU,4BACX,SAAS,+BACR"}

package/dist/react/adapters/LocalStorageThreadListAdapter.js

@@ -4,14 +4,153 @@ import { useAui } from "@assistant-ui/store";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/adapters/LocalStorageThreadListAdapter.tsx
+var KeyedMutationQueue = class {
+	tails = /* @__PURE__ */ new Map();
+	run(key, mutation) {
+		const previous = this.tails.get(key);
+		const result = previous ? previous.then(mutation) : mutation();
+		const tail = result.then(() => void 0, () => void 0);
+		this.tails.set(key, tail);
+		tail.then(() => {
+			if (this.tails.get(key) === tail) this.tails.delete(key);
+		});
+		return result;
+	}
+};
+const mutationQueues = /* @__PURE__ */ new WeakMap();
+const getMutationQueue = (storage) => {
+	let queue = mutationQueues.get(storage);
+	if (!queue) {
+		queue = new KeyedMutationQueue();
+		mutationQueues.set(storage, queue);
+	}
+	return queue;
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseJSON = (raw) => {
+	if (!raw) return void 0;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+};
+const parseStoredThread = (value) => {
+	if (!isRecord(value) || typeof value.remoteId !== "string") return null;
+	const status = value.status ?? "regular";
+	if (status !== "regular" && status !== "archived") return null;
+	return {
+		remoteId: value.remoteId,
+		status,
+		...typeof value.externalId === "string" ? { externalId: value.externalId } : void 0,
+		...typeof value.title === "string" ? { title: value.title } : void 0,
+		...isRecord(value.custom) ? { custom: value.custom } : void 0
+	};
+};
+const parseDate = (value) => {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+	if (typeof value !== "string" && typeof value !== "number") return null;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? null : date;
+};
+const isMessageRole = (value) => value === "system" || value === "user" || value === "assistant";
+const parseStoredThreadMessage = (value) => {
+	if (!isRecord(value) || typeof value.id !== "string") return null;
+	if (!isMessageRole(value.role)) return null;
+	if (!Array.isArray(value.content)) return null;
+	const createdAt = parseDate(value.createdAt);
+	if (!createdAt) return null;
+	const metadata = value.metadata;
+	if (!isRecord(metadata) || !isRecord(metadata.custom)) return null;
+	if (value.role === "assistant") {
+		const status = value.status;
+		if (!isRecord(status) || typeof status.type !== "string") return null;
+		const submittedFeedbackType = (isRecord(metadata.submittedFeedback) ? metadata.submittedFeedback : void 0)?.type;
+		return {
+			id: value.id,
+			role: "assistant",
+			content: value.content,
+			status,
+			createdAt,
+			metadata: {
+				unstable_state: metadata.unstable_state ?? null,
+				unstable_annotations: Array.isArray(metadata.unstable_annotations) ? metadata.unstable_annotations : [],
+				unstable_data: Array.isArray(metadata.unstable_data) ? metadata.unstable_data : [],
+				steps: Array.isArray(metadata.steps) ? metadata.steps : [],
+				...submittedFeedbackType === "positive" || submittedFeedbackType === "negative" ? { submittedFeedback: { type: submittedFeedbackType } } : void 0,
+				...metadata.timing !== void 0 ? { timing: metadata.timing } : void 0,
+				...metadata.isOptimistic === true ? { isOptimistic: true } : void 0,
+				custom: metadata.custom
+			}
+		};
+	}
+	if (value.role === "user") return {
+		id: value.id,
+		role: "user",
+		content: value.content,
+		attachments: Array.isArray(value.attachments) ? value.attachments : [],
+		createdAt,
+		metadata: { custom: metadata.custom }
+	};
+	if (value.content.length !== 1) return null;
+	return {
+		id: value.id,
+		role: "system",
+		content: [value.content[0]],
+		createdAt,
+		metadata: { custom: metadata.custom }
+	};
+};
+const parseStoredThreadMetadata = (raw) => {
+	const parsed = parseJSON(raw);
+	if (!Array.isArray(parsed)) return [];
+	return parsed.flatMap((item) => {
+		const thread = parseStoredThread(item);
+		return thread ? [thread] : [];
+	});
+};
+const parseStoredMessageRepositoryItem = (value) => {
+	if (!isRecord(value)) return null;
+	const message = parseStoredThreadMessage(value.message);
+	if (!message) return null;
+	const parentId = value.parentId;
+	if (parentId !== void 0 && parentId !== null && typeof parentId !== "string") return null;
+	return {
+		message,
+		parentId: parentId ?? null,
+		...isRecord(value.runConfig) ? { runConfig: value.runConfig } : void 0
+	};
+};
+const parseStoredMessageRepository = (raw) => {
+	const parsed = parseJSON(raw);
+	if (!isRecord(parsed) || !Array.isArray(parsed.messages)) return { messages: [] };
+	const candidateMessages = parsed.messages.flatMap((item) => {
+		const parsedItem = parseStoredMessageRepositoryItem(item);
+		return parsedItem ? [parsedItem] : [];
+	});
+	const acceptedIds = /* @__PURE__ */ new Set();
+	const messages = candidateMessages.flatMap((item) => {
+		if (acceptedIds.has(item.message.id)) return [];
+		if (item.parentId !== null && !acceptedIds.has(item.parentId)) return [];
+		acceptedIds.add(item.message.id);
+		return [item];
+	});
+	const headId = parsed.headId === null || typeof parsed.headId === "string" && messages.some((item) => item.message.id === parsed.headId) ? parsed.headId : void 0;
+	return {
+		...headId !== void 0 ? { headId } : void 0,
+		messages
+	};
+};
 var AsyncStorageHistoryAdapter = class {
 	storage;
 	aui;
 	prefix;
-	constructor(storage, aui, prefix) {
+	mutationQueue;
+	constructor(storage, aui, prefix, mutationQueue) {
 		this.storage = storage;
 		this.aui = aui;
 		this.prefix = prefix;
+		this.mutationQueue = mutationQueue;
 	}
 	_messagesKey(remoteId) {
 		return `${this.prefix}messages:${remoteId}`;
@@ -20,29 +159,30 @@ var AsyncStorageHistoryAdapter = class {
 		const remoteId = this.aui.threadListItem().getState().remoteId;
 		if (!remoteId) return { messages: [] };
 		const raw = await this.storage.getItem(this._messagesKey(remoteId));
-		if (!raw) return { messages: [] };
-		return JSON.parse(raw);
+		return parseStoredMessageRepository(raw);
 	}
 	async append(item) {
 		const { remoteId } = await this.aui.threadListItem().initialize();
 		const key = this._messagesKey(remoteId);
-		const raw = await this.storage.getItem(key);
-		const repo = raw ? JSON.parse(raw) : { messages: [] };
-		const idx = repo.messages.findIndex((m) => m.message.id === item.message.id);
-		if (idx >= 0) repo.messages[idx] = item;
-		else repo.messages.push(item);
-		repo.headId = item.message.id;
-		await this.storage.setItem(key, JSON.stringify(repo));
+		await this.mutationQueue.run(key, async () => {
+			const raw = await this.storage.getItem(key);
+			const repo = parseStoredMessageRepository(raw);
+			const idx = repo.messages.findIndex((m) => m.message.id === item.message.id);
+			if (idx >= 0) repo.messages[idx] = item;
+			else repo.messages.push(item);
+			repo.headId = item.message.id;
+			await this.storage.setItem(key, JSON.stringify(repo));
+		});
 	}
 };
-const createHistoryProvider = (storage, prefix) => {
+const createHistoryProvider = (storage, prefix, mutationQueue) => {
 	const Provider = (t0) => {
 		const $ = c(7);
 		const { children } = t0;
 		const aui = useAui();
 		let t1;
 		if ($[0] !== aui) {
-			t1 = new AsyncStorageHistoryAdapter(storage, aui, prefix);
+			t1 = new AsyncStorageHistoryAdapter(storage, aui, prefix, mutationQueue);
 			$[0] = aui;
 			$[1] = t1;
 		} else t1 = $[1];
@@ -72,15 +212,26 @@ const createLocalStorageAdapter = (options) => {
 	const { storage, prefix = "@assistant-ui:", titleGenerator } = options;
 	const threadsKey = `${prefix}threads`;
 	const messagesKey = (threadId) => `${prefix}messages:${threadId}`;
+	const mutationQueue = getMutationQueue(storage);
 	const loadThreadMetadata = async () => {
 		const raw = await storage.getItem(threadsKey);
-		return raw ? JSON.parse(raw) : [];
+		return parseStoredThreadMetadata(raw);
 	};
 	const saveThreadMetadata = async (threads) => {
 		await storage.setItem(threadsKey, JSON.stringify(threads));
 	};
+	const updateThreadMetadata = async (remoteId, update) => {
+		await mutationQueue.run(threadsKey, async () => {
+			const threads = await loadThreadMetadata();
+			const thread = threads.find((item) => item.remoteId === remoteId);
+			if (thread) {
+				update(thread);
+				await saveThreadMetadata(threads);
+			}
+		});
+	};
 	return {
-		unstable_Provider: createHistoryProvider(storage, prefix),
+		unstable_Provider: createHistoryProvider(storage, prefix, mutationQueue),
 		async list() {
 			return { threads: (await loadThreadMetadata()).map((t) => ({
 				remoteId: t.remoteId,
@@ -92,58 +243,52 @@ const createLocalStorageAdapter = (options) => {
 		},
 		async initialize(threadId) {
 			const remoteId = threadId;
-			const threads = await loadThreadMetadata();
-			if (!threads.some((t) => t.remoteId === remoteId)) {
-				threads.unshift({
+			return mutationQueue.run(threadsKey, async () => {
+				const threads = await loadThreadMetadata();
+				if (!threads.some((t) => t.remoteId === remoteId)) {
+					threads.unshift({
+						remoteId,
+						status: "regular"
+					});
+					await saveThreadMetadata(threads);
+				}
+				return {
 					remoteId,
-					status: "regular"
-				});
-				await saveThreadMetadata(threads);
-			}
-			return {
-				remoteId,
-				externalId: void 0
-			};
+					externalId: void 0
+				};
+			});
 		},
 		async rename(remoteId, newTitle) {
-			const threads = await loadThreadMetadata();
-			const thread = threads.find((t) => t.remoteId === remoteId);
-			if (thread) {
+			await updateThreadMetadata(remoteId, (thread) => {
 				thread.title = newTitle;
-				await saveThreadMetadata(threads);
-			}
+			});
 		},
 		async updateCustom(remoteId, custom) {
-			const threads = await loadThreadMetadata();
-			const thread = threads.find((t) => t.remoteId === remoteId);
-			if (thread) {
+			await updateThreadMetadata(remoteId, (thread) => {
 				thread.custom = custom;
-				await saveThreadMetadata(threads);
-			}
+			});
 		},
 		async archive(remoteId) {
-			const threads = await loadThreadMetadata();
-			const thread = threads.find((t) => t.remoteId === remoteId);
-			if (thread) {
+			await updateThreadMetadata(remoteId, (thread) => {
 				thread.status = "archived";
-				await saveThreadMetadata(threads);
-			}
+			});
 		},
 		async unarchive(remoteId) {
-			const threads = await loadThreadMetadata();
-			const thread = threads.find((t) => t.remoteId === remoteId);
-			if (thread) {
+			await updateThreadMetadata(remoteId, (thread) => {
 				thread.status = "regular";
-				await saveThreadMetadata(threads);
-			}
+			});
 		},
 		async delete(remoteId) {
-			await saveThreadMetadata((await loadThreadMetadata()).filter((t) => t.remoteId !== remoteId));
-			await storage.removeItem(messagesKey(remoteId));
+			await mutationQueue.run(threadsKey, async () => {
+				const filtered = (await loadThreadMetadata()).filter((t) => t.remoteId !== remoteId);
+				await saveThreadMetadata(filtered);
+			});
+			const key = messagesKey(remoteId);
+			await mutationQueue.run(key, () => storage.removeItem(key));
 		},
 		async fetch(threadId) {
 			const thread = (await loadThreadMetadata()).find((t) => t.remoteId === threadId);
-			if (!thread) throw new Error("Thread not found");
+			if (!thread) throw new Error(`Stored thread "${threadId}" not found while fetching thread metadata.`);
 			return {
 				remoteId: thread.remoteId,
 				externalId: thread.externalId,
@@ -155,12 +300,9 @@ const createLocalStorageAdapter = (options) => {
 		async generateTitle(remoteId, messages) {
 			if (titleGenerator) {
 				const title = await titleGenerator.generateTitle(messages);
-				const threads = await loadThreadMetadata();
-				const thread = threads.find((t) => t.remoteId === remoteId);
-				if (thread) {
+				await updateThreadMetadata(remoteId, (thread) => {
 					thread.title = title;
-					await saveThreadMetadata(threads);
-				}
+				});
 				return createAssistantStream((controller) => {
 					controller.appendText(title);
 				});
@@ -170,6 +312,6 @@ const createLocalStorageAdapter = (options) => {
 	};
 };
 //#endregion
-export { createLocalStorageAdapter };
+export { createLocalStorageAdapter, parseStoredMessageRepository, parseStoredThreadMetadata };
 
 //# sourceMappingURL=LocalStorageThreadListAdapter.js.map