@eaperezc/mcpgen 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,297 @@
+import { I as InlineToolDefinition, c as InlineResourceDefinition, d as InlinePromptDefinition, T as TransportConfig, e as AuthConfig, L as LogLevel, S as ServerHooks, M as McpServer, f as Logger, R as RequestContextData, A as AuthContext, g as Transport, H as HttpTransportConfig } from './types-B9yzEar_.js';
+export { k as ApiKeyConfig, l as ApiKeyValidationResult, b as BasePrompt, a as BaseResource, B as BaseTool, U as ContextKey, Y as CorsConfig, K as LogEntry, Q as LogTransport, N as LoggerConfig, O as OAuthConfig, F as PromptArgumentMetadata, C as PromptDefinition, E as PromptHandler, z as PromptMessage, G as PromptMetadata, P as PromptRegistry, D as PromptResult, y as PromptRole, s as ResourceContent, t as ResourceDefinition, v as ResourceHandler, w as ResourceMetadata, r as ResourceRegistry, u as ResourceResult, x as ResourceTemplate, j as ServerCapabilities, h as ServerConfig, i as ServerInfo, X as SseTransportConfig, W as StdioTransportConfig, Z as TlsConfig, n as ToolDefinition, p as ToolHandler, q as ToolMetadata, m as ToolRegistry, o as ToolResult, V as TransportType, J as logger } from './types-B9yzEar_.js';
+import { z } from 'zod';
+export { z } from 'zod';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+/**
+ * Fluent builder for creating MCP servers
+ *
+ * @example
+ * ```typescript
+ * const server = createServer({ name: 'my-server', version: '1.0.0' })
+ *   .tool('greet', {
+ *     description: 'Greets a user',
+ *     schema: z.object({ name: z.string() }),
+ *     handler: async ({ name }) => ({ content: `Hello, ${name}!` }),
+ *   })
+ *   .resource('config://app', {
+ *     name: 'App Config',
+ *     read: async () => ({ version: '1.0.0' }),
+ *   })
+ *   .withLogging({ level: 'debug' })
+ *   .build();
+ *
+ * await server.start();
+ * ```
+ */
+declare class ServerBuilder {
+    private config;
+    private tools;
+    private resources;
+    private prompts;
+    private hooks;
+    constructor(config: {
+        name: string;
+        version: string;
+        description?: string;
+    });
+    /**
+     * Add a tool using inline definition
+     */
+    tool<TSchema extends z.ZodType>(name: string, definition: InlineToolDefinition<TSchema>): ServerBuilder;
+    /**
+     * Add a resource using inline definition
+     */
+    resource(uri: string, definition: InlineResourceDefinition): ServerBuilder;
+    /**
+     * Add a prompt using inline definition
+     */
+    prompt<TArgs extends z.ZodType>(name: string, definition: InlinePromptDefinition<TArgs>): ServerBuilder;
+    /**
+     * Configure transport
+     */
+    withTransport(transport: 'stdio' | TransportConfig): ServerBuilder;
+    /**
+     * Configure authentication
+     */
+    withAuth(auth: AuthConfig): ServerBuilder;
+    /**
+     * Configure logging
+     */
+    withLogging(options: {
+        level?: LogLevel;
+        pretty?: boolean;
+    }): ServerBuilder;
+    /**
+     * Configure auto-discovery
+     */
+    withDiscovery(options: {
+        enabled?: boolean;
+        directories?: {
+            tools?: string;
+            resources?: string;
+            prompts?: string;
+        };
+    }): ServerBuilder;
+    /**
+     * Add lifecycle hooks
+     */
+    withHooks(hooks: ServerHooks): ServerBuilder;
+    /**
+     * Add a hook for before start
+     */
+    onBeforeStart(fn: () => Promise<void> | void): ServerBuilder;
+    /**
+     * Add a hook for after start
+     */
+    onAfterStart(fn: () => Promise<void> | void): ServerBuilder;
+    /**
+     * Add a hook for before stop
+     */
+    onBeforeStop(fn: () => Promise<void> | void): ServerBuilder;
+    /**
+     * Add a hook for after stop
+     */
+    onAfterStop(fn: () => Promise<void> | void): ServerBuilder;
+    /**
+     * Add an error handler
+     */
+    onError(fn: (error: Error) => Promise<void> | void): ServerBuilder;
+    /**
+     * Build the server instance
+     */
+    build(): McpServer;
+    /**
+     * Build and start the server
+     */
+    start(): Promise<McpServer>;
+}
+/**
+ * Create a new server builder
+ */
+declare function createServer(config: {
+    name: string;
+    version: string;
+    description?: string;
+}): ServerBuilder;
+
+/**
+ * Create a new request context
+ */
+declare function createRequestContext(correlationId?: string, logger?: Logger): RequestContextData;
+/**
+ * Run a function within a request context
+ */
+declare function runInRequestContext<T>(fn: () => T, context?: RequestContextData): T;
+/**
+ * Run an async function within a request context
+ */
+declare function runInRequestContextAsync<T>(fn: () => Promise<T>, context?: RequestContextData): Promise<T>;
+/**
+ * Get the current request context
+ * @returns The current context or undefined if not in a context
+ */
+declare function getRequestContext(): RequestContextData | undefined;
+/**
+ * Get the current request context or throw if not in a context
+ */
+declare function requireRequestContext(): RequestContextData;
+/**
+ * Get the correlation ID from current context
+ */
+declare function getCorrelationId(): string | undefined;
+/**
+ * Get the logger from current context
+ */
+declare function getContextLogger(): Logger;
+/**
+ * Set authentication context for current request
+ */
+declare function setAuthContext(auth: AuthContext): void;
+/**
+ * Get authentication context from current request
+ */
+declare function getAuthContext(): AuthContext | undefined;
+/**
+ * Set a custom value in the context
+ */
+declare function setContextValue<T>(key: string, value: T): void;
+/**
+ * Get a custom value from the context
+ */
+declare function getContextValue<T>(key: string): T | undefined;
+/**
+ * Get the request duration in milliseconds
+ */
+declare function getRequestDuration(): number | undefined;
+
+/**
+ * Error codes for MCP operations
+ */
+declare enum McpErrorCode {
+    SERVER_NOT_INITIALIZED = "SERVER_NOT_INITIALIZED",
+    SERVER_ALREADY_RUNNING = "SERVER_ALREADY_RUNNING",
+    SERVER_SHUTDOWN_ERROR = "SERVER_SHUTDOWN_ERROR",
+    TOOL_NOT_FOUND = "TOOL_NOT_FOUND",
+    TOOL_EXECUTION_ERROR = "TOOL_EXECUTION_ERROR",
+    TOOL_VALIDATION_ERROR = "TOOL_VALIDATION_ERROR",
+    TOOL_ALREADY_REGISTERED = "TOOL_ALREADY_REGISTERED",
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
+    RESOURCE_READ_ERROR = "RESOURCE_READ_ERROR",
+    RESOURCE_ALREADY_REGISTERED = "RESOURCE_ALREADY_REGISTERED",
+    PROMPT_NOT_FOUND = "PROMPT_NOT_FOUND",
+    PROMPT_RENDER_ERROR = "PROMPT_RENDER_ERROR",
+    PROMPT_ALREADY_REGISTERED = "PROMPT_ALREADY_REGISTERED",
+    AUTH_INVALID_TOKEN = "AUTH_INVALID_TOKEN",
+    AUTH_TOKEN_EXPIRED = "AUTH_TOKEN_EXPIRED",
+    AUTH_INSUFFICIENT_SCOPE = "AUTH_INSUFFICIENT_SCOPE",
+    AUTH_MISSING_CREDENTIALS = "AUTH_MISSING_CREDENTIALS",
+    TRANSPORT_ERROR = "TRANSPORT_ERROR",
+    TRANSPORT_CONNECTION_CLOSED = "TRANSPORT_CONNECTION_CLOSED",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    SCHEMA_ERROR = "SCHEMA_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"
+}
+interface McpErrorOptions {
+    code: McpErrorCode;
+    message: string;
+    cause?: Error;
+    details?: Record<string, unknown>;
+}
+
+/**
+ * Base error class for all MCP-related errors
+ */
+declare class McpError extends Error {
+    readonly code: McpErrorCode;
+    readonly details?: Record<string, unknown>;
+    readonly timestamp: Date;
+    constructor(options: McpErrorOptions);
+    /**
+     * Convert error to a JSON-serializable object
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Create an error for tool not found
+     */
+    static toolNotFound(toolName: string): McpError;
+    /**
+     * Create an error for resource not found
+     */
+    static resourceNotFound(uri: string): McpError;
+    /**
+     * Create an error for prompt not found
+     */
+    static promptNotFound(promptName: string): McpError;
+    /**
+     * Create a validation error
+     */
+    static validationError(message: string, details?: Record<string, unknown>): McpError;
+    /**
+     * Create an authentication error
+     */
+    static authError(code: McpErrorCode.AUTH_INVALID_TOKEN | McpErrorCode.AUTH_TOKEN_EXPIRED | McpErrorCode.AUTH_INSUFFICIENT_SCOPE | McpErrorCode.AUTH_MISSING_CREDENTIALS, message: string): McpError;
+    /**
+     * Create an internal error
+     */
+    static internal(message: string, cause?: Error): McpError;
+}
+
+/**
+ * HTTP Transport for MCP servers
+ *
+ * Implements the MCP Streamable HTTP transport specification,
+ * supporting both SSE streaming and direct HTTP responses.
+ *
+ * @example
+ * ```typescript
+ * const transport = new HttpTransport({
+ *   type: 'http',
+ *   port: 3000,
+ *   cors: { origin: ['https://myapp.com'] },
+ * });
+ *
+ * await transport.start(mcpServer);
+ * ```
+ */
+declare class HttpTransport implements Transport {
+    private config;
+    private logger;
+    private httpServer;
+    private mcpTransport;
+    private running;
+    constructor(config: HttpTransportConfig, logger?: Logger);
+    /**
+     * Start the HTTP transport
+     */
+    start(mcpServer?: Server): Promise<void>;
+    /**
+     * Stop the HTTP transport
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if transport is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get the underlying MCP transport (for advanced use cases)
+     */
+    getMcpTransport(): StreamableHTTPServerTransport | null;
+    /**
+     * Handle incoming HTTP request
+     */
+    private handleRequest;
+    /**
+     * Set CORS headers on response
+     */
+    private setCorsHeaders;
+    /**
+     * Parse request body as JSON
+     */
+    private parseBody;
+}
+
+export { AuthConfig, AuthContext, HttpTransport, HttpTransportConfig, InlinePromptDefinition, InlineResourceDefinition, InlineToolDefinition, LogLevel, Logger, McpError, McpErrorCode, type McpErrorOptions, McpServer, RequestContextData, ServerBuilder, ServerHooks, Transport, TransportConfig, createRequestContext, createServer, getAuthContext, getContextLogger, getContextValue, getCorrelationId, getRequestContext, getRequestDuration, requireRequestContext, runInRequestContext, runInRequestContextAsync, setAuthContext, setContextValue };