nitrostack 1.0.15 → 1.0.17

package/src/studio/lib/llm-service.ts

@@ -24,12 +24,131 @@ export interface ChatResponse {
 }
 
 export class LLMService {
+  // System prompt to improve tool usage (especially for Gemini)
+  private getSystemPrompt(tools: any[]): string {
+    return `You are an intelligent AI assistant with access to ${tools.length} powerful tools. Your goal is to help users accomplish their tasks efficiently and intelligently.
+
+**CORE PRINCIPLES FOR TOOL USAGE:**
+
+1. **Be Proactive & Infer Context**: 
+   - Infer obvious information instead of asking (e.g., "Bangalore" → Karnataka, India; "New York" → NY, USA)
+   - Use common sense defaults when reasonable
+   - Don't ask for information you can deduce from context
+
+2. **Chain Tools Intelligently**: 
+   - Use multiple tools in sequence to accomplish complex tasks
+   - If a task requires multiple steps, execute them automatically
+   - Example: login → fetch data → process → display results
+   - Don't ask permission for each step in an obvious workflow
+
+3. **Maintain Context Awareness**: 
+   - Remember information from previous tool calls in THIS conversation
+   - Extract and reuse data (IDs, names, values) from previous tool results
+   - Example: If browse_products returned products with IDs, use those IDs for add_to_cart
+   - Match user requests to previous data (e.g., "apple" → find product with name "Apple" → use its ID)
+   - Track state across the conversation (logged in status, product IDs, order IDs, etc.)
+   - NEVER ask for information you already have from a previous tool call
+
+4. **Use Smart Defaults**: 
+   - Apply sensible default values when parameters are optional
+   - Common defaults: page=1, limit=10, sort=recent, etc.
+   - Only ask for clarification when truly ambiguous
+
+5. **Minimize User Friction**: 
+   - Don't ask for every detail - use inference and defaults
+   - Chain related operations seamlessly
+   - Provide concise summaries after multi-step operations
+   - Be conversational but efficient
+
+6. **Handle Errors Gracefully**:
+   - If authentication required, guide user to login
+   - If prerequisite missing, suggest the required step
+   - If operation fails, explain why and suggest alternatives
+   - Always provide a helpful next step
+
+7. **Tool Call Best Practices**:
+   - Read tool descriptions carefully to understand their purpose
+   - Use exact parameter names as specified in the schema
+   - Pay attention to required vs optional parameters
+   - If a tool says "Requires authentication" - CALL IT ANYWAY! Auth is handled automatically
+   - Don't ask for credentials preemptively - only if a tool explicitly fails
+   - Look for examples in tool schemas for guidance
+
+**AUTHENTICATION HANDLING:**
+
+- Authentication tokens are AUTOMATICALLY handled in the background
+- If a tool says "Requires authentication", you can STILL call it directly - auth is transparent
+- NEVER ask users for credentials unless a tool explicitly fails with an auth error
+- If you get an auth error, THEN suggest the user login using the login tool
+- Once a user logs in (or if already logged in), the session persists automatically
+- You don't need to check if user is authenticated - just call the tool and let the system handle it
+
+**EXAMPLES:**
+
+**Authentication:**
+User: "whoami" → Call whoami tool directly (don't ask for login)
+User: "show my orders" → Call get_order_history directly (don't ask for login)
+User: "what's in my cart" → Call view_cart directly (don't ask for login)
+
+**Context Awareness:**
+1. browse_products returns: [{id: "prod-3", name: "Apple", price: 0.99}, ...]
+2. User: "add apple to cart" → Extract ID "prod-3" from previous result → Call add_to_cart({product_id: "prod-3", quantity: 1})
+3. User: "add 2 more" → Remember prod-3 → Call add_to_cart({product_id: "prod-3", quantity: 2})
+
+**NEVER do this:**
+❌ User: "add apple to cart" → "What is the product ID?" (You already have it!)
+❌ User: "add to cart" → "Which product?" (Look at conversation context!)
+
+Only if tool returns auth error → THEN suggest: "Please login with your credentials"
+
+**PRESENTING TOOL RESULTS:**
+
+When you call a tool and receive results, you MUST present the information to the user in a clear, formatted way:
+
+- For **list_resources**: Show each resource's URI, name, description, and mime type in a formatted list
+- For **list_prompts**: Show each prompt's name, description, and required arguments
+- For **read_resource**: Display the resource content in an appropriate format
+- For **execute_prompt**: Show the prompt result clearly
+- For ANY tool result: Extract and format the key information for the user to understand
+
+**Example:**
+User: "list all resources"
+1. Call list_resources tool
+2. Receive JSON array of resources
+3. Format and present: "Here are the available resources:
+   - **Resource Name** (uri) - Description
+   - **Another Resource** (uri) - Description"
+
+**NEVER** just say "I have the results" without showing them!
+**ALWAYS** format and display the actual data you receive from tools!
+
+**REMEMBER:** 
+
+- You have access to real, functional tools - use them!
+- Call tools directly - don't ask for permission or credentials first  
+- **After calling a tool, ALWAYS present the results to the user clearly**
+- Your goal is to be helpful, efficient, and reduce user friction
+- Think through multi-step workflows and execute them seamlessly
+- Use your intelligence to fill gaps rather than always asking questions`;
+  }
+
   async chat(
     provider: LLMProvider,
     messages: ChatMessage[],
     tools: any[],
     apiKey: string
   ): Promise<ChatResponse> {
+    // Inject system prompt at the beginning if not already present
+    if (messages.length > 0 && messages[0].role !== 'system') {
+      messages = [
+        {
+          role: 'system',
+          content: this.getSystemPrompt(tools),
+        },
+        ...messages,
+      ];
+    }
+    
     if (provider === 'openai') {
       return this.chatOpenAI(messages, tools, apiKey);
     } else if (provider === 'gemini') {

package/src/studio/lib/log-manager.ts

@@ -0,0 +1,76 @@
+// Log Manager for MCP Server
+// Captures stdout/stderr from MCP server process and streams to clients
+
+export interface LogEntry {
+  timestamp: number;
+  level: 'info' | 'error' | 'warn' | 'debug';
+  message: string;
+  source: 'stdout' | 'stderr' | 'system';
+}
+
+class LogManager {
+  private logs: LogEntry[] = [];
+  private maxLogs = 1000; // Keep last 1000 logs in memory
+  private listeners: Set<(log: LogEntry) => void> = new Set();
+
+  addLog(message: string, level: LogEntry['level'] = 'info', source: LogEntry['source'] = 'system') {
+    const entry: LogEntry = {
+      timestamp: Date.now(),
+      level,
+      message: message.trim(),
+      source,
+    };
+
+    this.logs.push(entry);
+
+    // Keep only last maxLogs entries
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(-this.maxLogs);
+    }
+
+    // Notify all listeners
+    this.listeners.forEach(listener => {
+      try {
+        listener(entry);
+      } catch (error) {
+        console.error('Error in log listener:', error);
+      }
+    });
+  }
+
+  getLogs(limit?: number): LogEntry[] {
+    if (limit) {
+      return this.logs.slice(-limit);
+    }
+    return [...this.logs];
+  }
+
+  clearLogs() {
+    this.logs = [];
+    this.addLog('Logs cleared', 'info', 'system');
+  }
+
+  subscribe(listener: (log: LogEntry) => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  getLogCount(): number {
+    return this.logs.length;
+  }
+}
+
+// Global singleton
+declare global {
+  var __logManager: LogManager | undefined;
+}
+
+export function getLogManager(): LogManager {
+  if (!global.__logManager) {
+    global.__logManager = new LogManager();
+  }
+  return global.__logManager;
+}
+

package/src/studio/lib/mcp-client.ts

@@ -1,20 +1,36 @@
 // MCP Client for Studio
-// Communicates with MCP server via stdio
+// Communicates with MCP server via stdio or HTTP
 
 import { spawn, ChildProcess } from 'child_process';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { HttpClientTransport } from '@/lib/http-client-transport';
+import { getLogManager } from '@/lib/log-manager';
 
-export interface McpClientConfig {
+export type TransportType = 'stdio' | 'http';
+
+export interface StdioClientConfig {
+  type: 'stdio';
   command: string;
   args: string[];
   env?: Record<string, string>;
   cwd?: string;
 }
 
+export interface HttpClientConfig {
+  type: 'http';
+  baseUrl: string;
+  basePath?: string;
+  headers?: Record<string, string>;
+}
+
+export type McpClientConfig = StdioClientConfig | HttpClientConfig;
+
 export class McpClient {
   private client: Client | null = null;
-  private transport: StdioClientTransport | null = null;
+  private transport: StdioClientTransport | HttpClientTransport | null = null;
+  private transportType: TransportType | null = null;
+  private childProcess: ChildProcess | null = null;
 
   async connect(config: McpClientConfig): Promise<void> {
     if (this.client && this.transport) {
@@ -35,16 +51,73 @@ export class McpClient {
       this.transport = null;
     }
 
-    console.log('🚀 Connecting to MCP server:', config.command, config.args);
-    console.log('📝 Environment vars:', Object.keys(config.env || {}).join(', '));
+    this.transportType = config.type;
+
+    // Create appropriate transport based on type
+    if (config.type === 'stdio') {
+      console.log('🚀 Connecting to MCP server via STDIO:', config.command, config.args);
+      console.log('📝 Environment vars:', Object.keys(config.env || {}).join(', '));
+      
+      const logManager = getLogManager();
+      logManager.addLog(`Starting MCP server: ${config.command} ${config.args.join(' ')}`, 'info', 'system');
+
+      // Create STDIO transport (it will spawn the process internally)
+      this.transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: { ...process.env, ...config.env },
+        cwd: config.cwd,
+      });
+
+      // Access the child process from the transport to capture logs
+      // The transport stores the process in a private property, so we need to access it
+      setTimeout(() => {
+        const transport = this.transport as any;
+        if (transport._process || transport.process) {
+          this.childProcess = transport._process || transport.process;
+          
+          // Capture stdout
+          this.childProcess?.stdout?.on('data', (data: Buffer) => {
+            const message = data.toString();
+            logManager.addLog(message, 'info', 'stdout');
+          });
+
+          // Capture stderr
+          this.childProcess?.stderr?.on('data', (data: Buffer) => {
+            const message = data.toString();
+            logManager.addLog(message, 'error', 'stderr');
+          });
+
+          // Handle process errors
+          this.childProcess?.on('error', (error: Error) => {
+            logManager.addLog(`Process error: ${error.message}`, 'error', 'system');
+          });
 
-    // Create transport (it will spawn the process internally)
-    this.transport = new StdioClientTransport({
-      command: config.command,
-      args: config.args,
-      env: { ...process.env, ...config.env },
-      cwd: config.cwd, // Set working directory for the child process
-    });
+          // Handle process exit
+          this.childProcess?.on('exit', (code: number | null, signal: string | null) => {
+            if (code !== null) {
+              logManager.addLog(`MCP server exited with code ${code}`, code === 0 ? 'info' : 'error', 'system');
+            } else if (signal) {
+              logManager.addLog(`MCP server killed with signal ${signal}`, 'warn', 'system');
+            }
+          });
+        }
+      }, 100); // Small delay to ensure transport has spawned the process
+    } else if (config.type === 'http') {
+      console.log('🌐 Connecting to MCP server via HTTP:', config.baseUrl);
+
+      // Create HTTP transport
+      this.transport = new HttpClientTransport({
+        baseUrl: config.baseUrl,
+        basePath: config.basePath,
+        headers: config.headers,
+      });
+
+      // Start the HTTP transport (establish SSE connection)
+      await this.transport.start();
+    } else {
+      throw new Error(`Unknown transport type: ${(config as any).type}`);
+    }
 
     // Create client
     this.client = new Client(
@@ -65,22 +138,25 @@ export class McpClient {
       console.error('❌ MCP Client error:', error);
       this.client = null;
       this.transport = null;
+      this.transportType = null;
     };
 
     this.client.onclose = () => {
       console.log('🔌 MCP Client connection closed');
       this.client = null;
       this.transport = null;
+      this.transportType = null;
     };
 
     // Connect
     try {
       await this.client.connect(this.transport);
-      console.log('✅ MCP Client connected and ready');
+      console.log(`✅ MCP Client connected and ready (${config.type.toUpperCase()} transport)`);
     } catch (error) {
       console.error('❌ Failed to connect MCP client:', error);
       this.client = null;
       this.transport = null;
+      this.transportType = null;
       throw error;
     }
   }
@@ -88,6 +164,8 @@ export class McpClient {
   async disconnect(): Promise<void> {
     console.log('🛑 Disconnecting MCP client...');
     
+    const logManager = getLogManager();
+    
     if (this.client) {
       await this.client.close();
       this.client = null;
@@ -97,12 +175,24 @@ export class McpClient {
       await this.transport.close();
       this.transport = null;
     }
+
+    if (this.childProcess) {
+      logManager.addLog('Stopping MCP server process', 'info', 'system');
+      this.childProcess.kill('SIGTERM');
+      this.childProcess = null;
+    }
+
+    this.transportType = null;
   }
 
   isConnected(): boolean {
     return this.client !== null;
   }
 
+  getTransportType(): TransportType | null {
+    return this.transportType;
+  }
+
   async listTools() {
     if (!this.client) throw new Error('Not connected');
     return await this.client.listTools();