@assistant-ui/react 0.11.35 → 0.11.36

package/src/context/react/index.ts

@@ -2,7 +2,11 @@
 // TODO createContextStoreHook does not work well with server-side nextjs bundler
 // use client necessary here for now
 
-export { useAssistantApi, type AssistantApi } from "./AssistantApiContext";
+export {
+  useAssistantApi,
+  useExtendedAssistantApi,
+  type AssistantApi,
+} from "./AssistantApiContext";
 export { useAssistantState } from "./hooks/useAssistantState";
 export { useAssistantEvent } from "./hooks/useAssistantEvent";
 

package/src/legacy-runtime/AssistantRuntimeProvider.tsx

@@ -1,11 +1,13 @@
 "use client";
 
 import { FC, memo, PropsWithChildren } from "react";
-import { AssistantProvider } from "../context/react/AssistantApiContext";
+import {
+  AssistantProvider,
+  useAssistantApi,
+} from "../context/react/AssistantApiContext";
 import { AssistantRuntime } from "./runtime/AssistantRuntime";
 import { AssistantRuntimeCore } from "./runtime-cores/core/AssistantRuntimeCore";
-import { useAssistantClient } from "../client/AssistantClient";
-import { ThreadListClient } from "./client/ThreadListRuntimeClient";
+import { RuntimeAdapter } from "./RuntimeAdapter";
 
 export namespace AssistantProvider {
   export type Props = PropsWithChildren<{
@@ -24,12 +26,8 @@ export const AssistantRuntimeProviderImpl: FC<AssistantProvider.Props> = ({
   children,
   runtime,
 }) => {
-  const api = useAssistantClient({
-    threads: ThreadListClient({
-      runtime: runtime.threads,
-    }),
-    registerModelContextProvider: runtime.registerModelContextProvider,
-    __internal_runtime: runtime,
+  const api = useAssistantApi({
+    threads: RuntimeAdapter(runtime),
   });
 
   const RenderComponent = getRenderComponent(runtime);

package/src/legacy-runtime/RuntimeAdapter.ts

@@ -0,0 +1,19 @@
+import { resource, tapEffect, tapInlineResource } from "@assistant-ui/tap";
+import type { AssistantRuntime } from "./runtime/AssistantRuntime";
+import { ThreadListClient } from "./client/ThreadListRuntimeClient";
+import { tapModelContext } from "../client/ModelContext";
+
+export const RuntimeAdapter = resource((runtime: AssistantRuntime) => {
+  const modelContext = tapModelContext();
+
+  tapEffect(() => {
+    return runtime.registerModelContextProvider(modelContext);
+  }, [runtime, modelContext]);
+
+  return tapInlineResource(
+    ThreadListClient({
+      runtime: runtime.threads,
+      __internal_assistantRuntime: runtime,
+    }),
+  );
+});

package/src/legacy-runtime/client/ThreadListRuntimeClient.ts

@@ -9,6 +9,7 @@ import {
   ThreadListClientState,
   ThreadListClientApi,
 } from "../../client/types/ThreadList";
+import type { AssistantRuntime } from "../runtime/AssistantRuntime";
 
 const ThreadListItemClientById = resource(
   ({ runtime, id }: { runtime: ThreadListRuntime; id: string }) => {
@@ -25,7 +26,13 @@ const ThreadListItemClientById = resource(
 );
 
 export const ThreadListClient = resource(
-  ({ runtime }: { runtime: ThreadListRuntime }) => {
+  ({
+    runtime,
+    __internal_assistantRuntime,
+  }: {
+    runtime: ThreadListRuntime;
+    __internal_assistantRuntime: AssistantRuntime;
+  }) => {
     const runtimeState = tapSubscribable(runtime);
 
     const main = tapInlineResource(
@@ -80,6 +87,8 @@ export const ThreadListClient = resource(
       switchToNewThread: () => {
         runtime.switchToNewThread();
       },
+
+      __internal_getAssistantRuntime: () => __internal_assistantRuntime,
     });
   },
 );

package/src/legacy-runtime/hooks/AssistantContext.ts

@@ -6,6 +6,8 @@ import type { ThreadListRuntime } from "../runtime/ThreadListRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 
 /**
+ * @deprecated Use `useAssistantApi()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the AssistantRuntime from the current context.
  *
  * The AssistantRuntime provides access to the top-level assistant state and actions,
@@ -17,13 +19,21 @@ import { createStateHookForRuntime } from "../../context/react/utils/createState
  *
  * @example
  * ```tsx
+ * // Before:
  * function MyComponent() {
  *   const runtime = useAssistantRuntime();
- *
  *   const handleNewThread = () => {
  *     runtime.switchToNewThread();
  *   };
+ *   return <button onClick={handleNewThread}>New Thread</button>;
+ * }
  *
+ * // After:
+ * function MyComponent() {
+ *   const api = useAssistantApi();
+ *   const handleNewThread = () => {
+ *     api.threads().switchToNewThread();
+ *   };
  *   return <button onClick={handleNewThread}>New Thread</button>;
  * }
  * ```
@@ -38,7 +48,7 @@ export function useAssistantRuntime(options?: {
   optional?: boolean | undefined;
 }) {
   const api = useAssistantApi();
-  const runtime = api.__internal_getRuntime?.() ?? null;
+  const runtime = api.threads().__internal_getAssistantRuntime?.() ?? null;
 
   if (!runtime && !options?.optional) {
     throw new Error("AssistantRuntime is not available");
@@ -50,4 +60,8 @@ export function useAssistantRuntime(options?: {
 const useThreadListRuntime = (opt: {
   optional: boolean | undefined;
 }): ThreadListRuntime | null => useAssistantRuntime(opt)?.threads ?? null;
+
+/**
+ * @deprecated Use `useAssistantState(({ threads }) => threads)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export const useThreadList = createStateHookForRuntime(useThreadListRuntime);

package/src/legacy-runtime/hooks/AttachmentContext.ts

@@ -4,6 +4,9 @@ import { AttachmentRuntime } from "../runtime/AttachmentRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 import { useAssistantApi, useAssistantState } from "../../context/react";
 
+/**
+ * @deprecated Use `useAssistantApi()` with `api.attachment()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export function useAttachmentRuntime(options?: {
   optional?: false | undefined;
 }): AttachmentRuntime;
@@ -80,6 +83,9 @@ export function useMessageAttachmentRuntime(options?: {
   return attachmentRuntime as AttachmentRuntime<"message">;
 }
 
+/**
+ * @deprecated Use `useAssistantState(({ attachment }) => attachment)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export const useAttachment = createStateHookForRuntime(useAttachmentRuntime);
 
 export const useThreadComposerAttachment = createStateHookForRuntime(

package/src/legacy-runtime/hooks/ComposerContext.ts

@@ -5,6 +5,8 @@ import { ComposerRuntime } from "../runtime/ComposerRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 
 /**
+ * @deprecated Use `useAssistantApi()` with `api.composer()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the ComposerRuntime from the current context.
  *
  * The ComposerRuntime provides access to composer state and actions for message
@@ -18,21 +20,42 @@ import { createStateHookForRuntime } from "../../context/react/utils/createState
  *
  * @example
  * ```tsx
+ * // Before:
  * function ComposerActions() {
  *   const runtime = useComposerRuntime();
- *
  *   const handleSend = () => {
  *     if (runtime.getState().canSend) {
  *       runtime.send();
  *     }
  *   };
- *
  *   const handleCancel = () => {
  *     if (runtime.getState().canCancel) {
  *       runtime.cancel();
  *     }
  *   };
+ *   return (
+ *     <div>
+ *       <button onClick={handleSend}>Send</button>
+ *       <button onClick={handleCancel}>Cancel</button>
+ *     </div>
+ *   );
+ * }
  *
+ * // After:
+ * function ComposerActions() {
+ *   const api = useAssistantApi();
+ *   const canSend = useAssistantState(({ composer }) => composer.canSend);
+ *   const canCancel = useAssistantState(({ composer }) => composer.canCancel);
+ *   const handleSend = () => {
+ *     if (canSend) {
+ *       api.composer().send();
+ *     }
+ *   };
+ *   const handleCancel = () => {
+ *     if (canCancel) {
+ *       api.composer().cancel();
+ *     }
+ *   };
  *   return (
  *     <div>
  *       <button onClick={handleSend}>Send</button>
@@ -64,6 +87,8 @@ export function useComposerRuntime(options?: {
 }
 
 /**
+ * @deprecated Use `useAssistantState(({ composer }) => composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the current composer state.
  *
  * This hook provides reactive access to the composer's state, including text content,
@@ -74,11 +99,25 @@ export function useComposerRuntime(options?: {
  *
  * @example
  * ```tsx
+ * // Before:
  * function ComposerStatus() {
  *   const text = useComposer((state) => state.text);
  *   const canSend = useComposer((state) => state.canSend);
  *   const attachmentCount = useComposer((state) => state.attachments.length);
+ *   return (
+ *     <div>
+ *       Text: {text.length} chars,
+ *       Attachments: {attachmentCount},
+ *       Can send: {canSend}
+ *     </div>
+ *   );
+ * }
  *
+ * // After:
+ * function ComposerStatus() {
+ *   const text = useAssistantState(({ composer }) => composer.text);
+ *   const canSend = useAssistantState(({ composer }) => composer.canSend);
+ *   const attachmentCount = useAssistantState(({ composer }) => composer.attachments.length);
  *   return (
  *     <div>
  *       Text: {text.length} chars,

package/src/legacy-runtime/hooks/MessageContext.ts

@@ -6,6 +6,8 @@ import { createStateHookForRuntime } from "../../context/react/utils/createState
 import { EditComposerRuntime } from "../runtime";
 
 /**
+ * @deprecated Use `useAssistantApi()` with `api.message()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the MessageRuntime from the current context.
  *
  * The MessageRuntime provides access to message-level state and actions,
@@ -17,17 +19,32 @@ import { EditComposerRuntime } from "../runtime";
  *
  * @example
  * ```tsx
+ * // Before:
  * function MessageActions() {
  *   const runtime = useMessageRuntime();
- *
  *   const handleReload = () => {
  *     runtime.reload();
  *   };
- *
  *   const handleEdit = () => {
  *     runtime.startEdit();
  *   };
+ *   return (
+ *     <div>
+ *       <button onClick={handleReload}>Reload</button>
+ *       <button onClick={handleEdit}>Edit</button>
+ *     </div>
+ *   );
+ * }
  *
+ * // After:
+ * function MessageActions() {
+ *   const api = useAssistantApi();
+ *   const handleReload = () => {
+ *     api.message().reload();
+ *   };
+ *   const handleEdit = () => {
+ *     api.message().startEdit();
+ *   };
  *   return (
  *     <div>
  *       <button onClick={handleReload}>Reload</button>
@@ -59,6 +76,8 @@ export function useMessageRuntime(options?: {
 }
 
 /**
+ * @deprecated Use `useAssistantState(({ message }) => message)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the current message state.
  *
  * This hook provides reactive access to the message's state, including content,
@@ -69,11 +88,23 @@ export function useMessageRuntime(options?: {
  *
  * @example
  * ```tsx
+ * // Before:
  * function MessageContent() {
  *   const role = useMessage((state) => state.role);
  *   const content = useMessage((state) => state.content);
  *   const isLoading = useMessage((state) => state.status.type === "running");
+ *   return (
+ *     <div className={`message-${role}`}>
+ *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
+ *     </div>
+ *   );
+ * }
  *
+ * // After:
+ * function MessageContent() {
+ *   const role = useAssistantState(({ message }) => message.role);
+ *   const content = useAssistantState(({ message }) => message.content);
+ *   const isLoading = useAssistantState(({ message }) => message.status.type === "running");
  *   return (
  *     <div className={`message-${role}`}>
  *       {isLoading ? "Loading..." : content.map(part => part.text).join("")}
@@ -87,6 +118,10 @@ export const useMessage = createStateHookForRuntime(useMessageRuntime);
 const useEditComposerRuntime = (opt: {
   optional: boolean | undefined;
 }): EditComposerRuntime | null => useMessageRuntime(opt)?.composer ?? null;
+
+/**
+ * @deprecated Use `useAssistantState(({ message }) => message.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export const useEditComposer = createStateHookForRuntime(
   useEditComposerRuntime,
 );

package/src/legacy-runtime/hooks/MessagePartContext.ts

@@ -4,6 +4,9 @@ import { MessagePartRuntime } from "../runtime/MessagePartRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 import { useAssistantApi, useAssistantState } from "../../context/react";
 
+/**
+ * @deprecated Use `useAssistantApi()` with `api.part()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export function useMessagePartRuntime(options?: {
   optional?: false | undefined;
 }): MessagePartRuntime;
@@ -23,4 +26,7 @@ export function useMessagePartRuntime(options?: {
   return runtime;
 }
 
+/**
+ * @deprecated Use `useAssistantState(({ part }) => part)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export const useMessagePart = createStateHookForRuntime(useMessagePartRuntime);

package/src/legacy-runtime/hooks/ThreadContext.ts

@@ -12,6 +12,8 @@ import {
 } from "../../context/react";
 
 /**
+ * @deprecated Use `useAssistantApi()` with `api.thread()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the ThreadRuntime from the current context.
  *
  * The ThreadRuntime provides access to thread-level state and actions,
@@ -23,13 +25,21 @@ import {
  *
  * @example
  * ```tsx
+ * // Before:
  * function MyComponent() {
  *   const runtime = useThreadRuntime();
- *
  *   const handleSendMessage = (text: string) => {
  *     runtime.append({ role: "user", content: [{ type: "text", text }] });
  *   };
+ *   return <button onClick={() => handleSendMessage("Hello!")}>Send</button>;
+ * }
  *
+ * // After:
+ * function MyComponent() {
+ *   const api = useAssistantApi();
+ *   const handleSendMessage = (text: string) => {
+ *     api.thread().append({ role: "user", content: [{ type: "text", text }] });
+ *   };
  *   return <button onClick={() => handleSendMessage("Hello!")}>Send</button>;
  * }
  * ```
@@ -52,6 +62,8 @@ export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
 }
 
 /**
+ * @deprecated Use `useAssistantState(({ thread }) => thread)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ *
  * Hook to access the current thread state.
  *
  * This hook provides reactive access to the thread's state, including messages,
@@ -62,10 +74,17 @@ export function useThreadRuntime(options?: { optional?: boolean | undefined }) {
  *
  * @example
  * ```tsx
+ * // Before:
  * function ThreadStatus() {
  *   const isRunning = useThread((state) => state.isRunning);
  *   const messageCount = useThread((state) => state.messages.length);
+ *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
+ * }
  *
+ * // After:
+ * function ThreadStatus() {
+ *   const isRunning = useAssistantState(({ thread }) => thread.isRunning);
+ *   const messageCount = useAssistantState(({ thread }) => thread.messages.length);
  *   return <div>Running: {isRunning}, Messages: {messageCount}</div>;
  * }
  * ```
@@ -75,10 +94,17 @@ export const useThread = createStateHookForRuntime(useThreadRuntime);
 const useThreadComposerRuntime = (opt: {
   optional: boolean | undefined;
 }): ThreadComposerRuntime | null => useThreadRuntime(opt)?.composer ?? null;
+
+/**
+ * @deprecated Use `useAssistantState(({ thread }) => thread.composer)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export const useThreadComposer = createStateHookForRuntime(
   useThreadComposerRuntime,
 );
 
+/**
+ * @deprecated Use `useAssistantState(({ thread }) => thread.modelContext)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export function useThreadModelContext(options?: {
   optional?: false | undefined;
 }): ModelContext;

package/src/legacy-runtime/hooks/ThreadListItemContext.ts

@@ -4,6 +4,9 @@ import { ThreadListItemRuntime } from "../runtime/ThreadListItemRuntime";
 import { createStateHookForRuntime } from "../../context/react/utils/createStateHookForRuntime";
 import { useAssistantApi, useAssistantState } from "../../context/react";
 
+/**
+ * @deprecated Use `useAssistantApi()` with `api.threadListItem()` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export function useThreadListItemRuntime(options?: {
   optional?: false | undefined;
 }): ThreadListItemRuntime;
@@ -25,6 +28,9 @@ export function useThreadListItemRuntime(options?: {
   return runtime;
 }
 
+/**
+ * @deprecated Use `useAssistantState(({ threadListItem }) => threadListItem)` instead. See migration guide: https://docs.assistant-ui.com/docs/migrations/v0-12
+ */
 export const useThreadListItem = createStateHookForRuntime(
   useThreadListItemRuntime,
 );

package/src/legacy-runtime/runtime-cores/core/AssistantRuntimeCore.tsx

@@ -7,6 +7,7 @@ export type AssistantRuntimeCore = {
   readonly threads: ThreadListRuntimeCore;
 
   registerModelContextProvider: (provider: ModelContextProvider) => Unsubscribe;
+  getModelContextProvider: () => ModelContextProvider;
 
   /**
    * EXPERIMENTAL: A component that is rendered inside the AssistantRuntimeProvider.

package/src/legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore.tsx

@@ -13,4 +13,8 @@ export abstract class BaseAssistantRuntimeCore implements AssistantRuntimeCore {
   ): Unsubscribe {
     return this._contextProvider.registerModelContextProvider(provider);
   }
+
+  public getModelContextProvider(): ModelContextProvider {
+    return this._contextProvider;
+  }
 }

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadListRuntimeCore.tsx

@@ -212,8 +212,10 @@ export class ExternalStoreThreadListRuntimeCore
     onDelete(threadId);
   }
 
-  public initialize(): never {
-    throw new Error("Method not implemented.");
+  public initialize(
+    threadId: string,
+  ): Promise<{ remoteId: string; externalId: string | undefined }> {
+    return Promise.resolve({ remoteId: threadId, externalId: undefined });
   }
 
   public generateTitle(): never {

package/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore.tsx

@@ -162,7 +162,13 @@ export class ExternalStoreThreadRuntimeCore
             if (!store.convertMessage) return m;
 
             const isLast = idx === store.messages!.length - 1;
-            const autoStatus = getAutoStatus(isLast, isRunning, false, false);
+            const autoStatus = getAutoStatus(
+              isLast,
+              isRunning,
+              false,
+              false,
+              undefined,
+            );
 
             if (
               cache &&

package/src/legacy-runtime/runtime-cores/external-store/auto-status.tsx

@@ -1,34 +1,67 @@
+import { ReadonlyJSONValue } from "assistant-stream/utils";
 import { MessageStatus } from "../../../types";
 
-const AUTO_STATUS_RUNNING = Object.freeze({ type: "running" });
-const AUTO_STATUS_COMPLETE = Object.freeze({
-  type: "complete",
-  reason: "unknown",
-});
+const symbolAutoStatus = Symbol("autoStatus");
 
-const AUTO_STATUS_PENDING = Object.freeze({
-  type: "requires-action",
-  reason: "tool-calls",
-});
+const AUTO_STATUS_RUNNING = Object.freeze(
+  Object.assign({ type: "running" as const }, { [symbolAutoStatus]: true }),
+);
+const AUTO_STATUS_COMPLETE = Object.freeze(
+  Object.assign(
+    {
+      type: "complete" as const,
+      reason: "unknown" as const,
+    },
+    { [symbolAutoStatus]: true },
+  ),
+);
 
-const AUTO_STATUS_INTERRUPT = Object.freeze({
-  type: "requires-action",
-  reason: "interrupt",
-});
+const AUTO_STATUS_PENDING = Object.freeze(
+  Object.assign(
+    {
+      type: "requires-action" as const,
+      reason: "tool-calls" as const,
+    },
+    { [symbolAutoStatus]: true },
+  ),
+);
+
+const AUTO_STATUS_INTERRUPT = Object.freeze(
+  Object.assign(
+    {
+      type: "requires-action" as const,
+      reason: "interrupt" as const,
+    },
+    { [symbolAutoStatus]: true },
+  ),
+);
 
 export const isAutoStatus = (status: MessageStatus) =>
-  status === AUTO_STATUS_RUNNING || status === AUTO_STATUS_COMPLETE;
+  (status as any)[symbolAutoStatus] === true;
 
 export const getAutoStatus = (
   isLast: boolean,
   isRunning: boolean,
   hasInterruptedToolCalls: boolean,
   hasPendingToolCalls: boolean,
-) =>
-  isLast && isRunning
+  error?: ReadonlyJSONValue,
+): MessageStatus => {
+  if (isLast && error) {
+    return Object.assign(
+      {
+        type: "incomplete" as const,
+        reason: "error" as const,
+        error: error,
+      },
+      { [symbolAutoStatus]: true },
+    );
+  }
+
+  return isLast && isRunning
     ? AUTO_STATUS_RUNNING
     : hasInterruptedToolCalls
       ? AUTO_STATUS_INTERRUPT
       : hasPendingToolCalls
         ? AUTO_STATUS_PENDING
         : AUTO_STATUS_COMPLETE;
+};

package/src/legacy-runtime/runtime-cores/external-store/external-message-converter.tsx

@@ -10,6 +10,7 @@ import { fromThreadMessageLike, ThreadMessageLike } from "./ThreadMessageLike";
 import { getAutoStatus, isAutoStatus } from "./auto-status";
 import { ThreadMessage, ToolCallMessagePart } from "../../../types";
 import { ToolExecutionStatus } from "../assistant-transport/useToolInvocations";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
 
 export namespace useExternalMessageConverter {
   export type Message =
@@ -30,6 +31,7 @@ export namespace useExternalMessageConverter {
 
   export type Metadata = {
     readonly toolStatuses?: Record<string, ToolExecutionStatus>;
+    readonly error?: ReadonlyJSONValue;
   };
 
   export type Callback<T> = (
@@ -263,6 +265,7 @@ export const convertExternalMessages = <T extends WeakKey>(
       isRunning,
       hasSuspendedToolCalls,
       hasPendingToolCalls,
+      isLast ? metadata.error : undefined,
     );
     const newMessage = fromThreadMessageLike(
       joined,
@@ -348,6 +351,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
           isRunning,
           hasSuspendedToolCalls,
           hasPendingToolCalls,
+          isLast ? state.metadata.error : undefined,
         );
 
         if (

package/src/legacy-runtime/runtime-cores/local/LocalThreadListRuntimeCore.tsx

@@ -104,8 +104,10 @@ export class LocalThreadListRuntimeCore
     throw new Error("Method not implemented.");
   }
 
-  public initialize(): never {
-    throw new Error("Method not implemented.");
+  public initialize(
+    threadId: string,
+  ): Promise<{ remoteId: string; externalId: string | undefined }> {
+    return Promise.resolve({ remoteId: threadId, externalId: undefined });
   }
 
   public generateTitle(): never {

package/src/legacy-runtime/runtime-cores/utils/MessageRepository.tsx

@@ -67,7 +67,7 @@ export const ExportedMessageRepository = {
       fromThreadMessageLike(
         m,
         generateId(),
-        getAutoStatus(false, false, false, false),
+        getAutoStatus(false, false, false, false, undefined),
       ),
     );
 

package/src/model-context/index.ts

@@ -19,5 +19,14 @@ export { tool } from "./tool";
 
 export { makeAssistantVisible } from "./makeAssistantVisible";
 
+export {
+  Toolkit,
+  type ToolDefinition,
+  type ToolkitFallback,
+  type ToolkitLayout,
+} from "./toolbox";
+
+export { Tools } from "../client/Tools";
+
 export * from "./registry";
 export * from "./frame";

package/src/model-context/makeAssistantVisible.tsx

@@ -76,7 +76,7 @@ export const makeAssistantVisible = <T extends ComponentType<any>>(
 
       const { clickable, editable } = config ?? {};
       useEffect(() => {
-        return api.registerModelContextProvider({
+        return api.modelContext().register({
           getModelContext: () => {
             return {
               tools: {