@juspay/neurolink 5.2.0 → 6.0.0

package/dist/lib/mcp/external-manager.js

@@ -72,7 +72,7 @@ export class ExternalMCPManager {
             });
         }
         catch (error) {
-            if (error.code === "ENOENT") {
+            if (error?.code === "ENOENT") {
                 logger.warn(`[External MCP Manager] Config file not found: ${this.configPath}`);
                 this.config = { mcpServers: {} };
             }
@@ -163,6 +163,12 @@ export class ExternalMCPManager {
      */
     async registerServerTools(serverInfo) {
         try {
+            if (!serverInfo.client) {
+                throw new Error("Client is not available");
+            }
+            if (!serverInfo.server) {
+                throw new Error("Server is not available");
+            }
             const tools = serverInfo.client.getNeuroLinkTools();
             // Register each tool with the server
             for (const [toolName, tool] of Object.entries(tools)) {
@@ -198,8 +204,8 @@ export class ExternalMCPManager {
             statuses[name] = {
                 ...info,
                 // Don't include the actual client/server objects in status
-                client: undefined,
-                server: undefined,
+                client: null,
+                server: null,
             };
         }
         return statuses;

package/dist/lib/mcp/factory.d.ts

@@ -42,15 +42,15 @@ export interface NeuroLinkExecutionContext extends ExecutionContext {
     features?: string[];
     enableDemoMode?: boolean;
     securityLevel?: "public" | "private" | "organization";
-    metadata?: Record<string, any>;
-    [key: string]: any;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
 }
 /**
  * Tool execution result - Standardized result format
  */
 export interface ToolResult {
     success: boolean;
-    data?: any;
+    data?: unknown;
     error?: string | Error;
     usage?: {
         tokens?: number;
@@ -67,7 +67,7 @@ export interface ToolResult {
         timestamp?: number;
         executionTime?: number;
         executionId?: string;
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
 /**
@@ -83,7 +83,7 @@ export interface NeuroLinkMCPTool {
     category?: string;
     permissions?: string[];
     version?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * MCP Server Interface - Lighthouse compatible
@@ -97,7 +97,7 @@ export interface NeuroLinkMCPServer {
     visibility?: "public" | "private" | "organization";
     tools: Record<string, NeuroLinkMCPTool>;
     registerTool(tool: NeuroLinkMCPTool): NeuroLinkMCPServer;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     dependencies?: string[];
     capabilities?: string[];
 }
@@ -111,7 +111,7 @@ export interface MCPServerConfig {
     version?: string;
     category?: MCPServerCategory;
     visibility?: "public" | "private" | "organization";
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     dependencies?: string[];
     capabilities?: string[];
 }

package/dist/lib/mcp/function-calling.d.ts

@@ -5,6 +5,7 @@
  */
 import type { Tool } from "ai";
 import type { NeuroLinkMCPTool, ToolResult, NeuroLinkExecutionContext } from "./factory.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Convert MCP tool to AI SDK function definition
  */
@@ -14,6 +15,7 @@ export declare function mcpToolToAISDKTool(tool: NeuroLinkMCPTool, serverId: str
  */
 export declare function getAvailableFunctionTools(): Promise<{
     tools: Tool[];
+    toolsObject: Record<string, Tool>;
     toolMap: Map<string, {
         serverId: string;
         toolName: string;
@@ -49,3 +51,15 @@ export declare function getFunctionToolsForCategory(category?: string, maxTools?
  * Check if function calling is available
  */
 export declare function isFunctionCallingAvailable(): Promise<boolean>;
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export declare function createNamedTool(name: string, toolDef: Tool): Tool & {
+    name: string;
+};
+/**
+ * Get tools with proper name properties for debugging
+ */
+export declare function getToolsWithNames(): Promise<Record<string, UnknownRecord & {
+    name: string;
+}>>;

package/dist/lib/mcp/function-calling.js

@@ -8,6 +8,100 @@ import { z } from "zod";
 import { unifiedRegistry } from "./unified-registry.js";
 import { createExecutionContext } from "./context-manager.js";
 import { mcpLogger } from "./logging.js";
+/**
+ * Parses neurolink-specific function name patterns to extract the server ID and tool name.
+ *
+ * @param {string[]} parts - An array of strings representing parts of a function name,
+ * typically obtained by splitting the function name on underscores.
+ * @returns {{ serverId: string; toolName: string } | null} An object containing the `serverId`
+ * and `toolName` if the input matches a neurolink-specific pattern, or `null` if no match is found.
+ *
+ * @example
+ * // Returns { serverId: "neurolink_ai_core", toolName: "generate" }
+ * parseNeuroLinkPattern(["neurolink", "ai", "core", "generate"]);
+ *
+ * @example
+ * // Returns { serverId: "neurolink_utility", toolName: "format_number" }
+ * parseNeuroLinkPattern(["neurolink", "utility", "format_number"]);
+ *
+ * @example
+ * // Returns null
+ * parseNeuroLinkPattern(["other", "pattern"]);
+ */
+function parseNeuroLinkPattern(parts) {
+    if (parts.length >= 3 &&
+        parts[0] === "neurolink" &&
+        (parts[1] === "ai" || parts[1] === "utility")) {
+        // neurolink_ai_core_generate -> serverId: "neurolink_ai_core", toolName: "generate"
+        // neurolink_utility_format_number -> serverId: "neurolink_utility", toolName: "format_number"
+        if (parts[1] === "ai" && parts[2] === "core") {
+            return {
+                serverId: "neurolink_ai_core",
+                toolName: parts.slice(3).join("_"),
+            };
+        }
+        else if (parts[1] === "utility") {
+            return {
+                serverId: "neurolink_utility",
+                toolName: parts.slice(2).join("_"),
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Parse underscore-separated function name format
+ */
+function parseUnderscoreFormat(functionName) {
+    const parts = functionName.split("_");
+    if (parts.length >= 2) {
+        // Try neurolink-specific patterns first
+        const neurolinkResult = parseNeuroLinkPattern(parts);
+        if (neurolinkResult) {
+            return neurolinkResult;
+        }
+        // Default underscore parsing
+        return {
+            serverId: parts[0],
+            toolName: parts.slice(1).join("_"),
+        };
+    }
+    return null;
+}
+/**
+ * Parse dot-separated function name format (legacy support)
+ */
+function parseDotFormat(functionName) {
+    const parts = functionName.split(".");
+    if (parts.length >= 2) {
+        return {
+            serverId: parts[0],
+            toolName: parts.slice(1).join("."),
+        };
+    }
+    return null;
+}
+/**
+ * Parse function name to extract server ID and tool name
+ * Handles various naming patterns including neurolink server patterns
+ */
+function parseFunctionName(functionName) {
+    // Try underscore format first (most common)
+    const underscoreResult = parseUnderscoreFormat(functionName);
+    if (underscoreResult) {
+        return underscoreResult;
+    }
+    // Fallback to dot format for backward compatibility
+    const dotResult = parseDotFormat(functionName);
+    if (dotResult) {
+        return dotResult;
+    }
+    // Final fallback - return as-is with unknown server
+    return {
+        serverId: "unknown",
+        toolName: functionName,
+    };
+}
 /**
  * Convert MCP tool to AI SDK function definition
  */
@@ -55,6 +149,7 @@ export function mcpToolToAISDKTool(tool, serverId) {
 export async function getAvailableFunctionTools() {
     const functionTag = "getAvailableFunctionTools";
     const tools = [];
+    const toolsObject = {};
     const toolMap = new Map();
     try {
         // Add overall timeout for the entire function
@@ -281,6 +376,8 @@ export async function getAvailableFunctionTools() {
                             },
                         });
                         tools.push(aiTool);
+                        // Store tool with proper name association
+                        toolsObject[functionName] = aiTool;
                         // Store mapping for execution - CRITICAL: Use sanitized functionName as key
                         toolMap.set(functionName, {
                             serverId: typeof toolInfo.serverId === "string"
@@ -302,7 +399,7 @@ export async function getAvailableFunctionTools() {
                 if (overallTimeoutId) {
                     clearTimeout(overallTimeoutId);
                 }
-                return { tools, toolMap };
+                return { tools, toolsObject, toolMap };
             }
             catch (error) {
                 if (overallTimeoutId) {
@@ -315,7 +412,7 @@ export async function getAvailableFunctionTools() {
     }
     catch (error) {
         mcpLogger.error(`[${functionTag}] Error getting function tools:`, error);
-        return { tools: [], toolMap: new Map() };
+        return { tools: [], toolsObject: {}, toolMap: new Map() };
     }
 }
 /**
@@ -345,38 +442,12 @@ export async function executeFunctionCall(functionName, parameters, context) {
             });
         }
         // Parse server and tool name from function name
-        // First try underscore format (sanitized), then fallback to dot format
-        let parts = functionName.split("_");
-        let serverId = "unknown";
-        let toolName = functionName;
-        if (parts.length >= 2) {
-            // Handle underscore format (sanitized names)
-            const firstPart = parts[0];
-            if (firstPart && typeof firstPart === "string" && firstPart.length > 0) {
-                serverId = firstPart;
-            }
-            else {
-                serverId = "unknown";
-            }
-            toolName = parts.slice(1).join("_"); // Rejoin in case tool name had underscores
-        }
-        else {
-            // Fallback to dot format for backward compatibility
-            parts = functionName.split(".");
-            if (parts.length === 2) {
-                const parsedServerId = parts[0];
-                const parsedToolName = parts[1];
-                if (parsedServerId && parsedToolName) {
-                    serverId = parsedServerId;
-                    toolName = parsedToolName;
-                }
-            }
-            else {
-                // Can't parse - try executing as-is through unified registry
-                mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
-                const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
-                return result;
-            }
+        const { serverId, toolName } = parseFunctionName(functionName);
+        if (serverId === "unknown") {
+            // Can't parse - try executing as-is through unified registry
+            mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
+            const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
+            return result;
         }
         // Handle built-in NeuroLink servers directly
         if (serverId === "neurolink-utility" ||
@@ -541,3 +612,31 @@ export async function isFunctionCallingAvailable() {
         return false;
     }
 }
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export function createNamedTool(name, toolDef) {
+    return {
+        name,
+        description: toolDef.description,
+        parameters: toolDef.parameters,
+        execute: toolDef.execute,
+    };
+}
+/**
+ * Get tools with proper name properties for debugging
+ */
+export async function getToolsWithNames() {
+    try {
+        const { toolsObject } = await getAvailableFunctionTools();
+        const namedTools = {};
+        for (const [name, tool] of Object.entries(toolsObject)) {
+            namedTools[name] = createNamedTool(name, tool);
+        }
+        return namedTools;
+    }
+    catch (error) {
+        mcpLogger.warn("[getToolsWithNames] Failed to get tools with names:", error);
+        return {};
+    }
+}

package/dist/lib/mcp/health-monitor.d.ts

@@ -4,6 +4,7 @@
  * Based on health monitoring patterns from Cline
  */
 import type { MCPRegistry } from "./registry.js";
+import type { Unknown } from "../types/common.js";
 import { ErrorManager } from "./error-manager.js";
 /**
  * Connection status states
@@ -215,7 +216,7 @@ export declare class HealthMonitor {
      * @param event Event type to subscribe to
      * @param callback Callback function
      */
-    on(event: "health-change" | "recovery-started" | "recovery-failed" | "critical-error", callback: (data: any) => void): void;
+    on(event: "health-change" | "recovery-started" | "recovery-failed" | "critical-error", callback: (data: Unknown) => void): void;
     /**
      * Get health history for trend analysis
      *

package/dist/lib/mcp/health-monitor.js

@@ -578,26 +578,35 @@ export class HealthMonitor {
      */
     generateRecommendations(summary, servers) {
         const recommendations = [];
+        // Type-safe access to summary properties
+        const overallHealth = typeof summary.overallHealth === "number" ? summary.overallHealth : 0;
+        const unhealthyServers = typeof summary.unhealthyServers === "number"
+            ? summary.unhealthyServers
+            : 0;
+        const totalServers = typeof summary.totalServers === "number" ? summary.totalServers : 1;
         // Check overall health
-        if (summary.overallHealth < 50) {
+        if (overallHealth < 50) {
             recommendations.push("Critical: System health is below 50%. Immediate attention required.");
         }
         // Check unhealthy servers
-        if (summary.unhealthyServers > summary.totalServers * 0.3) {
+        if (unhealthyServers > totalServers * 0.3) {
             recommendations.push("Multiple servers are failing. Check network connectivity and server availability.");
         }
         // Check recovery attempts
-        const highRecoveryServers = servers.filter((s) => s.metrics.recoveryAttempts > 2);
+        const highRecoveryServers = servers.filter((s) => typeof s.metrics === "object" &&
+            s.metrics &&
+            typeof s.metrics.recoveryAttempts === "number" &&
+            s.metrics.recoveryAttempts > 2);
         if (highRecoveryServers.length > 0) {
-            recommendations.push(`Servers with repeated recovery attempts: ${highRecoveryServers.map((s) => s.serverId).join(", ")}. Consider manual intervention.`);
+            recommendations.push(`Servers with repeated recovery attempts: ${highRecoveryServers.map((s) => (typeof s.serverId === "string" ? s.serverId : "unknown")).join(", ")}. Consider manual intervention.`);
         }
         // Check latency
-        const highLatencyServers = servers.filter((s) => s.avgLatency > 1000);
+        const highLatencyServers = servers.filter((s) => typeof s.avgLatency === "number" && s.avgLatency > 1000);
         if (highLatencyServers.length > 0) {
-            recommendations.push(`High latency detected on servers: ${highLatencyServers.map((s) => s.serverId).join(", ")}. Check server load and network conditions.`);
+            recommendations.push(`High latency detected on servers: ${highLatencyServers.map((s) => (typeof s.serverId === "string" ? s.serverId : "unknown")).join(", ")}. Check server load and network conditions.`);
         }
         // Positive feedback
-        if (summary.overallHealth >= 90) {
+        if (overallHealth >= 90) {
             recommendations.push("System health is excellent. All servers are operating normally.");
         }
         return recommendations;

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

@@ -23,17 +23,17 @@ export declare function listMCPs(): Promise<MCPMetadata[]>;
 /**
  * Execute an MCP operation
  */
-export declare function executeMCP<T = any>(name: string, config: any, args: any, context?: {
+export declare function executeMCP<T = unknown>(name: string, config: unknown, args: unknown, context?: {
     sessionId?: string;
     userId?: string;
 }): Promise<T>;
 /**
  * Quick filesystem operations
  */
-export declare function readFile(path: string, basePath?: string): Promise<any>;
-export declare function writeFile(path: string, content: string, basePath?: string): Promise<any>;
-export declare function listFiles(path: string, basePath?: string): Promise<any>;
-export declare function createDirectory(path: string, basePath?: string): Promise<any>;
+export declare function readFile(path: string, basePath?: string): Promise<string | Buffer>;
+export declare function writeFile(path: string, content: string, basePath?: string): Promise<void>;
+export declare function listFiles(path: string, basePath?: string): Promise<string[]>;
+export declare function createDirectory(path: string, basePath?: string): Promise<void>;
 /**
  * Get MCP ecosystem statistics
  */

package/dist/lib/mcp/initialize-tools.d.ts

@@ -4,6 +4,7 @@
  */
 import type { NeuroLinkMCPClient } from "./client.js";
 import type { NeuroLinkExecutionContext } from "./factory.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Initialize and register tools from MCP Servers with the MCP client
  * Following Lighthouse's pattern for tool registration
@@ -13,7 +14,7 @@ export declare const initializeMCPTools: (sessionId: string, client: NeuroLinkMC
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export declare function getAllAvailableTools(inMemoryServers?: Map<string, any>): Promise<Array<{
+export declare function getAllAvailableTools(inMemoryServers?: Map<string, UnknownRecord>): Promise<Array<{
     serverId: string;
     serverTitle: string;
     toolName: string;

package/dist/lib/mcp/initialize-tools.js

@@ -145,7 +145,10 @@ export async function getAllAvailableTools(inMemoryServers) {
     if (inMemoryServers) {
         for (const [serverId, serverConfig] of inMemoryServers) {
             const server = serverConfig.server;
-            if (server && server.tools) {
+            if (server &&
+                typeof server === "object" &&
+                "tools" in server &&
+                server.tools) {
                 // Handle both Map and object formats
                 const toolEntries = server.tools instanceof Map
                     ? Array.from(server.tools.entries())
@@ -175,7 +178,12 @@ export async function getAllAvailableTools(inMemoryServers) {
                     }
                     tools.push({
                         serverId,
-                        serverTitle: server.title || serverId,
+                        serverTitle: typeof server === "object" &&
+                            server &&
+                            "title" in server &&
+                            typeof server.title === "string"
+                            ? server.title
+                            : serverId,
                         toolName,
                         namespacedName,
                         description,

package/dist/lib/mcp/manager.d.ts

@@ -4,6 +4,7 @@
  */
 import { NeuroLinkMCPClient } from "./client.js";
 import type { MCPClientConfig } from "./client.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * MCP Manager - Factory pattern for managing multiple client instances
  * Following Lighthouse's session-based architecture
@@ -46,7 +47,7 @@ export declare class NeuroLinkMCPManager {
     static getAllStats(): {
         instanceCount: number;
         maxInstances: number;
-        instances: Record<string, any>;
+        instances: Record<string, UnknownRecord>;
     };
     /**
      * Clear all instances (for testing or shutdown)

package/dist/lib/mcp/neurolink-mcp-client.d.ts

@@ -70,6 +70,7 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Get registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;

package/dist/lib/mcp/neurolink-mcp-client.js

@@ -244,11 +244,26 @@ Response (JSON array only):`;
                     exists: async () => false,
                 },
                 path: {
-                    join: (...paths) => require("path").join(...paths),
-                    resolve: (...paths) => require("path").resolve(...paths),
-                    relative: (from, to) => require("path").relative(from, to),
-                    dirname: (path) => require("path").dirname(path),
-                    basename: (path, ext) => require("path").basename(path, ext),
+                    join: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.join(...paths);
+                    },
+                    resolve: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.resolve(...paths);
+                    },
+                    relative: (from, to) => {
+                        const pathModule = require("path");
+                        return pathModule.relative(from, to);
+                    },
+                    dirname: (pathArg) => {
+                        const pathModule = require("path");
+                        return pathModule.dirname(pathArg);
+                    },
+                    basename: (pathArg, ext) => {
+                        const pathModule = require("path");
+                        return pathModule.basename(pathArg, ext);
+                    },
                 },
                 grantedPermissions: [],
                 log: console.log,
@@ -367,7 +382,7 @@ Response (JSON array only):`;
             const toolResult = toolResults[0];
             if (toolResult.result.success && toolResult.result.data) {
                 const data = toolResult.result.data;
-                if (data.displayString) {
+                if (typeof data.displayString === "string") {
                     return data.displayString;
                 }
             }
@@ -409,6 +424,7 @@ Please provide a natural response based on the tool results.`;
         const tools = {};
         for (const [name, tool] of this.tools) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };

package/dist/lib/mcp/orchestrator.d.ts

@@ -5,6 +5,7 @@
  * Now with semaphore-based race condition prevention
  */
 import type { ToolResult } from "./factory.js";
+import type { JsonValue, UnknownRecord } from "../types/common.js";
 import { MCPToolRegistry, type ToolExecutionOptions } from "./tool-registry.js";
 import { ContextManager, type ContextRequest } from "./context-manager.js";
 import { SemaphoreManager } from "./semaphore-manager.js";
@@ -27,7 +28,7 @@ export interface PipelineOptions {
  */
 export interface PipelineStep {
     toolName: string;
-    params: any;
+    params: JsonValue;
     options?: ToolExecutionOptions;
     dependsOn?: string[];
     stepId?: string;
@@ -95,7 +96,7 @@ export declare class MCPOrchestrator {
      * @param options Execution options
      * @returns Tool execution result
      */
-    executeTool(toolName: string, params: any, contextRequest?: ContextRequest, options?: ToolExecutionOptions & {
+    executeTool(toolName: string, params: JsonValue, contextRequest?: ContextRequest, options?: ToolExecutionOptions & {
         sessionOptions?: SessionOptions;
     }): Promise<ToolResult>;
     /**
@@ -129,11 +130,11 @@ export declare class MCPOrchestrator {
      * @returns Comprehensive orchestrator statistics
      */
     getStats(): {
-        registry: any;
-        context: any;
-        session: any;
-        error: any;
-        health?: any;
+        registry: UnknownRecord;
+        context: UnknownRecord;
+        session: UnknownRecord;
+        error: UnknownRecord;
+        health?: UnknownRecord;
         orchestrator: {
             pipelinesExecuted: number;
         };
@@ -162,7 +163,7 @@ export declare class MCPOrchestrator {
      * @param value State value
      * @returns Success status
      */
-    setSessionState(sessionId: string, key: string, value: any): Promise<boolean>;
+    setSessionState(sessionId: string, key: string, value: JsonValue): Promise<boolean>;
     /**
      * Get session state value
      *
@@ -170,7 +171,7 @@ export declare class MCPOrchestrator {
      * @param key State key
      * @returns State value or undefined
      */
-    getSessionState(sessionId: string, key: string): Promise<any>;
+    getSessionState(sessionId: string, key: string): Promise<JsonValue | undefined>;
     /**
      * Get all active sessions
      *
@@ -240,7 +241,7 @@ export declare class MCPOrchestrator {
      * @param config Transport configuration
      * @returns Connected MCP client
      */
-    connectTransport(config: TransportConfig): Promise<any>;
+    connectTransport(config: TransportConfig): Promise<unknown>;
     /**
      * Disconnect from MCP server
      */
@@ -280,7 +281,7 @@ export declare const defaultOrchestrator: MCPOrchestrator;
  * @param options Execution options
  * @returns Tool execution result
  */
-export declare function executeTool(toolName: string, params: any, contextRequest?: ContextRequest, options?: ToolExecutionOptions): Promise<ToolResult>;
+export declare function executeTool(toolName: string, params: JsonValue, contextRequest?: ContextRequest, options?: ToolExecutionOptions): Promise<ToolResult>;
 /**
  * Utility function to execute text generation pipeline
  *
@@ -289,7 +290,7 @@ export declare function executeTool(toolName: string, params: any, contextReques
  * @param options Generation options
  * @returns Text generation result
  */
-export declare function executeTextPipeline(prompt: string, contextRequest?: ContextRequest, options?: any): Promise<TextPipelineResult>;
+export declare function executeTextPipeline(prompt: string, contextRequest?: ContextRequest, options?: UnknownRecord): Promise<TextPipelineResult>;
 /**
  * Utility function to execute pipeline with default orchestrator
  *

package/dist/lib/mcp/orchestrator.js

@@ -295,7 +295,7 @@ export class MCPOrchestrator {
                     toolName: "select-provider",
                     params: {
                         requirements: {
-                            maxTokens: options.maxTokens,
+                            maxTokens: options.maxTokens || 1000,
                             costEfficient: true,
                         },
                     },
@@ -307,11 +307,11 @@ export class MCPOrchestrator {
                 toolName: "generate",
                 params: {
                     prompt,
-                    provider: options.provider,
-                    model: options.model,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    systemPrompt: options.systemPrompt,
+                    provider: options.provider || "auto",
+                    model: options.model || "default",
+                    temperature: options.temperature || 0.7,
+                    maxTokens: options.maxTokens || 1000,
+                    systemPrompt: options.systemPrompt || "",
                 },
                 dependsOn: options.provider ? [] : ["select-provider"],
             });
@@ -346,7 +346,8 @@ export class MCPOrchestrator {
             return {
                 success: true,
                 text: textResult.data?.text,
-                provider: textResult.data?.provider || providerResult?.data?.provider,
+                provider: textResult.data?.provider ||
+                    providerResult?.data?.provider,
                 model: textResult.data?.model,
                 executionTime,
                 usage: textResult.usage,
@@ -441,7 +442,8 @@ export class MCPOrchestrator {
      * @returns State value or undefined
      */
     async getSessionState(sessionId, key) {
-        return this.sessionManager.getSessionState(sessionId, key);
+        const result = this.sessionManager.getSessionState(sessionId, key);
+        return result;
     }
     /**
      * Get all active sessions