@knitli/openapi-mcp 0.0.0

package/dist/stdio/index.js

@@ -0,0 +1,148 @@
+import { serveStdio, } from "@modelcontextprotocol/server/stdio";
+import { admitExecutableRelease, createOpenApiRuntime, verifyExecutableRelease, } from "../runtime/runtime.js";
+import { resolveRuntimeLimits } from "../runtime/versions.js";
+import { createCredentialProvider, } from "../sqlite/auth.js";
+import { SqliteCatalogStore } from "../sqlite/catalog-store.js";
+import { FileGenerationStore } from "../sqlite/generation-store.js";
+import { createLocalDispatchBoundary } from "../sqlite/guarded-fetch.js";
+import { parseOpenApiStdioConfig } from "./config.js";
+import { compileExactPolicy } from "./exact-policy.js";
+import { createStdioSearchRuntime } from "./search.js";
+import { createOpenApiMcpServer, createStdioActionAuthorizer, } from "./server.js";
+export { parseOpenApiStdioConfig } from "./config.js";
+export { createOpenApiMcpServer, } from "./server.js";
+/** Owns process-local credentials/catalogs independently of disposable SDK probes. */
+export async function serveOpenApiStdio(input) {
+    const config = parseOpenApiStdioConfig(input);
+    const stores = [];
+    const providers = [];
+    const boundaries = [];
+    let sdk;
+    let closing;
+    const onTerminate = () => {
+        void close().catch(() => {
+            process.stderr.write("OpenAPI stdio cleanup failed\n");
+            process.exitCode = 1;
+        });
+    };
+    const close = () => (closing ??= (async () => {
+        process.off("SIGTERM", onTerminate);
+        process.off("SIGINT", onTerminate);
+        process.stdin.off("end", onTerminate);
+        const results = await Promise.allSettled([
+            ...boundaries.map((entry) => entry.close()),
+            ...providers.map((entry) => entry.close()),
+            ...(sdk ? [sdk.close()] : []),
+        ]);
+        for (const store of stores)
+            store.close();
+        if (results.some((entry) => entry.status === "rejected"))
+            throw new Error("OpenAPI stdio cleanup failed");
+    })());
+    try {
+        const generations = new FileGenerationStore(config.generationStatePath);
+        const limits = resolveRuntimeLimits(config.limits);
+        const admitted = [];
+        for (const entry of config.catalogs) {
+            const store = new SqliteCatalogStore(entry.path, { limits });
+            stores.push(store);
+            const verified = await verifyExecutableRelease({ store, trust: config.trust, generations, limits }, entry.catalogId, entry.releaseId);
+            if (verified.manifest.catalogId !== entry.catalogId ||
+                verified.manifest.releaseId !== entry.releaseId)
+                throw new Error("Catalog identity mismatch");
+            admitted.push({ config: entry, store, verified });
+        }
+        const templates = await Promise.all((config.exactPolicies ?? []).map((entry) => compileExactPolicy(entry)));
+        // Reject invalid releases and policies before advancing any catalog.
+        // GenerationStore provides per-catalog CAS, not a cross-catalog transaction.
+        for (const entry of admitted)
+            await admitExecutableRelease({ store: entry.store, trust: config.trust, generations, limits }, entry.verified);
+        const authorizer = createStdioActionAuthorizer(templates);
+        const routes = [];
+        for (const profile of config.profiles) {
+            const catalogs = admitted.filter((entry) => entry.config.profileId === profile.profileId);
+            if (!catalogs.length)
+                continue;
+            const credentials = await createCredentialProvider(profile, {
+                manifestOrigins: [
+                    ...new Set(catalogs.flatMap((entry) => entry.verified.manifest.allowedOrigins)),
+                ],
+            });
+            providers.push(credentials);
+            const boundary = createLocalDispatchBoundary(authorizer, {
+                profile,
+                limits,
+                async allowsManifestOrigin(context) {
+                    const entry = catalogs.find((entry) => entry.verified.manifest.catalogId === context.catalogId &&
+                        entry.verified.manifest.releaseId === context.releaseId &&
+                        entry.verified.manifestDigest === context.manifestDigest);
+                    if (!entry ||
+                        !config.allowedOrigins.includes(context.origin) ||
+                        !entry.verified.manifest.allowedOrigins.includes(context.origin))
+                        return false;
+                    try {
+                        const current = await generations.get(entry.verified.manifest.catalogId, entry.verified.manifest.issuer);
+                        return (current?.activeGeneration ===
+                            entry.verified.manifest.generation &&
+                            current.activeManifestDigest === entry.verified.manifestDigest);
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            });
+            boundaries.push(boundary);
+            for (const entry of catalogs)
+                routes.push({
+                    catalogId: entry.config.catalogId,
+                    releaseId: entry.config.releaseId,
+                    apiNamespaces: [
+                        ...new Set(Object.keys(entry.verified.manifest.records)
+                            .filter((id) => id.startsWith("operation:"))
+                            .map((id) => id.split(":")[1])),
+                    ],
+                    credentials,
+                    boundary,
+                    runtime: createOpenApiRuntime({
+                        store: entry.store,
+                        trust: config.trust,
+                        generations,
+                        destinationPolicy: {
+                            async allows(origin) {
+                                return (config.allowedOrigins.includes(origin) &&
+                                    profile.allowedOrigins.includes(origin));
+                            },
+                        },
+                        credentialBinding: credentials.bindingResolver,
+                        paginationTokenCodec: boundary.paginationTokenCodec,
+                        limits,
+                    }),
+                });
+        }
+        sdk = serveStdio(() => createOpenApiMcpServer({
+            routes,
+            searchRuntime: createStdioSearchRuntime(admitted.map((entry) => ({
+                catalogId: entry.config.catalogId,
+                releaseId: entry.config.releaseId,
+                apiNamespaces: routes.find((route) => route.catalogId === entry.config.catalogId)?.apiNamespaces ?? [],
+                store: entry.store,
+            })), { trust: config.trust, generations, limits }),
+            limits,
+            authorizer,
+            maxSearchResults: limits.maxSearchResults,
+            defaultSearchResults: limits.defaultSearchResults,
+        }), {
+            onerror() {
+                process.stderr.write("OpenAPI stdio protocol error\n");
+            },
+        });
+        process.once("SIGTERM", onTerminate);
+        process.once("SIGINT", onTerminate);
+        process.stdin.once("end", onTerminate);
+        return Object.freeze({ close });
+    }
+    catch {
+        await close().catch(() => { });
+        throw new Error("OpenAPI stdio startup failed");
+    }
+}

package/dist/stdio/render.d.ts

@@ -0,0 +1,8 @@
+import type { CredentialAuthorizationBinding, PreparedCall, SafeApprovalPresentation, Sha256 } from "../runtime/types.ts";
+interface PolicyActivationInput {
+    readonly policyDigest: Sha256;
+    readonly expiresAt: number;
+    readonly template: unknown;
+}
+export declare function renderApproval(call: PreparedCall, binding: CredentialAuthorizationBinding, activation?: PolicyActivationInput): SafeApprovalPresentation;
+export {};

package/dist/stdio/render.js

@@ -0,0 +1,253 @@
+import { OpenApiMcpError } from "../runtime/errors.js";
+import { canonicalJsonBounded } from "../runtime/strict-json.js";
+const MAX_PRESENTATION_BYTES = 16 * 1024;
+const MAX_ARGUMENT_SUMMARY_BYTES = 2_048;
+const MAX_DESCRIPTION_BYTES = 512;
+const MAX_TEMPLATE_BYTES = 64 * 1024;
+const TRUNCATION_MARKER = "TRUNCATED";
+function denied() {
+    return new OpenApiMcpError("ACTION_DENIED", "Approval details cannot be displayed safely");
+}
+function bytes(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+function escapedCodePoint(character) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === undefined)
+        return "";
+    const isControl = codePoint <= 0x1f ||
+        (codePoint >= 0x7f && codePoint <= 0x9f) ||
+        codePoint === 0x2028 ||
+        codePoint === 0x2029;
+    const isDirectionControl = codePoint === 0x061c ||
+        (codePoint >= 0x200b && codePoint <= 0x200f) ||
+        (codePoint >= 0x202a && codePoint <= 0x202e) ||
+        (codePoint >= 0x2066 && codePoint <= 0x2069);
+    const isAsciiPunctuationOrSpace = codePoint <= 0x7e &&
+        !((codePoint >= 0x30 && codePoint <= 0x39) ||
+            (codePoint >= 0x41 && codePoint <= 0x5a) ||
+            (codePoint >= 0x61 && codePoint <= 0x7a));
+    if (!isControl && !isDirectionControl && !isAsciiPunctuationOrSpace) {
+        return character;
+    }
+    if (codePoint <= 0xffff) {
+        return `\\u${codePoint.toString(16).toUpperCase().padStart(4, "0")}`;
+    }
+    return `\\u{${codePoint.toString(16).toUpperCase()}}`;
+}
+/** A display encoding, not an HTML or Markdown escaping context. */
+function escapeValue(value, maxBytes) {
+    let rendered = "";
+    for (const character of value) {
+        const next = escapedCodePoint(character);
+        if (maxBytes !== undefined &&
+            bytes(rendered) + bytes(next) + bytes(TRUNCATION_MARKER) > maxBytes) {
+            return rendered + TRUNCATION_MARKER;
+        }
+        rendered += next;
+    }
+    return rendered;
+}
+function quoted(value) {
+    return `"${escapeValue(value)}"`;
+}
+function quotedDescription(value) {
+    return `"${escapeValue(value, MAX_DESCRIPTION_BYTES)}"`;
+}
+function cardinalityText(cardinality) {
+    return cardinality.kind === "bounded"
+        ? `bounded (${cardinality.maxAffected})`
+        : cardinality.kind;
+}
+function dataProperties(value) {
+    const entries = [];
+    for (const key of Object.keys(value).sort()) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor !== undefined && "value" in descriptor) {
+            entries.push([key, descriptor.value]);
+        }
+    }
+    return entries;
+}
+function valueType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function scalarDescription(value) {
+    if (typeof value === "string")
+        return quotedDescription(value);
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number") {
+        return quotedDescription(String(value));
+    }
+    if (Array.isArray(value))
+        return `array (${value.length} items)`;
+    if (typeof value === "object") {
+        return `object (${dataProperties(value).length} keys)`;
+    }
+    return valueType(value);
+}
+function bodyStructure(body) {
+    const lines = [];
+    const seen = new WeakSet();
+    function visit(value, path, depth) {
+        if (lines.length >= 128)
+            return;
+        if (Array.isArray(value)) {
+            if (seen.has(value)) {
+                lines.push(`${path}: cyclic array`);
+                return;
+            }
+            seen.add(value);
+            const types = [...new Set(value.slice(0, 64).map(valueType))].sort();
+            lines.push(`${path}: array (${value.length} items; observed types: ${types.join(", ") || "none"})`);
+            if (depth < 4 && value.length > 0)
+                visit(value[0], `${path}[]`, depth + 1);
+            return;
+        }
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                lines.push(`${path}: cyclic object`);
+                return;
+            }
+            seen.add(value);
+            const properties = dataProperties(value);
+            const keys = properties.map(([key]) => quotedDescription(key)).join(", ");
+            lines.push(`${path}: object (${properties.length} keys: ${keys || "none"})`);
+            if (depth < 4) {
+                for (const [key, child] of properties) {
+                    if (Array.isArray(child) ||
+                        (typeof child === "object" && child !== null)) {
+                        visit(child, `${path}.${escapeValue(key, MAX_DESCRIPTION_BYTES)}`, depth + 1);
+                    }
+                }
+            }
+            return;
+        }
+        lines.push(`${path}: ${valueType(value)}`);
+    }
+    visit(body, "Body structure", 0);
+    return lines;
+}
+function boundedLines(lines, maximum) {
+    let result = "";
+    for (const line of lines) {
+        const candidate = result.length === 0 ? line : `${result}\n${line}`;
+        if (bytes(candidate) <= maximum) {
+            result = candidate;
+            continue;
+        }
+        const marker = result.length === 0 ? TRUNCATION_MARKER : `\n${TRUNCATION_MARKER}`;
+        if (bytes(result) + bytes(marker) <= maximum)
+            result += marker;
+        break;
+    }
+    return result;
+}
+function argumentSummary(call) {
+    const lines = [];
+    for (const [section, value] of dataProperties(call.normalizedArguments)) {
+        if (section === "body") {
+            lines.push(...bodyStructure(value));
+            continue;
+        }
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            const properties = dataProperties(value);
+            lines.push(`${escapeValue(section, MAX_DESCRIPTION_BYTES)}: ${properties.length} entries`);
+            for (const [key, child] of properties) {
+                lines.push(`  ${quotedDescription(key)}: ${scalarDescription(child)}`);
+            }
+            continue;
+        }
+        lines.push(`${escapeValue(section, MAX_DESCRIPTION_BYTES)}: ${scalarDescription(value)}`);
+    }
+    return boundedLines(lines.length === 0 ? ["none"] : lines, MAX_ARGUMENT_SUMMARY_BYTES);
+}
+function canonicalTemplate(template) {
+    try {
+        return canonicalJsonBounded(template, {
+            maxBytes: MAX_TEMPLATE_BYTES,
+            maxDepth: 32,
+            maxNodes: 4_096,
+        });
+    }
+    catch {
+        throw denied();
+    }
+}
+function frozenCardinality(value) {
+    return value.kind === "bounded"
+        ? Object.freeze({ kind: value.kind, maxAffected: value.maxAffected })
+        : Object.freeze({ kind: value.kind });
+}
+export function renderApproval(call, binding, activation) {
+    try {
+        const credentialProfile = escapeValue(binding.profileId);
+        const audience = escapeValue(binding.audience ?? "not specified");
+        const scopes = Object.freeze(binding.scopes.map((scope) => escapeValue(scope)));
+        const normalizedArguments = argumentSummary(call);
+        const policyActivation = activation
+            ? Object.freeze({
+                policyDigest: activation.policyDigest,
+                expiresAt: activation.expiresAt,
+            })
+            : undefined;
+        const lines = [
+            "An external action requires approval.",
+            `Catalog: ${quoted(call.catalogId)}`,
+            `Release: ${quoted(call.releaseId)}`,
+            `Operation: ${quoted(call.operationId)}`,
+            `Method: ${quoted(call.method)}`,
+            `Origin: ${quoted(call.origin)}`,
+            `Relative URL: ${quoted(call.relativeUrl)}`,
+            `Action kind: ${quoted(call.actionKind ?? "unknown")}`,
+            `Cardinality: ${quoted(cardinalityText(call.cardinality ?? { kind: "unknown" }))}`,
+            `Credential profile: "${credentialProfile}"`,
+            `Credential audience: "${audience}"`,
+            `Credential scopes (${scopes.length}): ${scopes.map((scope) => `"${scope}"`).join(", ") || "none"}`,
+            `Operation digest: ${quoted(call.operationDigest)}`,
+            `Manifest digest: ${quoted(call.manifestDigest)}`,
+            `Credential profile digest: ${quoted(call.credentialProfileDigest)}`,
+            `Reserved slots digest: ${quoted(call.reservedSlotsDigest)}`,
+            `Prepared call digest: ${quoted(call.preparedCallDigest)}`,
+            `Credential binding digest: ${quoted(binding.bindingDigest)}`,
+            "Arguments summary:",
+            normalizedArguments,
+        ];
+        if (activation !== undefined) {
+            const template = escapeValue(canonicalTemplate(activation.template));
+            lines.push("POLICY ACTIVATION WARNING: approving this request also activates reusable standing authority for matching calls.", `Policy digest: ${quoted(activation.policyDigest)}`, `Policy expiry (Unix milliseconds): ${quoted(String(activation.expiresAt))}`, "Complete canonical template constraints:", `"${template}"`);
+        }
+        const message = lines.join("\n");
+        if (bytes(message) > MAX_PRESENTATION_BYTES)
+            throw denied();
+        return Object.freeze({
+            message,
+            credentialProfile,
+            audience,
+            scopes,
+            credentialBindingDigest: binding.bindingDigest,
+            ...(policyActivation === undefined ? {} : { policyActivation }),
+            catalogId: escapeValue(call.catalogId),
+            releaseId: escapeValue(call.releaseId),
+            operationId: escapeValue(call.operationId),
+            method: call.method,
+            origin: escapeValue(call.origin),
+            relativeUrl: escapeValue(call.relativeUrl),
+            actionKind: call.actionKind ?? "unknown",
+            cardinality: frozenCardinality(call.cardinality ?? { kind: "unknown" }),
+            normalizedArguments,
+            preparedCallDigest: call.preparedCallDigest,
+        });
+    }
+    catch (error) {
+        if (error instanceof OpenApiMcpError && error.code === "ACTION_DENIED") {
+            throw error;
+        }
+        throw denied();
+    }
+}

package/dist/stdio/request-state.d.ts

@@ -0,0 +1,18 @@
+import { type ServerContext } from "@modelcontextprotocol/server";
+import type { Sha256, VerifiedActionRequestState } from "../runtime/types.ts";
+export interface PendingRequestStatePayload {
+    readonly version: 1;
+    readonly pendingId: string;
+    readonly callDigest: Sha256;
+    readonly credentialBindingDigest: Sha256;
+    readonly expiresAt: number;
+}
+export declare function createVerifiedRequestStateCodec(options: {
+    readonly key: Uint8Array;
+    readonly now: () => number;
+    readonly isPending: (payload: PendingRequestStatePayload) => boolean;
+}): Readonly<{
+    mint(payload: PendingRequestStatePayload): Promise<string>;
+    verify(state: string, context?: ServerContext): Promise<VerifiedActionRequestState>;
+    read(capability: VerifiedActionRequestState): PendingRequestStatePayload | undefined;
+}>;

package/dist/stdio/request-state.js

@@ -0,0 +1,79 @@
+import { createRequestStateCodec, } from "@modelcontextprotocol/server";
+const digestPattern = /^[0-9a-f]{64}$/;
+const idPattern = /^[0-9a-f]{32}$/;
+function decodePayload(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("malformed");
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error("malformed");
+    }
+    const keys = Reflect.ownKeys(value);
+    const expected = [
+        "callDigest",
+        "credentialBindingDigest",
+        "expiresAt",
+        "pendingId",
+        "version",
+    ];
+    if (keys.some((key) => typeof key !== "string") ||
+        keys.sort().join(",") !== expected.join(",")) {
+        throw new Error("malformed");
+    }
+    const payload = Object.create(null);
+    for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined ||
+            !("value" in descriptor) ||
+            !descriptor.enumerable) {
+            throw new Error("malformed");
+        }
+        payload[key] = descriptor.value;
+    }
+    if (payload.version !== 1 ||
+        typeof payload.pendingId !== "string" ||
+        !idPattern.test(payload.pendingId) ||
+        typeof payload.callDigest !== "string" ||
+        !digestPattern.test(payload.callDigest) ||
+        typeof payload.credentialBindingDigest !== "string" ||
+        !digestPattern.test(payload.credentialBindingDigest) ||
+        typeof payload.expiresAt !== "number" ||
+        !Number.isSafeInteger(payload.expiresAt)) {
+        throw new Error("malformed");
+    }
+    return Object.freeze({
+        version: 1,
+        pendingId: payload.pendingId,
+        callDigest: payload.callDigest,
+        credentialBindingDigest: payload.credentialBindingDigest,
+        expiresAt: payload.expiresAt,
+    });
+}
+export function createVerifiedRequestStateCodec(options) {
+    if (!(options.key instanceof Uint8Array) || options.key.byteLength < 32) {
+        throw new RangeError("HMAC key is too short");
+    }
+    const codec = createRequestStateCodec({
+        key: new Uint8Array(options.key),
+        ttlSeconds: 120,
+    });
+    const registered = new WeakMap();
+    return Object.freeze({
+        async mint(payload) {
+            return codec.mint(decodePayload(payload));
+        },
+        async verify(state, context) {
+            const decoded = decodePayload(await codec.verify(state, context));
+            if (options.now() >= decoded.expiresAt || !options.isPending(decoded)) {
+                throw new Error("expired");
+            }
+            const capability = Object.freeze({});
+            registered.set(capability, decoded);
+            return capability;
+        },
+        read(capability) {
+            return registered.get(capability);
+        },
+    });
+}

package/dist/stdio/search.d.ts

@@ -0,0 +1,10 @@
+import { type OpenApiRuntimeOptions } from "../runtime/runtime.ts";
+import type { CatalogStore, OpenApiRuntime } from "../runtime/types.ts";
+export interface StdioSearchCatalog {
+    readonly catalogId: string;
+    readonly releaseId: string;
+    readonly apiNamespaces: readonly string[];
+    readonly store: CatalogStore;
+}
+/** One semantic search, including one shared proof/work/byte budget across catalogs. */
+export declare function createStdioSearchRuntime(catalogs: readonly StdioSearchCatalog[], options: Omit<OpenApiRuntimeOptions, "store">): Pick<OpenApiRuntime, "search">;

package/dist/stdio/search.js

@@ -0,0 +1,76 @@
+import { OpenApiMcpError } from "../runtime/errors.js";
+import { createRuntimeWithCandidateLookup, } from "../runtime/runtime.js";
+import { resolveRuntimeLimits } from "../runtime/versions.js";
+/** One semantic search, including one shared proof/work/byte budget across catalogs. */
+export function createStdioSearchRuntime(catalogs, options) {
+    const ordered = [...catalogs].sort((a, b) => {
+        const left = `${a.catalogId}\0${a.releaseId}`;
+        const right = `${b.catalogId}\0${b.releaseId}`;
+        return left < right ? -1 : left > right ? 1 : 0;
+    });
+    const limits = resolveRuntimeLimits(options.limits);
+    const stores = new Map(ordered.map((entry) => [
+        `${entry.catalogId}\0${entry.releaseId}`,
+        entry.store,
+    ]));
+    const storeFor = (catalogId, releaseId) => {
+        const store = stores.get(`${catalogId}\0${releaseId}`);
+        if (!store)
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED");
+        return store;
+    };
+    return {
+        async search(input) {
+            const matching = ordered.filter((entry) => input.api === undefined || entry.apiNamespaces.includes(input.api));
+            const store = {
+                getManifest: (catalog, release) => storeFor(catalog, release).getManifest(catalog, release),
+                getOperation: (catalog, release, id) => storeFor(catalog, release).getOperation(catalog, release, id),
+                getSchemas: (catalog, release, ids) => storeFor(catalog, release).getSchemas(catalog, release, ids),
+                async searchCandidates() {
+                    throw new OpenApiMcpError("UPSTREAM_ERROR");
+                },
+            };
+            return createRuntimeWithCandidateLookup({ ...options, limits, store }, async (query, tryChargeSource) => {
+                const batches = [];
+                let remaining = query.limit;
+                let limited = false;
+                // Source calls share the proof budget, including queries with no matches.
+                // One total candidate allowance bounds hydration across all sources.
+                // FTS ranks are local; interleave equal local ranks in stable catalog order.
+                for (const [index, entry] of matching.entries()) {
+                    if (remaining === 0)
+                        break;
+                    if (!tryChargeSource()) {
+                        limited = true;
+                        break;
+                    }
+                    const limit = Math.min(limits.maxSearchResults, Math.ceil(remaining / (matching.length - index)));
+                    const rows = await entry.store.searchCandidates({
+                        ...query,
+                        limit,
+                    });
+                    if (rows.length > limit ||
+                        rows.some((row) => row.catalogId !== entry.catalogId ||
+                            row.releaseId !== entry.releaseId))
+                        throw new OpenApiMcpError("RECORD_NOT_ADMITTED");
+                    remaining -= rows.length;
+                    batches.push(rows);
+                }
+                const candidates = [];
+                for (let rank = 0; candidates.length < query.limit; rank++) {
+                    let found = false;
+                    for (const batch of batches) {
+                        const candidate = batch[rank];
+                        if (candidate) {
+                            candidates.push(candidate);
+                            found = true;
+                        }
+                    }
+                    if (!found)
+                        break;
+                }
+                return { candidates, limited };
+            }).search(input);
+        },
+    };
+}

package/dist/stdio/server.d.ts

@@ -0,0 +1,29 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import type { CredentialProvider, OpenApiRuntime } from "../runtime/types.ts";
+import { type RuntimeLimits } from "../runtime/versions.ts";
+import type { createLocalDispatchBoundary } from "../sqlite/guarded-fetch.ts";
+import { type StatefulActionAuthorizer } from "./authorizer.ts";
+import type { CompiledExactPolicy } from "./exact-policy.ts";
+type Boundary = ReturnType<typeof createLocalDispatchBoundary>;
+/** One authorizer across factory instances preserves opaque continuation ownership. */
+export declare function createStdioActionAuthorizer(templates?: readonly CompiledExactPolicy[]): StatefulActionAuthorizer;
+export interface OpenApiServerRoute {
+    readonly catalogId: string;
+    readonly releaseId: string;
+    /** API names from the host's configured, verified manifest inventory. */
+    readonly apiNamespaces: readonly string[];
+    readonly runtime: OpenApiRuntime;
+    readonly credentials: CredentialProvider;
+    readonly boundary: Boundary;
+}
+export interface OpenApiMcpServerOptions {
+    readonly routes: readonly OpenApiServerRoute[];
+    /** Host-owned cross-catalog search with one application budget. */
+    readonly searchRuntime: Pick<OpenApiRuntime, "search">;
+    readonly authorizer: StatefulActionAuthorizer;
+    readonly limits?: Partial<RuntimeLimits>;
+    readonly maxSearchResults?: number;
+    readonly defaultSearchResults?: number;
+}
+export declare function createOpenApiMcpServer(options: OpenApiMcpServerOptions): McpServer;
+export {};