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

package/dist/cjs-browser/sandbox/interpreter.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeInterpreter = void 0;
+const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
+const sandbox_js_1 = require("./sandbox.js");
+class CodeInterpreter extends sandbox_js_1.SandboxInstance {
+    static DEFAULT_IMAGE = "blaxel/jupyter-server";
+    static DEFAULT_PORTS = [
+        { name: "jupyter", target: 8888, protocol: "HTTP" },
+    ];
+    static DEFAULT_LIFECYCLE = {
+        expirationPolicies: [{ type: "ttl-idle", value: "30m", action: "delete" }],
+    };
+    _sandboxConfig;
+    constructor(sandbox) {
+        super(sandbox);
+        this._sandboxConfig = sandbox;
+    }
+    static async get(sandboxName) {
+        const base = await sandbox_js_1.SandboxInstance.get(sandboxName);
+        // Create a minimal config - the base instance already has the sandbox data
+        // We'll rely on the process property for URL/headers access
+        const config = {
+            metadata: base.metadata,
+            spec: base.spec,
+            status: base.status,
+            events: base.events,
+        };
+        return new CodeInterpreter(config);
+    }
+    static async create(sandbox, { safe = true } = {}) {
+        const payload = {
+            image: CodeInterpreter.DEFAULT_IMAGE,
+            ports: CodeInterpreter.DEFAULT_PORTS,
+            lifecycle: CodeInterpreter.DEFAULT_LIFECYCLE,
+        };
+        const allowedCopyKeys = new Set(["name", "envs", "memory", "region", "headers"]);
+        if (sandbox && typeof sandbox === "object") {
+            if (Array.isArray(sandbox)) {
+                // Skip arrays
+            }
+            else if ("metadata" in sandbox || "spec" in sandbox) {
+                // It's a Sandbox object
+                const sandboxObj = sandbox;
+                if (sandboxObj.metadata?.name) {
+                    payload["name"] = sandboxObj.metadata.name;
+                }
+                if (sandboxObj.spec?.runtime) {
+                    if (sandboxObj.spec.runtime.envs) {
+                        payload["envs"] = sandboxObj.spec.runtime.envs;
+                    }
+                    if (sandboxObj.spec.runtime.memory) {
+                        payload["memory"] = sandboxObj.spec.runtime.memory;
+                    }
+                }
+                if (sandboxObj.spec?.region) {
+                    payload["region"] = sandboxObj.spec.region;
+                }
+            }
+            else if ("name" in sandbox || "image" in sandbox || "memory" in sandbox) {
+                // It's a SandboxCreateConfiguration or dict-like object
+                const sandboxDict = sandbox;
+                for (const k of allowedCopyKeys) {
+                    const value = sandboxDict[k];
+                    if (value !== null && value !== undefined) {
+                        payload[k] = value;
+                    }
+                }
+            }
+        }
+        const baseInstance = await sandbox_js_1.SandboxInstance.create(payload, { safe });
+        // Create config from the instance - preserve any forceUrl/headers if provided in input
+        const config = {
+            metadata: baseInstance.metadata,
+            spec: baseInstance.spec,
+            status: baseInstance.status,
+            events: baseInstance.events,
+        };
+        // Preserve forceUrl and headers from input if it was a dict-like object
+        if (sandbox && typeof sandbox === "object" && !Array.isArray(sandbox)) {
+            if ("forceUrl" in sandbox && typeof sandbox.forceUrl === "string") {
+                config.forceUrl = sandbox.forceUrl;
+            }
+            if ("headers" in sandbox && typeof sandbox.headers === "object") {
+                config.headers = sandbox.headers;
+            }
+            if ("params" in sandbox && typeof sandbox.params === "object") {
+                config.params = sandbox.params;
+            }
+        }
+        return new CodeInterpreter(config);
+    }
+    get _jupyterUrl() {
+        return this.process.url;
+    }
+    static OutputMessage = class {
+        text;
+        timestamp;
+        isStderr;
+        constructor(text, timestamp, isStderr) {
+            this.text = text;
+            this.timestamp = timestamp;
+            this.isStderr = isStderr;
+        }
+    };
+    static Result = class {
+        constructor(kwargs = {}) {
+            for (const [k, v] of Object.entries(kwargs)) {
+                this[k] = v;
+            }
+        }
+    };
+    static ExecutionError = class {
+        name;
+        value;
+        traceback;
+        constructor(name, value, traceback) {
+            this.name = name;
+            this.value = value;
+            this.traceback = traceback;
+        }
+    };
+    static Logs = class {
+        stdout = [];
+        stderr = [];
+    };
+    static Execution = class {
+        results = [];
+        logs = new CodeInterpreter.Logs();
+        error = null;
+        executionCount = null;
+    };
+    static Context = class {
+        id;
+        constructor(id) {
+            this.id = id;
+        }
+        static fromJson(data) {
+            return new CodeInterpreter.Context(String(data.id || data.context_id || ""));
+        }
+    };
+    _parseOutput(execution, output, onStdout, onStderr, onResult, onError) {
+        let data;
+        try {
+            data = JSON.parse(output);
+        }
+        catch {
+            // Fallback: treat as stdout text-only message
+            execution.logs.stdout.push(output);
+            if (onStdout) {
+                return onStdout(new CodeInterpreter.OutputMessage(output, null, false));
+            }
+            return null;
+        }
+        let dataType = "";
+        if (typeof data.type === "string") {
+            dataType = data.type;
+        }
+        else if (data.type !== null &&
+            data.type !== undefined &&
+            typeof data.type !== "object") {
+            const typeValue = data.type;
+            dataType = String(typeValue);
+        }
+        const restData = { ...data };
+        delete restData.type;
+        if (dataType === "result") {
+            const result = new CodeInterpreter.Result(restData);
+            execution.results.push(result);
+            if (onResult) {
+                return onResult(result);
+            }
+        }
+        else if (dataType === "stdout") {
+            let text = "";
+            if (typeof data.text === "string") {
+                text = data.text;
+            }
+            else if (data.text !== null &&
+                data.text !== undefined &&
+                typeof data.text !== "object") {
+                const textValue = data.text;
+                text = String(textValue);
+            }
+            execution.logs.stdout.push(text);
+            if (onStdout) {
+                return onStdout(new CodeInterpreter.OutputMessage(text, typeof data.timestamp === "number" ? data.timestamp : null, false));
+            }
+        }
+        else if (dataType === "stderr") {
+            let text = "";
+            if (typeof data.text === "string") {
+                text = data.text;
+            }
+            else if (data.text !== null &&
+                data.text !== undefined &&
+                typeof data.text !== "object") {
+                const textValue = data.text;
+                text = String(textValue);
+            }
+            execution.logs.stderr.push(text);
+            if (onStderr) {
+                return onStderr(new CodeInterpreter.OutputMessage(text, typeof data.timestamp === "number" ? data.timestamp : null, true));
+            }
+        }
+        else if (dataType === "error") {
+            let errorName = "";
+            if (typeof data.name === "string") {
+                errorName = data.name;
+            }
+            else if (data.name !== null &&
+                data.name !== undefined &&
+                typeof data.name !== "object") {
+                const nameValue = data.name;
+                errorName = String(nameValue);
+            }
+            execution.error = new CodeInterpreter.ExecutionError(errorName, data.value, data.traceback);
+            if (onError) {
+                return onError(execution.error);
+            }
+        }
+        else if (dataType === "number_of_executions") {
+            execution.executionCount =
+                typeof data.execution_count === "number" ? data.execution_count : null;
+        }
+        return null;
+    }
+    async runCode(code, options = {}) {
+        const { language = null, context = null, onStdout, onStderr, onResult, onError, envs = null, timeout = null, } = options;
+        const DEFAULT_TIMEOUT = 60.0;
+        if (language && context) {
+            throw new Error("You can provide context or language, but not both at the same time.");
+        }
+        const readTimeout = timeout === 0 ? null : timeout ?? DEFAULT_TIMEOUT;
+        const contextId = context?.id ?? null;
+        const body = {
+            code,
+            context_id: contextId,
+            language,
+            env_vars: envs,
+        };
+        const execution = new CodeInterpreter.Execution();
+        const headers = this._sandboxConfig.forceUrl
+            ? this._sandboxConfig.headers
+            : settings_js_1.settings.headers;
+        const controller = new AbortController();
+        let timeoutId = null;
+        // Set up timeout
+        if (readTimeout !== null) {
+            timeoutId = setTimeout(() => {
+                controller.abort();
+            }, readTimeout * 1000);
+        }
+        try {
+            const response = await fetch(`${this._jupyterUrl}/port/8888/execute`, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (response.status >= 400) {
+                let bodyText = "<unavailable>";
+                try {
+                    bodyText = await response.text();
+                }
+                catch {
+                    // Ignore errors
+                }
+                const method = "POST";
+                const url = `${this._jupyterUrl}/port/8888/execute`;
+                const reason = response.statusText;
+                const details = "Execution failed\n" +
+                    `- method: ${method}\n- url: ${url}\n- status: ${response.status} ${reason}\n` +
+                    `- response-headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}\n- body:\n${bodyText}`;
+                logger_js_1.logger.debug(details);
+                throw new Error(details);
+            }
+            if (!response.body) {
+                throw new Error("No response body");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            try {
+                while (true) {
+                    const result = await reader.read();
+                    if (result.done)
+                        break;
+                    const value = result.value;
+                    if (value instanceof Uint8Array) {
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split(/\r?\n/);
+                        buffer = lines.pop() || "";
+                        for (const line of lines) {
+                            if (!line)
+                                continue;
+                            try {
+                                this._parseOutput(execution, line, onStdout, onStderr, onResult, onError);
+                            }
+                            catch {
+                                // Fallback: treat as stdout text-only message
+                                execution.logs.stdout.push(line);
+                                if (onStdout) {
+                                    onStdout(new CodeInterpreter.OutputMessage(line, null, false));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "AbortError") {
+                throw new Error("Request timeout");
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+        return execution;
+    }
+    async createCodeContext(options = {}) {
+        const { cwd = null, language = null, requestTimeout = null } = options;
+        const data = {};
+        if (language) {
+            data.language = language;
+        }
+        if (cwd) {
+            data.cwd = cwd;
+        }
+        const headers = this._sandboxConfig.forceUrl
+            ? this._sandboxConfig.headers
+            : settings_js_1.settings.headers;
+        const controller = new AbortController();
+        let timeoutId = null;
+        if (requestTimeout !== null) {
+            timeoutId = setTimeout(() => {
+                controller.abort();
+            }, requestTimeout * 1000);
+        }
+        try {
+            const response = await fetch(`${this._jupyterUrl}/port/8888/contexts`, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(data),
+                signal: controller.signal,
+            });
+            if (response.status >= 400) {
+                let bodyText = "<unavailable>";
+                try {
+                    bodyText = await response.text();
+                }
+                catch {
+                    // Ignore errors
+                }
+                const method = "POST";
+                const url = `${this._jupyterUrl}/port/8888/contexts`;
+                const reason = response.statusText;
+                const details = "Create context failed\n" +
+                    `- method: ${method}\n- url: ${url}\n- status: ${response.status} ${reason}\n` +
+                    `- response-headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}\n- body:\n${bodyText}`;
+                logger_js_1.logger.debug(details);
+                throw new Error(details);
+            }
+            const responseData = (await response.json());
+            return CodeInterpreter.Context.fromJson(responseData);
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "AbortError") {
+                throw new Error("Request timeout");
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}
+exports.CodeInterpreter = CodeInterpreter;

package/dist/cjs-browser/sandbox/sandbox.js

@@ -5,16 +5,11 @@ const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
 const index_js_2 = require("./filesystem/index.js");
-const filesystem_ws_js_1 = require("./filesystem/filesystem-ws.js");
 const index_js_3 = require("./network/index.js");
-const network_ws_js_1 = require("./network/network-ws.js");
 const preview_js_1 = require("./preview.js");
 const index_js_4 = require("./process/index.js");
-const process_ws_js_1 = require("./process/process-ws.js");
 const index_js_5 = require("./codegen/index.js");
-const codegen_ws_js_1 = require("./codegen/codegen-ws.js");
 const session_js_1 = require("./session.js");
-const index_js_6 = require("./websocket/index.js");
 const types_js_1 = require("./types.js");
 class SandboxInstance {
     sandbox;
@@ -24,32 +19,14 @@ class SandboxInstance {
     previews;
     sessions;
     codegen;
-    wsClient;
     constructor(sandbox) {
         this.sandbox = sandbox;
-        // If connection type is websocket, initialize WebSocket client and use WebSocket transport layers
-        if (sandbox.connectionType === "websocket") {
-            const url = sandbox.forceUrl || sandbox.metadata?.url || "";
-            this.wsClient = new index_js_6.WebSocketClient({
-                url,
-                headers: sandbox.headers,
-            });
-            // Initialize WebSocket-based action handlers
-            this.process = new process_ws_js_1.SandboxProcessWebSocket(sandbox, this.wsClient);
-            this.fs = new filesystem_ws_js_1.SandboxFileSystemWebSocket(sandbox, this.process, this.wsClient);
-            this.network = new network_ws_js_1.SandboxNetworkWebSocket(sandbox, this.wsClient);
-            this.codegen = new codegen_ws_js_1.SandboxCodegenWebSocket(sandbox, this.wsClient);
-        }
-        else {
-            // Default to HTTP-based action handlers
-            this.process = new index_js_4.SandboxProcess(sandbox);
-            this.fs = new index_js_2.SandboxFileSystem(sandbox, this.process);
-            this.network = new index_js_3.SandboxNetwork(sandbox);
-            this.codegen = new index_js_5.SandboxCodegen(sandbox);
-        }
-        // These are always HTTP-based
+        this.process = new index_js_4.SandboxProcess(sandbox);
+        this.fs = new index_js_2.SandboxFileSystem(sandbox, this.process);
+        this.network = new index_js_3.SandboxNetwork(sandbox);
         this.previews = new preview_js_1.SandboxPreviews(sandbox);
         this.sessions = new session_js_1.SandboxSessions(sandbox);
+        this.codegen = new index_js_5.SandboxCodegen(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -68,17 +45,10 @@ class SandboxInstance {
         logger_js_1.logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");
         return this;
     }
-    closeConnection() {
-        if (this.wsClient) {
-            this.wsClient.close();
-        }
-    }
     static async create(sandbox, { safe = true } = {}) {
         const defaultName = `sandbox-${(0, uuid_1.v4)().replace(/-/g, '').substring(0, 8)}`;
         const defaultImage = `blaxel/base-image:latest`;
         const defaultMemory = 4096;
-        // Store connection type if provided
-        let connectionType;
         // Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs/volumes keys
         if (!sandbox ||
             'name' in sandbox ||
@@ -88,8 +58,7 @@ class SandboxInstance {
             'envs' in sandbox ||
             'volumes' in sandbox ||
             'lifecycle' in sandbox ||
-            'snapshotEnabled' in sandbox ||
-            'connectionType' in sandbox) {
+            'snapshotEnabled' in sandbox) {
             if (!sandbox)
                 sandbox = {};
             if (!sandbox.name)
@@ -98,7 +67,6 @@ class SandboxInstance {
                 sandbox.image = defaultImage;
             if (!sandbox.memory)
                 sandbox.memory = defaultMemory;
-            connectionType = sandbox.connectionType;
             const ports = (0, types_js_1.normalizePorts)(sandbox.ports);
             const envs = (0, types_js_1.normalizeEnvs)(sandbox.envs);
             const volumes = (0, types_js_1.normalizeVolumes)(sandbox.volumes);
@@ -147,16 +115,7 @@ class SandboxInstance {
             body: sandbox,
             throwOnError: true,
         });
-        // Add connection type to configuration
-        const config = {
-            ...data,
-            connectionType: connectionType || "http",
-        };
-        const instance = new SandboxInstance(config);
-        // Connect WebSocket if needed
-        if (connectionType === "websocket" && instance.wsClient) {
-            await instance.wsClient.connect();
-        }
+        const instance = new SandboxInstance(data);
         // TODO remove this part once we have a better way to handle this
         if (safe) {
             try {
@@ -166,34 +125,20 @@ class SandboxInstance {
         }
         return instance;
     }
-    static async get(sandboxName, connectionType) {
+    static async get(sandboxName) {
         const { data } = await (0, index_js_1.getSandbox)({
             path: {
                 sandboxName,
             },
             throwOnError: true,
         });
-        // Add connection type to configuration
-        const config = {
-            ...data,
-            connectionType: connectionType || "http",
-        };
-        const instance = new SandboxInstance(config);
-        // Connect WebSocket if needed
-        if (connectionType === "websocket" && instance.wsClient) {
-            await instance.wsClient.connect();
-        }
-        return instance;
+        return new SandboxInstance(data);
     }
     static async list() {
         const { data } = await (0, index_js_1.listSandboxes)({ throwOnError: true });
         return data.map((sandbox) => new SandboxInstance(sandbox));
     }
-    static async delete(sandboxName, instance) {
-        // Close WebSocket connection if instance is provided
-        if (instance && instance.wsClient) {
-            instance.closeConnection();
-        }
+    static async delete(sandboxName) {
         const { data } = await (0, index_js_1.deleteSandbox)({
             path: {
                 sandboxName,
@@ -223,10 +168,8 @@ class SandboxInstance {
                 if (!name) {
                     throw new Error("Sandbox name is required");
                 }
-                // Get connection type if specified
-                const connectionType = 'connectionType' in sandbox ? sandbox.connectionType : undefined;
                 // Get the existing sandbox to check its status
-                const sandboxInstance = await SandboxInstance.get(name, connectionType);
+                const sandboxInstance = await SandboxInstance.get(name);
                 // If the sandbox is TERMINATED, treat it as not existing
                 if (sandboxInstance.status === "TERMINATED") {
                     // Create a new sandbox - backend will handle cleanup of the terminated one

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

@@ -42,10 +42,6 @@ class McpTool {
         this.client = new index_js_1.Client({
             name: this.name,
             version: "1.0.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
         });
     }
     get fallbackUrl() {
@@ -58,8 +54,8 @@ class McpTool {
         return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/${this.pluralType}/${this.name}`);
     }
     get internalUrl() {
-        const url = (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, this.type, this.name, settings_js_1.settings.env, settings_js_1.settings.runInternalProtocol, settings_js_1.settings.runInternalHostname, settings_js_1.settings.blCloud, settings_js_1.settings.workspaceId);
-        return new URL(url);
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, this.type, this.name);
+        return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
     }
     get forcedUrl() {
         return (0, internal_js_1.getForcedUrl)(this.type, this.name);

package/dist/cjs-browser/types/client/responseInterceptor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Response interceptor that enhances authentication error messages (401/403)
+ * with a link to the authentication documentation.
+ */
+type ResponseInterceptor = (response: Response) => Promise<Response>;
+/**
+ * Intercepts HTTP responses and adds authentication documentation
+ * to 401/403 error responses
+ */
+export declare const authenticationErrorInterceptor: ResponseInterceptor;
+export declare const responseInterceptors: ResponseInterceptor[];
+export {};

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

@@ -1,5 +1,5 @@
 import type { Options as ClientOptions, TDataShape, Client } from '@hey-api/client-fetch';
-import type { ListAgentsData, CreateAgentData, DeleteAgentData, GetAgentData, UpdateAgentData, ListAgentRevisionsData, GetConfigurationData, ListCustomDomainsData, CreateCustomDomainData, DeleteCustomDomainData, GetCustomDomainData, UpdateCustomDomainData, VerifyCustomDomainData, ListFunctionsData, CreateFunctionData, DeleteFunctionData, GetFunctionData, UpdateFunctionData, ListFunctionRevisionsData, GetIntegrationData, ListIntegrationConnectionsData, CreateIntegrationConnectionData, DeleteIntegrationConnectionData, GetIntegrationConnectionData, UpdateIntegrationConnectionData, GetIntegrationConnectionModelEndpointConfigurationsData, ListIntegrationConnectionModelsData, GetIntegrationConnectionModelData, ListJobsData, CreateJobData, DeleteJobData, GetJobData, UpdateJobData, ListJobRevisionsData, ListLocationsData, ListMcpHubDefinitionsData, ListModelsData, CreateModelData, DeleteModelData, GetModelData, UpdateModelData, ListModelRevisionsData, ListPoliciesData, CreatePolicyData, DeletePolicyData, GetPolicyData, UpdatePolicyData, ListPrivateClustersData, CreatePrivateClusterData, DeletePrivateClusterData, GetPrivateClusterData, UpdatePrivateClusterData, GetPrivateClusterHealthData, UpdatePrivateClusterHealthData, ListAllPendingInvitationsData, ListPublicIpsData, ListSandboxHubDefinitionsData, ListSandboxesData, CreateSandboxData, DeleteSandboxData, GetSandboxData, UpdateSandboxData, ListSandboxPreviewsData, CreateSandboxPreviewData, DeleteSandboxPreviewData, GetSandboxPreviewData, UpdateSandboxPreviewData, ListSandboxPreviewTokensData, CreateSandboxPreviewTokenData, DeleteSandboxPreviewTokenData, StartSandboxData, StopSandboxData, GetWorkspaceServiceAccountsData, CreateWorkspaceServiceAccountData, DeleteWorkspaceServiceAccountData, UpdateWorkspaceServiceAccountData, ListApiKeysForServiceAccountData, CreateApiKeyForServiceAccountData, DeleteApiKeyForServiceAccountData, ListTemplatesData, GetTemplateData, ListWorkspaceUsersData, InviteWorkspaceUserData, RemoveWorkspaceUserData, UpdateWorkspaceUserRoleData, ListVolumeTemplatesData, CreateVolumeTemplateData, DeleteVolumeTemplateData, GetVolumeTemplateData, UpdateVolumeTemplateData, DeleteVolumeTemplateVersionData, ListVolumesData, CreateVolumeData, DeleteVolumeData, GetVolumeData, ListWorkspacesData, CreateWorkspaceData, DeleteWorkspaceData, GetWorkspaceData, UpdateWorkspaceData, DeclineWorkspaceInvitationData, AcceptWorkspaceInvitationData, LeaveWorkspaceData, CheckWorkspaceAvailabilityData } from './types.gen.js';
+import type { ListAgentsData, CreateAgentData, DeleteAgentData, GetAgentData, UpdateAgentData, ListAgentRevisionsData, GetConfigurationData, ListCustomDomainsData, CreateCustomDomainData, DeleteCustomDomainData, GetCustomDomainData, UpdateCustomDomainData, VerifyCustomDomainData, ListFunctionsData, CreateFunctionData, DeleteFunctionData, GetFunctionData, UpdateFunctionData, ListFunctionRevisionsData, ListImagesData, DeleteImageData, GetImageData, DeleteImageTagData, GetIntegrationData, ListIntegrationConnectionsData, CreateIntegrationConnectionData, DeleteIntegrationConnectionData, GetIntegrationConnectionData, UpdateIntegrationConnectionData, GetIntegrationConnectionModelEndpointConfigurationsData, ListIntegrationConnectionModelsData, GetIntegrationConnectionModelData, ListJobsData, CreateJobData, DeleteJobData, GetJobData, UpdateJobData, ListJobExecutionsData, CreateJobExecutionData, DeleteJobExecutionData, GetJobExecutionData, ListJobRevisionsData, ListLocationsData, ListMcpHubDefinitionsData, ListModelsData, CreateModelData, DeleteModelData, GetModelData, UpdateModelData, ListModelRevisionsData, ListPoliciesData, CreatePolicyData, DeletePolicyData, GetPolicyData, UpdatePolicyData, ListPrivateClustersData, CreatePrivateClusterData, DeletePrivateClusterData, GetPrivateClusterData, UpdatePrivateClusterData, GetPrivateClusterHealthData, UpdatePrivateClusterHealthData, ListAllPendingInvitationsData, ListPublicIpsData, ListSandboxHubDefinitionsData, ListSandboxesData, CreateSandboxData, DeleteSandboxData, GetSandboxData, UpdateSandboxData, ListSandboxPreviewsData, CreateSandboxPreviewData, DeleteSandboxPreviewData, GetSandboxPreviewData, UpdateSandboxPreviewData, ListSandboxPreviewTokensData, CreateSandboxPreviewTokenData, DeleteSandboxPreviewTokenData, StartSandboxData, StopSandboxData, GetWorkspaceServiceAccountsData, CreateWorkspaceServiceAccountData, DeleteWorkspaceServiceAccountData, UpdateWorkspaceServiceAccountData, ListApiKeysForServiceAccountData, CreateApiKeyForServiceAccountData, DeleteApiKeyForServiceAccountData, ListTemplatesData, GetTemplateData, ListWorkspaceUsersData, InviteWorkspaceUserData, RemoveWorkspaceUserData, UpdateWorkspaceUserRoleData, ListVolumeTemplatesData, CreateVolumeTemplateData, DeleteVolumeTemplateData, GetVolumeTemplateData, UpdateVolumeTemplateData, DeleteVolumeTemplateVersionData, ListVolumesData, CreateVolumeData, DeleteVolumeData, GetVolumeData, ListWorkspacesData, CreateWorkspaceData, DeleteWorkspaceData, GetWorkspaceData, UpdateWorkspaceData, DeclineWorkspaceInvitationData, AcceptWorkspaceInvitationData, LeaveWorkspaceData, CheckWorkspaceAvailabilityData } from './types.gen.js';
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
     /**
      * You can provide a client instance returned by `createClient()` instead of
@@ -90,6 +90,26 @@ export declare const updateFunction: <ThrowOnError extends boolean = false>(opti
  * Returns revisions for a function by name.
  */
 export declare const listFunctionRevisions: <ThrowOnError extends boolean = false>(options: Options<ListFunctionRevisionsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").RevisionMetadata[], unknown, ThrowOnError>;
+/**
+ * List images
+ * Returns a list of all images in the workspace grouped by repository with tags.
+ */
+export declare const listImages: <ThrowOnError extends boolean = false>(options?: Options<ListImagesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").Image[], unknown, ThrowOnError>;
+/**
+ * Delete image by name
+ * Deletes an image by name.
+ */
+export declare const deleteImage: <ThrowOnError extends boolean = false>(options: Options<DeleteImageData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").Image, unknown, ThrowOnError>;
+/**
+ * Get image by name
+ * Returns an image by name.
+ */
+export declare const getImage: <ThrowOnError extends boolean = false>(options: Options<GetImageData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").Image, unknown, ThrowOnError>;
+/**
+ * Delete image tag
+ * Deletes a specific tag from an image.
+ */
+export declare const deleteImageTag: <ThrowOnError extends boolean = false>(options: Options<DeleteImageTagData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").Image, unknown, ThrowOnError>;
 /**
  * List integrations connections
  * Returns integration information by name.
@@ -160,6 +180,26 @@ export declare const getJob: <ThrowOnError extends boolean = false>(options: Opt
  * Update a job by name.
  */
 export declare const updateJob: <ThrowOnError extends boolean = false>(options: Options<UpdateJobData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").Job, unknown, ThrowOnError>;
+/**
+ * List job executions
+ * Returns a list of all executions for a job by name.
+ */
+export declare const listJobExecutions: <ThrowOnError extends boolean = false>(options: Options<ListJobExecutionsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").JobExecution[], unknown, ThrowOnError>;
+/**
+ * Create job execution
+ * Creates a new execution for a job by name.
+ */
+export declare const createJobExecution: <ThrowOnError extends boolean = false>(options: Options<CreateJobExecutionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").JobExecution, unknown, ThrowOnError>;
+/**
+ * Delete job execution
+ * Stop an execution for a job by name.
+ */
+export declare const deleteJobExecution: <ThrowOnError extends boolean = false>(options: Options<DeleteJobExecutionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").JobExecution, unknown, ThrowOnError>;
+/**
+ * Get job execution
+ * Returns an execution for a job by name.
+ */
+export declare const getJobExecution: <ThrowOnError extends boolean = false>(options: Options<GetJobExecutionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen.js").JobExecution, unknown, ThrowOnError>;
 /**
  * List job revisions
  * Returns revisions for a job by name.