@utcp/http 1.0.4 → 1.0.7

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@utcp/http",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "HTTP utilities for UTCP",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "license": "MPL-2.0",
@@ -28,7 +29,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc"
+    "build": "tsup"
   },
   "files": [
     "dist"
@@ -37,12 +38,12 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@utcp/sdk": "^1.0.4",
+    "@utcp/sdk": "^1.0.6",
     "axios": "^1.11.0",
     "js-yaml": "^4.1.0"
   },

package/dist/http_call_template.d.ts

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-import { Auth } from '@utcp/sdk';
-import { CallTemplate } from '@utcp/sdk';
-import { Serializer } from '@utcp/sdk';
-/**
- * REQUIRED
- * Provider configuration for HTTP-based tools.
- *
- * Supports RESTful HTTP/HTTPS APIs with various HTTP methods, authentication,
- * custom headers, and flexible request/response handling. Supports URL path
- * parameters using {parameter_name} syntax.
- */
-export interface HttpCallTemplate extends CallTemplate {
-    call_template_type: 'http';
-    http_method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    url: string;
-    content_type: string;
-    headers?: Record<string, string>;
-    body_field?: string;
-    header_fields?: string[];
-    auth_tools?: Auth | null;
-}
-/**
- * HTTP Call Template schema for RESTful HTTP/HTTPS API tools.
- * Extends the base CallTemplate and defines HTTP-specific configuration.
- */
-export declare const HttpCallTemplateSchema: z.ZodType<HttpCallTemplate>;
-/**
- * REQUIRED
- * Serializer for HttpCallTemplate.
- */
-export declare class HttpCallTemplateSerializer extends Serializer<HttpCallTemplate> {
-    toDict(obj: HttpCallTemplate): Record<string, unknown>;
-    validateDict(obj: Record<string, unknown>): HttpCallTemplate;
-}

package/dist/http_call_template.js

@@ -1,55 +0,0 @@
-// packages/http/src/http_call_template.ts
-import { z } from 'zod';
-import { AuthSchema, AuthSerializer } from '@utcp/sdk';
-import { Serializer } from '@utcp/sdk';
-/**
- * HTTP Call Template schema for RESTful HTTP/HTTPS API tools.
- * Extends the base CallTemplate and defines HTTP-specific configuration.
- */
-export const HttpCallTemplateSchema = z.object({
-    name: z.string().optional(),
-    call_template_type: z.literal('http'),
-    http_method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).default('GET'),
-    url: z.string().describe('The base URL for the HTTP endpoint. Supports path parameters like "https://api.example.com/users/{user_id}".'),
-    content_type: z.string().default('application/json').describe('The Content-Type header for requests.'),
-    auth: AuthSchema.optional().describe('Optional authentication configuration.'),
-    headers: z.record(z.string(), z.string()).optional().describe('Optional static headers to include in all requests.'),
-    body_field: z.string().optional().default('body').describe('The name of the single input field to be sent as the request body.'),
-    header_fields: z.array(z.string()).optional().describe('List of input fields to be sent as request headers.'),
-    auth_tools: AuthSchema.nullable().optional().transform((val) => {
-        if (val === null || val === undefined)
-            return null;
-        if (typeof val === 'object' && 'auth_type' in val) {
-            return new AuthSerializer().validateDict(val);
-        }
-        return val;
-    }).describe('Authentication configuration for generated tools'),
-});
-/**
- * REQUIRED
- * Serializer for HttpCallTemplate.
- */
-export class HttpCallTemplateSerializer extends Serializer {
-    toDict(obj) {
-        return {
-            name: obj.name,
-            call_template_type: obj.call_template_type,
-            http_method: obj.http_method,
-            url: obj.url,
-            content_type: obj.content_type,
-            auth: obj.auth,
-            auth_tools: obj.auth_tools ? new AuthSerializer().toDict(obj.auth_tools) : null,
-            headers: obj.headers,
-            body_field: obj.body_field,
-            header_fields: obj.header_fields,
-        };
-    }
-    validateDict(obj) {
-        try {
-            return HttpCallTemplateSchema.parse(obj);
-        }
-        catch (e) {
-            throw new Error(`Invalid HttpCallTemplate: ${e.message}\n${e.stack || ''}`);
-        }
-    }
-}

package/dist/http_communication_protocol.d.ts

@@ -1,88 +0,0 @@
-import { CommunicationProtocol } from '@utcp/sdk';
-import { RegisterManualResult } from '@utcp/sdk';
-import { CallTemplate } from '@utcp/sdk';
-import { IUtcpClient } from '@utcp/sdk';
-/**
- * HTTP communication protocol implementation for UTCP client.
- *
- * Handles communication with HTTP-based tool providers, supporting various
- * authentication methods, URL path parameters, and automatic tool discovery.
- * Enforces security by requiring HTTPS or localhost connections.
- */
-export declare class HttpCommunicationProtocol implements CommunicationProtocol {
-    private _oauthTokens;
-    private _axiosInstance;
-    constructor();
-    private _logInfo;
-    private _logError;
-    /**
-     * Registers a manual and its tools from an HTTP provider.
-     * Supports UTCP Manuals directly or OpenAPI specifications which are converted.
-     *
-     * @param caller The UTCP client instance.
-     * @param manualCallTemplate The HTTP call template for discovery.
-     * @returns A RegisterManualResult object.
-     */
-    registerManual(caller: IUtcpClient, manualCallTemplate: CallTemplate): Promise<RegisterManualResult>;
-    /**
-     * Deregisters an HTTP manual. This is a no-op for stateless HTTP communication.
-     * @param caller The UTCP client instance.
-     * @param manualCallTemplate The HTTP call template to deregister.
-     */
-    deregisterManual(caller: IUtcpClient, manualCallTemplate: CallTemplate): Promise<void>;
-    /**
-     * Executes a tool call through the HTTP protocol.
-     *
-     * @param caller The UTCP client instance.
-     * @param toolName Name of the tool to call.
-     * @param toolArgs Dictionary of arguments to pass to the tool.
-     * @param toolCallTemplate The HTTP call template for the tool.
-     * @returns The tool's response.
-     */
-    callTool(caller: IUtcpClient, toolName: string, toolArgs: Record<string, any>, toolCallTemplate: CallTemplate): Promise<any>;
-    /**
-     * Executes a tool call through this transport streamingly.
-     * For standard HTTP, this typically means fetching the full response and yielding it as a single chunk.
-     * Real streaming for protocols like SSE or HTTP chunked transfer would be in their specific implementations.
-     *
-     * @param caller The UTCP client instance.
-     * @param toolName Name of the tool to call.
-     * @param toolArgs Dictionary of arguments to pass to the tool.
-     * @param toolCallTemplate The HTTP call template for the tool.
-     * @returns An async generator that yields chunks of the tool's response.
-     */
-    callToolStreaming(caller: IUtcpClient, toolName: string, toolArgs: Record<string, any>, toolCallTemplate: CallTemplate): AsyncGenerator<any, void, unknown>;
-    /**
-     * Closes any persistent connections or resources held by the communication protocol.
-     * For stateless HTTP, this clears OAuth tokens.
-     */
-    close(): Promise<void>;
-    /**
-     * Applies authentication details from the HttpCallTemplate to the Axios request configuration.
-     * This modifies `requestConfig.headers`, `requestConfig.params`, `requestConfig.auth`, and returns cookies.
-     *
-     * @param httpCallTemplate The CallTemplate containing authentication details.
-     * @param requestConfig The Axios request configuration to modify.
-     * @returns A Promise that resolves to an object containing any cookies to be set.
-     */
-    private _applyAuthToRequestConfig;
-    /**
-     * Handles OAuth2 client credentials flow, trying both body and auth header methods.
-     * Caches tokens and automatically refreshes if expired.
-     *
-     * @param authDetails The OAuth2 authentication details.
-     * @returns The access token.
-     * @throws Error if token cannot be fetched.
-     */
-    private _handleOAuth2;
-    /**
-     * Builds a URL by substituting path parameters from the provided arguments.
-     * Used arguments are removed from the `args` object.
-     *
-     * @param urlTemplate The URL template with path parameters in `{param_name}` format.
-     * @param args The dictionary of arguments; modified to remove path parameters.
-     * @returns The URL with path parameters substituted.
-     * @throws Error if a required path parameter is missing.
-     */
-    private _buildUrlWithPathParams;
-}

package/dist/http_communication_protocol.js

@@ -1,337 +0,0 @@
-// packages/http/src/http_communication_protocol.ts
-import axios from 'axios';
-import * as yaml from 'js-yaml';
-import { URLSearchParams } from 'url';
-import { UtcpManualSchema } from '@utcp/sdk';
-import { HttpCallTemplateSchema } from './http_call_template';
-import { OpenApiConverter } from './openapi_converter';
-/**
- * HTTP communication protocol implementation for UTCP client.
- *
- * Handles communication with HTTP-based tool providers, supporting various
- * authentication methods, URL path parameters, and automatic tool discovery.
- * Enforces security by requiring HTTPS or localhost connections.
- */
-export class HttpCommunicationProtocol {
-    _oauthTokens = new Map();
-    _axiosInstance;
-    constructor() {
-        this._axiosInstance = axios.create({
-            timeout: 30000,
-        });
-    }
-    _logInfo(message) {
-        console.log(`[HttpCommunicationProtocol] ${message}`);
-    }
-    _logError(message, error) {
-        console.error(`[HttpCommunicationProtocol Error] ${message}`, error);
-    }
-    /**
-     * Registers a manual and its tools from an HTTP provider.
-     * Supports UTCP Manuals directly or OpenAPI specifications which are converted.
-     *
-     * @param caller The UTCP client instance.
-     * @param manualCallTemplate The HTTP call template for discovery.
-     * @returns A RegisterManualResult object.
-     */
-    async registerManual(caller, manualCallTemplate) {
-        const httpCallTemplate = HttpCallTemplateSchema.parse(manualCallTemplate);
-        try {
-            const url = httpCallTemplate.url;
-            if (!url.startsWith('https://') && !url.startsWith('http://localhost') && !url.startsWith('http://127.0.0.1')) {
-                throw new Error(`Security error: URL must use HTTPS or start with 'http://localhost' or 'http://127.0.0.1'. Got: ${url}. ` +
-                    "Non-secure URLs are vulnerable to man-in-the-middle attacks.");
-            }
-            this._logInfo(`Discovering tools from '${httpCallTemplate.name}' (HTTP) at ${url}`);
-            const requestConfig = {
-                method: httpCallTemplate.http_method,
-                url: url,
-                headers: { ...httpCallTemplate.headers },
-                params: {},
-                data: undefined,
-                auth: undefined,
-                timeout: 10000
-            };
-            await this._applyAuthToRequestConfig(httpCallTemplate, requestConfig);
-            const response = await this._axiosInstance.request(requestConfig);
-            const contentType = response.headers['content-type'] || '';
-            let responseData;
-            if (contentType.includes('yaml') || url.endsWith('.yaml') || url.endsWith('.yml')) {
-                responseData = yaml.load(response.data);
-            }
-            else {
-                responseData = response.data;
-            }
-            let utcpManual;
-            if (responseData && responseData.utcp_version && Array.isArray(responseData.tools)) {
-                this._logInfo(`Detected UTCP manual from '${httpCallTemplate.name}'.`);
-                utcpManual = UtcpManualSchema.parse(responseData);
-            }
-            else if (responseData && (responseData.openapi || responseData.swagger || responseData.paths)) {
-                this._logInfo(`Assuming OpenAPI spec from '${httpCallTemplate.name}'. Converting to UTCP manual.`);
-                const converter = new OpenApiConverter(responseData, {
-                    specUrl: httpCallTemplate.url,
-                    callTemplateName: httpCallTemplate.name
-                });
-                utcpManual = converter.convert();
-            }
-            else {
-                throw new Error("Response is neither a valid UTCP Manual nor an OpenAPI Specification.");
-            }
-            const toolsInManual = utcpManual.tools;
-            if (toolsInManual.length > 0) {
-                this._logInfo(`Found ${toolsInManual.length} tools.`);
-            }
-            return {
-                manualCallTemplate: httpCallTemplate,
-                manual: utcpManual,
-                success: true,
-                errors: []
-            };
-        }
-        catch (error) {
-            this._logError(`Error discovering tools from HTTP provider '${httpCallTemplate.name}':`, error);
-            return {
-                manualCallTemplate: httpCallTemplate,
-                manual: UtcpManualSchema.parse({ tools: [] }),
-                success: false,
-                errors: [axios.isAxiosError(error) ? error.message : String(error)]
-            };
-        }
-    }
-    /**
-     * Deregisters an HTTP manual. This is a no-op for stateless HTTP communication.
-     * @param caller The UTCP client instance.
-     * @param manualCallTemplate The HTTP call template to deregister.
-     */
-    async deregisterManual(caller, manualCallTemplate) {
-        this._logInfo(`Deregistering HTTP manual '${manualCallTemplate.name}' (no-op).`);
-        return Promise.resolve();
-    }
-    /**
-     * Executes a tool call through the HTTP protocol.
-     *
-     * @param caller The UTCP client instance.
-     * @param toolName Name of the tool to call.
-     * @param toolArgs Dictionary of arguments to pass to the tool.
-     * @param toolCallTemplate The HTTP call template for the tool.
-     * @returns The tool's response.
-     */
-    async callTool(caller, toolName, toolArgs, toolCallTemplate) {
-        const httpCallTemplate = HttpCallTemplateSchema.parse(toolCallTemplate);
-        const requestHeaders = { ...httpCallTemplate.headers };
-        let bodyContent = undefined;
-        const remainingArgs = { ...toolArgs };
-        const queryParams = {};
-        if (httpCallTemplate.header_fields) {
-            for (const fieldName of httpCallTemplate.header_fields) {
-                if (fieldName in remainingArgs) {
-                    requestHeaders[fieldName] = String(remainingArgs[fieldName]);
-                    delete remainingArgs[fieldName];
-                }
-            }
-        }
-        if (httpCallTemplate.body_field && httpCallTemplate.body_field in remainingArgs) {
-            bodyContent = remainingArgs[httpCallTemplate.body_field];
-            delete remainingArgs[httpCallTemplate.body_field];
-        }
-        const url = this._buildUrlWithPathParams(httpCallTemplate.url, remainingArgs);
-        Object.assign(queryParams, remainingArgs);
-        const requestConfig = {
-            method: httpCallTemplate.http_method,
-            url: url,
-            headers: requestHeaders,
-            params: queryParams,
-            data: bodyContent,
-            auth: undefined,
-            timeout: httpCallTemplate.timeout
-        };
-        await this._applyAuthToRequestConfig(httpCallTemplate, requestConfig);
-        try {
-            if (bodyContent !== undefined && !('Content-Type' in (requestConfig.headers || {}))) {
-                requestConfig.headers = {
-                    ...(requestConfig.headers || {}),
-                    'Content-Type': httpCallTemplate.content_type,
-                };
-            }
-            this._logInfo(`Executing HTTP tool '${toolName}' with URL: ${requestConfig.url} and method: ${requestConfig.method}`);
-            const response = await this._axiosInstance.request(requestConfig);
-            const contentType = response.headers['content-type'] || '';
-            if (contentType.includes('yaml') || url.endsWith('.yaml') || url.endsWith('.yml')) {
-                return yaml.load(response.data);
-            }
-            return response.data;
-        }
-        catch (error) {
-            this._logError(`Error calling HTTP tool '${toolName}':`, error);
-            throw error;
-        }
-    }
-    /**
-     * Executes a tool call through this transport streamingly.
-     * For standard HTTP, this typically means fetching the full response and yielding it as a single chunk.
-     * Real streaming for protocols like SSE or HTTP chunked transfer would be in their specific implementations.
-     *
-     * @param caller The UTCP client instance.
-     * @param toolName Name of the tool to call.
-     * @param toolArgs Dictionary of arguments to pass to the tool.
-     * @param toolCallTemplate The HTTP call template for the tool.
-     * @returns An async generator that yields chunks of the tool's response.
-     */
-    async *callToolStreaming(caller, toolName, toolArgs, toolCallTemplate) {
-        this._logInfo(`HTTP protocol does not inherently support streaming for '${toolName}'. Fetching full response.`);
-        const result = await this.callTool(caller, toolName, toolArgs, toolCallTemplate);
-        yield result;
-    }
-    /**
-     * Closes any persistent connections or resources held by the communication protocol.
-     * For stateless HTTP, this clears OAuth tokens.
-     */
-    async close() {
-        this._oauthTokens.clear();
-        this._logInfo("HTTP Communication Protocol closed. OAuth tokens cleared.");
-        return Promise.resolve();
-    }
-    /**
-     * Applies authentication details from the HttpCallTemplate to the Axios request configuration.
-     * This modifies `requestConfig.headers`, `requestConfig.params`, `requestConfig.auth`, and returns cookies.
-     *
-     * @param httpCallTemplate The CallTemplate containing authentication details.
-     * @param requestConfig The Axios request configuration to modify.
-     * @returns A Promise that resolves to an object containing any cookies to be set.
-     */
-    async _applyAuthToRequestConfig(httpCallTemplate, requestConfig) {
-        const cookies = {};
-        if (httpCallTemplate.auth) {
-            if (httpCallTemplate.auth.auth_type === 'api_key') {
-                const apiKeyAuth = httpCallTemplate.auth;
-                if (!apiKeyAuth.api_key) {
-                    throw new Error("API key for ApiKeyAuth is empty.");
-                }
-                if (apiKeyAuth.location === 'header') {
-                    requestConfig.headers = { ...requestConfig.headers, [apiKeyAuth.var_name]: apiKeyAuth.api_key };
-                }
-                else if (apiKeyAuth.location === 'query') {
-                    requestConfig.params = { ...requestConfig.params, [apiKeyAuth.var_name]: apiKeyAuth.api_key };
-                }
-                else if (apiKeyAuth.location === 'cookie') {
-                    cookies[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                }
-            }
-            else if (httpCallTemplate.auth.auth_type === 'basic') {
-                const basicAuth = httpCallTemplate.auth;
-                requestConfig.auth = {
-                    username: basicAuth.username,
-                    password: basicAuth.password
-                };
-            }
-            else if (httpCallTemplate.auth.auth_type === 'oauth2') {
-                const oauth2Auth = httpCallTemplate.auth;
-                const token = await this._handleOAuth2(oauth2Auth);
-                requestConfig.headers = { ...requestConfig.headers, 'Authorization': `Bearer ${token}` };
-            }
-        }
-        return cookies;
-    }
-    /**
-     * Handles OAuth2 client credentials flow, trying both body and auth header methods.
-     * Caches tokens and automatically refreshes if expired.
-     *
-     * @param authDetails The OAuth2 authentication details.
-     * @returns The access token.
-     * @throws Error if token cannot be fetched.
-     */
-    async _handleOAuth2(authDetails) {
-        const clientId = authDetails.client_id;
-        const cachedToken = this._oauthTokens.get(clientId);
-        if (cachedToken && cachedToken.expiresAt > Date.now()) {
-            return cachedToken.accessToken;
-        }
-        this._logInfo(`Fetching new OAuth2 token for client: '${clientId}'`);
-        const tokenFetchPromises = [];
-        // Method 1: Send credentials in the request body
-        tokenFetchPromises.push((async () => {
-            try {
-                const bodyData = new URLSearchParams({
-                    'grant_type': 'client_credentials',
-                    'client_id': authDetails.client_id,
-                    'client_secret': authDetails.client_secret,
-                    'scope': authDetails.scope || ''
-                });
-                const response = await this._axiosInstance.post(authDetails.token_url, bodyData.toString(), { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
-                if (!response.data.access_token) {
-                    throw new Error("Access token not found in response.");
-                }
-                const expiresAt = Date.now() + (response.data.expires_in * 1000 || 3600 * 1000);
-                this._oauthTokens.set(clientId, { accessToken: response.data.access_token, expiresAt });
-                this._logInfo(`OAuth2 token fetched via body for client: '${clientId}'.`);
-                return response.data.access_token;
-            }
-            catch (error) {
-                this._logError(`OAuth2 with credentials in body failed for '${clientId}':`, error);
-                throw error;
-            }
-        })());
-        // Method 2: Send credentials as Basic Auth header
-        tokenFetchPromises.push((async () => {
-            try {
-                const bodyData = new URLSearchParams({
-                    'grant_type': 'client_credentials',
-                    'scope': authDetails.scope || ''
-                });
-                const response = await this._axiosInstance.post(authDetails.token_url, bodyData.toString(), {
-                    auth: { username: authDetails.client_id, password: authDetails.client_secret },
-                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
-                });
-                if (!response.data.access_token) {
-                    throw new Error("Access token not found in response.");
-                }
-                const expiresAt = Date.now() + (response.data.expires_in * 1000 || 3600 * 1000);
-                this._oauthTokens.set(clientId, { accessToken: response.data.access_token, expiresAt });
-                this._logInfo(`OAuth2 token fetched via Basic Auth header for client: '${clientId}'.`);
-                return response.data.access_token;
-            }
-            catch (error) {
-                this._logError(`OAuth2 with Basic Auth header failed for '${clientId}':`, error);
-                throw error;
-            }
-        })());
-        // Try both methods, and resolve if any succeed
-        try {
-            return await Promise.any(tokenFetchPromises);
-        }
-        catch (aggregateError) {
-            const errorMessages = aggregateError.errors ? aggregateError.errors.map((e) => e.message).join('; ') : String(aggregateError);
-            throw new Error(`Failed to fetch OAuth2 token for client '${clientId}' after trying all methods. Details: ${errorMessages}`);
-        }
-    }
-    /**
-     * Builds a URL by substituting path parameters from the provided arguments.
-     * Used arguments are removed from the `args` object.
-     *
-     * @param urlTemplate The URL template with path parameters in `{param_name}` format.
-     * @param args The dictionary of arguments; modified to remove path parameters.
-     * @returns The URL with path parameters substituted.
-     * @throws Error if a required path parameter is missing.
-     */
-    _buildUrlWithPathParams(urlTemplate, args) {
-        let url = urlTemplate;
-        const pathParams = urlTemplate.match(/\{([^}]+)\}/g) || [];
-        for (const param of pathParams) {
-            const paramName = param.slice(1, -1);
-            if (paramName in args) {
-                // URL-encode the parameter value to prevent path injection
-                url = url.replace(param, encodeURIComponent(String(args[paramName])));
-                delete args[paramName];
-            }
-            else {
-                throw new Error(`Missing required path parameter: ${paramName}`);
-            }
-        }
-        const remainingParams = url.match(/\{([^}]+)\}/g);
-        if (remainingParams && remainingParams.length > 0) {
-            throw new Error(`Missing required path parameters in URL template: ${remainingParams.join(', ')}`);
-        }
-        return url;
-    }
-}

package/dist/openapi_converter.d.ts

@@ -1,117 +0,0 @@
-import { UtcpManual } from '@utcp/sdk';
-import { Auth } from '@utcp/sdk';
-interface OpenApiConverterOptions {
-    specUrl?: string;
-    callTemplateName?: string;
-    authTools?: Auth;
-}
-/**
- * REQUIRED
- * Converts OpenAPI specifications into UTCP tool definitions.
- *
- * Processes OpenAPI 2.0 and 3.0 specifications to generate equivalent UTCP
- * tools, handling schema resolution, authentication mapping, and proper
- * HTTP call_template configuration. Each operation in the OpenAPI spec becomes
- * a UTCP tool with appropriate input/output schemas.
- */
-export declare class OpenApiConverter {
-    private spec;
-    private spec_url;
-    private auth_tools;
-    private placeholder_counter;
-    private call_template_name;
-    /**
-     * Initializes the OpenAPI converter.
-     *
-     * @param openapi_spec Parsed OpenAPI specification as a dictionary.
-     * @param options Optional settings including spec_url, call_template_name, and auth_tools.
-     *     - specUrl: URL where the specification was retrieved from.
-     *     - callTemplateName: Custom name for the call_template if spec title not provided.
-     *     - authTools: Optional auth configuration for generated tools.
-     */
-    constructor(openapi_spec: Record<string, any>, options?: OpenApiConverterOptions);
-    private _generateUuid;
-    private _incrementPlaceholderCounter;
-    private _getPlaceholder;
-    /**
-     * Parses the OpenAPI specification and returns a UtcpManual.
-     * @returns A UTCP manual containing tools derived from the OpenAPI specification.
-     */
-    /**
-     * REQUIRED
-     * Converts the loaded OpenAPI specification into a UtcpManual.
-     */
-    convert(): UtcpManual;
-    /**
-     * Resolves a local JSON reference within the OpenAPI spec.
-     * @param ref The reference string (e.g., '#/components/schemas/Pet').
-     * @returns The resolved schema object.
-     */
-    private _resolveRef;
-    /**
-     * Recursively resolves all $refs in a schema object, preventing infinite loops.
-     * @param schema The schema object that may contain references.
-     * @param visitedRefs A set of references already visited to detect cycles.
-     * @returns The resolved schema with all references replaced by their actual values.
-     */
-    private _resolveSchema;
-    /**
-     * Creates a Tool object from an OpenAPI operation.
-     * @param path The API path.
-     * @param method The HTTP method (GET, POST, etc.).
-     * @param operation The operation definition from OpenAPI.
-     * @param baseUrl The base URL for the API.
-     * @returns A Tool object or null if operationId is not defined.
-     */
-    private _createTool;
-    /**
-     * Extracts the input schema, header fields, and body field from an OpenAPI operation.
-     * - Merges path-level and operation-level parameters.
-     * - Resolves $ref for parameters.
-     * - Supports OpenAPI 2.0 body parameters and 3.0 requestBody.
-     * @param path The API path.
-     * @param operation The OpenAPI operation object.
-     * @returns An object containing the inputs schema, a list of header field names, and the body field name (if any).
-     */
-    private _extractInputs;
-    /**
-     * Extracts the output schema from an OpenAPI operation, resolving refs.
-     * @param operation The OpenAPI operation object.
-     * @returns The output schema.
-     */
-    private _extractOutputs;
-    /**
-     * Extracts authentication information from OpenAPI operation and global security schemes.
-     * Uses auth_tools configuration when compatible with OpenAPI auth requirements.
-     * Supports both OpenAPI 2.0 and 3.0 security schemes.
-     * @param operation The OpenAPI operation object.
-     * @returns An Auth object or undefined if no authentication is specified.
-     */
-    private _extractAuth;
-    /**
-     * Checks if auth_tools configuration is compatible with OpenAPI auth requirements.
-     *
-     * @param openapiAuth Auth generated from OpenAPI security scheme
-     * @param authTools Auth configuration from manual call template
-     * @returns True if compatible and auth_tools should be used, False otherwise
-     */
-    private _isAuthCompatible;
-    /**
-     * Gets security schemes supporting both OpenAPI 2.0 and 3.0.
-     * @returns A record of security schemes.
-     */
-    private _getSecuritySchemes;
-    /**
-     * Creates an Auth object from an OpenAPI security scheme.
-     * @param scheme The security scheme object.
-     * @param schemeName The name of the security scheme.
-     * @returns An Auth object or undefined if the scheme is not supported.
-     */
-    private _createAuthFromScheme;
-}
-declare global {
-    interface String {
-        lstrip(chars: string): string;
-    }
-}
-export {};