indusagi 0.13.7 → 0.13.8

package/dist/types/facade/mcp-core/errors.d.ts

@@ -0,0 +1,103 @@
+/**
+ * MCP Error Types
+ *
+ * Reference: structured MCP error handling patterns.
+ */
+/**
+ * Error codes for MCP operations.
+ */
+export declare enum MCPErrorCode {
+    /** Failed to connect to MCP server */
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    /** Request timed out */
+    TIMEOUT = "TIMEOUT",
+    /** Tool not found on server */
+    TOOL_NOT_FOUND = "TOOL_NOT_FOUND",
+    /** Invalid parameters for tool call */
+    INVALID_PARAMETERS = "INVALID_PARAMETERS",
+    /** Server returned an error */
+    SERVER_ERROR = "SERVER_ERROR",
+    /** Transport layer error */
+    TRANSPORT_ERROR = "TRANSPORT_ERROR",
+    /** Not connected to server */
+    NOT_CONNECTED = "NOT_CONNECTED",
+    /** Protocol error */
+    PROTOCOL_ERROR = "PROTOCOL_ERROR",
+    /** Configuration error */
+    CONFIG_ERROR = "CONFIG_ERROR",
+    /** Schema conversion error */
+    SCHEMA_CONVERSION_ERROR = "SCHEMA_CONVERSION_ERROR",
+    /** Resource not found */
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
+    /** Prompt not found */
+    PROMPT_NOT_FOUND = "PROMPT_NOT_FOUND",
+    /** Session error (requires reconnection) */
+    SESSION_ERROR = "SESSION_ERROR"
+}
+/**
+ * Error class for MCP operations.
+ * Provides structured error information with error codes and details.
+ */
+export declare class MCPError extends Error {
+    /** Error code */
+    readonly code: MCPErrorCode;
+    /** Additional error details */
+    readonly details?: unknown;
+    /** Server name where error occurred */
+    readonly serverName?: string;
+    /** Tool name if error occurred during tool execution */
+    readonly toolName?: string;
+    constructor(message: string, code: MCPErrorCode, details?: unknown, options?: {
+        serverName?: string;
+        toolName?: string;
+        cause?: Error;
+    });
+    /**
+     * Convert error to JSON for logging/serialization.
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Create a string representation of the error.
+     */
+    toString(): string;
+}
+/**
+ * Type guard to check if an error is an MCPError.
+ */
+export declare function isMCPError(error: unknown): error is MCPError;
+/**
+ * Check if an error indicates a session problem requiring reconnection.
+ */
+export declare function isSessionError(error: unknown): boolean;
+/**
+ * Create a connection failed error.
+ */
+export declare function createConnectionError(serverName: string, cause?: Error): MCPError;
+/**
+ * Create a timeout error.
+ */
+export declare function createTimeoutError(operation: string, serverName?: string): MCPError;
+/**
+ * Create a tool not found error.
+ */
+export declare function createToolNotFoundError(toolName: string, serverName?: string): MCPError;
+/**
+ * Create an invalid parameters error.
+ */
+export declare function createInvalidParametersError(toolName: string, details: unknown, serverName?: string): MCPError;
+/**
+ * Create a server error.
+ */
+export declare function createServerError(message: string, serverName?: string, details?: unknown): MCPError;
+/**
+ * Create a not connected error.
+ */
+export declare function createNotConnectedError(serverName?: string): MCPError;
+/**
+ * Create a config error.
+ */
+export declare function createConfigError(message: string, details?: unknown): MCPError;
+/**
+ * Create a schema conversion error.
+ */
+export declare function createSchemaConversionError(toolName: string, details: unknown, serverName?: string): MCPError;

package/dist/types/facade/mcp-core/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * MCP Module - Public Exports
+ *
+ * This module provides Model Context Protocol (MCP) support for new_indusvx.
+ * It allows connecting to MCP servers and using their tools as AgentTools.
+ *
+ * @example
+ * ```typescript
+ * import { MCPClient, MCPClientPool, loadMCPConfig } from "new_indusvx/mcp";
+ * import { ToolRegistry } from "new_indusvx/agent";
+ *
+ * // Load config from file
+ * const configs = loadMCPConfig(process.cwd());
+ *
+ * // Create a client pool
+ * const pool = new MCPClientPool({ servers: configs });
+ * await pool.connectAll();
+ *
+ * // Register tools
+ * const registry = new ToolRegistry();
+ * for (const client of pool.getAllClients()) {
+ *   const tools = await client.listTools();
+ *   await registerMCPToolsInRegistry(registry, client, tools);
+ * }
+ * ```
+ */
+import { MCPClientPool } from "./client-pool.js";
+export { MCPClient, type MCPClientOptions } from "./client.js";
+export { MCPClientPool, type MCPClientPoolOptions, type MCPServerStatus } from "./client-pool.js";
+export { mcpClientToToolBox } from "./toolbox-bridge.js";
+export type { McpToToolBoxOptions } from "./toolbox-bridge.js";
+export * as oauth from "./oauth/index.js";
+export type { McpOAuthClientProvider } from "./oauth/index.js";
+export { MCPServer, createMCPServer, type MCPServerOptions } from "./server.js";
+export { createMCPAgentToolFactory, registerMCPToolsInRegistry, createMCPToolsMap, createMCPToolsRecord, type MCPToolClient, } from "./tool-factory.js";
+export { jsonSchemaToTypeBox, applyPassthrough, convertMCPInputSchema, convertMCPOutputSchema, } from "./schema-converter.js";
+export { loadMCPConfig, getUserConfigPath, getProjectConfigPath, ensureUserConfigDir, ensureProjectConfigDir, saveConfig, saveUserConfig, saveProjectConfig, createDefaultConfig, EXAMPLE_CONFIG, } from "./config.js";
+export { MCPError, MCPErrorCode, isMCPError, isSessionError, createConnectionError, createTimeoutError, createToolNotFoundError, createInvalidParametersError, createServerError, createNotConnectedError, createConfigError, createSchemaConversionError, } from "./errors.js";
+export type { StdioServerConfig, HttpServerConfig, MCPServerConfig, MCPConnectionOptions, MCPToolDefinition, MCPResource, MCPPrompt, MCPInitializeResult, MCPClientState, MCPToolCallRequest, MCPContentBlock, MCPToolCallResult, MCPServerConfigEntry, MCPConfigFile, MCPLoggingLevel, MCPLogMessage, MCPLogHandler, MCPProgressNotification, MCPProgressHandler, MCPElicitRequest, MCPElicitResult, MCPElicitationHandler, MCPRoot, BaseServerOptions, } from "./types.js";
+/**
+ * Convenience function: Initialize MCP and register tools.
+ *
+ * This is the simplest way to add MCP support to an agent.
+ *
+ * @example
+ * ```typescript
+ * import { initializeMCP } from "new_indusvx/mcp";
+ * import { ToolRegistry, Agent } from "new_indusvx/agent";
+ *
+ * const registry = new ToolRegistry();
+ * const { pool, toolCount } = await initializeMCP(registry, process.cwd());
+ *
+ * console.log(`Connected to ${pool.getAllClients().length} servers with ${toolCount} tools`);
+ * ```
+ */
+export declare function initializeMCP(registry: import("../bot/actions/registry.js").ToolRegistry, cwd?: string): Promise<{
+    pool: MCPClientPool;
+    toolCount: number;
+}>;

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

@@ -0,0 +1,72 @@
+/**
+ * Local-callback server for MCP OAuth.
+ *
+ * The MCP SDK OAuth flow for CLIs is:
+ *   1. Pre-bind a 127.0.0.1 callback server → known `redirect_uri`
+ *   2. Pass that URL as `OAuthClientProvider.redirectUrl`
+ *   3. On 401 the SDK opens the browser via `redirectToAuthorization`
+ *   4. SDK returns REDIRECT → transport throws UnauthorizedError
+ *   5. Caller waits for the browser hit, then `transport.finishAuth(code)`
+ *   6. Reconnect
+ *
+ * This module owns steps 1 and 5's wait half. Browser open lives in
+ * {@link openBrowser}; the provider and MCPClient wire the rest.
+ */
+/**
+ * A pre-bound OAuth callback listener.
+ *
+ * Bind once before the MCP connect attempt so `redirect_uri` in the authorize
+ * request matches a real listening port. Then call {@link OAuthCallbackServer.waitForCode}
+ * after the SDK throws UnauthorizedError.
+ */
+export interface OAuthCallbackServer {
+    /** Absolute redirect URI, e.g. `http://127.0.0.1:54321/callback`. */
+    readonly redirectUri: string;
+    /** Bound port. */
+    readonly port: number;
+    /**
+     * Wait for the browser to hit the callback with `?code=…`.
+     * If `expectedState` is set, a mismatched `state` rejects.
+     */
+    waitForCode(expectedState?: string): Promise<string>;
+    /** Tear down the listener. Idempotent. */
+    close(): void;
+}
+/**
+ * Bind a one-shot OAuth callback server on 127.0.0.1 (random free port).
+ *
+ * Important: the 5‑minute wait timer starts only when {@link OAuthCallbackServer.waitForCode}
+ * is called (i.e. when the SDK actually needs browser OAuth). If tokens are already
+ * on disk and connect succeeds without OAuth, we must NOT arm a timer — otherwise a
+ * later orphan rejection crashes the process with:
+ *   "oauth-callback: timed out after … waiting for browser login"
+ */
+export declare function startOAuthCallbackServer(options?: {
+    timeoutMs?: number;
+    logger?: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+}): Promise<OAuthCallbackServer>;
+/**
+ * Back-compat helper used by older call sites: bind + wait in one shot.
+ * Prefer {@link startOAuthCallbackServer} so `redirect_uri` is known before authorize.
+ */
+export declare function waitForAuthorizationCode(expectedState: string, options?: {
+    timeoutMs?: number;
+    logger?: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+}): Promise<{
+    code: string;
+    redirectUri: string;
+    port: number;
+    close(): void;
+}>;
+/**
+ * Open the user's browser to the auth URL. Falls back silently if the runtime
+ * has no GUI (CI, headless containers). The caller should always log the URL
+ * too so the user can open it manually.
+ */
+export declare function openBrowser(url: string): Promise<boolean>;

package/dist/types/facade/mcp-core/oauth/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public barrel for the MCP OAuth submodule.
+ *
+ * The MCP OAuth flow is large (RFC 9728 discovery, RFC 7636 PKCE, RFC 7591
+ * dynamic registration, plus a browser redirect handler), but the
+ * indus-rebuild package only contributes the pieces the official
+ * `@modelcontextprotocol/sdk` cannot provide itself: a persistent token store
+ * and a local-callback HTTP server. The orchestrator (`auth()`) and the
+ * PKCE / refresh primitives all come from the SDK — re-export them so a
+ * power user can call them directly without reaching into the SDK.
+ */
+export { createMcpOAuthProvider, type McpOAuthClientProvider, } from "./provider.js";
+export type { McpClientInfo, McpOAuthConfig, McpOAuthState, McpTokenSet } from "./types.js";
+export { readMcpOAuthState, writeMcpOAuthState, clearMcpOAuthState, resolveCredentialsDir, credentialsPath, } from "./token-store.js";
+export { waitForAuthorizationCode, startOAuthCallbackServer, openBrowser, } from "./flow.js";
+export type { OAuthCallbackServer } from "./flow.js";
+export { auth, discoverOAuthServerInfo, startAuthorization, exchangeAuthorization, refreshAuthorization, registerClient, extractWWWAuthenticateParams, } from "@modelcontextprotocol/sdk/client/auth.js";
+export type { OAuthTokens, OAuthClientMetadata, OAuthClientInformationMixed } from "@modelcontextprotocol/sdk/shared/auth.js";

package/dist/types/facade/mcp-core/oauth/oauth.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for the MCP OAuth submodule.
+ *
+ * The tests focus on what *we* add (token-store persistence, provider plumbing,
+ * URL parsing) rather than re-validating the SDK. Every test uses a temp dir
+ * and never reads or writes the real `~/.config/indusagi/credentials/mcp/`.
+ */
+export {};

package/dist/types/facade/mcp-core/oauth/provider.d.ts

@@ -0,0 +1,51 @@
+/**
+ * An `OAuthClientProvider` implementation that persists every state transition
+ * to disk and coordinates a local callback server for the browser redirect.
+ *
+ * Matches the official SDK CLI pattern (`simpleOAuthClient`):
+ *   - `redirectToAuthorization` only opens the browser (does NOT wait)
+ *   - the MCP transport throws `UnauthorizedError` after REDIRECT
+ *   - the caller awaits {@link McpOAuthClientProvider.waitForAuthorizationCode}
+ *   - then calls `transport.finishAuth(code)` and reconnects
+ *
+ * The callback server is pre-bound at provider creation so `redirect_uri` is a
+ * real `http://127.0.0.1:<port>/callback` before the authorize request is sent.
+ */
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { McpOAuthConfig } from "./types.js";
+/**
+ * The provider object returned by {@link createMcpOAuthProvider}.
+ *
+ * Implements every required method of the SDK's `OAuthClientProvider`.
+ */
+export interface McpOAuthClientProvider {
+    readonly id: string;
+    readonly credentialsDir: string;
+    /** Real callback URL (pre-bound). */
+    readonly redirectUrl: string;
+    readonly clientMetadata: OAuthClientMetadata;
+    state(): string;
+    clientInformation(): OAuthClientInformationMixed | undefined;
+    saveClientInformation(client: OAuthClientInformationMixed): void;
+    tokens(): OAuthTokens | undefined;
+    saveTokens(tokens: OAuthTokens): void;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): void;
+    /**
+     * Wait for the browser OAuth round to complete after UnauthorizedError.
+     * Returns the authorization code for `transport.finishAuth(code)`.
+     */
+    waitForAuthorizationCode(): Promise<string>;
+    /** Tear down the local callback listener. Call after connect succeeds or fails. */
+    dispose(): void;
+    /** Last authorization URL (for logging / manual open). */
+    lastAuthorizationUrl(): string | undefined;
+}
+/**
+ * Build a persistent `OAuthClientProvider` for one MCP server.
+ *
+ * Always async: pre-binds the callback port so `redirectUrl` is real.
+ */
+export declare function createMcpOAuthProvider(config: McpOAuthConfig): Promise<McpOAuthClientProvider>;

package/dist/types/facade/mcp-core/oauth/token-store.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Persistent token store for MCP OAuth state.
+ *
+ * One JSON file per server id under `<credentialsDir>/<id>.json`. On POSIX we
+ * create the file with mode 0600 so only the owning user can read tokens; on
+ * other platforms we fall back to the umask default. Tokens and PKCE verifiers
+ * are short-lived material that must never leak to a multi-user host.
+ *
+ * The store is deliberately synchronous — every method is small and the caller
+ * is already in an async context, so wrapping in fs.promises would just add
+ * microtask overhead for no benefit.
+ */
+import type { McpOAuthState } from "./types.js";
+/** Resolve the credentials directory, honoring the override when supplied. */
+export declare function resolveCredentialsDir(override?: string): string;
+/** File path for a given server id. */
+export declare function credentialsPath(credentialsDir: string, id: string): string;
+/**
+ * Read the persisted state for `id`, or `undefined` if nothing was stored yet.
+ * Returns `undefined` rather than throwing on missing-file so callers can
+ * treat the cold start as "needs authorization".
+ */
+export declare function readMcpOAuthState(credentialsDir: string, id: string): McpOAuthState | undefined;
+/**
+ * Write state atomically: temp file in the same directory + rename, so a
+ * crash mid-write cannot leave a half-formed token file. Creates the parent
+ * directory if needed.
+ */
+export declare function writeMcpOAuthState(credentialsDir: string, state: McpOAuthState): void;
+/** Remove the state file. Idempotent. */
+export declare function clearMcpOAuthState(credentialsDir: string, id: string): void;

package/dist/types/facade/mcp-core/oauth/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Types for the MCP OAuth submodule.
+ *
+ * The MCP spec delegates OAuth to the official SDK (RFC 9728 Protected Resource
+ * Metadata discovery, RFC 7636 PKCE, RFC 7591 Dynamic Client Registration).
+ * This submodule supplies only the persistent state and the local-redirect
+ * capture the SDK cannot do on its own — the rest of the flow (PKCE challenge
+ * generation, discovery, token exchange, refresh) is delegated to
+ * `@modelcontextprotocol/sdk/client/auth.js`.
+ */
+/**
+ * The persistent token set we keep on disk across agent invocations.
+ *
+ * Aligned with the SDK's `OAuthTokens` shape so we can hand it straight back
+ * to the SDK without translation. `client_id` / `client_secret` come from
+ * RFC 7591 dynamic registration when the server supports it.
+ */
+export interface McpTokenSet {
+    /** OAuth access token; sent as `Authorization: Bearer <accessToken>`. */
+    readonly access_token: string;
+    /** Long-lived refresh token; used to mint new access tokens without a browser. */
+    readonly refresh_token?: string;
+    /** Optional scope string echoed back from the auth server. */
+    readonly scope?: string;
+    /** Token type; "Bearer" by default. */
+    readonly token_type?: string;
+    /** Absolute epoch-ms deadline derived from the server's `expires_in`. */
+    readonly expires_at?: number;
+}
+/**
+ * RFC 7591 client information persisted after dynamic registration. Many MCP
+ * servers do not require pre-registration, but when they do we need to reuse
+ * the issued client_id on every subsequent connection.
+ */
+export interface McpClientInfo {
+    readonly client_id: string;
+    readonly client_secret?: string;
+    readonly client_id_issued_at?: number;
+    readonly client_secret_expires_at?: number;
+}
+/**
+ * Per-server state persisted to disk. Keyed by stable server id (defaults to
+ * the MCP URL host). One file per id keeps isolation and rotation simple.
+ */
+export interface McpOAuthState {
+    /** Stable id (typically the MCP server URL host). */
+    readonly id: string;
+    /** When the state was last written, epoch-ms. */
+    readonly updatedAt: number;
+    /** Tokens from the last successful auth round. */
+    tokens?: McpTokenSet;
+    /** Client info from RFC 7591 dynamic registration, if performed. */
+    client?: McpClientInfo;
+    /** RFC 9728 protected resource metadata, cached to skip re-discovery. */
+    resourceMetadata?: unknown;
+    /** RFC 8414 authorization server metadata, cached to skip re-discovery. */
+    authServerMetadata?: unknown;
+    /** PKCE code verifier held between `startAuthorization` and the callback. */
+    codeVerifier?: string;
+    /** OAuth `state` parameter held between start and callback for CSRF check. */
+    state?: string;
+}
+/**
+ * Configuration passed when wiring up an OAuth-aware MCP client.
+ */
+export interface McpOAuthConfig {
+    /** Stable id used for the on-disk file name and the SDK's session. */
+    readonly id: string;
+    /** Override path to the credentials directory. Default: `~/.config/indusagi/credentials/mcp/`. */
+    readonly credentialsDir?: string;
+    /** Where to listen for the OAuth callback. Default: `http://127.0.0.1:<random>/callback`. */
+    readonly redirectUrl?: string;
+    /** Client metadata sent to RFC 7591 dynamic registration. */
+    readonly clientMetadata?: {
+        readonly client_name?: string;
+        readonly client_uri?: string;
+        readonly logo_uri?: string;
+        readonly contacts?: readonly string[];
+        readonly tos_uri?: string;
+        readonly policy_uri?: string;
+        readonly redirect_uris?: readonly string[];
+        readonly token_endpoint_auth_method?: "none" | "client_secret_basic" | "client_secret_post";
+        readonly grant_types?: readonly string[];
+        readonly response_types?: readonly string[];
+        readonly scope?: string;
+    };
+    /** Open the browser for the user to complete the auth round. Default: true in TTY. */
+    readonly openBrowser?: boolean;
+    /** Skip opening the browser and print the URL instead. */
+    readonly logger?: {
+        debug(msg: string): void;
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}

package/dist/types/facade/mcp-core/schema-converter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * JSON Schema to TypeBox Converter
+ *
+ * Converts MCP tool schemas (JSON Schema) to TypeBox schemas
+ * for validation in new_indusvx.
+ *
+ * Reference: JSON Schema conversion adapted to TypeBox.
+ */
+import { type TSchema } from "@sinclair/typebox";
+/**
+ * JSON Schema types we support
+ */
+interface JSONSchema {
+    type?: string | string[];
+    description?: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema | JSONSchema[];
+    enum?: (string | number | boolean | null)[];
+    const?: string | number | boolean | null;
+    additionalProperties?: boolean | JSONSchema;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minItems?: number;
+    maxItems?: number;
+    multipleOf?: number;
+    default?: unknown;
+    oneOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    allOf?: JSONSchema[];
+    $ref?: string;
+}
+/**
+ * Convert JSON Schema to TypeBox schema.
+ *
+ * Handles:
+ * - Primitive types (string, number, boolean, null)
+ * - Objects with properties
+ * - Arrays with items
+ * - Optional fields (not in required array)
+ * - Enums
+ * - Nested structures
+ */
+export declare function jsonSchemaToTypeBox(schema: JSONSchema): TSchema;
+/**
+ * Apply passthrough to allow extra properties.
+ *
+ * MCP servers may return extra fields not in the schema,
+ * so we use passthrough to avoid validation errors.
+ */
+export declare function applyPassthrough(schema: TSchema): TSchema;
+/**
+ * Convert MCP tool inputSchema to TypeBox with passthrough.
+ * This is the main entry point for converting MCP tool schemas.
+ */
+export declare function convertMCPInputSchema(inputSchema: Record<string, unknown>): TSchema;
+/**
+ * Convert MCP tool outputSchema to TypeBox with passthrough.
+ */
+export declare function convertMCPOutputSchema(outputSchema: Record<string, unknown> | undefined): TSchema | undefined;
+export {};

package/dist/types/facade/mcp-core/server.d.ts

@@ -0,0 +1,110 @@
+/**
+ * MCP Server
+ *
+ * Exposes new_indusvx tools as an MCP server.
+ * Compatible with Claude Desktop, Cursor, etc.
+ *
+ * Reference: MCP server implementation patterns.
+ */
+import type { AgentTool } from "../bot/types.js";
+/**
+ * Options for creating an MCP server.
+ */
+export interface MCPServerOptions {
+    /** Server name */
+    name: string;
+    /** Server version */
+    version?: string;
+    /** Tools to expose */
+    tools: AgentTool<any>[];
+    /** Optional description */
+    description?: string;
+}
+/**
+ * Tool converted for MCP protocol.
+ */
+interface MCPConvertedTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * MCP Server - exposes new_indusvx tools via the Model Context Protocol.
+ *
+ * Supports stdio transport for subprocess communication.
+ *
+ * @example
+ * ```typescript
+ * import { MCPServer } from "new_indusvx/mcp";
+ * import { createBashTool } from "new_indusvx/agent/tools";
+ *
+ * const server = new MCPServer({
+ *   name: "My Tools Server",
+ *   version: "1.0.0",
+ *   tools: [createBashTool()],
+ * });
+ *
+ * await server.startStdio();
+ * ```
+ */
+export declare class MCPServer {
+    private options;
+    private tools;
+    private buffer;
+    private isConnected;
+    /** Server name */
+    readonly name: string;
+    /** Server version */
+    readonly version: string;
+    constructor(options: MCPServerOptions);
+    /**
+     * Start the server using stdio transport.
+     *
+     * This is typically used when running the server as a subprocess
+     * that MCP clients (like Claude Desktop) spawn.
+     */
+    startStdio(): Promise<void>;
+    /**
+     * Stop the server.
+     */
+    stop(): Promise<void>;
+    /**
+     * Add a tool to the server.
+     */
+    addTool(tool: AgentTool<any>): void;
+    /**
+     * Remove a tool from the server.
+     */
+    removeTool(name: string): boolean;
+    /**
+     * List all available tools.
+     */
+    listTools(): MCPConvertedTool[];
+    private convertTool;
+    private typeBoxToJsonSchema;
+    private processBuffer;
+    private handleMessage;
+    private handleRequest;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    private sendResponse;
+    private sendError;
+}
+/**
+ * Create an MCP server from tools.
+ *
+ * @example
+ * ```typescript
+ * const server = createMCPServer({
+ *   name: "My Tools",
+ *   tools: [bashTool, readTool, writeTool],
+ * });
+ *
+ * await server.startStdio();
+ * ```
+ */
+export declare function createMCPServer(options: MCPServerOptions): MCPServer;
+export {};