@@ -8,11 +8,46 @@
  * - Cannot access Node.js APIs by design
  *
  * This is the most secure sandbox option available in Node.js.
+ *
+ * Note: isolated-vm requires V8 and won't work on:
+ * - Bun (uses JavaScriptCore)
+ * - Node.js 25+ (V8 API changes)
  */
 
-import ivm from 'isolated-vm';
 import { logger } from '../../utils/logger.js';
 
+// Lazy-loaded isolated-vm module (may fail on Bun or incompatible runtimes)
+let ivm: typeof import('isolated-vm') | null = null;
+let ivmLoadAttempted = false;
+let ivmLoadError: string | null = null;
+
+/**
+ * Lazily load isolated-vm module
+ * Returns null if loading fails (e.g., on Bun or incompatible Node.js versions)
+ */
+async function getIVM(): Promise<typeof import('isolated-vm') | null> {
+  if (ivmLoadAttempted) {
+    return ivm;
+  }
+  ivmLoadAttempted = true;
+
+  try {
+    ivm = await import('isolated-vm');
+    return ivm;
+  } catch (e) {
+    ivmLoadError = (e as Error)?.message ?? String(e);
+    logger.debug(`Failed to load isolated-vm: ${ivmLoadError}`);
+    return null;
+  }
+}
+
+/**
+ * Synchronously check if isolated-vm was loaded (for isAvailable check)
+ */
+function getIVMSync(): typeof import('isolated-vm') | null {
+  return ivm;
+}
+
 /**
  * Tool definition for the sandbox
  */
@@ -65,7 +100,7 @@ const DEFAULT_CONFIG: IsolatedVMSandboxConfig = {
  */
 export class IsolatedVMSandbox {
   private config: IsolatedVMSandboxConfig;
-  private isolate: ivm.Isolate | null = null;
+  private isolate: any = null;  // ivm.Isolate (lazy loaded)
 
   constructor(config?: Partial<IsolatedVMSandboxConfig>) {
     this.config = { ...DEFAULT_CONFIG, ...config };
@@ -87,9 +122,15 @@ export class IsolatedVMSandbox {
     const startTime = Date.now();
     const logs: string[] = [];
 
+    // Load isolated-vm module
+    const ivmModule = await getIVM();
+    if (!ivmModule) {
+      throw new Error(`isolated-vm not available: ${ivmLoadError || 'module failed to load'}`);
+    }
+
     try {
       // Create isolated V8 isolate with memory limit
-      this.isolate = new ivm.Isolate({
+      this.isolate = new ivmModule.Isolate({
         memoryLimit: this.config.memoryLimit,
         inspector: this.config.inspector,
       });
@@ -104,10 +145,10 @@ export class IsolatedVMSandbox {
       await jail.set('global', jail.derefInto());
 
       // Create log capture
-      await this.setupLogging(context, jail, logs);
+      await this.setupLogging(ivmModule, context, jail, logs);
 
       // Create tool callback system
-      await this.setupToolCallbacks(context, jail, tools, toolExecutor);
+      await this.setupToolCallbacks(ivmModule, context, jail, tools, toolExecutor);
 
       // Set up basic utilities (JSON is built into V8)
       await this.setupUtilities(jail);
@@ -127,7 +168,7 @@ export class IsolatedVMSandbox {
 
       // Copy result out of isolate
       const result = typeof resultRef === 'object' && resultRef !== null
-        ? await (resultRef as ivm.Reference<unknown>).copy()
+        ? await resultRef.copy()
         : resultRef;
 
       const duration = Date.now() - startTime;
@@ -147,6 +188,9 @@ export class IsolatedVMSandbox {
         errorMessage = 'Execution terminated (memory limit exceeded)';
       } else if (errorMessage.includes('Script execution timed out')) {
         errorMessage = `Execution timeout after ${this.config.timeout}ms`;
+      } else if (errorMessage.includes('undefined') && errorMessage.includes('length')) {
+        // Node.js 25+ V8 API incompatibility
+        errorMessage = 'V8 callback API incompatibility - please use Node.js 22-24 or set NCP_DISABLE_ISOLATED_VM=true';
       }
 
       return {
@@ -165,26 +209,27 @@ export class IsolatedVMSandbox {
    * Set up logging in the isolated context
    */
   private async setupLogging(
-    context: ivm.Context,
-    jail: ivm.Reference<Record<string, unknown>>,
+    ivmModule: typeof import('isolated-vm'),
+    context: any,  // ivm.Context
+    jail: any,     // ivm.Reference<Record<string, unknown>>
     logs: string[]
   ): Promise<void> {
     // Create log callback that runs in main thread
-    const logCallback = new ivm.Callback((...args: unknown[]) => {
+    const logCallback = new ivmModule.Callback((...args: unknown[]) => {
       const message = args
         .map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
         .join(' ');
       logs.push(message);
     });
 
-    const errorCallback = new ivm.Callback((...args: unknown[]) => {
+    const errorCallback = new ivmModule.Callback((...args: unknown[]) => {
       const message =
         '[ERROR] ' +
         args.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg))).join(' ');
       logs.push(message);
     });
 
-    const warnCallback = new ivm.Callback((...args: unknown[]) => {
+    const warnCallback = new ivmModule.Callback((...args: unknown[]) => {
       const message =
         '[WARN] ' +
         args.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg))).join(' ');
@@ -210,13 +255,14 @@ export class IsolatedVMSandbox {
    * Set up tool callbacks in the isolated context
    */
   private async setupToolCallbacks(
-    context: ivm.Context,
-    jail: ivm.Reference<Record<string, unknown>>,
+    ivmModule: typeof import('isolated-vm'),
+    context: any,  // ivm.Context
+    jail: any,     // ivm.Reference<Record<string, unknown>>
     tools: IsolatedVMTool[],
     toolExecutor: (toolName: string, params: unknown) => Promise<unknown>
   ): Promise<void> {
     // Create a callback that executes tools in the main thread
-    const executeToolCallback = new ivm.Callback(
+    const executeToolCallback = new ivmModule.Callback(
       async (toolName: string, paramsJson: string): Promise<string> => {
         try {
           const params = paramsJson ? JSON.parse(paramsJson) : {};
@@ -279,7 +325,7 @@ export class IsolatedVMSandbox {
   /**
    * Set up basic utilities in the isolated context
    */
-  private async setupUtilities(jail: ivm.Reference<Record<string, unknown>>): Promise<void> {
+  private async setupUtilities(jail: any): Promise<void> {  // ivm.Reference<Record<string, unknown>>
     // JSON, Promise, Array, Object, etc. are already available in V8
     // We just need to ensure they're accessible
 
@@ -323,29 +369,70 @@ export class IsolatedVMSandbox {
   }
 
   /**
-   * Check if the sandbox is available (isolated-vm is installed)
+   * Check if the sandbox is available (isolated-vm is installed and working)
+   *
+   * Returns false in cases where isolated-vm won't work:
+   * - Node.js 25+ (V8 API changes cause "Cannot read properties of undefined (reading 'length')")
+   * - Bun runtime (uses JavaScriptCore, not V8)
+   * - Environment variable NCP_DISABLE_ISOLATED_VM=true
+   * - Module load failures
    */
   static isAvailable(): boolean {
     if (process.env.NCP_DISABLE_ISOLATED_VM === 'true') {
       logger.warn('isolated-vm sandbox disabled via NCP_DISABLE_ISOLATED_VM');
       return false;
     }
 
+    // Check for Bun runtime (uses JavaScriptCore, not V8)
+    if (typeof (process.versions as any).bun !== 'undefined') {
+      logger.warn('isolated-vm unavailable: Bun runtime uses JavaScriptCore, not V8');
+      return false;
+    }
+
+    // Check Node.js version - isolated-vm has issues with Node.js 25+
+    const nodeVersion = process.versions.node;
+    const majorVersion = parseInt(nodeVersion.split('.')[0], 10);
+    if (majorVersion >= 25) {
+      logger.warn(`isolated-vm unavailable: Node.js ${nodeVersion} has V8 API changes that break isolated-vm`);
+      return false;
+    }
+
+    // If module already failed to load, return false
+    if (ivmLoadAttempted && !ivm) {
+      logger.warn(`isolated-vm unavailable: ${ivmLoadError || 'module failed to load'}`);
+      return false;
+    }
+
+    // If module not yet loaded, try synchronous check
+    // This will be attempted again in execute() with async loading
+    if (!ivmLoadAttempted) {
+      // Return true optimistically - the async load in execute() will handle failures
+      return true;
+    }
+
     try {
-      // Try to create a minimal isolate to verify the module works
-      const testIsolate = new ivm.Isolate({ memoryLimit: 8 });
+      // Module is loaded, try to create a minimal isolate to verify it works
+      const testIsolate = new ivm!.Isolate({ memoryLimit: 8 });
       testIsolate.dispose();
       return true;
     } catch (e) {
-      logger.warn(`isolated-vm unavailable: ${(e as Error)?.message ?? e}`);
+      const errorMessage = (e as Error)?.message ?? String(e);
+      // Detect common failure patterns
+      if (errorMessage.includes('undefined') && errorMessage.includes('length')) {
+        logger.warn('isolated-vm unavailable: V8 callback API incompatibility detected');
+      } else if (errorMessage.includes('ERR_DLOPEN_FAILED') || errorMessage.includes('undefined symbol')) {
+        logger.warn('isolated-vm unavailable: Native module incompatibility (possibly Bun or unsupported runtime)');
+      } else {
+        logger.warn(`isolated-vm unavailable: ${errorMessage}`);
+      }
       return false;
     }
   }
 
   /**
    * Get memory usage of the current isolate
    */
-  getHeapStatistics(): ivm.HeapStatistics | null {
+  getHeapStatistics(): any | null {  // ivm.HeapStatistics
     if (!this.isolate) return null;
 
     try {
 
@@ -61,27 +61,42 @@ export class ProfileManager {
     // Store token/API key
     if (config.auth.token) {
       const type: CredentialType = config.auth.type === 'bearer' ? 'bearer_token' : 'api_key';
-      await this.credentialStore.setCredential(
+      const success = await this.credentialStore.setCredential(
         mcpName,
         type,
         config.auth.token,
         `${config.auth.type} credential for ${mcpName}`
       );
-      // Replace with secure reference
-      securConfig.auth.token = '_USE_SECURE_STORAGE_';
+
+      if (success) {
+        // Only replace with secure reference if storage succeeded
+        securConfig.auth.token = '_USE_SECURE_STORAGE_';
+        logger.debug(`Stored ${type} for ${mcpName} in secure storage`);
+      } else {
+        // Storage failed - keep the token in the config as fallback
+        // This is less secure but ensures the MCP can still work
+        logger.warn(`Failed to store ${type} for ${mcpName} in secure storage - keeping in profile`);
+      }
     }
 
     // Store basic auth credentials
     if (config.auth.username && config.auth.password) {
-      await this.credentialStore.setCredential(
+      const success = await this.credentialStore.setCredential(
         mcpName,
         'basic_auth',
         { username: config.auth.username, password: config.auth.password },
         `Basic auth credentials for ${mcpName}`
       );
-      // Replace with secure references
-      securConfig.auth.username = '_USE_SECURE_STORAGE_';
-      securConfig.auth.password = '_USE_SECURE_STORAGE_';
+
+      if (success) {
+        // Only replace with secure references if storage succeeded
+        securConfig.auth.username = '_USE_SECURE_STORAGE_';
+        securConfig.auth.password = '_USE_SECURE_STORAGE_';
+        logger.debug(`Stored basic auth for ${mcpName} in secure storage`);
+      } else {
+        // Storage failed - keep credentials in the config as fallback
+        logger.warn(`Failed to store basic auth for ${mcpName} in secure storage - keeping in profile`);
+      }
     }
 
     return securConfig;
@@ -262,11 +277,25 @@ export class ProfileManager {
 
         try {
           // Remove metadata fields before adding (internal use only)
-          const cleanConfig = {
-            command: config.command,
-            args: config.args || [],
-            env: config.env || {}
-          };
+          // Support both stdio (command) and HTTP (url) transport types
+          const cleanConfig: MCPConfig = {};
+
+          // Stdio transport fields
+          if (config.command) {
+            cleanConfig.command = config.command;
+            cleanConfig.args = config.args || [];
+            cleanConfig.env = config.env || {};
+          }
+
+          // HTTP/SSE transport fields
+          if (config.url) {
+            cleanConfig.url = config.url;
+          }
+
+          // Auth configuration (for HTTP MCPs)
+          if (config.auth) {
+            cleanConfig.auth = config.auth;
+          }
 
           // Use addMCPToProfile to ensure cache updates happen
           await this.addMCPToProfile('all', name, cleanConfig);