@assistant-ui/react 0.7.43 → 0.7.45

package/src/runtimes/local/LocalRuntimeOptions.tsx

@@ -1,13 +1,15 @@
-import { AttachmentAdapter } from "../attachment/AttachmentAdapter";
+import { ThreadHistoryAdapter } from "../adapters/thread-history/ThreadHistoryAdapter";
+import { AttachmentAdapter } from "../adapters/attachment/AttachmentAdapter";
 import { ThreadMessageLike } from "../external-store";
-import { FeedbackAdapter } from "../feedback/FeedbackAdapter";
-import { SpeechSynthesisAdapter } from "../speech/SpeechAdapterTypes";
+import { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
 import { ChatModelAdapter } from "./ChatModelAdapter";
 
 export type LocalRuntimeOptionsBase = {
   maxSteps?: number | undefined;
   adapters: {
     chatModel: ChatModelAdapter;
+    history?: ThreadHistoryAdapter | undefined;
     attachments?: AttachmentAdapter | undefined;
     speech?: SpeechSynthesisAdapter | undefined;
     feedback?: FeedbackAdapter | undefined;

package/src/runtimes/local/LocalThreadListRuntimeCore.tsx

@@ -52,6 +52,12 @@ export class LocalThreadListRuntimeCore implements ThreadListRuntimeCore {
     return result;
   }
 
+  public getThreadRuntimeCore(threadId: string) {
+    const result = this._threadData.get(threadId)?.runtime;
+    if (!result) throw new Error("Thread not found.");
+    return result;
+  }
+
   public getLoadThreadsPromise(): Promise<void> {
     return RESOLVED_PROMISE;
   }
@@ -212,6 +218,10 @@ export class LocalThreadListRuntimeCore implements ThreadListRuntimeCore {
     return Promise.resolve();
   }
 
+  public initialize(): never {
+    throw new Error("Method not implemented.");
+  }
+
   private _subscriptions = new Set<() => void>();
 
   public subscribe(callback: () => void): Unsubscribe {

package/src/runtimes/local/LocalThreadRuntimeCore.tsx

@@ -127,9 +127,13 @@ export class LocalThreadRuntimeCore
 
     this._notifyEventSubscribers("run-start");
 
-    do {
-      message = await this.performRoundtrip(parentId, message, runConfig);
-    } while (shouldContinue(message));
+    try {
+      do {
+        message = await this.performRoundtrip(parentId, message, runConfig);
+      } while (shouldContinue(message));
+    } finally {
+      this._notifyEventSubscribers("run-end");
+    }
   }
 
   private async performRoundtrip(

package/src/runtimes/local/useLocalRuntime.tsx

@@ -43,7 +43,7 @@ export const useLocalRuntime = (
   const [runtime] = useState(() => new LocalRuntimeCore(opt, initialMessages));
 
   useEffect(() => {
-    runtime.threadList.getMainThreadRuntimeCore().__internal_setOptions(opt);
+    runtime.threads.getMainThreadRuntimeCore().__internal_setOptions(opt);
   }, [runtime, opt]);
 
   return useMemo(() => LocalRuntimeImpl.create(runtime), [runtime]);

package/src/runtimes/remote-thread-list/OptimisticState.ts

@@ -10,7 +10,11 @@ type Transform<TState, TResult> = {
   optimistic?: (state: TState) => TState;
 
   /** transform the state only while loading */
-  loading?: (state: TState) => TState;
+  loading?: (state: TState, task: Promise<TResult>) => TState;
+};
+
+type PendingTransform<TState, TResult> = Transform<TState, TResult> & {
+  task: Promise<TResult>;
 };
 
 const pipeTransforms = <TState, TExtra>(
@@ -24,7 +28,8 @@ const pipeTransforms = <TState, TExtra>(
 };
 
 export class OptimisticState<TState> extends BaseSubscribable {
-  private readonly _pendingTransforms: Array<Transform<TState, any>> = [];
+  private readonly _pendingTransforms: Array<PendingTransform<TState, any>> =
+    [];
   private _baseValue: TState;
   private _cachedValue: TState;
 
@@ -36,7 +41,7 @@ export class OptimisticState<TState> extends BaseSubscribable {
 
   private _updateState(): void {
     this._cachedValue = this._pendingTransforms.reduce((state, transform) => {
-      return pipeTransforms(state, undefined, [
+      return pipeTransforms(state, transform.task, [
         transform.loading,
         transform.optimistic,
       ]);
@@ -61,18 +66,20 @@ export class OptimisticState<TState> extends BaseSubscribable {
   public async optimisticUpdate<TResult>(
     transform: Transform<TState, TResult>,
   ): Promise<TResult> {
-    this._pendingTransforms.push(transform);
-    this._updateState();
-
+    const task = transform.execute();
+    const pendingTransform = { ...transform, task };
     try {
-      const result = await transform.execute();
+      this._pendingTransforms.push(pendingTransform);
+      this._updateState();
+
+      const result = await task;
       this._baseValue = pipeTransforms(this._baseValue, result, [
         transform.optimistic,
         transform.then,
       ]);
       return result;
     } finally {
-      const index = this._pendingTransforms.indexOf(transform);
+      const index = this._pendingTransforms.indexOf(pendingTransform);
       if (index > -1) {
         this._pendingTransforms.splice(index, 1);
       }

package/src/runtimes/remote-thread-list/RemoteThreadListHookInstanceManager.tsx

@@ -13,7 +13,10 @@ import {
 import { UseBoundStore, StoreApi, create } from "zustand";
 import { useAssistantRuntime } from "../../context";
 import { ThreadListItemRuntimeProvider } from "../../context/providers/ThreadListItemRuntimeProvider";
-import { useThreadListItem } from "../../context/react/ThreadListItemContext";
+import {
+  useThreadListItem,
+  useThreadListItemRuntime,
+} from "../../context/react/ThreadListItemContext";
 import { ThreadRuntimeCore, ThreadRuntimeImpl } from "../../internal";
 import { BaseSubscribable } from "./BaseSubscribable";
 import { AssistantRuntime } from "../../api";
@@ -112,6 +115,16 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       return threadBinding.outerSubscribe(updateRuntime);
     }, [threadBinding]);
 
+    // auto initialize thread
+    const threadListItemRuntime = useThreadListItemRuntime();
+    useEffect(() => {
+      return runtime.threads.main.unstable_on("initialize", () => {
+        if (threadListItemRuntime.getState().status === "new") {
+          threadListItemRuntime.initialize();
+        }
+      });
+    }, [runtime, threadListItemRuntime]);
+
     return null;
   };
 
@@ -121,7 +134,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   }> = memo(({ threadId, provider: Provider }) => {
     const assistantRuntime = useAssistantRuntime();
     const threadListItemRuntime = useMemo(
-      () => assistantRuntime.threadList.getItemById(threadId),
+      () => assistantRuntime.threads.getItemById(threadId),
       [assistantRuntime, threadId],
     );
 

package/src/runtimes/remote-thread-list/RemoteThreadListThreadListRuntimeCore.tsx

@@ -24,6 +24,15 @@ type RemoteThreadData =
     }
   | {
       readonly threadId: string;
+      readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
+      readonly remoteId?: undefined;
+      readonly externalId?: undefined;
+      readonly status: "regular" | "archived";
+      readonly title?: string | undefined;
+    }
+  | {
+      readonly threadId: string;
+      readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
       readonly remoteId: string;
       readonly externalId: string | undefined;
       readonly status: "regular" | "archived";
@@ -188,6 +197,10 @@ export class RemoteThreadListThreadListRuntimeCore
                 externalId: thread.externalId,
                 status: thread.status,
                 title: thread.title,
+                initializeTask: Promise.resolve({
+                  remoteId: thread.remoteId,
+                  externalId: thread.externalId,
+                }),
               };
             }
 
@@ -244,8 +257,7 @@ export class RemoteThreadListThreadListRuntimeCore
 
   public __internal_bindAdapter() {
     this.getLoadThreadsPromise(); // begin loading on initial bind
-    return this._adapter.subscribe({
-      onInitialize: this._onInitialize,
+    return this._adapter.subscribe?.({
       onGenerateTitle: this._onGenerateTitle,
     });
   }
@@ -272,6 +284,15 @@ export class RemoteThreadListThreadListRuntimeCore
     return result;
   }
 
+  public getThreadRuntimeCore(threadIdOrRemoteId: string) {
+    const data = this.getItemById(threadIdOrRemoteId);
+    if (!data) throw new Error("Thread not found");
+
+    const result = this._hookManager.getThreadRuntimeCore(data.threadId);
+    if (!result) throw new Error("Thread not found");
+    return result;
+  }
+
   public getItemById(threadIdOrRemoteId: string) {
     return getThreadData(this._state.value, threadIdOrRemoteId);
   }
@@ -332,20 +353,34 @@ export class RemoteThreadListThreadListRuntimeCore
     return this.switchToThread(threadId);
   }
 
-  private _onInitialize = async (
-    threadId: string,
-    begin: () => Promise<RemoteThreadInitializeResponse>,
-  ) => {
-    if (this._state.value.newThreadId !== threadId)
-      throw new Error("The provided thread is already initialized");
+  public initialize = async (threadId: string) => {
+    if (this._state.value.newThreadId !== threadId) {
+      const data = this.getItemById(threadId);
+      if (!data) throw new Error("Thread not found");
+      if (data.status === "new") throw new Error("Unexpected new state");
+      return data.initializeTask;
+    }
 
-    await this._state.optimisticUpdate({
+    return this._state.optimisticUpdate({
       execute: () => {
-        return begin();
+        return this._adapter.initialize(threadId);
       },
       optimistic: (state) => {
         return updateStatusReducer(state, threadId, "regular");
       },
+      loading: (state, task) => {
+        const mappingId = createThreadMappingId(threadId);
+        return {
+          ...state,
+          threadData: {
+            ...state.threadData,
+            [mappingId]: {
+              ...state.threadData[mappingId],
+              initializeTask: task,
+            },
+          },
+        };
+      },
       then: (state, { remoteId, externalId }) => {
         const data = getThreadData(state, threadId);
         if (!data) return state;
@@ -359,8 +394,9 @@ export class RemoteThreadListThreadListRuntimeCore
           },
           threadData: {
             ...state.threadData,
-            [threadId]: {
+            [mappingId]: {
               ...data,
+              initializeTask: Promise.resolve({ remoteId, externalId }),
               remoteId,
               externalId,
             },
@@ -404,8 +440,9 @@ export class RemoteThreadListThreadListRuntimeCore
     if (data.status === "new") throw new Error("Thread is not yet initialized");
 
     return this._state.optimisticUpdate({
-      execute: () => {
-        return this._adapter.rename(data.remoteId, newTitle);
+      execute: async () => {
+        const { remoteId } = await data.initializeTask;
+        return this._adapter.rename(remoteId, newTitle);
       },
       optimistic: (state) => {
         const data = getThreadData(state, threadIdOrRemoteId);
@@ -446,7 +483,8 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._state.optimisticUpdate({
       execute: async () => {
         await this._ensureThreadIsNotMain(data.threadId);
-        return this._adapter.archive(data.remoteId);
+        const { remoteId } = await data.initializeTask;
+        return this._adapter.archive(remoteId);
       },
       optimistic: (state) => {
         return updateStatusReducer(state, data.threadId, "archived");
@@ -462,7 +500,8 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._state.optimisticUpdate({
       execute: async () => {
         try {
-          return await this._adapter.unarchive(data.remoteId);
+          const { remoteId } = await data.initializeTask;
+          return await this._adapter.unarchive(remoteId);
         } catch (error) {
           await this._ensureThreadIsNotMain(data.threadId);
           throw error;
@@ -483,7 +522,8 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._state.optimisticUpdate({
       execute: async () => {
         await this._ensureThreadIsNotMain(data.threadId);
-        return await this._adapter.delete(data.remoteId);
+        const { remoteId } = await data.initializeTask;
+        return await this._adapter.delete(remoteId);
       },
       optimistic: (state) => {
         return updateStatusReducer(state, data.threadId, "deleted");

package/src/runtimes/remote-thread-list/cloud/AssistantCloudAPI.tsx

@@ -7,7 +7,7 @@ import {
 export type AssistantCloudConfig =
   | {
       baseUrl: string;
-      authToken(): Promise<string>;
+      authToken: (() => Promise<string | null>) | undefined;
     }
   | {
       apiKey: string;
@@ -30,16 +30,16 @@ type MakeRequestOptions = {
 };
 
 export class AssistantCloudAPI {
-  private _tokenManager: AssistantCloudAuthStrategy;
+  private _auth: AssistantCloudAuthStrategy;
   private _baseUrl;
 
   constructor(config: AssistantCloudConfig) {
     if ("authToken" in config) {
       this._baseUrl = config.baseUrl;
-      this._tokenManager = new AssistantCloudJWTAuthStrategy(config.authToken);
+      this._auth = new AssistantCloudJWTAuthStrategy(config.authToken);
     } else {
       this._baseUrl = "https://backend.assistant-api.com";
-      this._tokenManager = new AssistantCloudAPIKeyAuthStrategy(
+      this._auth = new AssistantCloudAPIKeyAuthStrategy(
         config.apiKey,
         config.userId,
         config.workspaceId,
@@ -47,11 +47,17 @@ export class AssistantCloudAPI {
     }
   }
 
+  public async initializeAuth() {
+    return !!this._auth.getAuthHeaders();
+  }
+
   public async makeRawRequest(
     endpoint: string,
     options: MakeRequestOptions = {},
   ) {
-    const authHeaders = await this._tokenManager.getAuthHeaders();
+    const authHeaders = await this._auth.getAuthHeaders();
+    if (!authHeaders) throw new Error("Authronization failed");
+
     const headers = {
       ...authHeaders,
       ...options.headers,
@@ -79,6 +85,8 @@ export class AssistantCloudAPI {
       body: options.body ? JSON.stringify(options.body) : null,
     });
 
+    this._auth.readAuthHeaders(response.headers);
+
     if (!response.ok) {
       const text = await response.text();
       try {

package/src/runtimes/remote-thread-list/cloud/AssistantCloudAuthStrategy.tsx

@@ -1,6 +1,7 @@
 export type AssistantCloudAuthStrategy = {
   readonly strategy: "jwt" | "api-key";
-  getAuthHeaders(): Promise<Record<string, string>>;
+  getAuthHeaders(): Promise<Record<string, string> | false>;
+  readAuthHeaders(headers: Headers): void;
 };
 
 export class AssistantCloudJWTAuthStrategy
@@ -13,7 +14,7 @@ export class AssistantCloudJWTAuthStrategy
 
   #authTokenCallback;
 
-  constructor(authTokenCallback: () => Promise<string>) {
+  constructor(authTokenCallback: (() => Promise<string | null>) | undefined) {
     this.#authTokenCallback = authTokenCallback;
   }
 
@@ -43,7 +44,7 @@ export class AssistantCloudJWTAuthStrategy
     }
   }
 
-  public async getAuthHeaders(): Promise<Record<string, string>> {
+  public async getAuthHeaders(): Promise<Record<string, string> | false> {
     const currentTime = Date.now();
 
     // Check if the cached token is valid for at least 30 seconds
@@ -58,7 +59,9 @@ export class AssistantCloudJWTAuthStrategy
     }
 
     // Fetch a new token
-    const newToken = await this.#authTokenCallback();
+    const newToken = await this.#authTokenCallback?.();
+    if (!newToken) return false;
+
     const expiry = this.getJwtExpiry(newToken);
 
     this.cachedToken = newToken;
@@ -68,7 +71,20 @@ export class AssistantCloudJWTAuthStrategy
       Authorization: `Bearer ${newToken}`,
     };
   }
+
+  public readAuthHeaders(headers: Headers) {
+    const authHeader = headers.get("Authorization");
+    if (!authHeader) return;
+
+    const [scheme, token] = authHeader.split(" ");
+    if (scheme !== "Bearer" || !token)
+      throw new Error("Invalid auth header received");
+
+    this.cachedToken = token;
+    this.tokenExpiry = this.getJwtExpiry(token);
+  }
 }
+
 export class AssistantCloudAPIKeyAuthStrategy
   implements AssistantCloudAuthStrategy
 {
@@ -91,4 +107,8 @@ export class AssistantCloudAPIKeyAuthStrategy
       "Aui-Workspace-Id": this.#workspaceId,
     };
   }
+
+  public readAuthHeaders() {
+    // noop
+  }
 }

package/src/runtimes/remote-thread-list/cloud/index.ts

@@ -1,3 +1,2 @@
 export { useCloudThreadListRuntime } from "./useCloudThreadListRuntime";
-export { useCloudThreadListItemRuntime } from "./CloudThreadListItemRuntime";
 export { AssistantCloud } from "./AssistantCloud";

package/src/runtimes/remote-thread-list/cloud/useCloudThreadListRuntime.tsx

@@ -1,18 +1,10 @@
 "use client";
 
-import {
-  PropsWithChildren,
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
+import { useEffect, useRef, useState } from "react";
 import { useRemoteThreadListRuntime } from "../useRemoteThreadListRuntime";
 import { AssistantCloud } from "./AssistantCloud";
 import { AssistantRuntime } from "../../../api";
 import { RemoteThreadListSubscriber } from "../types";
-import { CloudThreadListItemRuntimeProvider } from "./CloudThreadListItemRuntime";
 import { toCoreMessages } from "../../edge";
 
 type ThreadData = {
@@ -45,45 +37,6 @@ export const useCloudThreadListRuntime = (adapter: CloudThreadListAdapter) => {
 
   const [subscribers] = useState(() => new Set<RemoteThreadListSubscriber>());
 
-  const cloudThreadListItemRuntimeAdapter = useMemo(() => {
-    return {
-      initialize: async (threadId: string) => {
-        const begin = beginnable(async () => {
-          const createTask = adapterRef.current.create?.() ?? Promise.resolve();
-          const t = await createTask;
-          const external_id = t ? t.externalId : undefined;
-          const { thread_id } = await adapterRef.current.cloud.threads.create({
-            title: "New Thread",
-            last_message_at: new Date(),
-            external_id,
-          });
-          return { externalId: external_id, remoteId: thread_id };
-        });
-
-        for (const subscriber of subscribers) {
-          subscriber.onInitialize(threadId, begin);
-        }
-
-        // note: onInitialize immediately throws if there are any issues
-        // therefore begin is safe to call here
-        return begin();
-      },
-      generateTitle: async (remoteId: string) => {
-        const messages = runtime.thread.getState().messages;
-        const begin = beginnable(() => {
-          return adapterRef.current.cloud.runs.stream({
-            thread_id: remoteId,
-            assistant_id: "system/thread_title",
-            messages: toCoreMessages(messages),
-          });
-        });
-        for (const subscriber of subscribers) {
-          subscriber.onGenerateTitle(remoteId, begin);
-        }
-      },
-    };
-  }, [subscribers]);
-
   const runtime = useRemoteThreadListRuntime({
     runtimeHook: adapter.runtimeHook,
     list: async () => {
@@ -97,6 +50,41 @@ export const useCloudThreadListRuntime = (adapter: CloudThreadListAdapter) => {
         })),
       };
     },
+
+    initialize: async (threadId: string) => {
+      const createTask = adapterRef.current.create?.() ?? Promise.resolve();
+      const t = await createTask;
+      const external_id = t ? t.externalId : undefined;
+      const { thread_id: remoteId } =
+        await adapterRef.current.cloud.threads.create({
+          title: "New Thread",
+          last_message_at: new Date(),
+          external_id,
+        });
+
+      const dispose = runtime.threads
+        .getById(threadId)
+        .unstable_on("run-end", () => {
+          dispose();
+
+          const messages = runtime.threads
+            .getById(threadId)
+            .getState().messages;
+          const begin = beginnable(() => {
+            return adapterRef.current.cloud.runs.stream({
+              thread_id: remoteId,
+              assistant_id: "system/thread_title",
+              messages: toCoreMessages(messages),
+            });
+          });
+          for (const subscriber of subscribers) {
+            subscriber.onGenerateTitle(remoteId, begin);
+          }
+        });
+
+      return { externalId: external_id, remoteId: remoteId };
+    },
+
     rename: async (threadId, newTitle) => {
       return adapter.cloud.threads.update(threadId, { title: newTitle });
     },
@@ -116,18 +104,6 @@ export const useCloudThreadListRuntime = (adapter: CloudThreadListAdapter) => {
         subscribers.delete(callback);
       };
     },
-    unstable_Provider: useCallback(
-      ({ children }: PropsWithChildren) => {
-        return (
-          <CloudThreadListItemRuntimeProvider
-            adapter={cloudThreadListItemRuntimeAdapter}
-          >
-            {children}
-          </CloudThreadListItemRuntimeProvider>
-        );
-      },
-      [cloudThreadListItemRuntimeAdapter],
-    ),
   });
 
   return runtime;

package/src/runtimes/remote-thread-list/types.tsx

@@ -20,10 +20,6 @@ export type RemoteThreadListResponse = {
 };
 
 export type RemoteThreadListSubscriber = {
-  onInitialize: (
-    threadId: string,
-    begin: () => Promise<RemoteThreadInitializeResponse>,
-  ) => void;
   onGenerateTitle: (
     threadId: string,
     begin: () => Promise<AssistantStream>,
@@ -39,8 +35,9 @@ export type RemoteThreadListAdapter = {
   archive(remoteId: string): Promise<void>;
   unarchive(remoteId: string): Promise<void>;
   delete(remoteId: string): Promise<void>;
+  initialize(threadId: string): Promise<RemoteThreadInitializeResponse>;
 
-  subscribe(subscriber: RemoteThreadListSubscriber): Unsubscribe;
+  subscribe?(subscriber: RemoteThreadListSubscriber): Unsubscribe;
 
   unstable_Provider?: ComponentType<PropsWithChildren>;
 };

package/src/runtimes/remote-thread-list/useRemoteThreadListRuntime.tsx

@@ -11,15 +11,15 @@ class RemoteThreadListRuntimeCore
   extends BaseAssistantRuntimeCore
   implements AssistantRuntimeCore
 {
-  public readonly threadList;
+  public readonly threads;
 
   constructor(adapter: RemoteThreadListAdapter) {
     super();
-    this.threadList = new RemoteThreadListThreadListRuntimeCore(adapter);
+    this.threads = new RemoteThreadListThreadListRuntimeCore(adapter);
   }
 
   public get RenderComponent() {
-    return this.threadList.__internal_RenderComponent;
+    return this.threads.__internal_RenderComponent;
   }
 }
 
@@ -28,8 +28,8 @@ export const useRemoteThreadListRuntime = (
 ) => {
   const [runtime] = useState(() => new RemoteThreadListRuntimeCore(adapter));
   useEffect(() => {
-    runtime.threadList.__internal_setAdapter(adapter);
-    return runtime.threadList.__internal_bindAdapter();
+    runtime.threads.__internal_setAdapter(adapter);
+    return runtime.threads.__internal_bindAdapter();
   }, [runtime, adapter]);
   return useMemo(() => AssistantRuntimeImpl.create(runtime), [runtime]);
 };

package/src/runtimes/utils/MessageRepository.tsx

@@ -13,6 +13,11 @@ type RepositoryMessage = RepositoryParent & {
   level: number;
 };
 
+export type ExportedMessageRepositoryItem = {
+  message: ThreadMessage;
+  parentId: string | null;
+};
+
 export interface ExportedMessageRepository {
   headId?: string | null;
   messages: Array<{

package/src/ui/assistant-message.tsx

@@ -65,6 +65,7 @@ const AssistantMessageContent = forwardRef<
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [...(tools ?? []), components.ToolFallback],
   );
+  const Footer = components.Footer;
 
   return (
     <AssistantMessageContentWrapper {...rest} ref={ref}>
@@ -76,6 +77,7 @@ const AssistantMessageContent = forwardRef<
           tools: toolsComponents,
         }}
       />
+      {Footer && <Footer />}
     </AssistantMessageContentWrapper>
   );
 });

package/src/ui/thread-config.tsx

@@ -45,6 +45,7 @@ export type AssistantMessageConfig = {
         Text?: TextContentPartComponent | undefined;
         Empty?: EmptyContentPartComponent | undefined;
         ToolFallback?: ComponentType<ToolCallContentPartProps> | undefined;
+        Footer?: ComponentType | undefined;
       }
     | undefined;
 };

package/dist/runtimes/attachment/AttachmentAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttachmentAdapter.d.ts","sourceRoot":"","sources":["../../../src/runtimes/attachment/AttachmentAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AAErC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IAEf,GAAG,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACvD,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,IAAI,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAClE,CAAC"}

package/dist/runtimes/attachment/AttachmentAdapter.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/runtimes/attachment/AttachmentAdapter.ts"],"sourcesContent":["import {\n  Attachment,\n  PendingAttachment,\n  CompleteAttachment,\n} from \"../../types/AttachmentTypes\";\n\nexport type AttachmentAdapter = {\n  accept: string;\n\n  add(state: { file: File }): Promise<PendingAttachment>;\n  remove(attachment: Attachment): Promise<void>;\n  send(attachment: PendingAttachment): Promise<CompleteAttachment>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/runtimes/attachment/CompositeAttachmentAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CompositeAttachmentAdapter.d.ts","sourceRoot":"","sources":["../../../src/runtimes/attachment/CompositeAttachmentAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AA6CxD,qBAAa,0BAA2B,YAAW,iBAAiB;IAClE,OAAO,CAAC,SAAS,CAAsB;IAEhC,MAAM,EAAE,MAAM,CAAC;gBAEV,QAAQ,EAAE,iBAAiB,EAAE;IAgB5B,GAAG,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;IASzB,IAAI,CAAC,UAAU,EAAE,iBAAiB;IAUlC,MAAM,CAAC,UAAU,EAAE,UAAU;CAiB3C"}