@blaxel/core 0.2.10 → 0.2.11-dev.88

package/dist/authentication/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.authentication = authentication;
-/* eslint-disable */
 const path_1 = require("path");
 const yaml_1 = __importDefault(require("yaml"));
 const env_js_1 = require("../common/env.js");

package/dist/cache/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findFromCache = findFromCache;
-/* eslint-disable */
 const yaml_1 = __importDefault(require("yaml"));
 const node_js_1 = require("../common/node.js");
 const cache = new Map();

package/dist/common/internal.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAlphanumericLimitedHash = getAlphanumericLimitedHash;
 exports.getGlobalUniqueHash = getGlobalUniqueHash;
+/* eslint-disable */
 // Pure JS MD5 implementation (public domain, compact)
 function md5(input) {
     function cmn(q, a, b, x, s, t) {

package/dist/jobs/jobs.js

@@ -39,7 +39,7 @@ class BlJob {
         return this.externalUrl;
     }
     async call(url, tasks) {
-        let body = {
+        const body = {
             tasks: tasks
         };
         const response = await fetch(url + "/executions", {

package/dist/sandbox/filesystem/filesystem.d.ts

@@ -1,7 +1,7 @@
 import { Sandbox } from "../../client/types.gen.js";
 import { SandboxAction } from "../action.js";
 import { Directory, SuccessResponse } from "../client/index.js";
-import { CopyResponse, SandboxFilesystemFile, ToolWithExecute, ToolWithoutExecute, WatchEvent } from "./types.js";
+import { CopyResponse, SandboxFilesystemFile, WatchEvent } from "./types.js";
 export declare class SandboxFileSystem extends SandboxAction {
     constructor(sandbox: Sandbox);
     mkdir(path: string, permissions?: string): Promise<SuccessResponse>;
@@ -20,6 +20,4 @@ export declare class SandboxFileSystem extends SandboxAction {
         close: () => void;
     };
     private formatPath;
-    get toolsWithoutExecute(): ToolWithoutExecute;
-    get tools(): ToolWithExecute;
 }

package/dist/sandbox/filesystem/filesystem.js

@@ -9,7 +9,6 @@ const node_js_1 = require("../../common/node.js");
 const settings_js_1 = require("../../common/settings.js");
 const action_js_1 = require("../action.js");
 const index_js_1 = require("../client/index.js");
-const types_js_1 = require("./types.js");
 class SandboxFileSystem extends action_js_1.SandboxAction {
     constructor(sandbox) {
         super(sandbox);
@@ -290,155 +289,5 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         }
         return path;
     }
-    get toolsWithoutExecute() {
-        return {
-            cp: {
-                description: "Copy a file or directory",
-                parameters: types_js_1.CpParamsSchema,
-            },
-            mkdir: {
-                description: "Create a directory",
-                parameters: types_js_1.MkdirParamsSchema,
-            },
-            ls: {
-                description: "List a directory",
-                parameters: types_js_1.LsParamsSchema,
-            },
-            rm: {
-                description: "Remove a file or directory",
-                parameters: types_js_1.RmParamsSchema,
-            },
-            read: {
-                description: "Read a file",
-                parameters: types_js_1.ReadParamsSchema,
-            },
-            write: {
-                description: "Write a file",
-                parameters: types_js_1.WriteParamsSchema,
-            }
-        };
-    }
-    get tools() {
-        return {
-            cp: {
-                description: "Copy a file or directory",
-                parameters: types_js_1.CpParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.cp(args.source, args.destination);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                source: args.source,
-                                destination: args.destination
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            mkdir: {
-                description: "Create a directory",
-                parameters: types_js_1.MkdirParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.mkdir(args.path, args.permissions);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path,
-                                permissions: args.permissions
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            ls: {
-                description: "List a directory",
-                parameters: types_js_1.LsParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.ls(args.path);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            rm: {
-                description: "Remove a file or directory",
-                parameters: types_js_1.RmParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.rm(args.path, args.recursive);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path,
-                                recursive: args.recursive
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            read: {
-                description: "Read a file",
-                parameters: types_js_1.ReadParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.read(args.path);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            write: {
-                description: "Write a file",
-                parameters: types_js_1.WriteParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.write(args.path, args.content);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path,
-                                content: args.content
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            }
-        };
-    }
 }
 exports.SandboxFileSystem = SandboxFileSystem;

package/dist/sandbox/filesystem/types.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 export type CopyResponse = {
     message: string;
     source: string;
@@ -14,115 +13,3 @@ export type SandboxFilesystemFile = {
     path: string;
     content: string;
 };
-export declare const CpParamsSchema: z.ZodObject<{
-    source: z.ZodString;
-    destination: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    source: string;
-    destination: string;
-}, {
-    source: string;
-    destination: string;
-}>;
-export declare const MkdirParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-    permissions: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    permissions: string;
-}, {
-    path: string;
-    permissions?: string | undefined;
-}>;
-export declare const LsParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
-export declare const RmParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-    recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    recursive: boolean;
-}, {
-    path: string;
-    recursive?: boolean | undefined;
-}>;
-export declare const ReadParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
-export declare const WriteParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    content: string;
-}, {
-    path: string;
-    content: string;
-}>;
-export type ToolWithoutExecute = {
-    cp: {
-        description: string;
-        parameters: typeof CpParamsSchema;
-    };
-    mkdir: {
-        description: string;
-        parameters: typeof MkdirParamsSchema;
-    };
-    ls: {
-        description: string;
-        parameters: typeof LsParamsSchema;
-    };
-    rm: {
-        description: string;
-        parameters: typeof RmParamsSchema;
-    };
-    read: {
-        description: string;
-        parameters: typeof ReadParamsSchema;
-    };
-    write: {
-        description: string;
-        parameters: typeof WriteParamsSchema;
-    };
-};
-export type ToolWithExecute = {
-    cp: {
-        description: string;
-        parameters: typeof CpParamsSchema;
-        execute: (args: z.infer<typeof CpParamsSchema>) => Promise<string>;
-    };
-    mkdir: {
-        description: string;
-        parameters: typeof MkdirParamsSchema;
-        execute: (args: z.infer<typeof MkdirParamsSchema>) => Promise<string>;
-    };
-    ls: {
-        description: string;
-        parameters: typeof LsParamsSchema;
-        execute: (args: z.infer<typeof LsParamsSchema>) => Promise<string>;
-    };
-    rm: {
-        description: string;
-        parameters: typeof RmParamsSchema;
-        execute: (args: z.infer<typeof RmParamsSchema>) => Promise<string>;
-    };
-    read: {
-        description: string;
-        parameters: typeof ReadParamsSchema;
-        execute: (args: z.infer<typeof ReadParamsSchema>) => Promise<string>;
-    };
-    write: {
-        description: string;
-        parameters: typeof WriteParamsSchema;
-        execute: (args: z.infer<typeof WriteParamsSchema>) => Promise<string>;
-    };
-};

package/dist/sandbox/filesystem/types.js

@@ -1,26 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WriteParamsSchema = exports.ReadParamsSchema = exports.RmParamsSchema = exports.LsParamsSchema = exports.MkdirParamsSchema = exports.CpParamsSchema = void 0;
-const zod_1 = require("zod");
-exports.CpParamsSchema = zod_1.z.object({
-    source: zod_1.z.string().describe("Source file or directory path"),
-    destination: zod_1.z.string().describe("Destination file or directory path"),
-}).describe("Parameters for copying a file or directory");
-exports.MkdirParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("Directory path to create"),
-    permissions: zod_1.z.string().optional().default("0755").describe("Permissions for the new directory (default 0755)"),
-}).describe("Parameters for creating a directory");
-exports.LsParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("Directory path to list"),
-}).describe("Parameters for listing a directory");
-exports.RmParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("File or directory path to remove"),
-    recursive: zod_1.z.boolean().optional().default(false).describe("Whether to remove recursively (default false)"),
-}).describe("Parameters for removing a file or directory");
-exports.ReadParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("File path to read"),
-}).describe("Parameters for reading a file");
-exports.WriteParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("File path to write to"),
-    content: zod_1.z.string().describe("Content to write to the file"),
-}).describe("Parameters for writing to a file");

package/dist/sandbox/process/index.d.ts

@@ -1,2 +1 @@
 export * from "./process.js";
-export * from "./types.js";

package/dist/sandbox/process/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./process.js"), exports);
-__exportStar(require("./types.js"), exports);

package/dist/sandbox/process/process.d.ts

@@ -1,7 +1,6 @@
 import { Sandbox } from "../../client/types.gen.js";
 import { SandboxAction } from "../action.js";
 import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierResponse, GetProcessByIdentifierResponse, GetProcessResponse, PostProcessResponse, ProcessRequest } from "../client/index.js";
-import { ProcessToolWithExecute, ProcessToolWithoutExecute } from "./types.js";
 export declare class SandboxProcess extends SandboxAction {
     constructor(sandbox: Sandbox);
     streamLogs(identifier: string, options: {
@@ -21,6 +20,4 @@ export declare class SandboxProcess extends SandboxAction {
     stop(identifier: string): Promise<DeleteProcessByIdentifierResponse>;
     kill(identifier: string): Promise<DeleteProcessByIdentifierKillResponse>;
     logs(identifier: string, type?: "stdout" | "stderr" | "all"): Promise<string>;
-    get toolsWithoutExecute(): ProcessToolWithoutExecute;
-    get tools(): ProcessToolWithExecute;
 }

package/dist/sandbox/process/process.js

@@ -4,7 +4,6 @@ exports.SandboxProcess = void 0;
 const settings_js_1 = require("../../common/settings.js");
 const action_js_1 = require("../action.js");
 const index_js_1 = require("../client/index.js");
-const types_js_1 = require("./types.js");
 class SandboxProcess extends action_js_1.SandboxAction {
     constructor(sandbox) {
         super(sandbox);
@@ -141,132 +140,5 @@ class SandboxProcess extends action_js_1.SandboxAction {
         }
         throw new Error("Unsupported log type");
     }
-    get toolsWithoutExecute() {
-        return {
-            exec: {
-                description: "Execute a process in the sandbox",
-                parameters: types_js_1.ExecParamsSchema,
-            },
-            wait: {
-                description: "Wait for a process to finish by identifier",
-                parameters: types_js_1.WaitParamsSchema,
-            },
-            get: {
-                description: "Get process info by identifier",
-                parameters: types_js_1.GetParamsSchema,
-            },
-            list: {
-                description: "List all processes in the sandbox",
-                parameters: types_js_1.ListParamsSchema,
-            },
-            stop: {
-                description: "Stop a process by identifier",
-                parameters: types_js_1.StopParamsSchema,
-            },
-            kill: {
-                description: "Kill a process by identifier",
-                parameters: types_js_1.KillParamsSchema,
-            },
-            logs: {
-                description: "Get logs for a process by identifier",
-                parameters: types_js_1.LogsParamsSchema,
-            },
-        };
-    }
-    get tools() {
-        return {
-            exec: {
-                description: "Execute a process in the sandbox",
-                parameters: types_js_1.ExecParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.exec(args.process);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message, process: args.process });
-                    }
-                },
-            },
-            wait: {
-                description: "Wait for a process to finish by identifier",
-                parameters: types_js_1.WaitParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.wait(args.identifier, { maxWait: args.maxWait, interval: args.interval });
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message, identifier: args.identifier });
-                    }
-                },
-            },
-            get: {
-                description: "Get process info by identifier",
-                parameters: types_js_1.GetParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.get(args.identifier);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message, identifier: args.identifier });
-                    }
-                },
-            },
-            list: {
-                description: "List all processes in the sandbox",
-                parameters: types_js_1.ListParamsSchema,
-                execute: async () => {
-                    try {
-                        const result = await this.list();
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message });
-                    }
-                },
-            },
-            stop: {
-                description: "Stop a process by identifier",
-                parameters: types_js_1.StopParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.stop(args.identifier);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message, identifier: args.identifier });
-                    }
-                },
-            },
-            kill: {
-                description: "Kill a process by identifier",
-                parameters: types_js_1.KillParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.kill(args.identifier);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message, identifier: args.identifier });
-                    }
-                },
-            },
-            logs: {
-                description: "Get logs for a process by identifier",
-                parameters: types_js_1.LogsParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.logs(args.identifier, args.type || "all");
-                        return JSON.stringify({ logs: result });
-                    }
-                    catch (e) {
-                        return JSON.stringify({ message: e.message, identifier: args.identifier });
-                    }
-                },
-            },
-        };
-    }
 }
 exports.SandboxProcess = SandboxProcess;

package/dist/tools/mcpTool.d.ts

@@ -1,6 +1,8 @@
 import { Tool } from "./types.js";
 export declare class McpTool {
     private name;
+    private type;
+    private pluralType;
     private client;
     private transport?;
     private timer?;

package/dist/tools/mcpTool.js

@@ -13,6 +13,8 @@ const zodSchema_js_1 = require("./zodSchema.js");
 const McpToolCache = new Map();
 class McpTool {
     name;
+    type;
+    pluralType;
     client;
     transport;
     timer;
@@ -20,6 +22,13 @@ class McpTool {
     startPromise;
     constructor(name, ms = 5000) {
         this.name = name;
+        this.type = "function";
+        this.pluralType = "functions";
+        if (name.startsWith("sandbox/") || name.startsWith("sandboxes/")) {
+            this.name = name.split("/")[1];
+            this.type = "sandbox";
+            this.pluralType = "sandboxes";
+        }
         if (env_js_1.env.BL_CLOUD) {
             this.ms = 0;
         }
@@ -42,16 +51,16 @@ class McpTool {
         return null;
     }
     get externalUrl() {
-        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/functions/${this.name}`);
+        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/${this.pluralType}/${this.name}`);
     }
     get internalUrl() {
-        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "function", this.name);
+        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() {
         const envVar = this.name.replace(/-/g, "_").toUpperCase();
-        if (env_js_1.env[`BL_FUNCTION_${envVar}_URL`]) {
-            return new URL(env_js_1.env[`BL_FUNCTION_${envVar}_URL`]);
+        if (env_js_1.env[`BL_${this.pluralType.toUpperCase()}_${envVar}_URL`]) {
+            return new URL(env_js_1.env[`BL_${this.pluralType.toUpperCase()}_${envVar}_URL`]);
         }
         return null;
     }
@@ -68,7 +77,8 @@ class McpTool {
         this.startPromise = this.startPromise || (async () => {
             await (0, index_js_2.authenticate)();
             try {
-                logger_js_1.logger.debug(`MCP:${this.name}:Connecting`);
+                logger_js_1.logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
+                console.log("MCP: Connecting to");
                 this.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers);
                 await this.client.connect(this.transport);
                 logger_js_1.logger.debug(`MCP:${this.name}:Connected`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.10",
+  "version": "0.2.11-dev.88",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",

package/dist/sandbox/process/types.d.ts

@@ -1,120 +0,0 @@
-import { z } from "zod";
-export declare const ExecParamsSchema: z.ZodObject<{
-    process: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    process?: any;
-}, {
-    process?: any;
-}>;
-export declare const WaitParamsSchema: z.ZodObject<{
-    identifier: z.ZodString;
-    maxWait: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    interval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    identifier: string;
-    maxWait: number;
-    interval: number;
-}, {
-    identifier: string;
-    maxWait?: number | undefined;
-    interval?: number | undefined;
-}>;
-export declare const GetParamsSchema: z.ZodObject<{
-    identifier: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    identifier: string;
-}, {
-    identifier: string;
-}>;
-export declare const ListParamsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const StopParamsSchema: z.ZodObject<{
-    identifier: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    identifier: string;
-}, {
-    identifier: string;
-}>;
-export declare const KillParamsSchema: z.ZodObject<{
-    identifier: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    identifier: string;
-}, {
-    identifier: string;
-}>;
-export declare const LogsParamsSchema: z.ZodObject<{
-    identifier: z.ZodString;
-    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["stdout", "stderr", "all"]>>>;
-}, "strip", z.ZodTypeAny, {
-    type: "stdout" | "stderr" | "all";
-    identifier: string;
-}, {
-    identifier: string;
-    type?: "stdout" | "stderr" | "all" | undefined;
-}>;
-export type ProcessToolWithoutExecute = {
-    exec: {
-        description: string;
-        parameters: typeof ExecParamsSchema;
-    };
-    wait: {
-        description: string;
-        parameters: typeof WaitParamsSchema;
-    };
-    get: {
-        description: string;
-        parameters: typeof GetParamsSchema;
-    };
-    list: {
-        description: string;
-        parameters: typeof ListParamsSchema;
-    };
-    stop: {
-        description: string;
-        parameters: typeof StopParamsSchema;
-    };
-    kill: {
-        description: string;
-        parameters: typeof KillParamsSchema;
-    };
-    logs: {
-        description: string;
-        parameters: typeof LogsParamsSchema;
-    };
-};
-export type ProcessToolWithExecute = {
-    exec: {
-        description: string;
-        parameters: typeof ExecParamsSchema;
-        execute: (args: z.infer<typeof ExecParamsSchema>) => Promise<string>;
-    };
-    wait: {
-        description: string;
-        parameters: typeof WaitParamsSchema;
-        execute: (args: z.infer<typeof WaitParamsSchema>) => Promise<string>;
-    };
-    get: {
-        description: string;
-        parameters: typeof GetParamsSchema;
-        execute: (args: z.infer<typeof GetParamsSchema>) => Promise<string>;
-    };
-    list: {
-        description: string;
-        parameters: typeof ListParamsSchema;
-        execute: (args: z.infer<typeof ListParamsSchema>) => Promise<string>;
-    };
-    stop: {
-        description: string;
-        parameters: typeof StopParamsSchema;
-        execute: (args: z.infer<typeof StopParamsSchema>) => Promise<string>;
-    };
-    kill: {
-        description: string;
-        parameters: typeof KillParamsSchema;
-        execute: (args: z.infer<typeof KillParamsSchema>) => Promise<string>;
-    };
-    logs: {
-        description: string;
-        parameters: typeof LogsParamsSchema;
-        execute: (args: z.infer<typeof LogsParamsSchema>) => Promise<string>;
-    };
-};

package/dist/sandbox/process/types.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogsParamsSchema = exports.KillParamsSchema = exports.StopParamsSchema = exports.ListParamsSchema = exports.GetParamsSchema = exports.WaitParamsSchema = exports.ExecParamsSchema = void 0;
-const zod_1 = require("zod");
-exports.ExecParamsSchema = zod_1.z.object({
-    process: zod_1.z.any().describe("ProcessRequest object to execute in the sandbox"), // Refine if you have a zod schema for ProcessRequest
-}).describe("Parameters for executing a process in the sandbox");
-exports.WaitParamsSchema = zod_1.z.object({
-    identifier: zod_1.z.string().describe("Process identifier to wait for"),
-    maxWait: zod_1.z.number().optional().default(60000).describe("Maximum wait time in milliseconds (default 60000)"),
-    interval: zod_1.z.number().optional().default(1000).describe("Polling interval in milliseconds (default 1000)"),
-}).describe("Parameters for waiting for a process to finish");
-exports.GetParamsSchema = zod_1.z.object({
-    identifier: zod_1.z.string().describe("Process identifier to get info for"),
-}).describe("Parameters for getting process info");
-exports.ListParamsSchema = zod_1.z.object({}).describe("Parameters for listing all processes (none)");
-exports.StopParamsSchema = zod_1.z.object({
-    identifier: zod_1.z.string().describe("Process identifier to stop"),
-}).describe("Parameters for stopping a process");
-exports.KillParamsSchema = zod_1.z.object({
-    identifier: zod_1.z.string().describe("Process identifier to kill"),
-}).describe("Parameters for killing a process");
-exports.LogsParamsSchema = zod_1.z.object({
-    identifier: zod_1.z.string().describe("Process identifier to get logs for"),
-    type: zod_1.z.enum(["stdout", "stderr", "all"]).optional().default("all").describe("Type of logs to retrieve: stdout, stderr, or all (default all)"),
-}).describe("Parameters for retrieving process logs");