openapi-explorer-mcp 0.0.1

package/dist/http.js

@@ -0,0 +1,52 @@
+const RATE_LIMIT_HEADERS = ['retry-after', 'x-ratelimit-limit', 'x-ratelimit-remaining', 'x-ratelimit-reset'];
+/**
+ * Fills path parameters into a path template and appends the query string.
+ */
+export function buildUrl(baseUrl, pathTemplate, pathParams, query) {
+    let filled = pathTemplate;
+    for (const [key, value] of Object.entries(pathParams)) {
+        filled = filled.split(`{${key}}`).join(encodeURIComponent(String(value)));
+    }
+    const missing = filled.match(/\{[^}]+\}/g);
+    if (missing)
+        throw new Error(`missing path parameters: ${missing.join(', ')}`);
+    const url = new URL(`${baseUrl}${filled}`);
+    for (const [key, value] of Object.entries(query))
+        url.searchParams.set(key, String(value));
+    return url;
+}
+/**
+ * Sends a request and returns a structured result; authorization and retries are the caller's job.
+ */
+export async function send(method, url, headers, body, timeoutMs) {
+    const startedAt = Date.now();
+    const response = await fetch(url, {
+        method,
+        headers: { Accept: 'application/json', ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}), ...headers },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await response.text();
+    let parsed = null;
+    if (text) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = text;
+        }
+    }
+    const rateLimit = {};
+    for (const header of RATE_LIMIT_HEADERS) {
+        const value = response.headers.get(header);
+        if (value !== null)
+            rateLimit[header] = value;
+    }
+    return {
+        status: response.status,
+        ok: response.ok,
+        durationMs: Date.now() - startedAt,
+        ...(Object.keys(rateLimit).length ? { rateLimit } : {}),
+        body: parsed,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { OpenApiExplorerServer } from './server.js';
+// Tool handlers catch their own errors; anything reaching here is a bug worth a visible exit.
+process.on('unhandledRejection', (reason) => {
+    process.stderr.write(`openapi-explorer-mcp: unhandled rejection: ${reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)}\n`);
+    process.exit(1);
+});
+const server = await OpenApiExplorerServer.fromEnvironment();
+await server.start();

package/dist/journal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Appends one JSON line, creating the directory when needed; a failed write never fails the call.
+ */
+export declare function appendJsonl(file: string, entry: unknown): void;
+/**
+ * Returns the last entries of a JSONL journal.
+ */
+export declare function tailJsonl(file: string, limit: number): unknown[];

package/dist/journal.js

@@ -0,0 +1,26 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Appends one JSON line, creating the directory when needed; a failed write never fails the call.
+ */
+export function appendJsonl(file, entry) {
+    try {
+        mkdirSync(path.dirname(file), { recursive: true });
+        appendFileSync(file, `${JSON.stringify(entry)}\n`);
+    }
+    catch (error) {
+        process.stderr.write(`openapi-explorer-mcp: could not write the journal ${file} — ${error.message}\n`);
+    }
+}
+/**
+ * Returns the last entries of a JSONL journal.
+ */
+export function tailJsonl(file, limit) {
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, 'utf8')
+        .split('\n')
+        .filter(Boolean)
+        .slice(-limit)
+        .map((line) => JSON.parse(line));
+}

package/dist/operations.d.ts

@@ -0,0 +1,24 @@
+import type { Operation, SchemaNode, SpecIndex } from './spec-index.js';
+/**
+ * Finds an operation by "METHOD /path", a path with a single operation, or a unique operationId.
+ */
+export declare function resolveEndpoint(index: SpecIndex, endpoint: string): Operation;
+/**
+ * Parameter names by location, with ? marking optional ones.
+ */
+export declare function paramSummary(params: Operation['params']): Record<string, string[]>;
+/**
+ * Component schema name referenced by a node, directly or as array items.
+ */
+export declare function componentRef(node: SchemaNode | null | undefined): {
+    name: string;
+    array: boolean;
+} | null;
+/**
+ * Type name base for an operation: its operationId, or the method and path when there is none.
+ */
+export declare function operationTypeName(prefix: string, op: Operation): string;
+/**
+ * Renders `export type <Name>` from the path and query parameters of an operation.
+ */
+export declare function renderParams(op: Operation, name: string): string | null;

package/dist/operations.js

@@ -0,0 +1,82 @@
+/**
+ * Finds an operation by "METHOD /path", a path with a single operation, or a unique operationId.
+ */
+export function resolveEndpoint(index, endpoint) {
+    const raw = endpoint.trim();
+    const exact = index.byKey.get(raw) ?? index.byKey.get(raw.replace(/^(\w+)/, (m) => m.toUpperCase()));
+    if (exact)
+        return exact;
+    const asPath = raw.startsWith('/') ? raw : `/${raw}`;
+    const byPath = index.operations.filter((o) => o.path === asPath);
+    if (byPath.length === 1)
+        return byPath[0];
+    if (byPath.length > 1)
+        throw new Error(`the path ${asPath} has several methods: ${byPath.map((o) => o.key).join(', ')}. Pass METHOD /path.`);
+    const byOperationId = index.byOperationId.get(raw) ?? [];
+    if (byOperationId.length === 1) {
+        const op = index.byKey.get(byOperationId[0]);
+        if (op)
+            return op;
+    }
+    if (byOperationId.length > 1)
+        throw new Error(`operationId "${raw}" is ambiguous: ${byOperationId.join(', ')}. Pass METHOD /path.`);
+    throw new Error(`endpoint not found: "${endpoint}". Search with api_search.`);
+}
+/**
+ * Parameter names by location, with ? marking optional ones.
+ */
+export function paramSummary(params) {
+    return Object.fromEntries(Object.entries(params)
+        .filter(([, list]) => list.length > 0)
+        .map(([where, list]) => [where, list.map((p) => `${p.name}${p.required ? '' : '?'}`)]));
+}
+/**
+ * Component schema name referenced by a node, directly or as array items.
+ */
+export function componentRef(node) {
+    if (typeof node?.$ref === 'string')
+        return { name: node.$ref.split('/').pop() ?? '', array: false };
+    if (node?.type === 'array' && typeof node.items?.$ref === 'string')
+        return { name: node.items.$ref.split('/').pop() ?? '', array: true };
+    return null;
+}
+/**
+ * PascalCase from snake_case, kebab-case or camelCase.
+ */
+function pascal(value) {
+    return value.replace(/(^\w|[_\-\s]+\w)/g, (m) => m.replace(/[_\-\s]+/, '').toUpperCase());
+}
+/**
+ * Type name base for an operation: its operationId, or the method and path when there is none.
+ */
+export function operationTypeName(prefix, op) {
+    const base = op.operationId ?? `${op.method.toLowerCase()}_${op.path.replace(/[{}]/g, '').split('/').filter(Boolean).join('_')}`;
+    return `${prefix}${pascal(base.replace(/[^A-Za-z0-9_\-\s]/g, '_'))}`;
+}
+/**
+ * TypeScript type of a parameter schema: primitives, enums and arrays.
+ */
+function paramType(schema = {}) {
+    if (Array.isArray(schema.enum))
+        return schema.enum.map((v) => (typeof v === 'string' ? `'${v}'` : String(v))).join(' | ');
+    if (schema.type === 'integer' || schema.type === 'number')
+        return 'number';
+    if (schema.type === 'boolean')
+        return 'boolean';
+    if (schema.type === 'array')
+        return `${paramType(schema.items)}[]`;
+    return 'string';
+}
+/**
+ * Renders `export type <Name>` from the path and query parameters of an operation.
+ */
+export function renderParams(op, name) {
+    const fields = [...op.params.path, ...op.params.query];
+    if (fields.length === 0)
+        return null;
+    const lines = fields.map((p) => {
+        const doc = p.description ? `  /** ${String(p.description).slice(0, 80)} */\n` : '';
+        return `${doc}  ${p.name}${p.required ? '' : '?'}: ${paramType(p.schema)};`;
+    });
+    return `export type ${name} = {\n${lines.join('\n')}\n};`;
+}

package/dist/recipes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A markdown recipe.
+ */
+export interface Recipe {
+    /** File name without .md. */
+    name: string;
+    /** `description:` from the front matter. */
+    description: string;
+    /** Full text. */
+    text: string;
+}
+/**
+ * Lists the markdown recipes of a directory.
+ */
+export declare function listRecipes(dir: string): Recipe[];

package/dist/recipes.js

@@ -0,0 +1,16 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Lists the markdown recipes of a directory.
+ */
+export function listRecipes(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((file) => file.endsWith('.md'))
+        .sort()
+        .map((file) => {
+        const text = readFileSync(path.join(dir, file), 'utf8');
+        return { name: path.basename(file, '.md'), description: /^description:\s*(.+)$/m.exec(text)?.[1] ?? '', text };
+    });
+}

package/dist/risk.d.ts

@@ -0,0 +1,28 @@
+/** How risky calling an operation is. */
+export type Danger = 'safe' | 'write' | 'destructive';
+/**
+ * Danger level of an operation with the reason for destructive ones.
+ */
+export interface DangerVerdict {
+    /** Danger level. */
+    danger: Danger;
+    /** Why the operation is destructive. */
+    reason?: string;
+}
+/**
+ * Rules that classify operations.
+ */
+export interface DangerRules {
+    /** Exact "METHOD /path" keys marked destructive, with the reason. */
+    operations: Record<string, string>;
+    /** Path words that mark a non-GET operation destructive. */
+    pathPattern: RegExp;
+}
+/**
+ * Loads danger rules: built-in path words plus an optional JSON file with exact operations and extra words.
+ */
+export declare function loadDangerRules(file?: string): DangerRules;
+/**
+ * Classifies an operation: exact rules first, then GET is safe, DELETE and path words are destructive.
+ */
+export declare function classifyDanger(rules: DangerRules, method: string, path: string): DangerVerdict;

package/dist/risk.js

@@ -0,0 +1,57 @@
+import { readFileSync } from 'node:fs';
+import { ConfigError } from './config.js';
+const DEFAULT_PATH_WORDS = ['drop', 'purge', 'reset', 'destroy', 'bulk', 'broadcast'];
+/**
+ * Escapes a word for use inside a regular expression.
+ */
+function escapeRegExp(word) {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Loads danger rules: built-in path words plus an optional JSON file with exact operations and extra words.
+ */
+export function loadDangerRules(file) {
+    let operations = {};
+    const words = [...DEFAULT_PATH_WORDS];
+    if (file) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch (error) {
+            throw new ConfigError(`OPENAPI_DANGER_FILE is not valid JSON: ${error.message}`);
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new ConfigError('OPENAPI_DANGER_FILE must hold an object with "operations" and/or "pathPatterns"');
+        }
+        const { operations: ops, pathPatterns } = parsed;
+        if (ops !== undefined) {
+            if (!ops || typeof ops !== 'object' || Array.isArray(ops) || !Object.values(ops).every((v) => typeof v === 'string')) {
+                throw new ConfigError('OPENAPI_DANGER_FILE: "operations" must map "METHOD /path" to a reason string');
+            }
+            operations = ops;
+        }
+        if (pathPatterns !== undefined) {
+            if (!Array.isArray(pathPatterns) || !pathPatterns.every((w) => typeof w === 'string' && w.length > 0)) {
+                throw new ConfigError('OPENAPI_DANGER_FILE: "pathPatterns" must be a list of non-empty strings');
+            }
+            words.push(...pathPatterns);
+        }
+    }
+    return { operations, pathPattern: new RegExp(`(${words.map(escapeRegExp).join('|')})`, 'i') };
+}
+/**
+ * Classifies an operation: exact rules first, then GET is safe, DELETE and path words are destructive.
+ */
+export function classifyDanger(rules, method, path) {
+    const exact = rules.operations[`${method} ${path}`];
+    if (exact)
+        return { danger: 'destructive', reason: exact };
+    if (method === 'GET')
+        return { danger: 'safe' };
+    if (method === 'DELETE')
+        return { danger: 'destructive', reason: 'DELETE removes data' };
+    if (rules.pathPattern.test(path))
+        return { danger: 'destructive', reason: 'the path contains a sign of an irreversible operation' };
+    return { danger: 'write' };
+}

package/dist/schema-view.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Compact rendering of OpenAPI schemas. A single schema can be hundreds of kilobytes, so the outline folds it into
+ * a short pseudo-type with a depth limit and a field budget, and says how to dig deeper where it cuts.
+ */
+import type { SchemaNode } from './spec-index.js';
+/** The part of a spec schema rendering needs. */
+export type SchemaSpec = {
+    components: {
+        schemas: Record<string, SchemaNode>;
+    };
+};
+/**
+ * Result of rendering an outline.
+ */
+export interface Outline {
+    /** Rendered pseudo-type. */
+    text: string;
+    /** Whether depth or budget cut something. */
+    truncated: boolean;
+    /** Number of rendered fields. */
+    fields: number;
+}
+/**
+ * Renders a compact pseudo-type of a schema with a depth limit and a field budget.
+ */
+export declare function renderOutline(spec: SchemaSpec, schema: SchemaNode, { depth, budget }?: {
+    depth?: number;
+    budget?: number;
+}): Outline;
+/**
+ * Returns the schema as JSON with $refs substituted, cut at a depth.
+ */
+export declare function resolveJson(spec: SchemaSpec, node: SchemaNode | undefined, depth?: number, seen?: Set<string>): unknown;

package/dist/schema-view.js

@@ -0,0 +1,153 @@
+/**
+ * Follows a JSON pointer like #/components/schemas/X.
+ */
+function pointerWalk(spec, ref) {
+    const parts = ref
+        .replace(/^#\//, '')
+        .split('/')
+        .map((p) => p.replace(/~1/g, '/').replace(/~0/g, '~'));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let node = spec;
+    for (const part of parts) {
+        node = node?.[part];
+        if (node === undefined)
+            return undefined;
+    }
+    return node;
+}
+/**
+ * Resolves a chain of $refs, returning the schema and the name of the last reference.
+ */
+function resolveRef(spec, node, seen) {
+    let name = null;
+    let current = node;
+    let guard = 0;
+    while (current && typeof current.$ref === 'string' && guard++ < 20) {
+        const ref = current.$ref;
+        name = ref.split('/').pop() ?? null;
+        if (seen.has(ref))
+            return { schema: { __cycle: name }, name };
+        current = pointerWalk(spec, ref) ?? { __unresolved: ref };
+    }
+    return { schema: current, name };
+}
+/**
+ * Whether a schema allows null.
+ */
+function isNullable(schema) {
+    return schema.nullable === true || (Array.isArray(schema.type) && schema.type.includes('null'));
+}
+/**
+ * The primary type of a schema, ignoring null in type arrays.
+ */
+function primaryType(schema) {
+    return Array.isArray(schema.type) ? schema.type.find((t) => t !== 'null') : schema.type;
+}
+/**
+ * A one-line label for scalar, enum and plain types; null when the type needs a block.
+ */
+function scalarLabel(schema) {
+    const type = primaryType(schema);
+    if (schema.enum) {
+        const values = schema.enum.filter((v) => v !== null).map((v) => (typeof v === 'string' ? `'${v}'` : String(v)));
+        return values.length <= 8 ? values.join(' | ') : `${values.slice(0, 5).join(' | ')} | … (${values.length})`;
+    }
+    // A record comes as an object without properties; its value type is expanded as a block rather than lost.
+    const record = schema.additionalProperties && typeof schema.additionalProperties === 'object';
+    if (type === 'object' && (schema.properties || record))
+        return null;
+    const extra = [schema.format, schema.pattern && `pattern ${schema.pattern}`].filter(Boolean).join(', ');
+    return `${type ?? 'unknown'}${extra ? ` (${extra})` : ''}`;
+}
+/**
+ * Renders a schema node recursively, counting fields and marking cuts.
+ */
+function walk(spec, rawNode, ctx) {
+    const { schema, name } = resolveRef(spec, rawNode, ctx.seen);
+    if (!schema || typeof schema !== 'object')
+        return String(schema);
+    if (schema.__cycle)
+        return `${schema.__cycle} (cycle)`;
+    if (schema.__unresolved)
+        return `${schema.__unresolved} (not found)`;
+    const suffix = isNullable(schema) ? ' | null' : '';
+    const branches = schema.oneOf ?? schema.anyOf;
+    if (branches) {
+        const rendered = branches.map((b) => walk(spec, b, { ...ctx, depth: ctx.depth - 1 }));
+        return [...new Set(rendered)].join(' | ') + suffix;
+    }
+    if (schema.allOf) {
+        const merged = schema.allOf
+            .map((b) => resolveRef(spec, b, ctx.seen).schema ?? {})
+            .reduce((acc, s) => ({ ...acc, ...s, properties: { ...acc.properties, ...s.properties }, required: [...(acc.required ?? []), ...(s.required ?? [])] }), {});
+        return walk(spec, merged, ctx);
+    }
+    if (primaryType(schema) === 'array') {
+        const inner = walk(spec, schema.items ?? {}, ctx);
+        return (inner.includes('\n') ? `Array<${inner}>` : `${inner}[]`) + suffix;
+    }
+    const label = scalarLabel(schema);
+    if (label !== null)
+        return label + suffix;
+    if (ctx.depth <= 0) {
+        const fields = Object.keys(schema.properties ?? {}).length;
+        ctx.state.truncated = true;
+        const hint = name ? ` → api_schema('${name}')` : ' → increase depth';
+        return `{ … ${fields ? `${fields} fields` : '[key: string]'}${hint} }${suffix}`;
+    }
+    const required = new Set(schema.required ?? []);
+    const lines = [];
+    const pad = '  '.repeat(ctx.indent + 1);
+    for (const [key, propRaw] of Object.entries(schema.properties ?? {})) {
+        if (ctx.state.count >= ctx.state.budget) {
+            lines.push(`${pad}… cut (budget of ${ctx.state.budget} fields) — increase depth or narrow the path`);
+            ctx.state.truncated = true;
+            break;
+        }
+        ctx.state.count += 1;
+        const rendered = walk(spec, propRaw, { ...ctx, depth: ctx.depth - 1, indent: ctx.indent + 1 });
+        const prop = resolveRef(spec, propRaw, ctx.seen).schema;
+        const note = prop?.description ? `  // ${String(prop.description).slice(0, 80)}` : '';
+        lines.push(`${pad}${key}${required.has(key) ? '' : '?'}: ${rendered}${note}`);
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        lines.push(`${pad}[key: string]: ${walk(spec, schema.additionalProperties, { ...ctx, depth: ctx.depth - 1, indent: ctx.indent + 1 })}`);
+    }
+    return `{\n${lines.join('\n')}\n${'  '.repeat(ctx.indent)}}${suffix}`;
+}
+/**
+ * Renders a compact pseudo-type of a schema with a depth limit and a field budget.
+ */
+export function renderOutline(spec, schema, { depth = 3, budget = 400 } = {}) {
+    const state = { count: 0, budget, truncated: false };
+    const text = walk(spec, schema, { depth, indent: 0, seen: new Set(), state });
+    return { text, truncated: state.truncated, fields: state.count };
+}
+/**
+ * Returns the schema as JSON with $refs substituted, cut at a depth.
+ */
+export function resolveJson(spec, node, depth = 6, seen = new Set()) {
+    const { schema } = resolveRef(spec, node, seen);
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    if (schema.__cycle || schema.__unresolved) {
+        return { $ref: schema.__cycle ?? schema.__unresolved, note: schema.__cycle ? 'cycle' : 'not found' };
+    }
+    if (depth <= 0)
+        return schema.type ? { type: schema.type } : { note: '… deeper levels cut' };
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'properties' && value && typeof value === 'object') {
+            out.properties = {};
+            for (const [prop, sub] of Object.entries(value))
+                out.properties[prop] = resolveJson(spec, sub, depth - 1, new Set(seen));
+        }
+        else if (key === 'items') {
+            out.items = resolveJson(spec, value, depth - 1, new Set(seen));
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}

package/dist/schemas.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Input schemas of the tools. The server infers handler argument types from them.
+ */
+import { z } from 'zod';
+export declare const specInfoInput: {
+    refresh: z.ZodDefault<z.ZodBoolean>;
+};
+export declare const searchInput: {
+    query: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodEnum<{
+        GET: "GET";
+        DELETE: "DELETE";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>>;
+    group: z.ZodOptional<z.ZodString>;
+    include_admin: z.ZodDefault<z.ZodBoolean>;
+    has_body: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare const endpointInput: {
+    endpoint: z.ZodString;
+    depth: z.ZodDefault<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        outline: "outline";
+        json: "json";
+    }>>;
+};
+export declare const schemaInput: {
+    name: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        outline: "outline";
+        json: "json";
+    }>>;
+};
+export declare const typesInput: {
+    endpoint: z.ZodString;
+    include: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        params: "params";
+        request: "request";
+        response: "response";
+    }>>>;
+    name_prefix: z.ZodDefault<z.ZodString>;
+};
+export declare const getInput: {
+    endpoint: z.ZodString;
+    path_params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    query: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    as: z.ZodDefault<z.ZodString>;
+    identity: z.ZodOptional<z.ZodString>;
+};
+export declare const requestInput: {
+    method: z.ZodEnum<{
+        GET: "GET";
+        DELETE: "DELETE";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>;
+    endpoint: z.ZodString;
+    path_params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    query: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    as: z.ZodDefault<z.ZodString>;
+    identity: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    confirm_danger: z.ZodDefault<z.ZodBoolean>;
+};
+export declare const authInput: {
+    identity: z.ZodOptional<z.ZodString>;
+    refresh: z.ZodDefault<z.ZodBoolean>;
+    show_token: z.ZodDefault<z.ZodBoolean>;
+};
+export declare const callLogInput: {
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+export declare const recipeInput: {
+    name: z.ZodOptional<z.ZodString>;
+};

package/dist/schemas.js

@@ -0,0 +1,61 @@
+/**
+ * Input schemas of the tools. The server infers handler argument types from them.
+ */
+import { z } from 'zod';
+const method = z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
+const endpoint = z.string().min(1).describe('"METHOD /path", a path with a single operation, or a unique operationId');
+const depth = z.number().int().min(1).max(6).default(3).describe('How deep nested schemas are expanded');
+const renderMode = z.enum(['outline', 'json']).default('outline').describe('outline: a compact pseudo-type; json: the schema with $refs resolved');
+const as = z
+    .string()
+    .default('auto')
+    .describe("'auto' uses the first security alternative with configured credentials; 'anonymous' sends none; or a security scheme name from the spec");
+const identity = z.string().optional().describe('Identity passed to the auth module, e.g. a user id');
+const pathParams = z.record(z.string(), z.union([z.string(), z.number()])).default({}).describe('Path parameters');
+const query = z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).default({}).describe('Query-string parameters');
+export const specInfoInput = {
+    refresh: z.boolean().default(false).describe('Revalidate the spec now'),
+};
+export const searchInput = {
+    query: z.string().optional().describe('Words separated by spaces; all of them must match'),
+    method: method.optional(),
+    group: z.string().optional().describe('Group or path prefix, e.g. users or admin/accounts'),
+    include_admin: z.boolean().default(true).describe('Include /admin endpoints'),
+    has_body: z.boolean().optional().describe('Only operations with (true) or without (false) a request body'),
+    limit: z.number().int().min(1).max(100).default(30),
+};
+export const endpointInput = { endpoint, depth, mode: renderMode };
+export const schemaInput = {
+    name: z.string().min(1).describe('Schema name in components.schemas'),
+    path: z.string().optional().describe('Dotted path inside the schema, e.g. data.meta'),
+    depth,
+    mode: renderMode,
+};
+export const typesInput = {
+    endpoint,
+    include: z.array(z.enum(['request', 'response', 'params'])).default(['request', 'response', 'params']),
+    name_prefix: z.string().default('').describe('Prefix for generated type names'),
+};
+export const getInput = { endpoint, path_params: pathParams, query, as, identity };
+export const requestInput = {
+    method,
+    endpoint,
+    path_params: pathParams,
+    query,
+    body: z.unknown().optional().describe('JSON body'),
+    as,
+    identity,
+    reason: z.string().optional().describe('Note for the call journal: why the call was made'),
+    confirm_danger: z.boolean().default(false).describe('Required for operations classified as destructive'),
+};
+export const authInput = {
+    identity,
+    refresh: z.boolean().default(false).describe('Mint new tokens even if cached ones are still valid'),
+    show_token: z.boolean().default(false).describe('Return full tokens instead of previews'),
+};
+export const callLogInput = {
+    limit: z.number().int().min(1).max(500).default(50),
+};
+export const recipeInput = {
+    name: z.string().optional().describe('Recipe name; omit to list recipes'),
+};