@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/mcp/client.d.ts

@@ -0,0 +1,74 @@
+import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerCapabilities, MCPServerConfig, MCPServerConnection, MCPToolCallResult, MCPToolDefinition } from "./types";
+/**
+ * Connect to an MCP server.
+ * Has a 30 second timeout to prevent blocking startup.
+ */
+export declare function connectToServer(name: string, config: MCPServerConfig, options?: {
+    signal?: AbortSignal;
+    onNotification?: (method: string, params: unknown) => void;
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+}): Promise<MCPServerConnection>;
+/**
+ * List tools from a connected server.
+ */
+export declare function listTools(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPToolDefinition[]>;
+/**
+ * Call a tool on a connected server.
+ */
+export declare function callTool(connection: MCPServerConnection, toolName: string, args?: Record<string, unknown>, options?: MCPRequestOptions): Promise<MCPToolCallResult>;
+/**
+ * Disconnect from a server.
+ */
+export declare function disconnectServer(connection: MCPServerConnection): Promise<void>;
+/**
+ * Check if a server supports tools.
+ */
+export declare function serverSupportsTools(capabilities: MCPServerCapabilities): boolean;
+/**
+ * List resources from a connected server.
+ */
+export declare function listResources(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPResource[]>;
+/**
+ * List resource templates from a connected server.
+ */
+export declare function listResourceTemplates(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPResourceTemplate[]>;
+/**
+ * Read a resource from a connected server.
+ */
+export declare function readResource(connection: MCPServerConnection, uri: string, options?: MCPRequestOptions): Promise<MCPResourceReadResult>;
+/**
+ * Subscribe to resource update notifications.
+ */
+export declare function subscribeToResources(connection: MCPServerConnection, uris: string[], options?: MCPRequestOptions): Promise<void>;
+/**
+ * Unsubscribe from resource update notifications.
+ */
+export declare function unsubscribeFromResources(connection: MCPServerConnection, uris: string[], options?: MCPRequestOptions): Promise<void>;
+/**
+ * Check if a server supports resource subscriptions.
+ */
+export declare function serverSupportsResourceSubscriptions(capabilities: MCPServerCapabilities): boolean;
+/**
+ * Check if a server supports resources.
+ */
+export declare function serverSupportsResources(capabilities: MCPServerCapabilities): boolean;
+/**
+ * List prompts from a connected server.
+ */
+export declare function listPrompts(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPPrompt[]>;
+/**
+ * Get a specific prompt from a connected server.
+ */
+export declare function getPrompt(connection: MCPServerConnection, name: string, args?: Record<string, string>, options?: MCPRequestOptions): Promise<MCPGetPromptResult>;
+/**
+ * Check if a server supports prompts.
+ */
+export declare function serverSupportsPrompts(capabilities: MCPServerCapabilities): boolean;

package/dist/types/mcp/config-writer.d.ts

@@ -0,0 +1,53 @@
+import { type MCPConfigFile, type MCPServerConfig } from "./types";
+/**
+ * Read an MCP config file.
+ * Returns empty config if file doesn't exist.
+ */
+export declare function readMCPConfigFile(filePath: string): Promise<MCPConfigFile>;
+/**
+ * Write an MCP config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export declare function writeMCPConfigFile(filePath: string, config: MCPConfigFile): Promise<void>;
+/**
+ * Validate server name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateServerName(name: string): string | undefined;
+/**
+ * Add an MCP server to a config file.
+ * Validates the config before writing.
+ *
+ * @throws Error if server name already exists or validation fails
+ */
+export declare function addMCPServer(filePath: string, name: string, config: MCPServerConfig): Promise<void>;
+/**
+ * Update an existing MCP server in a config file.
+ * If the server doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export declare function updateMCPServer(filePath: string, name: string, config: MCPServerConfig): Promise<void>;
+/**
+ * Remove an MCP server from a config file.
+ *
+ * @throws Error if server doesn't exist
+ */
+export declare function removeMCPServer(filePath: string, name: string): Promise<void>;
+/**
+ * Get a specific server config from a file.
+ * Returns undefined if server doesn't exist.
+ */
+export declare function getMCPServer(filePath: string, name: string): Promise<MCPServerConfig | undefined>;
+/**
+ * List all server names in a config file.
+ */
+export declare function listMCPServers(filePath: string): Promise<string[]>;
+/**
+ * Read the disabled servers list from a config file.
+ */
+export declare function readDisabledServers(filePath: string): Promise<string[]>;
+/**
+ * Add or remove a server name from the disabled servers list.
+ */
+export declare function setServerDisabled(filePath: string, name: string, disabled: boolean): Promise<void>;

package/dist/types/mcp/config.d.ts

@@ -0,0 +1,75 @@
+/**
+ * MCP configuration loader.
+ *
+ * Uses the capability system to load MCP servers from multiple sources.
+ */
+import type { SourceMeta } from "../capability/types";
+import type { MCPServerConfig } from "./types";
+/** Options for loading MCP configs */
+export interface LoadMCPConfigsOptions {
+    /** Whether to load project-level config (default: true) */
+    enableProjectConfig?: boolean;
+    /** Whether to filter out Exa MCP servers (default: true) */
+    filterExa?: boolean;
+    /** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+    filterBrowser?: boolean;
+}
+/** Result of loading MCP configs */
+export interface LoadMCPConfigsResult {
+    /** Loaded server configs */
+    configs: Record<string, MCPServerConfig>;
+    /** Extracted Exa API keys (if any were filtered) */
+    exaApiKeys: string[];
+    /** Source metadata for each server */
+    sources: Record<string, SourceMeta>;
+}
+/**
+ * Load all MCP server configs from standard locations.
+ * Uses the capability system for multi-source discovery.
+ *
+ * @param cwd Working directory (project root)
+ * @param options Load options
+ */
+export declare function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOptions): Promise<LoadMCPConfigsResult>;
+/**
+ * Check if a server config is an Exa MCP server.
+ */
+export declare function isExaMCPServer(name: string, config: MCPServerConfig): boolean;
+/**
+ * Extract Exa API key from an MCP server config.
+ */
+export declare function extractExaApiKey(config: MCPServerConfig): string | undefined;
+/** Result of filtering Exa MCP servers */
+export interface ExaFilterResult {
+    /** Configs with Exa servers removed */
+    configs: Record<string, MCPServerConfig>;
+    /** Extracted Exa API keys (if any) */
+    exaApiKeys: string[];
+    /** Source metadata for remaining servers */
+    sources: Record<string, SourceMeta>;
+}
+/**
+ * Filter out Exa MCP servers and extract their API keys.
+ * Since we have native Exa integration, we don't need the MCP server.
+ */
+export declare function filterExaMCPServers(configs: Record<string, MCPServerConfig>, sources: Record<string, SourceMeta>): ExaFilterResult;
+/**
+ * Validate server config has required fields.
+ */
+export declare function validateServerConfig(name: string, config: MCPServerConfig): string[];
+/**
+ * Check if a server config is a browser automation MCP server.
+ */
+export declare function isBrowserMCPServer(name: string, config: MCPServerConfig): boolean;
+/** Result of filtering browser MCP servers */
+export interface BrowserFilterResult {
+    /** Configs with browser servers removed */
+    configs: Record<string, MCPServerConfig>;
+    /** Source metadata for remaining servers */
+    sources: Record<string, SourceMeta>;
+}
+/**
+ * Filter out browser automation MCP servers.
+ * Since we have a native browser tool, we don't need these MCP servers.
+ */
+export declare function filterBrowserMCPServers(configs: Record<string, MCPServerConfig>, sources: Record<string, SourceMeta>): BrowserFilterResult;

package/dist/types/mcp/discoverable-tool-metadata.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Back-compat re-export layer.
+ * All types and functions have moved to src/tool-discovery/tool-index.ts.
+ * This file exists solely so existing imports continue to compile without changes.
+ */
+export type { DiscoverableMCPSearchDocument, DiscoverableMCPSearchIndex, DiscoverableMCPSearchResult, DiscoverableMCPTool, DiscoverableMCPToolServerSummary, DiscoverableMCPToolSummary, } from "../tool-discovery/tool-index";
+export { buildDiscoverableMCPSearchIndex, collectDiscoverableMCPTools, formatDiscoverableMCPToolServerSummary, getDiscoverableMCPTool, isMCPToolName, searchDiscoverableMCPTools, selectDiscoverableMCPToolNamesByServer, summarizeDiscoverableMCPTools, } from "../tool-discovery/tool-index";

package/dist/types/mcp/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MCP (Model Context Protocol) support.
+ *
+ * Provides per-project .mcp.json configuration for connecting to
+ * MCP servers via stdio or HTTP transports.
+ */
+export * from "./client";
+export * from "./config";
+export * from "./config-writer";
+export { callMCP, parseSSE } from "./json-rpc";
+export * from "./loader";
+export * from "./manager";
+export * from "./oauth-discovery";
+export * from "./tool-bridge";
+export * from "./tool-cache";
+export * from "./transports/http";
+export * from "./transports/stdio";
+export * from "./types";

package/dist/types/mcp/json-rpc.d.ts

@@ -0,0 +1,22 @@
+/** Parse SSE response format (lines starting with "data: ") */
+export declare function parseSSE(text: string): unknown;
+/** JSON-RPC 2.0 response structure */
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/**
+ * Call an MCP server with JSON-RPC 2.0 over HTTPS.
+ *
+ * @param url - Full MCP server URL (including any query parameters)
+ * @param method - JSON-RPC method name (e.g., "tools/list", "tools/call")
+ * @param params - Method parameters
+ * @returns Parsed JSON-RPC response
+ */
+export declare function callMCP<T = unknown>(url: string, method: string, params?: Record<string, unknown>): Promise<JsonRpcResponse<T>>;

package/dist/types/mcp/loader.d.ts

@@ -0,0 +1,43 @@
+import type { LoadedCustomTool } from "../extensibility/custom-tools/types";
+import { AgentStorage } from "../session/agent-storage";
+import type { AuthStorage } from "../session/auth-storage";
+import { MCPManager } from "./manager";
+/** Result from loading MCP tools */
+export interface MCPToolsLoadResult {
+    /** MCP manager (for lifecycle management) */
+    manager: MCPManager;
+    /** Loaded tools as LoadedCustomTool format */
+    tools: LoadedCustomTool[];
+    /** Errors keyed by server name */
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+    /** Connected server names */
+    connectedServers: string[];
+    /** Extracted Exa API keys from filtered MCP servers */
+    exaApiKeys: string[];
+}
+/** Options for loading MCP tools */
+export interface MCPToolsLoadOptions {
+    /** Called when starting to connect to servers */
+    onConnecting?: (serverNames: string[]) => void;
+    /** Whether to load project-level config (default: true) */
+    enableProjectConfig?: boolean;
+    /** Whether to filter out Exa MCP servers (default: true) */
+    filterExa?: boolean;
+    /** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+    filterBrowser?: boolean;
+    /** SQLite storage for MCP tool cache (null disables cache) */
+    cacheStorage?: AgentStorage | null;
+    /** Auth storage used to resolve OAuth credentials before initial MCP connect */
+    authStorage?: AuthStorage;
+}
+/**
+ * Discover and load MCP tools from .mcp.json files.
+ *
+ * @param cwd Working directory (project root)
+ * @param options Load options including progress callbacks
+ * @returns MCP tools in LoadedCustomTool format for integration
+ */
+export declare function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult>;

package/dist/types/mcp/manager.d.ts

@@ -0,0 +1,193 @@
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { SourceMeta } from "../capability/types";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { AuthStorage } from "../session/auth-storage";
+import type { MCPToolDetails } from "./tool-bridge";
+import type { MCPToolCache } from "./tool-cache";
+import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
+/**
+ * Stable, total ordering on MCP tools by name.
+ *
+ * Anthropic prompt caching keys on byte-identical tool definitions: any reorder
+ * of the tools array invalidates the tools cache breakpoint and forces a full
+ * prefix rebuild on the next request. MCP servers connect/reconnect at arbitrary
+ * times, so the natural "insertion order" of `#tools` is non-deterministic.
+ * Sorting after every mutation makes the array bytes independent of connection
+ * sequence.
+ */
+export declare function sortMCPToolsByName<T extends {
+    name: string;
+}>(tools: T[]): T[];
+export declare function resolveSubscriptionPostAction(notificationsEnabled: boolean, currentEpoch: number, subscriptionEpoch: number): "rollback" | "ignore" | "apply";
+/** Result of loading MCP tools */
+export interface MCPLoadResult {
+    /** Loaded tools as CustomTool instances */
+    tools: CustomTool<TSchema, MCPToolDetails>[];
+    /** Connection errors by server name */
+    errors: Map<string, string>;
+    /** Connected server names */
+    connectedServers: string[];
+    /** Extracted Exa API keys from filtered MCP servers */
+    exaApiKeys: string[];
+}
+/** Options for discovering and connecting to MCP servers */
+export interface MCPDiscoverOptions {
+    /** Whether to load project-level config (default: true) */
+    enableProjectConfig?: boolean;
+    /** Whether to filter out Exa MCP servers (default: true) */
+    filterExa?: boolean;
+    /** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+    filterBrowser?: boolean;
+    /** Called when starting to connect to servers */
+    onConnecting?: (serverNames: string[]) => void;
+}
+/**
+ * MCP Server Manager.
+ *
+ * Manages connections to MCP servers and provides tools to the agent.
+ */
+export declare class MCPManager {
+    #private;
+    private cwd;
+    private toolCache;
+    /** Process-global instance shared by internal URL protocol handlers and tools. */
+    static instance(): MCPManager | undefined;
+    /** Install or clear the process-global instance. */
+    static setInstance(value: MCPManager | undefined): void;
+    /** Reset the process-global instance. Test-only. */
+    static resetForTests(): void;
+    constructor(cwd: string, toolCache?: MCPToolCache | null);
+    /**
+     * Set a callback to receive all server notifications.
+     */
+    setOnNotification(handler: (serverName: string, method: string, params: unknown) => void): void;
+    /**
+     * Set a callback to fire when any server's tools change.
+     */
+    setOnToolsChanged(handler: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void): void;
+    /**
+     * Set a callback to fire when any server's resources change.
+     */
+    setOnResourcesChanged(handler: (serverName: string, uri: string) => void): void;
+    /**
+     * Set a callback to fire when any server's prompts change.
+     */
+    setOnPromptsChanged(handler: (serverName: string) => void): void;
+    setNotificationsEnabled(enabled: boolean): void;
+    /**
+     * Set the auth storage for resolving OAuth credentials.
+     */
+    setAuthStorage(authStorage: AuthStorage): void;
+    /**
+     * Discover and connect to all MCP servers from .mcp.json files.
+     * Returns tools and any connection errors.
+     */
+    discoverAndConnect(options?: MCPDiscoverOptions): Promise<MCPLoadResult>;
+    /**
+     * Connect to specific MCP servers.
+     * Connections are made in parallel for faster startup.
+     */
+    connectServers(configs: Record<string, MCPServerConfig>, sources: Record<string, SourceMeta>, onConnecting?: (serverNames: string[]) => void): Promise<MCPLoadResult>;
+    /**
+     * Get all loaded tools.
+     */
+    getTools(): CustomTool<TSchema, MCPToolDetails>[];
+    /**
+     * Get a specific connection.
+     */
+    getConnection(name: string): MCPServerConnection | undefined;
+    /**
+     * Get current connection status for a server.
+     */
+    getConnectionStatus(name: string): "connected" | "connecting" | "disconnected";
+    /**
+     * Get the source metadata for a server.
+     */
+    getSource(name: string): SourceMeta | undefined;
+    /**
+     * Wait for a connection to complete (or fail).
+     */
+    waitForConnection(name: string): Promise<MCPServerConnection>;
+    /**
+     * Resolve auth and shell-command substitutions in config before connecting.
+     */
+    prepareConfig(config: MCPServerConfig): Promise<MCPServerConfig>;
+    /**
+     * Get all connected server names.
+     */
+    getConnectedServers(): string[];
+    /**
+     * Get all known server names (connected, connecting, or discovered).
+     */
+    getAllServerNames(): string[];
+    /**
+     * Disconnect from a specific server.
+     */
+    disconnectServer(name: string): Promise<void>;
+    /**
+     * Disconnect from all servers.
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Reconnect to a server after a connection failure.
+     * Tears down the stale connection, re-resolves auth, establishes a new
+     * connection, reloads tools, and notifies consumers.
+     * Concurrent calls for the same server share one reconnection attempt.
+     * Returns the new connection, or null if reconnection failed.
+     */
+    reconnectServer(name: string): Promise<MCPServerConnection | null>;
+    /**
+     * Refresh tools from a specific server.
+     */
+    refreshServerTools(name: string): Promise<void>;
+    /**
+     * Refresh tools from all servers.
+     */
+    refreshAllTools(): Promise<void>;
+    /**
+     * Refresh resources from a specific server.
+     */
+    refreshServerResources(name: string): Promise<void>;
+    /**
+     * Refresh prompts from a specific server.
+     */
+    refreshServerPrompts(name: string): Promise<void>;
+    /**
+     * Get resources and templates for a specific server.
+     */
+    getServerResources(name: string): {
+        resources: MCPResource[];
+        templates: MCPResourceTemplate[];
+    } | undefined;
+    /**
+     * Read a specific resource from a server.
+     */
+    readServerResource(name: string, uri: string, options?: MCPRequestOptions): Promise<MCPResourceReadResult | undefined>;
+    /**
+     * Get prompts for a specific server.
+     */
+    getServerPrompts(name: string): MCPPrompt[] | undefined;
+    /**
+     * Get a specific prompt from a server.
+     */
+    executePrompt(name: string, promptName: string, args?: Record<string, string>, options?: MCPRequestOptions): Promise<MCPGetPromptResult | undefined>;
+    /**
+     * Get all server instructions (for system prompt injection).
+     */
+    getServerInstructions(): Map<string, string>;
+    /**
+     * Get notification state for display.
+     */
+    getNotificationState(): {
+        enabled: boolean;
+        subscriptions: Map<string, ReadonlySet<string>>;
+    };
+}
+/**
+ * Create an MCP manager and discover servers.
+ * Convenience function for quick setup.
+ */
+export declare function createMCPManager(cwd: string, options?: MCPDiscoverOptions): Promise<{
+    manager: MCPManager;
+    result: MCPLoadResult;
+}>;

package/dist/types/mcp/oauth-discovery.d.ts

@@ -0,0 +1,40 @@
+/**
+ * MCP OAuth Auto-Discovery
+ *
+ * Automatically detects OAuth requirements from MCP server responses
+ * and extracts authentication endpoints.
+ */
+export interface OAuthEndpoints {
+    authorizationUrl: string;
+    tokenUrl: string;
+    clientId?: string;
+    scopes?: string;
+}
+export interface AuthDetectionResult {
+    requiresAuth: boolean;
+    authType?: "oauth" | "apikey" | "unknown";
+    oauth?: OAuthEndpoints;
+    authServerUrl?: string;
+    message?: string;
+}
+export declare function extractMcpAuthServerUrl(error: Error): string | undefined;
+/**
+ * Detect if an error indicates authentication is required.
+ * Checks for common auth error patterns.
+ */
+export declare function detectAuthError(error: Error): boolean;
+/**
+ * Extract OAuth endpoints from error response.
+ * Looks for WWW-Authenticate header format or JSON error bodies.
+ */
+export declare function extractOAuthEndpoints(error: Error): OAuthEndpoints | null;
+/**
+ * Analyze an error to determine authentication requirements.
+ * Returns structured info about what auth is needed.
+ */
+export declare function analyzeAuthError(error: Error): AuthDetectionResult;
+/**
+ * Try to discover OAuth endpoints by querying the server's well-known endpoints.
+ * This is a fallback when error responses don't include OAuth metadata.
+ */
+export declare function discoverOAuthEndpoints(serverUrl: string, authServerUrl?: string): Promise<OAuthEndpoints | null>;

package/dist/types/mcp/oauth-flow.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Generic OAuth flow for MCP servers.
+ *
+ * Allows users to authenticate with any OAuth-compatible MCP server
+ * by providing authorization URL, token URL, and client credentials.
+ */
+import { OAuthCallbackFlow } from "@oh-my-pi/pi-ai/utils/oauth/callback-server";
+import type { OAuthController, OAuthCredentials } from "@oh-my-pi/pi-ai/utils/oauth/types";
+export interface MCPOAuthConfig {
+    /** Authorization endpoint URL */
+    authorizationUrl: string;
+    /** Token endpoint URL */
+    tokenUrl: string;
+    /** Client ID (optional when already embedded in authorization URL) */
+    clientId?: string;
+    /** Client secret (optional for PKCE flows) */
+    clientSecret?: string;
+    /** OAuth scopes (space-separated) */
+    scopes?: string;
+    /** Exact redirect URI to advertise to the provider */
+    redirectUri?: string;
+    /** Custom callback port (default: 3000) */
+    callbackPort?: number;
+    /** Custom callback path (default: /callback or redirectUri pathname) */
+    callbackPath?: string;
+}
+/**
+ * Generic OAuth flow for MCP servers.
+ * Supports standard OAuth 2.0 authorization code flow with PKCE.
+ */
+export declare class MCPOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    private config;
+    constructor(config: MCPOAuthConfig, ctrl: OAuthController);
+    /**
+     * Client id used during the authorization request. Returns the value supplied
+     * via {@link MCPOAuthConfig.clientId} or, when the server required dynamic
+     * client registration, the id issued during registration. `undefined` until
+     * {@link generateAuthUrl} (or {@link login}) has run for a server that needs
+     * a client id.
+     */
+    get resolvedClientId(): string | undefined;
+    /**
+     * Client secret issued by dynamic client registration, if any. Always
+     * `undefined` for PKCE-only/public clients and when the caller supplies the
+     * client id via config.
+     */
+    get registeredClientSecret(): string | undefined;
+    generateAuthUrl(state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials>;
+}
+/**
+ * Refresh an MCP OAuth token using the standard refresh_token grant.
+ * Returns updated credentials; preserves the old refresh token if the server doesn't rotate it.
+ */
+export declare function refreshMCPOAuthToken(tokenUrl: string, refreshToken: string, clientId?: string, clientSecret?: string): Promise<OAuthCredentials>;

package/dist/types/mcp/render.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TUI rendering for MCP tools.
+ *
+ * Provides structured display of MCP tool calls and results,
+ * showing args and output in JSON tree format similar to task tool.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { MCPToolDetails } from "./tool-bridge";
+/**
+ * Render MCP tool call.
+ */
+export declare function renderMCPCall(args: Record<string, unknown>, theme: Theme, label: string): Component;
+/**
+ * Render MCP tool result.
+ */
+export declare function renderMCPResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: MCPToolDetails;
+    isError?: boolean;
+}, options: RenderResultOptions, theme: Theme, args?: Record<string, unknown>): Component;

package/dist/types/mcp/smithery-auth.d.ts

@@ -0,0 +1,16 @@
+type SmitheryCliAuthSession = {
+    sessionId: string;
+    authUrl: string;
+};
+type SmitheryCliPollResponse = {
+    status: "pending" | "success" | "error";
+    apiKey?: string;
+    message?: string;
+};
+export declare function getSmitheryLoginUrl(): string;
+export declare function createSmitheryCliAuthSession(): Promise<SmitheryCliAuthSession>;
+export declare function pollSmitheryCliAuthSession(sessionId: string, signal?: AbortSignal): Promise<SmitheryCliPollResponse>;
+export declare function getSmitheryApiKey(): Promise<string | undefined>;
+export declare function saveSmitheryApiKey(apiKey: string): Promise<void>;
+export declare function clearSmitheryApiKey(): Promise<boolean>;
+export {};

package/dist/types/mcp/smithery-connect.d.ts

@@ -0,0 +1,38 @@
+export declare class SmitheryConnectError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+type SmitheryNamespace = {
+    name: string;
+};
+type SmitheryConnectionStatus = {
+    state: "connected";
+} | {
+    state: "auth_required";
+    authorizationUrl?: string;
+} | {
+    state: "error";
+    message: string;
+} | {
+    state: string;
+    [key: string]: unknown;
+};
+export type SmitheryConnection = {
+    connectionId: string;
+    mcpUrl: string;
+    name: string;
+    status?: SmitheryConnectionStatus;
+    createdAt?: string;
+};
+export declare function getSmitheryApiBaseUrl(): string;
+export declare function listSmitheryNamespaces(apiKey: string): Promise<SmitheryNamespace[]>;
+export declare function createSmitheryNamespace(apiKey: string): Promise<SmitheryNamespace>;
+export declare function resolveSmitheryNamespace(apiKey: string): Promise<string>;
+export declare function listSmitheryConnectionsByUrl(apiKey: string, namespace: string, mcpUrl: string): Promise<SmitheryConnection[]>;
+export declare function createSmitheryConnection(apiKey: string, namespace: string, params: {
+    mcpUrl: string;
+    name?: string;
+}): Promise<SmitheryConnection>;
+export declare function getSmitheryConnection(apiKey: string, namespace: string, connectionId: string): Promise<SmitheryConnection>;
+export declare function deleteSmitheryConnection(apiKey: string, namespace: string, connectionId: string): Promise<void>;
+export {};