@utcp/http 1.0.4 → 1.0.6

package/dist/sse_communication_protocol.js

@@ -1,157 +0,0 @@
-import { UtcpManualSerializer } from '@utcp/sdk';
-/**
- * REQUIRED
- * SSE communication protocol implementation for UTCP client.
- *
- * Handles Server-Sent Events based tool providers with streaming capabilities.
- */
-export class SseCommunicationProtocol {
-    oauthTokens = new Map();
-    _logInfo(message) {
-        console.log(`[SseCommunicationProtocol] ${message}`);
-    }
-    _logError(message) {
-        console.error(`[SseCommunicationProtocol] ${message}`);
-    }
-    _applyAuth(provider, headers, queryParams) {
-        let auth;
-        const cookies = {};
-        if (provider.auth) {
-            if ('api_key' in provider.auth) {
-                const apiKeyAuth = provider.auth;
-                if (apiKeyAuth.api_key) {
-                    if (apiKeyAuth.location === 'header') {
-                        headers[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                    }
-                    else if (apiKeyAuth.location === 'query') {
-                        queryParams[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                    }
-                    else if (apiKeyAuth.location === 'cookie') {
-                        cookies[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                    }
-                }
-                else {
-                    this._logError('API key not found for ApiKeyAuth.');
-                    throw new Error('API key for ApiKeyAuth not found.');
-                }
-            }
-            else if ('username' in provider.auth && 'password' in provider.auth) {
-                const basicAuth = provider.auth;
-                auth = { username: basicAuth.username, password: basicAuth.password };
-            }
-            else if ('token_url' in provider.auth) {
-                // OAuth2 will be handled separately
-            }
-        }
-        return { auth, cookies };
-    }
-    /**
-     * REQUIRED
-     * Register a manual and its tools from an SSE provider.
-     */
-    async registerManual(caller, manualCallTemplate) {
-        if (manualCallTemplate.call_template_type !== 'sse') {
-            throw new Error('SseCommunicationProtocol can only be used with SseCallTemplate');
-        }
-        const provider = manualCallTemplate;
-        const url = provider.url;
-        // Security check: Enforce HTTPS or localhost to prevent MITM attacks
-        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 '${provider.name}' (SSE) at ${url}`);
-        try {
-            const requestHeaders = provider.headers ? { ...provider.headers } : {};
-            const queryParams = {};
-            const { auth, cookies } = this._applyAuth(provider, requestHeaders, queryParams);
-            // Build URL with query parameters
-            const urlObj = new URL(url);
-            Object.entries(queryParams).forEach(([key, value]) => {
-                urlObj.searchParams.append(key, String(value));
-            });
-            // SSE requires Accept: text/event-stream
-            requestHeaders['Accept'] = 'text/event-stream';
-            // Build fetch options
-            const fetchOptions = {
-                method: 'GET',
-                headers: requestHeaders,
-            };
-            // Add basic auth if present
-            if (auth) {
-                const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString('base64');
-                fetchOptions.headers = {
-                    ...fetchOptions.headers,
-                    'Authorization': `Basic ${credentials}`,
-                };
-            }
-            // Make discovery request
-            const response = await fetch(urlObj.toString(), fetchOptions);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            // For SSE discovery, we expect the first event to contain the manual
-            // This is a simplified implementation
-            const responseText = await response.text();
-            const utcpManual = new UtcpManualSerializer().validateDict(JSON.parse(responseText));
-            this._logInfo(`Discovered ${utcpManual.tools.length} tools from '${provider.name}'`);
-            return {
-                manualCallTemplate: provider,
-                manual: utcpManual,
-                success: true,
-                errors: [],
-            };
-        }
-        catch (error) {
-            this._logError(`Error discovering tools from '${provider.name}': ${error.message}`);
-            return {
-                manualCallTemplate: provider,
-                manual: new UtcpManualSerializer().validateDict({ tools: [] }),
-                success: false,
-                errors: [error.message || String(error)],
-            };
-        }
-    }
-    /**
-     * REQUIRED
-     * Deregister a manual (no-op for SSE).
-     */
-    async deregisterManual(caller, manualCallTemplate) {
-        // No-op for SSE
-    }
-    /**
-     * REQUIRED
-     * Call a tool using SSE (non-streaming).
-     */
-    async callTool(caller, toolName, toolArgs, toolCallTemplate) {
-        // For SSE, we collect all events and return them
-        const events = [];
-        for await (const event of this.callToolStreaming(caller, toolName, toolArgs, toolCallTemplate)) {
-            events.push(event);
-        }
-        return events;
-    }
-    /**
-     * REQUIRED
-     * Call a tool using SSE streaming.
-     * Returns an async generator that yields SSE events.
-     */
-    async *callToolStreaming(caller, toolName, toolArgs, toolCallTemplate) {
-        const provider = toolCallTemplate;
-        // TODO: Implement actual SSE call logic
-        // This would involve connecting to the SSE endpoint and streaming events
-        this._logInfo(`Calling SSE tool '${toolName}' with args: ${JSON.stringify(toolArgs)}`);
-        // Placeholder implementation
-        yield `SSE event for tool: ${toolName}`;
-    }
-    /**
-     * REQUIRED
-     * Close all active connections and clear internal state.
-     */
-    async close() {
-        this._logInfo('Closing SseCommunicationProtocol.');
-        this.oauthTokens.clear();
-    }
-}

package/dist/streamable_http_call_template.d.ts

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-import { CallTemplate } from '@utcp/sdk';
-import { Serializer } from '@utcp/sdk';
-/**
- * REQUIRED
- * Provider configuration for HTTP streaming tools.
- *
- * Uses HTTP Chunked Transfer Encoding to enable streaming of large responses
- * or real-time data. Useful for tools that return large datasets or provide
- * progressive results. 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 "streamable_http" for HTTP streaming providers.
- *     url: The streaming HTTP endpoint URL. Supports path parameters.
- *     http_method: The HTTP method to use (GET or POST).
- *     content_type: The Content-Type header for requests.
- *     chunk_size: Size of each chunk in bytes for reading the stream.
- *     timeout: Request timeout in milliseconds.
- *     headers: Optional static headers to include in requests.
- *     auth: Optional authentication configuration.
- *     body_field: Optional tool argument name to map to HTTP request body.
- *     header_fields: List of tool argument names to map to HTTP request headers.
- */
-export interface StreamableHttpCallTemplate extends CallTemplate {
-    call_template_type: 'streamable_http';
-    url: string;
-    http_method: 'GET' | 'POST';
-    content_type: string;
-    chunk_size: number;
-    timeout: number;
-    headers?: Record<string, string>;
-    body_field?: string | null;
-    header_fields?: string[] | null;
-}
-/**
- * Streamable HTTP Call Template schema.
- */
-export declare const StreamableHttpCallTemplateSchema: z.ZodType<StreamableHttpCallTemplate>;
-/**
- * REQUIRED
- * Serializer for StreamableHttpCallTemplate.
- */
-export declare class StreamableHttpCallTemplateSerializer extends Serializer<StreamableHttpCallTemplate> {
-    /**
-     * REQUIRED
-     * Convert StreamableHttpCallTemplate to dictionary.
-     */
-    toDict(obj: StreamableHttpCallTemplate): Record<string, unknown>;
-    /**
-     * REQUIRED
-     * Validate dictionary and convert to StreamableHttpCallTemplate.
-     */
-    validateDict(obj: Record<string, unknown>): StreamableHttpCallTemplate;
-}

package/dist/streamable_http_call_template.js

@@ -1,57 +0,0 @@
-// packages/http/src/streamable_http_call_template.ts
-import { z } from 'zod';
-import { AuthSchema } from '@utcp/sdk';
-import { Serializer } from '@utcp/sdk';
-/**
- * Streamable HTTP Call Template schema.
- */
-export const StreamableHttpCallTemplateSchema = z.object({
-    name: z.string().optional(),
-    call_template_type: z.literal('streamable_http'),
-    url: z.string().describe('The streaming HTTP endpoint URL. Supports path parameters.'),
-    http_method: z.enum(['GET', 'POST']).default('GET'),
-    content_type: z.string().default('application/octet-stream').describe('The Content-Type header for requests.'),
-    chunk_size: z.number().default(4096).describe('Size of each chunk in bytes for reading the stream.'),
-    timeout: z.number().default(60000).describe('Request timeout in milliseconds.'),
-    auth: AuthSchema.optional().describe('Optional authentication configuration.'),
-    headers: z.record(z.string(), z.string()).optional().describe('Optional static headers to include in requests.'),
-    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.'),
-});
-/**
- * REQUIRED
- * Serializer for StreamableHttpCallTemplate.
- */
-export class StreamableHttpCallTemplateSerializer extends Serializer {
-    /**
-     * REQUIRED
-     * Convert StreamableHttpCallTemplate to dictionary.
-     */
-    toDict(obj) {
-        return {
-            name: obj.name,
-            call_template_type: obj.call_template_type,
-            url: obj.url,
-            http_method: obj.http_method,
-            content_type: obj.content_type,
-            chunk_size: obj.chunk_size,
-            timeout: obj.timeout,
-            auth: obj.auth,
-            headers: obj.headers,
-            body_field: obj.body_field,
-            header_fields: obj.header_fields,
-        };
-    }
-    /**
-     * REQUIRED
-     * Validate dictionary and convert to StreamableHttpCallTemplate.
-     */
-    validateDict(obj) {
-        try {
-            return StreamableHttpCallTemplateSchema.parse(obj);
-        }
-        catch (e) {
-            throw new Error(`Invalid StreamableHttpCallTemplate: ${e.message}\n${e.stack || ''}`);
-        }
-    }
-}

package/dist/streamable_http_communication_protocol.d.ts

@@ -1,47 +0,0 @@
-/**
- * Streamable HTTP Communication Protocol for UTCP.
- *
- * Handles HTTP streaming with chunked transfer encoding for real-time data.
- */
-import { CommunicationProtocol } from '@utcp/sdk';
-import { RegisterManualResult } from '@utcp/sdk';
-import { CallTemplate } from '@utcp/sdk';
-import { IUtcpClient } from '@utcp/sdk';
-/**
- * REQUIRED
- * Streamable HTTP communication protocol implementation for UTCP client.
- *
- * Handles HTTP streaming with chunked transfer encoding for real-time data.
- */
-export declare class StreamableHttpCommunicationProtocol implements CommunicationProtocol {
-    private oauthTokens;
-    private _logInfo;
-    private _logError;
-    private _applyAuth;
-    /**
-     * REQUIRED
-     * Register a manual and its tools from a StreamableHttp provider.
-     */
-    registerManual(caller: IUtcpClient, manualCallTemplate: CallTemplate): Promise<RegisterManualResult>;
-    /**
-     * REQUIRED
-     * Deregister a manual (no-op for HTTP streaming).
-     */
-    deregisterManual(caller: IUtcpClient, manualCallTemplate: CallTemplate): Promise<void>;
-    /**
-     * REQUIRED
-     * Call a tool using HTTP (non-streaming).
-     */
-    callTool(caller: IUtcpClient, toolName: string, toolArgs: Record<string, any>, toolCallTemplate: CallTemplate): Promise<any>;
-    /**
-     * REQUIRED
-     * Call a tool using HTTP streaming.
-     * Returns an async generator that yields chunks of data.
-     */
-    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>;
-}

package/dist/streamable_http_communication_protocol.js

@@ -1,154 +0,0 @@
-import { UtcpManualSerializer } from '@utcp/sdk';
-/**
- * REQUIRED
- * Streamable HTTP communication protocol implementation for UTCP client.
- *
- * Handles HTTP streaming with chunked transfer encoding for real-time data.
- */
-export class StreamableHttpCommunicationProtocol {
-    oauthTokens = new Map();
-    _logInfo(message) {
-        console.log(`[StreamableHttpCommunicationProtocol] ${message}`);
-    }
-    _logError(message) {
-        console.error(`[StreamableHttpCommunicationProtocol] ${message}`);
-    }
-    _applyAuth(provider, headers, queryParams) {
-        let auth;
-        const cookies = {};
-        if (provider.auth) {
-            if ('api_key' in provider.auth) {
-                const apiKeyAuth = provider.auth;
-                if (apiKeyAuth.api_key) {
-                    if (apiKeyAuth.location === 'header') {
-                        headers[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                    }
-                    else if (apiKeyAuth.location === 'query') {
-                        queryParams[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                    }
-                    else if (apiKeyAuth.location === 'cookie') {
-                        cookies[apiKeyAuth.var_name] = apiKeyAuth.api_key;
-                    }
-                }
-                else {
-                    this._logError('API key not found for ApiKeyAuth.');
-                    throw new Error('API key for ApiKeyAuth not found.');
-                }
-            }
-            else if ('username' in provider.auth && 'password' in provider.auth) {
-                const basicAuth = provider.auth;
-                auth = { username: basicAuth.username, password: basicAuth.password };
-            }
-            else if ('token_url' in provider.auth) {
-                // OAuth2 will be handled separately
-            }
-        }
-        return { auth, cookies };
-    }
-    /**
-     * REQUIRED
-     * Register a manual and its tools from a StreamableHttp provider.
-     */
-    async registerManual(caller, manualCallTemplate) {
-        if (manualCallTemplate.call_template_type !== 'streamable_http') {
-            throw new Error('StreamableHttpCommunicationProtocol can only be used with StreamableHttpCallTemplate');
-        }
-        const provider = manualCallTemplate;
-        const url = provider.url;
-        // Security check: Enforce HTTPS or localhost to prevent MITM attacks
-        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 '${provider.name}' (HTTP Stream) at ${url}`);
-        try {
-            const requestHeaders = provider.headers ? { ...provider.headers } : {};
-            const queryParams = {};
-            const { auth, cookies } = this._applyAuth(provider, requestHeaders, queryParams);
-            // Build URL with query parameters
-            const urlObj = new URL(url);
-            Object.entries(queryParams).forEach(([key, value]) => {
-                urlObj.searchParams.append(key, String(value));
-            });
-            // Build fetch options
-            const fetchOptions = {
-                method: provider.http_method || 'GET',
-                headers: requestHeaders,
-            };
-            // Add basic auth if present
-            if (auth) {
-                const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString('base64');
-                fetchOptions.headers = {
-                    ...fetchOptions.headers,
-                    'Authorization': `Basic ${credentials}`,
-                };
-            }
-            // Make discovery request
-            const response = await fetch(urlObj.toString(), fetchOptions);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            // Read response body
-            const responseText = await response.text();
-            const utcpManual = new UtcpManualSerializer().validateDict(JSON.parse(responseText));
-            this._logInfo(`Discovered ${utcpManual.tools.length} tools from '${provider.name}'`);
-            return {
-                manualCallTemplate: provider,
-                manual: utcpManual,
-                success: true,
-                errors: [],
-            };
-        }
-        catch (error) {
-            this._logError(`Error discovering tools from '${provider.name}': ${error.message}`);
-            return {
-                manualCallTemplate: provider,
-                manual: new UtcpManualSerializer().validateDict({ tools: [] }),
-                success: false,
-                errors: [error.message || String(error)],
-            };
-        }
-    }
-    /**
-     * REQUIRED
-     * Deregister a manual (no-op for HTTP streaming).
-     */
-    async deregisterManual(caller, manualCallTemplate) {
-        // No-op for HTTP streaming
-    }
-    /**
-     * REQUIRED
-     * Call a tool using HTTP (non-streaming).
-     */
-    async callTool(caller, toolName, toolArgs, toolCallTemplate) {
-        // For streamable HTTP, we collect all chunks and return the complete result
-        const chunks = [];
-        for await (const chunk of this.callToolStreaming(caller, toolName, toolArgs, toolCallTemplate)) {
-            chunks.push(chunk);
-        }
-        return chunks.join('');
-    }
-    /**
-     * REQUIRED
-     * Call a tool using HTTP streaming.
-     * Returns an async generator that yields chunks of data.
-     */
-    async *callToolStreaming(caller, toolName, toolArgs, toolCallTemplate) {
-        const provider = toolCallTemplate;
-        // TODO: Implement actual streaming call logic
-        // This would involve making an HTTP request and streaming the response in chunks
-        this._logInfo(`Calling streaming tool '${toolName}' with args: ${JSON.stringify(toolArgs)}`);
-        // Placeholder implementation
-        yield `Streaming response for tool: ${toolName}`;
-    }
-    /**
-     * REQUIRED
-     * Close all active connections and clear internal state.
-     */
-    async close() {
-        this._logInfo('Closing StreamableHttpCommunicationProtocol.');
-        this.oauthTokens.clear();
-    }
-}