@mcp-b/embedded-agent 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1153 @@
+import { AssistantRuntime, ThreadMessageLike, ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { UIDataTypes, UIMessage, UITools } from "ai";
+import * as react0 from "react";
+import { ComponentPropsWithRef, FC, HTMLAttributes, ReactNode } from "react";
+import { ClassValue } from "clsx";
+import * as react_jsx_runtime5 from "react/jsx-runtime";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { VariantProps } from "class-variance-authority";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import * as class_variance_authority_types0 from "class-variance-authority/types";
+import { CallToolResult, GetPromptResult, MCPConnectionState, MCPSource, MCPSourceConfig, Prompt, ReadResourceResult, Resource, ResourceTemplate, SamplingHandler, Tool as Tool$1, ToolWithSource } from "@mcp-b/cloud-mirror-types";
+import { AgentChatState, PendingTool } from "@mcp-b/agents";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+//#region src/web-component.d.ts
+
+/**
+ * Props for the EmbeddedAgent React component
+ *
+ * These props map to HTML attributes in kebab-case when used as a web component:
+ * - appId -> app-id
+ * - apiBase -> api-base
+ * - tokenEndpoint -> token-endpoint
+ * - autoConnectLocal -> auto-connect-local
+ */
+interface EmbeddedAgentProps {
+  /** Your app/workspace ID */
+  appId: string;
+  /** API base URL for your WebMCP worker */
+  apiBase?: string;
+  /** Voice mode token endpoint (defaults to {apiBase}/api/realtime/session) */
+  tokenEndpoint?: string;
+  /** Auto-connect to local MCP source (default: true) */
+  autoConnectLocal?: boolean;
+  /** Callback when tools are updated */
+  onToolsChange?: (tools: unknown[]) => void;
+  /** Callback when voice mode errors */
+  onVoiceError?: (error: string) => void;
+  /** Callback when voice mode connects */
+  onVoiceConnect?: () => void;
+  /** Callback when voice mode disconnects */
+  onVoiceDisconnect?: (duration: number) => void;
+}
+/**
+ * EmbeddedAgent React Component
+ *
+ * A fully self-contained chat widget with MCP tool support and optional voice mode.
+ * Can be used as a React component or converted to a web component.
+ */
+declare const EmbeddedAgent: FC<EmbeddedAgentProps>;
+/**
+ * Web Component Definition
+ *
+ * Converts EmbeddedAgent to a custom element that can be used in any HTML page.
+ * Attributes are automatically converted from kebab-case to camelCase props.
+ */
+declare const WebMCPAgentElement: CustomElementConstructor;
+/**
+ * Register the custom element
+ *
+ * Call this function to register the <webmcp-agent> custom element.
+ * This is automatically called when importing the web-component entry point.
+ * Styles are automatically injected into the document head.
+ */
+declare function registerWebMCPAgent(tagName?: string): void;
+//#endregion
+//#region src/components/assistant-modal.d.ts
+declare const AssistantModal: FC;
+//#endregion
+//#region src/components/thread-with-voice.d.ts
+declare const ThreadWithVoice: FC;
+//#endregion
+//#region src/components/Thread.d.ts
+declare const Thread: FC;
+//#endregion
+//#region src/components/AssistantMessage.d.ts
+declare const AssistantMessage: FC;
+//#endregion
+//#region src/components/UserMessage.d.ts
+declare const UserMessage: FC;
+//#endregion
+//#region src/components/Composer.d.ts
+declare const Composer: FC;
+//#endregion
+//#region src/components/markdown-text.d.ts
+declare const MarkdownText: react0.MemoExoticComponent<() => react_jsx_runtime5.JSX.Element>;
+//#endregion
+//#region src/components/tool-fallback.d.ts
+declare const ToolFallback: ToolCallMessagePartComponent;
+//#endregion
+//#region src/components/attachment.d.ts
+declare const UserMessageAttachments: FC;
+declare const ComposerAttachments: FC;
+declare const ComposerAddAttachment: FC;
+//#endregion
+//#region src/services/realtime/types.d.ts
+/**
+ * Types for OpenAI Realtime API integration
+ */
+interface RealtimeConfig {
+  model?: string;
+  voice?: string;
+  apiUrl?: string;
+  tokenEndpoint?: string;
+}
+interface RealtimeSession {
+  pc: RTCPeerConnection;
+  dataChannel: RTCDataChannel;
+  audioElement: HTMLAudioElement;
+  localStream: MediaStream | null;
+  remoteStream: MediaStream | null;
+  cleanup: () => void;
+}
+type EventCallback = (data: unknown) => void;
+interface AudioLevelData {
+  micLevel: number;
+  micFrequency: number[];
+  speakerLevel: number;
+  speakerFrequency: number[];
+}
+interface TranscriptData {
+  type: 'user' | 'assistant';
+  text: string;
+  isDone: boolean;
+}
+interface ToolCallData {
+  status: 'started' | 'completed';
+  toolName: string;
+  error?: string;
+}
+interface VoiceModeState {
+  isActive: boolean;
+  isConnecting: boolean;
+  isMuted: boolean;
+  isError: boolean;
+  connectionState: string;
+  audioLevel?: AudioLevelData;
+  transcript?: TranscriptData;
+  toolCall?: ToolCallData;
+  error?: string;
+}
+/**
+ * Session state event data from the realtime service
+ */
+interface SessionStateEventData {
+  state: 'connecting' | 'connected' | 'disconnected' | 'error';
+  isActive: boolean;
+  isMuted: boolean;
+  durationSeconds?: number;
+}
+/**
+ * User transcript event data
+ */
+interface UserTranscriptEventData {
+  text: string;
+}
+/**
+ * Assistant transcript streaming event data
+ */
+interface AssistantTranscriptEventData {
+  delta?: string;
+  transcript?: string;
+}
+/**
+ * Tool call started event data
+ */
+interface ToolCallStartedEventData {
+  name: string;
+}
+/**
+ * Tool call completed event data
+ */
+interface ToolCallCompletedEventData {
+  name: string;
+  error?: string;
+}
+/**
+ * Error event data
+ */
+interface ErrorEventData {
+  error?: string;
+  message?: string;
+  type?: string;
+}
+/**
+ * Type guard for SessionStateEventData
+ */
+declare function isSessionStateEventData(data: unknown): data is SessionStateEventData;
+/**
+ * Type guard for UserTranscriptEventData
+ */
+declare function isUserTranscriptEventData(data: unknown): data is UserTranscriptEventData;
+/**
+ * Type guard for AssistantTranscriptEventData
+ */
+declare function isAssistantTranscriptEventData(data: unknown): data is AssistantTranscriptEventData;
+/**
+ * Type guard for ToolCallStartedEventData
+ */
+declare function isToolCallStartedEventData(data: unknown): data is ToolCallStartedEventData;
+/**
+ * Type guard for ToolCallCompletedEventData
+ */
+declare function isToolCallCompletedEventData(data: unknown): data is ToolCallCompletedEventData;
+/**
+ * Type guard for ErrorEventData
+ */
+declare function isErrorEventData(data: unknown): data is ErrorEventData;
+/**
+ * Type guard for AudioLevelData
+ */
+declare function isAudioLevelData(data: unknown): data is AudioLevelData;
+//#endregion
+//#region src/services/realtime/tool-manager.d.ts
+interface RegisteredTool {
+  name: string;
+  description: string;
+  inputSchema?: Record<string, unknown>;
+}
+type ToolExecutor = (name: string, args: Record<string, unknown>) => Promise<unknown>;
+//#endregion
+//#region src/services/realtime/openai-realtime-service.d.ts
+/**
+ * OpenAI Realtime API Service
+ *
+ * Manages voice conversations with OpenAI's Realtime API,
+ * including WebRTC connections, tool integration, and message handling.
+ */
+declare class OpenAIRealtimeService {
+  private session;
+  private webrtcManager;
+  private toolManager;
+  private messageHandler;
+  private eventEmitter;
+  private muted;
+  private lastState;
+  private localAnalyzer;
+  private remoteAnalyzer;
+  private visualizationInterval;
+  private sessionStartTime;
+  private onToolsChangedCallback;
+  constructor(tokenEndpoint: string);
+  /**
+   * Set the tools available for the voice session
+   */
+  setTools(tools: RegisteredTool[]): void;
+  /**
+   * Set the tool executor function
+   */
+  setToolExecutor(executor: ToolExecutor): void;
+  /**
+   * Register callback for when tools change
+   */
+  onToolsChanged(callback: () => void): void;
+  /**
+   * Start a new realtime session
+   */
+  startSession(config?: RealtimeConfig): Promise<RealtimeSession>;
+  /**
+   * Stop the current session
+   */
+  stopSession(): void;
+  /**
+   * Send a text message to the assistant
+   */
+  sendUserMessage(text: string): void;
+  /**
+   * Check if session is active
+   */
+  isSessionActive(): boolean;
+  /**
+   * Get the local audio stream
+   */
+  getLocalStream(): MediaStream | null;
+  /**
+   * Get the remote audio stream
+   */
+  getRemoteStream(): MediaStream | null;
+  /**
+   * Toggle audio mute
+   */
+  toggleMute(muted: boolean): void;
+  /**
+   * Event handling
+   */
+  on(event: string, callback: EventCallback): void;
+  off(event: string, callback: EventCallback): void;
+  getSessionStatus(): {
+    state: 'connecting' | 'connected' | 'disconnected' | 'error';
+    isActive: boolean;
+    isMuted: boolean;
+  };
+  /**
+   * Private methods
+   */
+  private setupDataChannel;
+  private setupPeerConnectionMonitoring;
+  private configureSession;
+  private updateSessionTools;
+  private getSessionInstructions;
+  private handleSessionError;
+  private initializeLocalAnalyzer;
+  private initializeRemoteAnalyzer;
+  private startAudioVisualization;
+  private emitSessionState;
+}
+//#endregion
+//#region src/components/voice-indicator.d.ts
+interface VoiceIndicatorProps {
+  isActive: boolean;
+  isConnecting: boolean;
+  isMuted: boolean;
+  audioLevel?: AudioLevelData;
+  toolCall?: ToolCallData;
+  onStart: () => void;
+  onStop: () => void;
+  onToggleMute: () => void;
+  className?: string;
+}
+declare function VoiceIndicator({
+  isActive,
+  isConnecting,
+  isMuted,
+  audioLevel,
+  toolCall,
+  onStart,
+  onStop,
+  onToggleMute,
+  className
+}: VoiceIndicatorProps): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/live-waveform.d.ts
+type LiveWaveformProps = HTMLAttributes<HTMLDivElement> & {
+  active?: boolean;
+  processing?: boolean;
+  barWidth?: number;
+  barGap?: number;
+  barRadius?: number;
+  barColor?: string;
+  fadeEdges?: boolean;
+  fadeWidth?: number;
+  height?: string | number;
+  sensitivity?: number;
+  smoothingTimeConstant?: number;
+  mode?: 'scrolling' | 'static';
+  /** Manual audio level (0-1) instead of using microphone */
+  manualAudioLevel?: number;
+};
+declare const LiveWaveform: ({
+  active,
+  processing,
+  barWidth,
+  barGap,
+  barRadius,
+  barColor,
+  fadeEdges,
+  fadeWidth,
+  height,
+  sensitivity,
+  mode,
+  manualAudioLevel,
+  className,
+  ...props
+}: LiveWaveformProps) => react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/realtime-tool-card.d.ts
+interface RealtimeToolCardProps {
+  toolCall: ToolCallData;
+  className?: string;
+}
+/**
+ * Displays a tool call status card for voice mode.
+ * Shows running, success, or error state with the tool name.
+ */
+declare function RealtimeToolCard({
+  toolCall,
+  className
+}: RealtimeToolCardProps): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/MCPToolRegistry.d.ts
+/**
+ * Tool registry that registers all MCP tools with assistant-ui.
+ * Routes tool calls automatically based on _sourceId.
+ */
+declare const MCPToolRegistry: FC;
+//#endregion
+//#region src/components/RemoteMCPSettings.d.ts
+declare const RemoteMCPSettings: FC;
+//#endregion
+//#region src/components/button.d.ts
+interface ButtonProps extends react0.ComponentProps<'button'>, VariantProps<typeof buttonVariants> {
+  asChild?: boolean;
+}
+declare const buttonVariants: (props?: ({
+  variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+  size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types0.ClassProp) | undefined) => string;
+declare function Button({
+  className,
+  variant,
+  size,
+  asChild,
+  ...props
+}: react0.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+  asChild?: boolean;
+}): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/avatar.d.ts
+declare function Avatar({
+  className,
+  ...props
+}: react0.ComponentProps<typeof AvatarPrimitive.Root>): react_jsx_runtime5.JSX.Element;
+declare function AvatarImage({
+  className,
+  ...props
+}: react0.ComponentProps<typeof AvatarPrimitive.Image>): react_jsx_runtime5.JSX.Element;
+declare function AvatarFallback({
+  className,
+  ...props
+}: react0.ComponentProps<typeof AvatarPrimitive.Fallback>): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/badge.d.ts
+declare const badgeVariants: (props?: ({
+  variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_types0.ClassProp) | undefined) => string;
+interface BadgeProps extends react0.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {}
+declare function Badge({
+  className,
+  variant,
+  ...props
+}: BadgeProps): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/dialog.d.ts
+declare function Dialog({
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Root>): react_jsx_runtime5.JSX.Element;
+declare function DialogTrigger({
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Trigger>): react_jsx_runtime5.JSX.Element;
+declare function DialogPortal({
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Portal>): react_jsx_runtime5.JSX.Element;
+declare function DialogClose({
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Close>): react_jsx_runtime5.JSX.Element;
+declare function DialogOverlay({
+  className,
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Overlay>): react_jsx_runtime5.JSX.Element;
+declare function DialogContent({
+  className,
+  children,
+  showCloseButton,
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Content> & {
+  showCloseButton?: boolean;
+}): react_jsx_runtime5.JSX.Element;
+declare function DialogHeader({
+  className,
+  ...props
+}: react0.ComponentProps<'div'>): react_jsx_runtime5.JSX.Element;
+declare function DialogFooter({
+  className,
+  ...props
+}: react0.ComponentProps<'div'>): react_jsx_runtime5.JSX.Element;
+declare function DialogTitle({
+  className,
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Title>): react_jsx_runtime5.JSX.Element;
+declare function DialogDescription({
+  className,
+  ...props
+}: react0.ComponentProps<typeof DialogPrimitive.Description>): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/scroll-area.d.ts
+declare function ScrollArea({
+  className,
+  children,
+  ...props
+}: react0.ComponentProps<typeof ScrollAreaPrimitive.Root>): react_jsx_runtime5.JSX.Element;
+declare function ScrollBar({
+  className,
+  orientation,
+  ...props
+}: react0.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/separator.d.ts
+declare function Separator({
+  className,
+  orientation,
+  decorative,
+  ...props
+}: react0.ComponentProps<typeof SeparatorPrimitive.Root>): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/tooltip.d.ts
+declare function TooltipProvider({
+  delayDuration,
+  ...props
+}: react0.ComponentProps<typeof TooltipPrimitive.Provider>): react_jsx_runtime5.JSX.Element;
+declare function Tooltip({
+  ...props
+}: react0.ComponentProps<typeof TooltipPrimitive.Root>): react_jsx_runtime5.JSX.Element;
+declare function TooltipTrigger({
+  ...props
+}: react0.ComponentProps<typeof TooltipPrimitive.Trigger>): react_jsx_runtime5.JSX.Element;
+declare function TooltipContent({
+  className,
+  sideOffset,
+  children,
+  ...props
+}: react0.ComponentProps<typeof TooltipPrimitive.Content>): react_jsx_runtime5.JSX.Element;
+//#endregion
+//#region src/components/tooltip-icon-button.d.ts
+type TooltipIconButtonProps = ComponentPropsWithRef<typeof Button> & {
+  tooltip: string;
+  side?: 'top' | 'bottom' | 'left' | 'right';
+};
+declare const TooltipIconButton: react0.ForwardRefExoticComponent<Omit<TooltipIconButtonProps, "ref"> & react0.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/providers/MCPToolsProvider.d.ts
+/** Well-known source IDs */
+declare const SOURCE_LOCAL = "local";
+declare const SOURCE_REMOTE = "remote";
+/**
+ * MCP Tools Context Value
+ */
+interface MCPToolsContextValue {
+  /** All tools from all sources, tagged with _sourceId */
+  tools: ToolWithSource[];
+  /** All sources and their states */
+  sources: Map<string, MCPSource>;
+  /** Add a new source */
+  addSource: (id: string, config: MCPSourceConfig) => Promise<void>;
+  /** Remove a source */
+  removeSource: (id: string) => Promise<void>;
+  /** Get a specific source */
+  getSource: (id: string) => MCPSource | undefined;
+  /** Check if a source is connected */
+  isConnected: (id: string) => boolean;
+  /** Call a tool (auto-routes based on tool name lookup) */
+  callTool: (name: string, args: Record<string, unknown>) => Promise<CallToolResult>;
+  /** Call a tool on a specific source */
+  callToolOnSource: (sourceId: string, name: string, args: Record<string, unknown>) => Promise<CallToolResult>;
+}
+interface MCPToolsProviderProps {
+  children: ReactNode;
+  /** Auto-connect to same-tab source on mount (default: true) */
+  autoConnectLocal?: boolean;
+  /** Callback when tools change */
+  onToolsChange?: (tools: ToolWithSource[]) => void;
+}
+declare function MCPToolsProvider({
+  children,
+  autoConnectLocal,
+  onToolsChange
+}: MCPToolsProviderProps): react_jsx_runtime5.JSX.Element;
+/**
+ * Hook to access MCP Tools context
+ */
+declare function useMCPTools(): MCPToolsContextValue;
+/**
+ * Hook to optionally access MCP Tools context
+ */
+declare function useOptionalMCPTools(): MCPToolsContextValue | null;
+//#endregion
+//#region src/hooks/useVoiceMode.d.ts
+interface UseVoiceModeOptions {
+  /** Endpoint to get ephemeral tokens from */
+  tokenEndpoint: string;
+  /** Tools available for the voice session */
+  tools?: RegisteredTool[];
+  /** Tool executor function */
+  toolExecutor?: ToolExecutor;
+  /** Callback when session connects */
+  onConnect?: () => void;
+  /** Callback when session disconnects */
+  onDisconnect?: (durationSeconds: number) => void;
+  /** Callback when error occurs */
+  onError?: (error: string) => void;
+  /** Callback when user transcript is complete */
+  onUserTranscript?: (text: string) => void;
+  /** Callback when assistant transcript is complete */
+  onAssistantTranscript?: (text: string) => void;
+}
+interface UseVoiceModeReturn extends VoiceModeState {
+  /** Start voice session */
+  startSession: (config?: RealtimeConfig) => Promise<void>;
+  /** Stop voice session */
+  stopSession: () => void;
+  /** Toggle microphone mute */
+  toggleMute: (muted?: boolean) => void;
+  /** Send text message while in voice mode */
+  sendMessage: (text: string) => void;
+}
+declare function useVoiceMode(options: UseVoiceModeOptions): UseVoiceModeReturn;
+//#endregion
+//#region src/providers/VoiceModeProvider.d.ts
+/**
+ * Voice Mode Provider
+ *
+ * Provides voice mode state and controls to the component tree.
+ */
+interface VoiceModeContextValue extends UseVoiceModeReturn {
+  isSupported: boolean;
+}
+interface VoiceModeProviderProps {
+  children: ReactNode;
+  /** Backend endpoint for ephemeral tokens */
+  tokenEndpoint: string;
+  /** Tools available for voice mode */
+  tools?: RegisteredTool[];
+  /** Tool executor function */
+  toolExecutor?: ToolExecutor;
+  /** Callback when session connects */
+  onConnect?: () => void;
+  /** Callback when session disconnects */
+  onDisconnect?: (durationSeconds: number) => void;
+  /** Callback when error occurs */
+  onError?: (error: string) => void;
+  /** Callback when user transcript is complete */
+  onUserTranscript?: (text: string) => void;
+  /** Callback when assistant transcript is complete */
+  onAssistantTranscript?: (text: string) => void;
+}
+declare function VoiceModeProvider({
+  children,
+  tokenEndpoint,
+  tools,
+  toolExecutor,
+  onConnect,
+  onDisconnect,
+  onError,
+  onUserTranscript,
+  onAssistantTranscript
+}: VoiceModeProviderProps): react_jsx_runtime5.JSX.Element;
+/**
+ * Hook to access voice mode context
+ */
+declare function useVoiceModeContext(): VoiceModeContextValue;
+/**
+ * Hook to optionally access voice mode context (returns null if not in provider)
+ */
+declare function useOptionalVoiceModeContext(): VoiceModeContextValue | null;
+//#endregion
+//#region src/providers/ChatRuntimeProvider.d.ts
+interface ChatRuntimeProviderProps {
+  children: ReactNode;
+}
+/**
+ * Provider that sets up the Assistant UI runtime with Cloudflare Workers backend.
+ *
+ * This component integrates the Cloudflare Agents SDK with Assistant UI,
+ * handling message conversion, tool calls, and HITL (Human-in-the-Loop) approvals.
+ *
+ * @example
+ * ```tsx
+ * import { ChatRuntimeProvider, Thread } from '@mcp-b/webmcp-client';
+ *
+ * function App() {
+ *   return (
+ *     <ChatRuntimeProvider>
+ *       <Thread />
+ *     </ChatRuntimeProvider>
+ *   );
+ * }
+ * ```
+ */
+declare const ChatRuntimeProvider: FC<ChatRuntimeProviderProps>;
+//#endregion
+//#region src/hooks/useMCPSource.d.ts
+/**
+ * Options for the useMCPSource hook
+ */
+interface UseMCPSourceOptions {
+  /** Auto-connect on mount (default: true) */
+  autoConnect?: boolean;
+  /** Callback when tools are updated */
+  onToolsUpdate?: (tools: Tool$1[]) => void;
+  /** Callback when resources are updated */
+  onResourcesUpdate?: (resources: Resource[], templates: ResourceTemplate[]) => void;
+  /** Callback when prompts are updated */
+  onPromptsUpdate?: (prompts: Prompt[]) => void;
+  /** Callback when connection state changes */
+  onStateChange?: (state: MCPConnectionState) => void;
+  /** Callback on connection error */
+  onError?: (error: Error) => void;
+  /**
+   * Handler for sampling requests from the server.
+   * If provided, enables the sampling capability.
+   * The handler should call an LLM and return the response.
+   */
+  samplingHandler?: SamplingHandler;
+}
+/**
+ * Return value from the useMCPSource hook
+ */
+interface UseMCPSourceReturn {
+  /** MCP client instance */
+  client: Client | null;
+  /** Available tools from this source */
+  tools: Tool$1[];
+  /** Available resources from this source */
+  resources: Resource[];
+  /** Available resource templates from this source */
+  resourceTemplates: ResourceTemplate[];
+  /** Available prompts from this source */
+  prompts: Prompt[];
+  /** Connection state */
+  state: MCPConnectionState;
+  /** Whether connected and ready */
+  isConnected: boolean;
+  /** Connection error (if any) */
+  error: Error | null;
+  /** Connect to the MCP server */
+  connect: () => Promise<void>;
+  /** Disconnect from the MCP server */
+  disconnect: () => Promise<void>;
+  /** Call a tool on this source */
+  callTool: (name: string, args: Record<string, unknown>) => Promise<CallToolResult>;
+  /** Read a resource by URI */
+  readResource: (uri: string) => Promise<ReadResourceResult>;
+  /** Get a prompt with optional arguments */
+  getPrompt: (name: string, args?: Record<string, string>) => Promise<GetPromptResult>;
+  /** Refresh the list of tools */
+  refreshTools: () => Promise<void>;
+  /** Refresh the list of resources */
+  refreshResources: () => Promise<void>;
+  /** Refresh the list of prompts */
+  refreshPrompts: () => Promise<void>;
+}
+/**
+ * Unified hook for connecting to MCP sources.
+ * Works with both tab-based (same-tab, iframe) and HTTP/SSE-based (remote) sources.
+ * Supports the full MCP specification including tools, resources, prompts, and sampling.
+ */
+declare function useMCPSource(id: string, config: MCPSourceConfig, options?: UseMCPSourceOptions): UseMCPSourceReturn;
+//#endregion
+//#region src/hooks/useAgentChat.d.ts
+/**
+ * Tool definition for frontend execution.
+ * Tools with execute function auto-execute.
+ * Tools without execute require manual confirmation via addToolResult.
+ */
+interface FrontendTool<TInput = unknown, TOutput = unknown> {
+  /** Optional description for UI */
+  description?: string;
+  /** If provided, tool auto-executes. If omitted, requires manual confirmation. */
+  execute?: (input: TInput) => Promise<TOutput> | TOutput;
+}
+/**
+ * Map of tool names to tool definitions.
+ */
+type FrontendTools = Record<string, FrontendTool>;
+/**
+ * Agent connection interface (WebSocket-like).
+ */
+interface AgentConnection {
+  send: (data: string) => void;
+  addEventListener: (event: 'message', handler: (event: MessageEvent) => void) => void;
+  removeEventListener: (event: 'message', handler: (event: MessageEvent) => void) => void;
+  readyState?: number;
+}
+/**
+ * Options for useAgentChat hook.
+ */
+interface UseAgentChatOptions {
+  /** WebSocket connection to the agent */
+  agent: AgentConnection;
+  /** Frontend tools for execution */
+  tools?: FrontendTools;
+  /** Initial messages (optional, typically restored from sync) */
+  initialMessages?: UIMessage[];
+  /** Callback when tools need confirmation */
+  onToolsNeedConfirmation?: (tools: PendingTool[]) => void;
+  /** Callback when agent state changes */
+  onStateChange?: (state: AgentChatState) => void;
+}
+/**
+ * Return value from useAgentChat hook.
+ */
+interface UseAgentChatReturn {
+  /** Current messages */
+  messages: UIMessage[];
+  /** Set messages manually */
+  setMessages: (messages: UIMessage[]) => void;
+  /** Current input value */
+  input: string;
+  /** Set input value */
+  setInput: (input: string) => void;
+  /** Handle input submission */
+  handleSubmit: (e?: React.FormEvent) => void;
+  /** Send a message programmatically */
+  sendMessage: (content: string) => void;
+  /** Add tool result (for confirmation flow) */
+  addToolResult: (toolCallId: string, toolName: string, output: unknown) => void;
+  /** Current agent state */
+  agentState: AgentChatState;
+  /** Whether currently streaming */
+  isStreaming: boolean;
+  /** Tools awaiting confirmation */
+  pendingConfirmationTools: PendingTool[];
+  /** Clear chat history */
+  clearHistory: () => void;
+}
+/**
+ * React hook for DO-first streaming chat.
+ *
+ * Handles:
+ * - Message sending and receiving
+ * - State synchronization on reconnect
+ * - Automatic tool execution
+ * - Confirmation-required tool flow
+ */
+declare function useAgentChat(options: UseAgentChatOptions): UseAgentChatReturn;
+//#endregion
+//#region src/hooks/useCloudflareRuntime.d.ts
+/**
+ * Options for the useCloudflareRuntime hook.
+ */
+interface UseCloudflareRuntimeOptions {
+  /**
+   * The host for the Cloudflare Agent WebSocket connection.
+   * @default 'localhost:8787'
+   */
+  host?: string;
+  /**
+   * The agent binding name to connect to.
+   * @default 'TOOL_HUB'
+   */
+  agent?: string;
+  /**
+   * Frontend tools that can be executed by the client.
+   * Tools with an `execute` function will auto-execute.
+   * Tools without `execute` require manual confirmation via the UI.
+   */
+  tools?: FrontendTools;
+  /**
+   * Callback when tools need user confirmation.
+   * Called with the list of tools awaiting approval.
+   */
+  onToolsNeedConfirmation?: (tools: Array<{
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+  }>) => void;
+}
+/**
+ * Hook that provides Assistant UI runtime integration with Cloudflare Workers backend.
+ *
+ * This hook orchestrates the connection between the Assistant UI component library and
+ * a Cloudflare Workers agent backend with DO-first streaming. It handles:
+ *
+ * 1. **Agent Connection**: Establishes WebSocket connection to the Cloudflare Agent
+ *    running on the local development server or Cloudflare Workers backend.
+ *
+ * 2. **DO-First Streaming**: Messages are accumulated on the Durable Object, making
+ *    streaming refresh-safe. On reconnection, the client receives a sync message
+ *    with the full state including any in-progress streaming message.
+ *
+ * 3. **Frontend Tool Execution**: When the LLM requests tool calls, the agent sends
+ *    a tools_needed message. Tools with `execute` functions auto-run, while others
+ *    require manual confirmation through the UI.
+ *
+ * 4. **User Input Handling**: Processes new user messages from the Assistant UI composer
+ *    and sends them to the Cloudflare Agent for processing.
+ *
+ * 5. **Message Conversion**: Converts messages between the Vercel AI SDK format
+ *    (used by Cloudflare Agents) and the Assistant UI format using the converter utility.
+ *
+ * @param options - Configuration options for the runtime
+ * @returns Assistant UI runtime configured with Cloudflare Workers backend integration
+ *
+ * @example
+ * ```tsx
+ * function ChatApp() {
+ *   const runtime = useCloudflareRuntime({
+ *     host: 'localhost:8787',
+ *     tools: {
+ *       getWeather: {
+ *         execute: async (args) => {
+ *           const data = await fetchWeather(args.city);
+ *           return data;
+ *         }
+ *       }
+ *     }
+ *   });
+ *   return <Thread runtime={runtime} />;
+ * }
+ * ```
+ */
+declare function useCloudflareRuntime(options?: UseCloudflareRuntimeOptions): AssistantRuntime;
+//#endregion
+//#region src/hooks/useAssistantMCP.d.ts
+interface UseAssistantMCPOptions {
+  /** MCP tools to register */
+  tools: Tool[];
+  /** MCP client for executing tools */
+  client: Client;
+  /** Optional system prompt to inject */
+  systemPrompt?: string;
+}
+/**
+ * Registers MCP tools with the Assistant UI runtime so they can be invoked by the
+ * assistant without any additional indirection.
+ *
+ * Tools are registered as frontend tools with execute functions that call the MCP client.
+ *
+ * @param options - Configuration options
+ *
+ * @example
+ * ```tsx
+ * function ChatThread() {
+ *   const { client, tools } = useMcpClient();
+ *
+ *   useAssistantMCP({
+ *     tools,
+ *     client,
+ *     systemPrompt: 'You are a helpful assistant.',
+ *   });
+ *
+ *   return <Thread />;
+ * }
+ * ```
+ */
+declare function useAssistantMCP(options: UseAssistantMCPOptions): void;
+//#endregion
+//#region src/lib/utils.d.ts
+/**
+ * Merges Tailwind CSS classes with proper precedence handling.
+ * Combines clsx for conditional classes and tailwind-merge for deduplication.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+//#endregion
+//#region src/lib/converter.d.ts
+/**
+ * Converts an array of UI messages to the Assistant UI format used by the thread component.
+ *
+ * This function transforms messages from the Vercel/Cloudflare AI format to the format
+ * expected by Assistant UI. Key transformations include:
+ * - Maps the message role to the corresponding Assistant UI role
+ * - Converts content parts, preserving text parts as-is
+ * - Transforms tool invocations from Vercel's combined call/result format to Assistant UI's
+ *   distinct tool-call format, separating the execution state (PENDING vs COMPLETED)
+ *
+ * @param messages - Array of UI messages to convert
+ * @returns Array of messages formatted for use in the Assistant UI thread component
+ *
+ * @example
+ * ```ts
+ * const messages = [{ role: 'user', parts: [{ type: 'text', text: 'Hello' }] }];
+ * const threadMessages = convertToAssistantUiMessages(messages);
+ * ```
+ */
+declare const convertToAssistantUiMessages: (messages: UIMessage[]) => ThreadMessageLike[];
+/**
+ * Converts a single UI message to the Assistant UI format.
+ *
+ * This function performs the same transformation as convertToAssistantUiMessages but operates
+ * on a single message. It's useful for converting individual messages from the Vercel/Cloudflare
+ * AI format to the Assistant UI format, particularly for generic UI message types that need
+ * advanced type parameters.
+ *
+ * @param msg - Single UI message to convert
+ * @returns Message formatted for use in the Assistant UI thread component
+ *
+ * @example
+ * ```ts
+ * const msg: UIMessage = { role: 'assistant', parts: [{ type: 'text', text: 'Hello' }] };
+ * const threadMsg = convertAssistantUIMessage(msg);
+ * ```
+ */
+declare const convertAssistantUIMessage: (msg: UIMessage<unknown, UIDataTypes, UITools>) => ThreadMessageLike;
+//#endregion
+//#region src/lib/mcp-transport.d.ts
+/**
+ * Transport type options for HTTP-based connections
+ */
+type TransportType = 'http' | 'sse';
+/**
+ * Creates the appropriate MCP transport based on source configuration.
+ *
+ * @param config - The MCP source configuration
+ * @param transportType - For HTTP sources, specifies whether to use HTTP or SSE transport
+ * @returns A configured MCP Transport instance
+ *
+ * @example Tab-based transport (same-tab or iframe)
+ * ```ts
+ * const transport = createMCPTransport({ type: 'tab' })
+ * ```
+ *
+ * @example HTTP transport with auth
+ * ```ts
+ * const transport = createMCPTransport({
+ *   type: 'http',
+ *   url: 'https://example.com/mcp',
+ *   authToken: 'secret'
+ * }, 'http')
+ * ```
+ */
+declare function createMCPTransport(config: MCPSourceConfig, transportType?: TransportType): Transport;
+/**
+ * Check if an error indicates we should try SSE fallback.
+ *
+ * This handles cases where HTTP streaming isn't supported (404/405) or
+ * when the connection fails due to CORS/network issues.
+ *
+ * @param error - The error from the failed HTTP connection
+ * @returns true if the error suggests trying SSE transport instead
+ */
+declare function shouldFallbackToSSE(error: Error): boolean;
+/**
+ * Calculate exponential backoff delay for reconnection attempts.
+ *
+ * @param attempt - The current attempt number (0-based)
+ * @param baseDelay - Base delay in milliseconds
+ * @param maxDelay - Maximum delay cap in milliseconds
+ * @returns The calculated delay in milliseconds
+ */
+declare function calculateReconnectDelay(attempt: number, baseDelay: number, maxDelay: number): number;
+//#endregion
+//#region src/lib/constants.d.ts
+/**
+ * Shared Constants
+ *
+ * Centralized location for all magic numbers, timeouts, and configuration values.
+ * Having these in one place makes the codebase more maintainable and easier to tune.
+ */
+/** Maximum number of reconnection attempts before giving up */
+declare const MCP_MAX_RECONNECT_ATTEMPTS = 5;
+/** Base delay in milliseconds for exponential backoff reconnection */
+declare const MCP_BASE_RECONNECT_DELAY_MS = 1000;
+/** Maximum reconnect delay in milliseconds (caps exponential backoff) */
+declare const MCP_MAX_RECONNECT_DELAY_MS = 30000;
+/** Delay before auto-connecting to tab-based MCP sources (allows server initialization) */
+declare const MCP_TAB_CONNECT_DELAY_MS = 100;
+/** Number of frequency bins for audio visualization */
+declare const AUDIO_FREQUENCY_BINS = 32;
+/** Default OpenAI Realtime model */
+declare const REALTIME_DEFAULT_MODEL = "gpt-4o-realtime-preview-2024-12-17";
+/** Default voice for OpenAI Realtime */
+declare const REALTIME_DEFAULT_VOICE = "verse";
+/** Default OpenAI Realtime API URL */
+declare const REALTIME_DEFAULT_API_URL = "https://api.openai.com/v1/realtime";
+/**
+ * Enable debug logging for development.
+ * Can be enabled by setting window.__WEBMCP_DEBUG__ = true in the browser console.
+ * In production builds, this defaults to false.
+ */
+declare const DEBUG_LOGGING_ENABLED: boolean;
+/**
+ * Conditional debug logger that only logs when DEBUG_LOGGING_ENABLED is true.
+ * Can be enabled at runtime by setting window.__WEBMCP_DEBUG__ = true
+ *
+ * @param component - The component or service name for the log prefix
+ * @param message - The log message
+ * @param data - Optional data to include in the log
+ */
+declare function debugLog(component: string, message: string, data?: unknown): void;
+//#endregion
+//#region src/embed.d.ts
+/**
+ * WebMCP Embedded Agent - Intercom-style Installation
+ *
+ * @example Basic Installation (paste before </body>)
+ * ```html
+ * <script>
+ *   window.webmcpSettings = {
+ *     app_id: "YOUR_APP_ID",
+ *     api_base: "https://your-worker.workers.dev"
+ *   };
+ * </script>
+ * <script>
+ *   (function(){var w=window;var wm=w.WebMCP;if(typeof wm==="function"){wm('reattach');}else{var q=function(){q.c(arguments);};q.q=[];q.c=function(args){q.q.push(args);};w.WebMCP=q;var l=function(){var s=document.createElement('script');s.type='text/javascript';s.async=true;s.src='https://your-cdn.com/embed.iife.js';var x=document.getElementsByTagName('script')[0];x.parentNode.insertBefore(s,x);};if(document.readyState==='complete'){l();}else{w.addEventListener('load',l,false);}}})();
+ * </script>
+ * ```
+ *
+ * @example Programmatic Control
+ * ```javascript
+ * // Boot with user data
+ * window.WebMCP('boot', {
+ *   app_id: 'YOUR_APP_ID',
+ *   user_id: 'user_123',
+ *   email: 'user@example.com'
+ * });
+ *
+ * // Show/hide the messenger
+ * window.WebMCP('show');
+ * window.WebMCP('hide');
+ *
+ * // Update settings
+ * window.WebMCP('update', { custom_data: { plan: 'pro' } });
+ *
+ * // Shutdown (clear session)
+ * window.WebMCP('shutdown');
+ * ```
+ */
+/**
+ * Configuration options (similar to intercomSettings)
+ */
+interface WebMCPSettings {
+  /** Your app/workspace ID */
+  app_id: string;
+  /** API base URL for your WebMCP worker */
+  api_base?: string;
+  /** Voice mode token endpoint */
+  token_endpoint?: string;
+  /** User ID for identified users */
+  user_id?: string;
+  /** User email */
+  email?: string;
+  /** User name */
+  name?: string;
+  /** Unix timestamp of user creation */
+  created_at?: number;
+  /** Custom user attributes */
+  custom_data?: Record<string, unknown>;
+  /** Auto-connect to local MCP source */
+  auto_connect_local?: boolean;
+  /** Custom container element ID */
+  container_id?: string;
+}
+/**
+ * Boot options (can override settings)
+ */
+interface WebMCPBootOptions extends Partial<WebMCPSettings> {}
+/**
+ * Handle method calls (Intercom-style API)
+ */
+type WebMCPMethod = 'boot' | 'shutdown' | 'update' | 'show' | 'hide' | 'showNewMessage' | 'getVisitorId' | 'trackEvent' | 'reattach';
+/**
+ * Main API function (Intercom-style)
+ */
+interface WebMCPFunction {
+  (method: WebMCPMethod, ...args: unknown[]): unknown;
+  q?: unknown[][];
+  c?: (args: unknown[]) => void;
+  booted: boolean;
+  visible: boolean;
+}
+declare global {
+  interface Window {
+    WebMCP: WebMCPFunction;
+    webmcpSettings?: WebMCPSettings;
+  }
+}
+//#endregion
+export { AUDIO_FREQUENCY_BINS, AssistantMessage, AssistantModal, type AssistantTranscriptEventData, type AudioLevelData, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Button, type ButtonProps, ChatRuntimeProvider, type ChatRuntimeProviderProps, Composer, ComposerAddAttachment, ComposerAttachments, DEBUG_LOGGING_ENABLED, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, EmbeddedAgent, type EmbeddedAgentProps, type ErrorEventData, LiveWaveform, MCPToolRegistry, type MCPToolsContextValue, MCPToolsProvider, type MCPToolsProviderProps, MCP_BASE_RECONNECT_DELAY_MS, MCP_MAX_RECONNECT_ATTEMPTS, MCP_MAX_RECONNECT_DELAY_MS, MCP_TAB_CONNECT_DELAY_MS, MarkdownText, OpenAIRealtimeService, REALTIME_DEFAULT_API_URL, REALTIME_DEFAULT_MODEL, REALTIME_DEFAULT_VOICE, type RealtimeConfig, type RealtimeSession, RealtimeToolCard, type RegisteredTool, RemoteMCPSettings, SOURCE_LOCAL, SOURCE_REMOTE, ScrollArea, ScrollBar, Separator, type SessionStateEventData, Thread, ThreadWithVoice, type ToolCallCompletedEventData, type ToolCallData, type ToolCallStartedEventData, type ToolExecutor, ToolFallback, Tooltip, TooltipContent, TooltipIconButton, TooltipProvider, TooltipTrigger, type TranscriptData, type TransportType, type UseAgentChatOptions, type UseAgentChatReturn, type UseMCPSourceOptions, type UseMCPSourceReturn, type UseVoiceModeOptions, type UseVoiceModeReturn, UserMessage, UserMessageAttachments, type UserTranscriptEventData, VoiceIndicator, VoiceModeProvider, type VoiceModeProviderProps, type VoiceModeState, WebMCPAgentElement, type WebMCPBootOptions, type WebMCPFunction, type WebMCPMethod, type WebMCPSettings, badgeVariants, buttonVariants, calculateReconnectDelay, cn, convertAssistantUIMessage, convertToAssistantUiMessages, createMCPTransport, debugLog, isAssistantTranscriptEventData, isAudioLevelData, isErrorEventData, isSessionStateEventData, isToolCallCompletedEventData, isToolCallStartedEventData, isUserTranscriptEventData, registerWebMCPAgent, shouldFallbackToSSE, useAgentChat, useAssistantMCP, useCloudflareRuntime, useMCPSource, useMCPTools, useOptionalMCPTools, useOptionalVoiceModeContext, useVoiceMode, useVoiceModeContext };
+//# sourceMappingURL=index.d.ts.map