@juspay/neurolink 7.35.0 → 7.37.0

package/dist/lib/neurolink.d.ts

@@ -62,6 +62,7 @@ export declare class NeuroLink {
     private conversationMemory?;
     private conversationMemoryNeedsInit;
     private conversationMemoryConfig?;
+    private enableOrchestration;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -70,6 +71,7 @@ export declare class NeuroLink {
      * @param config.conversationMemory.enabled - Whether to enable conversation memory (default: false)
      * @param config.conversationMemory.maxSessions - Maximum number of concurrent sessions (default: 100)
      * @param config.conversationMemory.maxTurnsPerSession - Maximum conversation turns per session (default: 50)
+     * @param config.enableOrchestration - Whether to enable smart model orchestration (default: false)
      *
      * @example
      * ```typescript
@@ -84,6 +86,11 @@ export declare class NeuroLink {
      *     maxTurnsPerSession: 20
      *   }
      * });
+     *
+     * // With orchestration enabled
+     * const neurolink = new NeuroLink({
+     *   enableOrchestration: true
+     * });
      * ```
      *
      * @throws {Error} When provider registry setup fails
@@ -92,6 +99,7 @@ export declare class NeuroLink {
      */
     constructor(config?: {
         conversationMemory?: Partial<ConversationMemoryConfig>;
+        enableOrchestration?: boolean;
     });
     /**
      * Log constructor start with comprehensive environment analysis
@@ -158,6 +166,18 @@ export declare class NeuroLink {
      * Log MCP initialization completion
      */
     private logMCPInitComplete;
+    /**
+     * Apply orchestration to determine optimal provider and model
+     * @param options - Original GenerateOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    private applyOrchestration;
+    /**
+     * Apply orchestration to determine optimal provider and model for streaming
+     * @param options - Original StreamOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    private applyStreamOrchestration;
     /**
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods

package/dist/lib/neurolink.js

@@ -35,6 +35,9 @@ import { getConversationMessages, storeConversationTurn, } from "./utils/convers
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 // Import direct tools server for automatic registration
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
+// Import orchestration components
+import { ModelRouter } from "./utils/modelRouter.js";
+import { BinaryTaskClassifier } from "./utils/taskClassifier.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
 // Core types imported from "./types/index.js"
 export class NeuroLink {
@@ -75,6 +78,8 @@ export class NeuroLink {
     conversationMemory;
     conversationMemoryNeedsInit = false;
     conversationMemoryConfig;
+    // Add orchestration property
+    enableOrchestration;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -83,6 +88,7 @@ export class NeuroLink {
      * @param config.conversationMemory.enabled - Whether to enable conversation memory (default: false)
      * @param config.conversationMemory.maxSessions - Maximum number of concurrent sessions (default: 100)
      * @param config.conversationMemory.maxTurnsPerSession - Maximum conversation turns per session (default: 50)
+     * @param config.enableOrchestration - Whether to enable smart model orchestration (default: false)
      *
      * @example
      * ```typescript
@@ -97,6 +103,11 @@ export class NeuroLink {
      *     maxTurnsPerSession: 20
      *   }
      * });
+     *
+     * // With orchestration enabled
+     * const neurolink = new NeuroLink({
+     *   enableOrchestration: true
+     * });
      * ```
      *
      * @throws {Error} When provider registry setup fails
@@ -112,6 +123,8 @@ export class NeuroLink {
         const constructorStartTime = Date.now();
         const constructorHrTimeStart = process.hrtime.bigint();
         const constructorId = `neurolink-constructor-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // Initialize orchestration setting
+        this.enableOrchestration = config?.enableOrchestration ?? false;
         this.logConstructorStart(constructorId, constructorStartTime, constructorHrTimeStart, config);
         this.initializeProviderRegistry(constructorId, constructorStartTime, constructorHrTimeStart);
         this.initializeConversationMemory(config, constructorId, constructorStartTime, constructorHrTimeStart);
@@ -758,6 +771,206 @@ export class NeuroLink {
             mcpLogger.debug("💡 Memory cleanup suggestion: MCP initialization used significant memory. Consider calling MemoryManager.forceGC() after heavy operations.");
         }
     }
+    /**
+     * Apply orchestration to determine optimal provider and model
+     * @param options - Original GenerateOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    async applyOrchestration(options) {
+        const startTime = Date.now();
+        try {
+            // Ensure input.text exists before proceeding
+            if (!options.input?.text || typeof options.input.text !== "string") {
+                logger.debug("Orchestration skipped - no valid input text", {
+                    hasInput: !!options.input,
+                    hasText: !!options.input?.text,
+                    textType: typeof options.input?.text,
+                });
+                return {}; // Return empty object to preserve existing fallback behavior
+            }
+            // Compute classification once to avoid duplicate calls
+            const classification = BinaryTaskClassifier.classify(options.input.text);
+            // Use the model router to get the optimal route
+            const route = ModelRouter.route(options.input.text);
+            // Validate that the routed provider is available and configured
+            const isProviderAvailable = await this.hasProviderEnvVars(route.provider);
+            if (!isProviderAvailable && route.provider !== "ollama") {
+                logger.debug("Orchestration provider validation failed", {
+                    taskType: classification.type,
+                    routedProvider: route.provider,
+                    routedModel: route.model,
+                    reason: "Provider not configured or missing environment variables",
+                    orchestrationTime: `${Date.now() - startTime}ms`,
+                });
+                return {}; // Return empty object to preserve existing fallback behavior
+            }
+            // For Ollama, check if service is running and model is available
+            if (route.provider === "ollama") {
+                try {
+                    const response = await fetch("http://localhost:11434/api/tags", {
+                        method: "GET",
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    if (!response.ok) {
+                        logger.debug("Orchestration provider validation failed", {
+                            taskType: classification.type,
+                            routedProvider: route.provider,
+                            routedModel: route.model,
+                            reason: "Ollama service not responding",
+                            orchestrationTime: `${Date.now() - startTime}ms`,
+                        });
+                        return {}; // Return empty object to preserve existing fallback behavior
+                    }
+                    const { models } = await response.json();
+                    const modelIsAvailable = models.some((m) => m.name === (route.model || "llama3.2:latest"));
+                    if (!modelIsAvailable) {
+                        logger.debug("Orchestration provider validation failed", {
+                            taskType: classification.type,
+                            routedProvider: route.provider,
+                            routedModel: route.model,
+                            reason: `Ollama model '${route.model || "llama3.2:latest"}' not found`,
+                            orchestrationTime: `${Date.now() - startTime}ms`,
+                        });
+                        return {}; // Return empty object to preserve existing fallback behavior
+                    }
+                }
+                catch (error) {
+                    logger.debug("Orchestration provider validation failed", {
+                        taskType: classification.type,
+                        routedProvider: route.provider,
+                        routedModel: route.model,
+                        reason: error instanceof Error ? error.message : "Ollama service check failed",
+                        orchestrationTime: `${Date.now() - startTime}ms`,
+                    });
+                    return {}; // Return empty object to preserve existing fallback behavior
+                }
+            }
+            logger.debug("Orchestration route determined", {
+                taskType: classification.type,
+                selectedProvider: route.provider,
+                selectedModel: route.model,
+                confidence: route.confidence,
+                reasoning: route.reasoning,
+                orchestrationTime: `${Date.now() - startTime}ms`,
+            });
+            // Mark preferred provider in context instead of directly setting provider
+            // This preserves global fallback behavior while indicating orchestration preference
+            return {
+                model: route.model,
+                context: {
+                    ...(options.context || {}),
+                    __orchestratedPreferredProvider: route.provider,
+                },
+            };
+        }
+        catch (error) {
+            logger.error("Orchestration failed", {
+                error: error instanceof Error ? error.message : String(error),
+                orchestrationTime: `${Date.now() - startTime}ms`,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Apply orchestration to determine optimal provider and model for streaming
+     * @param options - Original StreamOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    async applyStreamOrchestration(options) {
+        const startTime = Date.now();
+        try {
+            // Ensure input.text exists before proceeding
+            if (!options.input?.text || typeof options.input.text !== "string") {
+                logger.debug("Stream orchestration skipped - no valid input text", {
+                    hasInput: !!options.input,
+                    hasText: !!options.input?.text,
+                    textType: typeof options.input?.text,
+                });
+                return {}; // Return empty object to preserve existing fallback behavior
+            }
+            // Compute classification once to avoid duplicate calls
+            const classification = BinaryTaskClassifier.classify(options.input.text);
+            // Use the model router to get the optimal route
+            const route = ModelRouter.route(options.input.text);
+            // Validate that the routed provider is available and configured
+            const isProviderAvailable = await this.hasProviderEnvVars(route.provider);
+            if (!isProviderAvailable && route.provider !== "ollama") {
+                logger.debug("Stream orchestration provider validation failed", {
+                    taskType: classification.type,
+                    routedProvider: route.provider,
+                    routedModel: route.model,
+                    reason: "Provider not configured or missing environment variables",
+                    orchestrationTime: `${Date.now() - startTime}ms`,
+                });
+                return {}; // Return empty object to preserve existing fallback behavior
+            }
+            // For Ollama, check if service is running and model is available
+            if (route.provider === "ollama") {
+                try {
+                    const response = await fetch("http://localhost:11434/api/tags", {
+                        method: "GET",
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    if (!response.ok) {
+                        logger.debug("Stream orchestration provider validation failed", {
+                            taskType: classification.type,
+                            routedProvider: route.provider,
+                            routedModel: route.model,
+                            reason: "Ollama service not responding",
+                            orchestrationTime: `${Date.now() - startTime}ms`,
+                        });
+                        return {}; // Return empty object to preserve existing fallback behavior
+                    }
+                    const { models } = await response.json();
+                    const modelIsAvailable = models.some((m) => m.name === (route.model || "llama3.2:latest"));
+                    if (!modelIsAvailable) {
+                        logger.debug("Stream orchestration provider validation failed", {
+                            taskType: classification.type,
+                            routedProvider: route.provider,
+                            routedModel: route.model,
+                            reason: `Ollama model '${route.model || "llama3.2:latest"}' not found`,
+                            orchestrationTime: `${Date.now() - startTime}ms`,
+                        });
+                        return {}; // Return empty object to preserve existing fallback behavior
+                    }
+                }
+                catch (error) {
+                    logger.debug("Stream orchestration provider validation failed", {
+                        taskType: classification.type,
+                        routedProvider: route.provider,
+                        routedModel: route.model,
+                        reason: error instanceof Error ? error.message : "Ollama service check failed",
+                        orchestrationTime: `${Date.now() - startTime}ms`,
+                    });
+                    return {}; // Return empty object to preserve existing fallback behavior
+                }
+            }
+            logger.debug("Stream orchestration route determined", {
+                taskType: classification.type,
+                selectedProvider: route.provider,
+                selectedModel: route.model,
+                confidence: route.confidence,
+                reasoning: route.reasoning,
+                orchestrationTime: `${Date.now() - startTime}ms`,
+            });
+            // Mark preferred provider in context instead of directly setting provider
+            // This preserves global fallback behavior while indicating orchestration preference
+            return {
+                model: route.model,
+                context: {
+                    ...(options.context || {}),
+                    __orchestratedPreferredProvider: route.provider,
+                },
+            };
+        }
+        catch (error) {
+            logger.error("Stream orchestration failed", {
+                error: error instanceof Error ? error.message : String(error),
+                orchestrationTime: `${Date.now() - startTime}ms`,
+            });
+            throw error;
+        }
+    }
     /**
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
@@ -833,6 +1046,27 @@ export class NeuroLink {
             throw new Error("Input text is required and must be a non-empty string");
         }
         const startTime = Date.now();
+        // Apply orchestration if enabled and no specific provider/model requested
+        if (this.enableOrchestration && !options.provider && !options.model) {
+            try {
+                const orchestratedOptions = await this.applyOrchestration(options);
+                logger.debug("Orchestration applied", {
+                    originalProvider: options.provider || "auto",
+                    orchestratedProvider: orchestratedOptions.provider,
+                    orchestratedModel: orchestratedOptions.model,
+                    prompt: options.input.text.substring(0, 100),
+                });
+                // Use orchestrated options
+                Object.assign(options, orchestratedOptions);
+            }
+            catch (error) {
+                logger.warn("Orchestration failed, continuing with original options", {
+                    error: error instanceof Error ? error.message : String(error),
+                    originalProvider: options.provider || "auto",
+                });
+                // Continue with original options if orchestration fails
+            }
+        }
         // Emit generation start event (NeuroLink format - keep existing)
         this.emitter.emit("generation:start", {
             provider: options.provider || "auto",
@@ -854,7 +1088,7 @@ export class NeuroLink {
                 // Continue with warning rather than throwing - graceful degradation
             }
         }
-        // Convert to TextGenerationOptions using factory utilities
+        // 🔧 CRITICAL FIX: Convert to TextGenerationOptions while preserving the input object for multimodal support
         const baseOptions = {
             prompt: options.input.text,
             provider: options.provider,
@@ -868,6 +1102,7 @@ export class NeuroLink {
             context: options.context,
             evaluationDomain: options.evaluationDomain,
             toolUsageContext: options.toolUsageContext,
+            input: options.input, // This includes text, images, and content arrays
         };
         // Apply factory enhancement using centralized utilities
         const textOptions = enhanceTextGenerationOptions(baseOptions, factoryResult);
@@ -1428,14 +1663,21 @@ export class NeuroLink {
             "ollama",
         ];
         const requestedProvider = options.provider === "auto" ? undefined : options.provider;
-        // If specific provider requested, only use that provider (no fallback)
-        const tryProviders = requestedProvider
-            ? [requestedProvider]
-            : providerPriority;
+        // Check for orchestrated preferred provider in context
+        const preferredOrchestrated = options.context && typeof options.context === 'object' && '__orchestratedPreferredProvider' in options.context
+            ? options.context.__orchestratedPreferredProvider
+            : undefined;
+        // Build provider list with orchestrated preference first, then fallback to full list
+        const tryProviders = preferredOrchestrated
+            ? [preferredOrchestrated, ...providerPriority.filter((p) => p !== preferredOrchestrated)]
+            : requestedProvider
+                ? [requestedProvider]
+                : providerPriority;
         logger.debug(`[${functionTag}] Starting direct generation`, {
             requestedProvider: requestedProvider || "auto",
+            preferredOrchestrated: preferredOrchestrated || "none",
             tryProviders,
-            allowFallback: !requestedProvider,
+            allowFallback: !requestedProvider || !!preferredOrchestrated,
         });
         let lastError = null;
         // Try each provider in order
@@ -1650,6 +1892,28 @@ export class NeuroLink {
             await this.initializeConversationMemoryForGeneration(streamId, startTime, hrTimeStart);
             // Initialize MCP
             await this.initializeMCP();
+            const _originalPrompt = options.input.text;
+            // Apply orchestration if enabled and no specific provider/model requested
+            if (this.enableOrchestration && !options.provider && !options.model) {
+                try {
+                    const orchestratedOptions = await this.applyStreamOrchestration(options);
+                    logger.debug("Stream orchestration applied", {
+                        originalProvider: options.provider || "auto",
+                        orchestratedProvider: orchestratedOptions.provider,
+                        orchestratedModel: orchestratedOptions.model,
+                        prompt: options.input.text?.substring(0, 100),
+                    });
+                    // Use orchestrated options
+                    Object.assign(options, orchestratedOptions);
+                }
+                catch (error) {
+                    logger.warn("Stream orchestration failed, continuing with original options", {
+                        error: error instanceof Error ? error.message : String(error),
+                        originalProvider: options.provider || "auto",
+                    });
+                    // Continue with original options if orchestration fails
+                }
+            }
             factoryResult = processStreamingFactoryOptions(options);
             enhancedOptions = createCleanStreamOptions(options);
             if (options.input?.text) {
@@ -1664,7 +1928,9 @@ export class NeuroLink {
             const processedStream = (async function* (self) {
                 try {
                     for await (const chunk of mcpStream) {
-                        if (chunk && "content" in chunk && typeof chunk.content === "string") {
+                        if (chunk &&
+                            "content" in chunk &&
+                            typeof chunk.content === "string") {
                             accumulatedContent += chunk.content;
                             // Emit chunk event for compatibility
                             self.emitter.emit("response:chunk", chunk.content);
@@ -1941,7 +2207,9 @@ export class NeuroLink {
         const fallbackProcessedStream = (async function* (self) {
             try {
                 for await (const chunk of fallbackStreamResult.stream) {
-                    if (chunk && "content" in chunk && typeof chunk.content === "string") {
+                    if (chunk &&
+                        "content" in chunk &&
+                        typeof chunk.content === "string") {
                         fallbackAccumulatedContent += chunk.content;
                         // Emit chunk event
                         self.emitter.emit("response:chunk", chunk.content);

package/dist/lib/types/content.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Content type definitions for multimodal support
+ * Supports text and image content with provider-specific formatting
+ */
+/**
+ * Text content type for multimodal messages
+ */
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+/**
+ * Image content type for multimodal messages
+ */
+export interface ImageContent {
+    type: "image";
+    data: Buffer | string;
+    mediaType?: "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/bmp" | "image/tiff";
+    metadata?: {
+        description?: string;
+        quality?: "low" | "high" | "auto";
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+        filename?: string;
+    };
+}
+/**
+ * Union type for all content types
+ */
+export type Content = TextContent | ImageContent;
+/**
+ * Vision capability information for providers
+ */
+export interface VisionCapability {
+    provider: string;
+    supportedModels: string[];
+    maxImageSize?: number;
+    supportedFormats: string[];
+    maxImagesPerRequest?: number;
+}
+/**
+ * Provider-specific image format requirements
+ */
+export interface ProviderImageFormat {
+    provider: string;
+    format: "data_uri" | "base64" | "inline_data" | "source";
+    requiresPrefix?: boolean;
+    mimeTypeField?: string;
+    dataField?: string;
+}
+/**
+ * Image processing result
+ */
+export interface ProcessedImage {
+    data: string;
+    mediaType: string;
+    size: number;
+    format: "data_uri" | "base64" | "inline_data" | "source";
+}
+/**
+ * Multimodal message structure for provider adapters
+ */
+export interface MultimodalMessage {
+    role: "user" | "assistant" | "system";
+    content: Content[];
+}
+/**
+ * Provider-specific multimodal payload
+ */
+export interface ProviderMultimodalPayload {
+    provider: string;
+    model: string;
+    messages?: MultimodalMessage[];
+    contents?: unknown[];
+    [key: string]: unknown;
+}

package/dist/lib/types/content.js

@@ -0,0 +1,5 @@
+/**
+ * Content type definitions for multimodal support
+ * Supports text and image content with provider-specific formatting
+ */
+export {};

package/dist/lib/types/conversation.d.ts

@@ -66,6 +66,25 @@ export interface ChatMessage {
     /** Content of the message */
     content: string;
 }
+/**
+ * Content format for multimodal messages (used internally)
+ */
+export interface MessageContent {
+    type: string;
+    text?: string;
+    image?: string;
+    mimeType?: string;
+    [key: string]: unknown;
+}
+/**
+ * Extended chat message for multimodal support (internal use)
+ */
+export interface MultimodalChatMessage {
+    /** Role of the message sender */
+    role: "user" | "assistant" | "system";
+    /** Content of the message - can be text or multimodal content array */
+    content: string | MessageContent[];
+}
 /**
  * Events emitted by conversation memory system
  */

package/dist/lib/types/generateTypes.d.ts

@@ -6,13 +6,16 @@ import type { EvaluationData } from "./evaluation.js";
 import type { ChatMessage, ConversationMemoryConfig } from "./conversation.js";
 import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 import type { JsonValue } from "./common.js";
+import type { TextContent, ImageContent } from "./content.js";
 /**
  * Generate function options type - Primary method for content generation
- * Future-ready for multi-modal capabilities while maintaining text focus
+ * Supports multimodal content while maintaining backward compatibility
  */
 export type GenerateOptions = {
     input: {
         text: string;
+        images?: Array<Buffer | string>;
+        content?: Array<TextContent | ImageContent>;
     };
     output?: {
         format?: "text" | "structured" | "json";

package/dist/lib/types/index.d.ts

@@ -5,10 +5,12 @@ export * from "./common.js";
 export * from "./tools.js";
 export * from "./providers.js";
 export * from "./cli.js";
+export * from "./taskClassificationTypes.js";
 export type { Unknown, UnknownRecord, UnknownArray, JsonValue, JsonObject, JsonArray, ErrorInfo, Result, FunctionParameters, } from "./common.js";
 export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, } from "./tools.js";
 export type { AISDKModel, ProviderError, ProviderConfig } from "./providers.js";
 export type { BaseCommandArgs, GenerateCommandArgs, MCPCommandArgs, ModelsCommandArgs, CommandResult, GenerateResult, StreamChunk, } from "./cli.js";
+export type { TaskType, TaskClassification, ClassificationScores, ClassificationStats, ClassificationValidation, } from "./taskClassificationTypes.js";
 export type { MCPTransportType, MCPServerConnectionStatus, MCPServerCategory, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPToolInfo, MCPExecutableTool, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, } from "./mcpTypes.js";
 export type { ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolInfo, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPToolContext, ExternalMCPToolResult, ExternalMCPServerEvents, ExternalMCPManagerConfig, } from "./externalMcp.js";
 export type { ModelCapability, ModelUseCase, ModelFilter, ModelResolutionContext, ModelStats, ModelPricing, } from "./providers.js";

package/dist/lib/types/index.js

@@ -9,6 +9,8 @@ export * from "./tools.js";
 export * from "./providers.js";
 // CLI types
 export * from "./cli.js";
+// Task classification types
+export * from "./taskClassificationTypes.js";
 // Generate types - NEW
 export * from "./generateTypes.js";
 // Analytics types - NEW

package/dist/lib/types/streamTypes.d.ts

@@ -5,6 +5,7 @@ import type { AnalyticsData, TokenUsage } from "./analytics.js";
 import type { EvaluationData } from "./evaluation.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
 import type { ChatMessage } from "./conversation.js";
+import type { TextContent, ImageContent } from "./content.js";
 import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 /**
  * Progress tracking and metadata for streaming operations
@@ -118,10 +119,12 @@ export interface AudioChunk {
     channels: number;
     encoding: PCMEncoding;
 }
-export type StreamOptions = {
+export interface StreamOptions {
     input: {
-        text?: string;
+        text: string;
         audio?: AudioInputSpec;
+        images?: Array<Buffer | string>;
+        content?: Array<TextContent | ImageContent>;
     };
     output?: {
         format?: "text" | "structured" | "json";
@@ -166,7 +169,7 @@ export type StreamOptions = {
     };
     conversationMessages?: ChatMessage[];
     middleware?: MiddlewareFactoryOptions;
-};
+}
 /**
  * Stream function result type - Primary output format for streaming
  * Future-ready for multi-modal outputs while maintaining text focus

package/dist/lib/types/taskClassificationTypes.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Task Classification Types
+ * Type definitions for the task classification system
+ */
+/**
+ * Supported task types for classification
+ */
+export type TaskType = "fast" | "reasoning";
+/**
+ * Result of task classification analysis
+ */
+export interface TaskClassification {
+    /** The classified task type */
+    type: TaskType;
+    /** Confidence score (0-1) in the classification */
+    confidence: number;
+    /** Human-readable explanation of the classification decision */
+    reasoning: string;
+}
+/**
+ * Internal scoring data used during classification analysis
+ */
+export interface ClassificationScores {
+    /** Score indicating likelihood of fast task */
+    fastScore: number;
+    /** Score indicating likelihood of reasoning task */
+    reasoningScore: number;
+    /** Array of reasons contributing to the scores */
+    reasons: string[];
+}
+/**
+ * Statistics for batch classification analysis
+ */
+export interface ClassificationStats {
+    /** Total number of prompts analyzed */
+    total: number;
+    /** Number of prompts classified as fast */
+    fast: number;
+    /** Number of prompts classified as reasoning */
+    reasoning: number;
+    /** Average confidence across all classifications */
+    averageConfidence: number;
+}
+/**
+ * Validation result for testing classification accuracy
+ */
+export interface ClassificationValidation {
+    /** Whether the classification matched the expected result */
+    correct: boolean;
+    /** The actual classification result */
+    classification: TaskClassification;
+}