@alpic80/rivet-core 1.24.2-aidon.11 → 1.24.2-aidon.13

package/dist/cjs/bundle.cjs

@@ -2925,6 +2925,14 @@ async function chatMessageToOpenAIChatCompletionMessage(message, options2) {
         if (typeof part === "string") {
           return { type: "text", text: part };
         }
+        if (part.type === "file") {
+          return {
+            type: "file",
+            filename: part.filename || "file.pdf",
+            mediaType: part.mediaType,
+            data: part.data.toString()
+          };
+        }
         const url = part.type === "url" ? part.url : `data:${part.mediaType};base64,${await uint8ArrayToBase64(part.data)}`;
         return {
           type: "image_url",
@@ -3008,6 +3016,14 @@ var ChatNodeBase = {
         description: "The endpoint to use for the OpenAI API. You can use this to replace with any OpenAI-compatible API. Leave blank for the default: https://api.openai.com/api/v1/chat/completions"
       });
     }
+    if (data.useApiKeyInput) {
+      inputs.push({
+        dataType: "string",
+        id: "apikey",
+        title: "API Key",
+        description: "The API Key to use for the OpenAI API. You can use this to replace the default OpenAI key in settings. Leave blank for the default key."
+      });
+    }
     inputs.push({
       id: "systemPrompt",
       title: "System Prompt",
@@ -3556,6 +3572,13 @@ var ChatNodeBase = {
             useInputToggleDataKey: "useEndpointInput",
             helperMessage: "The endpoint to use for the OpenAI API. You can use this to replace with any OpenAI-compatible API. Leave blank for the default: https://api.openai.com/api/v1/chat/completions"
           },
+          {
+            type: "string",
+            label: "API Key",
+            dataKey: "apikey",
+            useInputToggleDataKey: "useApiKeyInput",
+            helperMessage: "The API Key to use for the OpenAI API. You can use this to replace the default OpenAI key in settings. Leave blank for the default key."
+          },
           {
             type: "string",
             label: "Custom Model",
@@ -3626,6 +3649,7 @@ var ChatNodeBase = {
     const frequencyPenalty = getInputOrData(data, inputs, "frequencyPenalty", "number");
     const numberOfChoices = getInputOrData(data, inputs, "numberOfChoices", "number");
     const endpoint = getInputOrData(data, inputs, "endpoint");
+    const apiKey = getInputOrData(data, inputs, "apikey");
     const overrideModel = getInputOrData(data, inputs, "overrideModel");
     const seed = getInputOrData(data, inputs, "seed", "number");
     const responseFormat = getInputOrData(data, inputs, "responseFormat");
@@ -3711,6 +3735,7 @@ var ChatNodeBase = {
       ...additionalHeaders,
       ...resolvedEndpointAndHeaders.headers
     });
+    const configuredApiKey = apiKey || context.settings.openAiKey || "";
     let inputTokenCount = 0;
     const tokenizerInfo = {
       node,
@@ -3793,7 +3818,7 @@ var ChatNodeBase = {
           if (isO1Beta || audio) {
             const response = await chatCompletions({
               auth: {
-                apiKey: context.settings.openAiKey ?? "",
+                apiKey: configuredApiKey,
                 organization: context.settings.openAiOrganization
               },
               headers: allAdditionalHeaders,
@@ -3882,7 +3907,7 @@ var ChatNodeBase = {
           }
           const chunks = streamChatCompletions({
             auth: {
-              apiKey: context.settings.openAiKey ?? "",
+              apiKey: configuredApiKey,
               organization: context.settings.openAiOrganization
             },
             headers: allAdditionalHeaders,
@@ -8354,6 +8379,7 @@ var GptFunctionNodeImpl = class extends NodeImpl {
       ["function"]: {
         type: "gpt-function",
         value: {
+          namespace: "internal",
           name,
           description,
           parameters: schema,
@@ -14044,6 +14070,14 @@ Headers: ${this.data.headers}` : "";
       if (!context.mcpProvider) {
         throw new Error("MCP Provider not found");
       }
+      const config = {
+        name,
+        version,
+        transportType,
+        // serverUrl: this.data.serverUrl,
+        serverId: this.data.serverId
+        // headers: this.data.headers?.trim()
+      };
       if (transportType === "http") {
         const serverUrl = getInputOrData(this.data, inputs, "serverUrl", "string");
         if (!serverUrl || serverUrl === "") {
@@ -14068,6 +14102,8 @@ Headers: ${this.data.headers}` : "";
         } else if ((_a = this.data.headers) == null ? void 0 : _a.trim()) {
           headers = JSON.parse(this.data.headers);
         }
+        config.serverUrl = serverUrl;
+        config.headers = headers;
         tools = await context.mcpProvider.getHTTPTools({ name, version }, serverUrl, headers);
         prompts = await context.mcpProvider.getHTTPrompts({ name, version }, serverUrl, headers);
       } else if (transportType === "stdio") {
@@ -14085,9 +14121,11 @@ Headers: ${this.data.headers}` : "";
       }
       const output = {};
       const gptFunctions = tools.map((tool) => ({
+        namespace: "mcp",
         name: tool.name,
         description: tool.description ?? "",
         parameters: tool.inputSchema,
+        config,
         strict: false
       }));
       if (this.data.useToolsOutput) {
@@ -16666,13 +16704,13 @@ var ChatAidonNodeImpl = class extends ChatNodeImpl {
     };
     return chatNode2;
   }
-  removeInvalidInputs(inputs) {
-    if (!inputs["toolSchemas"]) {
-      const { ["functions"]: _, ...rest } = inputs;
-      return rest;
-    }
-    return inputs;
-  }
+  // removeInvalidInputs(inputs: Inputs): Inputs {
+  // 	if (!inputs['toolSchemas' as PortId]) {
+  // 		const { ['functions' as PortId]: _, ...rest } = inputs;
+  // 		return rest;
+  // 	}
+  // 	return inputs;
+  // }
   convertToolSchemaToSchemaDetail(toolSchema) {
     const { name, description, parameters } = toolSchema;
     const { headers, requestInBody, routeMap, url } = parameters;
@@ -16759,42 +16797,164 @@ var ChatAidonNodeImpl = class extends ChatNodeImpl {
     }
     return data;
   }
+  async callOpenApiTool(inputs, functionCall, data) {
+    const toolSchemas = coerceTypeOptional(inputs["toolSchemas"], "gpt-function[]");
+    const toolSchema = toolSchemas.find((detail) => detail.name === functionCall.name);
+    if (!toolSchema) {
+      throw new Error(`Function ${functionCall.name} not found in any schema`);
+    }
+    const schemaDetail = this.convertToolSchemaToSchemaDetail(toolSchema);
+    const path = this.extractPath(schemaDetail, functionCall.name, functionCall.arguments);
+    if (schemaDetail.requestInBody) {
+      data = await this.callToolPost(schemaDetail, path, functionCall.arguments, data);
+    } else {
+      data = await this.callToolGet(schemaDetail, path, functionCall.arguments, data);
+    }
+    return data;
+  }
+  async callMcpTool(context, functionCall, funct, data) {
+    if (funct.config === void 0) {
+      throw new Error(`MCP function ${functionCall.name} is missing MCP configuration`);
+    }
+    const mcpConfig = funct.config;
+    const name = mcpConfig.name;
+    const version = mcpConfig.version;
+    const transportType = mcpConfig.transportType;
+    const toolCall = {
+      name: functionCall.name,
+      arguments: functionCall.arguments
+    };
+    let toolResponse = void 0;
+    try {
+      if (!context.mcpProvider) {
+        throw new Error("MCP Provider not found");
+      }
+      if (transportType === "http") {
+        const serverUrl = mcpConfig.serverUrl;
+        if (!serverUrl || serverUrl === "") {
+          throw new MCPError("SERVER_NOT_FOUND" /* SERVER_NOT_FOUND */, "No server URL was provided");
+        }
+        if (!serverUrl.includes("/mcp")) {
+          throw new MCPError(
+            "SERVER_COMMUNICATION_FAILED" /* SERVER_COMMUNICATION_FAILED */,
+            "Include /mcp in your server URL. For example: http://localhost:8080/mcp"
+          );
+        }
+        const headers = mcpConfig.headers;
+        toolResponse = await context.mcpProvider.httpToolCall({ name, version }, serverUrl, headers, toolCall);
+      } else if (transportType === "stdio") {
+        const serverId = mcpConfig.serverId ?? "";
+        const mcpConfiguration = await loadMCPConfiguration(context);
+        if (!mcpConfiguration.mcpServers[serverId]) {
+          throw new MCPError("SERVER_NOT_FOUND" /* SERVER_NOT_FOUND */, `Server ${serverId} not found in MCP config`);
+        }
+        const serverConfig = {
+          config: mcpConfiguration.mcpServers[serverId],
+          serverId
+        };
+        toolResponse = await context.mcpProvider.stdioToolCall({ name, version }, serverConfig, toolCall);
+      }
+    } catch (err) {
+      const { message } = getError(err);
+      if (context.executor === "browser") {
+        throw new Error("Failed to create Client without a node executor");
+      }
+      console.log(message);
+      throw err;
+    }
+    if (toolResponse) {
+      return toolResponse;
+    } else {
+      return data;
+    }
+  }
+  async callInternalTool(context, functionCall, data) {
+    let handler;
+    const matchingGraph = Object.values(context.project.graphs).find(
+      (graph) => {
+        var _a, _b;
+        return (_b = (_a = graph.metadata) == null ? void 0 : _a.name) == null ? void 0 : _b.includes("Tools/" + functionCall.name);
+      }
+    );
+    if (matchingGraph) {
+      handler = { key: void 0, value: matchingGraph.metadata.id };
+    }
+    if (!handler) {
+      throw new Error(`No handler found for tool call: ${functionCall.name}`);
+    }
+    const subgraphInputs = {
+      _function_name: {
+        type: "string",
+        value: functionCall.name
+      },
+      _arguments: {
+        type: "object",
+        value: functionCall.arguments
+      }
+    };
+    for (const [argName, argument] of Object.entries(functionCall.arguments ?? {})) {
+      subgraphInputs[argName] = {
+        type: "any",
+        value: argument
+      };
+    }
+    const handlerGraphId = handler.value;
+    const subprocessor = context.createSubProcessor(handlerGraphId, { signal: context.signal });
+    data = await subprocessor.processGraph(context, subgraphInputs, context.contextValues);
+    return data;
+  }
   // Override the process function
   async process(inputs, context) {
-    inputs = this.removeInvalidInputs(inputs);
     let outputs = await super.process(inputs, context);
-    const funcCallOutput = outputs["function-call"] ?? outputs["function-calls"];
-    const funcCalls = (funcCallOutput == null ? void 0 : funcCallOutput.type) === "object[]" ? funcCallOutput.value : void 0;
-    if (funcCalls !== void 0) {
-      const messages = outputs["all-messages"];
-      const toolSchemas = coerceTypeOptional(inputs["toolSchemas"], "gpt-function[]");
+    let messages = outputs["all-messages"];
+    let iterations = 0;
+    const maxIterations = 20;
+    while (true) {
+      if (iterations >= maxIterations) {
+        throw new Error(`Max tool call iterations (${maxIterations}) exceeded`);
+      }
+      const funcCallOutput = outputs["function-call"] ?? outputs["function-calls"];
+      const funcCalls = (funcCallOutput == null ? void 0 : funcCallOutput.type) === "object[]" ? funcCallOutput.value : void 0;
+      if (!funcCalls)
+        break;
+      console.log(`Need to call ${funcCalls.length} tools this iteration...`);
+      iterations++;
+      const functions = coerceTypeOptional(inputs["functions"], "gpt-function[]");
       const functionCalls = funcCalls.map((functionCall) => ({
         name: functionCall.name,
         arguments: functionCall.arguments,
         id: functionCall.id
       }));
       for (const functionCall of functionCalls) {
-        const toolSchema = toolSchemas.find((detail) => detail.name === functionCall.name);
-        if (!toolSchema) {
-          throw new Error(`Function ${functionCall.name} not found in any schema`);
+        const funct = functions.find((fctn) => fctn.name === functionCall.name);
+        if (!funct) {
+          throw new Error(`Function ${functionCall.name} not found in functions input`);
         }
-        const schemaDetail = this.convertToolSchemaToSchemaDetail(toolSchema);
-        const path = this.extractPath(schemaDetail, functionCall.name, functionCall.arguments);
         let data = {};
-        if (schemaDetail.requestInBody) {
-          data = await this.callToolPost(schemaDetail, path, functionCall.arguments, data);
-        } else {
-          data = await this.callToolGet(schemaDetail, path, functionCall.arguments, data);
+        console.log(`Calling tool ${functionCall.name} in namespace ${funct.namespace}...`);
+        switch (funct.namespace) {
+          case "openapi":
+            data = await this.callOpenApiTool(inputs, functionCall, data);
+            break;
+          case "mcp":
+            data = await this.callMcpTool(context, functionCall, funct, data);
+            break;
+          case "internal":
+          default:
+            data = await this.callInternalTool(context, functionCall, data);
+            break;
         }
+        console.log(`Tool call result for	${functionCall.name} is ${JSON.stringify(data)}...`);
         messages["value"].push({
           type: "function",
-          name: functionCall.id,
+          name: functionCall.id ?? functionCall.name,
           message: JSON.stringify(data)
         });
       }
-      inputs = (0, import_lodash_es18.omit)(inputs, ["functions", "prompt"]);
+      inputs = (0, import_lodash_es18.omit)(inputs, ["prompt"]);
       inputs["prompt"] = messages;
       outputs = await super.process(inputs, context);
+      messages = outputs["all-messages"];
     }
     return outputs;
   }
@@ -17928,6 +18088,8 @@ async function chatMessageContentToClaude3ChatMessage(content) {
       };
     case "url":
       throw new Error("unable to convert urls for Claude");
+    case "file":
+      throw new Error("unable to convert files for Claude");
     case "document":
       return {
         type: "document",