@blaxel/core 0.2.40 → 0.2.41-preview.91

package/dist/esm/sandbox/filesystem/filesystem.js

@@ -1,6 +1,6 @@
 import { settings } from "../../common/settings.js";
 import { SandboxAction } from "../action.js";
-import { deleteFilesystemByPath, getFilesystemByPath, getWatchFilesystemByPath, putFilesystemByPath } from "../client/index.js";
+import { deleteFilesystemByPath, getFilesystemByPath, getWatchFilesystemByPath, putFilesystemByPath, postProcess } from "../client/index.js";
 export class SandboxFileSystem extends SandboxAction {
     constructor(sandbox) {
         super(sandbox);
@@ -131,53 +131,20 @@ export class SandboxFileSystem extends SandboxAction {
     async cp(source, destination) {
         source = this.formatPath(source);
         destination = this.formatPath(destination);
-        const { response, data, error } = await getFilesystemByPath({
-            path: { path: source },
+        const process = {
+            command: `cp -r "${source}" "${destination}"`
+        };
+        const { response, data, error } = await postProcess({
+            body: process,
             baseUrl: this.url,
             client: this.client,
         });
         this.handleResponseError(response, data, error);
-        if (data && ('files' in data || 'subdirectories' in data)) {
-            // Create destination directory
-            await this.mkdir(destination);
-            // Process subdirectories in batches of 5
-            const subdirectories = data.subdirectories || [];
-            for (let i = 0; i < subdirectories.length; i += 5) {
-                const batch = subdirectories.slice(i, i + 5);
-                await Promise.all(batch.map(async (subdir) => {
-                    const sourcePath = subdir.path || `${source}/${subdir.path}`;
-                    const destPath = `${destination}/${subdir.path}`;
-                    await this.cp(sourcePath, destPath);
-                }));
-            }
-            // Process files in batches of 10
-            const files = data.files || [];
-            for (let i = 0; i < files.length; i += 10) {
-                const batch = files.slice(i, i + 10);
-                await Promise.all(batch.map(async (file) => {
-                    const sourcePath = file.path || `${source}/${file.path}`;
-                    const destPath = `${destination}/${file.path}`;
-                    const fileContent = await this.read(sourcePath);
-                    if (typeof fileContent === 'string') {
-                        await this.write(destPath, fileContent);
-                    }
-                }));
-            }
-            return {
-                message: "Directory copied successfully",
-                source,
-                destination,
-            };
-        }
-        else if (data && 'content' in data) {
-            await this.write(destination, data.content);
-            return {
-                message: "File copied successfully",
-                source,
-                destination,
-            };
-        }
-        throw new Error("Unsupported file type");
+        return {
+            message: "Files copied",
+            source,
+            destination,
+        };
     }
     watch(path, callback, options) {
         path = this.formatPath(path);
@@ -216,7 +183,11 @@ export class SandboxFileSystem extends SandboxAction {
                         const trimmed = line.trim();
                         if (!trimmed)
                             continue;
-                        const fileEvent = JSON.parse(line.trim());
+                        // Skip keepalive messages
+                        if (line.startsWith("[keepalive]")) {
+                            continue;
+                        }
+                        const fileEvent = JSON.parse(trimmed);
                         if (options?.withContent && ["CREATE", "WRITE"].includes(fileEvent.op)) {
                             try {
                                 let filePath = "";

package/dist/esm/tools/mcpTool.js

@@ -7,6 +7,7 @@ import { authenticate } from "../index.js";
 import { BlaxelMcpClientTransport } from "../mcp/client.js";
 import { startSpan } from "../telemetry/telemetry.js";
 import { schemaToZodSchema } from "./zodSchema.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 const McpToolCache = new Map();
 export class McpTool {
     name;
@@ -16,6 +17,7 @@ export class McpTool {
     transport;
     timer;
     ms;
+    transportName;
     meta;
     startPromise;
     constructor(name, options = { ms: 5000 }) {
@@ -73,7 +75,7 @@ export class McpTool {
             await authenticate();
             try {
                 logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
-                this.transport = new BlaxelMcpClientTransport(this.url.toString(), settings.headers, { retry: { max: 0 } });
+                this.transport = await this.getTransport();
                 await this.client.connect(this.transport);
                 logger.debug(`MCP:${this.name}:Connected`);
             }
@@ -90,7 +92,7 @@ export class McpTool {
                     throw err;
                 }
                 logger.debug(`MCP:${this.name}:Connecting to fallback`);
-                this.transport = new BlaxelMcpClientTransport(this.fallbackUrl.toString(), settings.headers);
+                this.transport = await this.getTransport(this.fallbackUrl);
                 await this.client.connect(this.transport);
                 logger.debug(`MCP:${this.name}:Connected to fallback`);
             }
@@ -201,6 +203,39 @@ export class McpTool {
             span.end();
         }
     }
+    async getTransport(forcedUrl) {
+        if (!this.transportName) {
+            // Detect transport type dynamically by querying the function's endpoint
+            try {
+                const testUrl = (forcedUrl || this.url).toString();
+                const response = await fetch(testUrl + "/", {
+                    method: "GET",
+                    headers: settings.headers,
+                });
+                const responseText = await response.text();
+                if (responseText.toLowerCase().includes("websocket")) {
+                    this.transportName = "websocket";
+                }
+                else {
+                    this.transportName = "http-stream";
+                }
+                logger.debug(`Detected transport type for ${this.name}: ${this.transportName}`);
+            }
+            catch (error) {
+                // Default to websocket if we can't determine the transport type
+                logger.warn(`Failed to detect transport type for ${this.name}: ${error}. Defaulting to websocket.`);
+                this.transportName = "websocket";
+            }
+        }
+        const url = forcedUrl || this.url;
+        if (this.transportName === "http-stream") {
+            url.pathname = url.pathname + "/mcp";
+            return new StreamableHTTPClientTransport(url, { requestInit: { headers: settings.headers } });
+        }
+        else {
+            return new BlaxelMcpClientTransport(url.toString(), settings.headers, { retry: { max: 0 } });
+        }
+    }
 }
 export const getMcpTool = async (name, options) => {
     let tool = McpToolCache.get(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.40",
+  "version": "0.2.41-preview.91",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -63,7 +63,7 @@
     "vite": "^5.2.0",
     "vitest": "^1.5.0"
   },
-  "commit": "9d887e963254d2a0f1d1d1aaab98198a3aa18b6b",
+  "commit": "68b2b0f03efd40f1ae2dcf83d21bfa7312b80282",
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",