@assistant-ui/react 0.12.10 → 0.12.11

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

@@ -1,218 +0,0 @@
-import {
-  ModelContextProvider,
-  ModelContext,
-} from "../../model-context/ModelContextTypes";
-import { Unsubscribe } from "../../types/Unsubscribe";
-import { Tool } from "assistant-stream";
-import {
-  FrameMessage,
-  FRAME_MESSAGE_CHANNEL,
-  SerializedModelContext,
-  SerializedTool,
-} from "./AssistantFrameTypes";
-
-/**
- * Deserializes tools from JSON Schema format back to Tool objects
- */
-const deserializeTool = (serializedTool: SerializedTool): Tool<any, any> =>
-  ({
-    parameters: serializedTool.parameters,
-    ...(serializedTool.description && {
-      description: serializedTool.description,
-    }),
-    ...(serializedTool.disabled !== undefined && {
-      disabled: serializedTool.disabled,
-    }),
-    ...(serializedTool.type && { type: serializedTool.type }),
-  }) as Tool<any, any>;
-
-/**
- * Deserializes a ModelContext from transmission format
- */
-const deserializeModelContext = (
-  serialized: SerializedModelContext,
-): ModelContext => ({
-  ...(serialized.system !== undefined && { system: serialized.system }),
-  ...(serialized.tools && {
-    tools: Object.fromEntries(
-      Object.entries(serialized.tools).map(([name, tool]) => [
-        name,
-        deserializeTool(tool),
-      ]),
-    ),
-  }),
-});
-
-/**
- * AssistantFrameHost - Runs in the parent window and acts as a ModelContextProvider
- * that receives context from an iframe's AssistantFrameProvider.
- *
- * Usage example:
- * ```typescript
- * // In parent window
- * const frameHost = new AssistantFrameHost(iframeWindow);
- *
- * // Register with assistant runtime
- * const runtime = useAssistantRuntime();
- * runtime.registerModelContextProvider(frameHost);
- *
- * // The assistant now has access to tools from the iframe
- * ```
- */
-export class AssistantFrameHost implements ModelContextProvider {
-  private _context: ModelContext = {};
-  private _subscribers = new Set<() => void>();
-  private _pendingRequests = new Map<
-    string,
-    {
-      resolve: (value: any) => void;
-      reject: (error: any) => void;
-    }
-  >();
-  private _requestCounter = 0;
-  private _iframeWindow: Window;
-  private _targetOrigin: string;
-
-  constructor(iframeWindow: Window, targetOrigin: string = "*") {
-    this._iframeWindow = iframeWindow;
-    this._targetOrigin = targetOrigin;
-
-    this.handleMessage = this.handleMessage.bind(this);
-    window.addEventListener("message", this.handleMessage);
-
-    // Request initial context
-    this.requestContext();
-  }
-
-  private handleMessage(event: MessageEvent) {
-    // Security: Validate origin and source
-    if (this._targetOrigin !== "*" && event.origin !== this._targetOrigin)
-      return;
-    if (event.source !== this._iframeWindow) return;
-    if (event.data?.channel !== FRAME_MESSAGE_CHANNEL) return;
-
-    const message = event.data.message as FrameMessage;
-
-    switch (message.type) {
-      case "model-context-update": {
-        this.updateContext(message.context);
-        break;
-      }
-
-      case "tool-result": {
-        const pending = this._pendingRequests.get(message.id);
-        if (pending) {
-          if (message.error) {
-            pending.reject(new Error(message.error));
-          } else {
-            pending.resolve(message.result);
-          }
-          this._pendingRequests.delete(message.id);
-        }
-        break;
-      }
-    }
-  }
-
-  private updateContext(serializedContext: SerializedModelContext) {
-    const context = deserializeModelContext(serializedContext);
-    this._context = {
-      ...context,
-      tools:
-        context.tools &&
-        Object.fromEntries(
-          Object.entries(context.tools).map(([name, tool]) => [
-            name,
-            {
-              ...tool,
-              execute: (args: any) => this.callTool(name, args),
-            } as Tool<any, any>,
-          ]),
-        ),
-    };
-    this.notifySubscribers();
-  }
-
-  private callTool(toolName: string, args: any): Promise<any> {
-    return this.sendRequest(
-      {
-        type: "tool-call",
-        id: `tool-${this._requestCounter++}`,
-        toolName,
-        args,
-      },
-      30000,
-      `Tool call "${toolName}" timed out`,
-    );
-  }
-
-  private sendRequest<T extends FrameMessage & { id: string }>(
-    message: T,
-    timeout = 30000,
-    timeoutMessage = "Request timed out",
-  ): Promise<any> {
-    return new Promise((resolve, reject) => {
-      this._pendingRequests.set(message.id, { resolve, reject });
-
-      this._iframeWindow.postMessage(
-        { channel: FRAME_MESSAGE_CHANNEL, message },
-        this._targetOrigin,
-      );
-
-      const timeoutId = setTimeout(() => {
-        const pending = this._pendingRequests.get(message.id);
-        if (pending) {
-          pending.reject(new Error(timeoutMessage));
-          this._pendingRequests.delete(message.id);
-        }
-      }, timeout);
-
-      // Store original resolve/reject with timeout cleanup
-      const originalResolve = this._pendingRequests.get(message.id)!.resolve;
-      const originalReject = this._pendingRequests.get(message.id)!.reject;
-
-      this._pendingRequests.set(message.id, {
-        resolve: (value: any) => {
-          clearTimeout(timeoutId);
-          originalResolve(value);
-        },
-        reject: (error: any) => {
-          clearTimeout(timeoutId);
-          originalReject(error);
-        },
-      });
-    });
-  }
-
-  private requestContext() {
-    // Request current context from iframe
-    this._iframeWindow.postMessage(
-      {
-        channel: FRAME_MESSAGE_CHANNEL,
-        message: {
-          type: "model-context-request",
-        } as FrameMessage,
-      },
-      this._targetOrigin,
-    );
-  }
-
-  private notifySubscribers() {
-    this._subscribers.forEach((callback) => callback());
-  }
-
-  getModelContext(): ModelContext {
-    return this._context;
-  }
-
-  subscribe(callback: () => void): Unsubscribe {
-    this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
-  }
-
-  dispose() {
-    window.removeEventListener("message", this.handleMessage);
-    this._subscribers.clear();
-    this._pendingRequests.clear();
-  }
-}

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

@@ -1,230 +0,0 @@
-import {
-  ModelContextProvider,
-  ModelContext,
-} from "../../model-context/ModelContextTypes";
-import { Unsubscribe } from "../../types/Unsubscribe";
-import { Tool } from "assistant-stream";
-import { z } from "zod";
-import {
-  FrameMessage,
-  FRAME_MESSAGE_CHANNEL,
-  SerializedModelContext,
-  SerializedTool,
-} from "./AssistantFrameTypes";
-
-/**
- * Converts tools to JSON Schema format for serialization
- */
-const serializeTool = (tool: Tool<any, any>): SerializedTool => ({
-  ...(tool.description && { description: tool.description }),
-  parameters:
-    tool.parameters instanceof z.ZodType
-      ? ((z as any).toJSONSchema?.(tool.parameters) ?? tool.parameters)
-      : tool.parameters,
-  ...(tool.disabled !== undefined && { disabled: tool.disabled }),
-  ...(tool.type && { type: tool.type }),
-});
-
-/**
- * Serializes a ModelContext for transmission across iframe boundary
- */
-const serializeModelContext = (
-  context: ModelContext,
-): SerializedModelContext => ({
-  ...(context.system !== undefined && { system: context.system }),
-  ...(context.tools && {
-    tools: Object.fromEntries(
-      Object.entries(context.tools).map(([name, tool]) => [
-        name,
-        serializeTool(tool),
-      ]),
-    ),
-  }),
-});
-
-/**
- * AssistantFrameProvider - Runs inside an iframe and provides ModelContextProviders
- * to the parent window's AssistantFrameHost.
- *
- * Usage example:
- * ```typescript
- * // Inside the iframe
- * // Add model context providers
- * const registry = new ModelContextRegistry();
- * AssistantFrameProvider.addModelContextProvider(registry);
- *
- * // Add tools to registry
- * registry.addTool({
- *   toolName: "search",
- *   description: "Search the web",
- *   parameters: z.object({ query: z.string() }),
- *   execute: async (args) => {
- *     // Tool implementation runs in iframe
- *     return { results: ["..."] };
- *   }
- * });
- * ```
- */
-export class AssistantFrameProvider {
-  private static _instance: AssistantFrameProvider | null = null;
-
-  private _providers = new Set<ModelContextProvider>();
-  private _providerUnsubscribes = new Map<
-    ModelContextProvider,
-    Unsubscribe | undefined
-  >();
-  private _targetOrigin: string;
-
-  private constructor(targetOrigin: string = "*") {
-    this._targetOrigin = targetOrigin;
-    this.handleMessage = this.handleMessage.bind(this);
-    window.addEventListener("message", this.handleMessage);
-
-    // Send initial update on initialization
-    setTimeout(() => this.broadcastUpdate(), 0);
-  }
-
-  private static getInstance(targetOrigin?: string): AssistantFrameProvider {
-    if (!AssistantFrameProvider._instance) {
-      AssistantFrameProvider._instance = new AssistantFrameProvider(
-        targetOrigin,
-      );
-    }
-    return AssistantFrameProvider._instance;
-  }
-
-  private handleMessage(event: MessageEvent) {
-    // Security: Validate origin if specified
-    if (this._targetOrigin !== "*" && event.origin !== this._targetOrigin)
-      return;
-    if (event.data?.channel !== FRAME_MESSAGE_CHANNEL) return;
-
-    const message = event.data.message as FrameMessage;
-
-    switch (message.type) {
-      case "model-context-request":
-        // Respond with current context
-        this.sendMessage(event, {
-          type: "model-context-update",
-          context: serializeModelContext(this.getModelContext()),
-        });
-        break;
-
-      case "tool-call":
-        this.handleToolCall(message, event);
-        break;
-    }
-  }
-
-  private async handleToolCall(
-    message: Extract<FrameMessage, { type: "tool-call" }>,
-    event: MessageEvent,
-  ) {
-    const tool = this.getModelContext().tools?.[message.toolName];
-
-    let result: any;
-    let error: string | undefined;
-
-    if (!tool) {
-      error = `Tool "${message.toolName}" not found`;
-    } else {
-      try {
-        result = tool.execute
-          ? await tool.execute(message.args, {
-              toolCallId: message.id,
-              abortSignal: new AbortController().signal,
-              human: async () => {
-                throw new Error(
-                  "Tool human input is not supported in frame context",
-                );
-              },
-            })
-          : undefined;
-      } catch (e) {
-        error = e instanceof Error ? e.message : String(e);
-      }
-    }
-
-    this.sendMessage(event, {
-      type: "tool-result",
-      id: message.id,
-      ...(error ? { error } : { result }),
-    });
-  }
-
-  private sendMessage(event: MessageEvent, message: FrameMessage) {
-    event.source?.postMessage(
-      { channel: FRAME_MESSAGE_CHANNEL, message },
-      { targetOrigin: event.origin },
-    );
-  }
-
-  private getModelContext(): ModelContext {
-    const contexts = Array.from(this._providers).map((p) =>
-      p.getModelContext(),
-    );
-
-    return contexts.reduce(
-      (merged, context) => ({
-        system: context.system
-          ? merged.system
-            ? `${merged.system}\n\n${context.system}`
-            : context.system
-          : merged.system,
-        tools: { ...(merged.tools || {}), ...(context.tools || {}) },
-      }),
-      {} as ModelContext,
-    );
-  }
-
-  private broadcastUpdate() {
-    // Always broadcast to parent window
-    if (window.parent && window.parent !== window) {
-      const updateMessage: FrameMessage = {
-        type: "model-context-update",
-        context: serializeModelContext(this.getModelContext()),
-      };
-
-      window.parent.postMessage(
-        { channel: FRAME_MESSAGE_CHANNEL, message: updateMessage },
-        this._targetOrigin,
-      );
-    }
-  }
-
-  static addModelContextProvider(
-    provider: ModelContextProvider,
-    targetOrigin?: string,
-  ): Unsubscribe {
-    const instance = AssistantFrameProvider.getInstance(targetOrigin);
-    instance._providers.add(provider);
-
-    const unsubscribe = provider.subscribe?.(() => instance.broadcastUpdate());
-    if (unsubscribe) {
-      instance._providerUnsubscribes.set(provider, unsubscribe);
-    }
-
-    instance.broadcastUpdate();
-
-    return () => {
-      instance._providers.delete(provider);
-      instance._providerUnsubscribes.get(provider)?.();
-      instance._providerUnsubscribes.delete(provider);
-      instance.broadcastUpdate();
-    };
-  }
-
-  static dispose() {
-    if (AssistantFrameProvider._instance) {
-      const instance = AssistantFrameProvider._instance;
-      window.removeEventListener("message", instance.handleMessage);
-
-      // Unsubscribe from all providers
-      instance._providerUnsubscribes.forEach((unsubscribe) => unsubscribe?.());
-      instance._providerUnsubscribes.clear();
-      instance._providers.clear();
-
-      AssistantFrameProvider._instance = null;
-    }
-  }
-}

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

@@ -1,40 +0,0 @@
-export type SerializedTool = {
-  description?: string;
-  parameters: any; // JSON Schema
-  disabled?: boolean;
-  type?: string;
-};
-
-export type SerializedModelContext = {
-  system?: string;
-  tools?: Record<string, SerializedTool>;
-};
-
-export type FrameMessageType =
-  | "model-context-request"
-  | "model-context-update"
-  | "tool-call"
-  | "tool-result";
-
-export type FrameMessage =
-  | {
-      type: "model-context-request";
-    }
-  | {
-      type: "model-context-update";
-      context: SerializedModelContext;
-    }
-  | {
-      type: "tool-call";
-      id: string;
-      toolName: string;
-      args: unknown;
-    }
-  | {
-      type: "tool-result";
-      id: string;
-      result?: unknown;
-      error?: string;
-    };
-
-export const FRAME_MESSAGE_CHANNEL = "assistant-ui-frame";

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

@@ -1,165 +0,0 @@
-import { Tool } from "assistant-stream";
-import {
-  ModelContext,
-  ModelContextProvider,
-  mergeModelContexts,
-} from "../../model-context/ModelContextTypes";
-import { Unsubscribe } from "../../types/Unsubscribe";
-import {
-  ModelContextRegistryToolHandle,
-  ModelContextRegistryInstructionHandle,
-  ModelContextRegistryProviderHandle,
-} from "./ModelContextRegistryHandles";
-import type { AssistantToolProps } from "../../model-context/useAssistantTool";
-import type { AssistantInstructionsConfig } from "../../model-context/useAssistantInstructions";
-
-export class ModelContextRegistry implements ModelContextProvider {
-  private _tools = new Map<symbol, AssistantToolProps<any, any>>();
-  private _instructions = new Map<symbol, string>();
-  private _providers = new Map<symbol, ModelContextProvider>();
-  private _subscribers = new Set<() => void>();
-  private _providerUnsubscribes = new Map<symbol, Unsubscribe | undefined>();
-
-  getModelContext(): ModelContext {
-    // Merge instructions
-    const instructions = Array.from(this._instructions.values()).filter(
-      Boolean,
-    );
-
-    const system =
-      instructions.length > 0 ? instructions.join("\n\n") : undefined;
-
-    // Collect tools
-    const tools: Record<string, Tool<any, any>> = {};
-    for (const toolProps of this._tools.values()) {
-      const { toolName, render, ...tool } = toolProps;
-      tools[toolName] = tool;
-    }
-
-    // Merge provider contexts
-    const providerContexts = mergeModelContexts(
-      new Set(this._providers.values()),
-    );
-
-    // Combine everything
-    const context: ModelContext = {
-      system,
-      tools: Object.keys(tools).length > 0 ? tools : undefined,
-    };
-
-    // Merge with provider contexts
-    if (providerContexts.system) {
-      context.system = context.system
-        ? `${context.system}\n\n${providerContexts.system}`
-        : providerContexts.system;
-    }
-
-    if (providerContexts.tools) {
-      context.tools = { ...(context.tools || {}), ...providerContexts.tools };
-    }
-
-    if (providerContexts.callSettings) {
-      context.callSettings = providerContexts.callSettings;
-    }
-
-    if (providerContexts.config) {
-      context.config = providerContexts.config;
-    }
-
-    return context;
-  }
-
-  subscribe(callback: () => void): Unsubscribe {
-    this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
-  }
-
-  private notifySubscribers(): void {
-    for (const callback of this._subscribers) {
-      callback();
-    }
-  }
-
-  addTool<TArgs extends Record<string, unknown>, TResult>(
-    tool: AssistantToolProps<TArgs, TResult>,
-  ): ModelContextRegistryToolHandle<TArgs, TResult> {
-    const id = Symbol();
-
-    this._tools.set(id, tool);
-    this.notifySubscribers();
-
-    return {
-      update: (newTool: AssistantToolProps<TArgs, TResult>) => {
-        if (this._tools.has(id)) {
-          this._tools.set(id, newTool);
-          this.notifySubscribers();
-        }
-      },
-      remove: () => {
-        this._tools.delete(id);
-        this.notifySubscribers();
-      },
-    };
-  }
-
-  addInstruction(
-    config: string | AssistantInstructionsConfig,
-  ): ModelContextRegistryInstructionHandle {
-    const id = Symbol();
-
-    const instruction =
-      typeof config === "string" ? config : config.instruction;
-    const disabled = typeof config === "object" ? config.disabled : false;
-
-    if (!disabled) {
-      this._instructions.set(id, instruction);
-      this.notifySubscribers();
-    }
-
-    return {
-      update: (newConfig: string | AssistantInstructionsConfig) => {
-        const newInstruction =
-          typeof newConfig === "string" ? newConfig : newConfig.instruction;
-        const newDisabled =
-          typeof newConfig === "object" ? newConfig.disabled : false;
-
-        if (newDisabled) {
-          this._instructions.delete(id);
-        } else {
-          this._instructions.set(id, newInstruction);
-        }
-        this.notifySubscribers();
-      },
-      remove: () => {
-        this._instructions.delete(id);
-        this.notifySubscribers();
-      },
-    };
-  }
-
-  addProvider(
-    provider: ModelContextProvider,
-  ): ModelContextRegistryProviderHandle {
-    const id = Symbol();
-
-    this._providers.set(id, provider);
-
-    // Subscribe to provider changes
-    const unsubscribe = provider.subscribe?.(() => {
-      this.notifySubscribers();
-    });
-    this._providerUnsubscribes.set(id, unsubscribe);
-
-    this.notifySubscribers();
-
-    return {
-      remove: () => {
-        this._providers.delete(id);
-        const unsubscribe = this._providerUnsubscribes.get(id);
-        unsubscribe?.();
-        this._providerUnsubscribes.delete(id);
-        this.notifySubscribers();
-      },
-    };
-  }
-}

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

@@ -1,19 +0,0 @@
-import type { AssistantToolProps } from "../../model-context/useAssistantTool";
-import type { AssistantInstructionsConfig } from "../../model-context/useAssistantInstructions";
-
-export interface ModelContextRegistryToolHandle<
-  TArgs extends Record<string, unknown> = any,
-  TResult = any,
-> {
-  update(tool: AssistantToolProps<TArgs, TResult>): void;
-  remove(): void;
-}
-
-export interface ModelContextRegistryInstructionHandle {
-  update(config: string | AssistantInstructionsConfig): void;
-  remove(): void;
-}
-
-export interface ModelContextRegistryProviderHandle {
-  remove(): void;
-}

package/src/model-context/tool.ts

@@ -1,9 +0,0 @@
-import { Tool } from "assistant-stream";
-
-// TODO re-add the inferrence of the parameters
-
-export function tool<TArgs extends Record<string, unknown>, TResult = any>(
-  tool: Tool<TArgs, TResult>,
-): Tool<TArgs, TResult> {
-  return tool;
-}