cas-parser-node-mcp 1.1.0

package/src/server.ts

@@ -0,0 +1,165 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Endpoint, endpoints, HandlerFunction, query } from './tools';
+import { CallToolRequestSchema, ListToolsRequestSchema, Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ClientOptions } from 'cas-parser-node';
+import CasParser from 'cas-parser-node';
+import {
+  applyCompatibilityTransformations,
+  ClientCapabilities,
+  defaultClientCapabilities,
+  knownClients,
+  parseEmbeddedJSON,
+} from './compat';
+import { dynamicTools } from './dynamic-tools';
+import { McpOptions } from './options';
+
+export { McpOptions } from './options';
+export { ClientType } from './compat';
+export { Filter } from './tools';
+export { ClientOptions } from 'cas-parser-node';
+export { endpoints } from './tools';
+
+export const newMcpServer = () =>
+  new McpServer(
+    {
+      name: 'cas_parser_node_api',
+      version: '1.1.0',
+    },
+    { capabilities: { tools: {}, logging: {} } },
+  );
+
+// Create server instance
+export const server = newMcpServer();
+
+/**
+ * Initializes the provided MCP Server with the given tools and handlers.
+ * If not provided, the default client, tools and handlers will be used.
+ */
+export function initMcpServer(params: {
+  server: Server | McpServer;
+  clientOptions: ClientOptions;
+  mcpOptions: McpOptions;
+  endpoints?: { tool: Tool; handler: HandlerFunction }[];
+}) {
+  const transformedEndpoints = selectTools(endpoints, params.mcpOptions);
+  const client = new CasParser(params.clientOptions);
+  const capabilities = {
+    ...defaultClientCapabilities,
+    ...(params.mcpOptions.client ? knownClients[params.mcpOptions.client] : params.mcpOptions.capabilities),
+  };
+  init({ server: params.server, client, endpoints: transformedEndpoints, capabilities });
+}
+
+export function init(params: {
+  server: Server | McpServer;
+  client?: CasParser;
+  endpoints?: { tool: Tool; handler: HandlerFunction }[];
+  capabilities?: Partial<ClientCapabilities>;
+}) {
+  const server = params.server instanceof McpServer ? params.server.server : params.server;
+  const providedEndpoints = params.endpoints || endpoints;
+
+  const endpointMap = Object.fromEntries(providedEndpoints.map((endpoint) => [endpoint.tool.name, endpoint]));
+
+  const logAtLevel =
+    (level: 'debug' | 'info' | 'warning' | 'error') =>
+    (message: string, ...rest: unknown[]) => {
+      void server.sendLoggingMessage({
+        level,
+        data: { message, rest },
+      });
+    };
+  const logger = {
+    debug: logAtLevel('debug'),
+    info: logAtLevel('info'),
+    warn: logAtLevel('warning'),
+    error: logAtLevel('error'),
+  };
+
+  const client =
+    params.client ||
+    new CasParser({
+      environment: (readEnv('CAS_PARSER_ENVIRONMENT') || undefined) as any,
+      defaultHeaders: { 'X-Stainless-MCP': 'true' },
+      logger: logger,
+    });
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: providedEndpoints.map((endpoint) => endpoint.tool),
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const endpoint = endpointMap[name];
+    if (!endpoint) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return executeHandler(endpoint.tool, endpoint.handler, client, args, params.capabilities);
+  });
+}
+
+/**
+ * Selects the tools to include in the MCP Server based on the provided options.
+ */
+export function selectTools(endpoints: Endpoint[], options: McpOptions): Endpoint[] {
+  const filteredEndpoints = query(options.filters, endpoints);
+
+  let includedTools = filteredEndpoints;
+
+  if (includedTools.length > 0) {
+    if (options.includeDynamicTools) {
+      includedTools = dynamicTools(includedTools);
+    }
+  } else {
+    if (options.includeAllTools) {
+      includedTools = endpoints;
+    } else if (options.includeDynamicTools) {
+      includedTools = dynamicTools(endpoints);
+    } else {
+      includedTools = endpoints;
+    }
+  }
+
+  const capabilities = { ...defaultClientCapabilities, ...options.capabilities };
+  return applyCompatibilityTransformations(includedTools, capabilities);
+}
+
+/**
+ * Runs the provided handler with the given client and arguments.
+ */
+export async function executeHandler(
+  tool: Tool,
+  handler: HandlerFunction,
+  client: CasParser,
+  args: Record<string, unknown> | undefined,
+  compatibilityOptions?: Partial<ClientCapabilities>,
+) {
+  const options = { ...defaultClientCapabilities, ...compatibilityOptions };
+  if (!options.validJson && args) {
+    args = parseEmbeddedJSON(args, tool.inputSchema);
+  }
+  return await handler(client, args || {});
+}
+
+export const readEnv = (env: string): string | undefined => {
+  if (typeof (globalThis as any).process !== 'undefined') {
+    return (globalThis as any).process.env?.[env]?.trim();
+  } else if (typeof (globalThis as any).Deno !== 'undefined') {
+    return (globalThis as any).Deno.env?.get?.(env)?.trim();
+  }
+  return;
+};
+
+export const readEnvOrError = (env: string): string => {
+  let envValue = readEnv(env);
+  if (envValue === undefined) {
+    throw new Error(`Environment variable ${env} is not set`);
+  }
+  return envValue;
+};

package/src/stdio.ts

@@ -0,0 +1,14 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { init, newMcpServer } from './server';
+import { Endpoint } from './tools';
+import { McpOptions } from './options';
+
+export const launchStdioServer = async (options: McpOptions, endpoints: Endpoint[]) => {
+  const server = newMcpServer();
+
+  init({ server, endpoints });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('MCP Server running on stdio');
+};

package/src/tools/cas-generator/generate-cas-cas-generator.ts

@@ -0,0 +1,67 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { maybeFilter } from 'cas-parser-node-mcp/filtering';
+import { Metadata, asTextContentResult } from 'cas-parser-node-mcp/tools/types';
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import CasParser from 'cas-parser-node';
+
+export const metadata: Metadata = {
+  resource: 'CAS Generator',
+  operation: 'write',
+  tags: [],
+  httpMethod: 'post',
+  httpPath: '/v4/generate',
+  operationId: 'generateCAS',
+};
+
+export const tool: Tool = {
+  name: 'generate_cas_cas_generator',
+  description:
+    "When using this tool, always use the `jq_filter` parameter to reduce the response size and improve performance.\n\nOnly omit if you're sure you don't need the data.\n\nThis endpoint generates CAS (Consolidated Account Statement) documents by submitting a mailback request to the specified CAS authority.\nCurrently only supports KFintech, with plans to support CAMS, CDSL, and NSDL in the future.\n\n\n# Response Schema\n```json\n{\n  type: 'object',\n  properties: {\n    msg: {\n      type: 'string'\n    },\n    status: {\n      type: 'string'\n    }\n  }\n}\n```",
+  inputSchema: {
+    type: 'object',
+    properties: {
+      email: {
+        type: 'string',
+        description: 'Email address to receive the CAS document',
+      },
+      from_date: {
+        type: 'string',
+        description: 'Start date for the CAS period (format YYYY-MM-DD)',
+      },
+      password: {
+        type: 'string',
+        description: 'Password to protect the generated CAS PDF',
+      },
+      to_date: {
+        type: 'string',
+        description: 'End date for the CAS period (format YYYY-MM-DD)',
+      },
+      cas_authority: {
+        type: 'string',
+        description: 'CAS authority to generate the document from (currently only kfintech is supported)',
+        enum: ['kfintech', 'cams', 'cdsl', 'nsdl'],
+      },
+      pan_no: {
+        type: 'string',
+        description: 'PAN number (optional for some CAS authorities)',
+      },
+      jq_filter: {
+        type: 'string',
+        title: 'jq Filter',
+        description:
+          'A jq filter to apply to the response to include certain fields. Consult the output schema in the tool description to see the fields that are available.\n\nFor example: to include only the `name` field in every object of a results array, you can provide ".results[].name".\n\nFor more information, see the [jq documentation](https://jqlang.org/manual/).',
+      },
+    },
+    required: ['email', 'from_date', 'password', 'to_date'],
+  },
+  annotations: {},
+};
+
+export const handler = async (client: CasParser, args: Record<string, unknown> | undefined) => {
+  const { jq_filter, ...body } = args as any;
+  return asTextContentResult(await maybeFilter(jq_filter, await client.casGenerator.generateCas(body)));
+};
+
+export default { metadata, tool, handler };

package/src/tools/cas-parser/cams-kfintech-cas-parser.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Metadata, asTextContentResult } from 'cas-parser-node-mcp/tools/types';
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import CasParser from 'cas-parser-node';
+
+export const metadata: Metadata = {
+  resource: 'CAS Parser',
+  operation: 'write',
+  tags: [],
+  httpMethod: 'post',
+  httpPath: '/v4/cams_kfintech/parse',
+  operationId: 'camsKfintechParse',
+};
+
+export const tool: Tool = {
+  name: 'cams_kfintech_cas_parser',
+  description:
+    'This endpoint specifically parses CAMS/KFintech CAS (Consolidated Account Statement) PDF files and returns data in a unified format.\nUse this endpoint when you know the PDF is from CAMS or KFintech.\n',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      password: {
+        type: 'string',
+        description: 'Password for the PDF file (if required)',
+      },
+      pdf_file: {
+        type: 'string',
+        description: 'Base64 encoded CAS PDF file',
+      },
+      pdf_url: {
+        type: 'string',
+        description: 'URL to the CAS PDF file',
+      },
+    },
+    required: [],
+  },
+  annotations: {},
+};
+
+export const handler = async (client: CasParser, args: Record<string, unknown> | undefined) => {
+  const body = args as any;
+  return asTextContentResult(await client.casParser.camsKfintech(body));
+};
+
+export default { metadata, tool, handler };

package/src/tools/cas-parser/cdsl-cas-parser.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Metadata, asTextContentResult } from 'cas-parser-node-mcp/tools/types';
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import CasParser from 'cas-parser-node';
+
+export const metadata: Metadata = {
+  resource: 'CAS Parser',
+  operation: 'write',
+  tags: [],
+  httpMethod: 'post',
+  httpPath: '/v4/cdsl/parse',
+  operationId: 'cdslParse',
+};
+
+export const tool: Tool = {
+  name: 'cdsl_cas_parser',
+  description:
+    'This endpoint specifically parses CDSL CAS (Consolidated Account Statement) PDF files and returns data in a unified format.\nUse this endpoint when you know the PDF is from CDSL.\n',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      password: {
+        type: 'string',
+        description: 'Password for the PDF file (if required)',
+      },
+      pdf_file: {
+        type: 'string',
+        description: 'Base64 encoded CAS PDF file',
+      },
+      pdf_url: {
+        type: 'string',
+        description: 'URL to the CAS PDF file',
+      },
+    },
+    required: [],
+  },
+  annotations: {},
+};
+
+export const handler = async (client: CasParser, args: Record<string, unknown> | undefined) => {
+  const body = args as any;
+  return asTextContentResult(await client.casParser.cdsl(body));
+};
+
+export default { metadata, tool, handler };

package/src/tools/cas-parser/nsdl-cas-parser.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Metadata, asTextContentResult } from 'cas-parser-node-mcp/tools/types';
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import CasParser from 'cas-parser-node';
+
+export const metadata: Metadata = {
+  resource: 'CAS Parser',
+  operation: 'write',
+  tags: [],
+  httpMethod: 'post',
+  httpPath: '/v4/nsdl/parse',
+  operationId: 'nsdlParse',
+};
+
+export const tool: Tool = {
+  name: 'nsdl_cas_parser',
+  description:
+    'This endpoint specifically parses NSDL CAS (Consolidated Account Statement) PDF files and returns data in a unified format.\nUse this endpoint when you know the PDF is from NSDL.\n',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      password: {
+        type: 'string',
+        description: 'Password for the PDF file (if required)',
+      },
+      pdf_file: {
+        type: 'string',
+        description: 'Base64 encoded CAS PDF file',
+      },
+      pdf_url: {
+        type: 'string',
+        description: 'URL to the CAS PDF file',
+      },
+    },
+    required: [],
+  },
+  annotations: {},
+};
+
+export const handler = async (client: CasParser, args: Record<string, unknown> | undefined) => {
+  const body = args as any;
+  return asTextContentResult(await client.casParser.nsdl(body));
+};
+
+export default { metadata, tool, handler };

package/src/tools/cas-parser/smart-parse-cas-parser.ts

@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Metadata, asTextContentResult } from 'cas-parser-node-mcp/tools/types';
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import CasParser from 'cas-parser-node';
+
+export const metadata: Metadata = {
+  resource: 'CAS Parser',
+  operation: 'write',
+  tags: [],
+  httpMethod: 'post',
+  httpPath: '/v4/smart/parse',
+  operationId: 'smartParse',
+};
+
+export const tool: Tool = {
+  name: 'smart_parse_cas_parser',
+  description:
+    'This endpoint parses CAS (Consolidated Account Statement) PDF files from NSDL, CDSL, or CAMS/KFintech and returns data in a unified format.\nIt auto-detects the CAS type and transforms the data into a consistent structure regardless of the source.\n',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      password: {
+        type: 'string',
+        description: 'Password for the PDF file (if required)',
+      },
+      pdf_file: {
+        type: 'string',
+        description: 'Base64 encoded CAS PDF file',
+      },
+      pdf_url: {
+        type: 'string',
+        description: 'URL to the CAS PDF file',
+      },
+    },
+    required: [],
+  },
+  annotations: {},
+};
+
+export const handler = async (client: CasParser, args: Record<string, unknown> | undefined) => {
+  const body = args as any;
+  return asTextContentResult(await client.casParser.smartParse(body));
+};
+
+export default { metadata, tool, handler };

package/src/tools/index.ts

@@ -0,0 +1,79 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Metadata, Endpoint, HandlerFunction } from './types';
+
+export { Metadata, Endpoint, HandlerFunction };
+
+import cams_kfintech_cas_parser from './cas-parser/cams-kfintech-cas-parser';
+import cdsl_cas_parser from './cas-parser/cdsl-cas-parser';
+import nsdl_cas_parser from './cas-parser/nsdl-cas-parser';
+import smart_parse_cas_parser from './cas-parser/smart-parse-cas-parser';
+import generate_cas_cas_generator from './cas-generator/generate-cas-cas-generator';
+
+export const endpoints: Endpoint[] = [];
+
+function addEndpoint(endpoint: Endpoint) {
+  endpoints.push(endpoint);
+}
+
+addEndpoint(cams_kfintech_cas_parser);
+addEndpoint(cdsl_cas_parser);
+addEndpoint(nsdl_cas_parser);
+addEndpoint(smart_parse_cas_parser);
+addEndpoint(generate_cas_cas_generator);
+
+export type Filter = {
+  type: 'resource' | 'operation' | 'tag' | 'tool';
+  op: 'include' | 'exclude';
+  value: string;
+};
+
+export function query(filters: Filter[], endpoints: Endpoint[]): Endpoint[] {
+  const allExcludes = filters.length > 0 && filters.every((filter) => filter.op === 'exclude');
+  const unmatchedFilters = new Set(filters);
+
+  const filtered = endpoints.filter((endpoint: Endpoint) => {
+    let included = false || allExcludes;
+
+    for (const filter of filters) {
+      if (match(filter, endpoint)) {
+        unmatchedFilters.delete(filter);
+        included = filter.op === 'include';
+      }
+    }
+
+    return included;
+  });
+
+  // Check if any filters didn't match
+  const unmatched = Array.from(unmatchedFilters).filter((f) => f.type === 'tool' || f.type === 'resource');
+  if (unmatched.length > 0) {
+    throw new Error(
+      `The following filters did not match any endpoints: ${unmatched
+        .map((f) => `${f.type}=${f.value}`)
+        .join(', ')}`,
+    );
+  }
+
+  return filtered;
+}
+
+function match({ type, value }: Filter, endpoint: Endpoint): boolean {
+  switch (type) {
+    case 'resource': {
+      const regexStr = '^' + normalizeResource(value).replace(/\*/g, '.*') + '$';
+      const regex = new RegExp(regexStr);
+      return regex.test(normalizeResource(endpoint.metadata.resource));
+    }
+    case 'operation':
+      return endpoint.metadata.operation === value;
+    case 'tag':
+      return endpoint.metadata.tags.includes(value);
+    case 'tool':
+      return endpoint.tool.name === value;
+  }
+}
+
+function normalizeResource(resource: string): string {
+  return resource.toLowerCase().replace(/[^a-z.*\-_]*/g, '');
+}

package/src/tools/types.ts

@@ -0,0 +1,103 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import CasParser from 'cas-parser-node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+type TextContentBlock = {
+  type: 'text';
+  text: string;
+};
+
+type ImageContentBlock = {
+  type: 'image';
+  data: string;
+  mimeType: string;
+};
+
+type AudioContentBlock = {
+  type: 'audio';
+  data: string;
+  mimeType: string;
+};
+
+type ResourceContentBlock = {
+  type: 'resource';
+  resource:
+    | {
+        uri: string;
+        mimeType: string;
+        text: string;
+      }
+    | {
+        uri: string;
+        mimeType: string;
+        blob: string;
+      };
+};
+
+export type ContentBlock = TextContentBlock | ImageContentBlock | AudioContentBlock | ResourceContentBlock;
+
+export type ToolCallResult = {
+  content: ContentBlock[];
+  isError?: boolean;
+};
+
+export type HandlerFunction = (
+  client: CasParser,
+  args: Record<string, unknown> | undefined,
+) => Promise<ToolCallResult>;
+
+export function asTextContentResult(result: unknown): ToolCallResult {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(result, null, 2),
+      },
+    ],
+  };
+}
+
+export async function asBinaryContentResult(response: Response): Promise<ToolCallResult> {
+  const blob = await response.blob();
+  const mimeType = blob.type;
+  const data = Buffer.from(await blob.arrayBuffer()).toString('base64');
+  if (mimeType.startsWith('image/')) {
+    return {
+      content: [{ type: 'image', mimeType, data }],
+    };
+  } else if (mimeType.startsWith('audio/')) {
+    return {
+      content: [{ type: 'audio', mimeType, data }],
+    };
+  } else {
+    return {
+      content: [
+        {
+          type: 'resource',
+          resource: {
+            // We must give a URI, even though this isn't actually an MCP resource.
+            uri: 'resource://tool-response',
+            mimeType,
+            blob: data,
+          },
+        },
+      ],
+    };
+  }
+}
+
+export type Metadata = {
+  resource: string;
+  operation: 'read' | 'write';
+  tags: string[];
+  httpMethod?: string;
+  httpPath?: string;
+  operationId?: string;
+};
+
+export type Endpoint = {
+  metadata: Metadata;
+  tool: Tool;
+  handler: HandlerFunction;
+};

package/src/tools.ts

@@ -0,0 +1 @@
+export * from './tools/index';

package/src/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": ["index.ts"],
+  "compilerOptions": {
+    "target": "es2015",
+    "lib": ["DOM"],
+    "moduleResolution": "node"
+  }
+}

package/stdio.d.mts

@@ -0,0 +1,4 @@
+import { Endpoint } from "./tools.mjs";
+import { McpOptions } from "./options.mjs";
+export declare const launchStdioServer: (options: McpOptions, endpoints: Endpoint[]) => Promise<void>;
+//# sourceMappingURL=stdio.d.mts.map

package/stdio.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.mts","sourceRoot":"","sources":["src/stdio.ts"],"names":[],"mappings":"OAEO,EAAE,QAAQ,EAAE;OACZ,EAAE,UAAU,EAAE;AAErB,eAAO,MAAM,iBAAiB,GAAU,SAAS,UAAU,EAAE,WAAW,QAAQ,EAAE,kBAQjF,CAAC"}

package/stdio.d.ts

@@ -0,0 +1,4 @@
+import { Endpoint } from "./tools.js";
+import { McpOptions } from "./options.js";
+export declare const launchStdioServer: (options: McpOptions, endpoints: Endpoint[]) => Promise<void>;
+//# sourceMappingURL=stdio.d.ts.map

package/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["src/stdio.ts"],"names":[],"mappings":"OAEO,EAAE,QAAQ,EAAE;OACZ,EAAE,UAAU,EAAE;AAErB,eAAO,MAAM,iBAAiB,GAAU,SAAS,UAAU,EAAE,WAAW,QAAQ,EAAE,kBAQjF,CAAC"}

package/stdio.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchStdioServer = void 0;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const server_1 = require("./server.js");
+const launchStdioServer = async (options, endpoints) => {
+    const server = (0, server_1.newMcpServer)();
+    (0, server_1.init)({ server, endpoints });
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('MCP Server running on stdio');
+};
+exports.launchStdioServer = launchStdioServer;
+//# sourceMappingURL=stdio.js.map

package/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["src/stdio.ts"],"names":[],"mappings":";;;AAAA,wEAAiF;AACjF,wCAA8C;AAIvC,MAAM,iBAAiB,GAAG,KAAK,EAAE,OAAmB,EAAE,SAAqB,EAAE,EAAE;IACpF,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;IAE9B,IAAA,aAAI,EAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAE5B,MAAM,SAAS,GAAG,IAAI,+BAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,OAAO,CAAC,KAAK,CAAC,6BAA6B,CAAC,CAAC;AAC/C,CAAC,CAAC;AARW,QAAA,iBAAiB,qBAQ5B"}

package/stdio.mjs

@@ -0,0 +1,10 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { init, newMcpServer } from "./server.mjs";
+export const launchStdioServer = async (options, endpoints) => {
+    const server = newMcpServer();
+    init({ server, endpoints });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('MCP Server running on stdio');
+};
+//# sourceMappingURL=stdio.mjs.map