@utcp/http 1.0.4 → 1.0.6

package/dist/openapi_converter.js

@@ -1,535 +0,0 @@
-/**
- * OpenAPI specification converter for UTCP tool generation.
- *
- * This module provides functionality to convert OpenAPI specifications (both 2.0
- * and 3.0) into UTCP tool definitions. It handles schema resolution, authentication
- * mapping, and proper tool creation from REST API specifications.
- *
- * Key Features:
- *     - OpenAPI 2.0 and 3.0 specification support.
- *     - Automatic JSON reference ($ref) resolution.
- *     - Authentication scheme mapping (API key, Basic, OAuth2).
- *     - Input/output schema extraction from OpenAPI schemas.
- *     - URL path parameter handling.
- *     - Request body and header field mapping.
- *     - Call template name generation from specification metadata.
- *
- * The converter creates UTCP tools that can be used to interact with REST APIs
- * defined by OpenAPI specifications, providing a bridge between OpenAPI and UTCP.
- */
-// packages/http/src/openapi_converter.ts
-import { JsonSchemaSchema } from '@utcp/sdk';
-import { UtcpManualSerializer } from '@utcp/sdk';
-/**
- * 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 class OpenApiConverter {
-    spec;
-    spec_url;
-    auth_tools;
-    placeholder_counter = 0;
-    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, options) {
-        this.spec = openapi_spec;
-        this.spec_url = options?.specUrl;
-        this.auth_tools = options?.authTools;
-        this.placeholder_counter = 0;
-        let callTemplateName = options?.callTemplateName;
-        if (!callTemplateName) {
-            callTemplateName = 'openapi_call_template_' + this._generateUuid();
-        }
-        const title = openapi_spec.info?.title || callTemplateName;
-        // Replace characters that are invalid for identifiers
-        const invalidChars = " -.,!?'\"\\/() []{}#@$%^&*+=~`|;:<>";
-        this.call_template_name = Array.from(String(title)).map(c => invalidChars.includes(c) ? '_' : c).join('');
-    }
-    _generateUuid() {
-        // Simple UUID hex generator without dashes
-        return 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'.replace(/x/g, () => {
-            return Math.floor(Math.random() * 16).toString(16);
-        });
-    }
-    _incrementPlaceholderCounter() {
-        this.placeholder_counter++;
-        return this.placeholder_counter;
-    }
-    _getPlaceholder(baseName) {
-        return `\$\{${baseName.toUpperCase()}_${this.placeholder_counter}\}`;
-    }
-    /**
-     * 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() {
-        this.placeholder_counter = 0;
-        const tools = [];
-        let baseUrl = '/';
-        const servers = this.spec.servers;
-        if (servers && Array.isArray(servers) && servers.length > 0 && servers[0].url) {
-            baseUrl = servers[0].url;
-        }
-        else if (this.spec_url) {
-            try {
-                const parsedUrl = new URL(this.spec_url);
-                baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}`;
-            }
-            catch (e) {
-                console.error(`[OpenApiConverter] Invalid spec_url provided: ${this.spec_url}`);
-            }
-        }
-        else {
-            console.warn("[OpenApiConverter] No server info or spec URL provided. Using fallback base URL: '/'");
-        }
-        const paths = this.spec.paths || {};
-        for (const [path, pathItem] of Object.entries(paths)) {
-            for (const [method, operation] of Object.entries(pathItem)) {
-                if (['get', 'post', 'put', 'delete', 'patch'].includes(method.toLowerCase())) {
-                    const tool = this._createTool(path, method, operation, baseUrl);
-                    if (tool) {
-                        tools.push(tool);
-                    }
-                }
-            }
-        }
-        // Use the serializer to leverage default values for utcp_version and manual_version
-        return new UtcpManualSerializer().validateDict({ tools });
-    }
-    /**
-     * Resolves a local JSON reference within the OpenAPI spec.
-     * @param ref The reference string (e.g., '#/components/schemas/Pet').
-     * @returns The resolved schema object.
-     */
-    _resolveRef(ref) {
-        if (!ref.startsWith('#/')) {
-            // External or non-local references are not fully supported by this simple resolver.
-            // For a robust implementation, external fetches would be needed.
-            return { $ref: ref }; // Return the ref itself to indicate it's unresolved
-        }
-        const parts = ref.substring(2).split('/');
-        let node = this.spec;
-        for (const part of parts) {
-            // Decode URI components in case the part contains slashes or other special characters
-            const decodedPart = decodeURIComponent(part);
-            if (node[decodedPart] === undefined) {
-                // Reference not found, return the ref to prevent crashing
-                return { $ref: ref };
-            }
-            node = node[decodedPart];
-        }
-        return node;
-    }
-    /**
-     * 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.
-     */
-    _resolveSchema(schema, visitedRefs = new Set()) {
-        if (schema === null || typeof schema !== 'object') {
-            return schema;
-        }
-        if (Array.isArray(schema)) {
-            return schema.map(item => this._resolveSchema(item, visitedRefs));
-        }
-        if ('$ref' in schema && typeof schema.$ref === 'string') {
-            const ref = schema.$ref;
-            if (visitedRefs.has(ref)) {
-                // Cycle detected, return the reference itself to break the loop
-                return { $ref: ref };
-            }
-            visitedRefs.add(ref);
-            const resolvedRef = this._resolveRef(ref);
-            // Recursively resolve the content of the resolved reference
-            return this._resolveSchema(resolvedRef, visitedRefs);
-        }
-        const newSchema = {};
-        for (const [key, value] of Object.entries(schema)) {
-            newSchema[key] = this._resolveSchema(value, visitedRefs);
-        }
-        return newSchema;
-    }
-    /**
-     * 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.
-     */
-    _createTool(path, method, operation, baseUrl) {
-        const operationId = operation.operationId;
-        if (!operationId) {
-            return null;
-        }
-        const description = operation.summary || operation.description || '';
-        const tags = operation.tags || [];
-        const { inputs, headerFields, bodyField } = this._extractInputs(path, operation);
-        const outputs = this._extractOutputs(operation);
-        const auth = this._extractAuth(operation);
-        const fullUrl = `${baseUrl.replace(/\/$/, '')}/${path.lstrip('/')}`;
-        const callTemplate = {
-            name: this.call_template_name,
-            call_template_type: 'http',
-            http_method: method.toUpperCase(),
-            url: fullUrl,
-            body_field: bodyField ?? undefined,
-            header_fields: headerFields.length > 0 ? headerFields : undefined,
-            auth,
-            content_type: 'application/json',
-            timeout: 30
-        };
-        return {
-            name: operationId,
-            description,
-            inputs: JsonSchemaSchema.parse(inputs),
-            outputs: JsonSchemaSchema.parse(outputs),
-            tags,
-            tool_call_template: callTemplate
-        };
-    }
-    /**
-     * 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).
-     */
-    _extractInputs(path, operation) {
-        const properties = {};
-        const required = [];
-        const headerFields = [];
-        let bodyField = null;
-        // Merge path-level and operation-level parameters
-        const pathItem = this.spec.paths?.[path] || {};
-        const allParams = [...(pathItem.parameters || []), ...(operation.parameters || [])];
-        for (const param of allParams) {
-            const resolvedParam = this._resolveSchema(param);
-            const paramName = resolvedParam.name;
-            if (!paramName)
-                continue;
-            if (resolvedParam.in === 'header') {
-                headerFields.push(paramName);
-            }
-            // OpenAPI 2.0 body parameter (deprecated in 3.0, but still possible)
-            if (resolvedParam.in === 'body') {
-                bodyField = 'body';
-                const jsonSchema = this._resolveSchema(resolvedParam.schema || {});
-                properties[bodyField] = {
-                    description: resolvedParam.description || 'Request body',
-                    ...jsonSchema,
-                };
-                if (resolvedParam.required) {
-                    required.push(bodyField);
-                }
-                continue;
-            }
-            // Other parameters (query, path, header, cookie)
-            const schema = this._resolveSchema(resolvedParam.schema || {});
-            // For OpenAPI 2.0, non-body parameters might have type/items directly on the parameter object
-            if (!schema.type && resolvedParam.type)
-                schema.type = resolvedParam.type;
-            if (!schema.items && resolvedParam.items)
-                schema.items = resolvedParam.items;
-            if (!schema.enum && resolvedParam.enum)
-                schema.enum = resolvedParam.enum;
-            properties[paramName] = {
-                description: resolvedParam.description || '',
-                ...schema,
-            };
-            if (resolvedParam.required) {
-                required.push(paramName);
-            }
-        }
-        // Handle request body (OpenAPI 3.0 equivalent of 'body' parameter)
-        const requestBody = operation.requestBody;
-        if (requestBody) {
-            const resolvedBody = this._resolveSchema(requestBody);
-            const content = resolvedBody.content || {};
-            const jsonSchema = content['application/json']?.schema || content['application/x-www-form-urlencoded']?.schema;
-            if (jsonSchema) {
-                bodyField = 'body';
-                properties[bodyField] = {
-                    description: resolvedBody.description || 'Request body',
-                    ...this._resolveSchema(jsonSchema),
-                };
-                if (resolvedBody.required) {
-                    required.push(bodyField);
-                }
-            }
-        }
-        const inputs = {
-            type: 'object',
-            properties,
-            required: required.length > 0 ? required : undefined
-        };
-        return { inputs, headerFields, bodyField };
-    }
-    /**
-     * Extracts the output schema from an OpenAPI operation, resolving refs.
-     * @param operation The OpenAPI operation object.
-     * @returns The output schema.
-     */
-    _extractOutputs(operation) {
-        const responses = operation.responses || {};
-        // Prioritize 200/201 responses, then fall back to 'default'
-        const successResponse = responses['200'] || responses['201'] || responses['default'];
-        if (!successResponse) {
-            return {};
-        }
-        const resolvedResponse = this._resolveSchema(successResponse);
-        let jsonSchema = null;
-        if ('content' in resolvedResponse) { // OpenAPI 3.0
-            const content = resolvedResponse.content || {};
-            jsonSchema = content['application/json']?.schema || content['text/plain']?.schema;
-            if (!jsonSchema && Object.keys(content).length > 0) {
-                // Fallback to first content type's schema, with a type guard
-                const firstContentTypeValue = Object.values(content)[0];
-                if (typeof firstContentTypeValue === 'object' && firstContentTypeValue !== null && 'schema' in firstContentTypeValue) {
-                    jsonSchema = firstContentTypeValue.schema;
-                }
-            }
-        }
-        else if ('schema' in resolvedResponse) { // OpenAPI 2.0
-            jsonSchema = resolvedResponse.schema;
-        }
-        if (!jsonSchema) {
-            return {};
-        }
-        const resolvedJsonSchema = this._resolveSchema(jsonSchema);
-        const schemaArgs = {
-            type: resolvedJsonSchema.type || 'object',
-            properties: resolvedJsonSchema.properties || undefined,
-            required: resolvedJsonSchema.required || undefined,
-            description: resolvedJsonSchema.description || undefined,
-            title: resolvedJsonSchema.title || undefined,
-            items: resolvedJsonSchema.items || undefined,
-            enum: resolvedJsonSchema.enum || undefined,
-            minimum: resolvedJsonSchema.minimum || undefined,
-            maximum: resolvedJsonSchema.maximum || undefined,
-            format: resolvedJsonSchema.format || undefined,
-        };
-        return schemaArgs;
-    }
-    /**
-     * 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.
-     */
-    _extractAuth(operation) {
-        // First check for operation-level security requirements
-        let securityRequirements = operation.security || [];
-        // If no operation-level security, check global security requirements
-        if (!securityRequirements.length) {
-            securityRequirements = this.spec.security || [];
-        }
-        // If no security requirements, return undefined (endpoint is public)
-        if (!securityRequirements.length) {
-            return undefined;
-        }
-        // Generate auth from OpenAPI security schemes - support both OpenAPI 2.0 and 3.0
-        const securitySchemes = this._getSecuritySchemes();
-        // Process the first security requirement (most common case)
-        // Each security requirement is a dict with scheme name as key
-        for (const securityReq of securityRequirements) {
-            for (const schemeName of Object.keys(securityReq)) {
-                if (schemeName in securitySchemes) {
-                    const scheme = securitySchemes[schemeName];
-                    const openapiAuth = this._createAuthFromScheme(scheme, schemeName);
-                    // If compatible with auth_tools, use actual values from manual call template
-                    if (this._isAuthCompatible(openapiAuth, this.auth_tools)) {
-                        return this.auth_tools;
-                    }
-                    else {
-                        return openapiAuth; // Use placeholder from OpenAPI scheme
-                    }
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * 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
-     */
-    _isAuthCompatible(openapiAuth, authTools) {
-        if (!openapiAuth || !authTools) {
-            return false;
-        }
-        // Must be same auth type
-        if (openapiAuth.auth_type !== authTools.auth_type) {
-            return false;
-        }
-        // For API Key auth, check header name and location compatibility
-        if ('var_name' in openapiAuth && 'var_name' in authTools) {
-            const openapiVar = openapiAuth.var_name?.toLowerCase() || '';
-            const toolsVar = authTools.var_name?.toLowerCase() || '';
-            if (openapiVar !== toolsVar) {
-                return false;
-            }
-            if ('location' in openapiAuth && 'location' in authTools) {
-                if (openapiAuth.location !== authTools.location) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Gets security schemes supporting both OpenAPI 2.0 and 3.0.
-     * @returns A record of security schemes.
-     */
-    _getSecuritySchemes() {
-        // OpenAPI 3.0 format
-        if ('components' in this.spec) {
-            return this.spec.components?.securitySchemes || {};
-        }
-        // OpenAPI 2.0 format
-        return this.spec.securityDefinitions || {};
-    }
-    /**
-     * 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.
-     */
-    _createAuthFromScheme(scheme, schemeName) {
-        const schemeType = (scheme.type || '').toLowerCase();
-        if (schemeType === 'apikey') {
-            // For API key auth, use the parameter name from the OpenAPI spec
-            const location = (scheme.in || 'header');
-            const paramName = scheme.name || 'Authorization';
-            // Use the current counter value for the placeholder
-            const apiKeyPlaceholder = this._getPlaceholder('API_KEY');
-            // Increment the counter after using it
-            this._incrementPlaceholderCounter();
-            return {
-                auth_type: 'api_key',
-                api_key: apiKeyPlaceholder,
-                var_name: paramName,
-                location,
-            };
-        }
-        if (schemeType === 'basic') {
-            // OpenAPI 2.0 format: type: basic
-            // Use the current counter value for both placeholders
-            const usernamePlaceholder = this._getPlaceholder('USERNAME');
-            const passwordPlaceholder = this._getPlaceholder('PASSWORD');
-            // Increment the counter after using it
-            this._incrementPlaceholderCounter();
-            return {
-                auth_type: 'basic',
-                username: usernamePlaceholder,
-                password: passwordPlaceholder,
-            };
-        }
-        if (schemeType === 'http') {
-            // OpenAPI 3.0 format: type: http with scheme
-            const httpScheme = (scheme.scheme || '').toLowerCase();
-            if (httpScheme === 'basic') {
-                // For basic auth, use conventional environment variable names
-                // Use the current counter value for both placeholders
-                const usernamePlaceholder = this._getPlaceholder('USERNAME');
-                const passwordPlaceholder = this._getPlaceholder('PASSWORD');
-                // Increment the counter after using it
-                this._incrementPlaceholderCounter();
-                return {
-                    auth_type: 'basic',
-                    username: usernamePlaceholder,
-                    password: passwordPlaceholder,
-                };
-            }
-            else if (httpScheme === 'bearer') {
-                // Treat bearer tokens as API keys
-                // Use the current counter value for the placeholder
-                const apiKeyPlaceholder = this._getPlaceholder('API_KEY');
-                // Increment the counter after using it
-                this._incrementPlaceholderCounter();
-                return {
-                    auth_type: 'api_key',
-                    api_key: `Bearer ${apiKeyPlaceholder}`,
-                    var_name: 'Authorization',
-                    location: 'header',
-                };
-            }
-        }
-        if (schemeType === 'oauth2') {
-            // Handle both OpenAPI 2.0 and 3.0 OAuth2 formats
-            const flows = scheme.flows || {};
-            // OpenAPI 3.0 format
-            if (Object.keys(flows).length > 0) {
-                for (const [flowType, flowConfig] of Object.entries(flows)) {
-                    // Support both old and new flow names
-                    if (['authorizationCode', 'accessCode', 'clientCredentials', 'application'].includes(flowType)) {
-                        const tokenUrl = flowConfig.tokenUrl;
-                        if (tokenUrl) {
-                            // Use the current counter value for both placeholders
-                            const clientIdPlaceholder = this._getPlaceholder('CLIENT_ID');
-                            const clientSecretPlaceholder = this._getPlaceholder('CLIENT_SECRET');
-                            // Increment the counter after using it
-                            this._incrementPlaceholderCounter();
-                            const scopes = flowConfig.scopes || {};
-                            return {
-                                auth_type: 'oauth2',
-                                token_url: tokenUrl,
-                                client_id: clientIdPlaceholder,
-                                client_secret: clientSecretPlaceholder,
-                                scope: Object.keys(scopes).length > 0 ? Object.keys(scopes).join(' ') : undefined,
-                            };
-                        }
-                    }
-                }
-            }
-            // OpenAPI 2.0 format fallback
-            const tokenUrl = scheme.tokenUrl;
-            if (tokenUrl) {
-                const clientIdPlaceholder = this._getPlaceholder('CLIENT_ID');
-                const clientSecretPlaceholder = this._getPlaceholder('CLIENT_SECRET');
-                this._incrementPlaceholderCounter();
-                const scopes = scheme.scopes || {};
-                return {
-                    auth_type: 'oauth2',
-                    token_url: tokenUrl,
-                    client_id: clientIdPlaceholder,
-                    client_secret: clientSecretPlaceholder,
-                    scope: Object.keys(scopes).length > 0 ? Object.keys(scopes).join(' ') : undefined,
-                };
-            }
-        }
-        return undefined;
-    }
-}
-if (!String.prototype.lstrip) {
-    String.prototype.lstrip = function (chars) {
-        let result = this;
-        while (result.startsWith(chars)) {
-            result = result.substring(chars.length);
-        }
-        return result;
-    };
-}

package/dist/sse_call_template.d.ts

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { CallTemplate } from '@utcp/sdk';
-import { Serializer } from '@utcp/sdk';
-/**
- * REQUIRED
- * Provider configuration for Server-Sent Events (SSE) tools.
- *
- * Enables real-time streaming of events from server to client using the
- * Server-Sent Events protocol. Supports automatic reconnection and
- * event type filtering. All tool arguments not mapped to URL body, headers
- * or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
- *
- * Attributes:
- *     call_template_type: Always "sse" for SSE providers.
- *     url: The SSE endpoint URL to connect to.
- *     event_type: Optional filter for specific event types. If None, all events are received.
- *     reconnect: Whether to automatically reconnect on connection loss.
- *     retry_timeout: Timeout in milliseconds before attempting reconnection.
- *     auth: Optional authentication configuration.
- *     headers: Optional static headers for the initial connection.
- *     body_field: Optional tool argument name to map to request body during connection.
- *     header_fields: List of tool argument names to map to HTTP headers during connection.
- */
-export interface SseCallTemplate extends CallTemplate {
-    call_template_type: 'sse';
-    url: string;
-    event_type?: string | null;
-    reconnect: boolean;
-    retry_timeout: number;
-    headers?: Record<string, string>;
-    body_field?: string | null;
-    header_fields?: string[] | null;
-}
-/**
- * SSE Call Template schema.
- */
-export declare const SseCallTemplateSchema: z.ZodType<SseCallTemplate>;
-/**
- * REQUIRED
- * Serializer for SseCallTemplate.
- */
-export declare class SseCallTemplateSerializer extends Serializer<SseCallTemplate> {
-    /**
-     * REQUIRED
-     * Convert SseCallTemplate to dictionary.
-     */
-    toDict(obj: SseCallTemplate): Record<string, unknown>;
-    /**
-     * REQUIRED
-     * Validate dictionary and convert to SseCallTemplate.
-     */
-    validateDict(obj: Record<string, unknown>): SseCallTemplate;
-}

package/dist/sse_call_template.js

@@ -1,55 +0,0 @@
-// packages/http/src/sse_call_template.ts
-import { z } from 'zod';
-import { AuthSchema } from '@utcp/sdk';
-import { Serializer } from '@utcp/sdk';
-/**
- * SSE Call Template schema.
- */
-export const SseCallTemplateSchema = z.object({
-    name: z.string().optional(),
-    call_template_type: z.literal('sse'),
-    url: z.string().describe('The SSE endpoint URL to connect to.'),
-    event_type: z.string().nullable().optional().describe('Optional filter for specific event types. If null, all events are received.'),
-    reconnect: z.boolean().default(true).describe('Whether to automatically reconnect on connection loss.'),
-    retry_timeout: z.number().default(30000).describe('Timeout in milliseconds before attempting reconnection.'),
-    auth: AuthSchema.optional().describe('Optional authentication configuration.'),
-    headers: z.record(z.string(), z.string()).optional().describe('Optional static headers for the initial connection.'),
-    body_field: z.string().nullable().optional().describe('The name of the single input field to be sent as the request body.'),
-    header_fields: z.array(z.string()).nullable().optional().describe('List of input fields to be sent as request headers for the initial connection.'),
-});
-/**
- * REQUIRED
- * Serializer for SseCallTemplate.
- */
-export class SseCallTemplateSerializer extends Serializer {
-    /**
-     * REQUIRED
-     * Convert SseCallTemplate to dictionary.
-     */
-    toDict(obj) {
-        return {
-            name: obj.name,
-            call_template_type: obj.call_template_type,
-            url: obj.url,
-            event_type: obj.event_type,
-            reconnect: obj.reconnect,
-            retry_timeout: obj.retry_timeout,
-            auth: obj.auth,
-            headers: obj.headers,
-            body_field: obj.body_field,
-            header_fields: obj.header_fields,
-        };
-    }
-    /**
-     * REQUIRED
-     * Validate dictionary and convert to SseCallTemplate.
-     */
-    validateDict(obj) {
-        try {
-            return SseCallTemplateSchema.parse(obj);
-        }
-        catch (e) {
-            throw new Error(`Invalid SseCallTemplate: ${e.message}\n${e.stack || ''}`);
-        }
-    }
-}

package/dist/sse_communication_protocol.d.ts

@@ -1,47 +0,0 @@
-/**
- * Server-Sent Events (SSE) Communication Protocol for UTCP.
- *
- * Handles Server-Sent Events based tool providers with streaming capabilities.
- */
-import { CommunicationProtocol } from '@utcp/sdk';
-import { RegisterManualResult } from '@utcp/sdk';
-import { CallTemplate } from '@utcp/sdk';
-import { IUtcpClient } from '@utcp/sdk';
-/**
- * REQUIRED
- * SSE communication protocol implementation for UTCP client.
- *
- * Handles Server-Sent Events based tool providers with streaming capabilities.
- */
-export declare class SseCommunicationProtocol implements CommunicationProtocol {
-    private oauthTokens;
-    private _logInfo;
-    private _logError;
-    private _applyAuth;
-    /**
-     * REQUIRED
-     * Register a manual and its tools from an SSE provider.
-     */
-    registerManual(caller: IUtcpClient, manualCallTemplate: CallTemplate): Promise<RegisterManualResult>;
-    /**
-     * REQUIRED
-     * Deregister a manual (no-op for SSE).
-     */
-    deregisterManual(caller: IUtcpClient, manualCallTemplate: CallTemplate): Promise<void>;
-    /**
-     * REQUIRED
-     * Call a tool using SSE (non-streaming).
-     */
-    callTool(caller: IUtcpClient, toolName: string, toolArgs: Record<string, any>, toolCallTemplate: CallTemplate): Promise<any>;
-    /**
-     * REQUIRED
-     * Call a tool using SSE streaming.
-     * Returns an async generator that yields SSE events.
-     */
-    callToolStreaming(caller: IUtcpClient, toolName: string, toolArgs: Record<string, any>, toolCallTemplate: CallTemplate): AsyncGenerator<any, void, unknown>;
-    /**
-     * REQUIRED
-     * Close all active connections and clear internal state.
-     */
-    close(): Promise<void>;
-}