@assistant-ui/react 0.11.57 → 0.12.0

package/src/context/react/AssistantApiContext.tsx

@@ -1,340 +0,0 @@
-"use client";
-
-import {
-  createContext,
-  FC,
-  PropsWithChildren,
-  useContext,
-  useMemo,
-  useEffect,
-} from "react";
-import { useResource } from "@assistant-ui/tap/react";
-
-import {
-  MessageClientApi,
-  MessageClientState,
-} from "../../client/types/Message";
-import {
-  ThreadListItemClientApi,
-  ThreadListItemClientState,
-} from "../../client/types/ThreadListItem";
-import {
-  MessagePartClientApi,
-  MessagePartClientState,
-} from "../../client/types/Part";
-import { ThreadClientApi, ThreadClientState } from "../../client/types/Thread";
-import {
-  ComposerClientApi,
-  ComposerClientState,
-} from "../../client/types/Composer";
-import {
-  AttachmentClientApi,
-  AttachmentClientState,
-} from "../../client/types/Attachment";
-import { Unsubscribe } from "../../types";
-import {
-  AssistantEvent,
-  AssistantEventCallback,
-  AssistantEventSelector,
-  normalizeEventSelector,
-} from "../../types/EventTypes";
-import {
-  ThreadListClientApi,
-  ThreadListClientState,
-} from "../../client/types/ThreadList";
-import { DevToolsProviderApi } from "../../devtools/DevToolsHooks";
-import {
-  AssistantClientProps,
-  useAssistantClient,
-} from "../../client/AssistantClient";
-import { ToolsApi, ToolsMeta, ToolsState } from "../../client/types/Tools";
-import {
-  ModelContextApi,
-  ModelContextMeta,
-} from "../../client/types/ModelContext";
-import {
-  DerivedScopes,
-  DerivedScopesInput,
-} from "../../utils/tap-store/derived-scopes";
-
-export type AssistantState = {
-  readonly threads: ThreadListClientState;
-  readonly tools: ToolsState;
-
-  readonly threadListItem: ThreadListItemClientState;
-  readonly thread: ThreadClientState;
-  readonly composer: ComposerClientState;
-  readonly message: MessageClientState;
-  readonly part: MessagePartClientState;
-  readonly attachment: AttachmentClientState;
-};
-
-export type AssistantApiField<
-  TApi,
-  TMeta extends { source: string | null; query: any },
-> = (() => TApi) & (TMeta | { source: null; query: Record<string, never> });
-
-// Meta types for each API method
-type ThreadsMeta = {
-  source: "root";
-  query: Record<string, never>;
-};
-
-type ThreadListItemMeta = {
-  source: "threads";
-  query:
-    | { type: "index"; index: number; archived: boolean }
-    | { type: "main" }
-    | { type: "id"; id: string };
-};
-
-type ThreadMeta = {
-  source: "threads";
-  query: { type: "main" };
-};
-
-type ComposerMeta = {
-  source: "message" | "thread";
-  query: Record<string, never>;
-};
-
-type MessageMeta =
-  | {
-      source: "thread";
-      query: { type: "index"; index: number };
-    }
-  | {
-      source: "root";
-      query: Record<string, never>;
-    };
-
-type PartMeta = {
-  source: "message" | "root";
-  query: { type: "index"; index: number } | Record<string, never>;
-};
-
-type AttachmentMeta = {
-  source: "message" | "composer";
-  query: { type: "index"; index: number };
-};
-
-export type AssistantApi = {
-  threads: AssistantApiField<ThreadListClientApi, ThreadsMeta>;
-  tools: AssistantApiField<ToolsApi, ToolsMeta>;
-  modelContext: AssistantApiField<ModelContextApi, ModelContextMeta>;
-  threadListItem: AssistantApiField<
-    ThreadListItemClientApi,
-    ThreadListItemMeta
-  >;
-  thread: AssistantApiField<ThreadClientApi, ThreadMeta>;
-  composer: AssistantApiField<ComposerClientApi, ComposerMeta>;
-  message: AssistantApiField<MessageClientApi, MessageMeta>;
-  part: AssistantApiField<MessagePartClientApi, PartMeta>;
-  attachment: AssistantApiField<AttachmentClientApi, AttachmentMeta>;
-
-  subscribe(listener: () => void): Unsubscribe;
-
-  on<TEvent extends AssistantEvent>(
-    event: AssistantEventSelector<TEvent>,
-    callback: AssistantEventCallback<TEvent>,
-  ): Unsubscribe;
-};
-
-export const createAssistantApiField = <
-  TApi,
-  TMeta extends { source: any; query: any },
->(
-  config: {
-    get: () => TApi;
-  } & (TMeta | { source: null; query: Record<string, never> }),
-): AssistantApiField<TApi, TMeta> => {
-  const fn = config.get as AssistantApiField<TApi, TMeta>;
-  fn.source = config.source;
-  fn.query = config.query;
-  return fn;
-};
-
-const NO_OP_FN = () => () => {};
-
-const AssistantApiContext = createContext<AssistantApi>({
-  threads: createAssistantApiField({
-    source: null,
-    query: {},
-    get: () => {
-      throw new Error("Threads is only available inside <AssistantProvider />");
-    },
-  }),
-  tools: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error("Tools is only available inside <AssistantProvider />");
-    },
-  }),
-  modelContext: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error(
-        "ModelContext is only available inside <AssistantProvider />",
-      );
-    },
-  }),
-  threadListItem: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error(
-        "ThreadListItem is only available inside <AssistantProvider />",
-      );
-    },
-  }),
-  thread: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error("Thread is only available inside <AssistantProvider />");
-    },
-  }),
-  composer: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error(
-        "Composer is only available inside <AssistantProvider />",
-      );
-    },
-  }),
-  message: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error(
-        "Message is only available inside <ThreadPrimitive.Messages />",
-      );
-    },
-  }),
-  part: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error(
-        "Part is only available inside <MessagePrimitive.Parts />",
-      );
-    },
-  }),
-  attachment: createAssistantApiField({
-    source: null,
-    query: {},
-    get: (): never => {
-      throw new Error(
-        "Attachment is only available inside <MessagePrimitive.Attachments /> or <ComposerPrimitive.Attachments />",
-      );
-    },
-  }),
-
-  subscribe: NO_OP_FN,
-  on: (selector) => {
-    const { scope } = normalizeEventSelector(selector);
-    throw new Error(`Event scope is not available in this component: ${scope}`);
-  },
-});
-
-export const useAssistantApiImpl = (): AssistantApi => {
-  return useContext(AssistantApiContext);
-};
-
-/**
- * Hook to extend the current AssistantApi with additional derived scope fields and special callbacks.
- * This merges the derived fields with the existing API from context.
- * Fields are automatically memoized based on source and query changes.
- * Special callbacks (on, subscribe) use the useEffectEvent pattern to always access latest values.
- *
- * @param scopes - Record of field names to DerivedScope resource elements, plus optional special callbacks
- * @returns The merged AssistantApi
- *
- * @example
- * ```tsx
- * const api = useExtendedAssistantApi({
- *   message: DerivedScope({
- *     source: "root",
- *     query: {},
- *     get: () => messageApi,
- *   }),
- *   on: (selector, callback) => {
- *     // Custom event filtering logic
- *   },
- * });
- * ```
- */
-export const useExtendedAssistantApi = (
-  scopes: DerivedScopesInput,
-): AssistantApi => {
-  const baseApi = useAssistantApiImpl();
-  const partialApi = useResource(DerivedScopes(scopes));
-  return useMemo(() => extendApi(baseApi, partialApi), [baseApi, partialApi]);
-};
-
-const useExtendedAssistantApiImpl = (
-  config: AssistantClientProps,
-): AssistantApi => {
-  return useAssistantClient(config);
-};
-
-export function useAssistantApi(): AssistantApi;
-export function useAssistantApi(config: AssistantClientProps): AssistantApi;
-export function useAssistantApi(config?: AssistantClientProps): AssistantApi {
-  if (config) {
-    return useExtendedAssistantApiImpl(config);
-  } else {
-    return useAssistantApiImpl();
-  }
-}
-
-const mergeFnsWithUnsubscribe = <TArgs extends Array<unknown>>(
-  fn1: (...args: TArgs) => Unsubscribe,
-  fn2: (...args: TArgs) => Unsubscribe,
-) => {
-  if (fn1 === NO_OP_FN) return fn2;
-  if (fn2 === NO_OP_FN) return fn1;
-
-  return (...args: TArgs) => {
-    const unsubscribe1 = fn1(...args);
-    const unsubscribe2 = fn2(...args);
-
-    return () => {
-      unsubscribe1();
-      unsubscribe2();
-    };
-  };
-};
-
-export const extendApi = (
-  api: AssistantApi,
-  api2: Partial<AssistantApi>,
-): AssistantApi => {
-  const api2Subscribe = api2.subscribe;
-  return {
-    ...api,
-    ...api2,
-    subscribe: mergeFnsWithUnsubscribe(
-      api.subscribe,
-      api2Subscribe ?? NO_OP_FN,
-    ),
-  };
-};
-
-export const AssistantProvider: FC<
-  PropsWithChildren<{ api: AssistantApi; devToolsVisible?: boolean }>
-> = ({ api, children, devToolsVisible = true }) => {
-  useEffect(() => {
-    if (!devToolsVisible || !api.subscribe) return undefined;
-    return DevToolsProviderApi.register(api);
-  }, [api, devToolsVisible]);
-
-  return (
-    <AssistantApiContext.Provider value={api}>
-      {children}
-    </AssistantApiContext.Provider>
-  );
-};

package/src/context/react/hooks/useAssistantEvent.ts

@@ -1,25 +0,0 @@
-import { useEffect, useRef } from "react";
-import { useAssistantApi } from "../../react/AssistantApiContext";
-import {
-  AssistantEvent,
-  AssistantEventCallback,
-  AssistantEventSelector,
-  normalizeEventSelector,
-} from "../../../types/EventTypes";
-
-export const useAssistantEvent = <TEvent extends AssistantEvent>(
-  selector: AssistantEventSelector<TEvent>,
-  callback: AssistantEventCallback<TEvent>,
-) => {
-  const api = useAssistantApi();
-  const callbackRef = useRef(callback);
-  useEffect(() => {
-    callbackRef.current = callback;
-  });
-
-  const { scope, event } = normalizeEventSelector(selector);
-  useEffect(
-    () => api.on({ scope, event }, (e) => callbackRef.current(e)),
-    [api, scope, event],
-  );
-};

package/src/context/react/hooks/useAssistantState.tsx

@@ -1,65 +0,0 @@
-import { useMemo, useSyncExternalStore, useDebugValue } from "react";
-import {
-  AssistantState,
-  AssistantApi,
-  useAssistantApi,
-} from "../AssistantApiContext";
-
-class ProxiedAssistantState implements AssistantState {
-  #api: AssistantApi;
-  constructor(api: AssistantApi) {
-    this.#api = api;
-  }
-
-  get threads() {
-    return this.#api.threads().getState();
-  }
-
-  get tools() {
-    return this.#api.tools().getState();
-  }
-
-  get threadListItem() {
-    return this.#api.threadListItem().getState();
-  }
-
-  get thread() {
-    return this.#api.thread().getState();
-  }
-
-  get composer() {
-    return this.#api.composer().getState();
-  }
-
-  get message() {
-    return this.#api.message().getState();
-  }
-
-  get part() {
-    return this.#api.part().getState();
-  }
-
-  get attachment() {
-    return this.#api.attachment().getState();
-  }
-}
-
-export const useAssistantState = <T,>(
-  selector: (state: AssistantState) => T,
-): T => {
-  const api = useAssistantApi();
-  const proxiedState = useMemo(() => new ProxiedAssistantState(api), [api]);
-  const slice = useSyncExternalStore(
-    api.subscribe,
-    () => selector(proxiedState),
-    () => selector(proxiedState),
-  );
-  useDebugValue(slice);
-
-  if (slice instanceof ProxiedAssistantState)
-    throw new Error(
-      "You tried to return the entire AssistantState. This is not supported due to technical limitations.",
-    );
-
-  return slice;
-};

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

@@ -1,81 +0,0 @@
-import { resource, tapMemo } from "@assistant-ui/tap";
-import { Unsubscribe } from "../../types/Unsubscribe";
-import {
-  AssistantEventMap,
-  AssistantEvent,
-  AssistantEventCallback,
-} from "../../types/EventTypes";
-
-export type EventManager = {
-  on<TEvent extends AssistantEvent>(
-    event: TEvent,
-    callback: AssistantEventCallback<TEvent>,
-  ): Unsubscribe;
-  emit<TEvent extends Exclude<AssistantEvent, "*">>(
-    event: TEvent,
-    payload: AssistantEventMap[TEvent],
-  ): void;
-};
-
-type ListenerMap = Omit<
-  Map<AssistantEvent, Set<AssistantEventCallback<AssistantEvent>>>,
-  "get" | "set"
-> & {
-  get<TEvent extends AssistantEvent>(
-    event: TEvent,
-  ): Set<AssistantEventCallback<TEvent>> | undefined;
-  set<TEvent extends AssistantEvent>(
-    event: TEvent,
-    value: Set<AssistantEventCallback<TEvent>>,
-  ): void;
-};
-
-export const EventManager = resource(() => {
-  const events = tapMemo(() => {
-    const listeners: ListenerMap = new Map();
-
-    return {
-      on: (event, callback) => {
-        if (!listeners.has(event)) {
-          listeners.set(event, new Set());
-        }
-
-        const eventListeners = listeners.get(event)!;
-        eventListeners.add(callback);
-
-        return () => {
-          eventListeners.delete(callback);
-          if (eventListeners.size === 0) {
-            listeners.delete(event);
-          }
-        };
-      },
-
-      emit: (event, payload) => {
-        const eventListeners = listeners.get(event);
-        const wildcardListeners = listeners.get("*");
-
-        if (!eventListeners && !wildcardListeners) return;
-
-        // make sure state updates flush
-        queueMicrotask(() => {
-          // Emit to specific event listeners
-          if (eventListeners) {
-            for (const callback of eventListeners) {
-              callback(payload);
-            }
-          }
-
-          // Emit to wildcard listeners
-          if (wildcardListeners) {
-            for (const callback of wildcardListeners) {
-              callback({ event, payload });
-            }
-          }
-        });
-      },
-    } satisfies EventManager;
-  }, []);
-
-  return events;
-});

package/src/primitives/assistant/AssistantIf.tsx

@@ -1,25 +0,0 @@
-"use client";
-
-import type { FC, PropsWithChildren } from "react";
-import { useAssistantState } from "../../context";
-import type { AssistantState } from "../../context/react/AssistantApiContext";
-
-type UseAssistantIfProps = {
-  condition: AssistantIf.Condition;
-};
-
-const useAssistantIf = (props: UseAssistantIfProps) => {
-  return useAssistantState(props.condition);
-};
-
-export namespace AssistantIf {
-  export type Props = PropsWithChildren<UseAssistantIfProps>;
-  export type Condition = (state: AssistantState) => boolean;
-}
-
-export const AssistantIf: FC<AssistantIf.Props> = ({ children, condition }) => {
-  const result = useAssistantIf({ condition });
-  return result ? children : null;
-};
-
-AssistantIf.displayName = "AssistantIf";

package/src/types/EventTypes.ts

@@ -1,103 +0,0 @@
-export type EventSource<T extends AssistantEvent = AssistantEvent> =
-  T extends `${infer Source}.${string}` ? Source : never;
-
-type ScopeConfig = {
-  composer: "thread" | "message";
-  thread: never;
-  "thread-list-item": never;
-};
-
-export type SourceByScope<TScope extends AssistantEventScope<AssistantEvent>> =
-  | (TScope extends "*" ? EventSource : never)
-  | (TScope extends keyof ScopeConfig ? TScope : never)
-  | {
-      [K in keyof ScopeConfig]: TScope extends ScopeConfig[K] ? K : never;
-    }[keyof ScopeConfig];
-
-export type AssistantEventScope<TEvent extends AssistantEvent> =
-  | "*"
-  | EventSource<TEvent>
-  | ScopeConfig[EventSource<TEvent>];
-
-export type AssistantEventSelector<TEvent extends AssistantEvent> =
-  | TEvent
-  | {
-      scope: AssistantEventScope<TEvent>;
-      event: TEvent;
-    };
-
-export type AssistantEvent = keyof AssistantEventMap;
-
-export type AssistantEventMap = {
-  // Thread events (from ThreadRuntimeEventType)
-  "thread.run-start": {
-    threadId: string;
-  };
-  "thread.run-end": {
-    threadId: string;
-  };
-  "thread.initialize": {
-    threadId: string;
-  };
-  "thread.model-context-update": {
-    threadId: string;
-  };
-
-  // Composer events (from ComposerRuntimeEventType)
-  "composer.send": {
-    threadId: string;
-    messageId?: string;
-  };
-  "composer.attachment-add": {
-    threadId: string;
-    messageId?: string;
-  };
-
-  // Thread list item events (from ThreadListItemEventType)
-  "thread-list-item.switched-to": {
-    threadId: string;
-  };
-  "thread-list-item.switched-away": {
-    threadId: string;
-  };
-
-  // Catch-all
-  "*": {
-    [K in Exclude<keyof AssistantEventMap, "*">]: {
-      event: K;
-      payload: AssistantEventMap[K];
-    };
-  }[Exclude<keyof AssistantEventMap, "*">];
-};
-
-export const normalizeEventSelector = <TEvent extends AssistantEvent>(
-  selector: AssistantEventSelector<TEvent>,
-) => {
-  if (typeof selector === "string") {
-    const source = selector.split(".")[0] as AssistantEventScope<TEvent>;
-    return {
-      scope: source,
-      event: selector,
-    };
-  }
-
-  return {
-    scope: selector.scope,
-    event: selector.event,
-  };
-};
-
-export const checkEventScope = <
-  TEvent extends AssistantEvent,
-  TExpectedScope extends AssistantEventScope<AssistantEvent>,
->(
-  expectedScope: TExpectedScope,
-  scope: AssistantEventScope<TEvent>,
-  _event: TEvent,
-): _event is Extract<TEvent, `${SourceByScope<TExpectedScope>}.${string}`> => {
-  return scope === expectedScope;
-};
-
-export type AssistantEventCallback<TEvent extends AssistantEvent> = (
-  payload: AssistantEventMap[TEvent],
-) => void;