cognitive-modules-cli 1.4.0 → 2.2.0

package/dist/providers/base.d.ts

@@ -1,8 +1,7 @@
 /**
  * Base Provider - Abstract class for all LLM providers
- * v2.5: Added streaming and multimodal support
  */
-import type { Provider, InvokeParams, InvokeResult, ProviderV25, InvokeParamsV25, StreamingInvokeResult, ModalityType } from '../types.js';
+import type { Provider, InvokeParams, InvokeResult } from '../types.js';
 export declare abstract class BaseProvider implements Provider {
     abstract name: string;
     abstract invoke(params: InvokeParams): Promise<InvokeResult>;
@@ -10,46 +9,3 @@ export declare abstract class BaseProvider implements Provider {
     protected buildJsonPrompt(schema: object): string;
     protected parseJsonResponse(content: string): unknown;
 }
-/**
- * Base Provider with v2.5 streaming and multimodal support
- */
-export declare abstract class BaseProviderV25 extends BaseProvider implements ProviderV25 {
-    /**
-     * Check if this provider supports streaming
-     * Override in subclass to enable streaming
-     */
-    supportsStreaming(): boolean;
-    /**
-     * Check if this provider supports multimodal input/output
-     * Override in subclass to enable multimodal
-     */
-    supportsMultimodal(): {
-        input: ModalityType[];
-        output: ModalityType[];
-    };
-    /**
-     * Invoke with streaming response
-     * Override in subclass to implement streaming
-     */
-    invokeStream(params: InvokeParamsV25): Promise<StreamingInvokeResult>;
-    /**
-     * Format media inputs for the specific provider API
-     * Override in subclass for provider-specific formatting
-     */
-    protected formatMediaForProvider(images?: Array<{
-        type: string;
-        url?: string;
-        data?: string;
-        media_type?: string;
-    }>, _audio?: Array<{
-        type: string;
-        url?: string;
-        data?: string;
-        media_type?: string;
-    }>, _video?: Array<{
-        type: string;
-        url?: string;
-        data?: string;
-        media_type?: string;
-    }>): unknown[];
-}

package/dist/providers/base.js

@@ -1,6 +1,5 @@
 /**
  * Base Provider - Abstract class for all LLM providers
- * v2.5: Added streaming and multimodal support
  */
 export class BaseProvider {
     buildJsonPrompt(schema) {
@@ -18,69 +17,3 @@ export class BaseProvider {
         }
     }
 }
-/**
- * Base Provider with v2.5 streaming and multimodal support
- */
-export class BaseProviderV25 extends BaseProvider {
-    /**
-     * Check if this provider supports streaming
-     * Override in subclass to enable streaming
-     */
-    supportsStreaming() {
-        return false;
-    }
-    /**
-     * Check if this provider supports multimodal input/output
-     * Override in subclass to enable multimodal
-     */
-    supportsMultimodal() {
-        return {
-            input: ['text'],
-            output: ['text']
-        };
-    }
-    /**
-     * Invoke with streaming response
-     * Override in subclass to implement streaming
-     */
-    async invokeStream(params) {
-        // Default: fallback to non-streaming with async generator wrapper
-        const result = await this.invoke(params);
-        async function* generateChunks() {
-            yield result.content;
-        }
-        return {
-            stream: generateChunks(),
-            usage: result.usage
-        };
-    }
-    /**
-     * Format media inputs for the specific provider API
-     * Override in subclass for provider-specific formatting
-     */
-    formatMediaForProvider(images, _audio, _video) {
-        // Default implementation for image-only providers (like OpenAI Vision)
-        if (!images || images.length === 0) {
-            return [];
-        }
-        return images.map(img => {
-            if (img.type === 'url' && img.url) {
-                return {
-                    type: 'image_url',
-                    image_url: {
-                        url: img.url
-                    }
-                };
-            }
-            else if (img.type === 'base64' && img.data && img.media_type) {
-                return {
-                    type: 'image_url',
-                    image_url: {
-                        url: `data:${img.media_type};base64,${img.data}`
-                    }
-                };
-            }
-            return null;
-        }).filter(Boolean);
-    }
-}

package/dist/providers/openai.d.ts

@@ -1,38 +1,14 @@
 /**
  * OpenAI Provider - OpenAI API (and compatible APIs)
- * v2.5: Added streaming and multimodal (vision) support
  */
-import { BaseProviderV25 } from './base.js';
-import type { InvokeParams, InvokeResult, InvokeParamsV25, StreamingInvokeResult, ModalityType } from '../types.js';
-export declare class OpenAIProvider extends BaseProviderV25 {
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class OpenAIProvider extends BaseProvider {
     name: string;
     private apiKey;
     private model;
     private baseUrl;
     constructor(apiKey?: string, model?: string, baseUrl?: string);
     isConfigured(): boolean;
-    /**
-     * Check if streaming is supported (always true for OpenAI)
-     */
-    supportsStreaming(): boolean;
-    /**
-     * Check multimodal support (vision models)
-     */
-    supportsMultimodal(): {
-        input: ModalityType[];
-        output: ModalityType[];
-    };
     invoke(params: InvokeParams): Promise<InvokeResult>;
-    /**
-     * Invoke with streaming response
-     */
-    invokeStream(params: InvokeParamsV25): Promise<StreamingInvokeResult>;
-    /**
-     * Build messages with multimodal content (images)
-     */
-    private buildMessagesWithMedia;
-    /**
-     * Convert MediaInput to URL for OpenAI API
-     */
-    private mediaInputToUrl;
 }

package/dist/providers/openai.js

@@ -1,14 +1,13 @@
 /**
  * OpenAI Provider - OpenAI API (and compatible APIs)
- * v2.5: Added streaming and multimodal (vision) support
  */
-import { BaseProviderV25 } from './base.js';
-export class OpenAIProvider extends BaseProviderV25 {
+import { BaseProvider } from './base.js';
+export class OpenAIProvider extends BaseProvider {
     name = 'openai';
     apiKey;
     model;
     baseUrl;
-    constructor(apiKey, model = 'gpt-4o', baseUrl = 'https://api.openai.com/v1') {
+    constructor(apiKey, model = 'gpt-5.2', baseUrl = 'https://api.openai.com/v1') {
         super();
         this.apiKey = apiKey || process.env.OPENAI_API_KEY || '';
         this.model = model;
@@ -17,24 +16,6 @@ export class OpenAIProvider extends BaseProviderV25 {
     isConfigured() {
         return !!this.apiKey;
     }
-    /**
-     * Check if streaming is supported (always true for OpenAI)
-     */
-    supportsStreaming() {
-        return true;
-    }
-    /**
-     * Check multimodal support (vision models)
-     */
-    supportsMultimodal() {
-        // Vision models support image input
-        const visionModels = ['gpt-4o', 'gpt-4-vision', 'gpt-4-turbo', 'gpt-4o-mini'];
-        const supportsVision = visionModels.some(m => this.model.includes(m));
-        return {
-            input: supportsVision ? ['text', 'image'] : ['text'],
-            output: ['text'] // DALL-E would be separate
-        };
-    }
     async invoke(params) {
         if (!this.isConfigured()) {
             throw new Error('OpenAI API key not configured. Set OPENAI_API_KEY environment variable.');
@@ -83,157 +64,4 @@ export class OpenAIProvider extends BaseProviderV25 {
             } : undefined,
         };
     }
-    /**
-     * Invoke with streaming response
-     */
-    async invokeStream(params) {
-        if (!this.isConfigured()) {
-            throw new Error('OpenAI API key not configured. Set OPENAI_API_KEY environment variable.');
-        }
-        const url = `${this.baseUrl}/chat/completions`;
-        // Build messages with multimodal content if present
-        const messages = this.buildMessagesWithMedia(params);
-        const body = {
-            model: this.model,
-            messages,
-            temperature: params.temperature ?? 0.7,
-            max_tokens: params.maxTokens ?? 4096,
-            stream: true,
-        };
-        // Add JSON mode if schema provided
-        if (params.jsonSchema) {
-            body.response_format = { type: 'json_object' };
-        }
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`OpenAI API error: ${response.status} - ${error}`);
-        }
-        const bodyReader = response.body?.getReader();
-        if (!bodyReader) {
-            throw new Error('No response body');
-        }
-        const decoder = new TextDecoder();
-        let usage;
-        // Capture reader reference for closure
-        const reader = bodyReader;
-        // Create async generator for streaming
-        async function* streamGenerator() {
-            let buffer = '';
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                // Parse SSE events
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (line.startsWith('data: ')) {
-                        const data = line.slice(6);
-                        if (data === '[DONE]') {
-                            return;
-                        }
-                        try {
-                            const parsed = JSON.parse(data);
-                            const content = parsed.choices?.[0]?.delta?.content;
-                            if (content) {
-                                yield content;
-                            }
-                            // Capture usage if available
-                            if (parsed.usage) {
-                                usage = {
-                                    promptTokens: parsed.usage.prompt_tokens || 0,
-                                    completionTokens: parsed.usage.completion_tokens || 0,
-                                    totalTokens: parsed.usage.total_tokens || 0,
-                                };
-                            }
-                        }
-                        catch {
-                            // Skip malformed JSON
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            stream: streamGenerator(),
-            usage
-        };
-    }
-    /**
-     * Build messages with multimodal content (images)
-     */
-    buildMessagesWithMedia(params) {
-        const hasImages = params.images && params.images.length > 0;
-        if (!hasImages) {
-            return params.messages;
-        }
-        // Find the last user message and add images to it
-        const messages = [];
-        const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
-        for (let i = 0; i < params.messages.length; i++) {
-            const msg = params.messages[i];
-            if (i === lastUserIdx && hasImages) {
-                // Convert to multimodal content
-                const content = [
-                    { type: 'text', text: msg.content }
-                ];
-                // Add images
-                for (const img of params.images) {
-                    const imageUrl = this.mediaInputToUrl(img);
-                    if (imageUrl) {
-                        content.push({
-                            type: 'image_url',
-                            image_url: { url: imageUrl, detail: 'auto' }
-                        });
-                    }
-                }
-                messages.push({ role: msg.role, content });
-            }
-            else {
-                messages.push({ role: msg.role, content: msg.content });
-            }
-        }
-        // Add JSON schema instruction if needed
-        if (params.jsonSchema && lastUserIdx >= 0) {
-            const lastMsg = messages[lastUserIdx];
-            if (typeof lastMsg.content === 'string') {
-                lastMsg.content = lastMsg.content + this.buildJsonPrompt(params.jsonSchema);
-            }
-            else {
-                // Content is array, append to text part
-                const textPart = lastMsg.content.find(p => p.type === 'text');
-                if (textPart && textPart.type === 'text') {
-                    textPart.text = textPart.text + this.buildJsonPrompt(params.jsonSchema);
-                }
-            }
-        }
-        return messages;
-    }
-    /**
-     * Convert MediaInput to URL for OpenAI API
-     */
-    mediaInputToUrl(media) {
-        switch (media.type) {
-            case 'url':
-                return media.url;
-            case 'base64':
-                return `data:${media.media_type};base64,${media.data}`;
-            case 'file':
-                // File paths would need to be loaded first
-                // This should be handled by the runner before calling the provider
-                console.warn('[cognitive] File media input not pre-loaded, skipping');
-                return null;
-            default:
-                return null;
-        }
-    }
 }

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 /**
  * Cognitive Runtime - Core Types
- * Version 2.5 - With streaming response and multimodal support
+ * Version 2.2 - With Control/Data plane separation, tier, overflow, extensible enums
  */
 export interface Provider {
     name: string;
@@ -282,210 +282,3 @@ export declare function extractMeta<T>(response: EnvelopeResponse<T>, riskRule?:
 export declare function aggregateRisk(data: Record<string, unknown>, riskRule?: RiskRule): RiskLevel;
 /** Check if result should be escalated to human review */
 export declare function shouldEscalate<T>(response: EnvelopeResponse<T>, confidenceThreshold?: number): boolean;
-/** Response mode configuration */
-export type ResponseMode = 'sync' | 'streaming' | 'both';
-/** Chunk type for streaming */
-export type ChunkType = 'delta' | 'snapshot';
-/** Response configuration in module.yaml */
-export interface ResponseConfig {
-    mode: ResponseMode;
-    chunk_type?: ChunkType;
-    buffer_size?: number;
-    heartbeat_interval_ms?: number;
-    max_duration_ms?: number;
-}
-/** Meta chunk - initial streaming response */
-export interface MetaChunk {
-    ok: true;
-    streaming: true;
-    session_id: string;
-    meta: Partial<EnvelopeMeta>;
-}
-/** Delta chunk - incremental content */
-export interface DeltaChunk {
-    chunk: {
-        seq: number;
-        type: 'delta';
-        field?: string;
-        delta: string;
-    };
-}
-/** Snapshot chunk - full state replacement */
-export interface SnapshotChunk {
-    chunk: {
-        seq: number;
-        type: 'snapshot';
-        field?: string;
-        data: unknown;
-    };
-}
-/** Progress chunk - progress update */
-export interface ProgressChunk {
-    progress: {
-        percent: number;
-        stage?: string;
-        message?: string;
-    };
-}
-/** Final chunk - completion signal */
-export interface FinalChunk {
-    final: true;
-    meta: EnvelopeMeta;
-    data: ModuleResultData;
-    usage?: {
-        input_tokens: number;
-        output_tokens: number;
-        total_tokens: number;
-    };
-}
-/** Error chunk during streaming */
-export interface ErrorChunk {
-    ok: false;
-    streaming: true;
-    session_id?: string;
-    error: {
-        code: string;
-        message: string;
-        recoverable?: boolean;
-    };
-    partial_data?: unknown;
-}
-/** Union of all streaming chunk types */
-export type StreamingChunk = MetaChunk | DeltaChunk | SnapshotChunk | ProgressChunk | FinalChunk | ErrorChunk;
-/** Streaming session state */
-export interface StreamingSession {
-    session_id: string;
-    module_name: string;
-    started_at: number;
-    chunks_sent: number;
-    accumulated_data: Record<string, unknown>;
-    accumulated_text: Record<string, string>;
-}
-/** Supported modality types */
-export type ModalityType = 'text' | 'image' | 'audio' | 'video' | 'document';
-/** Modalities configuration in module.yaml */
-export interface ModalitiesConfig {
-    input: ModalityType[];
-    output: ModalityType[];
-    constraints?: MediaConstraints;
-}
-/** Media size/duration constraints */
-export interface MediaConstraints {
-    max_image_size_mb?: number;
-    max_audio_size_mb?: number;
-    max_video_size_mb?: number;
-    max_audio_duration_s?: number;
-    max_video_duration_s?: number;
-    allowed_image_types?: string[];
-    allowed_audio_types?: string[];
-    allowed_video_types?: string[];
-}
-/** Media input - URL reference */
-export interface UrlMediaInput {
-    type: 'url';
-    url: string;
-    media_type?: string;
-}
-/** Media input - Base64 inline */
-export interface Base64MediaInput {
-    type: 'base64';
-    media_type: string;
-    data: string;
-}
-/** Media input - File path */
-export interface FileMediaInput {
-    type: 'file';
-    path: string;
-}
-/** Union of media input types */
-export type MediaInput = UrlMediaInput | Base64MediaInput | FileMediaInput;
-/** Media output with metadata */
-export interface MediaOutput {
-    type: 'url' | 'base64' | 'file';
-    media_type: string;
-    url?: string;
-    data?: string;
-    path?: string;
-    width?: number;
-    height?: number;
-    duration_ms?: number;
-    expires_at?: string;
-    generation_params?: Record<string, unknown>;
-}
-/** Supported image MIME types */
-export declare const SUPPORTED_IMAGE_TYPES: readonly ["image/jpeg", "image/png", "image/webp", "image/gif"];
-/** Supported audio MIME types */
-export declare const SUPPORTED_AUDIO_TYPES: readonly ["audio/mpeg", "audio/wav", "audio/ogg", "audio/webm"];
-/** Supported video MIME types */
-export declare const SUPPORTED_VIDEO_TYPES: readonly ["video/mp4", "video/webm", "video/quicktime"];
-/** v2.5 Error codes for streaming and multimodal */
-export declare const ErrorCodesV25: {
-    readonly UNSUPPORTED_MEDIA_TYPE: "E1010";
-    readonly MEDIA_TOO_LARGE: "E1011";
-    readonly MEDIA_FETCH_FAILED: "E1012";
-    readonly MEDIA_DECODE_FAILED: "E1013";
-    readonly STREAM_INTERRUPTED: "E2010";
-    readonly STREAM_TIMEOUT: "E2011";
-    readonly STREAMING_NOT_SUPPORTED: "E4010";
-    readonly MULTIMODAL_NOT_SUPPORTED: "E4011";
-};
-export type ErrorCodeV25 = typeof ErrorCodesV25[keyof typeof ErrorCodesV25];
-/** Runtime capability declaration */
-export interface RuntimeCapabilities {
-    streaming: boolean;
-    multimodal: {
-        input: ModalityType[];
-        output: ModalityType[];
-    };
-    max_media_size_mb: number;
-    supported_transports: ('sse' | 'websocket' | 'ndjson')[];
-}
-/** Default runtime capabilities */
-export declare const DEFAULT_RUNTIME_CAPABILITIES: RuntimeCapabilities;
-/** Extended invoke params with streaming support */
-export interface InvokeParamsV25 extends InvokeParams {
-    stream?: boolean;
-    images?: MediaInput[];
-    audio?: MediaInput[];
-    video?: MediaInput[];
-}
-/** Streaming invoke result */
-export interface StreamingInvokeResult {
-    stream: AsyncIterable<string>;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}
-/** Extended provider interface for v2.5 */
-export interface ProviderV25 extends Provider {
-    /** Check if provider supports streaming */
-    supportsStreaming?(): boolean;
-    /** Check if provider supports multimodal input */
-    supportsMultimodal?(): {
-        input: ModalityType[];
-        output: ModalityType[];
-    };
-    /** Invoke with streaming */
-    invokeStream?(params: InvokeParamsV25): Promise<StreamingInvokeResult>;
-}
-/** Type guard for v2.5 provider */
-export declare function isProviderV25(provider: Provider): provider is ProviderV25;
-/** Extended module interface for v2.5 */
-export interface CognitiveModuleV25 extends CognitiveModule {
-    /** v2.5: Response configuration */
-    response?: ResponseConfig;
-    /** v2.5: Modalities configuration */
-    modalities?: ModalitiesConfig;
-}
-/** Type guard for v2.5 module */
-export declare function isModuleV25(module: CognitiveModule): module is CognitiveModuleV25;
-/** Check if module supports streaming */
-export declare function moduleSupportsStreaming(module: CognitiveModule): boolean;
-/** Check if module supports multimodal input */
-export declare function moduleSupportsMultimodal(module: CognitiveModule): boolean;
-/** Get supported input modalities for module */
-export declare function getModuleInputModalities(module: CognitiveModule): ModalityType[];
-/** Get supported output modalities for module */
-export declare function getModuleOutputModalities(module: CognitiveModule): ModalityType[];

package/dist/types.js

@@ -1,6 +1,6 @@
 /**
  * Cognitive Runtime - Core Types
- * Version 2.5 - With streaming response and multimodal support
+ * Version 2.2 - With Control/Data plane separation, tier, overflow, extensible enums
  */
 // =============================================================================
 // Utility Types
@@ -90,84 +90,3 @@ export function shouldEscalate(response, confidenceThreshold = 0.7) {
     }
     return false;
 }
-/** Supported image MIME types */
-export const SUPPORTED_IMAGE_TYPES = [
-    'image/jpeg',
-    'image/png',
-    'image/webp',
-    'image/gif'
-];
-/** Supported audio MIME types */
-export const SUPPORTED_AUDIO_TYPES = [
-    'audio/mpeg',
-    'audio/wav',
-    'audio/ogg',
-    'audio/webm'
-];
-/** Supported video MIME types */
-export const SUPPORTED_VIDEO_TYPES = [
-    'video/mp4',
-    'video/webm',
-    'video/quicktime'
-];
-// =============================================================================
-// v2.5 Error Codes
-// =============================================================================
-/** v2.5 Error codes for streaming and multimodal */
-export const ErrorCodesV25 = {
-    // Media errors (E1xxx)
-    UNSUPPORTED_MEDIA_TYPE: 'E1010',
-    MEDIA_TOO_LARGE: 'E1011',
-    MEDIA_FETCH_FAILED: 'E1012',
-    MEDIA_DECODE_FAILED: 'E1013',
-    // Streaming errors (E2xxx)
-    STREAM_INTERRUPTED: 'E2010',
-    STREAM_TIMEOUT: 'E2011',
-    // Capability errors (E4xxx)
-    STREAMING_NOT_SUPPORTED: 'E4010',
-    MULTIMODAL_NOT_SUPPORTED: 'E4011',
-};
-/** Default runtime capabilities */
-export const DEFAULT_RUNTIME_CAPABILITIES = {
-    streaming: true,
-    multimodal: {
-        input: ['text', 'image'],
-        output: ['text']
-    },
-    max_media_size_mb: 20,
-    supported_transports: ['sse', 'ndjson']
-};
-/** Type guard for v2.5 provider */
-export function isProviderV25(provider) {
-    return 'invokeStream' in provider || 'supportsStreaming' in provider;
-}
-/** Type guard for v2.5 module */
-export function isModuleV25(module) {
-    return 'response' in module || 'modalities' in module;
-}
-/** Check if module supports streaming */
-export function moduleSupportsStreaming(module) {
-    if (!isModuleV25(module))
-        return false;
-    const mode = module.response?.mode;
-    return mode === 'streaming' || mode === 'both';
-}
-/** Check if module supports multimodal input */
-export function moduleSupportsMultimodal(module) {
-    if (!isModuleV25(module))
-        return false;
-    const modalities = module.modalities?.input ?? ['text'];
-    return modalities.some(m => m !== 'text');
-}
-/** Get supported input modalities for module */
-export function getModuleInputModalities(module) {
-    if (!isModuleV25(module))
-        return ['text'];
-    return module.modalities?.input ?? ['text'];
-}
-/** Get supported output modalities for module */
-export function getModuleOutputModalities(module) {
-    if (!isModuleV25(module))
-        return ['text'];
-    return module.modalities?.output ?? ['text'];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cognitive-modules-cli",
-  "version": "1.4.0",
+  "version": "2.2.0",
   "description": "Cognitive Modules - Structured AI Task Execution with version management",
   "type": "module",
   "main": "dist/index.js",