@assistant-ui/react 0.12.10 → 0.12.12

package/src/legacy-runtime/runtime-cores/local/ChatModelAdapter.ts

@@ -0,0 +1,7 @@
+export type {
+  ChatModelRunUpdate,
+  ChatModelRunResult,
+  CoreChatModelRunResult,
+  ChatModelRunOptions,
+  ChatModelAdapter,
+} from "@assistant-ui/core";

package/src/legacy-runtime/runtime-cores/local/LocalRuntimeCore.ts

@@ -0,0 +1 @@
+export { LocalRuntimeCore } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/local/LocalRuntimeOptions.ts

@@ -0,0 +1,36 @@
+export type { LocalRuntimeOptionsBase } from "@assistant-ui/core";
+
+import type { LocalRuntimeOptionsBase } from "@assistant-ui/core";
+import type { ThreadMessageLike } from "@assistant-ui/core";
+import type { AssistantCloud } from "assistant-cloud";
+
+// TODO align LocalRuntimeOptions with LocalRuntimeOptionsBase
+export type LocalRuntimeOptions = Omit<LocalRuntimeOptionsBase, "adapters"> & {
+  cloud?: AssistantCloud | undefined;
+  initialMessages?: readonly ThreadMessageLike[] | undefined;
+  adapters?: Omit<LocalRuntimeOptionsBase["adapters"], "chatModel"> | undefined;
+};
+
+export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
+  options: T,
+) => {
+  const {
+    cloud,
+    initialMessages,
+    maxSteps,
+    adapters,
+    unstable_humanToolNames,
+    ...rest
+  } = options;
+
+  return {
+    localRuntimeOptions: {
+      cloud,
+      initialMessages,
+      maxSteps,
+      adapters,
+      unstable_humanToolNames,
+    },
+    otherOptions: rest,
+  };
+};

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

@@ -0,0 +1,2 @@
+export { LocalThreadListRuntimeCore } from "@assistant-ui/core/internal";
+export type { LocalThreadFactory } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/local/LocalThreadRuntimeCore.ts

@@ -0,0 +1 @@
+export { LocalThreadRuntimeCore } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/local/index.ts

@@ -1,3 +1,13 @@
+// Re-export from @assistant-ui/core
+export type {
+  ChatModelAdapter,
+  ChatModelRunOptions,
+  ChatModelRunResult,
+  ChatModelRunUpdate,
+  LocalRuntimeOptionsBase,
+} from "@assistant-ui/core";
+
+// React-specific (stay in react)
 export { useLocalRuntime } from "./useLocalRuntime";
 
 /**
@@ -6,9 +16,3 @@ export { useLocalRuntime } from "./useLocalRuntime";
 export { useLocalRuntime as useLocalThreadRuntime } from "./useLocalRuntime";
 
 export type { LocalRuntimeOptions } from "./LocalRuntimeOptions";
-export type {
-  ChatModelAdapter,
-  ChatModelRunOptions,
-  ChatModelRunResult,
-  ChatModelRunUpdate,
-} from "./ChatModelAdapter";

package/src/legacy-runtime/runtime-cores/local/shouldContinue.ts

@@ -0,0 +1 @@
+export { shouldContinue } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/remote-thread-list/BaseSubscribable.ts

@@ -0,0 +1 @@
+export { BaseSubscribable } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/remote-thread-list/EMPTY_THREAD_CORE.ts

@@ -0,0 +1 @@
+export { EMPTY_THREAD_CORE } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/remote-thread-list/OptimisticState.ts

@@ -1,89 +1 @@
-import { BaseSubscribable } from "./BaseSubscribable";
-
-type Transform<TState, TResult> = {
-  execute: () => Promise<TResult>;
-
-  /** transform the state after the promise resolves */
-  then?: (state: TState, result: TResult) => TState;
-
-  /** transform the state during resolution and afterwards */
-  optimistic?: (state: TState) => TState;
-
-  /** transform the state only while loading */
-  loading?: (state: TState, task: Promise<TResult>) => TState;
-};
-
-type PendingTransform<TState, TResult> = Transform<TState, TResult> & {
-  task: Promise<TResult>;
-};
-
-const pipeTransforms = <TState, TExtra>(
-  initialState: TState,
-  extraParam: TExtra,
-  transforms: (((state: TState, extra: TExtra) => TState) | undefined)[],
-): TState => {
-  return transforms.reduce((state, transform) => {
-    return transform?.(state, extraParam) ?? state;
-  }, initialState);
-};
-
-export class OptimisticState<TState> extends BaseSubscribable {
-  private readonly _pendingTransforms: Array<PendingTransform<TState, any>> =
-    [];
-  private _baseValue: TState;
-  private _cachedValue: TState;
-
-  public constructor(initialState: TState) {
-    super();
-    this._baseValue = initialState;
-    this._cachedValue = initialState;
-  }
-
-  private _updateState(): void {
-    this._cachedValue = this._pendingTransforms.reduce((state, transform) => {
-      return pipeTransforms(state, transform.task, [
-        transform.loading,
-        transform.optimistic,
-      ]);
-    }, this._baseValue);
-
-    this._notifySubscribers();
-  }
-
-  public get baseValue(): TState {
-    return this._baseValue;
-  }
-
-  public get value(): TState {
-    return this._cachedValue;
-  }
-
-  public update(state: TState): void {
-    this._baseValue = state;
-    this._updateState();
-  }
-
-  public async optimisticUpdate<TResult>(
-    transform: Transform<TState, TResult>,
-  ): Promise<TResult> {
-    const task = transform.execute();
-    const pendingTransform = { ...transform, task };
-    try {
-      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(pendingTransform);
-      if (index > -1) {
-        this._pendingTransforms.splice(index, 1);
-      }
-      this._updateState();
-    }
-  }
-}
+export { OptimisticState } from "@assistant-ui/core/internal";

package/src/legacy-runtime/runtime-cores/remote-thread-list/RemoteThreadListHookInstanceManager.tsx

@@ -18,7 +18,7 @@ import {
   ThreadRuntimeCore,
   ThreadRuntimeImpl,
 } from "../../../internal";
-import { BaseSubscribable } from "./BaseSubscribable";
+import { BaseSubscribable } from "@assistant-ui/core/internal";
 import { AssistantRuntime } from "../../runtime";
 import { ThreadListRuntimeImpl } from "../../runtime/ThreadListRuntime";
 

package/src/legacy-runtime/runtime-cores/remote-thread-list/RemoteThreadListThreadListRuntimeCore.tsx

@@ -1,142 +1,33 @@
 "use client";
 
-import { ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
-import { generateId } from "../../../internal";
+import type { ThreadListRuntimeCore } from "@assistant-ui/core";
 import {
-  RemoteThreadInitializeResponse,
-  RemoteThreadListOptions,
-} from "./types";
+  generateId,
+  BaseSubscribable,
+  OptimisticState,
+  EMPTY_THREAD_CORE,
+  type RemoteThreadData,
+  type THREAD_MAPPING_ID,
+  type RemoteThreadState,
+  createThreadMappingId,
+  getThreadData,
+  updateStatusReducer,
+  type RemoteThreadListOptions,
+} from "@assistant-ui/core/internal";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
-import { BaseSubscribable } from "./BaseSubscribable";
-import { EMPTY_THREAD_CORE } from "./EMPTY_THREAD_CORE";
-import { OptimisticState } from "./OptimisticState";
-import { FC, Fragment, useEffect, useId } from "react";
+import {
+  ComponentType,
+  FC,
+  Fragment,
+  PropsWithChildren,
+  useEffect,
+  useId,
+} from "react";
 import { create } from "zustand";
 import { AssistantMessageStream } from "assistant-stream";
 import { ModelContextProvider } from "../../../model-context";
 import { RuntimeAdapterProvider } from "../adapters/RuntimeAdapterProvider";
 
-type RemoteThreadData =
-  | {
-      readonly id: string;
-      readonly remoteId: undefined;
-      readonly externalId: undefined;
-      readonly status: "new";
-      readonly title: undefined;
-    }
-  | {
-      readonly id: string;
-      readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
-      readonly remoteId: undefined;
-      readonly externalId: undefined;
-      readonly status: "regular" | "archived";
-      readonly title?: string | undefined;
-    }
-  | {
-      readonly id: string;
-      readonly initializeTask: Promise<RemoteThreadInitializeResponse>;
-      readonly remoteId: string;
-      readonly externalId: string | undefined;
-      readonly status: "regular" | "archived";
-      readonly title?: string | undefined;
-    };
-
-type THREAD_MAPPING_ID = string & { __brand: "THREAD_MAPPING_ID" };
-function createThreadMappingId(id: string): THREAD_MAPPING_ID {
-  return id as THREAD_MAPPING_ID;
-}
-
-type RemoteThreadState = {
-  readonly isLoading: boolean;
-  readonly newThreadId: string | undefined;
-  readonly threadIds: readonly string[];
-  readonly archivedThreadIds: readonly string[];
-  readonly threadIdMap: Readonly<Record<string, THREAD_MAPPING_ID>>;
-  readonly threadData: Readonly<Record<THREAD_MAPPING_ID, RemoteThreadData>>;
-};
-
-const getThreadData = (
-  state: RemoteThreadState,
-  threadIdOrRemoteId: string,
-) => {
-  const idx = state.threadIdMap[threadIdOrRemoteId];
-  if (idx === undefined) return undefined;
-  return state.threadData[idx];
-};
-
-const updateStatusReducer = (
-  state: RemoteThreadState,
-  threadIdOrRemoteId: string,
-  newStatus: "regular" | "archived" | "deleted",
-) => {
-  const data = getThreadData(state, threadIdOrRemoteId);
-  if (!data) return state;
-
-  const { id, remoteId, status: lastStatus } = data;
-  if (lastStatus === newStatus) return state;
-
-  const newState = { ...state };
-
-  // lastStatus
-  switch (lastStatus) {
-    case "new":
-      newState.newThreadId = undefined;
-      break;
-    case "regular":
-      newState.threadIds = newState.threadIds.filter((t) => t !== id);
-      break;
-    case "archived":
-      newState.archivedThreadIds = newState.archivedThreadIds.filter(
-        (t) => t !== id,
-      );
-      break;
-
-    default: {
-      const _exhaustiveCheck: never = lastStatus;
-      throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
-    }
-  }
-
-  // newStatus
-  switch (newStatus) {
-    case "regular":
-      newState.threadIds = [id, ...newState.threadIds];
-      break;
-
-    case "archived":
-      newState.archivedThreadIds = [id, ...newState.archivedThreadIds];
-      break;
-
-    case "deleted":
-      newState.threadData = Object.fromEntries(
-        Object.entries(newState.threadData).filter(([key]) => key !== id),
-      );
-      newState.threadIdMap = Object.fromEntries(
-        Object.entries(newState.threadIdMap).filter(
-          ([key]) => key !== id && key !== remoteId,
-        ),
-      );
-      break;
-
-    default: {
-      const _exhaustiveCheck: never = newStatus;
-      throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
-    }
-  }
-
-  if (newStatus !== "deleted") {
-    newState.threadData = {
-      ...newState.threadData,
-      [id]: {
-        ...data,
-        status: newStatus,
-      },
-    };
-  }
-
-  return newState;
-};
-
 export class RemoteThreadListThreadListRuntimeCore
   extends BaseSubscribable
   implements ThreadListRuntimeCore
@@ -243,7 +134,8 @@ export class RemoteThreadListThreadListRuntimeCore
       this,
     );
     this.useProvider = create(() => ({
-      Provider: options.adapter.unstable_Provider ?? Fragment,
+      Provider: (options.adapter.unstable_Provider ??
+        Fragment) as ComponentType<PropsWithChildren>,
     }));
     this.__internal_setOptions(options);
     this.switchToNewThread();
@@ -256,7 +148,8 @@ export class RemoteThreadListThreadListRuntimeCore
 
     this._options = options;
 
-    const Provider = options.adapter.unstable_Provider ?? Fragment;
+    const Provider = (options.adapter.unstable_Provider ??
+      Fragment) as ComponentType<PropsWithChildren>;
     if (Provider !== this.useProvider.getState().Provider) {
       this.useProvider.setState({ Provider }, true);
     }
@@ -485,12 +378,14 @@ export class RemoteThreadListThreadListRuntimeCore
     for await (const result of messageStream) {
       const newTitle = result.parts.filter((c) => c.type === "text")[0]?.text;
       const state = this._state.baseValue;
+      const currentData = getThreadData(state, data.id);
+      if (!currentData) continue;
       this._state.update({
         ...state,
         threadData: {
           ...state.threadData,
-          [data.id]: {
-            ...data,
+          [currentData.id]: {
+            ...currentData,
             title: newTitle,
           },
         },
@@ -541,9 +436,10 @@ export class RemoteThreadListThreadListRuntimeCore
     if (data.status !== "regular")
       throw new Error("Thread is not yet initialized or already archived");
 
+    await this._ensureThreadIsNotMain(data.id);
+
     return this._state.optimisticUpdate({
       execute: async () => {
-        await this._ensureThreadIsNotMain(data.id);
         const { remoteId } = await data.initializeTask;
         return this._options.adapter.archive(remoteId);
       },
@@ -580,9 +476,10 @@ export class RemoteThreadListThreadListRuntimeCore
     if (data.status !== "regular" && data.status !== "archived")
       throw new Error("Thread is not yet initialized");
 
+    await this._ensureThreadIsNotMain(data.id);
+
     return this._state.optimisticUpdate({
       execute: async () => {
-        await this._ensureThreadIsNotMain(data.id);
         const { remoteId } = await data.initializeTask;
         return await this._options.adapter.delete(remoteId);
       },

package/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud.tsx

@@ -9,10 +9,10 @@ import {
   useRef,
 } from "react";
 import { AssistantCloud } from "assistant-cloud";
-import { RemoteThreadListAdapter } from "../types";
+import type { RemoteThreadListAdapter } from "@assistant-ui/core";
+import { InMemoryThreadListAdapter } from "@assistant-ui/core";
 import { useAssistantCloudThreadHistoryAdapter } from "../../../cloud/AssistantCloudThreadHistoryAdapter";
 import { RuntimeAdapterProvider } from "../../adapters/RuntimeAdapterProvider";
-import { InMemoryThreadListAdapter } from "./in-memory";
 import { CloudFileAttachmentAdapter } from "../../adapters";
 
 type ThreadData = {
@@ -72,7 +72,15 @@ export const useCloudThreadListAdapter = (
   );
 
   const cloud = adapter.cloud ?? autoCloud;
-  if (!cloud) return new InMemoryThreadListAdapter();
+  if (!cloud) {
+    const ref = adapterRef;
+    const inMemory = new InMemoryThreadListAdapter();
+    inMemory.initialize = async (threadId: string) => {
+      const result = await ref.current.create?.();
+      return { remoteId: threadId, externalId: result?.externalId };
+    };
+    return inMemory;
+  }
 
   return {
     list: async () => {

package/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/in-memory.ts

@@ -0,0 +1 @@
+export { InMemoryThreadListAdapter } from "@assistant-ui/core";

package/src/legacy-runtime/runtime-cores/remote-thread-list/index.ts

@@ -1,5 +1,7 @@
+// React-specific (stay in react)
 export { useRemoteThreadListRuntime as unstable_useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
-export type { RemoteThreadListAdapter as unstable_RemoteThreadListAdapter } from "./types";
-
-export { InMemoryThreadListAdapter as unstable_InMemoryThreadListAdapter } from "./adapter/in-memory";
 export { useCloudThreadListAdapter as unstable_useCloudThreadListAdapter } from "./adapter/cloud";
+
+// Re-export from @assistant-ui/core
+export type { RemoteThreadListAdapter as unstable_RemoteThreadListAdapter } from "@assistant-ui/core";
+export { InMemoryThreadListAdapter as unstable_InMemoryThreadListAdapter } from "@assistant-ui/core";

package/src/legacy-runtime/runtime-cores/remote-thread-list/types.ts

@@ -0,0 +1,7 @@
+export type {
+  RemoteThreadInitializeResponse,
+  RemoteThreadMetadata,
+  RemoteThreadListResponse,
+  RemoteThreadListAdapter,
+  RemoteThreadListOptions,
+} from "@assistant-ui/core";

package/src/legacy-runtime/runtime-cores/remote-thread-list/{useRemoteThreadListRuntime.tsx → useRemoteThreadListRuntime.ts}

@@ -1,12 +1,16 @@
 "use client";
 
-import { useState, useEffect, useMemo } from "react";
-import { BaseAssistantRuntimeCore } from "../core/BaseAssistantRuntimeCore";
+import { useState, useEffect, useMemo, useRef, useCallback } from "react";
+import {
+  BaseAssistantRuntimeCore,
+  AssistantRuntimeImpl,
+  type RemoteThreadListOptions,
+} from "@assistant-ui/core/internal";
+import type {
+  AssistantRuntimeCore,
+  AssistantRuntime,
+} from "@assistant-ui/core";
 import { RemoteThreadListThreadListRuntimeCore } from "./RemoteThreadListThreadListRuntimeCore";
-import { RemoteThreadListOptions } from "./types";
-import { AssistantRuntimeImpl } from "../../../internal";
-import { AssistantRuntimeCore } from "../core/AssistantRuntimeCore";
-import { AssistantRuntime } from "../../runtime/AssistantRuntime";
 import { useAui } from "@assistant-ui/store";
 
 class RemoteThreadListRuntimeCore
@@ -42,11 +46,27 @@ const useRemoteThreadListRuntimeImpl = (
 export const useRemoteThreadListRuntime = (
   options: RemoteThreadListOptions,
 ): AssistantRuntime => {
+  const runtimeHookRef = useRef(options.runtimeHook);
+  runtimeHookRef.current = options.runtimeHook;
+
+  const stableRuntimeHook = useCallback(() => {
+    return runtimeHookRef.current();
+  }, []);
+
+  const stableOptions = useMemo<RemoteThreadListOptions>(
+    () => ({
+      adapter: options.adapter,
+      allowNesting: options.allowNesting,
+      runtimeHook: stableRuntimeHook,
+    }),
+    [options.adapter, options.allowNesting, stableRuntimeHook],
+  );
+
   const aui = useAui();
   const isNested = aui.threadListItem.source !== null;
 
   if (isNested) {
-    if (!options.allowNesting) {
+    if (!stableOptions.allowNesting) {
       throw new Error(
         "useRemoteThreadListRuntime cannot be nested inside another RemoteThreadListRuntime. " +
           "Set allowNesting: true to allow nesting (the inner runtime will become a no-op).",
@@ -55,8 +75,8 @@ export const useRemoteThreadListRuntime = (
 
     // If allowNesting is true and already inside a thread list context,
     // just call the runtimeHook directly (no-op behavior)
-    return options.runtimeHook();
+    return stableRuntimeHook();
   }
 
-  return useRemoteThreadListRuntimeImpl(options);
+  return useRemoteThreadListRuntimeImpl(stableOptions);
 };

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

@@ -0,0 +1,3 @@
+export type { ExportedMessageRepositoryItem } from "@assistant-ui/core";
+export { ExportedMessageRepository } from "@assistant-ui/core";
+export { MessageRepository } from "@assistant-ui/core/internal";

package/src/model-context/frame/AssistantFrame.test.ts

@@ -2,9 +2,11 @@
  * @vitest-environment jsdom
  */
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { AssistantFrameProvider } from "./AssistantFrameProvider";
-import { AssistantFrameHost } from "./AssistantFrameHost";
-import { ModelContextRegistry } from "../registry/ModelContextRegistry";
+import {
+  AssistantFrameProvider,
+  AssistantFrameHost,
+  ModelContextRegistry,
+} from "@assistant-ui/core";
 import z from "zod";
 
 describe("AssistantFrame Integration", () => {
@@ -134,7 +136,7 @@ describe("AssistantFrame Integration", () => {
       const context = host.getModelContext();
       expect(context.tools).toBeDefined();
       expect(context.tools?.search).toBeDefined();
-      expect(context.tools?.search.description).toBe("Search the web");
+      expect(context.tools?.search?.description).toBe("Search the web");
     });
 
     // Clean up

package/src/model-context/frame/index.ts

@@ -1,4 +1,10 @@
-export * from "./AssistantFrameHost";
-export * from "./AssistantFrameProvider";
-export * from "./AssistantFrameTypes";
+export { AssistantFrameHost } from "@assistant-ui/core";
+export { AssistantFrameProvider } from "@assistant-ui/core";
+export type {
+  SerializedTool,
+  SerializedModelContext,
+  FrameMessageType,
+  FrameMessage,
+} from "@assistant-ui/core";
+export { FRAME_MESSAGE_CHANNEL } from "@assistant-ui/core";
 export * from "./useAssistantFrameHost";

package/src/model-context/frame/useAssistantFrameHost.ts

@@ -1,8 +1,8 @@
 "use client";
 
+import type { Unsubscribe } from "@assistant-ui/core";
 import { useEffect, RefObject } from "react";
-import { AssistantFrameHost } from "./AssistantFrameHost";
-import { Unsubscribe } from "../../types";
+import { AssistantFrameHost } from "@assistant-ui/core";
 
 type UseAssistantFrameHostOptions = {
   iframeRef: Readonly<RefObject<HTMLIFrameElement | null | undefined>>;

package/src/model-context/index.ts

@@ -1,29 +1,45 @@
-export { makeAssistantTool, type AssistantTool } from "./makeAssistantTool";
+"use client";
+
+// Re-export shared from core/react
 export {
-  type AssistantToolUI,
+  makeAssistantTool,
+  type AssistantTool,
   makeAssistantToolUI,
-} from "./makeAssistantToolUI";
-export { useAssistantInstructions } from "./useAssistantInstructions";
-export { useAssistantTool, type AssistantToolProps } from "./useAssistantTool";
-export {
+  type AssistantToolUI,
+  makeAssistantDataUI,
+  type AssistantDataUI,
+  useAssistantTool,
+  type AssistantToolProps,
   useAssistantToolUI,
   type AssistantToolUIProps,
-} from "./useAssistantToolUI";
-export { useInlineRender } from "./useInlineRender";
-
-export type { ModelContext, ModelContextProvider } from "./ModelContextTypes";
+  useAssistantDataUI,
+  type AssistantDataUIProps,
+  useAssistantInstructions,
+  useInlineRender,
+  type Toolkit,
+  type ToolDefinition,
+  Tools,
+  DataRenderers,
+} from "@assistant-ui/core/react";
+
+// Core pass-through (unchanged)
+export type {
+  ModelContext,
+  ModelContextProvider,
+  LanguageModelConfig,
+  LanguageModelV1CallSettings,
+} from "@assistant-ui/core";
+
+export { mergeModelContexts } from "@assistant-ui/core";
 
 export type { Tool } from "assistant-stream";
 
-export { tool } from "./tool";
+export { tool } from "@assistant-ui/core";
 
-export { makeAssistantVisible } from "./makeAssistantVisible";
-
-export type { Toolkit, ToolDefinition } from "./toolbox";
+export { Suggestions, type SuggestionConfig } from "@assistant-ui/core/store";
 
-export { Tools } from "../client/Tools";
-
-export { Suggestions, type SuggestionConfig } from "../client/Suggestions";
+// React-only (stays)
+export { makeAssistantVisible } from "./makeAssistantVisible";
 
 export * from "./registry";
 export * from "./frame";

package/src/model-context/makeAssistantVisible.tsx

@@ -13,7 +13,7 @@ import {
 } from "react";
 import { useAui } from "@assistant-ui/store";
 import { useComposedRefs } from "@radix-ui/react-compose-refs";
-import { tool } from "./tool";
+import { tool } from "@assistant-ui/core";
 
 const click = tool({
   parameters: {

package/src/model-context/registry/index.ts

@@ -1,2 +1,6 @@
-export * from "./ModelContextRegistry";
-export * from "./ModelContextRegistryHandles";
+export { ModelContextRegistry } from "@assistant-ui/core";
+export type {
+  ModelContextRegistryToolHandle,
+  ModelContextRegistryInstructionHandle,
+  ModelContextRegistryProviderHandle,
+} from "@assistant-ui/core";