nitrostack 1.0.65 → 1.0.66

package/src/studio/lib/http-client-transport.ts

@@ -0,0 +1,222 @@
+/**
+ * HTTP Client Transport for MCP
+ * 
+ * Implements HTTP-based communication with MCP servers using SSE for server-to-client messages
+ * and POST for client-to-server messages.
+ * 
+ * Note: This uses EventSource which is browser-only. For server-side usage, you need eventsource polyfill.
+ */
+
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+
+// EventSource type that works in both browser and Node.js
+type EventSourceType = typeof EventSource extends { prototype: infer T } ? T : any;
+
+export interface HttpClientTransportOptions {
+  /**
+   * Base URL of the MCP server (e.g., http://localhost:3000)
+   */
+  baseUrl: string;
+  
+  /**
+   * Base path for MCP endpoints (default: '/mcp')
+   */
+  basePath?: string;
+  
+  /**
+   * Optional headers to include in requests (e.g., Authorization)
+   */
+  headers?: Record<string, string>;
+}
+
+/**
+ * HTTP Client Transport
+ * 
+ * Connects to an MCP server over HTTP using:
+ * - SSE (Server-Sent Events) for receiving messages from server
+ * - HTTP POST for sending messages to server
+ */
+export class HttpClientTransport implements Transport {
+  private baseUrl: string;
+  private basePath: string;
+  private headers: Record<string, string>;
+  private eventSource: EventSourceType | null = null;
+  private clientId: string;
+  private messageHandler?: (message: JSONRPCMessage) => Promise<void>;
+  private closeHandler?: () => void;
+  private errorHandler?: (error: Error) => void;
+  private isConnected = false;
+  private EventSourceImpl: any;
+
+  constructor(options: HttpClientTransportOptions) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.basePath = options.basePath || '/mcp';
+    this.headers = options.headers || {};
+    this.clientId = `client_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    
+    // Use native EventSource in browser, require polyfill in Node.js
+    if (typeof EventSource !== 'undefined') {
+      this.EventSourceImpl = EventSource;
+    } else {
+      // In Node.js environment, try to load eventsource package
+      try {
+        this.EventSourceImpl = require('eventsource');
+      } catch (e) {
+        throw new Error(
+          'EventSource is not available. In Node.js, install "eventsource" package: npm install eventsource'
+        );
+      }
+    }
+  }
+
+  /**
+   * Start the transport by connecting to SSE endpoint
+   */
+  async start(): Promise<void> {
+    if (this.isConnected) {
+      console.warn('⚠️  HTTP transport already connected');
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        const sseUrl = `${this.baseUrl}${this.basePath}/sse?clientId=${this.clientId}`;
+        console.log('🔌 Connecting to SSE endpoint:', sseUrl);
+
+        // Create EventSource for receiving server messages
+        this.eventSource = new this.EventSourceImpl(sseUrl) as EventSourceType;
+
+        this.eventSource.onopen = () => {
+          console.log('✅ SSE connection established');
+          this.isConnected = true;
+          resolve();
+        };
+
+        this.eventSource.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data) as JSONRPCMessage;
+            console.log('📨 Received message from server:', message);
+            
+            if (this.messageHandler) {
+              this.messageHandler(message).catch((error) => {
+                console.error('Error handling message:', error);
+                if (this.errorHandler) {
+                  this.errorHandler(error);
+                }
+              });
+            }
+          } catch (error) {
+            console.error('Failed to parse SSE message:', error);
+            if (this.errorHandler) {
+              this.errorHandler(error as Error);
+            }
+          }
+        };
+
+        this.eventSource.onerror = (error) => {
+          console.error('❌ SSE connection error:', error);
+          this.isConnected = false;
+          
+          if (this.errorHandler) {
+            this.errorHandler(new Error('SSE connection failed'));
+          }
+          
+          if (!this.isConnected) {
+            // Connection failed during initial setup
+            reject(new Error('Failed to establish SSE connection'));
+          }
+        };
+
+        // Set a timeout for connection establishment
+        setTimeout(() => {
+          if (!this.isConnected) {
+            this.eventSource?.close();
+            reject(new Error('SSE connection timeout'));
+          }
+        }, 10000); // 10 second timeout
+
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Send a message to the server
+   */
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (!this.isConnected) {
+      throw new Error('HTTP transport not connected');
+    }
+
+    try {
+      const url = `${this.baseUrl}${this.basePath}/message`;
+      console.log('📤 Sending message to server:', message);
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.headers,
+        },
+        body: JSON.stringify({
+          clientId: this.clientId,
+          message,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
+      }
+
+      console.log('✅ Message sent successfully');
+    } catch (error) {
+      console.error('Failed to send message:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Close the transport
+   */
+  async close(): Promise<void> {
+    console.log('🛑 Closing HTTP transport...');
+    
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    
+    this.isConnected = false;
+    
+    if (this.closeHandler) {
+      this.closeHandler();
+    }
+    
+    console.log('✅ HTTP transport closed');
+  }
+
+  /**
+   * Set handler for incoming messages
+   */
+  onmessage = (handler: (message: JSONRPCMessage) => Promise<void>): void => {
+    this.messageHandler = handler;
+  };
+
+  /**
+   * Set handler for connection close
+   */
+  onclose = (handler: () => void): void => {
+    this.closeHandler = handler;
+  };
+
+  /**
+   * Set handler for errors
+   */
+  onerror = (handler: (error: Error) => void): void => {
+    this.errorHandler = handler;
+  };
+}
+

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

@@ -0,0 +1,480 @@
+// LLM Service for Studio
+// Supports OpenAI and Gemini
+
+export type LLMProvider = 'openai' | 'gemini';
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'tool' | 'system';
+  content: string;
+  toolCalls?: ToolCall[];
+  toolCallId?: string; // For tool responses - the ID of the call being responded to
+  toolName?: string;   // For tool responses - the name of the tool (required by Gemini)
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: any;
+}
+
+export interface ChatResponse {
+  message: ChatMessage;
+  toolCalls?: ToolCall[];
+  finishReason?: string;
+}
+
+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') {
+      return this.chatGemini(messages, tools, apiKey);
+    }
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+
+  private async chatOpenAI(
+    messages: ChatMessage[],
+    tools: any[],
+    apiKey: string
+  ): Promise<ChatResponse> {
+    const formattedMessages = messages.map((msg) => {
+      if (msg.role === 'tool') {
+        return {
+          role: 'tool' as const,
+          content: msg.content,
+          tool_call_id: msg.toolCallId,
+        };
+      }
+
+      // Handle assistant messages with tool calls
+      if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
+        return {
+          role: 'assistant' as const,
+          content: msg.content || null,
+          tool_calls: msg.toolCalls.map(tc => ({
+            id: tc.id,
+            type: 'function' as const,
+            function: {
+              name: tc.name,
+              arguments: typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments),
+            },
+          })),
+        };
+      }
+
+      return {
+        role: msg.role,
+        content: msg.content,
+      };
+    });
+
+    console.log('Formatted messages for OpenAI:', JSON.stringify(formattedMessages, null, 2));
+
+    const requestBody: any = {
+      model: 'gpt-4-turbo-preview',
+      messages: formattedMessages,
+    };
+
+    if (tools.length > 0) {
+      requestBody.tools = tools.map((tool) => {
+        // Clean the schema for OpenAI - remove unsupported properties
+        const cleanSchema = { ...tool.inputSchema };
+
+        // Remove properties that OpenAI doesn't support
+        delete cleanSchema.$schema;
+        delete cleanSchema.additionalProperties;
+
+        // Ensure required properties for OpenAI
+        if (!cleanSchema.type) {
+          cleanSchema.type = 'object';
+        }
+        if (!cleanSchema.properties) {
+          cleanSchema.properties = {};
+        }
+
+        return {
+          type: 'function',
+          function: {
+            name: tool.name,
+            description: tool.description || 'No description provided',
+            parameters: cleanSchema,
+          },
+        };
+      });
+
+      console.log('Sending tools to OpenAI:', JSON.stringify(requestBody.tools, null, 2));
+    }
+
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      console.error('OpenAI API error details:', errorData);
+      throw new Error(`OpenAI API error: ${response.statusText} - ${JSON.stringify(errorData)}`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices[0];
+
+    const result: ChatResponse = {
+      message: {
+        role: 'assistant',
+        content: choice.message.content || '',
+      },
+      finishReason: choice.finish_reason,
+    };
+
+    if (choice.message.tool_calls) {
+      result.toolCalls = choice.message.tool_calls.map((tc: any) => ({
+        id: tc.id,
+        name: tc.function?.name || '',
+        arguments: JSON.parse(tc.function?.arguments || '{}'),
+      }));
+      result.message.toolCalls = result.toolCalls;
+    }
+
+    return result;
+  }
+
+  private async chatGemini(
+    messages: ChatMessage[],
+    tools: any[],
+    apiKey: string
+  ): Promise<ChatResponse> {
+    // Convert messages to Gemini format
+    const contents: any[] = [];
+    let systemInstruction = '';
+
+    // Group consecutive tool messages together for Gemini
+    let i = 0;
+    while (i < messages.length) {
+      const msg = messages[i];
+
+      if (msg.role === 'system') {
+        systemInstruction = msg.content;
+        i++;
+        continue;
+      }
+
+      if (msg.role === 'tool') {
+        // Collect all consecutive tool messages and group them into ONE function response
+        const functionParts: any[] = [];
+
+        while (i < messages.length && messages[i].role === 'tool') {
+          const toolMsg = messages[i];
+          functionParts.push({
+            functionResponse: {
+              name: toolMsg.toolName || 'unknown', // Use toolName for Gemini!
+              response: {
+                content: toolMsg.content,
+              },
+            },
+          });
+          i++;
+        }
+
+        // Add all function responses as ONE entry with multiple parts
+        contents.push({
+          role: 'function',
+          parts: functionParts,
+        });
+      } else if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
+        // Assistant message with tool calls
+        const parts: any[] = [];
+
+        if (msg.content) {
+          parts.push({ text: msg.content });
+        }
+
+        for (const tc of msg.toolCalls) {
+          parts.push({
+            functionCall: {
+              name: tc.name,
+              args: tc.arguments,
+            },
+          });
+        }
+
+        contents.push({
+          role: 'model',
+          parts,
+        });
+        i++;
+      } else {
+        // Regular user or assistant message
+        contents.push({
+          role: msg.role === 'assistant' ? 'model' : 'user',
+          parts: [{ text: msg.content }],
+        });
+        i++;
+      }
+    }
+
+    // console.log('Formatted contents for Gemini:', JSON.stringify(contents, null, 2));
+
+    // Prepare request body
+    const requestBody: any = {
+      contents,
+    };
+
+    // Add system instruction if present
+    if (systemInstruction) {
+      requestBody.systemInstruction = {
+        parts: [{ text: systemInstruction }],
+      };
+    }
+
+    // Add tools if present
+    if (tools.length > 0) {
+      requestBody.tools = [{
+        functionDeclarations: tools.map((tool) => {
+          const cleanSchema = { ...tool.inputSchema };
+
+          // Remove unsupported properties
+          delete cleanSchema.$schema;
+          delete cleanSchema.additionalProperties;
+
+          // Convert to Gemini's expected format
+          const parameters: any = {
+            type: cleanSchema.type || 'OBJECT',
+            properties: {},
+            required: cleanSchema.required || [],
+          };
+
+          // Convert properties
+          if (cleanSchema.properties) {
+            for (const [key, value] of Object.entries(cleanSchema.properties)) {
+              const prop: any = value;
+              parameters.properties[key] = {
+                type: this.convertTypeToGemini(prop.type),
+                description: prop.description || '',
+              };
+
+              // Handle enums
+              if (prop.enum) {
+                parameters.properties[key].enum = prop.enum;
+              }
+            }
+          }
+
+          return {
+            name: tool.name,
+            description: tool.description || 'No description provided',
+            parameters,
+          };
+        }),
+      }];
+
+      // console.log('Sending tools to Gemini:', JSON.stringify(requestBody.tools, null, 2));
+    }
+
+    // Use Gemini 2.0 Flash Experimental (latest model with function calling)
+    // The v1beta API uses 'gemini-2.0-flash-exp' for the newest features
+    const model = 'gemini-2.0-flash-exp';
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(requestBody),
+      }
+    );
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      console.error('Gemini API error details:', errorData);
+      throw new Error(`Gemini API error: ${response.statusText} - ${JSON.stringify(errorData)}`);
+    }
+
+    const data = await response.json();
+    console.log('Gemini response:', JSON.stringify(data, null, 2));
+
+    const candidate = data.candidates?.[0];
+    if (!candidate) {
+      throw new Error('No response from Gemini');
+    }
+
+    const parts = candidate.content?.parts || [];
+
+    // Extract text content
+    let content = '';
+    const toolCalls: ToolCall[] = [];
+
+    for (const part of parts) {
+      if (part.text) {
+        content += part.text;
+      }
+
+      if (part.functionCall) {
+        toolCalls.push({
+          id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          name: part.functionCall.name,
+          arguments: part.functionCall.args || {},
+        });
+      }
+    }
+
+    const result: ChatResponse = {
+      message: {
+        role: 'assistant',
+        content: content || '',
+      },
+      finishReason: candidate.finishReason,
+    };
+
+    if (toolCalls.length > 0) {
+      result.toolCalls = toolCalls;
+      result.message.toolCalls = toolCalls;
+    }
+
+    return result;
+  }
+
+  private convertTypeToGemini(type?: string): string {
+    if (!type) return 'STRING';
+
+    const typeMap: Record<string, string> = {
+      'string': 'STRING',
+      'number': 'NUMBER',
+      'integer': 'INTEGER',
+      'boolean': 'BOOLEAN',
+      'array': 'ARRAY',
+      'object': 'OBJECT',
+    };
+
+    return typeMap[type.toLowerCase()] || 'STRING';
+  }
+}
+