@mimik/agent-kit 1.0.0

package/src/mcp-server.js

@@ -0,0 +1,290 @@
+/* eslint-disable no-plusplus */
+
+class MCPServer {
+  constructor(httpClient, proxyEndpoint, apiKey, options = {}) {
+    this.http = httpClient;
+    this.endpoint = proxyEndpoint;
+    this.apiKey = apiKey;
+    this.requestId = 1;
+    this.initialized = false;
+    
+    // Tool whitelist configuration
+    this.toolWhitelist = options.toolWhitelist || null; // null means all tools allowed
+    this.whitelistMode = options.whitelistMode || 'include'; // 'include' or 'exclude'
+  }
+
+  // Set tool whitelist after construction
+  setToolWhitelist(whitelist, mode = 'include') {
+    this.toolWhitelist = whitelist;
+    this.whitelistMode = mode;
+  }
+
+  // Clear tool whitelist (allow all tools)
+  clearToolWhitelist() {
+    this.toolWhitelist = null;
+    this.whitelistMode = 'include';
+  }
+
+  // Helper method to filter tools based on whitelist
+  filterToolsByWhitelist(tools) {
+    if (!this.toolWhitelist || !Array.isArray(this.toolWhitelist)) {
+      return tools;
+    }
+
+    if (this.whitelistMode === 'exclude') {
+      // Exclude mode: remove tools that are in the whitelist
+      return tools.filter(tool => !this.toolWhitelist.includes(tool.name));
+    } else {
+      // Include mode (default): only include tools that are in the whitelist
+      return tools.filter(tool => this.toolWhitelist.includes(tool.name));
+    }
+  }
+
+  // Helper method to check if a tool is allowed
+  isToolAllowed(toolName) {
+    if (!this.toolWhitelist || !Array.isArray(this.toolWhitelist)) {
+      return true;
+    }
+
+    if (this.whitelistMode === 'exclude') {
+      return !this.toolWhitelist.includes(toolName);
+    } else {
+      return this.toolWhitelist.includes(toolName);
+    }
+  }
+
+  // Helper method to make JSON-RPC requests
+  async makeRequest(method, params = null) {
+    return new Promise((resolve, reject) => {
+      const request = {
+        jsonrpc: '2.0',
+        id: this.requestId++,
+        method,
+        ...(params && { params }),
+      };
+
+      this.http.request({
+        url: this.endpoint,
+        type: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': this.apiKey && `bearer ${this.apiKey}`,
+        },
+        data: request,
+        success: (result) => {
+          try {
+            const json = JSON.parse(result.data);
+            resolve(json);
+          } catch (err) {
+            reject(new Error(err.message || 'MCP Error'));
+          }
+        },
+        error: (err) => {
+          reject(err);
+        },
+      });
+    });
+  }
+
+  // Initialize the MCP connection
+  async initialize(clientInfo = null) {
+    if (this.initialized) {
+      return null;
+    }
+
+    const params = {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: clientInfo || { name: 'http-mcp-client', version: '1.0.0' },
+    };
+
+    const response = await this.makeRequest('initialize', params);
+    this.initialized = true;
+    return response;
+  }
+
+  // List available tools (filtered by whitelist)
+  async listTools() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const response = await this.makeRequest('tools/list');
+    
+    // Apply whitelist filtering
+    if (response.result && response.result.tools) {
+      response.result.tools = this.filterToolsByWhitelist(response.result.tools);
+    }
+    
+    return response.result;
+  }
+
+  // Get raw tools list without whitelist filtering
+  async listAllTools() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const response = await this.makeRequest('tools/list');
+    return response.result;
+  }
+
+  // Call a specific tool (with whitelist check)
+  async callTool({ name, arguments: args }) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    // Check if tool is allowed by whitelist
+    if (!this.isToolAllowed(name)) {
+      throw new Error(`Tool '${name}' is not allowed by the current whitelist configuration`);
+    }
+
+    const params = {
+      name,
+      arguments: args || {},
+    };
+
+    const response = await this.makeRequest('tools/call', params);
+    return response.result;
+  }
+
+  // List available resources
+  async listResources() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const response = await this.makeRequest('resources/list');
+    return response.result;
+  }
+
+  // Read a resource
+  async readResource(uri) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const params = { uri };
+    const response = await this.makeRequest('resources/read', params);
+    return response.result;
+  }
+
+  // List available prompts
+  async listPrompts() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const response = await this.makeRequest('prompts/list');
+    return response.result;
+  }
+
+  // Get a prompt
+  async getPrompt(name, args = {}) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const params = {
+      name,
+      arguments: args,
+    };
+
+    const response = await this.makeRequest('prompts/get', params);
+    return response.result;
+  }
+
+  // Generic method to call any MCP method
+  async call(method, params = null) {
+    if (!this.initialized && method !== 'initialize') {
+      await this.initialize();
+    }
+
+    return this.makeRequest(method, params);
+  }
+
+  // Get whitelist configuration info
+  getWhitelistInfo() {
+    return {
+      whitelist: this.toolWhitelist,
+      mode: this.whitelistMode,
+      isActive: this.toolWhitelist !== null && Array.isArray(this.toolWhitelist)
+    };
+  }
+}
+
+// Convert MCP tools to OpenAI function format (respects whitelist)
+function convertMCPToolsToOpenAI(mcpTools, toolWhitelist = null, whitelistMode = 'include') {
+  let toolsToConvert = mcpTools;
+
+  // Apply whitelist filtering if provided
+  if (toolWhitelist && Array.isArray(toolWhitelist)) {
+    if (whitelistMode === 'exclude') {
+      toolsToConvert = mcpTools.filter(tool => !toolWhitelist.includes(tool.name));
+    } else {
+      toolsToConvert = mcpTools.filter(tool => toolWhitelist.includes(tool.name));
+    }
+  }
+
+  const converted = toolsToConvert.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema || {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+  }));
+
+  // this.log('🔄 Converted MCP tools to OpenAI format', {
+  //   originalCount: mcpTools.length,
+  //   filteredCount: toolsToConvert.length,
+  //   convertedCount: converted.length,
+  //   tools: converted.map(t => t.function.name),
+  //   whitelist: toolWhitelist,
+  //   whitelistMode: whitelistMode
+  // });
+
+  return converted;
+}
+
+// Usage example:
+/*
+const mcpClient = new MCPClient(http, 'http://localhost:3000/mcp');
+
+// Example usage:
+async function example() {
+  try {
+    // Initialize (optional - will auto-initialize on first call)
+    await mcpClient.initialize();
+
+    // List tools
+    const toolsResult = await mcpClient.listTools();
+    console.log('Available tools:', toolsResult);
+
+    // Call a tool
+    const result = await mcpClient.callTool({
+      name: 'add',
+      arguments: { a: 5, b: 3 }
+    });
+    console.log('Tool result:', result);
+
+    // List resources
+    const resources = await mcpClient.listResources();
+    console.log('Available resources:', resources);
+
+    // Read a resource
+    const resourceContent = await mcpClient.readResource('file://example.txt');
+    console.log('Resource content:', resourceContent);
+
+  } catch (error) {
+    console.error('MCP Error:', error);
+  }
+}
+*/
+
+module.exports = { MCPServer, convertMCPToolsToOpenAI };

package/src/oai.js

@@ -0,0 +1,205 @@
+/* eslint-disable no-await-in-loop, no-loop-func, no-plusplus, no-continue */
+
+// Parse SSE (Server-Sent Events) data
+function parseSSEChunk(rawData) {
+  if (typeof rawData !== 'string') {
+    return null;
+  }
+
+  // Split by double newlines to separate SSE messages
+  const messages = rawData.split('\n\n');
+  const parsedMessages = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i].trim();
+    if (!message) continue;
+
+    const lines = message.split('\n');
+    let data = null;
+    let eventType = null;
+    let id = null;
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith('data: ')) {
+        data = trimmedLine.substring(6).trim();
+      } else if (trimmedLine.startsWith('event: ')) {
+        eventType = trimmedLine.substring(7).trim();
+      } else if (trimmedLine.startsWith('id: ')) {
+        id = trimmedLine.substring(4).trim();
+      }
+    }
+
+    if (data !== null) {
+      // Handle special SSE termination message (comes as: data: [DONE])
+      if (data === '[DONE]') {
+        parsedMessages.push({ type: 'done', data: '[DONE]' });
+      } else {
+        try {
+          // Try to parse as JSON
+          const jsonData = JSON.parse(data);
+          parsedMessages.push({
+            type: 'data',
+            data: jsonData,
+            event: eventType,
+            id,
+            raw: data,
+          });
+        } catch (e) {
+          // If not valid JSON, return as raw data
+          parsedMessages.push({
+            type: 'data',
+            data,
+            event: eventType,
+            id,
+            raw: data,
+          });
+        }
+      }
+    }
+  }
+
+  return parsedMessages.length > 0 ? parsedMessages : null;
+}
+
+// Alternative implementation using a more direct approach with queues
+async function* createChatCompletionStream(context, body, genAiChatUri, genAiApiKey, stream = true) {
+  const { http } = context;
+
+  let headers;
+  if (genAiApiKey) {
+    headers = { authorization: genAiApiKey };
+  }
+
+  // Use a queue-based approach
+  const chunkQueue = [];
+  let streamEnded = false;
+  let streamError = null;
+  let resolveNext = null;
+  let sseBuffer = ''; // Buffer for incomplete SSE messages
+
+  const streamCb = {
+    ondata: (result) => {
+      if (stream && result.data) {
+        // Handle SSE parsing
+        sseBuffer += result.data;
+
+        // Check if we have complete SSE messages (ending with \n\n)
+        if (sseBuffer.includes('\n\n')) {
+          const parts = sseBuffer.split('\n\n');
+
+          // Process all complete messages (all parts except the last one)
+          for (let i = 0; i < parts.length - 1; i++) {
+            const completeMessage = `${parts[i]}\n\n`;
+
+            const parsed = parseSSEChunk(completeMessage);
+            if (parsed) {
+              for (const message of parsed) {
+                chunkQueue.push(message);
+              }
+            }
+          }
+
+          // Keep the last part (potentially incomplete) in buffer
+          sseBuffer = parts[parts.length - 1];
+        }
+      } else {
+        // Non-SSE data, push as-is
+        chunkQueue.push(result);
+      }
+
+      if (resolveNext) {
+        resolveNext();
+        resolveNext = null;
+      }
+    },
+    onend: (result) => {
+      // Process any remaining buffer content
+      if (stream && sseBuffer.length > 0) {
+        // Add \n\n if not present to make it a complete message
+        const finalMessage = sseBuffer.endsWith('\n\n') ? sseBuffer : `${sseBuffer}\n\n`;
+        const parsed = parseSSEChunk(finalMessage);
+        if (parsed) {
+          for (const message of parsed) {
+            chunkQueue.push(message);
+          }
+        }
+        sseBuffer = '';
+      }
+
+      if (result) {
+        chunkQueue.push(result);
+      }
+      streamEnded = true;
+      if (resolveNext) {
+        resolveNext();
+        resolveNext = null;
+      }
+    },
+    onerror: (err) => {
+      streamError = err;
+      if (resolveNext) {
+        resolveNext();
+        resolveNext = null;
+      }
+    },
+  };
+
+  // Start the request
+  const requestPromise = new Promise((resolve, reject) => {
+    http.request({
+      url: genAiChatUri,
+      type: 'POST',
+      headers,
+      data: body,
+      mode: 'stream',
+      success: (result) => {
+        if (result.done === undefined) {
+          streamCb.onend(result);
+        } else if (result.done === true) {
+          streamCb.onend();
+        } else if (result.done === false) {
+          streamCb.ondata(result);
+        }
+        resolve();
+      },
+      error: (err) => {
+        streamCb.onerror(err);
+        reject(err);
+      },
+    });
+  });
+
+  // Start the request (don't await it, let it run in background)
+  requestPromise.catch(() => { }); // Handle errors through streamError
+
+  // Yield chunks as they arrive
+  while (true) {
+    if (streamError) {
+      throw streamError;
+    }
+
+    if (chunkQueue.length > 0) {
+      const chunk = chunkQueue.shift();
+
+      // Always yield the chunk first
+      yield chunk;
+
+      // THEN check if this was the termination message and break AFTER yielding
+      if (stream && chunk.type === 'done' && chunk.data === '[DONE]') {
+        // Stream is complete, break out of the loop
+        break;
+      }
+    } else if (streamEnded) {
+      // No more chunks and stream is ended
+      break;
+    } else {
+      // Wait for next chunk
+      await new Promise((resolve) => {
+        resolveNext = resolve;
+      });
+    }
+  }
+}
+
+module.exports = { createChatCompletionStream, parseSSEChunk };