@blaxel/core 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/esm/client/types.gen.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+// This file is auto-generated by @hey-api/openapi-ts
+export {};

package/dist/esm/common/autoload.js

@@ -0,0 +1,23 @@
+import { client } from "../client/client.gen.js";
+import { interceptors } from "../client/interceptors.js";
+import { client as clientSandbox } from "../sandbox/client/client.gen.js";
+import { settings } from "./settings.js";
+client.setConfig({
+    baseUrl: settings.baseUrl,
+});
+for (const interceptor of interceptors) {
+    // @ts-expect-error - Interceptor is not typed
+    client.interceptors.request.use(interceptor);
+    // @ts-expect-error - Interceptor is not typed
+    clientSandbox.interceptors.request.use(interceptor);
+}
+// Allow to set custom configuration for browser environment
+export function initialize(config) {
+    settings.setConfig(config);
+    client.setConfig({
+        baseUrl: settings.baseUrl,
+    });
+}
+export function authenticate() {
+    return settings.authenticate();
+}

package/dist/esm/common/env.js

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import toml from "toml";
+import { dotenv, fs } from "./node.js";
+const secretEnv = {};
+const configEnv = {};
+if (fs !== null && dotenv !== null) {
+    try {
+        const configFile = fs.readFileSync("blaxel.toml", "utf8");
+        const configInfos = toml.parse(configFile);
+        for (const key in configInfos.env) {
+            configEnv[key] = configInfos.env[key];
+        }
+    }
+    catch (error) { }
+    try {
+        const secretFile = fs.readFileSync(".env", "utf8");
+        const parsed = dotenv.parse(secretFile);
+        Object.assign(secretEnv, parsed);
+    }
+    catch (error) { }
+}
+const env = new Proxy({}, {
+    get: (target, prop) => {
+        if (secretEnv[prop]) {
+            return secretEnv[prop];
+        }
+        if (configEnv[prop]) {
+            return configEnv[prop];
+        }
+        if (typeof process !== "undefined" && process.env) {
+            return process.env[prop];
+        }
+        return undefined;
+    },
+});
+export { env };

package/dist/esm/common/errors.js

@@ -0,0 +1,14 @@
+export function handleDynamicImportError(err) {
+    if (err instanceof Error) {
+        // We check if it's module import error and retrieve package name from the error message with a regex
+        if (err.message.includes("Cannot find module")) {
+            const packageName = err.message.match(/Cannot find module '([^']+)'/)?.[1];
+            if (packageName) {
+                err.message = `Dependency not found. Please run one of the following commands to install it:
+- npm: 'npm install ${packageName}'
+- yarn: 'yarn add ${packageName}'
+- pnpm: 'pnpm add ${packageName}'`;
+            }
+        }
+    }
+}

package/dist/esm/common/internal.js

@@ -0,0 +1,182 @@
+/* eslint-disable */
+import { env } from './env.js';
+// Pure JS MD5 implementation that matches standard crypto MD5
+function md5(input) {
+    function cmn(q, a, b, x, s, t) {
+        a = (((a + q) | 0) + ((x + t) | 0)) | 0;
+        return (((a << s) | (a >>> (32 - s))) + b) | 0;
+    }
+    function ff(a, b, c, d, x, s, t) {
+        return cmn((b & c) | (~b & d), a, b, x, s, t);
+    }
+    function gg(a, b, c, d, x, s, t) {
+        return cmn((b & d) | (c & ~d), a, b, x, s, t);
+    }
+    function hh(a, b, c, d, x, s, t) {
+        return cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+    function ii(a, b, c, d, x, s, t) {
+        return cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+    function md5cycle(x, k) {
+        let [a, b, c, d] = x;
+        a = ff(a, b, c, d, k[0], 7, -680876936);
+        d = ff(d, a, b, c, k[1], 12, -389564586);
+        c = ff(c, d, a, b, k[2], 17, 606105819);
+        b = ff(b, c, d, a, k[3], 22, -1044525330);
+        a = ff(a, b, c, d, k[4], 7, -176418897);
+        d = ff(d, a, b, c, k[5], 12, 1200080426);
+        c = ff(c, d, a, b, k[6], 17, -1473231341);
+        b = ff(b, c, d, a, k[7], 22, -45705983);
+        a = ff(a, b, c, d, k[8], 7, 1770035416);
+        d = ff(d, a, b, c, k[9], 12, -1958414417);
+        c = ff(c, d, a, b, k[10], 17, -42063);
+        b = ff(b, c, d, a, k[11], 22, -1990404162);
+        a = ff(a, b, c, d, k[12], 7, 1804603682);
+        d = ff(d, a, b, c, k[13], 12, -40341101);
+        c = ff(c, d, a, b, k[14], 17, -1502002290);
+        b = ff(b, c, d, a, k[15], 22, 1236535329);
+        a = gg(a, b, c, d, k[1], 5, -165796510);
+        d = gg(d, a, b, c, k[6], 9, -1069501632);
+        c = gg(c, d, a, b, k[11], 14, 643717713);
+        b = gg(b, c, d, a, k[0], 20, -373897302);
+        a = gg(a, b, c, d, k[5], 5, -701558691);
+        d = gg(d, a, b, c, k[10], 9, 38016083);
+        c = gg(c, d, a, b, k[15], 14, -660478335);
+        b = gg(b, c, d, a, k[4], 20, -405537848);
+        a = gg(a, b, c, d, k[9], 5, 568446438);
+        d = gg(d, a, b, c, k[14], 9, -1019803690);
+        c = gg(c, d, a, b, k[3], 14, -187363961);
+        b = gg(b, c, d, a, k[8], 20, 1163531501);
+        a = gg(a, b, c, d, k[13], 5, -1444681467);
+        d = gg(d, a, b, c, k[2], 9, -51403784);
+        c = gg(c, d, a, b, k[7], 14, 1735328473);
+        b = gg(b, c, d, a, k[12], 20, -1926607734);
+        a = hh(a, b, c, d, k[5], 4, -378558);
+        d = hh(d, a, b, c, k[8], 11, -2022574463);
+        c = hh(c, d, a, b, k[11], 16, 1839030562);
+        b = hh(b, c, d, a, k[14], 23, -35309556);
+        a = hh(a, b, c, d, k[1], 4, -1530992060);
+        d = hh(d, a, b, c, k[4], 11, 1272893353);
+        c = hh(c, d, a, b, k[7], 16, -155497632);
+        b = hh(b, c, d, a, k[10], 23, -1094730640);
+        a = hh(a, b, c, d, k[13], 4, 681279174);
+        d = hh(d, a, b, c, k[0], 11, -358537222);
+        c = hh(c, d, a, b, k[3], 16, -722521979);
+        b = hh(b, c, d, a, k[6], 23, 76029189);
+        a = hh(a, b, c, d, k[9], 4, -640364487);
+        d = hh(d, a, b, c, k[12], 11, -421815835);
+        c = hh(c, d, a, b, k[15], 16, 530742520);
+        b = hh(b, c, d, a, k[2], 23, -995338651);
+        a = ii(a, b, c, d, k[0], 6, -198630844);
+        d = ii(d, a, b, c, k[7], 10, 1126891415);
+        c = ii(c, d, a, b, k[14], 15, -1416354905);
+        b = ii(b, c, d, a, k[5], 21, -57434055);
+        a = ii(a, b, c, d, k[12], 6, 1700485571);
+        d = ii(d, a, b, c, k[3], 10, -1894986606);
+        c = ii(c, d, a, b, k[10], 15, -1051523);
+        b = ii(b, c, d, a, k[1], 21, -2054922799);
+        a = ii(a, b, c, d, k[8], 6, 1873313359);
+        d = ii(d, a, b, c, k[15], 10, -30611744);
+        c = ii(c, d, a, b, k[6], 15, -1560198380);
+        b = ii(b, c, d, a, k[13], 21, 1309151649);
+        a = ii(a, b, c, d, k[4], 6, -145523070);
+        d = ii(d, a, b, c, k[11], 10, -1120210379);
+        c = ii(c, d, a, b, k[2], 15, 718787259);
+        b = ii(b, c, d, a, k[9], 21, -343485551);
+        x[0] = (a + x[0]) | 0;
+        x[1] = (b + x[1]) | 0;
+        x[2] = (c + x[2]) | 0;
+        x[3] = (d + x[3]) | 0;
+    }
+    function md5blk(s) {
+        const md5blks = [];
+        for (let i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] =
+                s.charCodeAt(i) +
+                    (s.charCodeAt(i + 1) << 8) +
+                    (s.charCodeAt(i + 2) << 16) +
+                    (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+    function md51(s) {
+        let n = s.length, state = [1732584193, -271733879, -1732584194, 271733878], i;
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        const tail = Array(16).fill(0);
+        for (i = 0; i < s.length; i++)
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            tail.fill(0);
+        }
+        tail[14] = n * 8;
+        md5cycle(state, tail);
+        return state;
+    }
+    // Fixed hex conversion function
+    function rhex(n) {
+        let s = '';
+        for (let j = 0; j < 4; j++) {
+            s += ((n >> (j * 8)) & 0xFF).toString(16).padStart(2, '0');
+        }
+        return s;
+    }
+    return md51(input).map(rhex).join('');
+}
+export function getAlphanumericLimitedHash(input, maxSize = 48) {
+    const hash = md5(input);
+    return hash.length > maxSize ? hash.substring(0, maxSize) : hash;
+}
+export function getGlobalUniqueHash(workspace, type, name) {
+    const globalUniqueName = `${workspace}-${type}-${name}`;
+    return getAlphanumericLimitedHash(globalUniqueName, 48);
+}
+export function pluralize(type) {
+    const word = type.toLowerCase();
+    // Words ending in s, ss, sh, ch, x, z - add 'es'
+    if (word.endsWith('s') || word.endsWith('ss') || word.endsWith('sh') ||
+        word.endsWith('ch') || word.endsWith('x') || word.endsWith('z')) {
+        return type + 'es';
+    }
+    // Words ending in consonant + y - change y to ies
+    if (word.endsWith('y') && word.length > 1) {
+        const beforeY = word[word.length - 2];
+        if (!'aeiou'.includes(beforeY)) {
+            return type.slice(0, -1) + 'ies';
+        }
+    }
+    // Words ending in f or fe - change to ves
+    if (word.endsWith('f')) {
+        return type.slice(0, -1) + 'ves';
+    }
+    if (word.endsWith('fe')) {
+        return type.slice(0, -2) + 'ves';
+    }
+    // Words ending in consonant + o - add 'es'
+    if (word.endsWith('o') && word.length > 1) {
+        const beforeO = word[word.length - 2];
+        if (!'aeiou'.includes(beforeO)) {
+            return type + 'es';
+        }
+    }
+    // Default case - just add 's'
+    return type + 's';
+}
+export function getForcedUrl(type, name) {
+    const pluralType = pluralize(type);
+    const envVar = name.replace(/-/g, "_").toUpperCase();
+    // BL_FUNCTIONS_NAME_URL
+    if (env[`BL_${pluralType.toUpperCase()}_${envVar}_URL`]) {
+        return new URL(env[`BL_${pluralType.toUpperCase()}_${envVar}_URL`]);
+    }
+    // BL_FUNCTION_NAME_URL
+    if (env[`BL_${type.toUpperCase()}_${envVar}_URL`]) {
+        return new URL(env[`BL_${type.toUpperCase()}_${envVar}_URL`]);
+    }
+    return null;
+}

package/dist/esm/common/internal.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { getAlphanumericLimitedHash, getGlobalUniqueHash } from "./internal.js";
+describe('getAlphanumericLimitedHash', () => {
+    it('returns correct MD5 hash for a known string', () => {
+        // MD5 of 'hello' is 5d41402abc4b2a76b9719d911017c592
+        expect(getAlphanumericLimitedHash('hello')).toBe('5d41402abc4b2a76b9719d911017c592');
+    });
+    it('respects the maxSize parameter', () => {
+        const hash = getAlphanumericLimitedHash('hello', 8);
+        expect(hash.length).toBe(8);
+        expect(hash).toBe('5d41402a');
+    });
+    it('returns full hash if maxSize is larger than hash', () => {
+        const hash = getAlphanumericLimitedHash('hello', 64);
+        expect(hash).toBe('5d41402abc4b2a76b9719d911017c592');
+    });
+});
+const testCases = [
+    {
+        workspace: 'charlou-dev',
+        type: 'function',
+        name: 'blaxel-search',
+        expected: '594d9322779f4a07a55a7bf1050360c6'
+    }, {
+        workspace: 'charlou-dev',
+        type: 'agent',
+        name: 'toto',
+        expected: '1bb3a151bda194751b062df8edb59eaf',
+    }
+];
+describe('getGlobalUniqueHash', () => {
+    testCases.forEach(({ workspace, type, name, expected }) => {
+        it(`returns ${expected} for ${workspace}-${type}-${name}`, () => {
+            expect(getGlobalUniqueHash(workspace, type, name)).toBe(expected);
+        });
+    });
+});

package/dist/esm/common/logger.js

@@ -0,0 +1,65 @@
+/**
+ * Stringify an object with a limited depth
+ * @param obj The object to stringify
+ * @param maxDepth Maximum depth (default: 1)
+ * @param depth Current depth (internal use)
+ */
+export function stringify(obj, maxDepth = 1, depth = 0) {
+    if (obj instanceof Error)
+        return obj.stack || obj.message;
+    if (obj === null)
+        return 'null';
+    if (obj === undefined)
+        return 'undefined';
+    // If we've reached max depth or it's not an object
+    if (depth >= maxDepth || typeof obj !== 'object') {
+        return typeof obj === 'object' ? `[${Array.isArray(obj) ? 'Array' : 'object'}]` :
+            typeof obj === 'string' ? `"${obj}"` : String(obj);
+    }
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return `[${obj.map(item => stringify(item, maxDepth, depth + 1)).join(', ')}]`;
+    }
+    // Handle objects
+    const pairs = Object.entries(obj).map(([key, val]) => `"${key}": ${stringify(val, maxDepth, depth + 1)}`);
+    return `{${pairs.join(', ')}}`;
+}
+class Logger {
+    logger;
+    constructor() {
+        this.logger = null;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    parseArgs(args) {
+        return args.map((arg) => {
+            if (arg instanceof Error) {
+                return arg.stack ?? arg.message;
+            }
+            return arg;
+        }).join(" ");
+    }
+    info(...message) {
+        if (this.logger) {
+            this.logger.info(this.parseArgs(message));
+        }
+    }
+    debug(...message) {
+        if (this.logger) {
+            this.logger.debug(this.parseArgs(message));
+        }
+    }
+    warn(...message) {
+        if (this.logger) {
+            this.logger.warn(this.parseArgs(message));
+        }
+    }
+    error(...message) {
+        if (this.logger) {
+            this.logger.error(this.parseArgs(message));
+        }
+    }
+}
+const logger = new Logger();
+export { logger };

package/dist/esm/common/node.js

@@ -0,0 +1,20 @@
+/* eslint-disable */
+const isNode = typeof process !== "undefined" &&
+    process.versions != null &&
+    process.versions.node != null;
+let fs = null;
+let os = null;
+let path = null;
+let dotenv = null;
+if (isNode) {
+    try {
+        fs = eval("require")("fs");
+        os = eval("require")("os");
+        path = eval("require")("path");
+        dotenv = eval("require")("dotenv");
+    }
+    catch (e) {
+        console.warn("fs and os are not available in this environment");
+    }
+}
+export { dotenv, fs, os, path };

package/dist/esm/common/settings.js

@@ -0,0 +1,167 @@
+import { authentication } from "../authentication/index.js";
+import { env } from "../common/env.js";
+// Function to get package version
+function getPackageVersion() {
+    try {
+        // Try to require package.json (Node.js only, gracefully fails in browser)
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const packageJson = {"version":"0.2.36-dev.190","commit":"fcb44cfa2e6fc7b7cc20cf8bf70e3bf380d74146"};
+        return packageJson.version || "unknown";
+    }
+    catch {
+        // Fallback for browser environments or if require fails
+        return "unknown";
+    }
+}
+// Function to get OS and architecture
+function getOsArch() {
+    try {
+        // Node.js environment
+        if (typeof process !== 'undefined' && process.platform && process.arch) {
+            const platform = process.platform === 'win32' ? 'windows' :
+                process.platform === 'darwin' ? 'darwin' :
+                    process.platform === 'linux' ? 'linux' : process.platform;
+            return `${platform}/${process.arch}`;
+        }
+    }
+    catch {
+        // Fall through to browser detection
+    }
+    // Browser environment - use fixed detection
+    try {
+        // @ts-ignore - navigator is available in browser environments
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (typeof navigator !== 'undefined' && navigator?.platform) {
+            // @ts-ignore - navigator.platform is available in browser environments
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            const navPlatform = navigator.platform.toLowerCase();
+            const platform = navPlatform.includes('win') ? 'windows' :
+                navPlatform.includes('mac') ? 'darwin' :
+                    navPlatform.includes('linux') ? 'linux' : 'browser';
+            const arch = navPlatform.includes('64') ? 'amd64' : 'unknown';
+            return `${platform}/${arch}`;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return "browser/unknown";
+}
+// Function to get commit hash
+function getCommitHash() {
+    try {
+        // Try to require package.json and look for commit field (set during build)
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const packageJson = {"version":"0.2.36-dev.190","commit":"fcb44cfa2e6fc7b7cc20cf8bf70e3bf380d74146"};
+        // Check for commit in various possible locations
+        const commit = packageJson.commit || packageJson.buildInfo?.commit;
+        if (commit) {
+            return commit.length > 7 ? commit.substring(0, 7) : commit;
+        }
+    }
+    catch {
+        // Fallback for browser environments or if require fails
+    }
+    return "unknown";
+}
+class Settings {
+    credentials;
+    config;
+    _version = null;
+    constructor() {
+        this.credentials = authentication();
+        this.config = {
+            proxy: "",
+            apikey: "",
+            workspace: "",
+        };
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    get env() {
+        return env.BL_ENV || "prod";
+    }
+    get baseUrl() {
+        if (this.config.proxy) {
+            return this.config.proxy + "/api";
+        }
+        if (env.BL_API_URL) {
+            return env.BL_API_URL;
+        }
+        if (this.env === "prod") {
+            return "https://api.blaxel.ai/v0";
+        }
+        return "https://api.blaxel.dev/v0";
+    }
+    get runUrl() {
+        if (this.config.proxy) {
+            return this.config.proxy + "/run";
+        }
+        if (env.BL_RUN_URL) {
+            return env.BL_RUN_URL;
+        }
+        if (this.env === "prod") {
+            return "https://run.blaxel.ai";
+        }
+        return "https://run.blaxel.dev";
+    }
+    get workspace() {
+        return this.config.workspace || this.credentials.workspace || "";
+    }
+    get authorization() {
+        if (this.config.apikey) {
+            return 'Bearer ' + this.token;
+        }
+        return this.credentials.authorization;
+    }
+    get token() {
+        if (this.config.apikey) {
+            return this.config.apikey;
+        }
+        return this.credentials.token;
+    }
+    get version() {
+        if (this._version === null) {
+            this._version = getPackageVersion();
+        }
+        return this._version;
+    }
+    get headers() {
+        const osArch = getOsArch();
+        const commitHash = getCommitHash();
+        return {
+            "x-blaxel-authorization": this.authorization,
+            "x-blaxel-workspace": this.workspace || "",
+            "User-Agent": `blaxel/sdk/typescript/${this.version} (${osArch}) blaxel/${commitHash}`,
+        };
+    }
+    get name() {
+        return env.BL_NAME || "";
+    }
+    get type() {
+        return env.BL_TYPE || "agents";
+    }
+    get runInternalHostname() {
+        if (!this.generation) {
+            return "";
+        }
+        return env.BL_RUN_INTERNAL_HOST || "";
+    }
+    get runInternalProtocol() {
+        return env.BL_RUN_INTERNAL_PROTOCOL || "https";
+    }
+    get blCloud() {
+        return env.BL_CLOUD === "true";
+    }
+    get generation() {
+        return env.BL_GENERATION || "";
+    }
+    get loggerType() {
+        return env.BL_LOGGER || "http";
+    }
+    async authenticate() {
+        await this.credentials.authenticate();
+    }
+}
+export const settings = new Settings();

package/dist/esm/index.browser.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+// Import your SDK entry point or a function to test
+import * as sdk from "./index.js";
+describe('SDK Browser Integration', () => {
+    it('should load the SDK without Node.js-only modules', () => {
+        // Example: check that SDK loads and a function exists
+        expect(typeof sdk).toBe('object');
+        // Add more specific tests for your SDK as needed
+    });
+});

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+import "./common/autoload.js";
+export * from "./agents/index.js";
+export * from "./client/client.js";
+export * from "./common/autoload.js";
+export * from "./common/env.js";
+export * from "./common/errors.js";
+export * from "./common/internal.js";
+export * from "./common/logger.js";
+export * from "./common/settings.js";
+export * from "./jobs/index.js";
+export * from "./mcp/index.js";
+export * from "./models/index.js";
+export * from "./sandbox/index.js";
+export * from "./telemetry/telemetry.js";
+export * from "./tools/index.js";
+export * from "./tools/types.js";
+export * from "./volume/index.js";

package/dist/esm/jobs/index.js

@@ -0,0 +1,3 @@
+export * from "./jobs.js";
+export * from "./start.js";
+export * from "./types.js";

package/dist/esm/jobs/jobs.js

@@ -0,0 +1,86 @@
+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 BlJob {
+    jobName;
+    constructor(jobName) {
+        this.jobName = jobName;
+    }
+    get fallbackUrl() {
+        if (this.externalUrl != this.url) {
+            return this.externalUrl;
+        }
+        return null;
+    }
+    get externalUrl() {
+        return new URL(`${settings.runUrl}/${settings.workspace}/jobs/${this.jobName}`);
+    }
+    get internalUrl() {
+        const hash = getGlobalUniqueHash(settings.workspace, "job", this.jobName);
+        return new URL(`${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`);
+    }
+    get forcedUrl() {
+        return getForcedUrl('job', this.jobName);
+    }
+    get url() {
+        if (this.forcedUrl)
+            return this.forcedUrl;
+        if (settings.runInternalHostname)
+            return this.internalUrl;
+        return this.externalUrl;
+    }
+    async call(url, tasks) {
+        const body = {
+            tasks: tasks
+        };
+        const response = await fetch(url.toString() + "/executions", {
+            method: "POST",
+            headers: {
+                ...settings.headers,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        return response;
+    }
+    async run(tasks) {
+        logger.debug(`Job Calling: ${this.jobName}`);
+        const span = startSpan(this.jobName, {
+            attributes: {
+                "job.name": this.jobName,
+                "span.type": "job.run",
+            },
+            isRoot: false,
+        });
+        try {
+            const response = await this.call(this.url, tasks);
+            return await response.text();
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (!this.fallbackUrl) {
+                    span.setAttribute("job.run.error", err.stack);
+                    throw err;
+                }
+                try {
+                    const response = await this.call(this.fallbackUrl, tasks);
+                    return await response.text();
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        span.setAttribute("job.run.error", err.stack);
+                    }
+                    throw err;
+                }
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    }
+}
+export const blJob = (jobName) => {
+    return new BlJob(jobName);
+};