@blaxel/core 0.2.49-dev.213 → 0.2.49-dev1

package/dist/client/types.gen.js

@@ -0,0 +1,4 @@
+"use strict";
+/* eslint-disable */
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/autoload.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "./settings.js";
+export declare function initialize(config: Config): void;
+export declare function authenticate(): Promise<void>;

package/dist/common/autoload.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = initialize;
+exports.authenticate = authenticate;
+const client_gen_js_1 = require("../client/client.gen.js");
+const interceptors_js_1 = require("../client/interceptors.js");
+const client_gen_js_2 = require("../sandbox/client/client.gen.js");
+const settings_js_1 = require("./settings.js");
+client_gen_js_1.client.setConfig({
+    baseUrl: settings_js_1.settings.baseUrl,
+});
+for (const interceptor of interceptors_js_1.interceptors) {
+    // @ts-expect-error - Interceptor is not typed
+    client_gen_js_1.client.interceptors.request.use(interceptor);
+    // @ts-expect-error - Interceptor is not typed
+    client_gen_js_2.client.interceptors.request.use(interceptor);
+}
+// Allow to set custom configuration for browser environment
+function initialize(config) {
+    settings_js_1.settings.setConfig(config);
+    client_gen_js_1.client.setConfig({
+        baseUrl: settings_js_1.settings.baseUrl,
+    });
+}
+function authenticate() {
+    return settings_js_1.settings.authenticate();
+}

package/dist/common/env.d.ts

@@ -0,0 +1,5 @@
+type EnvVariables = {
+    [key: string]: string | undefined;
+};
+declare const env: EnvVariables;
+export { env };

package/dist/common/env.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+/* eslint-disable */
+const toml_1 = __importDefault(require("toml"));
+const node_js_1 = require("./node.js");
+const secretEnv = {};
+const configEnv = {};
+if (node_js_1.fs !== null && node_js_1.dotenv !== null) {
+    try {
+        const configFile = node_js_1.fs.readFileSync("blaxel.toml", "utf8");
+        const configInfos = toml_1.default.parse(configFile);
+        for (const key in configInfos.env) {
+            configEnv[key] = configInfos.env[key];
+        }
+    }
+    catch (error) { }
+    try {
+        const secretFile = node_js_1.fs.readFileSync(".env", "utf8");
+        const parsed = node_js_1.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;
+    },
+});
+exports.env = env;

package/dist/common/errors.d.ts

@@ -0,0 +1 @@
+export declare function handleDynamicImportError(err: any): void;

package/dist/common/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDynamicImportError = handleDynamicImportError;
+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/common/internal.d.ts

@@ -0,0 +1,4 @@
+export declare function getAlphanumericLimitedHash(input: string, maxSize?: number): string;
+export declare function getGlobalUniqueHash(workspace: string, type: string, name: string): string;
+export declare function pluralize(type: string): string;
+export declare function getForcedUrl(type: string, name: string): import("url").URL | null;

package/dist/common/internal.js

@@ -0,0 +1,188 @@
+"use strict";
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlphanumericLimitedHash = getAlphanumericLimitedHash;
+exports.getGlobalUniqueHash = getGlobalUniqueHash;
+exports.pluralize = pluralize;
+exports.getForcedUrl = getForcedUrl;
+const core_1 = require("@blaxel/core");
+// 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('');
+}
+function getAlphanumericLimitedHash(input, maxSize = 48) {
+    const hash = md5(input);
+    return hash.length > maxSize ? hash.substring(0, maxSize) : hash;
+}
+function getGlobalUniqueHash(workspace, type, name) {
+    const globalUniqueName = `${workspace}-${type}-${name}`;
+    return getAlphanumericLimitedHash(globalUniqueName, 48);
+}
+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';
+}
+function getForcedUrl(type, name) {
+    const pluralType = pluralize(type);
+    const envVar = name.replace(/-/g, "_").toUpperCase();
+    // BL_FUNCTIONS_NAME_URL
+    if (core_1.env[`BL_${pluralType.toUpperCase()}_${envVar}_URL`]) {
+        return new URL(core_1.env[`BL_${pluralType.toUpperCase()}_${envVar}_URL`]);
+    }
+    // BL_FUNCTION_NAME_URL
+    if (core_1.env[`BL_${type.toUpperCase()}_${envVar}_URL`]) {
+        return new URL(core_1.env[`BL_${type.toUpperCase()}_${envVar}_URL`]);
+    }
+    return null;
+}

package/dist/common/internal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/internal.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const internal_1 = require("./internal");
+(0, vitest_1.describe)('getAlphanumericLimitedHash', () => {
+    (0, vitest_1.it)('returns correct MD5 hash for a known string', () => {
+        // MD5 of 'hello' is 5d41402abc4b2a76b9719d911017c592
+        (0, vitest_1.expect)((0, internal_1.getAlphanumericLimitedHash)('hello')).toBe('5d41402abc4b2a76b9719d911017c592');
+    });
+    (0, vitest_1.it)('respects the maxSize parameter', () => {
+        const hash = (0, internal_1.getAlphanumericLimitedHash)('hello', 8);
+        (0, vitest_1.expect)(hash.length).toBe(8);
+        (0, vitest_1.expect)(hash).toBe('5d41402a');
+    });
+    (0, vitest_1.it)('returns full hash if maxSize is larger than hash', () => {
+        const hash = (0, internal_1.getAlphanumericLimitedHash)('hello', 64);
+        (0, vitest_1.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',
+    }
+];
+(0, vitest_1.describe)('getGlobalUniqueHash', () => {
+    testCases.forEach(({ workspace, type, name, expected }) => {
+        (0, vitest_1.it)(`returns ${expected} for ${workspace}-${type}-${name}`, () => {
+            (0, vitest_1.expect)((0, internal_1.getGlobalUniqueHash)(workspace, type, name)).toBe(expected);
+        });
+    });
+});

package/dist/common/logger.d.ts

@@ -0,0 +1,25 @@
+interface LoggerInterface {
+    info: (message: string) => void;
+    debug: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+/**
+ * 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 declare function stringify<T>(obj: T, maxDepth?: number, depth?: number): string;
+declare class Logger {
+    private logger;
+    constructor();
+    setLogger(logger: LoggerInterface): void;
+    parseArgs(args: unknown[]): string;
+    info(...message: unknown[]): void;
+    debug(...message: unknown[]): void;
+    warn(...message: unknown[]): void;
+    error(...message: unknown[]): void;
+}
+declare const logger: Logger;
+export { logger };

package/dist/common/logger.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.stringify = stringify;
+/**
+ * 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)
+ */
+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();
+exports.logger = logger;

package/dist/common/node.d.ts

@@ -0,0 +1,5 @@
+declare let fs: typeof import("fs") | null;
+declare let os: typeof import("os") | null;
+declare let path: typeof import("path") | null;
+declare let dotenv: typeof import("dotenv") | null;
+export { dotenv, fs, os, path };

package/dist/common/node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.path = exports.os = exports.fs = exports.dotenv = void 0;
+/* eslint-disable */
+const isNode = typeof process !== "undefined" &&
+    process.versions != null &&
+    process.versions.node != null;
+let fs = null;
+exports.fs = fs;
+let os = null;
+exports.os = os;
+let path = null;
+exports.path = path;
+let dotenv = null;
+exports.dotenv = dotenv;
+if (isNode) {
+    try {
+        exports.fs = fs = eval("require")("fs");
+        exports.os = os = eval("require")("os");
+        exports.path = path = eval("require")("path");
+        exports.dotenv = dotenv = eval("require")("dotenv");
+    }
+    catch (e) {
+        console.warn("fs and os are not available in this environment");
+    }
+}

package/dist/common/settings.d.ts

@@ -0,0 +1,31 @@
+import { Credentials } from "../authentication/credentials.js";
+export type Config = {
+    proxy?: string;
+    apikey?: string;
+    workspace?: string;
+};
+declare class Settings {
+    credentials: Credentials;
+    config: Config;
+    private _version;
+    constructor();
+    setConfig(config: Config): void;
+    get env(): string;
+    get baseUrl(): string;
+    get runUrl(): string;
+    get workspace(): string;
+    get authorization(): string;
+    get token(): string;
+    get version(): string;
+    get headers(): Record<string, string>;
+    get name(): string;
+    get type(): string;
+    get runInternalHostname(): string;
+    get runInternalProtocol(): string;
+    get blCloud(): boolean;
+    get generation(): string;
+    get loggerType(): string;
+    authenticate(): Promise<void>;
+}
+export declare const settings: Settings;
+export {};

package/dist/common/settings.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settings = void 0;
+const index_js_1 = require("../authentication/index.js");
+const env_js_1 = require("../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.4-dev4","commit":"19931c18b6608532016e6c3567f4692edeb9e747"};
+        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.4-dev4","commit":"19931c18b6608532016e6c3567f4692edeb9e747"};
+        // 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 = (0, index_js_1.authentication)();
+        this.config = {
+            proxy: "",
+            apikey: "",
+            workspace: "",
+        };
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    get env() {
+        return env_js_1.env.BL_ENV || "prod";
+    }
+    get baseUrl() {
+        if (this.config.proxy) {
+            return this.config.proxy + "/api";
+        }
+        if (env_js_1.env.BL_API_URL) {
+            return env_js_1.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_js_1.env.BL_RUN_URL) {
+            return env_js_1.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_js_1.env.BL_NAME || "";
+    }
+    get type() {
+        return env_js_1.env.BL_TYPE || "agents";
+    }
+    get runInternalHostname() {
+        if (!this.generation) {
+            return "";
+        }
+        return env_js_1.env.BL_RUN_INTERNAL_HOST || "";
+    }
+    get runInternalProtocol() {
+        return env_js_1.env.BL_RUN_INTERNAL_PROTOCOL || "https";
+    }
+    get blCloud() {
+        return env_js_1.env.BL_CLOUD === "true";
+    }
+    get generation() {
+        return env_js_1.env.BL_GENERATION || "";
+    }
+    get loggerType() {
+        return env_js_1.env.BL_LOGGER || "http";
+    }
+    async authenticate() {
+        await this.credentials.authenticate();
+    }
+}
+exports.settings = new Settings();