recker 1.0.2-0

package/dist/core/request.js

@@ -0,0 +1,44 @@
+export class HttpRequest {
+    url;
+    method;
+    headers;
+    body;
+    signal;
+    throwHttpErrors;
+    onUploadProgress;
+    onDownloadProgress;
+    constructor(url, options = {}) {
+        this.url = url;
+        this.method = options.method || 'GET';
+        this.headers = new Headers(options.headers);
+        this.body = options.body || null;
+        this.signal = options.signal;
+        this.throwHttpErrors = options.throwHttpErrors !== undefined ? options.throwHttpErrors : true;
+        this.onUploadProgress = options.onUploadProgress;
+        this.onDownloadProgress = options.onDownloadProgress;
+    }
+    withHeader(name, value) {
+        const newHeaders = new Headers(this.headers);
+        newHeaders.set(name, value);
+        return new HttpRequest(this.url, {
+            method: this.method,
+            headers: newHeaders,
+            body: this.body,
+            signal: this.signal,
+            throwHttpErrors: this.throwHttpErrors,
+            onUploadProgress: this.onUploadProgress,
+            onDownloadProgress: this.onDownloadProgress,
+        });
+    }
+    withBody(body) {
+        return new HttpRequest(this.url, {
+            method: this.method,
+            headers: this.headers,
+            body: body,
+            signal: this.signal,
+            throwHttpErrors: this.throwHttpErrors,
+            onUploadProgress: this.onUploadProgress,
+            onDownloadProgress: this.onDownloadProgress,
+        });
+    }
+}

package/dist/core/response.d.ts

@@ -0,0 +1,33 @@
+import { ConnectionInfo, ReckerResponse, Timings, SSEEvent, ProgressEvent } from '../types/index.js';
+import { Dispatcher } from 'undici';
+import { type HeaderInfo, type CacheInfo, type RateLimitInfo } from '../utils/header-parser.js';
+import type { Readable } from 'node:stream';
+export declare class HttpResponse<T = unknown> implements ReckerResponse<T> {
+    readonly timings?: Timings;
+    readonly connection?: ConnectionInfo;
+    readonly raw: Response;
+    constructor(undiciRawResponse: Response | Dispatcher.ResponseData, options?: {
+        timings?: Timings;
+        connection?: ConnectionInfo;
+    });
+    get status(): number;
+    get statusText(): string;
+    get headers(): Headers;
+    get ok(): boolean;
+    get url(): string;
+    get cache(): CacheInfo;
+    get rateLimit(): RateLimitInfo;
+    get headerInfo(): HeaderInfo;
+    json<R = T>(): Promise<R>;
+    text(): Promise<string>;
+    cleanText(): Promise<string>;
+    blob(): Promise<Blob>;
+    read(): ReadableStream<Uint8Array> | null;
+    toNodeStream(): Readable | null;
+    pipe(destination: NodeJS.WritableStream): Promise<void>;
+    clone(): ReckerResponse<T>;
+    sse(): AsyncGenerator<SSEEvent>;
+    download(): AsyncGenerator<ProgressEvent>;
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+}
+//# sourceMappingURL=response.d.ts.map

package/dist/core/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/core/response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACrG,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAKpC,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,cAAc,CAAC,CAAC,CAAC;IACjE,SAAgB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClC,SAAgB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5C,SAAgB,GAAG,EAAE,QAAQ,CAAC;gBAG5B,iBAAiB,EAAE,QAAQ,GAAG,UAAU,CAAC,YAAY,EACrD,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,cAAc,CAAA;KAAO;IAkBlE,IAAI,MAAM,WAET;IAED,IAAI,UAAU,WAEb;IAED,IAAI,OAAO,YAEV;IAED,IAAI,EAAE,YAEL;IAED,IAAI,GAAG,WAEN;IAMD,IAAI,KAAK,IAAI,SAAS,CAErB;IAMD,IAAI,SAAS,IAAI,aAAa,CAE7B;IAKD,IAAI,UAAU,IAAI,UAAU,CAE3B;IAEK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;IAIzB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAIvB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI;IAqBzC,YAAY,IAAI,QAAQ,GAAG,IAAI;IAmBzB,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAc7D,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC;IAO1B,GAAG,IAAI,cAAc,CAAC,QAAQ,CAAC;IAQxB,QAAQ,IAAI,cAAc,CAAC,aAAa,CAAC;IAoDzC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,UAAU,CAAC;CAe5D"}

package/dist/core/response.js

@@ -0,0 +1,154 @@
+import { parseSSE } from '../utils/sse.js';
+import { cleanHtml } from '../utils/html-cleaner.js';
+import { webToNodeStream } from '../utils/streaming.js';
+import { parseHeaders } from '../utils/header-parser.js';
+export class HttpResponse {
+    timings;
+    connection;
+    raw;
+    constructor(undiciRawResponse, options = {}) {
+        this.timings = options.timings;
+        this.connection = options.connection;
+        if (undiciRawResponse instanceof Response) {
+            this.raw = undiciRawResponse;
+        }
+        else {
+            this.raw = new Response(undiciRawResponse.body, {
+                status: undiciRawResponse.statusCode,
+                statusText: String(undiciRawResponse.statusCode),
+                headers: undiciRawResponse.headers,
+            });
+        }
+    }
+    get status() {
+        return this.raw.status;
+    }
+    get statusText() {
+        return this.raw.statusText;
+    }
+    get headers() {
+        return this.raw.headers;
+    }
+    get ok() {
+        return this.raw.ok;
+    }
+    get url() {
+        return this.raw.url;
+    }
+    get cache() {
+        return parseHeaders(this.headers, this.status).cache;
+    }
+    get rateLimit() {
+        return parseHeaders(this.headers, this.status).rateLimit;
+    }
+    get headerInfo() {
+        return parseHeaders(this.headers, this.status);
+    }
+    async json() {
+        return (await this.raw.json());
+    }
+    async text() {
+        return this.raw.text();
+    }
+    async cleanText() {
+        const rawText = await this.text();
+        return cleanHtml(rawText);
+    }
+    async blob() {
+        return this.raw.blob();
+    }
+    read() {
+        return this.raw.body;
+    }
+    toNodeStream() {
+        if (!this.raw.body) {
+            return null;
+        }
+        return webToNodeStream(this.raw.body);
+    }
+    async pipe(destination) {
+        const nodeStream = this.toNodeStream();
+        if (!nodeStream) {
+            throw new Error('Response has no body to pipe');
+        }
+        return new Promise((resolve, reject) => {
+            nodeStream.pipe(destination);
+            nodeStream.on('end', resolve);
+            nodeStream.on('error', reject);
+            destination.on('error', reject);
+        });
+    }
+    clone() {
+        return new HttpResponse(this.raw.clone(), {
+            timings: this.timings,
+            connection: this.connection
+        });
+    }
+    sse() {
+        return parseSSE(this.raw);
+    }
+    async *download() {
+        if (!this.raw.body) {
+            return;
+        }
+        const contentLength = this.headers.get('content-length');
+        const total = contentLength ? parseInt(contentLength, 10) : undefined;
+        let loaded = 0;
+        const startTime = Date.now();
+        let lastUpdate = startTime;
+        const reader = this.raw.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    const elapsed = (Date.now() - startTime) / 1000;
+                    const rate = elapsed > 0 ? loaded / elapsed : 0;
+                    yield {
+                        loaded,
+                        total,
+                        percent: total ? 100 : undefined,
+                        rate,
+                    };
+                    break;
+                }
+                if (value) {
+                    loaded += value.byteLength;
+                    const now = Date.now();
+                    const elapsed = (now - startTime) / 1000;
+                    const rate = elapsed > 0 ? loaded / elapsed : 0;
+                    if (now - lastUpdate > 100) {
+                        yield {
+                            loaded,
+                            total,
+                            percent: total ? (loaded / total) * 100 : undefined,
+                            rate,
+                            estimated: total && rate > 0 ? ((total - loaded) / rate) * 1000 : undefined,
+                        };
+                        lastUpdate = now;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        if (!this.raw.body) {
+            return;
+        }
+        const reader = this.raw.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export * from './core/request-promise.js';
+export * from './transport/undici.js';
+export * from './transport/fetch.js';
+export * from './types/index.js';
+export * from './core/errors.js';
+export * from './core/client.js';
+export * from './core/request.js';
+export * from './core/response.js';
+export * from './plugins/retry.js';
+export * from './plugins/cache.js';
+export * from './plugins/dedup.js';
+export * from './plugins/logger.js';
+export * from './plugins/circuit-breaker.js';
+export * from './plugins/cookie-jar.js';
+export * from './runner/request-runner.js';
+export * from './contract/index.js';
+export * from './cache/memory-storage.js';
+export * from './cache/file-storage.js';
+export * from './utils/body.js';
+export * from './plugins/xsrf.js';
+export * from './plugins/compression.js';
+export * from './utils/streaming.js';
+export * from './utils/request-pool.js';
+export * from './utils/header-parser.js';
+export * from './websocket/client.js';
+export * from './utils/whois.js';
+export * from './utils/dns.js';
+export * from './utils/cert.js';
+export * from './utils/doh.js';
+export * from './utils/upload.js';
+export * from './utils/user-agent.js';
+export * from './plugins/har-recorder.js';
+export * from './plugins/har-player.js';
+export * from './plugins/graphql.js';
+export * from './plugins/server-timing.js';
+export * from './plugins/proxy-rotator.js';
+export * from './cache/redis-storage.js';
+export * from './mcp/index.js';
+export { Client as Recker } from './core/client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,39 @@
+export * from './core/request-promise.js';
+export * from './transport/undici.js';
+export * from './transport/fetch.js';
+export * from './types/index.js';
+export * from './core/errors.js';
+export * from './core/client.js';
+export * from './core/request.js';
+export * from './core/response.js';
+export * from './plugins/retry.js';
+export * from './plugins/cache.js';
+export * from './plugins/dedup.js';
+export * from './plugins/logger.js';
+export * from './plugins/circuit-breaker.js';
+export * from './plugins/cookie-jar.js';
+export * from './runner/request-runner.js';
+export * from './contract/index.js';
+export * from './cache/memory-storage.js';
+export * from './cache/file-storage.js';
+export * from './utils/body.js';
+export * from './plugins/xsrf.js';
+export * from './plugins/compression.js';
+export * from './utils/streaming.js';
+export * from './utils/request-pool.js';
+export * from './utils/header-parser.js';
+export * from './websocket/client.js';
+export * from './utils/whois.js';
+export * from './utils/dns.js';
+export * from './utils/cert.js';
+export * from './utils/doh.js';
+export * from './utils/upload.js';
+export * from './utils/user-agent.js';
+export * from './plugins/har-recorder.js';
+export * from './plugins/har-player.js';
+export * from './plugins/graphql.js';
+export * from './plugins/server-timing.js';
+export * from './plugins/proxy-rotator.js';
+export * from './cache/redis-storage.js';
+export * from './mcp/index.js';
+export { Client as Recker } from './core/client.js';

package/dist/mcp/client.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'events';
+import type { MCPServerInfo, MCPTool, MCPToolResult, MCPResource, MCPResourceContent, MCPPrompt, MCPPromptMessage } from './types.js';
+export interface MCPClientOptions {
+    endpoint: string;
+    clientName?: string;
+    clientVersion?: string;
+    protocolVersion?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retries?: number;
+    debug?: boolean;
+    transport?: any;
+}
+interface ResolvedMCPClientOptions {
+    endpoint: string;
+    clientName: string;
+    clientVersion: string;
+    protocolVersion: string;
+    headers: Record<string, string>;
+    timeout: number;
+    retries: number;
+    debug: boolean;
+}
+export declare class MCPClient extends EventEmitter {
+    private client;
+    private endpoint;
+    private requestId;
+    private serverInfo?;
+    private initialized;
+    private sseConnection?;
+    readonly options: ResolvedMCPClientOptions;
+    constructor(options: MCPClientOptions);
+    connect(): Promise<MCPServerInfo>;
+    disconnect(): Promise<void>;
+    readonly tools: {
+        list: () => Promise<MCPTool[]>;
+        call: (name: string, args?: Record<string, unknown>) => Promise<MCPToolResult>;
+        get: (name: string) => Promise<MCPTool | undefined>;
+    };
+    readonly resources: {
+        list: () => Promise<MCPResource[]>;
+        read: (uri: string) => Promise<MCPResourceContent[]>;
+        subscribe: (uri: string) => Promise<void>;
+        unsubscribe: (uri: string) => Promise<void>;
+    };
+    readonly prompts: {
+        list: () => Promise<MCPPrompt[]>;
+        get: (name: string, args?: Record<string, unknown>) => Promise<MCPPromptMessage[]>;
+    };
+    ping(): Promise<void>;
+    getServerInfo(): MCPServerInfo | undefined;
+    isConnected(): boolean;
+    private request;
+    private connectSSE;
+    private handleSSEEvent;
+}
+export declare function createMCPClient(options: MCPClientOptions): MCPClient;
+export {};
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/mcp/client.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAGV,aAAa,EACb,OAAO,EAEP,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,gBAAgB,EAYjB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB;AAED,UAAU,wBAAwB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB;AA2BD,qBAAa,SAAU,SAAQ,YAAY;IACzC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAC,CAAgB;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAC,CAAkB;IAExC,SAAgB,OAAO,EAAE,wBAAwB,CAAC;gBAEtC,OAAO,EAAE,gBAAgB;IAwC/B,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;IA2BjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC,SAAgB,KAAK;oBAIH,OAAO,CAAC,OAAO,EAAE,CAAC;qBAQf,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,OAAO,CAAC,aAAa,CAAC;oBAWhE,MAAM,KAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;MAIvD;IAKF,SAAgB,SAAS;oBAIP,OAAO,CAAC,WAAW,EAAE,CAAC;oBAQpB,MAAM,KAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;yBAUjC,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;2BAOpB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;MAG/C;IAKF,SAAgB,OAAO;oBAIL,OAAO,CAAC,SAAS,EAAE,CAAC;oBAQlB,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;MAOtF;IAKI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,aAAa,IAAI,aAAa,GAAG,SAAS;IAO1C,WAAW,IAAI,OAAO;YAMR,OAAO;YA8BP,UAAU;IAmBxB,OAAO,CAAC,cAAc;CAiCvB;AAYD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAEpE"}

package/dist/mcp/client.js

@@ -0,0 +1,195 @@
+import { EventEmitter } from 'events';
+import { createClient } from '../core/client.js';
+export class MCPClient extends EventEmitter {
+    client;
+    endpoint;
+    requestId = 0;
+    serverInfo;
+    initialized = false;
+    sseConnection;
+    options;
+    constructor(options) {
+        super();
+        this.options = {
+            endpoint: options.endpoint,
+            clientName: options.clientName || 'recker-mcp-client',
+            clientVersion: options.clientVersion || '1.0.0',
+            protocolVersion: options.protocolVersion || '2024-11-05',
+            headers: options.headers || {},
+            timeout: options.timeout || 30000,
+            retries: options.retries || 3,
+            debug: options.debug || false,
+        };
+        this.endpoint = this.options.endpoint;
+        this.client = createClient({
+            baseUrl: this.endpoint,
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.options.headers,
+            },
+            retry: {
+                maxAttempts: this.options.retries,
+                backoff: 'exponential',
+            },
+            transport: options.transport,
+        });
+        if (this.options.debug) {
+            this.on('request', (req) => console.log('[MCP Request]', req));
+            this.on('response', (res) => console.log('[MCP Response]', res));
+            this.on('notification', (notif) => console.log('[MCP Notification]', notif));
+        }
+    }
+    async connect() {
+        const response = await this.request('initialize', {
+            protocolVersion: this.options.protocolVersion,
+            capabilities: {
+                tools: {},
+                resources: { subscribe: true },
+                prompts: {},
+            },
+            clientInfo: {
+                name: this.options.clientName,
+                version: this.options.clientVersion,
+            },
+        });
+        this.serverInfo = response.serverInfo;
+        this.initialized = true;
+        await this.connectSSE();
+        this.emit('connected', this.serverInfo);
+        return this.serverInfo;
+    }
+    async disconnect() {
+        if (this.sseConnection) {
+            this.sseConnection.abort();
+            this.sseConnection = undefined;
+        }
+        this.initialized = false;
+        this.emit('disconnected');
+    }
+    tools = {
+        list: async () => {
+            const response = await this.request('tools/list');
+            return response.tools;
+        },
+        call: async (name, args) => {
+            const response = await this.request('tools/call', {
+                name,
+                arguments: args,
+            });
+            return response;
+        },
+        get: async (name) => {
+            const tools = await this.tools.list();
+            return tools.find(t => t.name === name);
+        },
+    };
+    resources = {
+        list: async () => {
+            const response = await this.request('resources/list');
+            return response.resources;
+        },
+        read: async (uri) => {
+            const response = await this.request('resources/read', {
+                uri,
+            });
+            return response.contents;
+        },
+        subscribe: async (uri) => {
+            await this.request('resources/subscribe', { uri });
+        },
+        unsubscribe: async (uri) => {
+            await this.request('resources/unsubscribe', { uri });
+        },
+    };
+    prompts = {
+        list: async () => {
+            const response = await this.request('prompts/list');
+            return response.prompts;
+        },
+        get: async (name, args) => {
+            const response = await this.request('prompts/get', {
+                name,
+                arguments: args,
+            });
+            return response.messages;
+        },
+    };
+    async ping() {
+        await this.request('ping');
+    }
+    getServerInfo() {
+        return this.serverInfo;
+    }
+    isConnected() {
+        return this.initialized;
+    }
+    async request(method, params) {
+        if (!this.initialized && method !== 'initialize') {
+            throw new Error('MCP client not initialized. Call connect() first.');
+        }
+        const request = {
+            jsonrpc: '2.0',
+            id: ++this.requestId,
+            method,
+            params: params,
+        };
+        this.emit('request', request);
+        const response = await this.client
+            .post('/', { json: request })
+            .json();
+        this.emit('response', response);
+        if (response.error) {
+            const error = new Error(response.error.message);
+            error.code = response.error.code;
+            error.data = response.error.data;
+            throw error;
+        }
+        return response.result;
+    }
+    async connectSSE() {
+        this.sseConnection = new AbortController();
+        try {
+            const response = await this.client.get('/sse', {
+                signal: this.sseConnection.signal,
+            });
+            for await (const event of response.sse()) {
+                this.handleSSEEvent(event);
+            }
+        }
+        catch (error) {
+            if (error.name !== 'AbortError') {
+                this.emit('error', error);
+            }
+        }
+    }
+    handleSSEEvent(event) {
+        try {
+            const data = JSON.parse(event.data);
+            switch (data.method) {
+                case 'notifications/progress':
+                    this.emit('progress', data.params);
+                    break;
+                case 'notifications/resources/updated':
+                    this.emit('resource:updated', data.params);
+                    break;
+                case 'notifications/resources/list_changed':
+                    this.emit('resources:changed');
+                    break;
+                case 'notifications/tools/list_changed':
+                    this.emit('tools:changed');
+                    break;
+                case 'notifications/prompts/list_changed':
+                    this.emit('prompts:changed');
+                    break;
+                default:
+                    this.emit('notification', data);
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+}
+export function createMCPClient(options) {
+    return new MCPClient(options);
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './client.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAKA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './client.js';