@ttoss/http-server-mcp-openapi 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,335 @@
+
+import { JsonObjectSchema, McpServer } from "@ttoss/http-server-mcp";
+
+//#region src/types.d.ts
+/**
+ * A single JSON Schema property descriptor as emitted for a tool's
+ * `inputSchema`. Only the subset of JSON Schema the generator produces is
+ * modelled here; the value is forwarded verbatim over the MCP wire protocol.
+ */
+interface JsonSchemaProperty {
+  type: 'string' | 'number' | 'boolean' | 'array' | 'integer' | 'object' | 'null';
+  description?: string;
+  items?: unknown;
+}
+/**
+ * A REST-backed MCP tool derived from a single OpenAPI operation.
+ *
+ * The `path` / `query` / `body` builders turn the camelCase arguments an MCP
+ * client sends into the pieces of an HTTP request against the original REST
+ * API. They intentionally hold no transport concerns (base URL, auth); the
+ * caller wires those in when it performs the request.
+ */
+interface ToolDefinition {
+  /** kebab-case tool name derived from the operation's `operationId`. */
+  name: string;
+  /** Sanitised operation description (quotes escaped, newlines flattened). */
+  description: string;
+  /** Plain JSON Schema describing the tool's camelCase input object. */
+  inputSchema: JsonObjectSchema;
+  /** Uppercase HTTP method (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`). */
+  method: string;
+  /** The raw OpenAPI path template, e.g. `/agents/{agent_id}`. */
+  pathTemplate: string;
+  /** The operation's `operationId`. */
+  operationId: string;
+  /** Builds the request path, substituting path params from the args. */
+  path: (args: Record<string, unknown>) => string;
+  /** Builds the query string (including leading `?`), or `undefined` if none. */
+  query?: (args: Record<string, unknown>) => string;
+  /** Builds the snake_case request body, or `undefined` if the op has no body. */
+  body?: (args: Record<string, unknown>) => Record<string, unknown>;
+  /**
+   * snake_case names of every top-level request-body property the operation's
+   * schema declares, including server-managed ones hidden from `inputSchema`.
+   */
+  acceptedBodyFields: string[];
+  /**
+   * Every `x-` prefixed extension declared on the operation, forwarded
+   * verbatim. Lets consumers read custom metadata (e.g. `x-iam-action`)
+   * without this package needing to know about it.
+   */
+  extensions: Record<string, unknown>;
+}
+/** Minimal shape of an OpenAPI document consumed by the generator. */
+interface OpenApiSpec {
+  paths?: Record<string, Record<string, unknown>>;
+  components?: {
+    schemas?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+  };
+}
+type RequestBodySpec = {
+  required?: boolean;
+  content?: {
+    'application/json'?: {
+      schema?: {
+        type?: string;
+        required?: string[];
+        properties?: Record<string, unknown>;
+        oneOf?: Array<Record<string, unknown>>;
+        anyOf?: Array<Record<string, unknown>>;
+        $ref?: string;
+      };
+    };
+  };
+};
+interface OperationSpec {
+  operationId?: string;
+  description?: string;
+  parameters?: Array<{
+    name?: string;
+    in?: string;
+    required?: boolean;
+    description?: string;
+    schema?: {
+      type?: string;
+      items?: {
+        type?: string;
+      };
+    };
+    $ref?: string;
+  }>;
+  requestBody?: RequestBodySpec;
+  [extension: string]: unknown;
+}
+/** Options that tune how operations and body properties are translated. */
+interface OpenApiToToolsOptions {
+  /**
+   * Operation-level extension flag that, when truthy, excludes the operation
+   * from the generated tool surface.
+   * @default 'x-mcp-exclude'
+   */
+  excludeExtension?: string;
+  /**
+   * Body-property extension flag that, when truthy, hides the property from the
+   * generated `inputSchema` while keeping it in `acceptedBodyFields` (for
+   * server-managed fields the API sets itself).
+   * @default 'x-mcp-server-managed'
+   */
+  serverManagedExtension?: string;
+}
+declare const DEFAULT_EXCLUDE_EXTENSION = "x-mcp-exclude";
+declare const DEFAULT_SERVER_MANAGED_EXTENSION = "x-mcp-server-managed";
+//#endregion
+//#region src/registerOpenApiTools.d.ts
+/** The resolved HTTP request a tool call maps to, before transport concerns. */
+interface ResolvedRequest {
+  /** Uppercase HTTP method. */
+  method: string;
+  /** Request path including the query string, e.g. `/agents/agt_1?limit=10`. */
+  url: string;
+  /** snake_case request body, or `undefined` when the operation has none. */
+  body?: Record<string, unknown>;
+  /** The tool definition the call resolved to (for auth/metadata lookups). */
+  tool: ToolDefinition;
+}
+interface RegisterOpenApiToolsArgs {
+  /** The MCP server the generated tools are registered on. */
+  server: McpServer;
+  /** One or more OpenAPI documents to derive tools from. */
+  spec: OpenApiSpec | OpenApiSpec[];
+  /** Tuning options forwarded to {@link openApiToToolDefinitions}. */
+  options?: OpenApiToToolsOptions;
+  /**
+   * Performs the HTTP request for a resolved tool call and returns the raw
+   * response data. This package builds the method/url/body; the caller owns
+   * how the request is executed — base URL, auth headers, fetch impl, etc.
+   */
+  callApi: (request: ResolvedRequest) => Promise<unknown> | unknown;
+  /**
+   * Serialises the raw API data into the MCP tool's text payload.
+   * @default (data) => JSON.stringify(data, null, 2)
+   */
+  toText?: (data: unknown) => string;
+}
+/**
+ * Derives MCP tools from OpenAPI document(s) and registers each on the given
+ * MCP server. Every tool's handler resolves the incoming camelCase args into a
+ * concrete HTTP request and delegates execution to `callApi`.
+ *
+ * @returns The list of {@link ToolDefinition} that were registered.
+ *
+ * @example
+ * ```typescript
+ * import { McpServer } from '@ttoss/http-server-mcp';
+ * import { registerOpenApiTools } from '@ttoss/http-server-mcp-openapi';
+ *
+ * const server = new McpServer({ name: 'my-api', version: '1.0.0' });
+ *
+ * registerOpenApiTools({
+ *   server,
+ *   spec: myOpenApiDocument,
+ *   callApi: async ({ method, url, body }) => {
+ *     const res = await fetch(`https://api.example.com${url}`, {
+ *       method,
+ *       headers: { 'Content-Type': 'application/json' },
+ *       body: body ? JSON.stringify(body) : undefined,
+ *     });
+ *     return res.json();
+ *   },
+ * });
+ * ```
+ */
+declare const registerOpenApiTools: (args: RegisterOpenApiToolsArgs) => ToolDefinition[];
+//#endregion
+//#region src/schema.d.ts
+type ResolvedSchema = {
+  type?: string;
+  required?: string[];
+  properties?: Record<string, unknown>;
+  oneOf?: Array<Record<string, unknown>>;
+  anyOf?: Array<Record<string, unknown>>;
+};
+/**
+ * Recursively inlines every `$ref` in a schema (including refs nested inside
+ * `properties`, `items`, `oneOf`, `anyOf`, etc.), producing a self-contained
+ * schema safe to hand to an MCP client or LLM provider as a tool definition —
+ * provider tool schemas have no `components` section to resolve refs against.
+ */
+declare const dereferenceSchema: (schema: Record<string, unknown> | undefined, spec: OpenApiSpec) => Record<string, unknown> | undefined;
+/**
+ * Resolves a schema down to a single object shape: follows a top-level `$ref`
+ * and merges `oneOf` / `anyOf` alternatives (union of properties, intersection
+ * of `required`) so the caller sees one flat property set.
+ */
+declare const resolveSchema: (schema: Record<string, unknown> | undefined, spec: OpenApiSpec) => ResolvedSchema;
+/** Follows a parameter `$ref` into `components.parameters`, if present. */
+declare const resolveParameter: (param: Record<string, unknown> | undefined, spec: OpenApiSpec) => {
+  name?: string;
+  in?: string;
+  required?: boolean;
+  description?: string;
+  schema?: {
+    type?: string;
+    items?: {
+      type?: string;
+    };
+  };
+};
+/** Builds a function that substitutes path params into the path template. */
+declare const buildPathFn: (pathTemplate: string, pathParams: Array<{
+  name: string;
+  camelName: string;
+}>) => ((args: Record<string, unknown>) => string);
+/**
+ * Builds a function that serialises query params into a query string
+ * (including the leading `?`). Returns `undefined` when the op has no query
+ * params. Array values are appended once per element.
+ */
+declare const buildQueryFn: (queryParams: Array<{
+  name: string;
+  camelName: string;
+}>) => ((args: Record<string, unknown>) => string) | undefined;
+/**
+ * Builds a function that maps camelCase args back to a snake_case request
+ * body, skipping `undefined` args. Returns `undefined` when the op has no body.
+ */
+declare const buildBodyFn: (bodyProps: Array<{
+  snakeName: string;
+  camelName: string;
+}>) => ((args: Record<string, unknown>) => Record<string, unknown>) | undefined;
+//#endregion
+//#region src/toolDefinitions.d.ts
+/**
+ * Folds `_` and `-` separators into camelCase. OpenAPI operation and parameter
+ * names may be snake_case (`agent_id`) or kebab-case (`list-tools`), and MCP
+ * tool inputs are camelCase by convention, so both are folded here.
+ */
+declare const snakeToCamel: (str: string) => string;
+/** Converts a camelCase `operationId` to a kebab-case tool name. */
+declare const operationIdToToolName: (operationId: string) => string;
+declare const getJsonSchemaType: (schemaType: string | undefined) => JsonSchemaProperty["type"];
+declare const buildInputSchema: (pathParams: Array<{
+  name: string;
+  camelName: string;
+}>, queryParams: Array<{
+  name: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+}>, bodyProps: Array<{
+  snakeName: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+  items?: unknown;
+}>) => JsonObjectSchema;
+declare const extractPathParams: (args: {
+  parameters?: Array<{
+    name?: string;
+    in?: string;
+    [key: string]: unknown;
+  }>;
+  spec: OpenApiSpec;
+}) => Array<{
+  name: string;
+  camelName: string;
+}>;
+declare const extractQueryParams: (args: {
+  parameters?: Array<{
+    name?: string;
+    in?: string;
+    [key: string]: unknown;
+  }>;
+  spec: OpenApiSpec;
+}) => Array<{
+  name: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+}>;
+/**
+ * snake_case names of every top-level property an operation's request schema
+ * declares, including server-managed ones.
+ */
+declare const extractAcceptedBodyFields: (args: {
+  requestBody?: RequestBodySpec;
+  spec: OpenApiSpec;
+}) => string[];
+declare const extractBodyProps: (args: {
+  requestBody?: RequestBodySpec;
+  spec: OpenApiSpec;
+  serverManagedExtension: string;
+}) => Array<{
+  snakeName: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+  items?: unknown;
+}>;
+declare const processOperation: (args: {
+  pathTemplate: string;
+  method: string;
+  operation: OperationSpec;
+  spec: OpenApiSpec;
+  options: Required<OpenApiToToolsOptions>;
+}) => ToolDefinition | null;
+declare const processPath: (args: {
+  pathTemplate: string;
+  pathItem: Record<string, OperationSpec>;
+  spec: OpenApiSpec;
+  options: Required<OpenApiToToolsOptions>;
+}) => ToolDefinition[];
+/**
+ * Translates one or more OpenAPI documents into REST-backed MCP tool
+ * definitions. Each translatable operation (has an `operationId`, a supported
+ * HTTP method, and is not excluded) becomes one {@link ToolDefinition}.
+ *
+ * @example
+ * ```typescript
+ * import { openApiToToolDefinitions } from '@ttoss/http-server-mcp-openapi';
+ *
+ * const tools = openApiToToolDefinitions({ spec: myOpenApiDocument });
+ * ```
+ */
+declare const openApiToToolDefinitions: (args: {
+  spec: OpenApiSpec | OpenApiSpec[];
+  options?: OpenApiToToolsOptions;
+}) => ToolDefinition[];
+//#endregion
+export { DEFAULT_EXCLUDE_EXTENSION, DEFAULT_SERVER_MANAGED_EXTENSION, type JsonSchemaProperty, type OpenApiSpec, type OpenApiToToolsOptions, type OperationSpec, type RegisterOpenApiToolsArgs, type RequestBodySpec, type ResolvedRequest, type ToolDefinition, buildBodyFn, buildInputSchema, buildPathFn, buildQueryFn, dereferenceSchema, extractAcceptedBodyFields, extractBodyProps, extractPathParams, extractQueryParams, getJsonSchemaType, openApiToToolDefinitions, operationIdToToolName, processOperation, processPath, registerOpenApiTools, resolveParameter, resolveSchema, snakeToCamel };

package/dist/index.d.mts

@@ -0,0 +1,335 @@
+
+import { JsonObjectSchema, McpServer } from "@ttoss/http-server-mcp";
+
+//#region src/types.d.ts
+/**
+ * A single JSON Schema property descriptor as emitted for a tool's
+ * `inputSchema`. Only the subset of JSON Schema the generator produces is
+ * modelled here; the value is forwarded verbatim over the MCP wire protocol.
+ */
+interface JsonSchemaProperty {
+  type: 'string' | 'number' | 'boolean' | 'array' | 'integer' | 'object' | 'null';
+  description?: string;
+  items?: unknown;
+}
+/**
+ * A REST-backed MCP tool derived from a single OpenAPI operation.
+ *
+ * The `path` / `query` / `body` builders turn the camelCase arguments an MCP
+ * client sends into the pieces of an HTTP request against the original REST
+ * API. They intentionally hold no transport concerns (base URL, auth); the
+ * caller wires those in when it performs the request.
+ */
+interface ToolDefinition {
+  /** kebab-case tool name derived from the operation's `operationId`. */
+  name: string;
+  /** Sanitised operation description (quotes escaped, newlines flattened). */
+  description: string;
+  /** Plain JSON Schema describing the tool's camelCase input object. */
+  inputSchema: JsonObjectSchema;
+  /** Uppercase HTTP method (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`). */
+  method: string;
+  /** The raw OpenAPI path template, e.g. `/agents/{agent_id}`. */
+  pathTemplate: string;
+  /** The operation's `operationId`. */
+  operationId: string;
+  /** Builds the request path, substituting path params from the args. */
+  path: (args: Record<string, unknown>) => string;
+  /** Builds the query string (including leading `?`), or `undefined` if none. */
+  query?: (args: Record<string, unknown>) => string;
+  /** Builds the snake_case request body, or `undefined` if the op has no body. */
+  body?: (args: Record<string, unknown>) => Record<string, unknown>;
+  /**
+   * snake_case names of every top-level request-body property the operation's
+   * schema declares, including server-managed ones hidden from `inputSchema`.
+   */
+  acceptedBodyFields: string[];
+  /**
+   * Every `x-` prefixed extension declared on the operation, forwarded
+   * verbatim. Lets consumers read custom metadata (e.g. `x-iam-action`)
+   * without this package needing to know about it.
+   */
+  extensions: Record<string, unknown>;
+}
+/** Minimal shape of an OpenAPI document consumed by the generator. */
+interface OpenApiSpec {
+  paths?: Record<string, Record<string, unknown>>;
+  components?: {
+    schemas?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+  };
+}
+type RequestBodySpec = {
+  required?: boolean;
+  content?: {
+    'application/json'?: {
+      schema?: {
+        type?: string;
+        required?: string[];
+        properties?: Record<string, unknown>;
+        oneOf?: Array<Record<string, unknown>>;
+        anyOf?: Array<Record<string, unknown>>;
+        $ref?: string;
+      };
+    };
+  };
+};
+interface OperationSpec {
+  operationId?: string;
+  description?: string;
+  parameters?: Array<{
+    name?: string;
+    in?: string;
+    required?: boolean;
+    description?: string;
+    schema?: {
+      type?: string;
+      items?: {
+        type?: string;
+      };
+    };
+    $ref?: string;
+  }>;
+  requestBody?: RequestBodySpec;
+  [extension: string]: unknown;
+}
+/** Options that tune how operations and body properties are translated. */
+interface OpenApiToToolsOptions {
+  /**
+   * Operation-level extension flag that, when truthy, excludes the operation
+   * from the generated tool surface.
+   * @default 'x-mcp-exclude'
+   */
+  excludeExtension?: string;
+  /**
+   * Body-property extension flag that, when truthy, hides the property from the
+   * generated `inputSchema` while keeping it in `acceptedBodyFields` (for
+   * server-managed fields the API sets itself).
+   * @default 'x-mcp-server-managed'
+   */
+  serverManagedExtension?: string;
+}
+declare const DEFAULT_EXCLUDE_EXTENSION = "x-mcp-exclude";
+declare const DEFAULT_SERVER_MANAGED_EXTENSION = "x-mcp-server-managed";
+//#endregion
+//#region src/registerOpenApiTools.d.ts
+/** The resolved HTTP request a tool call maps to, before transport concerns. */
+interface ResolvedRequest {
+  /** Uppercase HTTP method. */
+  method: string;
+  /** Request path including the query string, e.g. `/agents/agt_1?limit=10`. */
+  url: string;
+  /** snake_case request body, or `undefined` when the operation has none. */
+  body?: Record<string, unknown>;
+  /** The tool definition the call resolved to (for auth/metadata lookups). */
+  tool: ToolDefinition;
+}
+interface RegisterOpenApiToolsArgs {
+  /** The MCP server the generated tools are registered on. */
+  server: McpServer;
+  /** One or more OpenAPI documents to derive tools from. */
+  spec: OpenApiSpec | OpenApiSpec[];
+  /** Tuning options forwarded to {@link openApiToToolDefinitions}. */
+  options?: OpenApiToToolsOptions;
+  /**
+   * Performs the HTTP request for a resolved tool call and returns the raw
+   * response data. This package builds the method/url/body; the caller owns
+   * how the request is executed — base URL, auth headers, fetch impl, etc.
+   */
+  callApi: (request: ResolvedRequest) => Promise<unknown> | unknown;
+  /**
+   * Serialises the raw API data into the MCP tool's text payload.
+   * @default (data) => JSON.stringify(data, null, 2)
+   */
+  toText?: (data: unknown) => string;
+}
+/**
+ * Derives MCP tools from OpenAPI document(s) and registers each on the given
+ * MCP server. Every tool's handler resolves the incoming camelCase args into a
+ * concrete HTTP request and delegates execution to `callApi`.
+ *
+ * @returns The list of {@link ToolDefinition} that were registered.
+ *
+ * @example
+ * ```typescript
+ * import { McpServer } from '@ttoss/http-server-mcp';
+ * import { registerOpenApiTools } from '@ttoss/http-server-mcp-openapi';
+ *
+ * const server = new McpServer({ name: 'my-api', version: '1.0.0' });
+ *
+ * registerOpenApiTools({
+ *   server,
+ *   spec: myOpenApiDocument,
+ *   callApi: async ({ method, url, body }) => {
+ *     const res = await fetch(`https://api.example.com${url}`, {
+ *       method,
+ *       headers: { 'Content-Type': 'application/json' },
+ *       body: body ? JSON.stringify(body) : undefined,
+ *     });
+ *     return res.json();
+ *   },
+ * });
+ * ```
+ */
+declare const registerOpenApiTools: (args: RegisterOpenApiToolsArgs) => ToolDefinition[];
+//#endregion
+//#region src/schema.d.ts
+type ResolvedSchema = {
+  type?: string;
+  required?: string[];
+  properties?: Record<string, unknown>;
+  oneOf?: Array<Record<string, unknown>>;
+  anyOf?: Array<Record<string, unknown>>;
+};
+/**
+ * Recursively inlines every `$ref` in a schema (including refs nested inside
+ * `properties`, `items`, `oneOf`, `anyOf`, etc.), producing a self-contained
+ * schema safe to hand to an MCP client or LLM provider as a tool definition —
+ * provider tool schemas have no `components` section to resolve refs against.
+ */
+declare const dereferenceSchema: (schema: Record<string, unknown> | undefined, spec: OpenApiSpec) => Record<string, unknown> | undefined;
+/**
+ * Resolves a schema down to a single object shape: follows a top-level `$ref`
+ * and merges `oneOf` / `anyOf` alternatives (union of properties, intersection
+ * of `required`) so the caller sees one flat property set.
+ */
+declare const resolveSchema: (schema: Record<string, unknown> | undefined, spec: OpenApiSpec) => ResolvedSchema;
+/** Follows a parameter `$ref` into `components.parameters`, if present. */
+declare const resolveParameter: (param: Record<string, unknown> | undefined, spec: OpenApiSpec) => {
+  name?: string;
+  in?: string;
+  required?: boolean;
+  description?: string;
+  schema?: {
+    type?: string;
+    items?: {
+      type?: string;
+    };
+  };
+};
+/** Builds a function that substitutes path params into the path template. */
+declare const buildPathFn: (pathTemplate: string, pathParams: Array<{
+  name: string;
+  camelName: string;
+}>) => ((args: Record<string, unknown>) => string);
+/**
+ * Builds a function that serialises query params into a query string
+ * (including the leading `?`). Returns `undefined` when the op has no query
+ * params. Array values are appended once per element.
+ */
+declare const buildQueryFn: (queryParams: Array<{
+  name: string;
+  camelName: string;
+}>) => ((args: Record<string, unknown>) => string) | undefined;
+/**
+ * Builds a function that maps camelCase args back to a snake_case request
+ * body, skipping `undefined` args. Returns `undefined` when the op has no body.
+ */
+declare const buildBodyFn: (bodyProps: Array<{
+  snakeName: string;
+  camelName: string;
+}>) => ((args: Record<string, unknown>) => Record<string, unknown>) | undefined;
+//#endregion
+//#region src/toolDefinitions.d.ts
+/**
+ * Folds `_` and `-` separators into camelCase. OpenAPI operation and parameter
+ * names may be snake_case (`agent_id`) or kebab-case (`list-tools`), and MCP
+ * tool inputs are camelCase by convention, so both are folded here.
+ */
+declare const snakeToCamel: (str: string) => string;
+/** Converts a camelCase `operationId` to a kebab-case tool name. */
+declare const operationIdToToolName: (operationId: string) => string;
+declare const getJsonSchemaType: (schemaType: string | undefined) => JsonSchemaProperty["type"];
+declare const buildInputSchema: (pathParams: Array<{
+  name: string;
+  camelName: string;
+}>, queryParams: Array<{
+  name: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+}>, bodyProps: Array<{
+  snakeName: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+  items?: unknown;
+}>) => JsonObjectSchema;
+declare const extractPathParams: (args: {
+  parameters?: Array<{
+    name?: string;
+    in?: string;
+    [key: string]: unknown;
+  }>;
+  spec: OpenApiSpec;
+}) => Array<{
+  name: string;
+  camelName: string;
+}>;
+declare const extractQueryParams: (args: {
+  parameters?: Array<{
+    name?: string;
+    in?: string;
+    [key: string]: unknown;
+  }>;
+  spec: OpenApiSpec;
+}) => Array<{
+  name: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+}>;
+/**
+ * snake_case names of every top-level property an operation's request schema
+ * declares, including server-managed ones.
+ */
+declare const extractAcceptedBodyFields: (args: {
+  requestBody?: RequestBodySpec;
+  spec: OpenApiSpec;
+}) => string[];
+declare const extractBodyProps: (args: {
+  requestBody?: RequestBodySpec;
+  spec: OpenApiSpec;
+  serverManagedExtension: string;
+}) => Array<{
+  snakeName: string;
+  camelName: string;
+  description: string;
+  required: boolean;
+  type: string;
+  items?: unknown;
+}>;
+declare const processOperation: (args: {
+  pathTemplate: string;
+  method: string;
+  operation: OperationSpec;
+  spec: OpenApiSpec;
+  options: Required<OpenApiToToolsOptions>;
+}) => ToolDefinition | null;
+declare const processPath: (args: {
+  pathTemplate: string;
+  pathItem: Record<string, OperationSpec>;
+  spec: OpenApiSpec;
+  options: Required<OpenApiToToolsOptions>;
+}) => ToolDefinition[];
+/**
+ * Translates one or more OpenAPI documents into REST-backed MCP tool
+ * definitions. Each translatable operation (has an `operationId`, a supported
+ * HTTP method, and is not excluded) becomes one {@link ToolDefinition}.
+ *
+ * @example
+ * ```typescript
+ * import { openApiToToolDefinitions } from '@ttoss/http-server-mcp-openapi';
+ *
+ * const tools = openApiToToolDefinitions({ spec: myOpenApiDocument });
+ * ```
+ */
+declare const openApiToToolDefinitions: (args: {
+  spec: OpenApiSpec | OpenApiSpec[];
+  options?: OpenApiToToolsOptions;
+}) => ToolDefinition[];
+//#endregion
+export { DEFAULT_EXCLUDE_EXTENSION, DEFAULT_SERVER_MANAGED_EXTENSION, type JsonSchemaProperty, type OpenApiSpec, type OpenApiToToolsOptions, type OperationSpec, type RegisterOpenApiToolsArgs, type RequestBodySpec, type ResolvedRequest, type ToolDefinition, buildBodyFn, buildInputSchema, buildPathFn, buildQueryFn, dereferenceSchema, extractAcceptedBodyFields, extractBodyProps, extractPathParams, extractQueryParams, getJsonSchemaType, openApiToToolDefinitions, operationIdToToolName, processOperation, processPath, registerOpenApiTools, resolveParameter, resolveSchema, snakeToCamel };