blaxel 0.2.32__py3-none-any.whl → 0.2.33__py3-none-any.whl

blaxel/__init__.py

@@ -4,8 +4,8 @@ from .core.common.autoload import autoload
 from .core.common.env import env
 from .core.common.settings import settings
 
-__version__ = "0.2.32"
-__commit__ = "72a43488d87cfae83389f5a928dfa9256649396b"
+__version__ = "0.2.33"
+__commit__ = "3472a6744215e59d421423f105edb2ec34edebe8"
 __sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
 

blaxel/core/common/__init__.py

@@ -1,5 +1,6 @@
-from .autoload import autoload, capture_exception
+from .autoload import autoload
 from .env import env
+from .sentry import capture_exception, flush_sentry, init_sentry, is_sentry_initialized
 from .internal import get_alphanumeric_limited_hash, get_global_unique_hash
 from .settings import Settings, settings
 from .webhook import (
@@ -12,6 +13,9 @@ from .webhook import (
 __all__ = [
     "autoload",
     "capture_exception",
+    "flush_sentry",
+    "init_sentry",
+    "is_sentry_initialized",
     "Settings",
     "settings",
     "env",

blaxel/core/common/autoload.py

@@ -1,10 +1,4 @@
-import atexit
 import logging
-import sys
-import threading
-from asyncio import CancelledError
-
-from sentry_sdk import Client, Hub
 
 from ..client import client
 from ..client.response_interceptor import (
@@ -12,130 +6,11 @@ from ..client.response_interceptor import (
     response_interceptors_sync,
 )
 from ..sandbox.client import client as client_sandbox
+from .sentry import init_sentry
 from .settings import settings
 
 logger = logging.getLogger(__name__)
 
-# Isolated Sentry hub for SDK-only error tracking (doesn't interfere with user's Sentry)
-_sentry_hub: Hub | None = None
-_captured_exceptions: set = set()  # Track already captured exceptions to avoid duplicates
-
-# Exceptions that are part of normal control flow and should not be captured
-_IGNORED_EXCEPTIONS = (
-    StopIteration,  # Iterator exhaustion
-    StopAsyncIteration,  # Async iterator exhaustion
-    GeneratorExit,  # Generator cleanup
-    KeyboardInterrupt,  # User interrupt (Ctrl+C)
-    SystemExit,  # Program exit
-    CancelledError,  # Async task cancellation
-)
-
-# Optional dependencies that may not be installed - import errors for these are expected
-_OPTIONAL_DEPENDENCIES = ("opentelemetry",)
-
-
-def _get_exception_key(exc_type, exc_value, frame) -> str:
-    """Generate a unique key for an exception based on type, message, and origin."""
-    # Use type name + message + original file/line where exception was raised
-    # This ensures the same logical exception is only captured once
-    exc_name = exc_type.__name__ if exc_type else "Unknown"
-    exc_msg = str(exc_value) if exc_value else ""
-    # Get the original traceback location (where exception was first raised)
-    tb = getattr(exc_value, "__traceback__", None)
-    if tb:
-        # Walk to the deepest frame (origin of exception)
-        while tb.tb_next:
-            tb = tb.tb_next
-        origin = f"{tb.tb_frame.f_code.co_filename}:{tb.tb_lineno}"
-    else:
-        origin = f"{frame.f_code.co_filename}:{frame.f_lineno}"
-    return f"{exc_name}:{exc_msg}:{origin}"
-
-
-def _is_optional_dependency_error(exc_type, exc_value) -> bool:
-    """Check if the exception is an import error for an optional dependency."""
-    # ModuleNotFoundError is a subclass of ImportError, so checking ImportError covers both
-    if exc_type and issubclass(exc_type, ImportError):
-        msg = str(exc_value).lower()
-        return any(dep in msg for dep in _OPTIONAL_DEPENDENCIES)
-    return False
-
-
-def _trace_blaxel_exceptions(frame, event, arg):
-    """Trace function that captures exceptions from blaxel SDK code."""
-    if event == "exception":
-        exc_type, exc_value, exc_tb = arg
-
-        # Skip control flow exceptions (not actual errors)
-        if exc_type and issubclass(exc_type, _IGNORED_EXCEPTIONS):
-            return _trace_blaxel_exceptions
-
-        # Skip import errors for optional dependencies (expected when not installed)
-        if _is_optional_dependency_error(exc_type, exc_value):
-            return _trace_blaxel_exceptions
-
-        filename = frame.f_code.co_filename
-
-        # Only capture if it's from blaxel in site-packages
-        if "site-packages/blaxel" in filename:
-            # Avoid capturing the same exception multiple times using a content-based key
-            exc_key = _get_exception_key(exc_type, exc_value, frame)
-            if exc_key not in _captured_exceptions:
-                _captured_exceptions.add(exc_key)
-                capture_exception(exc_value)
-                # Clean up old exception keys to prevent memory leak
-                if len(_captured_exceptions) > 1000:
-                    _captured_exceptions.clear()
-
-    return _trace_blaxel_exceptions
-
-
-def sentry() -> None:
-    """Initialize an isolated Sentry client for SDK error tracking."""
-    global _sentry_hub
-    try:
-        dsn = settings.sentry_dsn
-        if not dsn:
-            return
-
-        # Create an isolated client that won't interfere with user's Sentry
-        sentry_client = Client(
-            dsn=dsn,
-            environment=settings.env,
-            release=f"sdk-python@{settings.version}",
-            default_integrations=False,
-            auto_enabling_integrations=False,
-        )
-        _sentry_hub = Hub(sentry_client)
-
-        # Set SDK-specific tags
-        with _sentry_hub.configure_scope() as scope:
-            scope.set_tag("blaxel.workspace", settings.workspace)
-            scope.set_tag("blaxel.version", settings.version)
-            scope.set_tag("blaxel.commit", settings.commit)
-
-        # Install trace function to automatically capture SDK exceptions
-        sys.settrace(_trace_blaxel_exceptions)
-        threading.settrace(_trace_blaxel_exceptions)
-
-        # Register atexit handler to flush pending events
-        atexit.register(_flush_sentry)
-
-    except Exception as e:
-        logger.debug(f"Error initializing Sentry: {e}")
-
-
-def capture_exception(exception: Exception | None = None) -> None:
-    """Capture an exception to the SDK's isolated Sentry hub."""
-    if _sentry_hub is not None and _sentry_hub.client is not None:
-        _sentry_hub.capture_exception(exception)
-
-
-def _flush_sentry():
-    """Flush pending Sentry events on program exit."""
-    if _sentry_hub is not None and _sentry_hub.client is not None:
-        _sentry_hub.client.flush(timeout=2)
-
 
 def telemetry() -> None:
     from blaxel.telemetry import telemetry_manager
@@ -164,7 +39,7 @@ def autoload() -> None:
 
     if settings.tracking:
         try:
-            sentry()
+            init_sentry()
         except Exception:
             pass
 

blaxel/core/common/sentry.py

@@ -0,0 +1,319 @@
+import atexit
+import json
+import logging
+import sys
+import threading
+import traceback
+import uuid
+from asyncio import CancelledError
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from .settings import settings
+
+logger = logging.getLogger(__name__)
+
+# Lightweight Sentry client using httpx - only captures SDK errors
+_sentry_initialized = False
+_captured_exceptions: set = set()  # Track already captured exceptions to avoid duplicates
+
+# Parsed DSN components
+_sentry_config: dict[str, str] | None = None
+
+# Queue for pending events
+_pending_events: list[dict[str, Any]] = []
+_flush_lock = threading.Lock()
+_handlers_registered = False
+
+# Exceptions that are part of normal control flow and should not be captured
+_IGNORED_EXCEPTIONS = (
+    StopIteration,  # Iterator exhaustion
+    StopAsyncIteration,  # Async iterator exhaustion
+    GeneratorExit,  # Generator cleanup
+    KeyboardInterrupt,  # User interrupt (Ctrl+C)
+    SystemExit,  # Program exit
+    CancelledError,  # Async task cancellation
+)
+
+# Optional dependencies that may not be installed - import errors for these are expected
+_OPTIONAL_DEPENDENCIES = ("opentelemetry",)
+
+# SDK path patterns to identify errors originating from our SDK
+_SDK_PATTERNS = [
+    "blaxel/",
+    "blaxel\\",
+    "site-packages/blaxel",
+    "site-packages\\blaxel",
+]
+
+
+def _is_from_sdk(error: Exception) -> bool:
+    """Check if an error originated from SDK code based on stack trace."""
+    tb = error.__traceback__
+    if not tb:
+        return False
+
+    # Walk through the traceback
+    while tb:
+        filename = tb.tb_frame.f_code.co_filename
+        if any(pattern in filename for pattern in _SDK_PATTERNS):
+            return True
+        tb = tb.tb_next
+
+    return False
+
+
+def _parse_dsn(dsn: str) -> dict[str, str] | None:
+    """
+    Parse a Sentry DSN into its components.
+    DSN format: https://{public_key}@{host}/{project_id}
+    """
+    try:
+        parsed = urlparse(dsn)
+        public_key = parsed.username
+        host = parsed.hostname
+        project_id = parsed.path.lstrip("/")
+
+        if not public_key or not host or not project_id:
+            return None
+
+        return {"public_key": public_key, "host": host, "project_id": project_id}
+    except Exception:
+        return None
+
+
+def _generate_event_id() -> str:
+    """Generate a UUID v4 for event ID."""
+    return uuid.uuid4().hex
+
+
+def _parse_stack_trace(exc: Exception) -> list[dict[str, Any]]:
+    """Parse exception traceback into Sentry-compatible frames."""
+    frames: list[dict[str, Any]] = []
+    tb = traceback.extract_tb(exc.__traceback__)
+
+    for frame in tb:
+        frames.append(
+            {
+                "filename": frame.filename,
+                "function": frame.name or "<anonymous>",
+                "lineno": frame.lineno,
+                "colno": 0,
+            }
+        )
+
+    return frames
+
+
+def _error_to_sentry_event(error: Exception) -> dict[str, Any]:
+    """Convert an Exception to a Sentry event payload."""
+    frames = _parse_stack_trace(error)
+
+    return {
+        "event_id": _generate_event_id(),
+        "timestamp": datetime.now(timezone.utc).timestamp(),
+        "platform": "python",
+        "level": "error",
+        "environment": settings.env,
+        "release": f"sdk-python@{settings.version}",
+        "tags": {
+            "blaxel.workspace": settings.workspace,
+            "blaxel.version": settings.version,
+            "blaxel.commit": settings.commit,
+        },
+        "exception": {
+            "values": [
+                {
+                    "type": type(error).__name__,
+                    "value": str(error),
+                    "stacktrace": {"frames": frames},
+                }
+            ]
+        },
+    }
+
+
+def _send_to_sentry(event: dict[str, Any]) -> None:
+    """Send an event to Sentry using httpx."""
+    if not _sentry_config:
+        return
+
+    public_key = _sentry_config["public_key"]
+    host = _sentry_config["host"]
+    project_id = _sentry_config["project_id"]
+    envelope_url = f"https://{host}/api/{project_id}/envelope/"
+
+    # Create envelope header
+    envelope_header = json.dumps(
+        {
+            "event_id": event["event_id"],
+            "sent_at": datetime.now(timezone.utc).isoformat(),
+            "dsn": f"https://{public_key}@{host}/{project_id}",
+        }
+    )
+
+    # Create item header
+    item_header = json.dumps({"type": "event", "content_type": "application/json"})
+
+    # Create envelope body
+    envelope = f"{envelope_header}\n{item_header}\n{json.dumps(event)}"
+
+    try:
+        httpx.post(
+            envelope_url,
+            headers={
+                "Content-Type": "application/x-sentry-envelope",
+                "X-Sentry-Auth": f"Sentry sentry_version=7, sentry_client=blaxel-sdk/{settings.version}, sentry_key={public_key}",
+            },
+            content=envelope,
+            timeout=5.0,
+        )
+    except Exception:
+        # Silently fail - error reporting should never break the SDK
+        pass
+
+
+def _get_exception_key(exc_type, exc_value, frame) -> str:
+    """Generate a unique key for an exception based on type, message, and origin."""
+    exc_name = exc_type.__name__ if exc_type else "Unknown"
+    exc_msg = str(exc_value) if exc_value else ""
+    tb = getattr(exc_value, "__traceback__", None)
+    if tb:
+        while tb.tb_next:
+            tb = tb.tb_next
+        origin = f"{tb.tb_frame.f_code.co_filename}:{tb.tb_lineno}"
+    else:
+        origin = f"{frame.f_code.co_filename}:{frame.f_lineno}"
+    return f"{exc_name}:{exc_msg}:{origin}"
+
+
+def _is_optional_dependency_error(exc_type, exc_value) -> bool:
+    """Check if the exception is an import error for an optional dependency."""
+    if exc_type and issubclass(exc_type, ImportError):
+        msg = str(exc_value).lower()
+        return any(dep in msg for dep in _OPTIONAL_DEPENDENCIES)
+    return False
+
+
+def _trace_blaxel_exceptions(frame, event, arg):
+    """Trace function that captures exceptions from blaxel SDK code."""
+    if event == "exception":
+        exc_type, exc_value, exc_tb = arg
+
+        # Skip control flow exceptions (not actual errors)
+        if exc_type and issubclass(exc_type, _IGNORED_EXCEPTIONS):
+            return _trace_blaxel_exceptions
+
+        # Skip import errors for optional dependencies (expected when not installed)
+        if _is_optional_dependency_error(exc_type, exc_value):
+            return _trace_blaxel_exceptions
+
+        filename = frame.f_code.co_filename
+
+        # Only capture if it's from blaxel in site-packages
+        if "site-packages/blaxel" in filename:
+            # Avoid capturing the same exception multiple times using a content-based key
+            exc_key = _get_exception_key(exc_type, exc_value, frame)
+            if exc_key not in _captured_exceptions:
+                _captured_exceptions.add(exc_key)
+                capture_exception(exc_value)
+                # Clean up old exception keys to prevent memory leak
+                if len(_captured_exceptions) > 1000:
+                    _captured_exceptions.clear()
+
+    return _trace_blaxel_exceptions
+
+
+def init_sentry() -> None:
+    """Initialize the lightweight Sentry client for SDK error tracking."""
+    global _sentry_initialized, _sentry_config, _handlers_registered
+    try:
+        dsn = settings.sentry_dsn
+        if not dsn:
+            return
+
+        # Parse DSN
+        _sentry_config = _parse_dsn(dsn)
+        if not _sentry_config:
+            return
+
+        # Only allow dev/prod environments
+        if settings.env not in ("dev", "prod"):
+            return
+
+        _sentry_initialized = True
+
+        # Register handlers only once
+        if not _handlers_registered:
+            _handlers_registered = True
+
+            # Install trace function to automatically capture SDK exceptions
+            sys.settrace(_trace_blaxel_exceptions)
+            threading.settrace(_trace_blaxel_exceptions)
+
+            # Register atexit handler to flush pending events
+            atexit.register(flush_sentry)
+
+    except Exception as e:
+        logger.debug(f"Error initializing Sentry: {e}")
+
+
+def capture_exception(exception: Exception | None = None) -> None:
+    """Capture an exception to Sentry.
+    Only errors originating from SDK code will be captured.
+    """
+    if not _sentry_initialized or not _sentry_config or exception is None:
+        return
+
+    try:
+        # Generate unique key to prevent duplicate captures
+        exc_key = f"{type(exception).__name__}:{str(exception)}"
+        if exc_key in _captured_exceptions:
+            return
+
+        _captured_exceptions.add(exc_key)
+
+        # Clean up old exception keys to prevent memory leak
+        if len(_captured_exceptions) > 1000:
+            _captured_exceptions.clear()
+
+        # Convert error to Sentry event and queue it
+        event = _error_to_sentry_event(exception)
+        with _flush_lock:
+            _pending_events.append(event)
+
+        # Send immediately (fire and forget)
+        _send_to_sentry(event)
+
+    except Exception:
+        # Silently fail - error capturing should never break the SDK
+        pass
+
+
+def flush_sentry(timeout: float = 2.0) -> None:
+    """Flush pending Sentry events."""
+    if not _sentry_initialized:
+        return
+
+    with _flush_lock:
+        if not _pending_events:
+            return
+
+        events_to_send = _pending_events.copy()
+        _pending_events.clear()
+
+    # Send all pending events
+    for event in events_to_send:
+        try:
+            _send_to_sentry(event)
+        except Exception:
+            # Silently fail
+            pass
+
+
+def is_sentry_initialized() -> bool:
+    """Check if Sentry is initialized and available."""
+    return _sentry_initialized

blaxel/core/sandbox/default/process.py

@@ -184,55 +184,170 @@ class SandboxProcess(SandboxAction):
     ) -> Union[ProcessResponse, ProcessResponseWithLog]:
         """Execute a process in the sandbox."""
         on_log = None
+        on_stdout = None
+        on_stderr = None
+
         if isinstance(process, ProcessRequestWithLog):
             on_log = process.on_log
+            on_stdout = process.on_stdout
+            on_stderr = process.on_stderr
             process = process.to_dict()
 
         if isinstance(process, dict):
             if "on_log" in process:
                 on_log = process["on_log"]
                 del process["on_log"]
+            if "on_stdout" in process:
+                on_stdout = process["on_stdout"]
+                del process["on_stdout"]
+            if "on_stderr" in process:
+                on_stderr = process["on_stderr"]
+                del process["on_stderr"]
             process = ProcessRequest.from_dict(process)
 
         # Store original wait_for_completion setting
         should_wait_for_completion = process.wait_for_completion
 
-        # Always start process without wait_for_completion to avoid server-side blocking
-        if should_wait_for_completion and on_log is not None:
-            process.wait_for_completion = False
-
-        client = self.get_client()
-        response = await client.post("/process", json=process.to_dict())
-        try:
-            content_bytes = await response.aread()
-            self.handle_response_error(response)
-            import json
-
-            response_data = json.loads(content_bytes) if content_bytes else None
-            result = ProcessResponse.from_dict(response_data)
-        finally:
-            await response.aclose()
-
-        # Handle wait_for_completion with parallel log streaming
-        if should_wait_for_completion and on_log is not None:
-            stream_control = self._stream_logs(result.pid, {"on_log": on_log})
+        # When waiting for completion with streaming callbacks, use streaming endpoint
+        if should_wait_for_completion and (on_log or on_stdout or on_stderr):
+            return await self._exec_with_streaming(
+                process, on_log=on_log, on_stdout=on_stdout, on_stderr=on_stderr
+            )
+        else:
+            client = self.get_client()
+            response = await client.post("/process", json=process.to_dict())
             try:
-                # Wait for process completion
-                result = await self.wait(result.pid, interval=500, max_wait=1000 * 60 * 60)
+                content_bytes = await response.aread()
+                self.handle_response_error(response)
+                import json
+
+                response_data = json.loads(content_bytes) if content_bytes else None
+                result = ProcessResponse.from_dict(response_data)
             finally:
-                # Clean up log streaming
-                if stream_control:
-                    stream_control["close"]()
-        else:
-            # For non-blocking execution, set up log streaming immediately if requested
-            if on_log is not None:
-                stream_control = self._stream_logs(result.pid, {"on_log": on_log})
+                await response.aclose()
+
+            if on_log or on_stdout or on_stderr:
+                stream_control = self._stream_logs(
+                    result.pid, {"on_log": on_log, "on_stdout": on_stdout, "on_stderr": on_stderr}
+                )
                 return ProcessResponseWithLog(
                     result,
                     lambda: stream_control["close"]() if stream_control else None,
                 )
 
-        return result
+            return result
+
+    async def _exec_with_streaming(
+        self,
+        process_request: ProcessRequest,
+        on_log: Callable[[str], None] | None = None,
+        on_stdout: Callable[[str], None] | None = None,
+        on_stderr: Callable[[str], None] | None = None,
+    ) -> ProcessResponseWithLog:
+        """Execute a process with streaming response handling for NDJSON."""
+        import json
+
+        headers = (
+            self.sandbox_config.headers
+            if self.sandbox_config.force_url
+            else {**settings.headers, **self.sandbox_config.headers}
+        )
+
+        async with httpx.AsyncClient() as client_instance:
+            async with client_instance.stream(
+                "POST",
+                f"{self.url}/process",
+                headers={
+                    **headers,
+                    "Content-Type": "application/json",
+                    "Accept": "text/event-stream",
+                },
+                json=process_request.to_dict(),
+                timeout=None,
+            ) as response:
+                if response.status_code >= 400:
+                    error_text = await response.aread()
+                    raise Exception(f"Failed to execute process: {error_text}")
+
+                content_type = response.headers.get("Content-Type", "")
+                is_streaming = "application/x-ndjson" in content_type
+
+                # Fallback: server doesn't support streaming, use legacy approach
+                if not is_streaming:
+                    content = await response.aread()
+                    data = json.loads(content)
+                    result = ProcessResponse.from_dict(data)
+
+                    # If process already completed (server waited), emit logs through callbacks
+                    if result.status == "completed" or result.status == "failed":
+                        if result.stdout:
+                            for line in result.stdout.split("\n"):
+                                if line:
+                                    if on_stdout:
+                                        on_stdout(line)
+                        if result.stderr:
+                            for line in result.stderr.split("\n"):
+                                if line:
+                                    if on_stderr:
+                                        on_stderr(line)
+                        if result.logs:
+                            for line in result.logs.split("\n"):
+                                if line:
+                                    if on_log:
+                                        on_log(line)
+
+                    return ProcessResponseWithLog(result, lambda: None)
+
+                # Streaming response handling
+                buffer = ""
+                result = None
+
+                async for chunk in response.aiter_text():
+                    buffer += chunk
+                    lines = buffer.split("\n")
+                    buffer = lines.pop()
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+                        try:
+                            parsed = json.loads(line)
+                            parsed_type = parsed.get("type", "")
+                            parsed_data = parsed.get("data", "")
+
+                            if parsed_type == "stdout":
+                                if parsed_data:
+                                    if on_stdout:
+                                        on_stdout(parsed_data)
+                                    if on_log:
+                                        on_log(parsed_data)
+                            elif parsed_type == "stderr":
+                                if parsed_data:
+                                    if on_stderr:
+                                        on_stderr(parsed_data)
+                                    if on_log:
+                                        on_log(parsed_data)
+                            elif parsed_type == "result":
+                                try:
+                                    result = ProcessResponse.from_dict(json.loads(parsed_data))
+                                except Exception:
+                                    raise Exception(f"Failed to parse result JSON: {parsed_data}")
+                        except json.JSONDecodeError:
+                            continue
+
+                # Process any remaining buffer
+                if buffer.strip():
+                    if buffer.startswith("result:"):
+                        json_str = buffer[7:]
+                        try:
+                            result = ProcessResponse.from_dict(json.loads(json_str))
+                        except Exception:
+                            raise Exception(f"Failed to parse result JSON: {json_str}")
+
+                if not result:
+                    raise Exception("No result received from streaming response")
+
+                return ProcessResponseWithLog(result, lambda: None)
 
     async def wait(
         self, identifier: str, max_wait: int = 60000, interval: int = 1000

blaxel/core/sandbox/sync/process.py

@@ -143,43 +143,169 @@ class SyncSandboxProcess(SyncSandboxAction):
         process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]],
     ) -> Union[ProcessResponse, ProcessResponseWithLog]:
         on_log = None
+        on_stdout = None
+        on_stderr = None
+
         if isinstance(process, ProcessRequestWithLog):
             on_log = process.on_log
+            on_stdout = process.on_stdout
+            on_stderr = process.on_stderr
             process = process.to_dict()
+
         if isinstance(process, dict):
             if "on_log" in process:
                 on_log = process["on_log"]
                 del process["on_log"]
+            if "on_stdout" in process:
+                on_stdout = process["on_stdout"]
+                del process["on_stdout"]
+            if "on_stderr" in process:
+                on_stderr = process["on_stderr"]
+                del process["on_stderr"]
             process = ProcessRequest.from_dict(process)
+
         should_wait_for_completion = process.wait_for_completion
-        if should_wait_for_completion and on_log is not None:
-            process.wait_for_completion = False
-        with self.get_client() as client_instance:
-            response = client_instance.post("/process", json=process.to_dict())
-            response_data = None
-            if response.content:
-                try:
-                    response_data = response.json()
-                except Exception:
-                    self.handle_response_error(response)
-                    raise
-            self.handle_response_error(response)
-            result = ProcessResponse.from_dict(response_data)
-            if should_wait_for_completion and on_log is not None:
-                stream_control = self._stream_logs(result.pid, {"on_log": on_log})
-                try:
-                    result = self.wait(result.pid, interval=500, max_wait=1000 * 60 * 60)
-                finally:
-                    if stream_control:
-                        stream_control["close"]()
-            else:
-                if on_log is not None:
-                    stream_control = self._stream_logs(result.pid, {"on_log": on_log})
+
+        # When waiting for completion with streaming callbacks, use streaming endpoint
+        if should_wait_for_completion and (on_log or on_stdout or on_stderr):
+            return self._exec_with_streaming(
+                process, on_log=on_log, on_stdout=on_stdout, on_stderr=on_stderr
+            )
+        else:
+            with self.get_client() as client_instance:
+                response = client_instance.post("/process", json=process.to_dict())
+                response_data = None
+                if response.content:
+                    try:
+                        response_data = response.json()
+                    except Exception:
+                        self.handle_response_error(response)
+                        raise
+                self.handle_response_error(response)
+                result = ProcessResponse.from_dict(response_data)
+
+                if on_log or on_stdout or on_stderr:
+                    stream_control = self._stream_logs(
+                        result.pid, {"on_log": on_log, "on_stdout": on_stdout, "on_stderr": on_stderr}
+                    )
                     return ProcessResponseWithLog(
                         result,
                         lambda: stream_control["close"]() if stream_control else None,
                     )
-            return result
+
+                return result
+
+    def _exec_with_streaming(
+        self,
+        process_request: ProcessRequest,
+        on_log: Callable[[str], None] | None = None,
+        on_stdout: Callable[[str], None] | None = None,
+        on_stderr: Callable[[str], None] | None = None,
+    ) -> ProcessResponseWithLog:
+        """Execute a process with streaming response handling for NDJSON."""
+        import json
+
+        headers = (
+            self.sandbox_config.headers
+            if self.sandbox_config.force_url
+            else {**settings.headers, **self.sandbox_config.headers}
+        )
+
+        with httpx.Client() as client_instance:
+            with client_instance.stream(
+                "POST",
+                f"{self.url}/process",
+                headers={
+                    **headers,
+                    "Content-Type": "application/json",
+                    "Accept": "text/event-stream",
+                },
+                json=process_request.to_dict(),
+                timeout=None,
+            ) as response:
+                if response.status_code >= 400:
+                    error_text = response.read()
+                    raise Exception(f"Failed to execute process: {error_text}")
+
+                content_type = response.headers.get("Content-Type", "")
+                is_streaming = "application/x-ndjson" in content_type
+
+                # Fallback: server doesn't support streaming, use legacy approach
+                if not is_streaming:
+                    content = response.read()
+                    data = json.loads(content)
+                    result = ProcessResponse.from_dict(data)
+
+                    # If process already completed (server waited), emit logs through callbacks
+                    if result.status == "completed" or result.status == "failed":
+                        if result.stdout:
+                            for line in result.stdout.split("\n"):
+                                if line:
+                                    if on_stdout:
+                                        on_stdout(line)
+                        if result.stderr:
+                            for line in result.stderr.split("\n"):
+                                if line:
+                                    if on_stderr:
+                                        on_stderr(line)
+                        if result.logs:
+                            for line in result.logs.split("\n"):
+                                if line:
+                                    if on_log:
+                                        on_log(line)
+
+                    return ProcessResponseWithLog(result, lambda: None)
+
+                # Streaming response handling
+                buffer = ""
+                result = None
+
+                for chunk in response.iter_text():
+                    buffer += chunk
+                    lines = buffer.split("\n")
+                    buffer = lines.pop()
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+                        try:
+                            parsed = json.loads(line)
+                            parsed_type = parsed.get("type", "")
+                            parsed_data = parsed.get("data", "")
+
+                            if parsed_type == "stdout":
+                                if parsed_data:
+                                    if on_stdout:
+                                        on_stdout(parsed_data)
+                                    if on_log:
+                                        on_log(parsed_data)
+                            elif parsed_type == "stderr":
+                                if parsed_data:
+                                    if on_stderr:
+                                        on_stderr(parsed_data)
+                                    if on_log:
+                                        on_log(parsed_data)
+                            elif parsed_type == "result":
+                                try:
+                                    result = ProcessResponse.from_dict(json.loads(parsed_data))
+                                except Exception:
+                                    raise Exception(f"Failed to parse result JSON: {parsed_data}")
+                        except json.JSONDecodeError:
+                            continue
+
+                # Process any remaining buffer
+                if buffer.strip():
+                    if buffer.startswith("result:"):
+                        json_str = buffer[7:]
+                        try:
+                            result = ProcessResponse.from_dict(json.loads(json_str))
+                        except Exception:
+                            raise Exception(f"Failed to parse result JSON: {json_str}")
+
+                if not result:
+                    raise Exception("No result received from streaming response")
+
+                return ProcessResponseWithLog(result, lambda: None)
 
     def wait(self, identifier: str, max_wait: int = 60000, interval: int = 1000) -> ProcessResponse:
         start_time = time.monotonic() * 1000

blaxel/core/sandbox/types.py

@@ -282,6 +282,8 @@ class SandboxCreateConfiguration:
 @_attrs_define
 class ProcessRequestWithLog(ProcessRequest):
     on_log: Callable[[str], None] | None = None
+    on_stdout: Callable[[str], None] | None = None
+    on_stderr: Callable[[str], None] | None = None
 
 
 class ProcessResponseWithLog:

{blaxel-0.2.32.dist-info → blaxel-0.2.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.32
+Version: 0.2.33
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -17,7 +17,6 @@ Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: requests>=2.32.3
-Requires-Dist: sentry-sdk>=2.46.0
 Requires-Dist: tomli>=2.2.1
 Requires-Dist: websockets<16.0.0
 Provides-Extra: all

{blaxel-0.2.32.dist-info → blaxel-0.2.33.dist-info}/RECORD

@@ -1,4 +1,4 @@
-blaxel/__init__.py,sha256=DodOCaAPXa8pstbUXBPzRjID-7e_I2akWFDmtctRxkc,413
+blaxel/__init__.py,sha256=wk69Pg_DfZapO7suCkD3c_pEa3GOrJe2AUqhua2R2WE,413
 blaxel/core/__init__.py,sha256=CKMC7TaCYdOdnwqcJCN9VjBbNg366coZUGTxI1mgFQQ,1710
 blaxel/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 blaxel/core/agents/__init__.py,sha256=MJZga99lU8JWUUPHd4rmUfdo7ALwWgF7CQq95SfT2OI,4456
@@ -330,11 +330,12 @@ blaxel/core/client/models/workspace.py,sha256=3Z-bpTYukkbqW46B39Nljr4XZtAV41AqqK
 blaxel/core/client/models/workspace_labels.py,sha256=M_ZbpQeVNdgqWv2RmTYO7znBczUJ6zi5_XS1EDin3Gk,1253
 blaxel/core/client/models/workspace_runtime.py,sha256=Pdr_Q-ugs_5famziqGSyBzUkKQ6e-pAFRGza6GhppSA,1672
 blaxel/core/client/models/workspace_user.py,sha256=f28XZuP3V46y2YYbfiIiNbnIMpy3JINLwpy_mX9N1iU,3430
-blaxel/core/common/__init__.py,sha256=K5uIZe98NIjYkjMPdKvP5RuwzIfv1Obm6g3aWh2qjZ0,599
-blaxel/core/common/autoload.py,sha256=1v6-MwjifmPLnfFA11deNYxydSPTKIawc3nQGOb4l50,6375
+blaxel/core/common/__init__.py,sha256=A69U94NslPOYjKvja0bN5z98eguJPC6UaGaVN2-FdRY,736
+blaxel/core/common/autoload.py,sha256=Tq6cmmNcOwUy77ACWM-4Ap8DgRY6GWkAOJmIwugRAPU,1481
 blaxel/core/common/env.py,sha256=05Jm2mw0-KIgR7QaNVyvZPP91B9OlxlJ6mcx6Mqfji0,1234
 blaxel/core/common/internal.py,sha256=NDTFh9Duj84os8GkMXjGzn-UVS9zBDyLAcfPxIpoQGA,3218
 blaxel/core/common/logger.py,sha256=Jt0MCJgYDPq36rl7UyKRDJH76a-AwYdfggNeNYJt6N0,4779
+blaxel/core/common/sentry.py,sha256=P_v1vWivlh-usXV1_JeJ603r1OHoWaR5jaYV2JJ6vDM,9759
 blaxel/core/common/settings.py,sha256=f7ZP8VpB8gKESptyb6S82gTHQsbmx6RcaAkDkxy2JpE,4599
 blaxel/core/common/webhook.py,sha256=N1f2bamP7wRyPyCfmAZKMdjeB3aQ6d6pcafHyVZKtPk,5330
 blaxel/core/jobs/__init__.py,sha256=LZTtkOwqUyMjRTdeLv4EXLbVhgebwvY95jd56IGO4MQ,17082
@@ -343,7 +344,7 @@ blaxel/core/mcp/client.py,sha256=EZ7l5w3bTXaD41nalHzM-byxfQK-JdcmQqxg3zGpVO4,550
 blaxel/core/mcp/server.py,sha256=edAztWBlukERw9-dzS2Sk96TP8R3-CSofY1CZDu19ZA,5967
 blaxel/core/models/__init__.py,sha256=ydz1txqIVyOhehItut-AOnLMnGp7AtCD2zku9gkvAsE,1722
 blaxel/core/sandbox/__init__.py,sha256=SQ9YH0I9ruAYscY_W75jqIhNbejbY_92xL7VqM083Mc,1345
-blaxel/core/sandbox/types.py,sha256=h_e0Zk_BNRjix1RRtomqVwdG64ViA34KwM4ZQIM5Bp0,12601
+blaxel/core/sandbox/types.py,sha256=m8yWOXxpLfzeNPhxBwU1VnXFeIHnv95OQuDnST3tYrc,12703
 blaxel/core/sandbox/client/__init__.py,sha256=N26bD5o1jsTb48oExow6Rgivd8ylaU9jaWZfZsVilP8,128
 blaxel/core/sandbox/client/client.py,sha256=EGCYliUHCk4RyIBlydEZyVpc_VUiIIGPuu2E-xYeKFY,7074
 blaxel/core/sandbox/client/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
@@ -438,7 +439,7 @@ blaxel/core/sandbox/default/filesystem.py,sha256=Gn1G3DpMmDXplUEpXVENXkjUDAEkWAK
 blaxel/core/sandbox/default/interpreter.py,sha256=TJSryQvq2rWedyhMU69tOlXVOF1iIpgIbV2z3_mF72E,11316
 blaxel/core/sandbox/default/network.py,sha256=3ZvrJB_9JdZrclNkwifZOIciz2OqzV0LQfbebjZXLIY,358
 blaxel/core/sandbox/default/preview.py,sha256=dV_xuu9Efop5TnzuFJPeLUZ7CEepuYkJedx01fDVMX4,6132
-blaxel/core/sandbox/default/process.py,sha256=hUdFxFD5w8Md827gVwRijhY55D4BQEbmxuLrqFrCC6I,11965
+blaxel/core/sandbox/default/process.py,sha256=7nI1wJXeZWoveBesC13wur-ghIjP5POZ38G8wqCdJTw,16983
 blaxel/core/sandbox/default/sandbox.py,sha256=b641_MHILDdsz9ZkbSIoRAmbB_0grbd3C_SG5JOwe18,12576
 blaxel/core/sandbox/default/session.py,sha256=XzVpPOH_az6T38Opp4Hmj3RIg7QCzA1l5wh1YDh7czc,5313
 blaxel/core/sandbox/sync/__init__.py,sha256=iqTRxQYbJyHTXoA4MHaigeXFxi9wtJ3o9XygZuFe3bM,372
@@ -448,7 +449,7 @@ blaxel/core/sandbox/sync/filesystem.py,sha256=FoxM9EJ5sXGysf-x22tbt9yrcbbpaunTD3
 blaxel/core/sandbox/sync/interpreter.py,sha256=5cAzwnt5BgnByGimagMBotjGW2vMAz4vutBBrrFV9-A,11062
 blaxel/core/sandbox/sync/network.py,sha256=QkCFKfFayvwL1J4JYwOuXPGlYQuX4J9Jj55Kf_kD-ig,283
 blaxel/core/sandbox/sync/preview.py,sha256=w3bC8iA3QecHiLkRvITmQ6LTT9Co_93G24QpZFgEQSE,6379
-blaxel/core/sandbox/sync/process.py,sha256=U4aYv-uRXDOKScz6Ets-QkwZZ1kdgR9ve04CkUaUkEU,9624
+blaxel/core/sandbox/sync/process.py,sha256=W-ZUM6VyFDxTmexHTQn9PI6iRc0QiB9JMOEq__r2bBA,14913
 blaxel/core/sandbox/sync/sandbox.py,sha256=jNqwMJXIpjC8Fs9nn-ujfSpFK2PgCvEePISKQKaMhH0,10515
 blaxel/core/sandbox/sync/session.py,sha256=e0CVbW2LBRYTwm4RL52S0UdNvhNfuFLo6AYE5hk9DH0,4931
 blaxel/core/tools/__init__.py,sha256=OK2TFqeXAIi6CC7xtL8fFl-4DvCB7jjihkhx6RTld_c,13147
@@ -500,7 +501,7 @@ blaxel/telemetry/instrumentation/map.py,sha256=PCzZJj39yiYVYJrxLBNP-NW-tjjYyTijw
 blaxel/telemetry/instrumentation/utils.py,sha256=FGyMY5ZE4f-0JdZpm_R_BCoKLJ18hftz8vsh7ftDwMk,1889
 blaxel/telemetry/log/log.py,sha256=vtzUIFIIj4MTTKUigILDYXN8NHHPOo44OaKukpyIjQg,2407
 blaxel/telemetry/log/logger.py,sha256=IcFWCd1yyWWGAjAd2i0pDYqpZHQ61pmcaQ7Kf4bC8lg,4150
-blaxel-0.2.32.dist-info/METADATA,sha256=yQQO_JdQpH1Ka7_HxoTU2he4DXnWLWh8--eD8LWzdZc,10108
-blaxel-0.2.32.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-blaxel-0.2.32.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
-blaxel-0.2.32.dist-info/RECORD,,
+blaxel-0.2.33.dist-info/METADATA,sha256=nWdiqiO6Qc_LIqAz4Tc6AyLaXFzhtyFkL0lDUSwwxQU,10074
+blaxel-0.2.33.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+blaxel-0.2.33.dist-info/licenses/LICENSE,sha256=p5PNQvpvyDT_0aYBDgmV1fFI_vAD2aSV0wWG7VTgRis,1069
+blaxel-0.2.33.dist-info/RECORD,,