cognitive-modules-cli 2.2.0 → 2.2.5

package/dist/providers/anthropic.js

@@ -1,5 +1,7 @@
 /**
  * Anthropic Provider - Claude API
+ *
+ * Supports both streaming and non-streaming invocation.
  */
 import { BaseProvider } from './base.js';
 export class AnthropicProvider extends BaseProvider {
@@ -15,11 +17,16 @@ export class AnthropicProvider extends BaseProvider {
     isConfigured() {
         return !!this.apiKey;
     }
-    async invoke(params) {
-        if (!this.isConfigured()) {
-            throw new Error('Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable.');
-        }
-        const url = `${this.baseUrl}/messages`;
+    /**
+     * Anthropic supports streaming.
+     */
+    supportsStreaming() {
+        return true;
+    }
+    /**
+     * Build request body for Anthropic API
+     */
+    buildRequestBody(params, stream) {
         // Extract system message
         const systemMessage = params.messages.find(m => m.role === 'system');
         const otherMessages = params.messages.filter(m => m.role !== 'system');
@@ -39,10 +46,19 @@ export class AnthropicProvider extends BaseProvider {
             model: this.model,
             messages: messages.map(m => ({ role: m.role, content: m.content })),
             max_tokens: params.maxTokens ?? 4096,
+            stream,
         };
         if (systemMessage) {
             body.system = systemMessage.content;
         }
+        return { body, systemContent: systemMessage?.content };
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/messages`;
+        const { body } = this.buildRequestBody(params, false);
         const response = await fetch(url, {
             method: 'POST',
             headers: {
@@ -67,4 +83,130 @@ export class AnthropicProvider extends BaseProvider {
             } : undefined,
         };
     }
+    /**
+     * Stream-based invoke using Anthropic's streaming API.
+     * Yields content chunks as they arrive from the API.
+     */
+    async *invokeStream(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/messages`;
+        const { body } = this.buildRequestBody(params, true);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+        if (!response.body) {
+            throw new Error('Anthropic API returned no body for streaming request');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        const collectedChunks = [];
+        let usage;
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete lines from the buffer
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith(':'))
+                        continue; // Skip empty lines and comments
+                    if (trimmed.startsWith('data: ')) {
+                        try {
+                            const data = JSON.parse(trimmed.slice(6));
+                            // Extract content chunk (content_block_delta event)
+                            if (data.type === 'content_block_delta' && data.delta?.type === 'text_delta') {
+                                const text = data.delta.text || '';
+                                if (text) {
+                                    collectedChunks.push(text);
+                                    yield text;
+                                }
+                            }
+                            // Extract usage info (message_delta or message_stop event)
+                            if (data.type === 'message_delta' && data.usage) {
+                                usage = {
+                                    promptTokens: data.usage.input_tokens || 0,
+                                    completionTokens: data.usage.output_tokens || 0,
+                                    totalTokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
+                                };
+                            }
+                            // Also check message_start for input tokens
+                            if (data.type === 'message_start' && data.message?.usage) {
+                                const inputTokens = data.message.usage.input_tokens || 0;
+                                usage = {
+                                    promptTokens: inputTokens,
+                                    completionTokens: usage?.completionTokens || 0,
+                                    totalTokens: inputTokens + (usage?.completionTokens || 0),
+                                };
+                            }
+                        }
+                        catch {
+                            // Skip invalid JSON chunks
+                        }
+                    }
+                }
+            }
+            // Flush decoder and process trailing buffered data even without trailing newline.
+            buffer += decoder.decode();
+            for (const line of buffer.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
+                    continue;
+                if (trimmed.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(trimmed.slice(6));
+                        if (data.type === 'content_block_delta' && data.delta?.type === 'text_delta') {
+                            const text = data.delta.text || '';
+                            if (text) {
+                                collectedChunks.push(text);
+                                yield text;
+                            }
+                        }
+                        if (data.type === 'message_delta' && data.usage) {
+                            usage = {
+                                promptTokens: data.usage.input_tokens || 0,
+                                completionTokens: data.usage.output_tokens || 0,
+                                totalTokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
+                            };
+                        }
+                        if (data.type === 'message_start' && data.message?.usage) {
+                            const inputTokens = data.message.usage.input_tokens || 0;
+                            usage = {
+                                promptTokens: inputTokens,
+                                completionTokens: usage?.completionTokens || 0,
+                                totalTokens: inputTokens + (usage?.completionTokens || 0),
+                            };
+                        }
+                    }
+                    catch {
+                        // Skip invalid JSON chunks
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const fullContent = collectedChunks.join('');
+        return {
+            content: fullContent,
+            usage,
+        };
+    }
 }

package/dist/providers/base.d.ts

@@ -6,6 +6,17 @@ export declare abstract class BaseProvider implements Provider {
     abstract name: string;
     abstract invoke(params: InvokeParams): Promise<InvokeResult>;
     abstract isConfigured(): boolean;
+    /**
+     * Check if this provider supports streaming.
+     * Override in subclasses that implement streaming.
+     */
+    supportsStreaming(): boolean;
+    /**
+     * Stream-based invoke (optional).
+     * Default implementation falls back to non-streaming invoke.
+     * Override in subclasses that support streaming.
+     */
+    invokeStream(params: InvokeParams): AsyncGenerator<string, InvokeResult, unknown>;
     protected buildJsonPrompt(schema: object): string;
     protected parseJsonResponse(content: string): unknown;
 }

package/dist/providers/base.js

@@ -2,6 +2,24 @@
  * Base Provider - Abstract class for all LLM providers
  */
 export class BaseProvider {
+    /**
+     * Check if this provider supports streaming.
+     * Override in subclasses that implement streaming.
+     */
+    supportsStreaming() {
+        return false;
+    }
+    /**
+     * Stream-based invoke (optional).
+     * Default implementation falls back to non-streaming invoke.
+     * Override in subclasses that support streaming.
+     */
+    async *invokeStream(params) {
+        // Default fallback: use non-streaming invoke and yield the entire result at once
+        const result = await this.invoke(params);
+        yield result.content;
+        return result;
+    }
     buildJsonPrompt(schema) {
         return `\n\nYou MUST respond with valid JSON matching this schema:\n${JSON.stringify(schema, null, 2)}\n\nRespond with ONLY the JSON, no markdown code blocks.`;
     }

package/dist/providers/gemini.d.ts

@@ -1,5 +1,7 @@
 /**
  * Gemini Provider - Google Gemini API
+ *
+ * Supports both streaming and non-streaming invocation.
  */
 import { BaseProvider } from './base.js';
 import type { InvokeParams, InvokeResult } from '../types.js';
@@ -10,10 +12,23 @@ export declare class GeminiProvider extends BaseProvider {
     private baseUrl;
     constructor(apiKey?: string, model?: string);
     isConfigured(): boolean;
+    /**
+     * Gemini supports streaming.
+     */
+    supportsStreaming(): boolean;
     /**
      * Clean JSON Schema for Gemini API compatibility
      * Removes unsupported fields like additionalProperties
      */
     private cleanSchemaForGemini;
+    /**
+     * Build request body for Gemini API
+     */
+    private buildRequestBody;
     invoke(params: InvokeParams): Promise<InvokeResult>;
+    /**
+     * Stream-based invoke using Gemini's streaming API.
+     * Yields content chunks as they arrive from the API.
+     */
+    invokeStream(params: InvokeParams): AsyncGenerator<string, InvokeResult, unknown>;
 }

package/dist/providers/gemini.js

@@ -1,5 +1,7 @@
 /**
  * Gemini Provider - Google Gemini API
+ *
+ * Supports both streaming and non-streaming invocation.
  */
 import { BaseProvider } from './base.js';
 export class GeminiProvider extends BaseProvider {
@@ -15,6 +17,12 @@ export class GeminiProvider extends BaseProvider {
     isConfigured() {
         return !!this.apiKey;
     }
+    /**
+     * Gemini supports streaming.
+     */
+    supportsStreaming() {
+        return true;
+    }
     /**
      * Clean JSON Schema for Gemini API compatibility
      * Removes unsupported fields like additionalProperties
@@ -38,11 +46,10 @@ export class GeminiProvider extends BaseProvider {
         };
         return clean(schema);
     }
-    async invoke(params) {
-        if (!this.isConfigured()) {
-            throw new Error('Gemini API key not configured. Set GEMINI_API_KEY environment variable.');
-        }
-        const url = `${this.baseUrl}/models/${this.model}:generateContent?key=${this.apiKey}`;
+    /**
+     * Build request body for Gemini API
+     */
+    buildRequestBody(params) {
         // Convert messages to Gemini format
         const contents = params.messages
             .filter(m => m.role !== 'system')
@@ -71,6 +78,14 @@ export class GeminiProvider extends BaseProvider {
                 responseSchema: cleanedSchema,
             };
         }
+        return body;
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Gemini API key not configured. Set GEMINI_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/models/${this.model}:generateContent?key=${this.apiKey}`;
+        const body = this.buildRequestBody(params);
         const response = await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
@@ -91,4 +106,106 @@ export class GeminiProvider extends BaseProvider {
             } : undefined,
         };
     }
+    /**
+     * Stream-based invoke using Gemini's streaming API.
+     * Yields content chunks as they arrive from the API.
+     */
+    async *invokeStream(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Gemini API key not configured. Set GEMINI_API_KEY environment variable.');
+        }
+        // Use streamGenerateContent endpoint
+        const url = `${this.baseUrl}/models/${this.model}:streamGenerateContent?key=${this.apiKey}&alt=sse`;
+        const body = this.buildRequestBody(params);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini API error: ${response.status} - ${error}`);
+        }
+        if (!response.body) {
+            throw new Error('Gemini API returned no body for streaming request');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        const collectedChunks = [];
+        let usage;
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete lines from the buffer
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    if (trimmed.startsWith('data: ')) {
+                        try {
+                            const data = JSON.parse(trimmed.slice(6));
+                            // Extract content chunk
+                            const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+                            if (text) {
+                                collectedChunks.push(text);
+                                yield text;
+                            }
+                            // Extract usage info (usually in the last chunk)
+                            if (data.usageMetadata) {
+                                usage = {
+                                    promptTokens: data.usageMetadata.promptTokenCount || 0,
+                                    completionTokens: data.usageMetadata.candidatesTokenCount || 0,
+                                    totalTokens: data.usageMetadata.totalTokenCount || 0,
+                                };
+                            }
+                        }
+                        catch {
+                            // Skip invalid JSON chunks
+                        }
+                    }
+                }
+            }
+            // Flush decoder and process trailing buffered data even without trailing newline.
+            buffer += decoder.decode();
+            for (const line of buffer.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                if (trimmed.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(trimmed.slice(6));
+                        const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+                        if (text) {
+                            collectedChunks.push(text);
+                            yield text;
+                        }
+                        if (data.usageMetadata) {
+                            usage = {
+                                promptTokens: data.usageMetadata.promptTokenCount || 0,
+                                completionTokens: data.usageMetadata.candidatesTokenCount || 0,
+                                totalTokens: data.usageMetadata.totalTokenCount || 0,
+                            };
+                        }
+                    }
+                    catch {
+                        // Skip invalid JSON chunks
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const fullContent = collectedChunks.join('');
+        return {
+            content: fullContent,
+            usage,
+        };
+    }
 }

package/dist/providers/ollama.d.ts

@@ -1,5 +1,7 @@
 /**
  * Ollama Provider - Local LLM via Ollama
+ *
+ * Supports both streaming and non-streaming invocation.
  */
 import { BaseProvider } from './base.js';
 import type { InvokeParams, InvokeResult } from '../types.js';
@@ -9,5 +11,18 @@ export declare class OllamaProvider extends BaseProvider {
     private baseUrl;
     constructor(model?: string, baseUrl?: string);
     isConfigured(): boolean;
+    /**
+     * Ollama supports streaming.
+     */
+    supportsStreaming(): boolean;
+    /**
+     * Build request body for Ollama API
+     */
+    private buildRequestBody;
     invoke(params: InvokeParams): Promise<InvokeResult>;
+    /**
+     * Stream-based invoke using Ollama's streaming API.
+     * Yields content chunks as they arrive from the API.
+     */
+    invokeStream(params: InvokeParams): AsyncGenerator<string, InvokeResult, unknown>;
 }

package/dist/providers/ollama.js

@@ -1,5 +1,7 @@
 /**
  * Ollama Provider - Local LLM via Ollama
+ *
+ * Supports both streaming and non-streaming invocation.
  */
 import { BaseProvider } from './base.js';
 export class OllamaProvider extends BaseProvider {
@@ -14,8 +16,16 @@ export class OllamaProvider extends BaseProvider {
     isConfigured() {
         return true; // Ollama doesn't need API key
     }
-    async invoke(params) {
-        const url = `${this.baseUrl}/api/chat`;
+    /**
+     * Ollama supports streaming.
+     */
+    supportsStreaming() {
+        return true;
+    }
+    /**
+     * Build request body for Ollama API
+     */
+    buildRequestBody(params, stream) {
         let messages = params.messages.map(m => ({ role: m.role, content: m.content }));
         // Add JSON mode if schema provided
         if (params.jsonSchema) {
@@ -31,7 +41,7 @@ export class OllamaProvider extends BaseProvider {
         const body = {
             model: this.model,
             messages,
-            stream: false,
+            stream,
             options: {
                 temperature: params.temperature ?? 0.7,
                 num_predict: params.maxTokens ?? 4096,
@@ -41,6 +51,11 @@ export class OllamaProvider extends BaseProvider {
         if (params.jsonSchema) {
             body.format = 'json';
         }
+        return body;
+    }
+    async invoke(params) {
+        const url = `${this.baseUrl}/api/chat`;
+        const body = this.buildRequestBody(params, false);
         const response = await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
@@ -61,4 +76,97 @@ export class OllamaProvider extends BaseProvider {
             },
         };
     }
+    /**
+     * Stream-based invoke using Ollama's streaming API.
+     * Yields content chunks as they arrive from the API.
+     */
+    async *invokeStream(params) {
+        const url = `${this.baseUrl}/api/chat`;
+        const body = this.buildRequestBody(params, true);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${error}`);
+        }
+        if (!response.body) {
+            throw new Error('Ollama API returned no body for streaming request');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        const collectedChunks = [];
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete lines from the buffer (NDJSON format)
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const data = JSON.parse(trimmed);
+                        // Extract content chunk
+                        const content = data.message?.content;
+                        if (content) {
+                            collectedChunks.push(content);
+                            yield content;
+                        }
+                        // Extract usage info (in the final message when done=true)
+                        if (data.done) {
+                            promptTokens = data.prompt_eval_count || 0;
+                            completionTokens = data.eval_count || 0;
+                        }
+                    }
+                    catch {
+                        // Skip invalid JSON lines
+                    }
+                }
+            }
+            // Flush decoder and process trailing buffered data even without trailing newline.
+            buffer += decoder.decode();
+            for (const line of buffer.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const data = JSON.parse(trimmed);
+                    const content = data.message?.content;
+                    if (content) {
+                        collectedChunks.push(content);
+                        yield content;
+                    }
+                    if (data.done) {
+                        promptTokens = data.prompt_eval_count || 0;
+                        completionTokens = data.eval_count || 0;
+                    }
+                }
+                catch {
+                    // Skip invalid JSON lines
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const fullContent = collectedChunks.join('');
+        return {
+            content: fullContent,
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+            },
+        };
+    }
 }

package/dist/providers/openai.d.ts

@@ -1,5 +1,7 @@
 /**
  * OpenAI Provider - OpenAI API (and compatible APIs)
+ *
+ * Supports both streaming and non-streaming invocation.
  */
 import { BaseProvider } from './base.js';
 import type { InvokeParams, InvokeResult } from '../types.js';
@@ -10,5 +12,14 @@ export declare class OpenAIProvider extends BaseProvider {
     private baseUrl;
     constructor(apiKey?: string, model?: string, baseUrl?: string);
     isConfigured(): boolean;
+    /**
+     * OpenAI supports streaming.
+     */
+    supportsStreaming(): boolean;
     invoke(params: InvokeParams): Promise<InvokeResult>;
+    /**
+     * Stream-based invoke using OpenAI's streaming API.
+     * Yields content chunks as they arrive from the API.
+     */
+    invokeStream(params: InvokeParams): AsyncGenerator<string, InvokeResult, unknown>;
 }