mcpmake 0.1.0 → 0.2.0

package/dist/emitter/templates/tsconfig.json.hbs

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/dist/emitter/templates/types.ts.hbs

@@ -1,5 +0,0 @@
-export interface ApiResponse {
-  status: number;
-  data: unknown;
-  headers: Record<string, string>;
-}

package/dist/emitter/worker-template-loader.d.ts

@@ -1,5 +0,0 @@
-/**
- * Template loader for Cloudflare Workers MCP server templates.
- * Parallel to template-loader.ts but reads from worker-templates/.
- */
-export declare function renderWorkerTemplate(name: string, data: any): string;

package/dist/emitter/worker-template-loader.js

@@ -1,33 +0,0 @@
-/**
- * Template loader for Cloudflare Workers MCP server templates.
- * Parallel to template-loader.ts but reads from worker-templates/.
- */
-import { readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import Handlebars from 'handlebars';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const WORKER_TEMPLATE_DIR = resolve(__dirname, 'worker-templates');
-const workerTemplateCache = new Map();
-// Register helpers (same as template-loader.ts — Handlebars helpers are global).
-// These may already be registered; Handlebars silently overwrites, which is fine.
-Handlebars.registerHelper('eq', function (a, b) {
-    return a === b;
-});
-Handlebars.registerHelper('capitalize', function (str) {
-    if (!str)
-        return str;
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function renderWorkerTemplate(name, data) {
-    if (!workerTemplateCache.has(name)) {
-        const templatePath = resolve(WORKER_TEMPLATE_DIR, `${name}.hbs`);
-        if (!templatePath.startsWith(WORKER_TEMPLATE_DIR + '/')) {
-            throw new Error(`Invalid worker template name: ${name}`);
-        }
-        const raw = readFileSync(templatePath, 'utf-8');
-        workerTemplateCache.set(name, Handlebars.compile(raw, { noEscape: true }));
-    }
-    return workerTemplateCache.get(name)(data);
-}

package/dist/emitter/worker-templates/config.ts.hbs

@@ -1,54 +0,0 @@
-/**
- * Runtime configuration, sourced from the Workers `env` binding (not the Node
- * process environment). Same `AppConfig` shape the shared HTTP executor + auth
- * modules consume, so those are reused verbatim from the Node templates.
- */
-export interface AppConfig {
-  baseUrl: string;
-{{#each authSchemes}}
-{{#if (eq type "apiKey")}}
-  apiKey?: string;
-{{/if}}
-{{#if (eq type "http-bearer")}}
-  bearerToken?: string;
-{{/if}}
-{{#if (eq type "http-basic")}}
-  basicUsername?: string;
-  basicPassword?: string;
-{{/if}}
-{{/each}}
-  maxRetries: number;
-  requestIntervalMs: number;
-}
-
-type EnvLike = Record<string, string | undefined>;
-
-export function loadConfig(env: EnvLike): AppConfig {
-  const baseUrl = requireEnv(env, 'BASE_URL');
-
-  return {
-    baseUrl: baseUrl.replace(/\/$/, ''),
-{{#each authSchemes}}
-{{#if (eq type "apiKey")}}
-    apiKey: env.API_KEY,
-{{/if}}
-{{#if (eq type "http-bearer")}}
-    bearerToken: env.BEARER_TOKEN,
-{{/if}}
-{{#if (eq type "http-basic")}}
-    basicUsername: env.BASIC_USERNAME,
-    basicPassword: env.BASIC_PASSWORD,
-{{/if}}
-{{/each}}
-    maxRetries: parseInt(env.MAX_RETRIES ?? '3', 10),
-    requestIntervalMs: parseInt(env.REQUEST_INTERVAL_MS ?? '100', 10),
-  };
-}
-
-function requireEnv(env: EnvLike, name: string): string {
-  const value = env[name];
-  if (!value) {
-    throw new Error(`Missing required environment variable: ${name}`);
-  }
-  return value;
-}

package/dist/emitter/worker-templates/dev-vars.example.hbs

@@ -1,10 +0,0 @@
-# Local dev secrets for `wrangler dev`. Copy to `.dev.vars` (gitignored) and fill in.
-# In production these are set with `wrangler secret put <NAME>` instead.
-
-# Bearer token clients must send as `Authorization: Bearer <token>`.
-# Leave empty to disable auth (local/dev only — never deploy without it).
-MCP_AUTH_TOKEN=
-{{#each authEnvVars}}
-# {{description}}
-{{name}}=
-{{/each}}

package/dist/emitter/worker-templates/gitignore.hbs

@@ -1,6 +0,0 @@
-node_modules/
-.dev.vars
-.wrangler/
-dist/
-*.tgz
-.DS_Store

package/dist/emitter/worker-templates/package.json.hbs

@@ -1,24 +0,0 @@
-{
-  "name": "{{serverName}}",
-  "version": "{{serverVersion}}",
-  "type": "module",
-  "private": true,
-  "scripts": {
-    "dev": "wrangler dev",
-    "deploy": "wrangler deploy",
-    "start": "wrangler dev",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "zod": "^3.24.0",
-    "zod-to-json-schema": "^3.24.1"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20241127.0",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.8.0",
-    "vitest": "^3.1.0",
-    "wrangler": "^3.90.0"
-  }
-}

package/dist/emitter/worker-templates/readme.md.hbs

@@ -1,53 +0,0 @@
-# {{serverName}}
-
-An MCP server for **{{baseUrl}}**, generated by [mcpmake](https://mcpmake.dev) for
-**Cloudflare Workers** (`--target cloudflare`).
-
-It runs as a stateless [Fetch handler](https://developers.cloudflare.com/workers/runtime-apis/handlers/fetch/):
-every `POST /mcp` carries one self-contained JSON-RPC message and gets one JSON
-response — which is exactly the MCP 2026-07-28 stateless transport, so no session
-state is kept and any request can hit any edge location. Cloudflare's free plan
-covers 100,000 requests/day.
-
-## Tools
-
-This server exposes **{{tools.length}}** tool(s). Run `tools/list` to see them.
-
-## Develop
-
-```bash
-npm install
-cp .dev.vars.example .dev.vars   # fill in MCP_AUTH_TOKEN + API credentials
-npm run dev                      # wrangler dev — local Workers runtime
-npm run typecheck
-```
-
-## Deploy
-
-```bash
-# One-time: store each secret in Cloudflare (never commit them).
-npx wrangler secret put MCP_AUTH_TOKEN     # bearer token clients must present
-{{#each authEnvVars}}
-npx wrangler secret put {{name}}
-{{/each}}
-
-npx wrangler deploy
-```
-
-`BASE_URL` and HTTP tuning live in `wrangler.toml` under `[vars]`; secrets are
-set with `wrangler secret put` and injected via the `env` binding at runtime.
-
-## Connect a client
-
-Point an MCP client at `https://<your-worker>.workers.dev/mcp` with the header
-`Authorization: Bearer <MCP_AUTH_TOKEN>`. Health checks: `GET /health`, `GET /ready`.
-
-## Notes & limits (Workers target)
-
-- **Auth:** every path except `/health` and `/ready` requires the bearer token
-  (constant-time check) when `MCP_AUTH_TOKEN` is set.
-- **Stateless only:** there is no SSE stream or `Mcp-Session-Id` session; `GET`/
-  `DELETE /mcp` are not used. Long-running tools resolve within the request (no
-  Tasks extension / background polling).
-- Need MCP resources, prompts, the Tasks extension, or OAuth2 outbound auth?
-  Regenerate with `--target node` (the default) for the full feature set.

package/dist/emitter/worker-templates/server.test.ts.hbs

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { tools } from '../src/tools/index.js';
-
-describe('{{serverName}} worker tools', () => {
-  it('registers every tool with a usable definition', () => {
-    expect(tools.length).toBe({{tools.length}});
-    for (const { definition, handler } of tools) {
-      expect(definition.name).toMatch(/^[a-zA-Z0-9_-]+$/);
-      expect(typeof definition.description).toBe('string');
-      expect(typeof handler).toBe('function');
-      // The input schema must accept a safeParse call (used for tools/call validation).
-      expect(typeof definition.inputSchema.safeParse).toBe('function');
-    }
-  });
-
-  it('has unique tool names', () => {
-    const names = tools.map((t) => t.definition.name);
-    expect(new Set(names).size).toBe(names.length);
-  });
-});

package/dist/emitter/worker-templates/tool-handler.ts.hbs

@@ -1,85 +0,0 @@
-import { z } from 'zod';
-import { executeRequest } from '../http.js';
-import type { AppConfig } from '../config.js';
-
-const inputSchema = {{{inputSchemaCode}}};
-
-export const definition = {
-  name: '{{name}}',
-  title: '{{title}}',
-  description: `{{{description}}}`,
-  inputSchema,
-{{#if annotations}}
-  annotations: {
-{{#if annotations.readOnlyHint}}
-    readOnlyHint: true,
-{{/if}}
-{{#if annotations.destructiveHint}}
-    destructiveHint: true,
-{{/if}}
-{{#if annotations.idempotentHint}}
-    idempotentHint: true,
-{{/if}}
-  } as Record<string, boolean>,
-{{/if}}
-};
-
-export interface ToolResult {
-  content: { type: 'text'; text: string }[];
-  isError?: boolean;
-}
-
-/**
- * Execute this tool. On the Workers (stateless) target a tool always runs to
- * completion within the request — there is no Tasks extension / background
- * polling, so async operations resolve synchronously here.
- */
-export async function handler(
-  input: Record<string, unknown>,
-  config: AppConfig,
-): Promise<ToolResult> {
-  try {
-    const result = await runRequest(input, config);
-    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-  }
-}
-
-async function runRequest(input: Record<string, unknown>, config: AppConfig): Promise<unknown> {
-  const url = buildUrl(input, config.baseUrl);
-
-  const response = await executeRequest({
-    method: '{{method}}',
-    url,
-{{#if hasRequestBody}}
-    body: input.body,
-    contentType: '{{requestBodyContentType}}',
-{{/if}}
-    headers: {},
-    config,
-  });
-
-{{#if jqFilter}}
-  // Apply x-mcp-jq-filter to trim response before returning to agent
-  let result: unknown = response.data;
-  try {
-    const parts = '{{{jqFilter}}}'.split('.');
-    for (const part of parts) {
-      if (part && result != null && typeof result === 'object') {
-        result = (result as Record<string, unknown>)[part];
-      }
-    }
-  } catch {
-    result = response.data;
-  }
-  return result;
-{{else}}
-  return response.data;
-{{/if}}
-}
-
-function buildUrl(params: Record<string, unknown>, baseUrl: string): string {
-{{{buildUrlBody}}}
-}

package/dist/emitter/worker-templates/tool-index.ts.hbs

@@ -1,28 +0,0 @@
-import type { z } from 'zod';
-import type { AppConfig } from '../config.js';
-{{#each tools}}
-import {
-  definition as def{{capitalize functionName}},
-  handler as handler{{capitalize functionName}},
-} from './{{fileName}}.js';
-{{/each}}
-
-export interface ToolEntry {
-  definition: {
-    name: string;
-    title: string;
-    description: string;
-    inputSchema: z.ZodTypeAny;
-    annotations?: Record<string, boolean>;
-  };
-  handler: (
-    input: Record<string, unknown>,
-    config: AppConfig,
-  ) => Promise<{ content: { type: 'text'; text: string }[]; isError?: boolean }>;
-}
-
-export const tools: ToolEntry[] = [
-{{#each tools}}
-  { definition: def{{capitalize functionName}}, handler: handler{{capitalize functionName}} },
-{{/each}}
-];

package/dist/emitter/worker-templates/tsconfig.json.hbs

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "lib": ["ES2022"],
-    "types": ["@cloudflare/workers-types", "node"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*.ts", "test/**/*.ts"],
-  "exclude": ["node_modules"]
-}

package/dist/emitter/worker-templates/worker.ts.hbs

@@ -1,242 +0,0 @@
-/**
- * Cloudflare Workers entry — stateless MCP server (Fetch handler).
- *
- * The MCP 2026-07-28 transport is stateless (no Mcp-Session-Id, no persistent
- * connection): each `POST /mcp` carries one self-contained JSON-RPC message (or
- * a batch) and receives one JSON response. That maps cleanly onto the Workers
- * request/response model, so we dispatch JSON-RPC by hand here instead of using
- * the SDK's StreamableHTTPServerTransport, which is bound to node:http req/res
- * objects and cannot run on Workers.
- *
- * Secrets (API credentials + the MCP bearer token) arrive via the `env` binding,
- * not process.env — set them with `wrangler secret put <NAME>`.
- */
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { loadConfig, type AppConfig } from './config.js';
-import { tools, type ToolEntry } from './tools/index.js';
-import { deriveContext, runWithTrace } from './trace.js';
-
-export interface Env {
-  [key: string]: string | undefined;
-}
-
-const PROTOCOL_VERSION = '2025-06-18'; // initialize handshake (back-compat with current clients)
-const PROTOCOL_REVISION = '2026-07-28'; // server/discover (SEP-2575)
-const SERVER_INFO = { name: '{{serverName}}', version: '{{serverVersion}}' } as const;
-const MAX_BODY = 4 * 1024 * 1024; // 4 MB
-
-const toolByName = new Map<string, ToolEntry>(tools.map((t) => [t.definition.name, t]));
-
-/* ── Constant-time bearer check ──────────────────────────────────────────
- * HMACs both tokens to fixed-length digests with a random per-isolate key,
- * then compares the bytes — constant time and independent of token length, so
- * neither equality nor length leaks through timing. The key is created lazily
- * on first use: Workers forbids generating random values in global scope, so it
- * must be minted inside a request handler. */
-let cmpKeyPromise: Promise<CryptoKey> | null = null;
-function compareKey(): Promise<CryptoKey> {
-  if (!cmpKeyPromise) {
-    cmpKeyPromise = crypto.subtle.importKey(
-      'raw',
-      crypto.getRandomValues(new Uint8Array(32)),
-      { name: 'HMAC', hash: 'SHA-256' },
-      false,
-      ['sign'],
-    );
-  }
-  return cmpKeyPromise;
-}
-async function safeEqual(a: string, b: string): Promise<boolean> {
-  const key = await compareKey();
-  const enc = new TextEncoder();
-  const da = new Uint8Array(await crypto.subtle.sign('HMAC', key, enc.encode(a)));
-  const db = new Uint8Array(await crypto.subtle.sign('HMAC', key, enc.encode(b)));
-  let diff = 0;
-  for (let i = 0; i < da.length; i++) diff |= da[i] ^ db[i];
-  return diff === 0;
-}
-async function isAuthorized(request: Request, expected: string | undefined): Promise<boolean> {
-  if (!expected) return true; // auth disabled when MCP_AUTH_TOKEN is unset (local/dev only)
-  const header = request.headers.get('authorization');
-  if (!header || !header.startsWith('Bearer ')) return false;
-  const presented = header.slice(7).trim();
-  if (!presented) return false;
-  return safeEqual(presented, expected);
-}
-
-/* ── HTTP / CORS helpers ─────────────────────────────────────────────── */
-function corsHeaders(origin?: string | null): Record<string, string> {
-  return {
-    'access-control-allow-origin': origin || '*',
-    'access-control-allow-methods': 'POST, GET, OPTIONS',
-    'access-control-allow-headers':
-      'authorization, content-type, mcp-method, mcp-name, mcp-protocol-version, traceparent, tracestate',
-  };
-}
-function json(body: unknown, status = 200, extra?: Record<string, string>): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'content-type': 'application/json', ...corsHeaders(), ...extra },
-  });
-}
-function ok(id: unknown, result: unknown): object {
-  return { jsonrpc: '2.0', id: id ?? null, result };
-}
-function err(id: unknown, code: number, message: string): object {
-  return { jsonrpc: '2.0', id: id ?? null, error: { code, message } };
-}
-function rpcErrorResponse(id: unknown, code: number, message: string): Response {
-  return json(err(id, code, message));
-}
-
-/* ── server/discover (SEP-2575) — VERIFY result shape against the final spec ── */
-function discoverResult(): Record<string, unknown> {
-  return {
-    server: SERVER_INFO,
-    protocolRevision: PROTOCOL_REVISION,
-    capabilities: { tools: { count: tools.length } },
-    extensions: [],
-    cacheTtlSeconds: 300,
-  };
-}
-
-/** A tool's `tools/list` entry: its input schema rendered as JSON Schema. */
-function toListEntry(t: ToolEntry): Record<string, unknown> {
-  const schema = zodToJsonSchema(t.definition.inputSchema, {
-    $refStrategy: 'none',
-  }) as Record<string, unknown>;
-  delete schema.$schema;
-  return {
-    name: t.definition.name,
-    title: t.definition.title,
-    description: t.definition.description,
-    inputSchema: schema,
-    ...(t.definition.annotations ? { annotations: t.definition.annotations } : {}),
-  };
-}
-
-async function handleToolCall(
-  id: unknown,
-  params: { name?: unknown; arguments?: unknown } | undefined,
-  config: AppConfig,
-): Promise<object> {
-  const name = typeof params?.name === 'string' ? params.name : '';
-  const entry = toolByName.get(name);
-  if (!entry) return err(id, -32602, `Unknown tool: ${name}`);
-  const parsed = entry.definition.inputSchema.safeParse(params?.arguments ?? {});
-  if (!parsed.success) {
-    return err(id, -32602, `Invalid arguments for ${name}: ${parsed.error.message}`);
-  }
-  const result = await entry.handler(parsed.data as Record<string, unknown>, config);
-  return ok(id, result);
-}
-
-/** Dispatch one JSON-RPC message. Returns null for notifications (no reply). */
-async function handleRpc(
-  msg: { id?: unknown; method?: unknown; params?: unknown } | null,
-  config: AppConfig,
-): Promise<object | null> {
-  const id = msg?.id;
-  const method = msg?.method;
-  switch (method) {
-    case 'initialize': {
-      const requested = (msg?.params as { protocolVersion?: unknown })?.protocolVersion;
-      return ok(id, {
-        protocolVersion: typeof requested === 'string' ? requested : PROTOCOL_VERSION,
-        capabilities: { tools: { listChanged: false } },
-        serverInfo: SERVER_INFO,
-      });
-    }
-    case 'ping':
-      return ok(id, {});
-    case 'tools/list':
-      return ok(id, { tools: tools.map(toListEntry) });
-    case 'tools/call':
-      return handleToolCall(id, msg?.params as { name?: unknown; arguments?: unknown }, config);
-    case 'server/discover':
-      return ok(id, discoverResult());
-    default:
-      // Notifications (e.g. notifications/initialized) carry no id and get no reply.
-      if (id === undefined || id === null) return null;
-      return err(id, -32601, `Method not found: ${String(method)}`);
-  }
-}
-
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const url = new URL(request.url);
-    const origin = request.headers.get('origin');
-
-    if (request.method === 'OPTIONS') {
-      return new Response(null, { status: 204, headers: corsHeaders(origin) });
-    }
-    if (url.pathname === '/health') return json({ status: 'ok' });
-    if (url.pathname === '/ready') return json({ status: 'ready' });
-
-    // Bearer authentication (every path except /health and /ready).
-    if (!(await isAuthorized(request, env.MCP_AUTH_TOKEN))) {
-      return json({ error: 'Unauthorized: missing or invalid bearer token' }, 401, {
-        'www-authenticate': 'Bearer',
-      });
-    }
-
-    // Routing-header observability (SEP-2243, additive — never rejects).
-    const mcpMethod = request.headers.get('mcp-method');
-    const mcpName = request.headers.get('mcp-name');
-    if (mcpMethod || mcpName) {
-      console.log(JSON.stringify({ level: 'info', msg: 'mcp-meta-headers', mcpMethod, mcpName }));
-    }
-
-    if (url.pathname !== '/mcp') return json({ error: 'Not found' }, 404);
-    if (request.method !== 'POST') {
-      // Stateless: no SSE stream to open (GET) or session to delete (DELETE).
-      return rpcErrorResponse(null, -32601, 'Only POST is supported on this stateless server');
-    }
-
-    // Origin guard (DNS-rebinding protection). Enforced only when configured —
-    // a Workers endpoint is public and gated by the bearer token, not by origin.
-    const allowedOrigin = env.ALLOWED_ORIGIN;
-    if (allowedOrigin && origin && origin !== allowedOrigin) {
-      return json({ error: 'Forbidden: invalid origin' }, 403);
-    }
-
-    const contentLength = Number(request.headers.get('content-length') ?? '0');
-    if (contentLength > MAX_BODY) return rpcErrorResponse(null, -32600, 'Request body too large');
-    const raw = await request.text();
-    if (raw.length > MAX_BODY) return rpcErrorResponse(null, -32600, 'Request body too large');
-    if (!raw) return rpcErrorResponse(null, -32600, 'Empty request body');
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return rpcErrorResponse(null, -32700, 'Parse error');
-    }
-
-    const config = loadConfig(env);
-    // Bind a W3C Trace Context for this request so upstream API calls made inside
-    // the tool handlers carry the traceparent and the trace spans the API hop.
-    const trace = deriveContext(
-      request.headers.get('traceparent') ?? undefined,
-      request.headers.get('tracestate') ?? undefined,
-    );
-
-    return runWithTrace(trace, async () => {
-      if (Array.isArray(parsed)) {
-        const settled = await Promise.all(
-          parsed.map((m) => handleRpc(m as { id?: unknown; method?: unknown }, config)),
-        );
-        const responses = settled.filter((r): r is object => r !== null);
-        if (responses.length === 0) {
-          return new Response(null, { status: 202, headers: corsHeaders(origin) });
-        }
-        return json(responses);
-      }
-      const response = await handleRpc(parsed as { id?: unknown; method?: unknown }, config);
-      if (response === null) {
-        return new Response(null, { status: 202, headers: corsHeaders(origin) });
-      }
-      return json(response);
-    });
-  },
-};

package/dist/emitter/worker-templates/wrangler.toml.hbs

@@ -1,19 +0,0 @@
-name = "{{serverName}}"
-main = "src/index.ts"
-compatibility_date = "2024-11-01"
-# nodejs_compat backs the reused modules (AsyncLocalStorage trace context,
-# node:crypto, Buffer). Required — do not remove.
-compatibility_flags = ["nodejs_compat"]
-
-# Non-secret configuration. Override per-environment as needed.
-[vars]
-BASE_URL = "{{baseUrl}}"
-MAX_RETRIES = "3"
-REQUEST_INTERVAL_MS = "100"
-# ALLOWED_ORIGIN = "https://your-client.example.com"
-
-# Secrets are NOT stored in this file. Set them before `wrangler deploy`:
-#   wrangler secret put MCP_AUTH_TOKEN        # bearer token clients must present
-{{#each authEnvVars}}
-#   wrangler secret put {{name}}
-{{/each}}

package/dist/generator/spec-generator.d.ts

@@ -1,6 +0,0 @@
-export interface GenerateSpecOptions {
-    description: string;
-    baseUrl?: string;
-    model?: string;
-}
-export declare function generateSpecFromDescription(options: GenerateSpecOptions): Promise<string>;