@mcp-use/inspector 20.0.0-beta.5 → 20.0.0-beta.50

package/dist/client/index.d.ts

@@ -1,51 +1,1406 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Tool, Resource, Prompt, McpServer, ElicitRequestFormParams, ElicitRequestURLParams, GetPromptResult, ElicitResult } from '@mcp-use/client/react';
+export { ViewRenderer, getViewResourceUri, isViewTool } from '@mcp-use/client/react';
+import { ProviderName, McpConnectionLike } from '@mcp-use/agent';
+import * as react from 'react';
+import react__default, { ReactNode, RefObject } from 'react';
+
+interface AddToClientDropdownProps {
+    serverConfig: {
+        url: string;
+        name: string;
+        headers?: Record<string, string>;
+        serverId?: string;
+    };
+    additionalItems?: Array<{
+        id: string;
+        label: string;
+        icon?: React.ReactNode;
+        onClick: () => void | Promise<void>;
+    }>;
+    showClients?: {
+        cursor?: boolean;
+        vsCode?: boolean;
+        vsCodeInsiders?: boolean;
+        claudeDesktop?: boolean;
+        claudeCode?: boolean;
+        geminiCli?: boolean;
+        codexCli?: boolean;
+    };
+    className?: string;
+    onSuccess?: (client: string) => void;
+    onError?: (error: Error) => void;
+    trigger?: React.ReactNode | ((props: {
+        isOpen: boolean;
+        onClick: () => void;
+    }) => React.ReactNode);
+}
 /**
- * Client-side exports for inspector package
- *
- * CSS note: Chat components use Tailwind CSS utility classes.
- * Consumers must have Tailwind CSS configured and include this package
- * in their content paths:
- *   content: ["./node_modules/@mcp-use/inspector/dist/client/**"]
- */
-export { AddToClientDropdown } from "./components/AddToClientDropdown.js";
-export * from "./utils/mcpClientUtils.js";
-export { ToolInputForm } from "./components/tools/ToolInputForm.js";
-export { ToolResultDisplay, type ToolResult, } from "./components/tools/ToolResultDisplay.js";
-export { ToolResultRenderer } from "./components/chat/ToolResultRenderer.js";
-export { ViewRenderer, isViewTool, getViewResourceUri, } from "@mcp-use/client/react";
-export { ThemeProvider } from "./context/ThemeContext.js";
-export { WidgetDebugProvider } from "./context/WidgetDebugContext.js";
-export { InspectorProvider, useInspector, type EmbeddedConfig, type TabType, } from "./context/InspectorContext.js";
-export { ToolsTab, type ToolsTabRef } from "./components/ToolsTab.js";
-export { ResourcesTab, type ResourcesTabRef, } from "./components/ResourcesTab.js";
-export { PromptsTab, type PromptsTabRef } from "./components/PromptsTab.js";
-export { ChatTab, type ChatTabProps } from "./components/ChatTab.js";
-export { MessageList } from "./components/chat/MessageList.js";
-export { ChatHeader } from "./components/chat/ChatHeader.js";
-export { chatBarActionButtonClass, chatBarFrostedPill, chatBarTitleFrostedClass, } from "./components/chat/chat-bar-styles.js";
-export { ChatInputArea } from "./components/chat/ChatInputArea.js";
-export { ChatLandingForm } from "./components/chat/ChatLandingForm.js";
-export { ConfigurationDialog } from "./components/chat/ConfigurationDialog.js";
-export { ConfigureEmptyState } from "./components/chat/ConfigureEmptyState.js";
-export { DEFAULT_CHAT_SYSTEM_PROMPT } from "./components/chat/system-prompt-default.js";
-export type { ChatSystemPromptProvider } from "./components/chat/system-prompt/types.js";
-export { getSystemPromptStorageKey, readStoredSystemPrompt, resolveSystemPrompt, writeStoredSystemPrompt, } from "./components/chat/system-prompt/local-storage.js";
-export type { Message, LLMConfig, AuthConfig, MessageAttachment, MCPServerConfig, MCPConfig, StreamProtocol, } from "./components/chat/types.js";
-export type { ChatView } from "./components/chat/ChatTraceView.js";
-export type { InspectorTokenUsage, InspectorTraceEvent, InspectorTraceSpan, InspectorTraceState, } from "./components/chat/trace.js";
-export { useChatMessagesClientSide } from "./components/chat/useChatMessagesClientSide.js";
-export { useChatMessages } from "./components/chat/useChatMessages.js";
-export { useConfig } from "./components/chat/useConfig.js";
-export { ChatHistoryPanel } from "./chat-history/ChatHistoryPanel.js";
-export { ChatHistoryHeader } from "./chat-history/ChatHistoryHeader.js";
-export { ChatHistoryRail } from "./chat-history/ChatHistoryRail.js";
-export { ChatList, type ChatSession } from "./chat-history/ChatList.js";
-export { ChatTitleReveal } from "./chat-history/ChatTitleReveal.js";
-export type { ChatStorageProvider, ListChatsParams, } from "./chat-history/types.js";
-export { LocalChatStorageProvider } from "./chat-history/providers/local-storage.js";
-export { chatEventsToInspectorMessages } from "./chat-history/chat-events-to-inspector-messages.js";
-export type { ChatEventRowForMessages } from "./chat-history/chat-events-to-inspector-messages.js";
-export { useChatHistory } from "./chat-history/useChatHistory.js";
-export { CHAT_TITLE_PLACEHOLDER, CHAT_TITLE_SIMPLE, firstUserMessageFromMessages, generateChatTitleWithLlm, isPlaceholderTitle, } from "./chat-history/chat-title.js";
-export { useChatTitleGeneration } from "./chat-history/useChatTitleGeneration.js";
-export { useMCPPrompts, type PromptResult } from "./hooks/useMCPPrompts.js";
-//# sourceMappingURL=index.d.ts.map
+ * Reusable dropdown component for adding MCP servers to various clients
+ *
+ * @example
+ * ```tsx
+ * <AddToClientDropdown
+ *   serverConfig={{
+ *     url: "https://mcp.example.com/mcp",
+ *     name: "My Server",
+ *     headers: { Authorization: "Bearer token" }
+ *   }}
+ *   additionalItems={[{
+ *     id: "agent",
+ *     label: "Add to mcp-use Agent",
+ *     onClick: () => handleAddToAgent()
+ *   }]}
+ * />
+ * ```
+ */
+declare function AddToClientDropdown({ serverConfig, additionalItems, showClients, className, onSuccess, onError, trigger, }: AddToClientDropdownProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Utility functions for generating MCP client configurations and commands
+ */
+/**
+ * Builds a Cursor deep link that installs an MCP configured with the provided URL and optional headers.
+ *
+ * @param name - Display name for the server; will be sanitized for use in the link
+ * @param headers - Optional mapping of header names to values; headers are represented in the generated config as environment-variable placeholders (e.g., `{{HEADER_ENV_VAR}}`)
+ * @returns A Cursor deep link URL containing a base64-encoded JSON config with the `url` and optional header placeholders, and a sanitized `name` query parameter
+ */
+declare function generateCursorDeepLink(url: string, name: string, headers?: Record<string, string>): string;
+/**
+ * Build a VS Code deep link that installs an MCP server configuration.
+ *
+ * If `headers` are provided, each header name is mapped to a placeholder value of the form `your-<ENVVAR>-value`.
+ *
+ * @param url - The server URL to include in the configuration
+ * @param name - The display name for the server; it will be sanitized for use in the config
+ * @param headers - Optional map of HTTP header names to values; header names are converted to environment-variable-style placeholders in the generated config
+ * @returns A VS Code deep link (`vscode:mcp/install?...`) containing the URL-encoded JSON configuration
+ */
+declare function generateVSCodeDeepLink(url: string, name: string, headers?: Record<string, string>): string;
+/**
+ * Build a VS Code Insiders deep link that installs an MCP server configuration.
+ *
+ * If `headers` are provided, each header name is mapped to a placeholder value of the form `your-<ENVVAR>-value`.
+ *
+ * @param url - The server URL to include in the configuration
+ * @param name - The display name for the server; it will be sanitized for use in the config
+ * @param headers - Optional map of HTTP header names to values; header names are converted to environment-variable-style placeholders in the generated config
+ * @returns A VS Code Insiders deep link (`vscode-insiders:mcp/install?...`) containing the URL-encoded JSON configuration
+ */
+declare function generateVSCodeInsidersDeepLink(url: string, name: string, headers?: Record<string, string>): string;
+/**
+ * Builds a .mcpb configuration object for an MCP server.
+ *
+ * @param url - The server URL to include in the configuration
+ * @param name - The server name; it will be sanitized for use in the config
+ * @param headers - Optional mapping of header names to values; when provided each header value is replaced with a placeholder of the form `your-ENVVAR-value` where `ENVVAR` is derived from the header name
+ * @returns An object containing `url`, a sanitized `name`, and, if provided, a `headers` mapping of header names to placeholder values
+ */
+declare function generateMcpbConfig(url: string, name: string, headers?: Record<string, string>): object;
+/**
+ * Triggers a browser download of a generated .mcpb configuration file.
+ *
+ * @param url - The MCP server URL to include in the generated configuration
+ * @param name - The server name used for the configuration and as the downloaded filename (sanitized)
+ * @param headers - Optional map of HTTP headers to include in the configuration
+ * @throws Rethrows any error encountered while generating the configuration or initiating the download
+ */
+declare function downloadMcpbFile(url: string, name: string, headers?: Record<string, string>): void;
+/**
+ * Builds a Claude Code CLI command to add an MCP using HTTP transport and collects environment variable metadata for any provided headers.
+ *
+ * @param url - The server URL to include in the CLI command
+ * @param name - The display name for the server; it will be sanitized for use in the command
+ * @param headers - Optional map of header names to header values; header names will be converted to environment variable placeholders in the command
+ * @returns An object containing:
+ *  - `command`: the complete `claude mcp add` CLI command string with header values referenced as environment variable placeholders, and
+ *  - `envVars`: an array of `{ name, header }` entries where `name` is the generated environment variable and `header` is the original header name
+ */
+declare function generateClaudeCodeCommand(url: string, name: string, headers?: Record<string, string>): {
+    command: string;
+    envVars: Array<{
+        name: string;
+        header: string;
+    }>;
+};
+/**
+ * Builds a Gemini CLI command to add an MCP using HTTP transport and returns any environment-variable mappings needed for headers.
+ *
+ * If `headers` are provided, the command includes header entries that reference environment variable placeholders, and `envVars` lists the placeholder names with their corresponding header names.
+ *
+ * @param url - The MCP server URL
+ * @param name - A human-readable server name used to derive a sanitized identifier for the command
+ * @param headers - Optional mapping of header names to values; header names are converted to environment-variable placeholders in the returned command
+ * @returns An object with `command`, the assembled CLI command string, and `envVars`, an array of `{ name, header }` pairs linking environment variable names to header names
+ */
+declare function generateGeminiCLICommand(url: string, name: string, headers?: Record<string, string>): {
+    command: string;
+    envVars: Array<{
+        name: string;
+        header: string;
+    }>;
+};
+/**
+ * Build a Codex-style INI configuration string for an MCP server and collect environment-variable metadata for any HTTP headers.
+ *
+ * @param url - The server URL to include in the configuration
+ * @param name - The server display name; used to produce a sanitized section key
+ * @param headers - Optional mapping of HTTP header names; header keys will be added to `http_headers` in the config with placeholder values and returned as environment-variable metadata
+ * @returns An object with `config`, the generated INI-style configuration string, and `envVars`, an array of `{ name, header }` pairs where `name` is the suggested environment variable and `header` is the original header name
+ */
+declare function generateCodexConfig(url: string, name: string, headers?: Record<string, string>): {
+    config: string;
+    envVars: Array<{
+        name: string;
+        header: string;
+    }>;
+};
+/**
+ * Generate shell instructions to export required environment variables.
+ *
+ * @param envVars - Array of environment variable metadata; each item should include `name` (the environment variable name) and `header` (the corresponding HTTP header)
+ * @returns A shell snippet that exports each environment variable (one `export NAME="your-NAME-value"` line per variable), or an empty string if `envVars` is empty
+ */
+declare function getEnvVarInstructions(envVars: Array<{
+    name: string;
+    header: string;
+}>): string;
+/**
+ * Produce a TypeScript code snippet that initializes an MCPClient configured for the given server.
+ *
+ * @param url - The server URL to include in the generated client configuration
+ * @param name - The human-readable server name used when deriving a default server id
+ * @param serverId - Optional explicit server id to use instead of a sanitized `name`
+ * @param headers - Optional HTTP headers to include in the server configuration
+ * @returns A TypeScript code snippet (as a string) that registers the server with MCPClient, creates sessions, and demonstrates common session operations
+ */
+declare function generateTypeScriptSDKCode(url: string, name: string, serverId?: string, headers?: Record<string, string>): string;
+/**
+ * Produce a Python code snippet that initializes an MCPClient with the provided server configuration and demonstrates basic session usage.
+ *
+ * @param url - The MCP server URL to include in the generated configuration.
+ * @param name - The server name; used to derive a sanitized identifier when `serverId` is not provided.
+ * @param serverId - Optional explicit server identifier to use in the config; if omitted, a sanitized form of `name` is used.
+ * @param headers - Optional HTTP headers to include in the server configuration (mapped directly into the generated config).
+ * @returns A Python source string that defines an `MCPClient` configured with the specified server and includes example calls for creating sessions, listing tools/resources, and placeholders for tool/resource usage.
+ */
+declare function generatePythonSDKCode(url: string, name: string, serverId?: string, headers?: Record<string, string>): string;
+
+interface ToolInputFormProps {
+    selectedTool: Tool;
+    toolArgs: Record<string, unknown>;
+    onArgChange: (key: string, value: string) => void;
+    onBulkPaste?: (pastedText: string, fieldKey: string) => Promise<boolean>;
+    autoFilledFields?: Set<string>;
+    setFields?: Set<string>;
+    sendEmptyFields?: Set<string>;
+    onToggleEmpty?: (key: string, expectedType: "string" | "object" | "array", pressed: boolean) => void;
+}
+declare function ToolInputForm({ selectedTool, toolArgs, onArgChange, onBulkPaste, autoFilledFields, setFields, sendEmptyFields, onToggleEmpty, }: ToolInputFormProps): react_jsx_runtime.JSX.Element;
+
+interface ToolResult {
+    toolName: string;
+    args: Record<string, unknown>;
+    result: any;
+    error?: string;
+    timestamp: number;
+    duration?: number;
+    toolMeta?: Record<string, any>;
+}
+interface ToolResultDisplayProps {
+    results: ToolResult[];
+    copiedResult: number | null;
+    serverId: string;
+    readResource: (uri: string) => Promise<any>;
+    onCopy: (index: number, text: string) => void;
+    onDelete: (index: number) => void;
+    onFullscreen: (index: number) => void;
+    onMaximize?: () => void;
+    isMaximized?: boolean;
+    onRerunTool?: () => void;
+    onWidgetHeightChange?: (height: number | null) => void;
+}
+declare function ToolResultDisplay({ results, copiedResult, serverId, readResource, onCopy, onMaximize, isMaximized, onRerunTool, onWidgetHeightChange, }: ToolResultDisplayProps): react_jsx_runtime.JSX.Element;
+
+/** SEP-1865 `ui/message` content block (follow-up messages from MCP Apps). */
+type MessageContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        [key: string]: unknown;
+    };
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+
+interface MessageAttachment {
+    type: "image" | "file";
+    data: string;
+    mimeType: string;
+    name?: string;
+    size?: number;
+}
+interface Message$1 {
+    id: string;
+    role: "user" | "assistant";
+    content: string | Array<{
+        index: number;
+        type: string;
+        text: string;
+    }>;
+    timestamp: number;
+    attachments?: MessageAttachment[];
+    parts?: Array<{
+        type: "text" | "tool-invocation";
+        text?: string;
+        toolInvocation?: {
+            toolCallId?: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            result?: any;
+            state?: "pending" | "streaming" | "result" | "error";
+            /** Best-effort parsed partial arguments while the LLM is still generating */
+            partialArgs?: Record<string, unknown>;
+        };
+    }>;
+    toolCalls?: Array<{
+        toolName: string;
+        args: Record<string, unknown>;
+        result?: any;
+    }>;
+}
+interface ChatSerializedMessage {
+    role: string;
+    content: unknown;
+    attachments?: unknown;
+}
+interface ChatBodyContext {
+    disabledTools: string[];
+    widgetModelContext?: string;
+}
+type ChatBodyBuilder = (messages: ChatSerializedMessage[], context: ChatBodyContext) => unknown;
+interface SendMessageOptions {
+    throwOnError?: boolean;
+    onAccepted?: () => void;
+}
+interface LLMConfig {
+    provider: ProviderName;
+    apiKey: string;
+    model: string;
+    temperature?: number;
+    baseUrl?: string;
+    credentials?: RequestCredentials;
+}
+interface AuthConfig {
+    type: "none" | "basic" | "bearer" | "oauth";
+    username?: string;
+    password?: string;
+    token?: string;
+    oauthTokens?: {
+        access_token?: string;
+        refresh_token?: string;
+        token_type?: string;
+    };
+}
+interface MCPServerConfig {
+    url?: string;
+    transport?: "http" | "sse";
+    headers?: Record<string, string>;
+    authToken?: string;
+    auth_token?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    preferSse?: boolean;
+}
+interface MCPConfig {
+    mcpServers: Record<string, MCPServerConfig>;
+}
+type StreamProtocol = "sse" | "data-stream";
+
+interface ToolResultRendererProps {
+    toolName: string;
+    toolArgs: Record<string, unknown>;
+    result: any;
+    serverId?: string;
+    readResource?: (uri: string) => Promise<any>;
+    toolMeta?: Record<string, any>;
+    onSendFollowUp?: (content: MessageContentBlock[]) => Promise<void>;
+    modelContextScope?: string;
+    llmConfig?: LLMConfig | null;
+    partialToolArgs?: Record<string, unknown>;
+    cancelled?: boolean;
+}
+declare function ToolResultRenderer({ toolName, toolArgs, result, serverId, readResource, toolMeta, onSendFollowUp, modelContextScope, llmConfig, partialToolArgs, cancelled, }: ToolResultRendererProps): react_jsx_runtime.JSX.Element | null;
+
+type Theme = "light" | "dark" | "system";
+interface ThemeProviderProps {
+    children: ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+    forcedTheme?: Theme;
+}
+declare function ThemeProvider({ children, defaultTheme, storageKey, forcedTheme, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+interface WidgetModelContext {
+    content?: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}
+
+/**
+ * Provider for widget debugging context
+ *
+ * Manages widget debug state following the same pattern as InspectorProvider
+ */
+declare function WidgetDebugProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type TabType = "tools" | "prompts" | "resources" | "chat" | "sampling" | "elicitation" | "notifications" | "server-metadata" | "connection-settings";
+/**
+ * Configuration injected by a host application when the inspector runs in
+ * embedded / hosted mode (e.g. inside inspector.manufact.com or the Vibe IDE).
+ *
+ * ── Hosted-inspector chat flow ──────────────────────────────────────────────
+ * The Chat tab uses a managed backend by default:
+ *
+ *   1. `InspectorProvider` (below) prefers the runtime MANUFACT_CHAT_URL,
+ *      then VITE_MANUFACT_CHAT_URL, and finally the Manufact Cloud endpoint.
+ *
+ *   2. `LayoutContent` passes these down to `ChatTab` as props; `ChatTab`
+ *      then passes `useClientSide={false}` to `useChatMessages`.
+ *
+ *   3. If the user already has their own API key in localStorage, `ChatTab`
+ *      overrides this with `effectiveClientSide=true` (see forceClientSide
+ *      logic there), bypassing the backend entirely.
+ *
+ *   4. The backend endpoint (`/api/v1/inspector/chat/stream`, cloud.mcp-use)
+ *      requires an OAuth bearer token and meters the user's organization.
+ *
+ *   5. On a 429 response the frontend offers cloud OAuth sign-in or BYOK.
+ *
+ * ── Related files ────────────────────────────────────────────────────────────
+ *  • cloud.mcp-use/src/routes/v1/inspector-chat.ts   — rate-limited endpoint
+ *  • cloud.mcp-use/src/lib/mcp-chat-stream.ts        — shared OpenRouter streamer
+ *  • inspector/src/client/components/ChatTab.tsx      — effectiveClientSide logic
+ *  • inspector/src/client/auth/manufact-auth.ts       — cloud OAuth session
+ *  • inspector/src/client/components/HostedUserMenu.tsx — avatar / authorization
+ */
+interface EmbeddedConfig {
+    backgroundColor?: string;
+    padding?: string;
+    /** Show only a single tab with no tab bar / header chrome */
+    singleTab?: boolean;
+    /** Which tabs to show. If omitted, all tabs are visible. */
+    visibleTabs?: TabType[];
+    /** Override the default tab to open on load */
+    defaultTab?: TabType;
+    /** Custom API URL for the Chat tab's server-side streaming */
+    chatApiUrl?: string;
+    /**
+     * Wire protocol for the `chatApiUrl` streaming endpoint.
+     * - `"sse"` (default): Inspector SSE protocol
+     * - `"data-stream"`: Vercel AI SDK data-stream protocol
+     */
+    chatStreamProtocol?: StreamProtocol;
+    /**
+     * Credentials policy for chat fetch requests.
+     * Set to `"include"` when the chat endpoint requires session cookies (e.g. when the
+     * inspector iframe is on a subdomain that shares cookies with the API).
+     */
+    chatCredentials?: RequestCredentials;
+    /** Externally-managed LLM config passed to ChatTab (bypasses config UI) */
+    managedLlmConfig?: LLMConfig;
+    /** Opt in to the Manufact free-tier sign-in / upgrade UI in the chat. */
+    chatEnableFreeTierUpgrade?: boolean;
+    /** Hide the "Chat" title in the header */
+    chatHideTitle?: boolean;
+    /** Hide the model badge on the landing form and header */
+    chatHideModelBadge?: boolean;
+    /** Hide the MCP server URL on the landing form */
+    chatHideServerUrl?: boolean;
+    /** Hide the API key / provider configuration dialog */
+    chatHideConfigButton?: boolean;
+    /** Custom label for the clear / new-chat button */
+    chatClearButtonLabel?: string;
+    /** Hide the icon on the clear / new-chat button */
+    chatClearButtonHideIcon?: boolean;
+    /** Hide the keyboard shortcut (⌘O) on the clear / new-chat button */
+    chatClearButtonHideShortcut?: boolean;
+    /** Button variant for the clear / new-chat button (e.g. "secondary", "ghost") */
+    chatClearButtonVariant?: "default" | "secondary" | "ghost" | "outline";
+    /** Initial quick questions shown below the landing input. */
+    chatQuickQuestions?: string[];
+    /** Initial followup suggestions shown above input in chat mode. */
+    chatFollowups?: string[];
+    /** When true, hides the "New Chat" / clear button in the chat header. */
+    chatHideClearButton?: boolean;
+    /** When true, hides the tool selector (wrench icon) in the chat input. */
+    chatHideToolSelector?: boolean;
+    /**
+     * When true, treat the chat as already connected even when no MCP server is
+     * selected. Use this together with `chatApiUrl` when the backend manages the
+     * MCP connections and no client-side server URL is required.
+     */
+    forceConnected?: boolean;
+}
+interface InspectorState {
+    selectedServerId: string | null;
+    activeTab: TabType;
+    selectedToolName: string | null;
+    selectedPromptName: string | null;
+    selectedResourceUri: string | null;
+    selectedSamplingRequestId: string | null;
+    selectedElicitationRequestId: string | null;
+    tunnelUrl: string | null;
+    isTunnelStarting: boolean;
+    isEmbedded: boolean;
+    embeddedConfig: EmbeddedConfig;
+}
+interface InspectorContextType extends InspectorState {
+    setSelectedServerId: (serverId: string | null) => void;
+    setActiveTab: (tab: TabType) => void;
+    setSelectedToolName: (toolName: string | null) => void;
+    setSelectedPromptName: (promptName: string | null) => void;
+    setSelectedResourceUri: (resourceUri: string | null) => void;
+    setSelectedSamplingRequestId: (requestId: string | null) => void;
+    setSelectedElicitationRequestId: (requestId: string | null) => void;
+    setTunnelUrl: (tunnelUrl: string | null) => void;
+    setIsTunnelStarting: (starting: boolean) => void;
+    setEmbeddedMode: (isEmbedded: boolean, config?: EmbeddedConfig) => void;
+    navigateToItem: (serverId: string, tab: TabType, itemIdentifier?: string) => void;
+    clearSelection: () => void;
+}
+/**
+ * Provides Inspector context and state to descendant components.
+ *
+ * Initializes and supplies the inspector UI state (selected server, active tab,
+ * per-tab selections, tunnel URL, and embedded mode/config) along with updater
+ * callbacks and navigation/clearing helpers through React context.
+ *
+ * @param children - Elements that will receive the Inspector context
+ * @returns A context provider element that supplies inspector state and mutator functions to its children
+ */
+declare function InspectorProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useInspector(): InspectorContextType;
+
+interface ToolsTabRef {
+    focusSearch: () => void;
+    blurSearch: () => void;
+}
+interface ToolsTabProps {
+    tools: Tool[];
+    callTool: (name: string, args?: Record<string, unknown>, options?: {
+        timeout?: number;
+        maxTotalTimeout?: number;
+        resetTimeoutOnProgress?: boolean;
+        signal?: AbortSignal;
+    }) => Promise<any>;
+    readResource: (uri: string) => Promise<any>;
+    serverId: string;
+    isConnected: boolean;
+    refreshTools?: () => Promise<void>;
+}
+/**
+ * Render the Tools tab UI for browsing, executing, and managing tools and saved requests.
+ *
+ * Renders a responsive interface with a searchable tools list and saved-requests list, a tool execution panel, a results history (with copying, deleting, fullscreen, preview and MCP Apps widget integration), and an RPC message logger. Supports mobile-specific navigation, resizable panels for desktop, saved request persistence, keyboard navigation, execution abort/timeout handling, and telemetry for executions and saved requests.
+ *
+ * @param ref - Optional imperative ref exposing `focusSearch` and `blurSearch` methods.
+ * @param tools - Array of available tools to list and execute.
+ * @param callTool - Function to invoke a tool by name with arguments and options (timeout, reset behavior, abort signal).
+ * @param readResource - Function to fetch a resource by URI (used for MCP Apps widget prefetch).
+ * @param serverId - Identifier for the current server (used for telemetry and RPC filtering).
+ * @param isConnected - Whether the inspector is connected to the server (affects execution UI).
+ * @returns The React element for the Tools tab.
+ */
+declare function ToolsTab({ ref, tools, callTool, readResource, serverId, isConnected, refreshTools, }: ToolsTabProps & {
+    ref?: React.RefObject<ToolsTabRef | null>;
+}): react_jsx_runtime.JSX.Element;
+declare namespace ToolsTab {
+    var displayName: string;
+}
+
+interface ResourcesTabRef {
+    focusSearch: () => void;
+    blurSearch: () => void;
+}
+interface ResourcesTabProps {
+    resources: Resource[];
+    readResource: (uri: string) => Promise<any>;
+    serverId: string;
+    isConnected: boolean;
+    mcpServerUrl: string;
+    refreshResources?: () => Promise<void>;
+}
+/**
+ * Render the Resources tab UI and manage its interactions (resource list, selection, result display, search, keyboard navigation, mobile/desktop layouts, copy/download/fullscreen actions, and RPC logger).
+ *
+ * @param ref - Optional ref exposing `focusSearch()` and `blurSearch()` methods for programmatic search focus control.
+ * @param resources - Array of resources to show and filter.
+ * @param readResource - Function to read a resource by its URI; used when a resource is selected.
+ * @param serverId - Identifier for the server; used for telemetry and RPC logger scope.
+ * @param isConnected - When `true`, selecting a resource triggers `readResource`; when `false`, reads are skipped.
+ * @returns The ResourcesTab React element.
+ */
+declare function ResourcesTab({ ref, resources, readResource, serverId, isConnected, mcpServerUrl, refreshResources, }: ResourcesTabProps & {
+    ref?: React.RefObject<ResourcesTabRef | null>;
+}): react_jsx_runtime.JSX.Element;
+declare namespace ResourcesTab {
+    var displayName: string;
+}
+
+interface PromptsTabRef {
+    focusSearch: () => void;
+    blurSearch: () => void;
+}
+interface PromptsTabProps {
+    prompts: Prompt[];
+    callPrompt: (name: string, args?: Record<string, unknown>) => Promise<any>;
+    serverId: string;
+    isConnected: boolean;
+    refreshPrompts?: () => Promise<void>;
+}
+/**
+ * Render the Prompts tab UI for browsing, selecting, executing, saving, and inspecting prompts.
+ *
+ * The component manages prompt selection, argument state, execution results, saved prompts (persisted
+ * to localStorage), keyboard navigation, responsive mobile/desktop layouts, RPC message viewing,
+ * and exposes `focusSearch` / `blurSearch` via the forwarded ref.
+ *
+ * @param ref - Optional forwarded ref exposing `focusSearch` and `blurSearch` methods.
+ * @param prompts - The list of available prompts to display.
+ * @param callPrompt - Function invoked to execute a prompt by name with an arguments object.
+ * @param serverId - Identifier for the current server; used for RPC scoping and telemetry.
+ * @param isConnected - Whether the application is currently connected to the backend (controls execution availability).
+ * @returns The PromptsTab UI element.
+ */
+declare function PromptsTab({ ref, prompts, callPrompt, serverId, isConnected, refreshPrompts, }: PromptsTabProps & {
+    ref?: React.RefObject<PromptsTabRef | null>;
+}): react_jsx_runtime.JSX.Element;
+declare namespace PromptsTab {
+    var displayName: string;
+}
+
+/** Chat session kind from the chats API. */
+type ChatType = string;
+type ChatSession = {
+    id: string;
+    title: string;
+    agent_id: string;
+    /** Omitted on some API rows — treat as regular chat unless `"agent_execution"`. */
+    type?: ChatType;
+    agent_name: string;
+    created_at: string;
+    updated_at: string;
+};
+interface ListChatsParams {
+    agentId?: string;
+    take?: number;
+    skip?: number;
+}
+interface ChatStorageProvider {
+    listChats(params: ListChatsParams): Promise<{
+        items: ChatSession[];
+        total: number;
+    }>;
+    getMessages(chatId: string): Promise<Message$1[]>;
+    createChat(params: {
+        agentId: string;
+        title?: string;
+        agentName?: string;
+    }): Promise<ChatSession>;
+    updateChat(chatId: string, patch: {
+        title?: string;
+    }): Promise<ChatSession>;
+    deleteChat(chatId: string): Promise<void>;
+    /** Optional — local provider implements; cloud relies on /stream event writes */
+    saveMessages?(chatId: string, messages: Message$1[]): Promise<void>;
+    /** Optional — cloud uses API; standalone may use built-in LLM fallback in ChatTab */
+    generateTitle?(chatId: string): Promise<string | null>;
+}
+
+interface CloudModel {
+    id: string;
+    name: string;
+    provider: string;
+}
+declare function useManagedCloudModel(chatApiUrl: string | undefined, accessToken: string | null | undefined, authMode: "session" | "oauth" | null, enabled: boolean): {
+    models: CloudModel[];
+    selectedModelId: string;
+    setSelectedModelId: (id: string) => void;
+    isLoading: boolean;
+    selectedModel: CloudModel | null;
+    defaultModelId: string;
+};
+
+interface InspectorTokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+}
+interface TraceEventBase {
+    id: string;
+    timestamp: number;
+    raw?: unknown;
+}
+type InspectorTraceEvent = (TraceEventBase & {
+    type: "request";
+    request: unknown;
+}) | (TraceEventBase & {
+    type: "text-delta";
+    delta: string;
+}) | (TraceEventBase & {
+    type: "tool-call-start";
+    toolCallId: string;
+    toolName: string;
+}) | (TraceEventBase & {
+    type: "tool-call-args";
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}) | (TraceEventBase & {
+    type: "tool-result";
+    toolCallId?: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}) | (TraceEventBase & {
+    type: "usage";
+    usage: InspectorTokenUsage;
+}) | (TraceEventBase & {
+    type: "error";
+    message: string;
+}) | (TraceEventBase & {
+    type: "done";
+});
+interface InspectorTraceSpan {
+    id: string;
+    kind: "llm" | "tool";
+    name: string;
+    status: "running" | "success" | "error";
+    startedAt: number;
+    endedAt?: number;
+    preview?: string;
+    usage?: InspectorTokenUsage;
+}
+interface InspectorTraceState {
+    events: InspectorTraceEvent[];
+    spans: InspectorTraceSpan[];
+    usage?: InspectorTokenUsage;
+}
+
+type ChatView = "conv" | "raw";
+
+interface ChatSystemPromptProvider {
+    prompt: string | null;
+    savePrompt: (prompt: string) => Promise<void>;
+    isLoading?: boolean;
+    isSaving?: boolean;
+    disabled?: boolean;
+}
+
+type MCPConnection$1 = {
+    [K in keyof McpServer]: McpServer[K];
+};
+interface ChatTabProps {
+    connection: MCPConnection$1;
+    isConnected: boolean;
+    useClientSide?: boolean;
+    /** Enable global keyboard shortcuts (Cmd+O for new chat). Default: true.
+     *  Set to false when embedding to avoid conflicts with host app shortcuts. */
+    enableKeyboardShortcuts?: boolean;
+    prompts: Prompt[];
+    serverId: string;
+    readResource?: (uri: string) => Promise<any>;
+    callPrompt: (name: string, args?: Record<string, unknown>) => Promise<any>;
+    /** Custom API endpoint URL for server-side chat streaming (used when useClientSide=false).
+     *  Defaults to "/inspector/api/chat/stream". */
+    chatApiUrl?: string;
+    /** When chatApiUrl is not yet available, called before sending to resolve the URL. Useful for background initialization. */
+    waitForChatApiUrl?: () => Promise<string | undefined>;
+    /** Pre-populate the chat with messages from a previous session (e.g. when restoring history). */
+    initialMessages?: Message$1[];
+    /** Externally-managed LLM config. When provided, bypasses localStorage-based config
+     *  and hides the API key configuration UI. Useful for host apps that provide their own backend. */
+    managedLlmConfig?: LLMConfig;
+    /** Curated cloud model state when signed in on hosted inspector. */
+    managedCloudModel?: ReturnType<typeof useManagedCloudModel>;
+    /** Opt in to the Manufact free-tier sign-in / upgrade UI. Default: false. */
+    enableFreeTierUpgrade?: boolean;
+    /** Label for the clear/new-chat button. Default: "New Chat". */
+    clearButtonLabel?: string;
+    /** When true, hides the "Chat" title in the header. Default: false. */
+    hideTitle?: boolean;
+    /** When true, hides the model badge on the landing form. Default: false. */
+    hideModelBadge?: boolean;
+    /** When true, hides the MCP server URL on the landing form. Default: false. */
+    hideServerUrl?: boolean;
+    /** When true, hides the icon on the clear/new-chat button. */
+    clearButtonHideIcon?: boolean;
+    /** When true, hides the keyboard shortcut (⌘O) on the clear/new-chat button. */
+    clearButtonHideShortcut?: boolean;
+    /** Button variant for the clear/new-chat button. Default: "default". */
+    clearButtonVariant?: "default" | "secondary" | "ghost" | "outline";
+    /** When true, hides the "New Chat" / clear button entirely. */
+    hideClearButton?: boolean;
+    /** When true, hides the tool selector (wrench icon) in the chat input. */
+    hideToolSelector?: boolean;
+    /** Initial quick questions shown below the landing input. */
+    chatQuickQuestions?: string[];
+    /** Initial followups shown above input in active chat mode. */
+    chatFollowups?: string[];
+    /**
+     * Wire protocol used by the streaming endpoint.
+     * - `"sse"` (default): Inspector SSE protocol
+     * - `"data-stream"`: Vercel AI SDK data-stream protocol
+     */
+    streamProtocol?: StreamProtocol;
+    /** Credentials policy for the fetch request (e.g. `"include"` for cross-origin cookie auth). */
+    credentials?: RequestCredentials;
+    /** Extra headers to send with every streaming request. */
+    extraHeaders?: Record<string, string>;
+    /**
+     * Custom body builder for the streaming request.
+     * The second argument contains the effective disabled tools and serialized
+     * scoped widget context. Existing one-argument callbacks remain valid.
+     */
+    body?: ChatBodyBuilder;
+    /** Pluggable chat history storage. Defaults to localStorage in standalone mode. */
+    chatStorageProvider?: ChatStorageProvider;
+    /** When false, hides the built-in history sidebar even if a provider is available. */
+    enableChatHistory?: boolean;
+    /** Controlled active chat thread id */
+    activeChatId?: string;
+    onActiveChatIdChange?: (chatId: string | null) => void;
+    /** When false, defer title generation until host signals persisted events (cloud embed). Default: true. */
+    titleGenerationReady?: boolean;
+    /** Known title for the active chat; skips generation when not the placeholder. */
+    activeChatTitle?: string;
+    /** Called after a title is generated and persisted via the storage provider. */
+    onChatTitleGenerated?: (chatId: string, title: string) => void;
+    /** Initial focused chat view. Default: "conv". */
+    defaultView?: ChatView;
+    /** Pluggable system prompt source. Defaults to localStorage per serverId. */
+    systemPromptProvider?: ChatSystemPromptProvider;
+    /** Raise ChatHeader above host chrome (cloud embed). */
+    elevatedHeader?: boolean;
+}
+declare function ChatTab({ connection, isConnected, useClientSide, enableKeyboardShortcuts, prompts, serverId, callPrompt, readResource, chatApiUrl, waitForChatApiUrl, initialMessages, managedLlmConfig, managedCloudModel, enableFreeTierUpgrade, clearButtonLabel, hideTitle, hideModelBadge, clearButtonHideIcon, clearButtonHideShortcut, clearButtonVariant, hideClearButton, hideToolSelector, chatQuickQuestions, chatFollowups, streamProtocol, credentials, extraHeaders, body, chatStorageProvider, enableChatHistory, activeChatId: controlledActiveChatId, onActiveChatIdChange, titleGenerationReady, activeChatTitle, onChatTitleGenerated, defaultView, systemPromptProvider: externalSystemPromptProvider, elevatedHeader, }: ChatTabProps): react_jsx_runtime.JSX.Element;
+
+interface Message {
+    id: string;
+    role: "user" | "assistant";
+    content: string | Array<{
+        index: number;
+        type: string;
+        text: string;
+    }>;
+    timestamp: number;
+    attachments?: MessageAttachment[];
+    parts?: Array<{
+        type: "text" | "tool-invocation";
+        text?: string;
+        toolInvocation?: {
+            toolCallId?: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            result?: any;
+            state?: "pending" | "streaming" | "result" | "error";
+            partialArgs?: Record<string, unknown>;
+        };
+    }>;
+    toolCalls?: Array<{
+        toolName: string;
+        args: Record<string, unknown>;
+        result?: any;
+    }>;
+}
+interface MessageListProps {
+    messages: Message[];
+    isLoading: boolean;
+    serverId?: string;
+    readResource?: (uri: string) => Promise<any>;
+    tools?: any[];
+    sendMessage?: (message: string, attachments?: MessageAttachment[]) => Promise<void>;
+    /** When provided, passed to widget renderers to avoid useMcpClient() context lookup. */
+    serverBaseUrl?: string;
+    /** Anchor at the end of the thread — owned by useChatScrollToBottom in ChatTab. */
+    messagesEndRef?: RefObject<HTMLDivElement | null>;
+    /** Trace events used to derive per-message token counts on hover. */
+    traceEvents?: InspectorTraceEvent[];
+    modelContextScope?: string;
+    llmConfig?: LLMConfig | null;
+}
+declare const MessageList: react.MemoExoticComponent<({ messages, isLoading, serverId, readResource, tools, sendMessage, messagesEndRef, traceEvents, modelContextScope, llmConfig, }: MessageListProps) => react_jsx_runtime.JSX.Element>;
+
+interface ChatHeaderProps {
+    llmConfig: LLMConfig | null;
+    hasMessages: boolean;
+    configDialogOpen: boolean;
+    onConfigDialogOpenChange: (open: boolean) => void;
+    onClearChat: () => void;
+    onCopyChat?: () => void;
+    onExportChat?: (format: "json" | "markdown") => void;
+    tempProvider: ProviderName;
+    tempModel: string;
+    tempApiKey: string;
+    tempBaseUrl: string;
+    onProviderChange: (provider: ProviderName) => void;
+    onModelChange: (model: string) => void;
+    onApiKeyChange: (apiKey: string) => void;
+    onBaseUrlChange: (baseUrl: string) => void;
+    onSaveConfig: () => void;
+    onClearConfig: () => void;
+    /** When true, hides the API key config badge/button and dialog. */
+    hideConfigButton?: boolean;
+    /** Hosted inspector — unified Configure Chat dialog layout. */
+    hostedInspector?: boolean;
+    /**
+     * When set, the header shows a "Free tier" badge (instead of the local
+     * provider/model badge) and passes this info down to the ConfigurationDialog
+     * so it renders a Sign-in CTA above the bring-your-own-key form.
+     * Used in hosted inspector mode where the LLM is managed server-side.
+     */
+    freeTierInfo?: {
+        onLoginClick: () => void;
+    };
+    managedCloudInfo?: {
+        models: CloudModel[];
+        selectedModelId: string;
+        onModelChange: (modelId: string) => void;
+        isLoading?: boolean;
+    };
+    useManagedCloud?: boolean;
+    onSaveManagedCloud?: () => void;
+    /** When true, shows Clear Config in the BYOK tab of the config dialog. */
+    showClearButton?: boolean;
+    /** Label for the clear/new-chat button. Default: "New Chat". */
+    clearButtonLabel?: string;
+    /** When true, hides the "Chat" title in the header. */
+    hideTitle?: boolean;
+    /** When true, hides the icon on the clear/new-chat button. */
+    clearButtonHideIcon?: boolean;
+    /** When true, hides the keyboard shortcut (⌘O) on the clear/new-chat button. */
+    clearButtonHideShortcut?: boolean;
+    /** Button variant for the clear/new-chat button. Default: "default". */
+    clearButtonVariant?: "default" | "secondary" | "ghost" | "outline";
+    /** When true, hides the "New Chat" / clear button entirely. */
+    hideClearButton?: boolean;
+    /** Active chat id — enables animated title reveal in the header. */
+    activeChatId?: string | null;
+    /** Title for the active chat thread. */
+    chatTitle?: string;
+    /** When true, shows Conv / Raw tabs in the header. */
+    showViewToggle?: boolean;
+    /** 0 = Conv, 1 = Raw */
+    viewIndex?: 0 | 1;
+    onViewIndexChange?: (index: number) => void;
+    /** Raise header above host chrome (cloud embed). */
+    elevatedHeader?: boolean;
+}
+declare function ChatHeader({ llmConfig, hasMessages, configDialogOpen, onConfigDialogOpenChange, onClearChat, tempProvider, tempModel, tempApiKey, tempBaseUrl, onProviderChange, onModelChange, onApiKeyChange, onBaseUrlChange, onSaveConfig, onClearConfig, hideConfigButton, hostedInspector, freeTierInfo, managedCloudInfo, useManagedCloud, onSaveManagedCloud, showClearButton, clearButtonLabel, hideTitle, clearButtonHideIcon, clearButtonHideShortcut, clearButtonVariant, hideClearButton, onCopyChat, onExportChat, activeChatId, chatTitle, showViewToggle, viewIndex, onViewIndexChange, elevatedHeader, }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
+
+/** Frosted pill for chat header controls — chat scrolls underneath the absolute header. */
+declare const chatBarFrostedPill = "rounded-full bg-background/80 backdrop-blur-md supports-[backdrop-filter]:bg-background/60 dark:bg-zinc-950/75 dark:supports-[backdrop-filter]:bg-zinc-950/55";
+/** Title pill: no extra padding so text stays aligned with other tab headers. */
+declare const chatBarTitleFrostedClass: string;
+declare const chatBarActionButtonClass: string;
+
+interface PendingElicitationRequest {
+    id: string;
+    request: ElicitRequestFormParams | ElicitRequestURLParams;
+    timestamp: number;
+    serverName: string;
+    toolName?: string;
+}
+
+interface PromptResult {
+    promptName: string;
+    args: Record<string, unknown>;
+    result: GetPromptResult | {
+        error?: string;
+        isError?: boolean;
+    };
+    error?: string;
+    timestamp: number;
+    duration?: number;
+}
+interface UseMCPPromptsProps {
+    prompts: Prompt[];
+    callPrompt: (name: string, args?: Record<string, unknown>) => Promise<GetPromptResult>;
+    serverId: string;
+}
+/**
+ * Manages prompt selection, execution, and results for an MCP server.
+ * Provides filtered prompts, execution state, and result management.
+ */
+declare function useMCPPrompts({ prompts, callPrompt, serverId, }: UseMCPPromptsProps): {
+    filteredPrompts: {
+        name: string;
+        description?: string | undefined;
+        arguments?: {
+            name: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "dark" | "light" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    }[];
+    selectedPrompt: {
+        name: string;
+        description?: string | undefined;
+        arguments?: {
+            name: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "dark" | "light" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | null;
+    setSelectedPrompt: react.Dispatch<react.SetStateAction<{
+        name: string;
+        description?: string | undefined;
+        arguments?: {
+            name: string;
+            description?: string | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "dark" | "light" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | null>>;
+    results: PromptResult[];
+    handleDeleteResult: (index: number) => void;
+    promptArgs: Record<string, unknown>;
+    setPromptArgs: react.Dispatch<react.SetStateAction<Record<string, unknown>>>;
+    isExecuting: boolean;
+    handlePromptSelect: (prompt: Prompt) => void;
+    handleArgChange: (key: string, value: any) => void;
+    executePrompt: (prompt: Prompt, args: Record<string, unknown>) => Promise<void>;
+    executeSelectedPrompt: () => Promise<void>;
+    searchQuery: string;
+    setSearchQuery: react.Dispatch<react.SetStateAction<string>>;
+    clearPromptResults: () => void;
+};
+
+interface ToolInfo {
+    name: string;
+    description?: string;
+}
+
+interface ChatInputAreaProps$1 {
+    inputValue: string;
+    isConnected: boolean;
+    isLoading: boolean;
+    textareaRef: react__default.RefObject<HTMLTextAreaElement | null>;
+    llmConfig: LLMConfig | null;
+    promptsDropdownOpen: boolean;
+    promptFocusedIndex: number;
+    prompts: Prompt[];
+    selectedPrompt: Prompt | null;
+    promptResults: PromptResult[];
+    attachments: MessageAttachment[];
+    tools?: ToolInfo[];
+    disabledTools?: Set<string>;
+    onDisabledToolsChange?: (disabledTools: Set<string>) => void;
+    onInputChange: (value: string) => void;
+    onKeyDown: (e: react__default.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onKeyUp: (e: react__default.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onClick: () => void;
+    onSendMessage: () => void;
+    onStopStreaming: () => void;
+    onConfigDialogOpenChange: (open: boolean) => void;
+    onPromptSelect: (prompt: Prompt) => void;
+    onDeletePromptResult: (index: number) => void;
+    onAttachmentAdd: (file: File) => void;
+    onAttachmentRemove: (index: number) => void;
+    /** When true, hides the model badge in the input toolbar. */
+    hideModelBadge?: boolean;
+    /**
+     * When set (hosted-managed mode), keeps the model badge visible for upgrade
+     * even when `hideModelBadge` is true.
+     */
+    freeTierInfo?: {
+        onLoginClick: () => void;
+    };
+    managedCloudInfo?: {
+        models: CloudModel[];
+        selectedModelId: string;
+        onModelChange: (modelId: string) => void;
+        isLoading?: boolean;
+    };
+    modelBadgeMode?: "managed" | "byok";
+    modelDisplayName?: string;
+    /** Optional followup suggestions rendered above the chat input. */
+    followups?: string[];
+    /** Called when a followup suggestion is selected. */
+    onFollowupSelect?: (followup: string) => void;
+    /** Pending MCP elicitation requests — rendered floating above the composer. */
+    pendingElicitationRequests?: PendingElicitationRequest[];
+    onApproveElicitation?: (requestId: string, result: ElicitResult) => void;
+    onRejectElicitation?: (requestId: string, error?: string) => void;
+    /** Pluggable system prompt source (localStorage or host API). */
+    systemPromptProvider?: ChatSystemPromptProvider;
+}
+declare function ChatInputArea({ inputValue, isConnected, isLoading, textareaRef, llmConfig, promptsDropdownOpen, promptFocusedIndex, prompts, selectedPrompt, promptResults, attachments, tools, disabledTools, onDisabledToolsChange, onInputChange, onKeyDown, onKeyUp, onClick, onSendMessage, onStopStreaming, onConfigDialogOpenChange, onPromptSelect, onDeletePromptResult, onAttachmentAdd, onAttachmentRemove, hideModelBadge, freeTierInfo, managedCloudInfo, modelBadgeMode, modelDisplayName, followups, onFollowupSelect, pendingElicitationRequests, onApproveElicitation, onRejectElicitation, systemPromptProvider, }: ChatInputAreaProps$1): react_jsx_runtime.JSX.Element;
+
+type ChatInputAreaProps = react__default.ComponentProps<typeof ChatInputArea>;
+interface ChatLandingFormProps extends ChatInputAreaProps {
+    serverDisplayName: string;
+    /** Inline notice rendered above the composer (e.g. managed chat errors). */
+    composerNotice?: ReactNode;
+    /** Optional quick question suggestions displayed below the landing input. */
+    quickQuestions?: string[];
+    /** Called when a quick question is selected. */
+    onQuickQuestionSelect?: (question: string) => void;
+}
+declare function ChatLandingForm({ serverDisplayName, composerNotice, quickQuestions, onQuickQuestionSelect, ...inputAreaProps }: ChatLandingFormProps): react_jsx_runtime.JSX.Element;
+
+interface ConfigurationDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    tempProvider: ProviderName;
+    tempModel: string;
+    tempApiKey: string;
+    tempBaseUrl: string;
+    onProviderChange: (provider: ProviderName) => void;
+    onModelChange: (model: string) => void;
+    onApiKeyChange: (apiKey: string) => void;
+    onBaseUrlChange: (baseUrl: string) => void;
+    onSave: () => void;
+    onClear?: () => void;
+    showClearButton?: boolean;
+    buttonLabel?: string;
+    /** Hosted inspector — use unified Configure Chat layout. */
+    hostedInspector?: boolean;
+    /**
+     * When present, the dialog renders a mesh-gradient sign-in card above the
+     * provider/api-key form. Used in hosted inspector mode where the default
+     * LLM is provided server-side.
+     */
+    freeTierInfo?: {
+        onLoginClick: () => void;
+    };
+    /** Authenticated hosted tier — Manufact cloud models + source tabs. */
+    managedCloudInfo?: {
+        models: CloudModel[];
+        selectedModelId: string;
+        onModelChange: (modelId: string) => void;
+        isLoading?: boolean;
+    };
+    /** When true, chat uses Manufact cloud; drives the default config tab. */
+    useManagedCloud?: boolean;
+    /** Persist Manufact cloud selection and switch chat to managed mode. */
+    onSaveManagedCloud?: () => void;
+}
+declare function ConfigurationDialog({ open, onOpenChange, tempProvider, tempModel, tempApiKey, tempBaseUrl, onProviderChange, onModelChange, onApiKeyChange, onBaseUrlChange, onSave, onClear, showClearButton, buttonLabel: _buttonLabel, hostedInspector, freeTierInfo, managedCloudInfo, useManagedCloud, onSaveManagedCloud, }: ConfigurationDialogProps): react_jsx_runtime.JSX.Element;
+
+interface ConfigureEmptyStateProps {
+    onConfigureClick: () => void;
+}
+declare function ConfigureEmptyState({ onConfigureClick, }: ConfigureEmptyStateProps): react_jsx_runtime.JSX.Element;
+
+declare const DEFAULT_CHAT_SYSTEM_PROMPT = "You are a helpful assistant with access to MCP tools. Help users interact with the MCP server.";
+
+declare function getSystemPromptStorageKey(serverId: string): string;
+declare function readStoredSystemPrompt(serverId: string): string | null;
+declare function writeStoredSystemPrompt(serverId: string, prompt: string): void;
+declare function resolveSystemPrompt(stored: string | null | undefined): string;
+
+type ManagedChatNotice = {
+    kind: "cloud_unavailable";
+} | {
+    kind: "login_required";
+    loginUrl: string;
+} | {
+    kind: "credits_exhausted";
+    billingUrl?: string;
+    message?: string;
+};
+
+type MCPConnection = McpServer;
+interface UseChatMessagesClientSideProps {
+    connection: MCPConnection;
+    llmConfig: LLMConfig | null;
+    isConnected: boolean;
+    readResource?: (uri: string) => Promise<any>;
+    widgetModelContexts?: Map<string, WidgetModelContext | undefined>;
+    disabledTools?: Set<string>;
+    appToolConnections?: McpConnectionLike[];
+    initialMessages?: Message$1[];
+    systemPrompt?: string;
+}
+declare function useChatMessagesClientSide({ connection, llmConfig, isConnected, readResource, widgetModelContexts, disabledTools, appToolConnections, initialMessages, systemPrompt, }: UseChatMessagesClientSideProps): {
+    messages: Message$1[];
+    isLoading: boolean;
+    attachments: MessageAttachment[];
+    managedChatNotice: ManagedChatNotice | null;
+    sendMessage: (userInput: string, promptResults: PromptResult[], extraAttachments?: MessageAttachment[], options?: SendMessageOptions) => Promise<void>;
+    clearMessages: () => void;
+    clearManagedChatNotice: () => void;
+    showManagedChatNotice: (notice: ManagedChatNotice) => void;
+    setMessages: react.Dispatch<react.SetStateAction<Message$1[]>>;
+    stop: () => void;
+    addAttachment: (file: File) => Promise<void>;
+    removeAttachment: (index: number) => void;
+    clearAttachments: () => void;
+    clearTrace: () => void;
+    traceEvents: InspectorTraceEvent[];
+    tokenUsage: InspectorTokenUsage | undefined;
+};
+
+interface UseChatMessagesProps {
+    mcpServerUrl: string;
+    llmConfig: LLMConfig | null;
+    authConfig: AuthConfig | null;
+    /** Live OAuth tokens from the active MCP connection (preferred over saved authConfig). */
+    mcpAuthTokens?: AuthConfig["oauthTokens"];
+    isConnected: boolean;
+    /** Custom API endpoint URL for chat streaming. Defaults to "/inspector/api/chat/stream". */
+    chatApiUrl?: string;
+    /** When chatApiUrl is not yet available, called before sending to resolve the URL. Useful for background initialization. */
+    waitForChatApiUrl?: () => Promise<string | undefined>;
+    /** Active widget model contexts to inject into the LLM conversation */
+    widgetModelContexts?: Map<string, WidgetModelContext | undefined>;
+    /** Pre-populate the chat with messages from a previous session (e.g. when restoring history). */
+    initialMessages?: Message$1[];
+    /** Tool names the user has disabled via the tool selector. Sent to the server so it can exclude them. */
+    disabledTools?: Set<string>;
+    /**
+     * Wire protocol used by the streaming endpoint.
+     * - `"sse"` (default): Inspector SSE protocol (`data: {"type":"text","content":"..."}\n\n`)
+     * - `"data-stream"`: Vercel AI SDK data-stream protocol (`0:"text"`, `9:{...}`, etc.)
+     */
+    streamProtocol?: StreamProtocol;
+    /** Credentials policy for the fetch request (e.g. `"include"` for cross-origin cookie auth). */
+    credentials?: RequestCredentials;
+    /** Extra headers to send with every streaming request. */
+    extraHeaders?: Record<string, string>;
+    /**
+     * Custom body builder. Receives the serialised messages array and returns the
+     * object that will be JSON-stringified as the request body.
+     * When omitted, the default body includes `mcpServerUrl`, `llmConfig`,
+     * `authConfig`, and `messages`.
+     * The second argument contains the effective disabled tools and serialized
+     * scoped widget context.
+     */
+    body?: ChatBodyBuilder;
+}
+declare function useChatMessages({ mcpServerUrl, llmConfig, authConfig, mcpAuthTokens, isConnected, chatApiUrl, waitForChatApiUrl, widgetModelContexts, initialMessages, disabledTools, streamProtocol, credentials, extraHeaders, body: bodyBuilder, }: UseChatMessagesProps): {
+    messages: Message$1[];
+    isLoading: boolean;
+    attachments: MessageAttachment[];
+    managedChatNotice: ManagedChatNotice | null;
+    mcpServerAuthRequired: {
+        mcpServerUrl: string;
+        message?: string;
+    } | null;
+    sendMessage: (userInput: string, promptResults: PromptResult[], extraAttachments?: MessageAttachment[], options?: SendMessageOptions) => Promise<void>;
+    clearMessages: () => void;
+    clearManagedChatNotice: () => void;
+    showManagedChatNotice: (notice: ManagedChatNotice) => void;
+    clearMcpServerAuthRequired: () => void;
+    setMessages: react.Dispatch<react.SetStateAction<Message$1[]>>;
+    stop: () => void;
+    addAttachment: (file: File) => Promise<void>;
+    removeAttachment: (index: number) => void;
+    clearAttachments: () => void;
+    clearTrace: () => void;
+    traceEvents: InspectorTraceEvent[];
+    tokenUsage: InspectorTokenUsage | undefined;
+};
+
+interface UseConfigProps {
+    mcpServerUrl: string;
+}
+declare function useConfig({ mcpServerUrl }: UseConfigProps): {
+    llmConfig: LLMConfig | null;
+    authConfig: AuthConfig | null;
+    configDialogOpen: boolean;
+    setConfigDialogOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    tempProvider: ProviderName;
+    setTempProvider: react.Dispatch<react.SetStateAction<ProviderName>>;
+    tempApiKey: string;
+    setTempApiKey: react.Dispatch<react.SetStateAction<string>>;
+    tempModel: string;
+    setTempModel: react.Dispatch<react.SetStateAction<string>>;
+    tempBaseUrl: string;
+    setTempBaseUrl: react.Dispatch<react.SetStateAction<string>>;
+    tempAuthType: "none" | "basic" | "bearer" | "oauth";
+    saveLLMConfig: () => boolean;
+    clearConfig: () => void;
+};
+
+interface ChatHistoryPanelProps {
+    provider: ChatStorageProvider;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    currentChatId?: string;
+    container?: HTMLElement | null;
+    agentId?: string;
+    /** When agent relation is denied (e.g. server chat agents), use this for display instead of "Unknown Agent" */
+    agentDisplayNameFallback?: string;
+    /** Called on chat selection; panel closes when provided */
+    onSelectChat?: (chatId: string) => void;
+    /** "drawer" = Sheet overlay (default). "inline" = content only, no overlay; parent controls layout */
+    variant?: "drawer" | "inline";
+    /** Optional class for the inline panel container */
+    containerClassName?: string;
+    /** When this value changes, triggers an immediate refetch of the chat list */
+    refetchKey?: number;
+    /** Poll interval in ms when set (e.g. server chat) */
+    refetchInterval?: number | false;
+    /** Called when the currently active chat is deleted */
+    onCurrentChatDeleted?: () => void;
+    onDeleteSuccess?: () => void;
+    onDeleteError?: (error: unknown) => void;
+}
+declare function ChatHistoryPanel({ provider, open, onOpenChange, currentChatId, container, agentId, agentDisplayNameFallback, onSelectChat, variant, containerClassName, refetchKey, refetchInterval, onCurrentChatDeleted, onDeleteSuccess, onDeleteError, }: ChatHistoryPanelProps): react_jsx_runtime.JSX.Element;
+
+declare function ChatHistoryHeader({ count }: {
+    count: number;
+}): react_jsx_runtime.JSX.Element;
+
+/** Collapse control on the drawer edge — only shown when history is open. */
+declare function ChatHistoryRail({ onCollapse }: {
+    onCollapse: () => void;
+}): react_jsx_runtime.JSX.Element;
+
+interface ChatListProps {
+    chats: ChatSession[];
+    onDelete: (id: string) => void;
+    /** When provided, render buttons that call this instead of navigation links */
+    onSelect?: (chatId: string) => void;
+    /** When true, align item content with header (reduced horizontal padding) */
+    compact?: boolean;
+    /** When true, hide the agent name line (e.g. for MCP Server Chat where it's not an agent) */
+    hideAgentName?: boolean;
+    /** When true and chats is empty, show skeleton placeholders instead of empty state */
+    isLoading?: boolean;
+    /** Highlight the active chat */
+    currentChatId?: string;
+}
+declare function ChatList({ chats, onDelete: _onDelete, onSelect, compact, hideAgentName, isLoading, currentChatId, }: ChatListProps): react_jsx_runtime.JSX.Element;
+
+interface ChatTitleRevealProps {
+    chatId: string;
+    title: string;
+    className?: string;
+    onRevealComplete?: () => void;
+}
+/** Reveals a generated title over the placeholder with blur-fade typing. */
+declare function ChatTitleReveal({ chatId, title, className, onRevealComplete, }: ChatTitleRevealProps): react_jsx_runtime.JSX.Element;
+
+declare class LocalChatStorageProvider implements ChatStorageProvider {
+    private saveTimers;
+    listChats(params: ListChatsParams): Promise<{
+        items: ChatSession[];
+        total: number;
+    }>;
+    getMessages(chatId: string): Promise<Message$1[]>;
+    createChat(params: {
+        agentId: string;
+        title?: string;
+        agentName?: string;
+    }): Promise<ChatSession>;
+    updateChat(chatId: string, patch: {
+        title?: string;
+    }): Promise<ChatSession>;
+    deleteChat(chatId: string): Promise<void>;
+    saveMessages(chatId: string, messages: Message$1[]): Promise<void>;
+}
+
+/** Shape of rows from GET /api/v1/chats/:id/events (OpenAPI). */
+type ChatEventRowForMessages = {
+    id: string;
+    type: string;
+    eventData: unknown;
+    createdAt: string | Date;
+};
+/**
+ * Convert persisted chat events → inspector `Message[]` (same contract as the backend stream).
+ */
+declare function chatEventsToInspectorMessages(events: ChatEventRowForMessages[]): Message$1[];
+
+interface UseChatHistoryOptions {
+    provider: ChatStorageProvider;
+    enabled?: boolean;
+    agentId?: string;
+    refetchKey?: number;
+    refetchInterval?: number | false;
+}
+declare function useChatHistory({ provider, enabled, agentId, refetchKey, refetchInterval, }: UseChatHistoryOptions): {
+    chats: ChatSession[];
+    total: number;
+    isLoading: boolean;
+    error: Error | null;
+    hasNextPage: boolean;
+    loadMore: () => void;
+    refetch: () => void;
+    deleteChat: (chatId: string) => Promise<void>;
+};
+
+/** Placeholder title for new chats; must match storage default and cloud DB default. */
+declare const CHAT_TITLE_PLACEHOLDER = "New Chat";
+/** Short title when the first message has no concrete topic yet. */
+declare const CHAT_TITLE_SIMPLE = "Chat";
+declare function isPlaceholderTitle(title: string): boolean;
+declare function firstUserMessageFromMessages(messages: Message$1[]): string | null;
+/** Generate a concise title from the first user message using the connected LLM. */
+declare function generateChatTitleWithLlm(llmConfig: LLMConfig, message: string, signal?: AbortSignal): Promise<string | null>;
+
+type UseChatTitleGenerationParams = {
+    activeChatId: string | null;
+    storage: ChatStorageProvider | null;
+    messages: Message$1[];
+    isLoading: boolean;
+    effectiveClientSide: boolean;
+    llmConfig: LLMConfig | null;
+    activeChatTitle?: string;
+    titleGenerationReady?: boolean;
+    onTitleGenerated?: (chatId: string, title: string) => void;
+    onHistoryRefetch?: () => void;
+};
+declare function useChatTitleGeneration({ activeChatId, storage, messages, isLoading, effectiveClientSide, llmConfig, activeChatTitle, titleGenerationReady, onTitleGenerated, onHistoryRefetch, }: UseChatTitleGenerationParams): void;
+
+export { AddToClientDropdown, type AuthConfig, CHAT_TITLE_PLACEHOLDER, CHAT_TITLE_SIMPLE, type ChatBodyBuilder, type ChatBodyContext, type ChatEventRowForMessages, ChatHeader, ChatHistoryHeader, ChatHistoryPanel, ChatHistoryRail, ChatInputArea, ChatLandingForm, ChatList, type ChatSerializedMessage, type ChatSession, type ChatStorageProvider, type ChatSystemPromptProvider, ChatTab, type ChatTabProps, ChatTitleReveal, type ChatView, ConfigurationDialog, ConfigureEmptyState, DEFAULT_CHAT_SYSTEM_PROMPT, type EmbeddedConfig, InspectorProvider, type InspectorTokenUsage, type InspectorTraceEvent, type InspectorTraceSpan, type InspectorTraceState, type LLMConfig, type ListChatsParams, LocalChatStorageProvider, type MCPConfig, type MCPServerConfig, type Message$1 as Message, type MessageAttachment, MessageList, type PromptResult, PromptsTab, type PromptsTabRef, ResourcesTab, type ResourcesTabRef, type StreamProtocol, type TabType, ThemeProvider, ToolInputForm, type ToolResult, ToolResultDisplay, ToolResultRenderer, ToolsTab, type ToolsTabRef, WidgetDebugProvider, chatBarActionButtonClass, chatBarFrostedPill, chatBarTitleFrostedClass, chatEventsToInspectorMessages, downloadMcpbFile, firstUserMessageFromMessages, generateChatTitleWithLlm, generateClaudeCodeCommand, generateCodexConfig, generateCursorDeepLink, generateGeminiCLICommand, generateMcpbConfig, generatePythonSDKCode, generateTypeScriptSDKCode, generateVSCodeDeepLink, generateVSCodeInsidersDeepLink, getEnvVarInstructions, getSystemPromptStorageKey, isPlaceholderTitle, readStoredSystemPrompt, resolveSystemPrompt, useChatHistory, useChatMessages, useChatMessagesClientSide, useChatTitleGeneration, useConfig, useInspector, useMCPPrompts, writeStoredSystemPrompt };