@superatomai/sdk-node 0.0.18 → 0.0.19

package/dist/index.js

@@ -2947,6 +2947,8 @@ var promptLoader = new PromptLoader({
 // src/llm.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var import_groq_sdk = __toESM(require("groq-sdk"));
+var import_generative_ai = require("@google/generative-ai");
+var import_openai = __toESM(require("openai"));
 var import_jsonrepair = require("jsonrepair");
 var LLM = class {
   /* Get a complete text response from an LLM (Anthropic or Groq) */
@@ -2956,8 +2958,12 @@ var LLM = class {
       return this._anthropicText(messages, modelName, options);
     } else if (provider === "groq") {
       return this._groqText(messages, modelName, options);
+    } else if (provider === "gemini") {
+      return this._geminiText(messages, modelName, options);
+    } else if (provider === "openai") {
+      return this._openaiText(messages, modelName, options);
     } else {
-      throw new Error(`Unsupported provider: ${provider}. Use "anthropic" or "groq"`);
+      throw new Error(`Unsupported provider: ${provider}. Use "anthropic", "groq", "gemini", or "openai"`);
     }
   }
   /* Stream response from an LLM (Anthropic or Groq) */
@@ -2967,17 +2973,26 @@ var LLM = class {
       return this._anthropicStream(messages, modelName, options, json);
     } else if (provider === "groq") {
       return this._groqStream(messages, modelName, options, json);
+    } else if (provider === "gemini") {
+      return this._geminiStream(messages, modelName, options, json);
+    } else if (provider === "openai") {
+      return this._openaiStream(messages, modelName, options, json);
     } else {
-      throw new Error(`Unsupported provider: ${provider}. Use "anthropic" or "groq"`);
+      throw new Error(`Unsupported provider: ${provider}. Use "anthropic", "groq", "gemini", or "openai"`);
     }
   }
-  /* Stream response with tool calling support (Anthropic only for now) */
+  /* Stream response with tool calling support (Anthropic and Gemini) */
   static async streamWithTools(messages, tools, toolHandler, options = {}, maxIterations = 3) {
     const [provider, modelName] = this._parseModel(options.model);
-    if (provider !== "anthropic") {
-      throw new Error(`Tool calling is only supported for Anthropic models`);
+    if (provider === "anthropic") {
+      return this._anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+    } else if (provider === "gemini") {
+      return this._geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+    } else if (provider === "openai") {
+      return this._openaiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+    } else {
+      throw new Error(`Tool calling is only supported for Anthropic, Gemini, and OpenAI models`);
     }
-    return this._anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
   }
   // ============================================================
   // PRIVATE HELPER METHODS
@@ -3311,6 +3326,298 @@ var LLM = class {
     return fullText;
   }
   // ============================================================
+  // GEMINI IMPLEMENTATION
+  // ============================================================
+  static async _geminiText(messages, modelName, options) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
+    const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const model = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemPrompt,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        topP: options.topP
+      }
+    });
+    const result = await model.generateContent(messages.user);
+    const response = await result.response;
+    return response.text();
+  }
+  static async _geminiStream(messages, modelName, options, json) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
+    const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const model = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemPrompt,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        topP: options.topP,
+        responseMimeType: json ? "application/json" : void 0
+      }
+    });
+    const result = await model.generateContentStream(messages.user);
+    let fullText = "";
+    for await (const chunk of result.stream) {
+      const text = chunk.text();
+      if (text) {
+        fullText += text;
+        if (options.partial) {
+          options.partial(text);
+        }
+      }
+    }
+    if (json) {
+      return this._parseJSON(fullText);
+    }
+    return fullText;
+  }
+  static async _geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
+    const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const functionDeclarations = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: import_generative_ai.SchemaType.OBJECT,
+        properties: tool.input_schema.properties,
+        required: tool.input_schema.required || []
+      }
+    }));
+    const model = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemPrompt,
+      tools: [{ functionDeclarations }],
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 4e3,
+        temperature: options.temperature,
+        topP: options.topP
+      }
+    });
+    const chat = model.startChat({
+      history: []
+    });
+    let iterations = 0;
+    let finalText = "";
+    let currentUserMessage = messages.user;
+    while (iterations < maxIterations) {
+      iterations++;
+      const result = await chat.sendMessageStream(currentUserMessage);
+      let responseText = "";
+      const functionCalls = [];
+      for await (const chunk of result.stream) {
+        const candidate = chunk.candidates?.[0];
+        if (!candidate) continue;
+        for (const part of candidate.content?.parts || []) {
+          if (part.text) {
+            responseText += part.text;
+            if (options.partial) {
+              options.partial(part.text);
+            }
+          } else if (part.functionCall) {
+            functionCalls.push({
+              name: part.functionCall.name,
+              args: part.functionCall.args
+            });
+          }
+        }
+      }
+      if (functionCalls.length === 0) {
+        finalText = responseText;
+        break;
+      }
+      const functionResponses = [];
+      for (const fc of functionCalls) {
+        try {
+          const result2 = await toolHandler(fc.name, fc.args);
+          functionResponses.push({
+            name: fc.name,
+            response: { result: typeof result2 === "string" ? result2 : JSON.stringify(result2) }
+          });
+        } catch (error) {
+          functionResponses.push({
+            name: fc.name,
+            response: { error: error instanceof Error ? error.message : String(error) }
+          });
+        }
+      }
+      const functionResponseParts = functionResponses.map((fr) => ({
+        functionResponse: {
+          name: fr.name,
+          response: fr.response
+        }
+      }));
+      currentUserMessage = functionResponseParts;
+    }
+    if (iterations >= maxIterations) {
+      throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
+    }
+    return finalText;
+  }
+  // ============================================================
+  // OPENAI IMPLEMENTATION
+  // ============================================================
+  static async _openaiText(messages, modelName, options) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    const openai = new import_openai.default({ apiKey });
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const response = await openai.chat.completions.create({
+      model: modelName,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: messages.user }
+      ],
+      max_tokens: options.maxTokens || 1e3,
+      temperature: options.temperature,
+      top_p: options.topP
+    });
+    return response.choices[0]?.message?.content || "";
+  }
+  static async _openaiStream(messages, modelName, options, json) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    const openai = new import_openai.default({ apiKey });
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const stream = await openai.chat.completions.create({
+      model: modelName,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: messages.user }
+      ],
+      max_tokens: options.maxTokens || 1e3,
+      temperature: options.temperature,
+      top_p: options.topP,
+      response_format: json ? { type: "json_object" } : void 0,
+      stream: true
+    });
+    let fullText = "";
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || "";
+      if (content) {
+        fullText += content;
+        if (options.partial) {
+          options.partial(content);
+        }
+      }
+    }
+    if (json) {
+      return this._parseJSON(fullText);
+    }
+    return fullText;
+  }
+  static async _openaiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    const openai = new import_openai.default({ apiKey });
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const openaiTools = tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: tool.input_schema.type,
+          properties: tool.input_schema.properties,
+          required: tool.input_schema.required || []
+        }
+      }
+    }));
+    const conversationMessages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: messages.user }
+    ];
+    let iterations = 0;
+    let finalText = "";
+    while (iterations < maxIterations) {
+      iterations++;
+      const stream = await openai.chat.completions.create({
+        model: modelName,
+        messages: conversationMessages,
+        max_tokens: options.maxTokens || 4e3,
+        temperature: options.temperature,
+        top_p: options.topP,
+        tools: openaiTools,
+        stream: true
+      });
+      let responseText = "";
+      const toolCalls = [];
+      const toolCallsInProgress = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          responseText += delta.content;
+          if (options.partial) {
+            options.partial(delta.content);
+          }
+        }
+        if (delta?.tool_calls) {
+          for (const toolCallDelta of delta.tool_calls) {
+            const index = toolCallDelta.index;
+            if (!toolCallsInProgress.has(index)) {
+              toolCallsInProgress.set(index, {
+                id: toolCallDelta.id || "",
+                name: toolCallDelta.function?.name || "",
+                arguments: ""
+              });
+            }
+            const tc = toolCallsInProgress.get(index);
+            if (toolCallDelta.id) {
+              tc.id = toolCallDelta.id;
+            }
+            if (toolCallDelta.function?.name) {
+              tc.name = toolCallDelta.function.name;
+            }
+            if (toolCallDelta.function?.arguments) {
+              tc.arguments += toolCallDelta.function.arguments;
+            }
+          }
+        }
+      }
+      for (const tc of toolCallsInProgress.values()) {
+        if (tc.id && tc.name) {
+          toolCalls.push(tc);
+        }
+      }
+      if (toolCalls.length === 0) {
+        finalText = responseText;
+        break;
+      }
+      conversationMessages.push({
+        role: "assistant",
+        content: responseText || null,
+        tool_calls: toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: tc.arguments
+          }
+        }))
+      });
+      for (const tc of toolCalls) {
+        let result;
+        try {
+          const args = JSON.parse(tc.arguments);
+          const toolResult = await toolHandler(tc.name, args);
+          result = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
+        } catch (error) {
+          result = JSON.stringify({ error: error instanceof Error ? error.message : String(error) });
+        }
+        conversationMessages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: result
+        });
+      }
+    }
+    if (iterations >= maxIterations) {
+      throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
+    }
+    return finalText;
+  }
+  // ============================================================
   // JSON PARSING HELPER
   // ============================================================
   /**
@@ -4599,18 +4906,56 @@ var AnthropicLLM = class extends BaseLLM {
 };
 var anthropicLLM = new AnthropicLLM();
 
-// src/userResponse/index.ts
+// src/userResponse/gemini.ts
 var import_dotenv3 = __toESM(require("dotenv"));
 import_dotenv3.default.config();
+var GeminiLLM = class extends BaseLLM {
+  constructor(config) {
+    super(config);
+  }
+  getDefaultModel() {
+    return "gemini/gemini-2.5-flash";
+  }
+  getDefaultApiKey() {
+    return process.env.GEMINI_API_KEY;
+  }
+  getProviderName() {
+    return "Gemini";
+  }
+};
+var geminiLLM = new GeminiLLM();
+
+// src/userResponse/openai.ts
+var import_dotenv4 = __toESM(require("dotenv"));
+import_dotenv4.default.config();
+var OpenAILLM = class extends BaseLLM {
+  constructor(config) {
+    super(config);
+  }
+  getDefaultModel() {
+    return "openai/gpt-4.1";
+  }
+  getDefaultApiKey() {
+    return process.env.OPENAI_API_KEY;
+  }
+  getProviderName() {
+    return "OpenAI";
+  }
+};
+var openaiLLM = new OpenAILLM();
+
+// src/userResponse/index.ts
+var import_dotenv5 = __toESM(require("dotenv"));
+import_dotenv5.default.config();
 function getLLMProviders() {
   const envProviders = process.env.LLM_PROVIDERS;
-  const DEFAULT_PROVIDERS = ["anthropic", "groq"];
+  const DEFAULT_PROVIDERS = ["anthropic", "gemini", "openai", "groq"];
   if (!envProviders) {
     return DEFAULT_PROVIDERS;
   }
   try {
     const providers = JSON.parse(envProviders);
-    const validProviders = providers.filter((p) => p === "anthropic" || p === "groq");
+    const validProviders = providers.filter((p) => p === "anthropic" || p === "groq" || p === "gemini" || p === "openai");
     if (validProviders.length === 0) {
       return DEFAULT_PROVIDERS;
     }
@@ -4653,10 +4998,44 @@ var useGroqMethod = async (prompt, components, apiKey, logCollector, conversatio
   logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
   return matchResult;
 };
+var useGeminiMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  logger.debug("[useGeminiMethod] Initializing Gemini LLM matching method");
+  logger.debug(`[useGeminiMethod] Response mode: ${responseMode}`);
+  const msg = `Using Gemini LLM ${responseMode === "text" ? "text response" : "matching"} method...`;
+  logger.info(msg);
+  logCollector?.info(msg);
+  if (responseMode === "component" && components.length === 0) {
+    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useGeminiMethod] No components available");
+    logCollector?.error(emptyMsg);
+    return { success: false, errors: [emptyMsg] };
+  }
+  logger.debug(`[useGeminiMethod] Processing with ${components.length} components`);
+  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useGeminiMethod] Successfully generated ${responseMode} using Gemini`);
+  return matchResult;
+};
+var useOpenAIMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  logger.debug("[useOpenAIMethod] Initializing OpenAI GPT matching method");
+  logger.debug(`[useOpenAIMethod] Response mode: ${responseMode}`);
+  const msg = `Using OpenAI GPT ${responseMode === "text" ? "text response" : "matching"} method...`;
+  logger.info(msg);
+  logCollector?.info(msg);
+  if (responseMode === "component" && components.length === 0) {
+    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useOpenAIMethod] No components available");
+    logCollector?.error(emptyMsg);
+    return { success: false, errors: [emptyMsg] };
+  }
+  logger.debug(`[useOpenAIMethod] Processing with ${components.length} components`);
+  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useOpenAIMethod] Successfully generated ${responseMode} using OpenAI`);
+  return matchResult;
+};
 var getUserResponseFromCache = async (prompt) => {
   return false;
 };
-var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   logger.debug(`[get_user_response] Starting user response generation for prompt: "${prompt.substring(0, 50)}..."`);
   logger.debug(`[get_user_response] Response mode: ${responseMode}`);
   logger.debug("[get_user_response] Checking cache for existing response");
@@ -4692,6 +5071,10 @@ var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey,
       result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else if (provider === "groq") {
       result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "gemini") {
+      result = await useGeminiMethod(prompt, components, geminiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "openai") {
+      result = await useOpenAIMethod(prompt, components, openaiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else {
       logger.warn(`[get_user_response] Unknown provider: ${provider} - skipping`);
       errors.push(`Unknown provider: ${provider}`);
@@ -5036,7 +5419,7 @@ var CONTEXT_CONFIG = {
 };
 
 // src/handlers/user-prompt-request.ts
-var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections, externalTools, userId) => {
+var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId) => {
   const errors = [];
   logger.debug("[USER_PROMPT_REQ] Parsing incoming message data");
   const parseResult = UserPromptRequestMessageSchema.safeParse(data);
@@ -5111,6 +5494,8 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     components,
     anthropicApiKey,
     groqApiKey,
+    geminiApiKey,
+    openaiApiKey,
     llmProviders,
     logCollector,
     conversationHistory,
@@ -5209,8 +5594,8 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     wsId
   };
 };
-async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections, externalTools, userId) {
-  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections, externalTools, userId);
+async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId) {
+  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId);
   sendDataResponse4(
     response.id || data.id,
     {
@@ -5337,13 +5722,13 @@ function sendResponse(id, res, sendMessage, clientId) {
 }
 
 // src/userResponse/next-questions.ts
-async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory) {
+async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory) {
   try {
     logger.debug("[generateNextQuestions] Starting next questions generation");
     logger.debug(`[generateNextQuestions] User prompt: "${originalUserPrompt?.substring(0, 50)}..."`);
     logger.debug(`[generateNextQuestions] Component: ${component?.name || "unknown"} (${component?.type || "unknown"})`);
     logger.debug(`[generateNextQuestions] Component data available: ${componentData ? "yes" : "no"}`);
-    const providers = llmProviders || ["anthropic"];
+    const providers = llmProviders || ["anthropic", "gemini", "openai", "groq"];
     logger.info(`[generateNextQuestions] Using LLM providers: [${providers.join(", ")}]`);
     if (conversationHistory && conversationHistory.length > 0) {
       const exchangeCount = conversationHistory.split("\n").filter((l) => l.startsWith("Q")).length;
@@ -5368,6 +5753,26 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             logCollector,
             conversationHistory
           );
+        } else if (provider === "gemini") {
+          logger.debug("[generateNextQuestions] Using Gemini LLM for next questions");
+          result = await geminiLLM.generateNextQuestions(
+            originalUserPrompt,
+            component,
+            componentData,
+            geminiApiKey,
+            logCollector,
+            conversationHistory
+          );
+        } else if (provider === "openai") {
+          logger.debug("[generateNextQuestions] Using OpenAI LLM for next questions");
+          result = await openaiLLM.generateNextQuestions(
+            originalUserPrompt,
+            component,
+            componentData,
+            openaiApiKey,
+            logCollector,
+            conversationHistory
+          );
         } else {
           logger.debug("[generateNextQuestions] Using Anthropic LLM for next questions");
           result = await anthropicLLM.generateNextQuestions(
@@ -5418,7 +5823,7 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
 }
 
 // src/handlers/actions-request.ts
-async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
+async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders) {
   try {
     logger.debug("[ACTIONS_REQ] Parsing incoming actions request");
     const actionsRequest = ActionsRequestMessageSchema.parse(data);
@@ -5490,6 +5895,8 @@ ${conversationHistory.substring(0, 200)}...`);
         componentData,
         anthropicApiKey,
         groqApiKey,
+        geminiApiKey,
+        openaiApiKey,
         llmProviders,
         logCollector,
         conversationHistory
@@ -7364,7 +7771,10 @@ var SuperatomSDK = class {
     this.url = config.url || process.env.SA_WEBSOCKET_URL || DEFAULT_WS_URL;
     this.anthropicApiKey = config.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY || "";
     this.groqApiKey = config.GROQ_API_KEY || process.env.GROQ_API_KEY || "";
+    this.geminiApiKey = config.GEMINI_API_KEY || process.env.GEMINI_API_KEY || "";
+    this.openaiApiKey = config.OPENAI_API_KEY || process.env.OPENAI_API_KEY || "";
     this.llmProviders = config.LLM_PROVIDERS || getLLMProviders();
+    logger.info(`Initializing Superatom SDK v${SDK_VERSION} for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, config llm providers: ${config.LLM_PROVIDERS}`);
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
@@ -7449,7 +7859,9 @@ var SuperatomSDK = class {
     return new Promise((resolve, reject) => {
       try {
         const url = new URL(this.url);
-        url.searchParams.set("apiKey", this.apiKey);
+        if (this.apiKey) {
+          url.searchParams.set("apiKey", this.apiKey);
+        }
         url.searchParams.set("projectId", this.projectId);
         url.searchParams.set("userId", this.userId);
         url.searchParams.set("type", this.type);
@@ -7508,12 +7920,12 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_REQ":
-          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.llmProviders, this.collections, this.tools, this.userId).catch((error) => {
+          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.userId).catch((error) => {
             logger.error("Failed to handle user prompt request:", error);
           });
           break;
         case "ACTIONS":
-          handleActionsRequest(parsed, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.llmProviders).catch((error) => {
+          handleActionsRequest(parsed, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders).catch((error) => {
             logger.error("Failed to handle actions request:", error);
           });
           break;