@voltagent/core 0.1.73 → 0.1.74

package/dist/index.js

@@ -9997,8 +9997,8 @@ var TelemetryServiceApiClient = class {
       );
     }
   }
-  async request(method, path3, body) {
-    const url = `${this.baseUrl}${path3}`;
+  async request(method, path4, body) {
+    const url = `${this.baseUrl}${path4}`;
     const headers = {
       "Content-Type": "application/json",
       "x-public-key": this.publicKey,
@@ -12651,11 +12651,14 @@ ${retrieverContext}`;
       options.parentAgentId,
       options.parentHistoryEntryId
     );
+    const userContextToUse = options.parentOperationContext?.userContext || options.userContext || this.defaultUserContext;
+    const userContextObject = userContextToUse ? Object.fromEntries(userContextToUse.entries()) : {};
     const methodLogger = contextualLogger.child({
       userId: options.userId,
       conversationId: options.conversationId,
       executionId: historyEntry.id,
       operationName: options.operationName,
+      userContext: userContextObject,
       // Preserve parent execution ID if present in contextual logger
       ...options.parentHistoryEntryId && {
         parentExecutionId: options.parentHistoryEntryId
@@ -12663,7 +12666,7 @@ ${retrieverContext}`;
     });
     const opContext = {
       operationId: historyEntry.id,
-      userContext: (options.parentOperationContext?.userContext || options.userContext || this.defaultUserContext) ?? /* @__PURE__ */ new Map(),
+      userContext: userContextToUse ?? /* @__PURE__ */ new Map(),
       historyEntry,
       isActive: true,
       parentAgentId: options.parentAgentId,
@@ -15847,6 +15850,8 @@ var MCPConfiguration = class {
 };
 
 // src/server/api.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path4 = __toESM(require("path"));
 var import_swagger_ui = require("@hono/swagger-ui");
 var import_zod_openapi3 = require("@hono/zod-openapi");
 var import_cors = require("hono/cors");
@@ -17973,6 +17978,88 @@ app.post("/updates/:packageName", async (c) => {
     );
   }
 });
+app.post("/setup-observability", async (c) => {
+  try {
+    const body = await c.req.json();
+    const { publicKey, secretKey } = body;
+    if (!publicKey || !secretKey) {
+      return c.json(
+        {
+          success: false,
+          error: "Missing publicKey or secretKey"
+        },
+        400
+      );
+    }
+    const envPath = import_node_path4.default.join(process.cwd(), ".env");
+    try {
+      let envContent = "";
+      try {
+        envContent = await import_promises.default.readFile(envPath, "utf-8");
+      } catch (_error) {
+        logger.debug(".env file not found, will create new one");
+      }
+      const lines = envContent.split("\n");
+      let publicKeyUpdated = false;
+      let secretKeyUpdated = false;
+      const updatedLines = lines.map((line) => {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith("# VOLTAGENT_PUBLIC_KEY=")) {
+          publicKeyUpdated = true;
+          return `VOLTAGENT_PUBLIC_KEY=${publicKey}`;
+        }
+        if (trimmedLine.startsWith("# VOLTAGENT_SECRET_KEY=")) {
+          secretKeyUpdated = true;
+          return `VOLTAGENT_SECRET_KEY=${secretKey}`;
+        }
+        return line;
+      });
+      envContent = updatedLines.join("\n");
+      if (!publicKeyUpdated || !secretKeyUpdated) {
+        if (!envContent.endsWith("\n") && envContent.length > 0) {
+          envContent += "\n";
+        }
+        if (!publicKeyUpdated && !secretKeyUpdated) {
+          envContent += `
+# VoltAgent Observability
+VOLTAGENT_PUBLIC_KEY=${publicKey}
+VOLTAGENT_SECRET_KEY=${secretKey}
+`;
+        } else if (!publicKeyUpdated) {
+          envContent += `VOLTAGENT_PUBLIC_KEY=${publicKey}
+`;
+        } else if (!secretKeyUpdated) {
+          envContent += `VOLTAGENT_SECRET_KEY=${secretKey}
+`;
+        }
+      }
+      await import_promises.default.writeFile(envPath, envContent);
+      logger.info("Observability configuration updated in .env file");
+      return c.json({
+        success: true,
+        message: "Observability configured successfully. Please restart your application."
+      });
+    } catch (error) {
+      logger.error("Failed to update .env file:", { error });
+      return c.json(
+        {
+          success: false,
+          error: "Failed to update .env file"
+        },
+        500
+      );
+    }
+  } catch (error) {
+    logger.error("Failed to setup observability:", { error });
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to setup observability"
+      },
+      500
+    );
+  }
+});
 app.doc("/doc", {
   openapi: "3.1.0",
   info: {
@@ -17985,25 +18072,25 @@ app.doc("/doc", {
 function registerCustomEndpoint(endpoint) {
   try {
     const validatedEndpoint = validateCustomEndpoint(endpoint);
-    const { path: path3, method, handler } = validatedEndpoint;
+    const { path: path4, method, handler } = validatedEndpoint;
     switch (method) {
       case "get":
-        app.get(path3, handler);
+        app.get(path4, handler);
         break;
       case "post":
-        app.post(path3, handler);
+        app.post(path4, handler);
         break;
       case "put":
-        app.put(path3, handler);
+        app.put(path4, handler);
         break;
       case "patch":
-        app.patch(path3, handler);
+        app.patch(path4, handler);
         break;
       case "delete":
-        app.delete(path3, handler);
+        app.delete(path4, handler);
         break;
       case "options":
-        app.options(path3, handler);
+        app.options(path4, handler);
         break;
       default:
         throw new CustomEndpointError(`Unsupported HTTP method: ${method}`);
@@ -18029,25 +18116,25 @@ function registerCustomEndpoints(endpoints) {
       return;
     }
     for (const endpoint of validatedEndpoints) {
-      const { path: path3, method, handler } = endpoint;
+      const { path: path4, method, handler } = endpoint;
       switch (method) {
         case "get":
-          app.get(path3, handler);
+          app.get(path4, handler);
           break;
         case "post":
-          app.post(path3, handler);
+          app.post(path4, handler);
           break;
         case "put":
-          app.put(path3, handler);
+          app.put(path4, handler);
           break;
         case "patch":
-          app.patch(path3, handler);
+          app.patch(path4, handler);
           break;
         case "delete":
-          app.delete(path3, handler);
+          app.delete(path4, handler);
           break;
         case "options":
-          app.options(path3, handler);
+          app.options(path4, handler);
           break;
         default:
           throw new CustomEndpointError(`Unsupported HTTP method: ${method}`);
@@ -18363,9 +18450,9 @@ var printServerStartup = /* @__PURE__ */ __name((port, config) => {
     const methodOrder = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
     methodOrder.forEach((method) => {
       if (methodGroups[method]) {
-        methodGroups[method].forEach((path3) => {
+        methodGroups[method].forEach((path4) => {
           console.log(
-            `${colors.dim}    ${method.padEnd(6)} ${colors.reset}${colors.white}${path3}${colors.reset}`
+            `${colors.dim}    ${method.padEnd(6)} ${colors.reset}${colors.white}${path4}${colors.reset}`
           );
         });
       }
@@ -18419,8 +18506,8 @@ var startServer = /* @__PURE__ */ __name(async (config) => {
       const ws = createWebSocketServer();
       server.addListener("upgrade", (req, socket, head) => {
         const url = new URL(req.url || "", "http://localhost");
-        const path3 = url.pathname;
-        if (path3.startsWith("/ws")) {
+        const path4 = url.pathname;
+        if (path4.startsWith("/ws")) {
           ws.handleUpgrade(req, socket, head, (websocket) => {
             ws.emit("connection", websocket, req);
           });
@@ -18449,6 +18536,15 @@ var startServer = /* @__PURE__ */ __name(async (config) => {
   );
 }, "startServer");
 
+// src/utils/voltops-validation.ts
+function isValidVoltOpsKeys(publicKey, secretKey) {
+  if (!publicKey || !secretKey) {
+    return false;
+  }
+  return publicKey.startsWith("pk_") && secretKey.startsWith("sk_");
+}
+__name(isValidVoltOpsKeys, "isValidVoltOpsKeys");
+
 // src/voltagent.ts
 var isTelemetryInitializedByVoltAgent = false;
 var registeredProvider = null;
@@ -18477,7 +18573,8 @@ var VoltAgent = class {
     }
     if (options.logger) {
       this.registry.setGlobalLogger(options.logger);
-    } else if (options.telemetryExporter) {
+    }
+    if (options.telemetryExporter) {
       this.logger.warn(
         `\u26A0\uFE0F  DEPRECATION WARNING: 'telemetryExporter' parameter is deprecated!
         
@@ -18501,6 +18598,26 @@ https://voltagent.dev/docs/observability/developer-console/#migration-guide-from
       }
       this.initializeGlobalTelemetry(options.telemetryExporter);
     }
+    if (!options.voltOpsClient && !options.telemetryExporter) {
+      const publicKey = process.env.VOLTAGENT_PUBLIC_KEY;
+      const secretKey = process.env.VOLTAGENT_SECRET_KEY;
+      if (publicKey && secretKey && isValidVoltOpsKeys(publicKey, secretKey)) {
+        try {
+          const autoClient = new VoltOpsClient({
+            publicKey,
+            secretKey
+          });
+          this.registry.setGlobalVoltOpsClient(autoClient);
+          if (autoClient.observability) {
+            this.registry.setGlobalVoltAgentExporter(autoClient.observability);
+            this.initializeGlobalTelemetry(autoClient.observability);
+          }
+          this.logger.debug("VoltOpsClient auto-configured from environment variables");
+        } catch (error) {
+          this.logger.debug("Could not auto-configure VoltOpsClient", { error });
+        }
+      }
+    }
     this.registerAgents(options.agents);
     if (options.workflows) {
       this.registerWorkflows(options.workflows);