@cloudflare/sandbox 0.2.1 → 0.2.2

package/container_src/jupyter-service.ts

@@ -0,0 +1,448 @@
+import { existsSync } from "node:fs";
+import { CircuitBreaker } from "./circuit-breaker";
+import { type CreateContextRequest, JupyterServer } from "./jupyter-server";
+
+interface PoolStats {
+  available: number;
+  inUse: number;
+  total: number;
+  minSize: number;
+  maxSize: number;
+  warming: boolean;
+}
+
+interface CircuitBreakerState {
+  state: string;
+  failures: number;
+  lastFailure: number;
+  isOpen: boolean;
+}
+
+export interface JupyterHealthStatus {
+  ready: boolean;
+  initializing: boolean;
+  error?: string;
+  checks?: {
+    httpApi: boolean;
+    kernelManager: boolean;
+    markerFile: boolean;
+    kernelSpawn?: boolean;
+    websocket?: boolean;
+  };
+  timestamp: number;
+  performance?: {
+    poolStats?: Record<string, PoolStats>;
+    activeContexts?: number;
+    uptime?: number;
+    circuitBreakers?: {
+      contextCreation: CircuitBreakerState;
+      codeExecution: CircuitBreakerState;
+      kernelCommunication: CircuitBreakerState;
+    };
+  };
+}
+
+/**
+ * Wrapper service that provides graceful degradation for Jupyter functionality
+ */
+export class JupyterService {
+  private jupyterServer: JupyterServer;
+  private initPromise: Promise<void> | null = null;
+  private initialized = false;
+  private initError: Error | null = null;
+  private startTime = Date.now();
+  private circuitBreakers: {
+    contextCreation: CircuitBreaker;
+    codeExecution: CircuitBreaker;
+    kernelCommunication: CircuitBreaker;
+  };
+
+  constructor() {
+    this.jupyterServer = new JupyterServer();
+
+    // Initialize circuit breakers for different operations
+    this.circuitBreakers = {
+      contextCreation: new CircuitBreaker({
+        name: "context-creation",
+        threshold: 3,
+        timeout: 60000, // 1 minute
+      }),
+      codeExecution: new CircuitBreaker({
+        name: "code-execution",
+        threshold: 5,
+        timeout: 30000, // 30 seconds
+      }),
+      kernelCommunication: new CircuitBreaker({
+        name: "kernel-communication",
+        threshold: 10,
+        timeout: 20000, // 20 seconds
+      }),
+    };
+  }
+
+  /**
+   * Initialize Jupyter server with retry logic
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    if (!this.initPromise) {
+      this.initPromise = this.doInitialize()
+        .then(() => {
+          this.initialized = true;
+          console.log("[JupyterService] Initialization complete");
+        })
+        .catch((err) => {
+          this.initError = err;
+          // Don't null out initPromise on error - keep it so we can return the same error
+          console.error("[JupyterService] Initialization failed:", err);
+          throw err;
+        });
+    }
+
+    return this.initPromise;
+  }
+
+  private async doInitialize(): Promise<void> {
+    // Wait for Jupyter marker file or timeout
+    const markerCheckPromise = this.waitForMarkerFile();
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      setTimeout(
+        () => reject(new Error("Jupyter initialization timeout")),
+        60000
+      );
+    });
+
+    try {
+      await Promise.race([markerCheckPromise, timeoutPromise]);
+      console.log("[JupyterService] Jupyter process detected via marker file");
+    } catch (error) {
+      console.log(
+        "[JupyterService] Marker file not found yet - proceeding with initialization"
+      );
+    }
+
+    // Initialize Jupyter server
+    await this.jupyterServer.initialize();
+
+    // Pre-warm context pools in background after Jupyter is ready
+    this.warmContextPools();
+  }
+
+  /**
+   * Pre-warm context pools for better performance
+   */
+  private async warmContextPools() {
+    try {
+      console.log(
+        "[JupyterService] Pre-warming context pools for better performance"
+      );
+
+      // Enable pool warming with min sizes
+      await this.jupyterServer.enablePoolWarming("python", 1);
+      await this.jupyterServer.enablePoolWarming("javascript", 1);
+    } catch (error) {
+      console.error("[JupyterService] Error pre-warming context pools:", error);
+    }
+  }
+
+  private async waitForMarkerFile(): Promise<void> {
+    const markerPath = "/tmp/jupyter-ready";
+    let attempts = 0;
+    const maxAttempts = 120; // 2 minutes with 1s intervals
+
+    while (attempts < maxAttempts) {
+      if (existsSync(markerPath)) {
+        return;
+      }
+      attempts++;
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+
+    throw new Error("Marker file not found within timeout");
+  }
+
+  /**
+   * Get current health status
+   */
+  async getHealthStatus(): Promise<JupyterHealthStatus> {
+    const status: JupyterHealthStatus = {
+      ready: this.initialized,
+      initializing: this.initPromise !== null && !this.initialized,
+      timestamp: Date.now(),
+    };
+
+    if (this.initError) {
+      status.error = this.initError.message;
+    }
+
+    // Detailed health checks
+    if (this.initialized || this.initPromise) {
+      status.checks = {
+        httpApi: await this.checkHttpApi(),
+        kernelManager: this.initialized,
+        markerFile: existsSync("/tmp/jupyter-ready"),
+      };
+
+      // Advanced health checks only if fully initialized
+      if (this.initialized) {
+        const advancedChecks = await this.performAdvancedHealthChecks();
+        status.checks.kernelSpawn = advancedChecks.kernelSpawn;
+        status.checks.websocket = advancedChecks.websocket;
+
+        // Performance metrics
+        status.performance = {
+          poolStats: await this.jupyterServer.getPoolStats(),
+          activeContexts: (await this.jupyterServer.listContexts()).length,
+          uptime: Date.now() - this.startTime,
+        };
+      }
+    }
+
+    // Add circuit breaker status
+    if (status.performance) {
+      status.performance.circuitBreakers = {
+        contextCreation: this.circuitBreakers.contextCreation.getState(),
+        codeExecution: this.circuitBreakers.codeExecution.getState(),
+        kernelCommunication:
+          this.circuitBreakers.kernelCommunication.getState(),
+      };
+    }
+
+    return status;
+  }
+
+  private async checkHttpApi(): Promise<boolean> {
+    try {
+      const response = await fetch("http://localhost:8888/api", {
+        signal: AbortSignal.timeout(2000),
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Perform advanced health checks including kernel spawn and WebSocket
+   */
+  private async performAdvancedHealthChecks(): Promise<{
+    kernelSpawn: boolean;
+    websocket: boolean;
+  }> {
+    const checks = {
+      kernelSpawn: false,
+      websocket: false,
+    };
+
+    try {
+      // Test kernel spawn with timeout
+      const testContext = await Promise.race([
+        this.jupyterServer.createContext({ language: "python" }),
+        new Promise<null>((_, reject) =>
+          setTimeout(() => reject(new Error("Kernel spawn timeout")), 5000)
+        ),
+      ]);
+
+      if (testContext) {
+        checks.kernelSpawn = true;
+
+        // Test WebSocket by executing simple code
+        try {
+          const result = await Promise.race([
+            this.jupyterServer.executeCode(
+              testContext.id,
+              "print('health_check')"
+            ),
+            new Promise<null>((_, reject) =>
+              setTimeout(() => reject(new Error("WebSocket timeout")), 3000)
+            ),
+          ]);
+
+          checks.websocket = result !== null;
+        } catch {
+          // WebSocket test failed
+        }
+
+        // Clean up test context
+        try {
+          await this.jupyterServer.deleteContext(testContext.id);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    } catch (error) {
+      console.log("[JupyterService] Advanced health check failed:", error);
+    }
+
+    return checks;
+  }
+
+  /**
+   * Ensure Jupyter is initialized before proceeding
+   * This will wait for initialization to complete or fail
+   */
+  private async ensureInitialized(timeoutMs: number = 30000): Promise<void> {
+    if (this.initialized) return;
+
+    // Start initialization if not already started
+    if (!this.initPromise) {
+      this.initPromise = this.initialize();
+    }
+
+    // Wait for initialization with timeout
+    try {
+      await Promise.race([
+        this.initPromise,
+        new Promise<never>((_, reject) =>
+          setTimeout(
+            () =>
+              reject(new Error("Timeout waiting for Jupyter initialization")),
+            timeoutMs
+          )
+        ),
+      ]);
+    } catch (error) {
+      // If it's a timeout and Jupyter is still initializing, throw a retryable error
+      if (
+        error instanceof Error &&
+        error.message.includes("Timeout") &&
+        !this.initError
+      ) {
+        throw new JupyterNotReadyError(
+          "Jupyter is taking longer than expected to initialize. Please try again.",
+          {
+            retryAfter: 10,
+            progress: this.getInitializationProgress(),
+          }
+        );
+      }
+      // If initialization actually failed, throw the real error
+      throw new Error(
+        `Jupyter initialization failed: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
+    }
+  }
+
+  /**
+   * Create context - will wait for Jupyter if still initializing
+   */
+  async createContext(req: CreateContextRequest): Promise<any> {
+    if (!this.initialized) {
+      console.log(
+        "[JupyterService] Context creation requested while Jupyter is initializing - waiting..."
+      );
+      const startWait = Date.now();
+      await this.ensureInitialized();
+      const waitTime = Date.now() - startWait;
+      console.log(
+        `[JupyterService] Jupyter ready after ${waitTime}ms wait - proceeding with context creation`
+      );
+    }
+
+    // Use circuit breaker for context creation
+    return await this.circuitBreakers.contextCreation.execute(async () => {
+      return await this.jupyterServer.createContext(req);
+    });
+  }
+
+  /**
+   * Execute code - will wait for Jupyter if still initializing
+   */
+  async executeCode(
+    contextId: string | undefined,
+    code: string,
+    language?: string
+  ): Promise<Response> {
+    if (!this.initialized) {
+      console.log(
+        "[JupyterService] Code execution requested while Jupyter is initializing - waiting..."
+      );
+      const startWait = Date.now();
+      await this.ensureInitialized();
+      const waitTime = Date.now() - startWait;
+      console.log(
+        `[JupyterService] Jupyter ready after ${waitTime}ms wait - proceeding with code execution`
+      );
+    }
+
+    // Use circuit breaker for code execution
+    return await this.circuitBreakers.codeExecution.execute(async () => {
+      return await this.jupyterServer.executeCode(contextId, code, language);
+    });
+  }
+
+  /**
+   * List contexts with graceful degradation
+   */
+  async listContexts(): Promise<any[]> {
+    if (!this.initialized) {
+      return [];
+    }
+    return await this.jupyterServer.listContexts();
+  }
+
+  /**
+   * Delete context - will wait for Jupyter if still initializing
+   */
+  async deleteContext(contextId: string): Promise<void> {
+    if (!this.initialized) {
+      console.log(
+        "[JupyterService] Context deletion requested while Jupyter is initializing - waiting..."
+      );
+      const startWait = Date.now();
+      await this.ensureInitialized();
+      const waitTime = Date.now() - startWait;
+      console.log(
+        `[JupyterService] Jupyter ready after ${waitTime}ms wait - proceeding with context deletion`
+      );
+    }
+
+    // Use circuit breaker for kernel communication
+    return await this.circuitBreakers.kernelCommunication.execute(async () => {
+      return await this.jupyterServer.deleteContext(contextId);
+    });
+  }
+
+  /**
+   * Shutdown the service
+   */
+  async shutdown(): Promise<void> {
+    if (this.initialized) {
+      await this.jupyterServer.shutdown();
+    }
+  }
+
+  /**
+   * Get initialization progress
+   */
+  private getInitializationProgress(): number {
+    if (this.initialized) return 100;
+    if (!this.initPromise) return 0;
+
+    const elapsed = Date.now() - this.startTime;
+    const estimatedTotal = 20000; // 20 seconds estimated
+    return Math.min(95, Math.round((elapsed / estimatedTotal) * 100));
+  }
+}
+
+/**
+ * Error thrown when Jupyter is not ready yet
+ * This matches the interface of the SDK's JupyterNotReadyError
+ */
+export class JupyterNotReadyError extends Error {
+  public readonly retryAfter: number;
+  public readonly progress?: number;
+
+  constructor(
+    message: string,
+    options?: { retryAfter?: number; progress?: number }
+  ) {
+    super(message);
+    this.name = "JupyterNotReadyError";
+    this.retryAfter = options?.retryAfter || 5;
+    this.progress = options?.progress;
+  }
+}

package/container_src/startup.sh

@@ -1,5 +1,17 @@
 #!/bin/bash
 
+# Function to check if Jupyter is ready
+check_jupyter_ready() {
+  curl -s http://localhost:8888/api > /dev/null 2>&1
+}
+
+# Function to notify Bun server that Jupyter is ready
+notify_jupyter_ready() {
+  # Create a marker file that the Bun server can check
+  touch /tmp/jupyter-ready
+  echo "[Startup] Jupyter is ready, notified Bun server"
+}
+
 # Start Jupyter notebook server in background
 echo "[Startup] Starting Jupyter server..."
 jupyter notebook \
@@ -17,36 +29,55 @@ jupyter notebook \
 
 JUPYTER_PID=$!
 
-# Wait for Jupyter to be ready
-echo "[Startup] Waiting for Jupyter to become ready..."
-MAX_ATTEMPTS=30
-ATTEMPT=0
+# Start Bun server immediately (parallel startup)
+echo "[Startup] Starting Bun server..."
+bun index.ts &
+BUN_PID=$!
 
-while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
-  if curl -s http://localhost:8888/api > /dev/null 2>&1; then
-    echo "[Startup] Jupyter server is ready!"
-    break
-  fi
+# Monitor Jupyter readiness in background
+(
+  echo "[Startup] Monitoring Jupyter readiness in background..."
+  MAX_ATTEMPTS=30
+  ATTEMPT=0
+  DELAY=0.5
+  MAX_DELAY=5
   
-  # Check if Jupyter process is still running
-  if ! kill -0 $JUPYTER_PID 2>/dev/null; then
-    echo "[Startup] ERROR: Jupyter process died. Check /tmp/jupyter.log for details"
+  while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
+    if check_jupyter_ready; then
+      notify_jupyter_ready
+      echo "[Startup] Jupyter server is ready after $ATTEMPT attempts"
+      break
+    fi
+    
+    # Check if Jupyter process is still running
+    if ! kill -0 $JUPYTER_PID 2>/dev/null; then
+      echo "[Startup] WARNING: Jupyter process died. Check /tmp/jupyter.log for details"
+      cat /tmp/jupyter.log
+      # Don't exit - let Bun server continue running in degraded mode
+      break
+    fi
+    
+    ATTEMPT=$((ATTEMPT + 1))
+    echo "[Startup] Jupyter not ready yet (attempt $ATTEMPT/$MAX_ATTEMPTS, delay ${DELAY}s)"
+    
+    # Sleep with exponential backoff
+    sleep $DELAY
+    
+    # Increase delay exponentially with jitter, cap at MAX_DELAY
+    DELAY=$(awk "BEGIN {printf \"%.2f\", $DELAY * 1.5 + (rand() * 0.5)}")
+    # Use awk for comparison since bc might not be available
+    if [ $(awk "BEGIN {print ($DELAY > $MAX_DELAY)}") -eq 1 ]; then
+      DELAY=$MAX_DELAY
+    fi
+  done
+  
+  if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
+    echo "[Startup] WARNING: Jupyter failed to become ready within attempts"
+    echo "[Startup] Jupyter logs:"
     cat /tmp/jupyter.log
-    exit 1
+    # Don't exit - let Bun server continue in degraded mode
   fi
-  
-  ATTEMPT=$((ATTEMPT + 1))
-  echo "[Startup] Waiting for Jupyter... (attempt $ATTEMPT/$MAX_ATTEMPTS)"
-  sleep 1
-done
+) &
 
-if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
-  echo "[Startup] ERROR: Jupyter failed to start within 30 seconds"
-  echo "[Startup] Jupyter logs:"
-  cat /tmp/jupyter.log
-  exit 1
-fi
-
-# Start the main Bun server
-echo "[Startup] Starting Bun server..."
-exec bun index.ts
+# Wait for Bun server (main process)
+wait $BUN_PID

package/dist/chunk-LALY4SFU.js

@@ -0,0 +1,129 @@
+// src/errors.ts
+var SandboxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var JupyterNotReadyError = class extends SandboxError {
+  code = "JUPYTER_NOT_READY";
+  retryAfter;
+  progress;
+  constructor(message, options) {
+    super(
+      message || "Jupyter is still initializing. Please retry in a few seconds."
+    );
+    this.retryAfter = options?.retryAfter || 5;
+    this.progress = options?.progress;
+  }
+};
+var ContextNotFoundError = class extends SandboxError {
+  code = "CONTEXT_NOT_FOUND";
+  contextId;
+  constructor(contextId) {
+    super(`Context ${contextId} not found`);
+    this.contextId = contextId;
+  }
+};
+var CodeExecutionError = class extends SandboxError {
+  code = "CODE_EXECUTION_ERROR";
+  executionError;
+  constructor(message, executionError) {
+    super(message);
+    this.executionError = executionError;
+  }
+};
+var ContainerNotReadyError = class extends SandboxError {
+  code = "CONTAINER_NOT_READY";
+  constructor(message) {
+    super(
+      message || "Container is not ready. Please wait for initialization to complete."
+    );
+  }
+};
+var SandboxNetworkError = class extends SandboxError {
+  code = "NETWORK_ERROR";
+  statusCode;
+  statusText;
+  constructor(message, statusCode, statusText) {
+    super(message);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+  }
+};
+var ServiceUnavailableError = class extends SandboxError {
+  code = "SERVICE_UNAVAILABLE";
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message || "Service temporarily unavailable");
+    this.retryAfter = retryAfter;
+  }
+};
+function isJupyterNotReadyError(error) {
+  return error instanceof JupyterNotReadyError;
+}
+function isSandboxError(error) {
+  return error instanceof SandboxError;
+}
+function isRetryableError(error) {
+  if (error instanceof JupyterNotReadyError || error instanceof ContainerNotReadyError || error instanceof ServiceUnavailableError) {
+    return true;
+  }
+  if (error instanceof SandboxNetworkError) {
+    return error.statusCode ? [502, 503, 504].includes(error.statusCode) : false;
+  }
+  return false;
+}
+async function parseErrorResponse(response) {
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    return new SandboxNetworkError(
+      `Request failed with status ${response.status}`,
+      response.status,
+      response.statusText
+    );
+  }
+  if (response.status === 503) {
+    if (data.status === "circuit_open") {
+      return new ServiceUnavailableError(
+        "Service temporarily unavailable",
+        parseInt(response.headers.get("Retry-After") || "30")
+      );
+    }
+    if (data.status === "initializing") {
+      return new JupyterNotReadyError(data.error, {
+        retryAfter: parseInt(response.headers.get("Retry-After") || "5"),
+        progress: data.progress
+      });
+    }
+  }
+  if (response.status === 404 && data.error?.includes("Context") && data.error?.includes("not found")) {
+    const contextId = data.error.match(/Context (\S+) not found/)?.[1] || "unknown";
+    return new ContextNotFoundError(contextId);
+  }
+  return new SandboxNetworkError(
+    data.error || `Request failed with status ${response.status}`,
+    response.status,
+    response.statusText
+  );
+}
+
+export {
+  SandboxError,
+  JupyterNotReadyError,
+  ContextNotFoundError,
+  CodeExecutionError,
+  ContainerNotReadyError,
+  SandboxNetworkError,
+  ServiceUnavailableError,
+  isJupyterNotReadyError,
+  isSandboxError,
+  isRetryableError,
+  parseErrorResponse
+};
+//# sourceMappingURL=chunk-LALY4SFU.js.map

package/dist/chunk-LALY4SFU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Standard error response from the sandbox API\n */\nexport interface SandboxErrorResponse {\n  error?: string;\n  status?: string;\n  progress?: number;\n}\n\n/**\n * Base error class for all Sandbox-related errors\n */\nexport class SandboxError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = this.constructor.name;\n\n    // Maintains proper stack trace for where our error was thrown (only available on V8)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error thrown when Jupyter functionality is requested but the service is still initializing.\n *\n * Note: With the current implementation, requests wait for Jupyter to be ready.\n * This error is only thrown when:\n * 1. The request times out waiting for Jupyter (default: 30 seconds)\n * 2. Jupyter initialization actually fails\n *\n * Most requests will succeed after a delay, not throw this error.\n */\nexport class JupyterNotReadyError extends SandboxError {\n  public readonly code = \"JUPYTER_NOT_READY\";\n  public readonly retryAfter: number;\n  public readonly progress?: number;\n\n  constructor(\n    message?: string,\n    options?: { retryAfter?: number; progress?: number }\n  ) {\n    super(\n      message || \"Jupyter is still initializing. Please retry in a few seconds.\"\n    );\n    this.retryAfter = options?.retryAfter || 5;\n    this.progress = options?.progress;\n  }\n}\n\n/**\n * Error thrown when a context is not found\n */\nexport class ContextNotFoundError extends SandboxError {\n  public readonly code = \"CONTEXT_NOT_FOUND\";\n  public readonly contextId: string;\n\n  constructor(contextId: string) {\n    super(`Context ${contextId} not found`);\n    this.contextId = contextId;\n  }\n}\n\n/**\n * Error thrown when code execution fails\n */\nexport class CodeExecutionError extends SandboxError {\n  public readonly code = \"CODE_EXECUTION_ERROR\";\n  public readonly executionError?: {\n    ename?: string;\n    evalue?: string;\n    traceback?: string[];\n  };\n\n  constructor(message: string, executionError?: any) {\n    super(message);\n    this.executionError = executionError;\n  }\n}\n\n/**\n * Error thrown when the sandbox container is not ready\n */\nexport class ContainerNotReadyError extends SandboxError {\n  public readonly code = \"CONTAINER_NOT_READY\";\n\n  constructor(message?: string) {\n    super(\n      message ||\n        \"Container is not ready. Please wait for initialization to complete.\"\n    );\n  }\n}\n\n/**\n * Error thrown when a network request to the sandbox fails\n */\nexport class SandboxNetworkError extends SandboxError {\n  public readonly code = \"NETWORK_ERROR\";\n  public readonly statusCode?: number;\n  public readonly statusText?: string;\n\n  constructor(message: string, statusCode?: number, statusText?: string) {\n    super(message);\n    this.statusCode = statusCode;\n    this.statusText = statusText;\n  }\n}\n\n/**\n * Error thrown when service is temporarily unavailable (e.g., circuit breaker open)\n */\nexport class ServiceUnavailableError extends SandboxError {\n  public readonly code = \"SERVICE_UNAVAILABLE\";\n  public readonly retryAfter?: number;\n\n  constructor(message?: string, retryAfter?: number) {\n    // Simple, user-friendly message without implementation details\n    super(message || \"Service temporarily unavailable\");\n    this.retryAfter = retryAfter;\n  }\n}\n\n/**\n * Type guard to check if an error is a JupyterNotReadyError\n */\nexport function isJupyterNotReadyError(\n  error: unknown\n): error is JupyterNotReadyError {\n  return error instanceof JupyterNotReadyError;\n}\n\n/**\n * Type guard to check if an error is any SandboxError\n */\nexport function isSandboxError(error: unknown): error is SandboxError {\n  return error instanceof SandboxError;\n}\n\n/**\n * Helper to determine if an error is retryable\n */\nexport function isRetryableError(error: unknown): boolean {\n  if (\n    error instanceof JupyterNotReadyError ||\n    error instanceof ContainerNotReadyError ||\n    error instanceof ServiceUnavailableError\n  ) {\n    return true;\n  }\n\n  if (error instanceof SandboxNetworkError) {\n    // Retry on 502, 503, 504 (gateway/service unavailable errors)\n    return error.statusCode\n      ? [502, 503, 504].includes(error.statusCode)\n      : false;\n  }\n\n  return false;\n}\n\n/**\n * Parse error response from the sandbox API and return appropriate error instance\n */\nexport async function parseErrorResponse(\n  response: Response\n): Promise<SandboxError> {\n  let data: SandboxErrorResponse;\n\n  try {\n    data = (await response.json()) as SandboxErrorResponse;\n  } catch {\n    // If JSON parsing fails, return a generic network error\n    return new SandboxNetworkError(\n      `Request failed with status ${response.status}`,\n      response.status,\n      response.statusText\n    );\n  }\n\n  // Check for specific error types based on response\n  if (response.status === 503) {\n    // Circuit breaker error\n    if (data.status === \"circuit_open\") {\n      return new ServiceUnavailableError(\n        \"Service temporarily unavailable\",\n        parseInt(response.headers.get(\"Retry-After\") || \"30\")\n      );\n    }\n\n    // Jupyter initialization error\n    if (data.status === \"initializing\") {\n      return new JupyterNotReadyError(data.error, {\n        retryAfter: parseInt(response.headers.get(\"Retry-After\") || \"5\"),\n        progress: data.progress,\n      });\n    }\n  }\n\n  // Check for context not found\n  if (\n    response.status === 404 &&\n    data.error?.includes(\"Context\") &&\n    data.error?.includes(\"not found\")\n  ) {\n    const contextId =\n      data.error.match(/Context (\\S+) not found/)?.[1] || \"unknown\";\n    return new ContextNotFoundError(contextId);\n  }\n\n  // Default network error\n  return new SandboxNetworkError(\n    data.error || `Request failed with status ${response.status}`,\n    response.status,\n    response.statusText\n  );\n}\n"],"mappings":"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","names":[]}