@utcp/http 1.0.0

package/dist/sse_call_template.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { CallTemplate } from '@utcp/core/data/call_template';
+import { Serializer } from '@utcp/core/interfaces/serializer';
+/**
+ * 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

@@ -0,0 +1,55 @@
+// packages/http/src/sse_call_template.ts
+import { z } from 'zod';
+import { AuthSchema } from '@utcp/core/data/auth';
+import { Serializer } from '@utcp/core/interfaces/serializer';
+/**
+ * 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

@@ -0,0 +1,47 @@
+/**
+ * Server-Sent Events (SSE) Communication Protocol for UTCP.
+ *
+ * Handles Server-Sent Events based tool providers with streaming capabilities.
+ */
+import { CommunicationProtocol } from '@utcp/core/interfaces/communication_protocol';
+import { RegisterManualResult } from '@utcp/core/data/register_manual_result';
+import { CallTemplate } from '@utcp/core/data/call_template';
+import { IUtcpClient } from '@utcp/core/interfaces/utcp_client_interface';
+/**
+ * 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>;
+}

package/dist/sse_communication_protocol.js

@@ -0,0 +1,157 @@
+import { UtcpManualSerializer } from '@utcp/core/data/utcp_manual';
+/**
+ * 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

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { CallTemplate } from '@utcp/core/data/call_template';
+import { Serializer } from '@utcp/core/interfaces/serializer';
+/**
+ * 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

@@ -0,0 +1,57 @@
+// packages/http/src/streamable_http_call_template.ts
+import { z } from 'zod';
+import { AuthSchema } from '@utcp/core/data/auth';
+import { Serializer } from '@utcp/core/interfaces/serializer';
+/**
+ * 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

@@ -0,0 +1,47 @@
+/**
+ * Streamable HTTP Communication Protocol for UTCP.
+ *
+ * Handles HTTP streaming with chunked transfer encoding for real-time data.
+ */
+import { CommunicationProtocol } from '@utcp/core/interfaces/communication_protocol';
+import { RegisterManualResult } from '@utcp/core/data/register_manual_result';
+import { CallTemplate } from '@utcp/core/data/call_template';
+import { IUtcpClient } from '@utcp/core/interfaces/utcp_client_interface';
+/**
+ * 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

@@ -0,0 +1,154 @@
+import { UtcpManualSerializer } from '@utcp/core/data/utcp_manual';
+/**
+ * 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();
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@utcp/http",
+  "version": "1.0.0",
+  "description": "HTTP utilities for UTCP",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "license": "MPL-2.0",
+  "author": "UTCP Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/universal-tool-calling-protocol/typescript-utcp.git",
+    "directory": "packages/http"
+  },
+  "keywords": [
+    "utcp",
+    "universal-tool-calling-protocol",
+    "tools",
+    "api",
+    "typescript",
+    "tool calling",
+    "http",
+    "agent",
+    "ai",
+    "llm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@utcp/sdk": "^1.0.0",
+    "axios": "^1.11.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "^5.0.0",
+    "@types/bun": "latest"
+  }
+}