@assistant-ui/react 0.12.10 → 0.12.11

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 {
+  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

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

@@ -3,27 +3,36 @@ export {
   type AssistantToolUI,
   makeAssistantToolUI,
 } from "./makeAssistantToolUI";
+export {
+  type AssistantDataUI,
+  makeAssistantDataUI,
+} from "./makeAssistantDataUI";
 export { useAssistantInstructions } from "./useAssistantInstructions";
 export { useAssistantTool, type AssistantToolProps } from "./useAssistantTool";
 export {
   useAssistantToolUI,
   type AssistantToolUIProps,
 } from "./useAssistantToolUI";
+export {
+  useAssistantDataUI,
+  type AssistantDataUIProps,
+} from "./useAssistantDataUI";
 export { useInlineRender } from "./useInlineRender";
 
-export type { ModelContext, ModelContextProvider } from "./ModelContextTypes";
+export type { ModelContext, ModelContextProvider } 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 { Tools } from "../client/Tools";
+export { DataRenderers } from "../client/DataRenderers";
 
-export { Suggestions, type SuggestionConfig } from "../client/Suggestions";
+export { Suggestions, type SuggestionConfig } from "@assistant-ui/core/store";
 
 export * from "./registry";
 export * from "./frame";

package/src/model-context/makeAssistantDataUI.ts

@@ -0,0 +1,22 @@
+"use client";
+
+import type { FC } from "react";
+import {
+  type AssistantDataUIProps,
+  useAssistantDataUI,
+} from "./useAssistantDataUI";
+
+export type AssistantDataUI = FC & {
+  unstable_data: AssistantDataUIProps;
+};
+
+export const makeAssistantDataUI = <T = any>(
+  dataUI: AssistantDataUIProps<T>,
+) => {
+  const DataUI: AssistantDataUI = () => {
+    useAssistantDataUI(dataUI);
+    return null;
+  };
+  DataUI.unstable_data = dataUI;
+  return DataUI;
+};

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";

package/src/model-context/useAssistantDataUI.ts

@@ -0,0 +1,18 @@
+"use client";
+
+import { useEffect } from "react";
+import { useAui } from "@assistant-ui/store";
+import type { DataMessagePartComponent } from "../types/MessagePartComponentTypes";
+
+export type AssistantDataUIProps<T = any> = {
+  name: string;
+  render: DataMessagePartComponent<T>;
+};
+
+export const useAssistantDataUI = (dataUI: AssistantDataUIProps | null) => {
+  const aui = useAui();
+  useEffect(() => {
+    if (!dataUI?.name || !dataUI?.render) return undefined;
+    return aui.dataRenderers().setDataUI(dataUI.name, dataUI.render);
+  }, [aui, dataUI?.name, dataUI?.render]);
+};

package/src/model-context/{useAssistantInstructions.tsx → useAssistantInstructions.ts}

@@ -2,11 +2,9 @@
 
 import { useEffect } from "react";
 import { useAui } from "@assistant-ui/store";
+import type { AssistantInstructionsConfig } from "@assistant-ui/core";
 
-export type AssistantInstructionsConfig = {
-  disabled?: boolean | undefined;
-  instruction: string;
-};
+export type { AssistantInstructionsConfig };
 
 const getInstructions = (
   instruction: string | AssistantInstructionsConfig,

package/src/model-context/{useAssistantTool.tsx → useAssistantTool.ts}

@@ -3,13 +3,12 @@
 import { useEffect } from "react";
 import { useAui } from "@assistant-ui/store";
 import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
-import type { Tool } from "assistant-stream";
+import type { AssistantToolProps as CoreAssistantToolProps } from "@assistant-ui/core";
 
 export type AssistantToolProps<
   TArgs extends Record<string, unknown>,
   TResult,
-> = Tool<TArgs, TResult> & {
-  toolName: string;
+> = CoreAssistantToolProps<TArgs, TResult> & {
   render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
 };
 

package/src/primitives/composer/ComposerAttachments.tsx

@@ -1,7 +1,7 @@
 "use client";
 
+import type { Attachment } from "@assistant-ui/core";
 import { ComponentType, type FC, memo, useMemo } from "react";
-import { Attachment } from "../../types";
 import { useAuiState } from "@assistant-ui/store";
 import { ComposerAttachmentByIndexProvider } from "../../context/providers";
 

package/src/primitives/index.ts

@@ -24,3 +24,4 @@ export { useMessagePartData } from "./messagePart/useMessagePartData";
 export { useThreadViewportAutoScroll } from "./thread/useThreadViewportAutoScroll";
 export { useScrollLock } from "./reasoning";
 export { useMessageQuote } from "../hooks/useMessageQuote";
+export { useMessageTiming } from "../hooks/useMessageTiming";

package/src/primitives/message/MessageAttachments.tsx

@@ -1,9 +1,9 @@
 "use client";
 
+import type { CompleteAttachment } from "@assistant-ui/core";
 import { ComponentType, type FC, memo, useMemo } from "react";
 import { useAuiState } from "@assistant-ui/store";
 import { MessageAttachmentByIndexProvider } from "../../context/providers";
-import { CompleteAttachment } from "../../types";
 
 export namespace MessagePrimitiveAttachments {
   export type Props = {