@blaxel/core 0.2.70 → 0.2.71-dev.105

package/dist/cjs-browser/tools/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToolMetadata = exports.blTool = exports.blTools = exports.BLTools = exports.getTool = void 0;
+exports.getToolMetadata = exports.blTool = exports.blTools = exports.BLTools = exports.getTool = exports.McpTool = void 0;
 const index_js_1 = require("../cache/index.js");
 const client_js_1 = require("../client/client.js");
 const internal_js_1 = require("../common/internal.js");
 const mcpTool_js_1 = require("./mcpTool.js");
+var mcpTool_js_2 = require("./mcpTool.js");
+Object.defineProperty(exports, "McpTool", { enumerable: true, get: function () { return mcpTool_js_2.McpTool; } });
 const getTool = async (name, options) => {
     return await (0, mcpTool_js_1.getMcpTool)(name, options);
 };

package/dist/cjs-browser/tools/mcpTool.js

@@ -9,7 +9,6 @@ const logger_js_1 = require("../common/logger.js");
 const settings_js_1 = require("../common/settings.js");
 const index_js_2 = require("../index.js");
 const client_js_1 = require("../mcp/client.js");
-const telemetry_js_1 = require("../telemetry/telemetry.js");
 const zodSchema_js_1 = require("./zodSchema.js");
 const McpToolCache = new Map();
 class McpTool {
@@ -141,47 +140,24 @@ class McpTool {
         }
     }
     async listTools() {
-        const span = (0, telemetry_js_1.startSpan)(this.name, {
-            attributes: {
-                "span.type": "tool.list",
-            },
+        logger_js_1.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: (0, zodSchema_js_1.schemaToZodSchema)(tool.inputSchema),
+                originalSchema: tool.inputSchema,
+                call: (input) => {
+                    return this.call(tool.name, input);
+                },
+            };
         });
-        try {
-            logger_js_1.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: (0, zodSchema_js_1.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 = (0, telemetry_js_1.startSpan)(this.name + "." + toolName, {
-            attributes: {
-                "span.type": "tool.call",
-                "tool.name": toolName,
-                "tool.args": JSON.stringify(args),
-            },
-        });
         try {
             logger_js_1.logger.debug(`MCP:${this.name}:Tool calling`, toolName, JSON.stringify(args));
             logger_js_1.logger.debug(`MCP:${this.name}:Tool calling:start`);
@@ -195,7 +171,6 @@ class McpTool {
             logger_js_1.logger.debug(`MCP:${this.name}:Tool calling:result`);
             await this.close();
             logger_js_1.logger.debug(`MCP:${this.name}:Tool result`, toolName, JSON.stringify(args));
-            span.setAttribute("tool.call.result", JSON.stringify(result));
             return result;
         }
         catch (err) {
@@ -210,9 +185,6 @@ class McpTool {
             }
             throw err;
         }
-        finally {
-            span.end();
-        }
     }
     async getTransport(forcedUrl) {
         if (!this.transportName) {

package/dist/cjs-browser/types/agents/index.d.ts

@@ -1,5 +1,5 @@
 import { Agent } from "../client/index.js";
-declare class BlAgent {
+export declare class BlAgent {
     agentName: string;
     constructor(agentName: string);
     get fallbackUrl(): import("url").URL | null;
@@ -12,4 +12,3 @@ declare class BlAgent {
 }
 export declare const blAgent: (agentName: string) => BlAgent;
 export declare const getAgentMetadata: (agent: string) => Promise<Agent | null>;
-export {};

package/dist/cjs-browser/types/common/autoload.d.ts

@@ -1,3 +1,8 @@
 import { Config } from "./settings.js";
 export declare function initialize(config: Config): void;
 export declare function authenticate(): Promise<void>;
+/**
+ * Close all pooled H2 connections. Call this for explicit cleanup
+ * (e.g. in test teardown or before process exit).
+ */
+export declare function closeConnections(): Promise<void>;

package/dist/cjs-browser/types/common/h2fetch.d.ts

@@ -0,0 +1,22 @@
+import http2 from "http2";
+import type { h2Pool as H2PoolType } from "./h2pool.js";
+/**
+ * Creates a fetch()-compatible function that sends requests over an existing
+ * HTTP/2 session. Falls back to global fetch() if the session is closed,
+ * destroyed, or if the H2 request times out.
+ */
+export declare function createH2Fetch(session: http2.ClientHttp2Session): (input: Request) => Promise<Response>;
+/**
+ * Creates a fetch()-compatible function backed by the H2 session pool.
+ *
+ * Non-blocking: checks the pool cache synchronously. If a warm session is
+ * available it's used immediately; otherwise the request goes through
+ * regular fetch with zero delay (the pool keeps warming in the background
+ * so subsequent calls get H2).
+ */
+export declare function createPoolBackedH2Fetch(pool: typeof H2PoolType, domain: string): (input: Request) => Promise<Response>;
+/**
+ * Low-level H2 request that takes raw URL + init, skipping Request construction.
+ * Used by SandboxAction.h2Fetch() for direct calls from subsystems.
+ */
+export declare function h2RequestDirect(session: http2.ClientHttp2Session, url: string, init?: RequestInit): Promise<Response>;

package/dist/cjs-browser/types/common/h2pool.d.ts

@@ -0,0 +1,38 @@
+import type http2 from "http2";
+/**
+ * Singleton H2 session pool keyed by edge domain.
+ *
+ * - `warm(domain)` starts a background connection (fire-and-forget).
+ * - `get(domain)` returns a live session immediately if cached, or awaits
+ *   an in-flight warming, or establishes a fresh one.
+ * - Closed / destroyed sessions are automatically evicted.
+ */
+declare class H2Pool {
+    private sessions;
+    private inflight;
+    private _establish;
+    /**
+     * Lazily resolve the establish function so the http2 / tls / dns modules
+     * are only imported in Node.js environments.
+     */
+    private establish;
+    /**
+     * Fire-and-forget background warming. Safe to call multiple times for
+     * the same domain — only one connection attempt per domain at a time.
+     */
+    warm(domain: string): void;
+    /**
+     * Synchronous cache check. Returns a live cached session or `null`.
+     * Never blocks, never establishes — use for non-blocking fast paths.
+     */
+    tryGet(domain: string): http2.ClientHttp2Session | null;
+    /**
+     * Get a live H2 session for `domain`. Returns immediately from cache,
+     * joins an in-flight warming, or starts a new one.
+     */
+    get(domain: string): Promise<http2.ClientHttp2Session | null>;
+    /** Close all sessions (for cleanup). */
+    closeAll(): void;
+}
+export declare const h2Pool: H2Pool;
+export {};

package/dist/cjs-browser/types/common/h2warm.d.ts

@@ -0,0 +1,2 @@
+import http2 from "http2";
+export declare function establishH2(sniHostname: string): Promise<http2.ClientHttp2Session>;

package/dist/cjs-browser/types/jobs/jobs.d.ts

@@ -1,5 +1,5 @@
 import { CreateJobExecutionRequest, JobExecution } from "../client/index.js";
-declare class BlJob {
+export declare class BlJob {
     jobName: string;
     constructor(jobName: string);
     run(tasks: Record<string, unknown>[], options?: {
@@ -39,4 +39,3 @@ declare class BlJob {
     }): Promise<JobExecution>;
 }
 export declare const blJob: (jobName: string) => BlJob;
-export {};

package/dist/cjs-browser/types/sandbox/action.d.ts

@@ -1,3 +1,4 @@
+import { type Client } from "@hey-api/client-fetch";
 import { SandboxConfiguration } from "./types.js";
 export declare class ResponseError extends Error {
     response: Response;
@@ -7,12 +8,18 @@ export declare class ResponseError extends Error {
 }
 export declare class SandboxAction {
     protected sandbox: SandboxConfiguration;
+    private _h2Client;
     constructor(sandbox: SandboxConfiguration);
     get name(): string;
     get fallbackUrl(): string | null;
     get externalUrl(): string;
     get internalUrl(): string;
-    get client(): import("@hey-api/client-fetch").Client;
+    get client(): Client;
+    /**
+     * Routes through the H2 session when available, falling back to
+     * globalThis.fetch. Uses a direct H2 path that avoids Request allocation.
+     */
+    protected h2Fetch(input: string | URL, init?: RequestInit): Promise<Response>;
     get forcedUrl(): string | import("url").URL | null;
     get url(): string;
     handleResponseError(response: Response, data: unknown, error: unknown): void;

package/dist/cjs-browser/types/sandbox/client/types.gen.d.ts

@@ -137,9 +137,16 @@ export type ProcessRequest = {
     env?: {
         [key: string]: string;
     };
+    /**
+     * Disable scale-to-zero while process runs. Default timeout is 600s (10 minutes). Set timeout to 0 for infinite.
+     */
+    keepAlive?: boolean;
     maxRestarts?: number;
     name?: string;
     restartOnFailure?: boolean;
+    /**
+     * Timeout in seconds. When keepAlive is true, defaults to 600s (10 minutes). Set to 0 for infinite (no auto-kill).
+     */
     timeout?: number;
     waitForCompletion?: boolean;
     waitForPorts?: Array<number>;
@@ -149,6 +156,10 @@ export type ProcessResponse = {
     command: string;
     completedAt: string;
     exitCode: number;
+    /**
+     * Whether scale-to-zero is disabled for this process
+     */
+    keepAlive?: boolean;
     logs: string;
     maxRestarts?: number;
     name: string;

package/dist/cjs-browser/types/sandbox/interpreter.d.ts

@@ -12,6 +12,7 @@ export declare class CodeInterpreter extends SandboxInstance {
         safe?: boolean;
     }): Promise<CodeInterpreter>;
     get _jupyterUrl(): string;
+    private _fetch;
     static OutputMessage: {
         new (text: string, timestamp: number | null, isStderr: boolean): {
             text: string;

package/dist/cjs-browser/types/sandbox/sandbox.d.ts

@@ -18,12 +18,18 @@ export declare class SandboxInstance {
     codegen: SandboxCodegen;
     system: SandboxSystem;
     drives: SandboxDrive;
+    h2Session: any;
     constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata;
     get status(): import("../client/types.gen.js").Status | undefined;
     get events(): import("../client/types.gen.js").CoreEvents | undefined;
     get spec(): import("../client/types.gen.js").SandboxSpec;
     get lastUsedAt(): string | undefined;
+    /**
+     * Warm and attach an H2 session based on the sandbox's region.
+     * Shared by create(), get(), list(), and update helpers.
+     */
+    private static attachH2Session;
     get expiresIn(): number | undefined;
     wait({ maxWait, interval }?: {
         maxWait?: number;

package/dist/cjs-browser/types/sandbox/types.d.ts

@@ -1,3 +1,4 @@
+import type http2 from "http2";
 import { Port, Sandbox, SandboxLifecycle, VolumeAttachment, SandboxNetwork } from "../client/types.gen";
 import { PostProcessResponse, ProcessRequest } from "./client";
 export interface SessionCreateOptions {
@@ -24,6 +25,7 @@ export type SandboxConfiguration = {
     forceUrl?: string;
     headers?: Record<string, string>;
     params?: Record<string, string>;
+    h2Session?: http2.ClientHttp2Session | null;
 } & Sandbox;
 export type SandboxUpdateMetadata = {
     labels?: Record<string, string>;

package/dist/cjs-browser/types/tools/index.d.ts

@@ -1,6 +1,7 @@
 import { Function } from "../client/client.js";
 import { ToolOptions } from "./mcpTool.js";
 import { Tool } from "./types.js";
+export { McpTool } from "./mcpTool.js";
 export type { ToolOptions };
 export declare const getTool: (name: string, options?: number | ToolOptions) => Promise<Tool[]>;
 export declare class BLTools {