@blaxel/core 0.2.70 → 0.2.71-dev.101

package/dist/esm/agents/index.js

@@ -3,8 +3,7 @@ import { getAgent } from "../client/index.js";
 import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
-import { startSpan } from '../telemetry/telemetry.js';
-class BlAgent {
+export class BlAgent {
     agentName;
     constructor(agentName) {
         this.agentName = agentName;
@@ -54,42 +53,25 @@ class BlAgent {
     }
     async run(input, headers = {}, params = {}) {
         logger.debug(`Agent Calling: ${this.agentName}`);
-        const span = startSpan(this.agentName, {
-            attributes: {
-                "agent.name": this.agentName,
-                "agent.args": JSON.stringify(input),
-                "span.type": "agent.run",
-            },
-            isRoot: false,
-        });
         try {
             const response = await this.call(this.url, input, headers, params);
-            span.setAttribute("agent.run.result", await response.text());
             return await response.text();
         }
         catch (err) {
             if (err instanceof Error) {
                 if (!this.fallbackUrl) {
-                    span.setAttribute("agent.run.error", err.stack);
                     throw err;
                 }
                 try {
                     const response = await this.call(this.fallbackUrl, input, headers, params);
-                    span.setAttribute("agent.run.result", await response.text());
                     return await response.text();
                 }
                 catch (err) {
-                    if (err instanceof Error) {
-                        span.setAttribute("agent.run.error", err.stack);
-                    }
                     throw err;
                 }
             }
             throw err;
         }
-        finally {
-            span.end();
-        }
     }
 }
 export const blAgent = (agentName) => {

package/dist/esm/common/settings.js

@@ -3,8 +3,8 @@ import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
 import { fs, os, path } from "../common/node.js";
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.70";
-const BUILD_COMMIT = "a3bbb13aa4ec149d33f1662d30dfb10ce3683baf";
+const BUILD_VERSION = "0.2.71-dev.101";
+const BUILD_COMMIT = "dccf33c2f51602cd1cd06116b55d326f4645465a";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

package/dist/esm/jobs/jobs.js

@@ -1,40 +1,21 @@
 import { createJobExecution, deleteJobExecution, getJobExecution, listJobExecutions, } from "../client/index.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
-import { startSpan } from "../telemetry/telemetry.js";
-class BlJob {
+export class BlJob {
     jobName;
     constructor(jobName) {
         this.jobName = jobName;
     }
     async run(tasks, options) {
         logger.debug(`Job Calling: ${this.jobName}`);
-        const span = startSpan(this.jobName, {
-            attributes: {
-                "job.name": this.jobName,
-                "span.type": "job.run",
-            },
-            isRoot: false,
-        });
-        try {
-            const request = {
-                tasks,
-                ...(options?.env && { env: options.env }),
-                ...(options?.memory && { memory: options.memory }),
-                ...(options?.executionId && { executionId: options.executionId }),
-            };
-            const executionId = await this.createExecution(request);
-            return executionId;
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                span.setAttribute("job.run.error", err.stack);
-            }
-            throw err;
-        }
-        finally {
-            span.end();
-        }
+        const request = {
+            tasks,
+            ...(options?.env && { env: options.env }),
+            ...(options?.memory && { memory: options.memory }),
+            ...(options?.executionId && { executionId: options.executionId }),
+        };
+        const executionId = await this.createExecution(request);
+        return executionId;
     }
     /**
      * Create a new execution for this job and return the execution ID

package/dist/esm/mcp/server.js

@@ -2,8 +2,6 @@ import { v4 as uuidv4 } from "uuid";
 import WebSocket, { WebSocketServer } from "ws";
 import { env } from "../common/env.js";
 import { logger } from "../common/logger.js";
-import { startSpan } from "../telemetry/telemetry.js";
-const spans = new Map();
 export class BlaxelMcpServerTransport {
     port;
     wss;
@@ -38,26 +36,10 @@ export class BlaxelMcpServerTransport {
                 ws,
             });
             this.onconnection?.(clientId);
-            ws.on("message", (data) => {
-                const span = startSpan("message", {
-                    attributes: {
-                        "mcp.client.id": clientId,
-                        "span.type": "mcp.message",
-                    },
-                    isRoot: false,
-                });
+            ws.on("message", async (data) => {
                 try {
                     const msg = JSON.parse(data.toString());
-                    this.messageHandler?.(msg, clientId);
-                    if ("method" in msg && "id" in msg && "params" in msg) {
-                        span.setAttributes({
-                            "mcp.message.parsed": true,
-                            "mcp.method": msg.method,
-                            "mcp.messageId": msg.id,
-                            "mcp.toolName": msg.params?.name,
-                        });
-                        spans.set(clientId + ":" + msg.id, span);
-                    }
+                    await this.messageHandler?.(msg, clientId);
                     // Handle msg.id safely
                     const msgId = msg.id ? String(msg.id) : "";
                     const [cId, parsedMsgId] = msgId.split(":");
@@ -65,27 +47,7 @@ export class BlaxelMcpServerTransport {
                     // Use optional chaining for safe access
                     const client = this.clients.get(cId ?? "");
                     if (client?.ws?.readyState === WebSocket.OPEN) {
-                        const msgSpan = spans.get(cId + ":" + (msg.id ?? ""));
-                        try {
-                            client.ws.send(JSON.stringify(msg));
-                            if (msgSpan) {
-                                msgSpan.setAttributes({
-                                    "mcp.message.response_sent": true,
-                                });
-                            }
-                        }
-                        catch (err) {
-                            if (msgSpan) {
-                                msgSpan.setStatus("error"); // Error status
-                                msgSpan.recordException(err);
-                            }
-                            throw err;
-                        }
-                        finally {
-                            if (msgSpan) {
-                                msgSpan.end();
-                            }
-                        }
+                        client.ws.send(JSON.stringify(msg));
                     }
                     else {
                         this.clients.delete(cId);
@@ -94,14 +56,11 @@ export class BlaxelMcpServerTransport {
                 }
                 catch (err) {
                     if (err instanceof Error) {
-                        span.setStatus("error"); // Error status
-                        span.recordException(err);
                         this.onerror?.(err);
                     }
                     else {
                         this.onerror?.(new Error(`Failed to parse message: ${String(err)}`));
                     }
-                    span.end();
                 }
             });
             ws.on("close", () => {
@@ -123,27 +82,7 @@ export class BlaxelMcpServerTransport {
             // Send to specific client
             const client = this.clients.get(cId);
             if (client?.ws?.readyState === WebSocket.OPEN) {
-                const msgSpan = spans.get(cId + ":" + msg.id);
-                try {
-                    client.ws.send(data);
-                    if (msgSpan) {
-                        msgSpan.setAttributes({
-                            "mcp.message.response_sent": true,
-                        });
-                    }
-                }
-                catch (err) {
-                    if (msgSpan) {
-                        msgSpan.setStatus("error"); // Error status
-                        msgSpan.recordException(err);
-                    }
-                    throw err;
-                }
-                finally {
-                    if (msgSpan) {
-                        msgSpan.end();
-                    }
-                }
+                client.ws.send(data);
             }
             else {
                 this.clients.delete(cId);

package/dist/esm/tools/index.js

@@ -2,6 +2,7 @@ import { findFromCache } from "../cache/index.js";
 import { getFunction } from "../client/client.js";
 import { getForcedUrl } from "../common/internal.js";
 import { getMcpTool } from "./mcpTool.js";
+export { McpTool } from "./mcpTool.js";
 export const getTool = async (name, options) => {
     return await getMcpTool(name, options);
 };

package/dist/esm/tools/mcpTool.js

@@ -6,7 +6,6 @@ import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { authenticate, SandboxInstance } from "../index.js";
 import { BlaxelMcpClientTransport } from "../mcp/client.js";
-import { startSpan } from "../telemetry/telemetry.js";
 import { schemaToZodSchema } from "./zodSchema.js";
 const McpToolCache = new Map();
 export class McpTool {
@@ -138,47 +137,24 @@ export class McpTool {
         }
     }
     async listTools() {
-        const span = startSpan(this.name, {
-            attributes: {
-                "span.type": "tool.list",
-            },
+        logger.debug(`MCP:${this.name}:Listing tools`);
+        await this.start();
+        const { tools } = (await this.client.listTools());
+        await this.close();
+        const result = tools.map((tool) => {
+            return {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: schemaToZodSchema(tool.inputSchema),
+                originalSchema: tool.inputSchema,
+                call: (input) => {
+                    return this.call(tool.name, input);
+                },
+            };
         });
-        try {
-            logger.debug(`MCP:${this.name}:Listing tools`);
-            await this.start();
-            const { tools } = (await this.client.listTools());
-            await this.close();
-            const result = tools.map((tool) => {
-                return {
-                    name: tool.name,
-                    description: tool.description,
-                    inputSchema: schemaToZodSchema(tool.inputSchema),
-                    originalSchema: tool.inputSchema,
-                    call: (input) => {
-                        return this.call(tool.name, input);
-                    },
-                };
-            });
-            span.setAttribute("tool.list.result", JSON.stringify(result));
-            return result;
-        }
-        catch (err) {
-            span.setStatus("error");
-            span.recordException(err);
-            throw err;
-        }
-        finally {
-            span.end();
-        }
+        return result;
     }
     async call(toolName, args) {
-        const span = startSpan(this.name + "." + toolName, {
-            attributes: {
-                "span.type": "tool.call",
-                "tool.name": toolName,
-                "tool.args": JSON.stringify(args),
-            },
-        });
         try {
             logger.debug(`MCP:${this.name}:Tool calling`, toolName, JSON.stringify(args));
             logger.debug(`MCP:${this.name}:Tool calling:start`);
@@ -192,7 +168,6 @@ export class McpTool {
             logger.debug(`MCP:${this.name}:Tool calling:result`);
             await this.close();
             logger.debug(`MCP:${this.name}:Tool result`, toolName, JSON.stringify(args));
-            span.setAttribute("tool.call.result", JSON.stringify(result));
             return result;
         }
         catch (err) {
@@ -207,9 +182,6 @@ export class McpTool {
             }
             throw err;
         }
-        finally {
-            span.end();
-        }
     }
     async getTransport(forcedUrl) {
         if (!this.transportName) {