@assistant-ui/core 0.3.19 → 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

@@ -1,7 +1,7 @@
 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. */
-type TaskState = {
+export type TaskState = {
   readonly id: string;
   readonly toolName: string;
   readonly args: ToolCallMessagePart["args"];
@@ -14,10 +14,10 @@ type TaskState = {
   readonly depth: number;
   readonly messages: readonly ThreadMessage[];
 };
-type TaskMethods = {
+export type TaskMethods = {
   getState(): TaskState;
 };
-type TaskMeta = {
+export type TaskMeta = {
   source: "thread";
   query: {
     type: "index";
@@ -27,10 +27,9 @@ type TaskMeta = {
     id: string;
   };
 };
-type TaskClientSchema = {
+export type TaskClientSchema = {
   methods: TaskMethods;
   meta: TaskMeta;
 };
 //#endregion
-export { TaskClientSchema, TaskMeta, TaskMethods, TaskState };
 //# sourceMappingURL=task.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","names":[],"sources":["../../../src/store/scopes/task.ts"],"mappings":";;;KAOY;WACD;WACA;WACA,MAAM;WACN,SAAS;WACT;WACA,QAAQ;WACR,SAAS;WACT;WACA;WACA;WACA,mBAAmB;;KAGlB;EACV,YAAY;;KAGF;EACV;EACA;IAAS;IAAe;;IAAoB;IAAY;;;KAG9C;EACV,SAAS;EACT,MAAM"}
+{"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

@@ -10,7 +10,7 @@ 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.
    */
@@ -57,7 +57,7 @@ type ThreadState = {
   readonly voice: VoiceSessionState | undefined;
   readonly composer: ComposerState;
 };
-type ThreadMethods = {
+export type ThreadMethods = {
   /**
    * Get the current state of the thread.
    */
@@ -143,13 +143,13 @@ 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;
@@ -196,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":";;;;;;;;;;;;KAsBY;;;;WAID;;;;WAIA;;;;WAIA;;;;WAIA;;;;WAIA,cAAc;;;;WAId,mBAAmB;;;;WAInB,gBAAgB;;;;;WAKhB,OAAO;;;;WAIP,sBAAsB;;;;WAItB;;WAEA,QAAQ;WACR,OAAO;WACP,UAAU;;KAGT;;;;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;;KAGhB;EACV;EACA;IAAS;;;KAGC;EACV;IACE;IACA;IACA;IACA;IACA;;;;;;EAMF;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,37 +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 const runCleanups: (cleanups: Iterable<Unsubscribe>) => 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;
@@ -40,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>);
@@ -49,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>);
@@ -58,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>);
@@ -66,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(): {
@@ -76,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, runCleanups };
 //# 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;cAuBE,cAAe,UAAU,SAAS;cASlC;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;EAWD,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;;cA4BX,yBACX,+BACQ;UACA;EAEI,YAAA,QAAQ,kBAAkB;EAK/B;IAlSW,cAAA,OAAA,QAAA,WAAC,+BACR;;EAqSJ,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/tests/remote-thread-list-test-helpers.d.ts

@@ -2,15 +2,14 @@ import { ModelContextProvider } from "../model-context/types.js";
 import { RemoteThreadListAdapter } from "../runtimes/remote-thread-list/types.js";
 import { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore.js";
 //#region src/tests/remote-thread-list-test-helpers.d.ts
-declare function deferred<T>(): {
+export declare function deferred<T>(): {
   promise: Promise<T>;
   resolve: (value: T) => void;
   reject: (reason?: unknown) => void;
 };
-declare const contextProvider: ModelContextProvider;
-declare function setStartThreadRuntime(core: RemoteThreadListThreadListRuntimeCore, startThreadRuntime: (id: string) => Promise<unknown>): void;
-declare function makeAdapter(overrides?: Partial<RemoteThreadListAdapter>): RemoteThreadListAdapter;
-declare function createCore(adapter: RemoteThreadListAdapter, threadId?: string, onThreadIdChange?: (threadId: string | undefined) => void): RemoteThreadListThreadListRuntimeCore;
+export declare const contextProvider: ModelContextProvider;
+export declare function setStartThreadRuntime(core: RemoteThreadListThreadListRuntimeCore, startThreadRuntime: (id: string) => Promise<unknown>): void;
+export declare function makeAdapter(overrides?: Partial<RemoteThreadListAdapter>): RemoteThreadListAdapter;
+export declare function createCore(adapter: RemoteThreadListAdapter, threadId?: string, onThreadIdChange?: (threadId: string | undefined) => void): RemoteThreadListThreadListRuntimeCore;
 //#endregion
-export { contextProvider, createCore, deferred, makeAdapter, setStartThreadRuntime };
 //# sourceMappingURL=remote-thread-list-test-helpers.d.ts.map

package/dist/tests/remote-thread-list-test-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-thread-list-test-helpers.d.ts","names":[],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"mappings":";;;;iBAKgB,SAAS;;EACD,UAAA,OAAA;EACC,SAAA;;cAQZ,iBAAiB;iBAKd,sBACd,MAAM,uCACN,qBAAqB,eAAe;iBAWtB,YACd,YAAW,QAAQ,2BAClB;iBA6Ba,WACd,SAAS,yBACT,mBACA,oBAAoB,wCACnB"}
+{"version":3,"file":"remote-thread-list-test-helpers.d.ts","names":[],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"mappings":";;;;wBAKgB,SAAS;;EACD,UAAA,OAAA;EACC,SAAA;;qBAQZ,iBAAiB;wBAKd,sBACd,MAAM,uCACN,qBAAqB,eAAe;wBAWtB,YACd,YAAW,QAAQ,2BAClB;wBA6Ba,WACd,SAAS,yBACT,mBACA,oBAAoB,wCACnB"}

package/dist/types/attachment.d.ts

@@ -1,6 +1,6 @@
 import { ThreadUserMessagePart } from "./message.js";
 //#region src/types/attachment.d.ts
-type PendingAttachmentStatus = {
+export type PendingAttachmentStatus = {
   type: "running";
   reason: "uploading";
   progress: number;
@@ -12,10 +12,10 @@ type PendingAttachmentStatus = {
   reason: "error" | "upload-paused";
   message?: string;
 };
-type CompleteAttachmentStatus = {
+export type CompleteAttachmentStatus = {
   type: "complete";
 };
-type AttachmentStatus = PendingAttachmentStatus | CompleteAttachmentStatus;
+export type AttachmentStatus = PendingAttachmentStatus | CompleteAttachmentStatus;
 type BaseAttachment = {
   id: string;
   type: "image" | "document" | "file" | (string & {});
@@ -24,24 +24,23 @@ type BaseAttachment = {
   file?: File;
   content?: ThreadUserMessagePart[];
 };
-type PendingAttachment = BaseAttachment & {
+export type PendingAttachment = BaseAttachment & {
   status: PendingAttachmentStatus;
   file: File;
 };
-type CompleteAttachment = BaseAttachment & {
+export type CompleteAttachment = BaseAttachment & {
   status: CompleteAttachmentStatus;
   content: ThreadUserMessagePart[];
 };
-type Attachment = PendingAttachment | CompleteAttachment;
-type CreateAttachment = {
+export type Attachment = PendingAttachment | CompleteAttachment;
+export type CreateAttachment = {
   id?: string;
   type?: "image" | "document" | "file" | (string & {});
   name: string;
   contentType?: string;
   content: ThreadUserMessagePart[];
 };
-declare const isCreateAttachment: (attachment: File | CreateAttachment) => attachment is CreateAttachment;
-declare const isAttachmentComplete: (attachment: Attachment) => attachment is CompleteAttachment;
+export declare const isCreateAttachment: (attachment: File | CreateAttachment) => attachment is CreateAttachment;
+export declare const isAttachmentComplete: (attachment: Attachment) => attachment is CompleteAttachment;
 //#endregion
-export { Attachment, AttachmentStatus, CompleteAttachment, CompleteAttachmentStatus, CreateAttachment, PendingAttachment, PendingAttachmentStatus, isAttachmentComplete, isCreateAttachment };
 //# sourceMappingURL=attachment.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"attachment.d.ts","names":[],"sources":["../../src/types/attachment.ts"],"mappings":";;KAEY;EAEN;EACA;EACA;;EAGA;EACA;;EAGA;EACA;EACA;;KAGM;EACV;;KAGU,mBACR,0BACA;KAEC;EACH;EACA;EACA;EACA;EACA,OAAO;EACP,UAAU;;KAGA,oBAAoB;EAC9B,QAAQ;EACR,MAAM;;KAGI,qBAAqB;EAC/B,QAAQ;EACR,SAAS;;KAGC,aAAa,oBAAoB;KAEjC;EACV;EACA;EACA;EACA;EACA,SAAS;;cAGE,qBACX,YAAY,OAAO,qBAClB,cAAc;cAGJ,uBACX,YAAY,eACX,cAAc"}
+{"version":3,"file":"attachment.d.ts","names":[],"sources":["../../src/types/attachment.ts"],"mappings":";;YAEY;EAEN;EACA;EACA;;EAGA;EACA;;EAGA;EACA;EACA;;YAGM;EACV;;YAGU,mBACR,0BACA;KAEC;EACH;EACA;EACA;EACA;EACA,OAAO;EACP,UAAU;;YAGA,oBAAoB;EAC9B,QAAQ;EACR,MAAM;;YAGI,qBAAqB;EAC/B,QAAQ;EACR,SAAS;;YAGC,aAAa,oBAAoB;YAEjC;EACV;EACA;EACA;EACA;EACA,SAAS;;qBAGE,qBACX,YAAY,OAAO,qBAClB,cAAc;qBAGJ,uBACX,YAAY,eACX,cAAc"}

package/dist/types/augmentations.d.ts

@@ -22,12 +22,11 @@
  * }
  * ```
  */
-declare namespace Assistant {
+export declare namespace Assistant {
   interface Commands {}
   interface ExternalState {}
 }
-type UserCommands = Assistant.Commands[keyof Assistant.Commands];
-type UserExternalState = keyof Assistant.ExternalState extends never ? Record<string, unknown> : Assistant.ExternalState[keyof Assistant.ExternalState];
+export type UserCommands = Assistant.Commands[keyof Assistant.Commands];
+export type UserExternalState = keyof Assistant.ExternalState extends never ? Record<string, unknown> : Assistant.ExternalState[keyof Assistant.ExternalState];
 //#endregion
-export { Assistant, UserCommands, UserExternalState };
 //# sourceMappingURL=augmentations.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"augmentations.d.ts","names":[],"sources":["../../src/types/augmentations.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;kBAuBiB;YACE;YAEA;;KAGP,eAAe,UAAU,eAAe,UAAU;KAClD,0BAA0B,UAAU,8BAC5C,0BACA,UAAU,oBAAoB,UAAU"}
+{"version":3,"file":"augmentations.d.ts","names":[],"sources":["../../src/types/augmentations.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;yBAuBiB;YACE;YAEA;;YAGP,eAAe,UAAU,eAAe,UAAU;YAClD,0BAA0B,UAAU,8BAC5C,0BACA,UAAU,oBAAoB,UAAU"}