@assistant-ui/core 0.2.20 → 0.2.21

package/dist/internal.d.ts

@@ -1,10 +1,14 @@
+import { getFileDataURL } from "./adapters/attachment.js";
 import { fromThreadMessageLike } from "./runtime/utils/thread-message-like.js";
 import { ExportedMessageRepository, ExportedMessageRepositoryItem, MessageRepository } from "./runtime/utils/message-repository.js";
+import { consumeSuggestionResult } from "./adapters/suggestion.js";
 import { BaseSubject, BaseSubscribable, EventSubscribable, EventSubscriptionSubject, LazyMemoizeSubject, NestedSubscribable, NestedSubscriptionSubject, SKIP_UPDATE, ShallowMemoizeSubject, Subscribable, SubscribableWithState } from "./subscribable/subscribable.js";
 import { generateErrorMessageId, generateId, isErrorMessageId } from "./utils/id.js";
 import { getThreadMessageText } from "./utils/text.js";
 import { resolveToolApprovalResponse } from "./runtime/utils/resolveToolApprovalResponse.js";
 import { CompositeContextProvider } from "./utils/composite-context-provider.js";
+import { stableStringifyToolArgs, trackToolArgsKeyOrder } from "./utils/json/stable-stringify-tool-args.js";
+import { isJSONValue, isRecord } from "./utils/json/is-json.js";
 import { RuntimeExtras, createRuntimeExtras } from "./react/runtimes/createRuntimeExtras.js";
 import { ComposerRuntimeCoreBinding, EditComposerRuntimeCoreBinding, MessageStateBinding, ThreadComposerRuntimeCoreBinding } from "./runtime/api/bindings.js";
 import { BaseAssistantRuntimeCore } from "./runtime/base/base-assistant-runtime-core.js";
@@ -20,6 +24,7 @@ import { MessagePartRuntimeImpl } from "./runtime/api/message-part-runtime.js";
 import { MessageRuntimeImpl } from "./runtime/api/message-runtime.js";
 import { symbolInnerMessage } from "./runtime/utils/external-store-message.js";
 import { getAutoStatus, isAutoStatus } from "./runtime/utils/auto-status.js";
+import "./runtime/internal.js";
 import { LocalRuntimeOptionsBase } from "./runtimes/local/local-runtime-options.js";
 import { LocalThreadRuntimeCore } from "./runtimes/local/local-thread-runtime-core.js";
 import { LocalThreadFactory, LocalThreadListRuntimeCore } from "./runtimes/local/local-thread-list-runtime-core.js";
@@ -34,6 +39,7 @@ import { OptimisticState } from "./runtimes/remote-thread-list/optimistic-state.
 import { EMPTY_THREAD_CORE } from "./runtimes/remote-thread-list/empty-thread-core.js";
 import { RemoteThreadInitializeResponse, RemoteThreadListOptions } from "./runtimes/remote-thread-list/types.js";
 import { RemoteThreadData, RemoteThreadState, THREAD_MAPPING_ID, createThreadMappingId, getThreadData, updateStatusReducer } from "./runtimes/remote-thread-list/remote-thread-state.js";
+import "./runtimes/internal.js";
 import { ThreadListItemRuntimeBinding, ThreadRuntimeCoreBinding, ThreadRuntimeImpl, getThreadState } from "./runtime/api/thread-runtime.js";
 import { AssistantRuntimeImpl } from "./runtime/api/assistant-runtime.js";
-export { AssistantRuntimeImpl, AttachmentRuntimeImpl, BaseAssistantRuntimeCore, BaseComposerRuntimeCore, BaseSubject, BaseSubscribable, BaseThreadRuntimeCore, type ComposerRuntimeCoreBinding, ComposerRuntimeImpl, CompositeContextProvider, type ConverterCallback, DefaultEditComposerRuntimeCore, DefaultThreadComposerRuntimeCore, EMPTY_THREAD_CORE, EditComposerAttachmentRuntimeImpl, type EditComposerRuntimeCoreBinding, EditComposerRuntimeImpl, type EventSubscribable, EventSubscriptionSubject, ExportedMessageRepository, type ExportedMessageRepositoryItem, ExternalStoreRuntimeCore, type ExternalStoreThreadFactory, ExternalStoreThreadListRuntimeCore, ExternalStoreThreadRuntimeCore, LazyMemoizeSubject, LocalRuntimeCore, type LocalRuntimeOptionsBase, type LocalThreadFactory, LocalThreadListRuntimeCore, LocalThreadRuntimeCore, MessageAttachmentRuntimeImpl, MessagePartRuntimeImpl, MessageRepository, MessageRuntimeImpl, type MessageStateBinding, type NestedSubscribable, NestedSubscriptionSubject, OptimisticState, ReadonlyThreadRuntimeCore, type RemoteThreadData, type RemoteThreadInitializeResponse, type RemoteThreadListOptions, type RemoteThreadState, type RuntimeExtras, SKIP_UPDATE, type SKIP_UPDATE as SKIP_UPDATE_TYPE, ShallowMemoizeSubject, type Subscribable, type SubscribableWithState, type THREAD_MAPPING_ID, ThreadComposerAttachmentRuntimeImpl, type ThreadComposerRuntimeCoreBinding, ThreadComposerRuntimeImpl, type ThreadListItemRuntimeBinding, ThreadListItemRuntimeImpl, type ThreadListItemStateBinding, type ThreadListRuntimeCoreBinding, ThreadListRuntimeImpl, ThreadMessageConverter, type ThreadRuntimeCoreBinding, ThreadRuntimeImpl, createRuntimeExtras, createThreadMappingId, fromThreadMessageLike, generateErrorMessageId, generateId, getAutoStatus, getThreadData, getThreadMessageText, getThreadState, hasUpcomingMessage, isAutoStatus, isErrorMessageId, resolveToolApprovalResponse, shouldContinue, symbolInnerMessage, updateStatusReducer };
+export { AssistantRuntimeImpl, AttachmentRuntimeImpl, BaseAssistantRuntimeCore, BaseComposerRuntimeCore, BaseSubject, BaseSubscribable, BaseThreadRuntimeCore, type ComposerRuntimeCoreBinding, ComposerRuntimeImpl, CompositeContextProvider, type ConverterCallback, DefaultEditComposerRuntimeCore, DefaultThreadComposerRuntimeCore, EMPTY_THREAD_CORE, EditComposerAttachmentRuntimeImpl, type EditComposerRuntimeCoreBinding, EditComposerRuntimeImpl, type EventSubscribable, EventSubscriptionSubject, ExportedMessageRepository, type ExportedMessageRepositoryItem, ExternalStoreRuntimeCore, type ExternalStoreThreadFactory, ExternalStoreThreadListRuntimeCore, ExternalStoreThreadRuntimeCore, LazyMemoizeSubject, LocalRuntimeCore, type LocalRuntimeOptionsBase, type LocalThreadFactory, LocalThreadListRuntimeCore, LocalThreadRuntimeCore, MessageAttachmentRuntimeImpl, MessagePartRuntimeImpl, MessageRepository, MessageRuntimeImpl, type MessageStateBinding, type NestedSubscribable, NestedSubscriptionSubject, OptimisticState, ReadonlyThreadRuntimeCore, type RemoteThreadData, type RemoteThreadInitializeResponse, type RemoteThreadListOptions, type RemoteThreadState, type RuntimeExtras, SKIP_UPDATE, type SKIP_UPDATE as SKIP_UPDATE_TYPE, ShallowMemoizeSubject, type Subscribable, type SubscribableWithState, type THREAD_MAPPING_ID, ThreadComposerAttachmentRuntimeImpl, type ThreadComposerRuntimeCoreBinding, ThreadComposerRuntimeImpl, type ThreadListItemRuntimeBinding, ThreadListItemRuntimeImpl, type ThreadListItemStateBinding, type ThreadListRuntimeCoreBinding, ThreadListRuntimeImpl, ThreadMessageConverter, type ThreadRuntimeCoreBinding, ThreadRuntimeImpl, consumeSuggestionResult, createRuntimeExtras, createThreadMappingId, fromThreadMessageLike, generateErrorMessageId, generateId, getAutoStatus, getFileDataURL, getThreadData, getThreadMessageText, getThreadState, hasUpcomingMessage, isAutoStatus, isErrorMessageId, isJSONValue, isRecord, resolveToolApprovalResponse, shouldContinue, stableStringifyToolArgs, symbolInnerMessage, trackToolArgsKeyOrder, updateStatusReducer };

package/dist/internal.js

@@ -1,12 +1,16 @@
+import { isJSONValue, isRecord } from "./utils/json/is-json.js";
 import { generateErrorMessageId, generateId, isErrorMessageId } from "./utils/id.js";
+import { getFileDataURL } from "./adapters/attachment.js";
+import { getThreadMessageText } from "./utils/text.js";
+import { consumeSuggestionResult } from "./adapters/suggestion.js";
 import { fromThreadMessageLike } from "./runtime/utils/thread-message-like.js";
 import { symbolInnerMessage } from "./runtime/utils/external-store-message.js";
 import { getAutoStatus, isAutoStatus } from "./runtime/utils/auto-status.js";
 import { ExportedMessageRepository, MessageRepository } from "./runtime/utils/message-repository.js";
-import { getThreadMessageText } from "./utils/text.js";
 import { BaseSubject, BaseSubscribable, EventSubscriptionSubject, LazyMemoizeSubject, NestedSubscriptionSubject, SKIP_UPDATE, ShallowMemoizeSubject } from "./subscribable/subscribable.js";
 import { resolveToolApprovalResponse } from "./runtime/utils/resolveToolApprovalResponse.js";
 import { CompositeContextProvider } from "./utils/composite-context-provider.js";
+import { stableStringifyToolArgs, trackToolArgsKeyOrder } from "./utils/json/stable-stringify-tool-args.js";
 import { createRuntimeExtras } from "./react/runtimes/createRuntimeExtras.js";
 import { BaseAssistantRuntimeCore } from "./runtime/base/base-assistant-runtime-core.js";
 import { BaseComposerRuntimeCore } from "./runtime/base/base-composer-runtime-core.js";
@@ -33,4 +37,4 @@ import { ReadonlyThreadRuntimeCore } from "./runtimes/readonly/ReadonlyThreadRun
 import { OptimisticState } from "./runtimes/remote-thread-list/optimistic-state.js";
 import { EMPTY_THREAD_CORE } from "./runtimes/remote-thread-list/empty-thread-core.js";
 import { createThreadMappingId, getThreadData, updateStatusReducer } from "./runtimes/remote-thread-list/remote-thread-state.js";
-export { AssistantRuntimeImpl, AttachmentRuntimeImpl, BaseAssistantRuntimeCore, BaseComposerRuntimeCore, BaseSubject, BaseSubscribable, BaseThreadRuntimeCore, ComposerRuntimeImpl, CompositeContextProvider, DefaultEditComposerRuntimeCore, DefaultThreadComposerRuntimeCore, EMPTY_THREAD_CORE, EditComposerAttachmentRuntimeImpl, EditComposerRuntimeImpl, EventSubscriptionSubject, ExportedMessageRepository, ExternalStoreRuntimeCore, ExternalStoreThreadListRuntimeCore, ExternalStoreThreadRuntimeCore, LazyMemoizeSubject, LocalRuntimeCore, LocalThreadListRuntimeCore, LocalThreadRuntimeCore, MessageAttachmentRuntimeImpl, MessagePartRuntimeImpl, MessageRepository, MessageRuntimeImpl, NestedSubscriptionSubject, OptimisticState, ReadonlyThreadRuntimeCore, SKIP_UPDATE, ShallowMemoizeSubject, ThreadComposerAttachmentRuntimeImpl, ThreadComposerRuntimeImpl, ThreadListItemRuntimeImpl, ThreadListRuntimeImpl, ThreadMessageConverter, ThreadRuntimeImpl, createRuntimeExtras, createThreadMappingId, fromThreadMessageLike, generateErrorMessageId, generateId, getAutoStatus, getThreadData, getThreadMessageText, getThreadState, hasUpcomingMessage, isAutoStatus, isErrorMessageId, resolveToolApprovalResponse, shouldContinue, symbolInnerMessage, updateStatusReducer };
+export { AssistantRuntimeImpl, AttachmentRuntimeImpl, BaseAssistantRuntimeCore, BaseComposerRuntimeCore, BaseSubject, BaseSubscribable, BaseThreadRuntimeCore, ComposerRuntimeImpl, CompositeContextProvider, DefaultEditComposerRuntimeCore, DefaultThreadComposerRuntimeCore, EMPTY_THREAD_CORE, EditComposerAttachmentRuntimeImpl, EditComposerRuntimeImpl, EventSubscriptionSubject, ExportedMessageRepository, ExternalStoreRuntimeCore, ExternalStoreThreadListRuntimeCore, ExternalStoreThreadRuntimeCore, LazyMemoizeSubject, LocalRuntimeCore, LocalThreadListRuntimeCore, LocalThreadRuntimeCore, MessageAttachmentRuntimeImpl, MessagePartRuntimeImpl, MessageRepository, MessageRuntimeImpl, NestedSubscriptionSubject, OptimisticState, ReadonlyThreadRuntimeCore, SKIP_UPDATE, ShallowMemoizeSubject, ThreadComposerAttachmentRuntimeImpl, ThreadComposerRuntimeImpl, ThreadListItemRuntimeImpl, ThreadListRuntimeImpl, ThreadMessageConverter, ThreadRuntimeImpl, consumeSuggestionResult, createRuntimeExtras, createThreadMappingId, fromThreadMessageLike, generateErrorMessageId, generateId, getAutoStatus, getFileDataURL, getThreadData, getThreadMessageText, getThreadState, hasUpcomingMessage, isAutoStatus, isErrorMessageId, isJSONValue, isRecord, resolveToolApprovalResponse, shouldContinue, stableStringifyToolArgs, symbolInnerMessage, trackToolArgsKeyOrder, updateStatusReducer };

package/dist/model-context/frame/host.d.ts

@@ -1,6 +1,5 @@
 import { Unsubscribe } from "../../types/unsubscribe.js";
 import { ModelContext, ModelContextProvider } from "../types.js";
-
 //#region src/model-context/frame/host.d.ts
 declare class AssistantFrameHost implements ModelContextProvider {
   private _context;

package/dist/model-context/frame/host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host.d.ts","names":[],"sources":["../../../src/model-context/frame/host.ts"],"mappings":";;;;cA0Ca,kBAAA,YAA8B,oBAAA;EAAA,QACjC,QAAA;EAAA,QACA,YAAA;EAAA,QACA,gBAAA;EAAA,QAOA,eAAA;EAAA,QACA,aAAA;EAAA,QACA,aAAA;cAEI,YAAA,EAAc,MAAA,EAAQ,YAAA;EAAA,QAU1B,aAAA;EAAA,QA6BA,aAAA;EAAA,QAmBA,QAAA;EAAA,QAaA,WAAA;EAAA,QAqCA,cAAA;EAAA,QAYA,iBAAA;EAIR,eAAA,IAAmB,YAAA;EAInB,SAAA,CAAU,QAAA,eAAuB,WAAA;EAKjC,OAAA;AAAA"}
+{"version":3,"file":"host.d.ts","names":[],"sources":["../../../src/model-context/frame/host.ts"],"mappings":";;;cA0Ca,8BAA8B;UACjC;UACA;UACA;UAOA;UACA;UACA;cAEI,cAAc,QAAQ;UAU1B;UA6BA;UAmBA;UAaA;UAqCA;UAYA;EAIR,mBAAmB;EAInB,UAAU,uBAAuB;EAKjC"}

package/dist/model-context/frame/provider.d.ts

@@ -1,6 +1,5 @@
 import { Unsubscribe } from "../../types/unsubscribe.js";
 import { ModelContextProvider } from "../types.js";
-
 //#region src/model-context/frame/provider.d.ts
 declare class AssistantFrameProvider {
   private static _instance;

package/dist/model-context/frame/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","names":[],"sources":["../../../src/model-context/frame/provider.ts"],"mappings":";;;;cA+Ba,sBAAA;EAAA,eACI,SAAA;EAAA,QAEP,UAAA;EAAA,QACA,qBAAA;EAAA,QAIA,aAAA;EAAA,QAED,WAAA;EAAA,eAQQ,WAAA;EAAA,QASP,aAAA;EAAA,QAqBM,cAAA;EAAA,QAoCN,WAAA;EAAA,QAOA,eAAA;EAAA,QAkBA,eAAA;EAAA,OAcD,uBAAA,CACL,QAAA,EAAU,oBAAA,EACV,YAAA,YACC,WAAW;EAAA,OAmBP,OAAA;AAAA"}
+{"version":3,"file":"provider.d.ts","names":[],"sources":["../../../src/model-context/frame/provider.ts"],"mappings":";;;cA+Ba;iBACI;UAEP;UACA;UAIA;UAED;iBAQQ;UASP;UAqBM;UAoCN;UAOA;UAkBA;SAcD,wBACL,UAAU,sBACV,wBACC;SAmBI"}

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/model-context/frame/types.ts"],"mappings":";KAAY,cAAA;EACV,WAAA;EACA,UAAA;EACA,QAAA;EACA,IAAA;AAAA;AAAA,KAGU,sBAAA;EACV,MAAA;EACA,KAAA,GAAQ,MAAM,SAAS,cAAA;AAAA;AAAA,KAGb,gBAAA;AAAA,KAMA,YAAA;EAEN,IAAA;AAAA;EAGA,IAAA;EACA,OAAA,EAAS,sBAAsB;AAAA;EAG/B,IAAA;EACA,EAAA;EACA,QAAA;EACA,IAAA;AAAA;EAGA,IAAA;EACA,EAAA;EACA,MAAA;EACA,KAAA;AAAA;AAAA,cAGO,qBAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/model-context/frame/types.ts"],"mappings":";KAAY;EACV;EACA;EACA;EACA;;KAGU;EACV;EACA,QAAQ,eAAe;;KAGb;KAMA;EAEN;;EAGA;EACA,SAAS;;EAGT;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;;cAGO"}

package/dist/model-context/interactable-composer-metadata.d.ts

@@ -64,8 +64,10 @@ declare function shallowMergeInteractableState(prev: unknown, partial: unknown,
  * @deprecated Unstable / Experimental (not actually removed).
  */
 type Unstable_InteractableVersion = {
-  /** The full state as of this version. */state: unknown;
-  origin: "create" | "update" | "user-edit"; /** For create/update versions, the tool call that produced this version. */
+  /** The full state as of this version. */
+  state: unknown;
+  origin: "create" | "update" | "user-edit";
+  /** For create/update versions, the tool call that produced this version. */
   toolCallId?: string | undefined;
 };
 /**

package/dist/model-context/interactable-composer-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactable-composer-metadata.d.ts","names":[],"sources":["../../src/model-context/interactable-composer-metadata.ts"],"mappings":";;AAOA;;;KAAY,kCAAA;EACV,EAAA;EACA,IAAA;EACA,KAAA;EAMA;;AAAO;AACP;;EADA,OAAA;AAAA;;;;;AAWO;KAHJ,sBAAA;EACH,IAAA;EACA,QAAA;EACA,OAAA;AAAA;;;;AAcoC;AAgBtC;;;;AAC2C;iBAnB3B,iCAAA,CAAkC,OAAA;EAChD,QAAA;AAAA,IACE,kCAAkC;;AA0BW;AA0DjD;;;iBApEgB,mCAAA,CACd,KAAyC,EAAlC,kCAAkC;;iBAS3B,oBAAA,CAAqB,IAAY;;;;;;iBA0DjC,6BAAA,CACd,IAAA,WACA,OAAA,WACA,OAAA;EAEM,aAAA;EASO;AA8Ff;;;;EAjGQ,SAAA,IAAa,KAAA;EACb,aAAA,GAAgB,WAAW;AAAA;;AAqGvB;AA0BZ;;KA/BY,4BAAA;EAmCmB,yCAjC7B,KAAA;EACA,MAAA,qCA8BA;EA5BA,UAAA;AAAA;;AA8B6B;AAwE/B;;;;;;;;;;AAIU;AAaV;;;iBA7FgB,gCAAA,CACd,QAAA,WAAmB,sBAAA,IACnB,EAAA,UACA,IAAA,WACC,4BAA4B;;;;;iBAwEf,mBAAA,CACd,QAAA,WAAmB,sBAAsB,IACzC,EAAA,UACA,IAAA;EACG,KAAA;AAAA;;;;AAgBI;;;;iBAHO,gCAAA,CACd,IAAA,EAAM,MAAA,+BACN,QAAA,WAAmB,sBAAA,KAClB,MAAA"}
+{"version":3,"file":"interactable-composer-metadata.d.ts","names":[],"sources":["../../src/model-context/interactable-composer-metadata.ts"],"mappings":";;;;;KAOY;EACV;EACA;EACA;;;;;;EAMA;;;;;;;KAQG;EACH;EACA;EACA;;;;;;;;;;;iBAYc,kCAAkC;EAChD;IACE;;;;;;iBAgBY,oCACd,OAAO;;iBASO,qBAAqB;;;;;;iBA0DrB,8BACd,eACA,kBACA;EAEM;;;;;;EAMA,aAAa;EACb,gBAAgB;;;;;;KAgGZ;;EAEV;EACA;;EAEA;;;;;;;;;;;;;;;;;;iBA0Bc,iCACd,mBAAmB,0BACnB,YACA,eACC;;;;;iBAwEa,oBACd,mBAAmB,0BACnB,YACA;EACG;;;;;;;;;iBAaW,iCACd,MAAM,qCACN,mBAAmB,2BAClB"}

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

@@ -1,5 +1,4 @@
 import { AssistantInstructionsConfig, AssistantToolProps } from "./types.js";
-
 //#region src/model-context/registry-handles.d.ts
 interface ModelContextRegistryToolHandle<TArgs extends Record<string, unknown> = any, TResult = any> {
   update(tool: AssistantToolProps<TArgs, TResult>): void;

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

@@ -1 +1 @@
-{"version":3,"file":"registry-handles.d.ts","names":[],"sources":["../../src/model-context/registry-handles.ts"],"mappings":";;;UAEiB,8BAAA,eACD,MAAA;EAGd,MAAA,CAAO,IAAA,EAAM,kBAAA,CAAmB,KAAA,EAAO,OAAA;EACvC,MAAA;AAAA;AAAA,UAGe,qCAAA;EACf,MAAA,CAAO,MAAA,WAAiB,2BAA2B;EACnD,MAAA;AAAA;AAAA,UAGe,kCAAA;EACf,MAAM;AAAA"}
+{"version":3,"file":"registry-handles.d.ts","names":[],"sources":["../../src/model-context/registry-handles.ts"],"mappings":";;UAEiB,+BACf,cAAc,+BACd;EAEA,OAAO,MAAM,mBAAmB,OAAO;EACvC;;UAGe;EACf,OAAO,iBAAiB;EACxB;;UAGe;EACf"}

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/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;;KAGtB;EACH,SAAS;EACT;EACA,iBAAiB;;KAGd;EACH;EACA;EACA;EACA;EACA,SAAS;;cAwIE,4BACX,uBACC;cAoCU,+BACX,uBACC;cA8FU,4BACX,SAAS,+BACR"}

package/dist/react/adapters/LocalStorageThreadListAdapter.js

@@ -4,6 +4,121 @@ 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
+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;
@@ -20,14 +135,13 @@ 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 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);
@@ -74,7 +188,7 @@ const createLocalStorageAdapter = (options) => {
 	const messagesKey = (threadId) => `${prefix}messages:${threadId}`;
 	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));
@@ -138,12 +252,13 @@ const createLocalStorageAdapter = (options) => {
 			}
 		},
 		async delete(remoteId) {
-			await saveThreadMetadata((await loadThreadMetadata()).filter((t) => t.remoteId !== remoteId));
+			const filtered = (await loadThreadMetadata()).filter((t) => t.remoteId !== remoteId);
+			await saveThreadMetadata(filtered);
 			await storage.removeItem(messagesKey(remoteId));
 		},
 		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,
@@ -170,6 +285,6 @@ const createLocalStorageAdapter = (options) => {
 	};
 };
 //#endregion
-export { createLocalStorageAdapter };
+export { createLocalStorageAdapter, parseStoredMessageRepository, parseStoredThreadMetadata };
 
 //# sourceMappingURL=LocalStorageThreadListAdapter.js.map