@assistant-ui/core 0.3.18 → 0.3.20

package/dist/store/scopes/message.d.ts

@@ -5,7 +5,7 @@ import { AttachmentMethods } from "./attachment.js";
 import { ComposerMethods, ComposerState } from "./composer.js";
 import { PartMethods, PartState } from "./part.js";
 //#region src/store/scopes/message.d.ts
-type MessageState = ThreadMessage & {
+export type MessageState = ThreadMessage & {
   readonly parentId: string | null;
   readonly isLast: boolean;
   readonly branchNumber: number;
@@ -34,7 +34,7 @@ type MessageState = ThreadMessage & {
   /** The position of this message in the thread (0 for first message) */
   readonly index: number;
 };
-type MessageMethods = {
+export type MessageMethods = {
   /**
    * Get the current state of the message.
    */
@@ -50,6 +50,7 @@ type MessageMethods = {
   stopSpeaking(): void;
   submitFeedback(feedback: {
     type: "positive" | "negative";
+    comment?: string;
   }): void;
   switchToBranch(options: {
     position?: "previous" | "next";
@@ -70,7 +71,7 @@ type MessageMethods = {
   setIsHovering(value: boolean): void;
   __internal_getRuntime?(): MessageRuntime;
 };
-type MessageMeta = {
+export type MessageMeta = {
   source: "thread";
   query: {
     type: "id";
@@ -80,7 +81,7 @@ type MessageMeta = {
     index: number;
   };
 };
-type MessageEvents = {
+export type MessageEvents = {
   /** The user asked for this assistant message to be generated again. */
   "message.reload": {
     threadId: string;
@@ -108,11 +109,10 @@ type MessageEvents = {
     reason: "error";
   };
 };
-type MessageClientSchema = {
+export type MessageClientSchema = {
   methods: MessageMethods;
   meta: MessageMeta;
   events: MessageEvents;
 };
 //#endregion
-export { MessageClientSchema, MessageEvents, MessageMeta, MessageMethods, MessageState };
 //# sourceMappingURL=message.d.ts.map

package/dist/store/scopes/message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","names":[],"sources":["../../../src/store/scopes/message.ts"],"mappings":";;;;;;;KAQY,eAAe;WAChB;WACA;WACA;WACA;;;;;;;;;;;;;;;;;WAiBA,QAAQ;WACR,UAAU;WACV,gBAAgB;WAChB;WACA;;WAEA;;KAGC;;;;EAIV,YAAY;EACZ,YAAY;EACZ,iBAAiB;EACjB,OAAO;IAAW,YAAY;;;EAE9B;;EAEA;EACA,eAAe;IAAY;;EAC3B,eAAe;IACb;IACA;;EAEF;EACA,KAAK;IAAY;;IAAoB;MAAuB;EAC5D,WAAW;IAAY;;IAAoB;MAAe;EAC1D,YAAY;EACZ,cAAc;EACd,0BAA0B;;KAGhB;EACV;EACA;IAAS;IAAY;;IAAiB;IAAe;;;KAG3C;;EAEV;IAAoB;IAAkB;;;EAEtC;IAA4B;IAAkB;;;EAE9C;IAAoB;IAAkB;;;EAEtC;IAAmB;IAAkB;;;EAErC;IAAmB;IAAkB;IAAmB;;;KAG9C;EACV,SAAS;EACT,MAAM;EACN,QAAQ"}
+{"version":3,"file":"message.d.ts","names":[],"sources":["../../../src/store/scopes/message.ts"],"mappings":";;;;;;;YAQY,eAAe;WAChB;WACA;WACA;WACA;;;;;;;;;;;;;;;;;WAiBA,QAAQ;WACR,UAAU;WACV,gBAAgB;WAChB;WACA;;WAEA;;YAGC;;;;EAIV,YAAY;EACZ,YAAY;EACZ,iBAAiB;EACjB,OAAO;IAAW,YAAY;;;EAE9B;;EAEA;EACA,eAAe;IACb;IACA;;EAEF,eAAe;IACb;IACA;;EAEF;EACA,KAAK;IAAY;;IAAoB;MAAuB;EAC5D,WAAW;IAAY;;IAAoB;MAAe;EAC1D,YAAY;EACZ,cAAc;EACd,0BAA0B;;YAGhB;EACV;EACA;IAAS;IAAY;;IAAiB;IAAe;;;YAG3C;;EAEV;IAAoB;IAAkB;;;EAEtC;IAA4B;IAAkB;;;EAE9C;IAAoB;IAAkB;;;EAEtC;IAAmB;IAAkB;;;EAErC;IAAmB;IAAkB;IAAmB;;;YAG9C;EACV,SAAS;EACT,MAAM;EACN,QAAQ"}

package/dist/store/scopes/model-context.d.ts

@@ -1,17 +1,16 @@
 import { Unsubscribe } from "../../types/unsubscribe.js";
 import { ModelContextProvider } from "../../model-context/types.js";
 //#region src/store/scopes/model-context.d.ts
-type ModelContextState = {
+export type ModelContextState = {
   readonly modelName?: string | undefined;
   readonly toolNames: readonly string[];
 };
-type ModelContextMethods = ModelContextProvider & {
+export type ModelContextMethods = ModelContextProvider & {
   getState(): ModelContextState;
   register: (provider: ModelContextProvider) => Unsubscribe;
 };
-type ModelContextClientSchema = {
+export type ModelContextClientSchema = {
   methods: ModelContextMethods;
 };
 //#endregion
-export { ModelContextClientSchema, ModelContextMethods, ModelContextState };
 //# sourceMappingURL=model-context.d.ts.map

package/dist/store/scopes/model-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-context.d.ts","names":[],"sources":["../../../src/store/scopes/model-context.ts"],"mappings":";;;KAGY;WACD;WACA;;KAGC,sBAAsB;EAChC,YAAY;EACZ,WAAW,UAAU,yBAAyB;;KAGpC;EACV,SAAS"}
+{"version":3,"file":"model-context.d.ts","names":[],"sources":["../../../src/store/scopes/model-context.ts"],"mappings":";;;YAGY;WACD;WACA;;YAGC,sBAAsB;EAChC,YAAY;EACZ,WAAW,UAAU,yBAAyB;;YAGpC;EACV,SAAS"}

package/dist/store/scopes/part.d.ts

@@ -2,10 +2,10 @@ import { MessagePartStatus, ThreadAssistantMessagePart, ThreadUserMessagePart, T
 import { MessagePartRuntime } from "../../runtime/api/message-part-runtime.js";
 import { ToolResponse } from "assistant-stream";
 //#region src/store/scopes/part.d.ts
-type PartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
+export type PartState = (ThreadUserMessagePart | ThreadAssistantMessagePart) & {
   readonly status: MessagePartStatus | ToolCallMessagePartStatus;
 };
-type PartMethods = {
+export type PartMethods = {
   /**
    * Get the current state of the message part.
    */
@@ -31,7 +31,7 @@ type PartMethods = {
   respondToToolApproval(response: ToolApprovalResponse): Promise<void>;
   __internal_getRuntime?(): MessagePartRuntime;
 };
-type PartMeta = {
+export type PartMeta = {
   source: "message";
   query: {
     type: "index";
@@ -47,10 +47,9 @@ type PartMeta = {
     index: number;
   };
 };
-type PartClientSchema = {
+export type PartClientSchema = {
   methods: PartMethods;
   meta: PartMeta;
 };
 //#endregion
-export { PartClientSchema, PartMeta, PartMethods, PartState };
 //# sourceMappingURL=part.d.ts.map

package/dist/store/scopes/part.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"part.d.ts","names":[],"sources":["../../../src/store/scopes/part.ts"],"mappings":";;;;KAUY,aAAa,wBAAwB;WACtC,QAAQ,oBAAoB;;KAG3B;;;;EAIV,YAAY;;;;;EAKZ,cAAc,kBAAkB;;;;;EAKhC,eAAe;;;;;;;;;EASf,sBAAsB,UAAU,uBAAuB;EACvD,0BAA0B;;KAGhB;EAEN;EACA;IACM;IAAe;;IACf;IAAoB;;;EAG1B;EACA;IAAS;IAAe;;;KAGlB;EACV,SAAS;EACT,MAAM"}
+{"version":3,"file":"part.d.ts","names":[],"sources":["../../../src/store/scopes/part.ts"],"mappings":";;;;YAUY,aAAa,wBAAwB;WACtC,QAAQ,oBAAoB;;YAG3B;;;;EAIV,YAAY;;;;;EAKZ,cAAc,kBAAkB;;;;;EAKhC,eAAe;;;;;;;;;EASf,sBAAsB,UAAU,uBAAuB;EACvD,0BAA0B;;YAGhB;EAEN;EACA;IACM;IAAe;;IACf;IAAoB;;;EAG1B;EACA;IAAS;IAAe;;;YAGlB;EACV,SAAS;EACT,MAAM"}

package/dist/store/scopes/queue-item.d.ts

@@ -1,14 +1,14 @@
 import { QueueItemState } from "../../runtime/queue/queue-item.js";
 import { QueuePlacement } from "../../runtime/queue/external-thread-queue-adapter.js";
 //#region src/store/scopes/queue-item.d.ts
-type QueueItemMethods = {
+export type QueueItemMethods = {
   getState(): QueueItemState;
   /** @deprecated Use `move({ lane: "steer", insertAfter: null })` instead. Removal after 2026-11-05. */
   steer(): void;
   move(placement: QueuePlacement): void;
   remove(): void;
 };
-type QueueItemMeta = {
+export type QueueItemMeta = {
   source: "composer";
   query: {
     type: "index";
@@ -18,10 +18,10 @@ type QueueItemMeta = {
     id: string;
   };
 };
-type QueueItemClientSchema = {
+export type QueueItemClientSchema = {
   methods: QueueItemMethods;
   meta: QueueItemMeta;
 };
 //#endregion
-export { QueueItemClientSchema, QueueItemMeta, QueueItemMethods, type QueueItemState };
+export type { QueueItemState };
 //# sourceMappingURL=queue-item.d.ts.map

package/dist/store/scopes/queue-item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue-item.d.ts","names":[],"sources":["../../../src/store/scopes/queue-item.ts"],"mappings":";;;KAKY;EACV,YAAY;;EAEZ;EACA,KAAK,WAAW;EAChB;;KAGU;EACV;EACA;IAAS;IAAe;;IAAoB;IAAY;;;KAG9C;EACV,SAAS;EACT,MAAM"}
+{"version":3,"file":"queue-item.d.ts","names":[],"sources":["../../../src/store/scopes/queue-item.ts"],"mappings":";;;YAKY;EACV,YAAY;;EAEZ;EACA,KAAK,WAAW;EAChB;;YAGU;EACV;EACA;IAAS;IAAe;;IAAoB;IAAY;;;YAG9C;EACV,SAAS;EACT,MAAM"}

package/dist/store/scopes/suggestion.d.ts

@@ -1,22 +1,21 @@
 //#region src/store/scopes/suggestion.d.ts
-type SuggestionState = {
+export type SuggestionState = {
   title: string;
   label: string;
   prompt: string;
 };
-type SuggestionMethods = {
+export type SuggestionMethods = {
   getState(): SuggestionState;
 };
-type SuggestionMeta = {
+export type SuggestionMeta = {
   source: "suggestions";
   query: {
     index: number;
   };
 };
-type SuggestionClientSchema = {
+export type SuggestionClientSchema = {
   methods: SuggestionMethods;
   meta: SuggestionMeta;
 };
 //#endregion
-export { SuggestionClientSchema, SuggestionMeta, SuggestionMethods, SuggestionState };
 //# sourceMappingURL=suggestion.d.ts.map

package/dist/store/scopes/suggestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suggestion.d.ts","names":[],"sources":["../../../src/store/scopes/suggestion.ts"],"mappings":";KAAY;EACV;EACA;EACA;;KAGU;EACV,YAAY;;KAGF;EACV;EACA;IAAS;;;KAGC;EACV,SAAS;EACT,MAAM"}
+{"version":3,"file":"suggestion.d.ts","names":[],"sources":["../../../src/store/scopes/suggestion.ts"],"mappings":";YAAY;EACV;EACA;EACA;;YAGU;EACV,YAAY;;YAGF;EACV;EACA;IAAS;;;YAGC;EACV,SAAS;EACT,MAAM"}

package/dist/store/scopes/suggestions.d.ts

@@ -1,27 +1,26 @@
 import { SuggestionMethods } from "./suggestion.js";
 //#region src/store/scopes/suggestions.d.ts
-type Suggestion = {
+export type Suggestion = {
   title: string;
   label: string;
   prompt: string;
 };
-type SuggestionsState = {
+export type SuggestionsState = {
   suggestions: Suggestion[];
 };
-type SuggestionsMethods = {
+export type SuggestionsMethods = {
   getState(): SuggestionsState;
   suggestion(query: {
     index: number;
   }): SuggestionMethods;
 };
-type SuggestionsMeta = {
+export type SuggestionsMeta = {
   source: "thread";
   query: Record<string, never>;
 };
-type SuggestionsClientSchema = {
+export type SuggestionsClientSchema = {
   methods: SuggestionsMethods;
   meta: SuggestionsMeta;
 };
 //#endregion
-export { Suggestion, SuggestionsClientSchema, SuggestionsMeta, SuggestionsMethods, SuggestionsState };
 //# sourceMappingURL=suggestions.d.ts.map

package/dist/store/scopes/suggestions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suggestions.d.ts","names":[],"sources":["../../../src/store/scopes/suggestions.ts"],"mappings":";;KAEY;EACV;EACA;EACA;;KAGU;EACV,aAAa;;KAGH;EACV,YAAY;EACZ,WAAW;IAAS;MAAkB;;KAG5B;EACV;EACA,OAAO;;KAGG;EACV,SAAS;EACT,MAAM"}
+{"version":3,"file":"suggestions.d.ts","names":[],"sources":["../../../src/store/scopes/suggestions.ts"],"mappings":";;YAEY;EACV;EACA;EACA;;YAGU;EACV,aAAa;;YAGH;EACV,YAAY;EACZ,WAAW;IAAS;MAAkB;;YAG5B;EACV;EACA,OAAO;;YAGG;EACV,SAAS;EACT,MAAM"}

package/dist/store/scopes/task.d.ts

@@ -0,0 +1,35 @@
+import { ThreadMessage, ToolCallMessagePart, ToolCallMessagePartStatus } from "../../types/message.js";
+//#region src/store/scopes/task.d.ts
+/** A tool call that carries a nested conversation, read as one unit of child work; `id` is its toolCallId. */
+export type TaskState = {
+  readonly id: string;
+  readonly toolName: string;
+  readonly args: ToolCallMessagePart["args"];
+  readonly result?: ToolCallMessagePart["result"];
+  readonly isError?: boolean;
+  readonly status: ToolCallMessagePartStatus;
+  readonly timing?: ToolCallMessagePart["timing"];
+  readonly messageId: string;
+  readonly parentTaskId: string | null;
+  readonly depth: number;
+  readonly messages: readonly ThreadMessage[];
+};
+export type TaskMethods = {
+  getState(): TaskState;
+};
+export type TaskMeta = {
+  source: "thread";
+  query: {
+    type: "index";
+    index: number;
+  } | {
+    type: "id";
+    id: string;
+  };
+};
+export type TaskClientSchema = {
+  methods: TaskMethods;
+  meta: TaskMeta;
+};
+//#endregion
+//# sourceMappingURL=task.d.ts.map

package/dist/store/scopes/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","names":[],"sources":["../../../src/store/scopes/task.ts"],"mappings":";;;YAOY;WACD;WACA;WACA,MAAM;WACN,SAAS;WACT;WACA,QAAQ;WACR,SAAS;WACT;WACA;WACA;WACA,mBAAmB;;YAGlB;EACV,YAAY;;YAGF;EACV;EACA;IAAS;IAAe;;IAAoB;IAAY;;;YAG9C;EACV,SAAS;EACT,MAAM"}

package/dist/store/scopes/thread-list-item.d.ts

@@ -1,7 +1,7 @@
 import { ThreadListItemStatus } from "../../runtime/interfaces/thread-list-runtime-core.js";
 import { ThreadListItemGenerateTitleOptions, ThreadListItemRuntime } from "../../runtime/api/thread-list-item-runtime.js";
 //#region src/store/scopes/thread-list-item.d.ts
-type ThreadListItemState = {
+export type ThreadListItemState = {
   readonly id: string;
   readonly remoteId: string | undefined;
   readonly externalId: string | undefined;
@@ -17,7 +17,7 @@ type ThreadListItemState = {
    */
   readonly isRunning: boolean;
 };
-type ThreadListItemMethods = {
+export type ThreadListItemMethods = {
   getState(): ThreadListItemState;
   switchTo(options?: {
     unarchive?: boolean;
@@ -35,7 +35,7 @@ type ThreadListItemMethods = {
   detach(): void;
   __internal_getRuntime?(): ThreadListItemRuntime;
 };
-type ThreadListItemMeta = {
+export type ThreadListItemMeta = {
   source: "threads";
   query: {
     type: "main";
@@ -48,7 +48,7 @@ type ThreadListItemMeta = {
     archived?: boolean;
   };
 };
-type ThreadListItemEvents = {
+export type ThreadListItemEvents = {
   /**
    * @deprecated Use `threads.selectionChanged` instead; its `threadId` is the
    * newly selected thread. Inside a per-item `threadListItem` scope, filter by
@@ -67,11 +67,10 @@ type ThreadListItemEvents = {
     threadId: string;
   };
 };
-type ThreadListItemClientSchema = {
+export type ThreadListItemClientSchema = {
   methods: ThreadListItemMethods;
   meta: ThreadListItemMeta;
   events: ThreadListItemEvents;
 };
 //#endregion
-export { ThreadListItemClientSchema, ThreadListItemEvents, ThreadListItemMeta, ThreadListItemMethods, ThreadListItemState };
 //# sourceMappingURL=thread-list-item.d.ts.map

package/dist/store/scopes/thread-list-item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread-list-item.d.ts","names":[],"sources":["../../../src/store/scopes/thread-list-item.ts"],"mappings":";;;KAMY;WACD;WACA;WACA;WACA;WACA,gBAAgB;WAChB,QAAQ;WACR,SAAS;;;;;;;WAOT;;KAGC;EACV,YAAY;EACZ,SAAS;IAAY;;EACrB,OAAO;EACP,aAAa,QAAQ;EACrB;EACA;EACA;EACA,cAAc,UAAU;EACxB,cAAc;IAAU;IAAkB;;EAC1C;EACA,0BAA0B;;KAGhB;EACV;EACA;IACM;;IACA;IAAY;;IACZ;IAAe;IAAe;;;KAG1B;;;;;;;EAOV;IAA+B;;;;;;;EAM/B;IAAiC;;;KAGvB;EACV,SAAS;EACT,MAAM;EACN,QAAQ"}
+{"version":3,"file":"thread-list-item.d.ts","names":[],"sources":["../../../src/store/scopes/thread-list-item.ts"],"mappings":";;;YAMY;WACD;WACA;WACA;WACA;WACA,gBAAgB;WAChB,QAAQ;WACR,SAAS;;;;;;;WAOT;;YAGC;EACV,YAAY;EACZ,SAAS;IAAY;;EACrB,OAAO;EACP,aAAa,QAAQ;EACrB;EACA;EACA;EACA,cAAc,UAAU;EACxB,cAAc;IAAU;IAAkB;;EAC1C;EACA,0BAA0B;;YAGhB;EACV;EACA;IACM;;IACA;IAAY;;IACZ;IAAe;IAAe;;;YAG1B;;;;;;;EAOV;IAA+B;;;;;;;EAM/B;IAAiC;;;YAGvB;EACV,SAAS;EACT,MAAM;EACN,QAAQ"}

package/dist/store/scopes/thread.d.ts

@@ -6,10 +6,11 @@ import { RuntimeCapabilities, SpeechState, ThreadSuggestion, VoiceSessionState }
 import { ComposerMethods, ComposerState } from "./composer.js";
 import { MessageMethods, MessageState } from "./message.js";
 import { SuggestionsMethods } from "./suggestions.js";
+import { TaskMethods, TaskState } from "./task.js";
 import { CreateAppendMessage, CreateResumeRunConfig, CreateStartRunConfig, ThreadRuntime } from "../../runtime/api/thread-runtime.js";
 import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/store/scopes/thread.d.ts
-type ThreadState = {
+export type ThreadState = {
   /**
    * Whether the thread is empty. A thread is considered empty when it has no messages and is not loading.
    */
@@ -34,6 +35,10 @@ type ThreadState = {
    * The messages in the currently selected branch of the thread.
    */
   readonly messages: readonly MessageState[];
+  /**
+   * Child work derived from the thread's tool calls: every tool call that carries a nested conversation, in document order with nested tasks after their parent. The array keeps its identity while no task changed.
+   */
+  readonly tasks: readonly TaskState[];
   /**
    * The thread state.
    * @deprecated This feature is experimental
@@ -52,7 +57,7 @@ type ThreadState = {
   readonly voice: VoiceSessionState | undefined;
   readonly composer: ComposerState;
 };
-type ThreadMethods = {
+export type ThreadMethods = {
   /**
    * Get the current state of the thread.
    */
@@ -65,6 +70,14 @@ type ThreadMethods = {
    * The suggestions shown for this thread.
    */
   suggestions(): SuggestionsMethods;
+  /**
+   * Access a task by index or toolCallId; an id resolves the first task with that toolCallId in document order.
+   */
+  task(selector: {
+    index: number;
+  } | {
+    id: string;
+  }): TaskMethods;
   /**
    * Append a new message to the thread.
    *
@@ -130,13 +143,20 @@ type ThreadMethods = {
   unmuteVoice(): void;
   __internal_getRuntime?(): ThreadRuntime;
 };
-type ThreadMeta = {
+export type ThreadMeta = {
   source: "threads";
   query: {
     type: "main";
   };
 };
-type ThreadEvents = {
+export type ThreadEvents = {
+  "thread.toolApprovalAnswered": {
+    threadId: string;
+    messageId: string;
+    toolCallId: string;
+    toolName: string;
+    approved: boolean;
+  };
   /**
    * A run started on this thread. Also observable as `isRunning` flipping to
    * `true` in thread state.
@@ -176,11 +196,10 @@ type ThreadEvents = {
     threadId: string;
   };
 };
-type ThreadClientSchema = {
+export type ThreadClientSchema = {
   methods: ThreadMethods;
   meta: ThreadMeta;
   events: ThreadEvents;
 };
 //#endregion
-export { ThreadClientSchema, ThreadEvents, ThreadMeta, ThreadMethods, ThreadState };
 //# sourceMappingURL=thread.d.ts.map

package/dist/store/scopes/thread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread.d.ts","names":[],"sources":["../../../src/store/scopes/thread.ts"],"mappings":";;;;;;;;;;;KAqBY;;;;WAID;;;;WAIA;;;;WAIA;;;;WAIA;;;;WAIA,cAAc;;;;WAId,mBAAmB;;;;;WAKnB,OAAO;;;;WAIP,sBAAsB;;;;WAItB;;WAEA,QAAQ;WACR,OAAO;WACP,UAAU;;KAGT;;;;EAIV,YAAY;;;;EAIZ,YAAY;;;;EAIZ,eAAe;;;;;;;;;;;;;;;;;EAiBf,OAAO,SAAS;EAChB,cAAc,2BAA2B;;;;;EAKzC,SAAS,QAAQ;;;;;EAKjB,UAAU,QAAQ;EAClB;;;;;;;;;;;;EAYA,2BAA2B;EAC3B,mBAAmB;EACnB,UAAU;EACV,OAAO,YAAY;;;;;EAKnB,MAAM,2BAA2B;EACjC,oBAAoB;EACpB,QAAQ;IAAY;;IAAiB;MAAkB;;EAEvD;EACA;EACA;EACA;EACA,qBAAqB,uBAAuB;EAC5C;EACA;EACA,0BAA0B;;KAGhB;EACV;EACA;IAAS;;;KAGC;;;;;EAKV;IAAqB;;;;;;;EAMrB;IAAmB;;;EAEnB;IAAsB;;;EAEtB;IAAyB;;;;;;;EAMzB;IAAuB;;;;;;EAKvB;IAA+B;;;KAGrB;EACV,SAAS;EACT,MAAM;EACN,QAAQ"}
+{"version":3,"file":"thread.d.ts","names":[],"sources":["../../../src/store/scopes/thread.ts"],"mappings":";;;;;;;;;;;;YAsBY;;;;WAID;;;;WAIA;;;;WAIA;;;;WAIA;;;;WAIA,cAAc;;;;WAId,mBAAmB;;;;WAInB,gBAAgB;;;;;WAKhB,OAAO;;;;WAIP,sBAAsB;;;;WAItB;;WAEA,QAAQ;WACR,OAAO;WACP,UAAU;;YAGT;;;;EAIV,YAAY;;;;EAIZ,YAAY;;;;EAIZ,eAAe;;;;EAIf,KAAK;IAAY;;IAAoB;MAAe;;;;;;;;;;;;;;;;;EAiBpD,OAAO,SAAS;EAChB,cAAc,2BAA2B;;;;;EAKzC,SAAS,QAAQ;;;;;EAKjB,UAAU,QAAQ;EAClB;;;;;;;;;;;;EAYA,2BAA2B;EAC3B,mBAAmB;EACnB,UAAU;EACV,OAAO,YAAY;;;;;EAKnB,MAAM,2BAA2B;EACjC,oBAAoB;EACpB,QAAQ;IAAY;;IAAiB;MAAkB;;EAEvD;EACA;EACA;EACA;EACA,qBAAqB,uBAAuB;EAC5C;EACA;EACA,0BAA0B;;YAGhB;EACV;EACA;IAAS;;;YAGC;EACV;IACE;IACA;IACA;IACA;IACA;;;;;;EAMF;IAAqB;;;;;;;EAMrB;IAAmB;;;EAEnB;IAAsB;;;EAEtB;IAAyB;;;;;;;EAMzB;IAAuB;;;;;;EAKvB;IAA+B;;;YAGrB;EACV,SAAS;EACT,MAAM;EACN,QAAQ"}

package/dist/store/scopes/threads.d.ts

@@ -2,7 +2,7 @@ import { ThreadListItemMethods, ThreadListItemState } from "./thread-list-item.j
 import { ThreadMethods, ThreadState } from "./thread.js";
 import { AssistantRuntime } from "../../runtime/api/assistant-runtime.js";
 //#region src/store/scopes/threads.d.ts
-type ThreadsState = {
+export type ThreadsState = {
   readonly mainThreadId: string;
   readonly newThreadId: string | null;
   readonly isLoading: boolean;
@@ -14,7 +14,7 @@ type ThreadsState = {
   readonly threadItems: readonly ThreadListItemState[];
   readonly main: ThreadState;
 };
-type ThreadsMethods = {
+export type ThreadsMethods = {
   getState(): ThreadsState;
   switchToThread(threadId: string, options?: {
     unarchive?: boolean;
@@ -33,7 +33,7 @@ type ThreadsMethods = {
   loadMore(): Promise<void>;
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };
-type ThreadsEvents = {
+export type ThreadsEvents = {
   /**
    * The main thread selection changed. Fires once per switch with the newly
    * selected thread and the thread that was selected before. Does not fire
@@ -48,10 +48,9 @@ type ThreadsEvents = {
     previousThreadId: string;
   };
 };
-type ThreadsClientSchema = {
+export type ThreadsClientSchema = {
   methods: ThreadsMethods;
   events: ThreadsEvents;
 };
 //#endregion
-export { ThreadsClientSchema, ThreadsEvents, ThreadsMethods, ThreadsState };
 //# sourceMappingURL=threads.d.ts.map

package/dist/store/scopes/threads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"threads.d.ts","names":[],"sources":["../../../src/store/scopes/threads.ts"],"mappings":";;;;KAOY;WACD;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA,sBAAsB;WACtB,MAAM;;KAGL;EACV,YAAY;EACZ,eAAe,kBAAkB;IAAY;;EAC7C;EACA,KACE;IAEM;;IACA;IAAe;MACpB;EACH,OAAO,mBAAmB;EAC1B,yBAAyB;EACzB,UAAU;EACV,oBAAoB;EACpB,YAAY;EACZ,mCAAmC;;KAGzB;;;;;;;;;;EAUV;IAA8B;IAAkB;;;KAGtC;EACV,SAAS;EACT,QAAQ"}
+{"version":3,"file":"threads.d.ts","names":[],"sources":["../../../src/store/scopes/threads.ts"],"mappings":";;;;YAOY;WACD;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA,sBAAsB;WACtB,MAAM;;YAGL;EACV,YAAY;EACZ,eAAe,kBAAkB;IAAY;;EAC7C;EACA,KACE;IAEM;;IACA;IAAe;MACpB;EACH,OAAO,mBAAmB;EAC1B,yBAAyB;EACzB,UAAU;EACV,oBAAoB;EACpB,YAAY;EACZ,mCAAmC;;YAGzB;;;;;;;;;;EAUV;IAA8B;IAAkB;;;YAGtC;EACV,SAAS;EACT,QAAQ"}

package/dist/subscribable/subscribable.d.ts

@@ -1,36 +1,37 @@
 import { Unsubscribe } from "../types/unsubscribe.js";
 //#region src/subscribable/subscribable.d.ts
-declare const SKIP_UPDATE: unique symbol;
-type SKIP_UPDATE = typeof SKIP_UPDATE;
-type Subscribable = {
+export declare const SKIP_UPDATE: unique symbol;
+export type SKIP_UPDATE = typeof SKIP_UPDATE;
+export type Subscribable = {
   subscribe: (callback: () => void) => Unsubscribe;
 };
-type SubscribableWithState<TState, TPath> = Subscribable & {
+export type SubscribableWithState<TState, TPath> = Subscribable & {
   path: TPath;
   getState: () => TState;
 };
-type NestedSubscribable<TState extends Subscribable | undefined, TPath> = SubscribableWithState<TState, TPath>;
-type EventSubscribable<TEvent extends string> = {
+export type NestedSubscribable<TState extends Subscribable | undefined, TPath> = SubscribableWithState<TState, TPath>;
+export type EventSubscribable<TEvent extends string> = {
   event: TEvent;
   binding: SubscribableWithState<{
     unstable_on: (event: TEvent, callback: (payload?: unknown) => void) => Unsubscribe;
   } | undefined, unknown>;
 };
-declare const notifySubscribers: <TArgs extends unknown[]>(subscribers: Iterable<(...args: TArgs) => void>, ...args: TArgs) => void;
-declare class BaseSubscribable {
+export declare const notifySubscribers: <TArgs extends unknown[]>(subscribers: Iterable<(...args: TArgs) => void>, ...args: TArgs) => void;
+export declare const runCleanups: (cleanups: Iterable<Unsubscribe>) => void;
+export declare class BaseSubscribable {
   private _subscribers;
   subscribe(callback: () => void): Unsubscribe;
   waitForUpdate(): Promise<void>;
   protected _notifySubscribers(): void;
 }
-declare class WritableSubscribable<TState> extends BaseSubscribable {
+export declare class WritableSubscribable<TState> extends BaseSubscribable {
   private _state;
   constructor(state: TState);
   getState(): TState;
   getServerSnapshot: () => TState;
   setState(state: TState): void;
 }
-declare abstract class BaseSubject {
+export declare abstract class BaseSubject {
   private _subscriptions;
   private _connection;
   protected get isConnected(): boolean;
@@ -39,7 +40,7 @@ declare abstract class BaseSubject {
   private _updateConnection;
   subscribe(callback: (payload?: unknown) => void): () => void;
 }
-declare class ShallowMemoizeSubject<TState extends object, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath> {
+export declare class ShallowMemoizeSubject<TState extends object, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath> {
   get path(): TPath;
   private binding;
   constructor(binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>);
@@ -48,7 +49,7 @@ declare class ShallowMemoizeSubject<TState extends object, TPath> extends BaseSu
   private _syncState;
   protected _connect(): Unsubscribe;
 }
-declare class LazyMemoizeSubject<TState extends object, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath> {
+export declare class LazyMemoizeSubject<TState extends object, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath> {
   get path(): TPath;
   private binding;
   constructor(binding: SubscribableWithState<TState | SKIP_UPDATE, TPath>);
@@ -57,7 +58,7 @@ declare class LazyMemoizeSubject<TState extends object, TPath> extends BaseSubje
   getState: () => TState;
   protected _connect(): Unsubscribe;
 }
-declare class NestedSubscriptionSubject<TState extends Subscribable | undefined, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath>, NestedSubscribable<TState, TPath> {
+export declare class NestedSubscriptionSubject<TState extends Subscribable | undefined, TPath> extends BaseSubject implements SubscribableWithState<TState, TPath>, NestedSubscribable<TState, TPath> {
   get path(): TPath;
   private binding;
   constructor(binding: NestedSubscribable<TState, TPath>);
@@ -65,7 +66,7 @@ declare class NestedSubscriptionSubject<TState extends Subscribable | undefined,
   outerSubscribe(callback: () => void): Unsubscribe;
   protected _connect(): Unsubscribe;
 }
-declare class EventSubscriptionSubject<TEvent extends string> extends BaseSubject {
+export declare class EventSubscriptionSubject<TEvent extends string> extends BaseSubject {
   private config;
   constructor(config: EventSubscribable<TEvent>);
   getState(): {
@@ -75,5 +76,4 @@ declare class EventSubscriptionSubject<TEvent extends string> extends BaseSubjec
   protected _connect(): Unsubscribe;
 }
 //#endregion
-export { BaseSubject, BaseSubscribable, EventSubscribable, EventSubscriptionSubject, LazyMemoizeSubject, NestedSubscribable, NestedSubscriptionSubject, SKIP_UPDATE, ShallowMemoizeSubject, Subscribable, SubscribableWithState, WritableSubscribable, notifySubscribers };
 //# sourceMappingURL=subscribable.d.ts.map

package/dist/subscribable/subscribable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscribable.d.ts","names":[],"sources":["../../src/subscribable/subscribable.ts"],"mappings":";;cAIa;KACD,qBAAqB;KAErB;EACV,YAAY,yBAAyB;;KAG3B,sBAAsB,QAAQ,SAAS;EACjD,MAAM;EACN,gBAAgB;;KAGN,mBACV,eAAe,0BACf,SACE,sBAAsB,QAAQ;KAEtB,kBAAkB;EAC5B,OAAO;EACP,SAAS;IAEH,cACE,OAAO,QACP,WAAW,+BACR;;;cAOA,oBAAqB,yBAChC,aAAa,aAAa,MAAM,oBAC7B,MAAM;cA4BE;UACH;EAED,UAAU,uBAAuB;EAKjC,iBAAa;YASV;;cAKC,qBAAqB,gBAAgB;UACxC;EAEI,YAAA,OAAO;EAUZ,YAAY;EAIZ,yBAAyB;EAEzB,SAAS,OAAO;;uBAQH;UACZ;UACA;gBAEM;qBAIK,YAAY;YAErB,kBAAkB,mBAAmB;UASvC;EAUD,UAAU,WAAW;;cAWjB,sBAAsB,uBAAuB,eAChD,uBACG,sBAAsB,QAAQ;MAE9B,QAAI;UAIP;EAEI,YAAA,SAAS,sBAAsB,SAAS,aAAa;UASzD;EACD,gBAAQ;UAKP;YAQE,YAAQ;;cAaP,mBAAmB,uBAAuB,eAC7C,uBACG,sBAAsB,QAAQ;MAE9B,QAAI;UAIP;EAEI,YAAA,SAAS,sBAAsB,SAAS,aAAa;UAKzD;UACA;EACD,gBAAQ;YAiBL,YAAQ;;cAYP,0BACX,eAAe,0BACf,eAEQ,uBAEN,sBAAsB,QAAQ,QAC9B,mBAAmB,QAAQ;MAElB,QAAI;UAIP;EAEI,YAAA,SAAS,mBAAmB,QAAQ;EAKzC,YAAQ;EAIR,eAAe,uBAAoB;YAIhC,YAAY;;cA0BX,yBACX,+BACQ;UACA;EAEI,YAAA,QAAQ,kBAAkB;EAK/B;IA3RW,cAAA,OAAA,QAAA,WAAC,+BACR;;EA8RJ,eAAe,uBAAoB;YAIhC,YAAY"}
+{"version":3,"file":"subscribable.d.ts","names":[],"sources":["../../src/subscribable/subscribable.ts"],"mappings":";;qBAIa;YACD,qBAAqB;YAErB;EACV,YAAY,yBAAyB;;YAG3B,sBAAsB,QAAQ,SAAS;EACjD,MAAM;EACN,gBAAgB;;YAGN,mBACV,eAAe,0BACf,SACE,sBAAsB,QAAQ;YAEtB,kBAAkB;EAC5B,OAAO;EACP,SAAS;IAEH,cACE,OAAO,QACP,WAAW,+BACR;;;qBAOA,oBAAqB,yBAChC,aAAa,aAAa,MAAM,oBAC7B,MAAM;qBAuBE,cAAe,UAAU,SAAS;qBASlC;UACH;EAED,UAAU,uBAAuB;EAKjC,iBAAa;YASV;;qBAKC,qBAAqB,gBAAgB;UACxC;EAEI,YAAA,OAAO;EAUZ,YAAY;EAIZ,yBAAyB;EAEzB,SAAS,OAAO;;8BAQH;UACZ;UACA;gBAEM;qBAIK,YAAY;YAErB,kBAAkB,mBAAmB;UASvC;EAWD,UAAU,WAAW;;qBAWjB,sBAAsB,uBAAuB,eAChD,uBACG,sBAAsB,QAAQ;MAE9B,QAAI;UAIP;EAEI,YAAA,SAAS,sBAAsB,SAAS,aAAa;UASzD;EACD,gBAAQ;UAKP;YAQE,YAAQ;;qBAaP,mBAAmB,uBAAuB,eAC7C,uBACG,sBAAsB,QAAQ;MAE9B,QAAI;UAIP;EAEI,YAAA,SAAS,sBAAsB,SAAS,aAAa;UAKzD;UACA;EACD,gBAAQ;YAiBL,YAAQ;;qBAYP,0BACX,eAAe,0BACf,eAEQ,uBAEN,sBAAsB,QAAQ,QAC9B,mBAAmB,QAAQ;MAElB,QAAI;UAIP;EAEI,YAAA,SAAS,mBAAmB,QAAQ;EAKzC,YAAQ;EAIR,eAAe,uBAAoB;YAIhC,YAAY;;qBA4BX,yBACX,+BACQ;UACA;EAEI,YAAA,QAAQ,kBAAkB;EAK/B;IAlSW,cAAA,OAAA,QAAA,WAAC,+BACR;;EAqSJ,eAAe,uBAAoB;YAIhC,YAAY"}

package/dist/subscribable/subscribable.js

@@ -15,6 +15,9 @@ const notifySubscribers = (subscribers, ...args) => {
 		throw new AggregateError(errors);
 	}
 };
+const runCleanups = (cleanups) => {
+	notifySubscribers(cleanups);
+};
 const shallowEqualOrUndefined = (a, b) => a === void 0 || b === void 0 ? a === b : shallowEqual(a, b);
 var BaseSubscribable = class {
 	_subscribers = /* @__PURE__ */ new Set();
@@ -71,8 +74,9 @@ var BaseSubject = class {
 			if (this._connection) return;
 			this._connection = this._connect();
 		} else {
-			this._connection?.();
+			const connection = this._connection;
 			this._connection = void 0;
+			connection?.();
 		}
 	}
 	subscribe(callback) {
@@ -172,15 +176,17 @@ var NestedSubscriptionSubject = class extends BaseSubject {
 			const newState = this.binding.getState();
 			if (newState === lastState) return;
 			lastState = newState;
-			innerUnsubscribe?.();
-			innerUnsubscribe = newState?.subscribe(callback);
-			callback();
+			const previousInner = innerUnsubscribe;
+			innerUnsubscribe = void 0;
+			try {
+				previousInner?.();
+			} finally {
+				innerUnsubscribe = newState?.subscribe(callback);
+				callback();
+			}
 		};
 		const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
-		return () => {
-			outerUnsubscribe?.();
-			innerUnsubscribe?.();
-		};
+		return () => runCleanups([() => outerUnsubscribe?.(), () => innerUnsubscribe?.()]);
 	}
 };
 var EventSubscriptionSubject = class extends BaseSubject {
@@ -206,17 +212,19 @@ var EventSubscriptionSubject = class extends BaseSubject {
 			const newState = this.config.binding.getState();
 			if (newState === lastState) return;
 			lastState = newState;
-			innerUnsubscribe?.();
-			innerUnsubscribe = newState?.unstable_on(this.config.event, callback);
+			const previousInner = innerUnsubscribe;
+			innerUnsubscribe = void 0;
+			try {
+				previousInner?.();
+			} finally {
+				innerUnsubscribe = newState?.unstable_on(this.config.event, callback);
+			}
 		};
 		const outerUnsubscribe = this.outerSubscribe(onRuntimeUpdate);
-		return () => {
-			outerUnsubscribe?.();
-			innerUnsubscribe?.();
-		};
+		return () => runCleanups([() => outerUnsubscribe?.(), () => innerUnsubscribe?.()]);
 	}
 };
 //#endregion
-export { BaseSubject, BaseSubscribable, EventSubscriptionSubject, LazyMemoizeSubject, NestedSubscriptionSubject, SKIP_UPDATE, ShallowMemoizeSubject, WritableSubscribable, notifySubscribers };
+export { BaseSubject, BaseSubscribable, EventSubscriptionSubject, LazyMemoizeSubject, NestedSubscriptionSubject, SKIP_UPDATE, ShallowMemoizeSubject, WritableSubscribable, notifySubscribers, runCleanups };
 
 //# sourceMappingURL=subscribable.js.map