logfire-api 5.5.0__tar.gz → 5.6.0__tar.gz

{logfire_api-5.5.0 → logfire_api-5.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 5.5.0
+Version: 5.6.0
 Summary: Shim for the Logfire SDK which does nothing unless Logfire is installed
 Author-email: Pydantic Team <engineering@pydantic.dev>, Samuel Colvin <samuel@pydantic.dev>, Hasan Ramezani <hasan@pydantic.dev>, Adrian Garcia Badaracco <adrian@pydantic.dev>, David Montague <david@pydantic.dev>, Marcelo Trylesinski <marcelo@pydantic.dev>, David Hewitt <david.hewitt@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/__init__.py

@@ -167,7 +167,11 @@ except ImportError:
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
 
-            def instrument_sqlite3(self, *args, **kwargs) -> None: ...
+            def instrument_sqlite3(self, conn=None, *args, **kwargs):
+                return conn
+
+            def instrument_mysql(self, conn=None, *args, **kwargs):
+                return conn
 
             def instrument_aws_lambda(self, *args, **kwargs) -> None: ...
 
@@ -230,7 +234,8 @@ except ImportError:
             async def forward_export_request_starlette(self, *args, **kwargs) -> MagicMock:
                 return MagicMock()
 
-            def shutdown(self, *args, **kwargs) -> None: ...
+            def shutdown(self, *args, **kwargs) -> bool:
+                return True
 
         DEFAULT_LOGFIRE_INSTANCE = Logfire()
         span = DEFAULT_LOGFIRE_INSTANCE.span

logfire_api-5.6.0/logfire_api/_internal/agent_sandboxes.pyi

@@ -0,0 +1,13 @@
+from collections.abc import Callable, Mapping as Mapping
+from logfire import Logfire as Logfire
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from logfire.propagate import get_context as get_context
+from pydantic_monty import AsyncMontyRemote
+from typing import Any
+
+def agent_sandboxes_url(base_url: str) -> str:
+    """Validate and normalize a supplied or derived Logfire Agent Sandboxes URL.
+
+    The client opens its gRPC stream at the root of this URL, so the base URL must not have a path.
+    """
+def create_agent_sandboxes(logfire_instance: Logfire, *, api_key: str | None, url: str | None, metadata: Callable[[], Mapping[str, str]] | None = None, connect_headers: Callable[[], Mapping[str, str]] | None = None, **kwargs: Any) -> AsyncMontyRemote: ...

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/config.pyi

@@ -11,7 +11,7 @@ from .exporters.console import ConsoleColorsValues as ConsoleColorsValues, Conso
 from .exporters.dynamic_batch import DynamicBatchSpanProcessor as DynamicBatchSpanProcessor
 from .exporters.logs import CheckSuppressInstrumentationLogProcessorWrapper as CheckSuppressInstrumentationLogProcessorWrapper, MainLogProcessorWrapper as MainLogProcessorWrapper
 from .exporters.otlp import BodySizeCheckingOTLPSpanExporter as BodySizeCheckingOTLPSpanExporter, OTLPExporterHttpSession as OTLPExporterHttpSession, QuietLogExporter as QuietLogExporter, QuietSpanExporter as QuietSpanExporter, RetryFewerSpansSpanExporter as RetryFewerSpansSpanExporter, cleanup_disk_retryers as cleanup_disk_retryers, zstd_compress as zstd_compress
-from .exporters.processor_wrapper import CheckSuppressInstrumentationProcessorWrapper as CheckSuppressInstrumentationProcessorWrapper, MainSpanProcessorWrapper as MainSpanProcessorWrapper
+from .exporters.processor_wrapper import BackgroundScrubbingSpanProcessor as BackgroundScrubbingSpanProcessor, CheckSuppressInstrumentationProcessorWrapper as CheckSuppressInstrumentationProcessorWrapper, MainSpanProcessorWrapper as MainSpanProcessorWrapper, ScrubbingSpanProcessor as ScrubbingSpanProcessor, SpanProcessorGroup as SpanProcessorGroup, make_scrubbing_queue as make_scrubbing_queue, scrub_span as scrub_span
 from .exporters.quiet_metrics import QuietMetricExporter as QuietMetricExporter
 from .exporters.remove_pending import RemovePendingSpansExporter as RemovePendingSpansExporter
 from .exporters.test import TestExporter as TestExporter
@@ -204,6 +204,8 @@ def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-
 
         data_dir: Directory to store credentials, and logs. If `None` uses the `LOGFIRE_CREDENTIALS_DIR` environment variable, otherwise defaults to `'.logfire'`.
         additional_span_processors: Span processors to use in addition to the default processor which exports spans to Logfire's API.
+            Processors which have a custom `on_end` method (other than `BatchSpanProcessor`) will cause
+            span attribute scrubbing to happen on the calling thread, which may slow down your application.
         metrics: Set to `False` to disable sending all metrics,
             or provide a `MetricsOptions` object to configure metrics, e.g. additional metric readers.
         scrubbing: Options for scrubbing sensitive data. Set to `False` to disable.

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -9,7 +9,6 @@ from .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperSpanExport
 from _typeshed import Incomplete
 from collections import deque
 from collections.abc import Mapping, Sequence
-from functools import cached_property
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import ReadableLogRecord as ReadableLogRecord
@@ -60,7 +59,7 @@ class OTLPExporterHttpSession(Session):
     def __init__(self, *, _use_zstd: bool = False) -> None: ...
     def request(self, method: str, url: str, **kwargs: Any): ...
     def post(self, url: str, data: bytes, **kwargs: Any): ...
-    @cached_property
+    @property
     def retryer(self) -> DiskRetryer: ...
     def close(self) -> None: ...
 
@@ -76,6 +75,7 @@ class DiskRetryer:
     tasks: deque[tuple[Path, dict[str, Any]]]
     total_size: int
     closed: bool
+    pid: Incomplete
     session: Incomplete
     dir: Incomplete
     last_log_time: Incomplete

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/exporters/processor_wrapper.pyi

@@ -5,9 +5,11 @@ from ..json_schema import JsonSchemaProperties as JsonSchemaProperties, attribut
 from ..scrubbing import BaseScrubber as BaseScrubber
 from ..utils import ReadableSpanDict as ReadableSpanDict, handle_internal_errors as handle_internal_errors, is_asgi_send_receive_span_name as is_asgi_send_receive_span_name, is_instrumentation_suppressed as is_instrumentation_suppressed, span_to_dict as span_to_dict, truncate_string as truncate_string
 from .wrapper import WrapperSpanProcessor as WrapperSpanProcessor
+from collections.abc import Sequence
 from dataclasses import dataclass
 from opentelemetry import context
-from opentelemetry.sdk.trace import Event as Event, ReadableSpan, Span
+from opentelemetry.sdk.trace import Event as Event, ReadableSpan, Span, SpanProcessor, SynchronousMultiSpanProcessor
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExportResult, SpanExporter
 
 class CheckSuppressInstrumentationProcessorWrapper(WrapperSpanProcessor):
     """Checks if instrumentation is suppressed, then suppresses instrumentation itself.
@@ -17,14 +19,42 @@ class CheckSuppressInstrumentationProcessorWrapper(WrapperSpanProcessor):
     def on_start(self, span: Span, parent_context: context.Context | None = None) -> None: ...
     def on_end(self, span: ReadableSpan) -> None: ...
 
-@dataclass
 class MainSpanProcessorWrapper(WrapperSpanProcessor):
     """Wrapper around other processors to intercept starting and ending spans with our own global logic.
 
     Suppresses starting/ending if the current context has a `suppress_instrumentation` value.
     Tweaks the send/receive span names generated by the ASGI middleware.
     """
+    def on_end(self, span: ReadableSpan) -> None: ...
+
+def scrub_span(span: ReadableSpan, scrubber: BaseScrubber) -> ReadableSpan: ...
+
+@dataclass
+class ScrubbingSpanProcessor(WrapperSpanProcessor):
     scrubber: BaseScrubber
     def on_end(self, span: ReadableSpan) -> None: ...
 
+@dataclass
+class _SpanProcessorExporter(SpanExporter):
+    """Forward drained records to a processor's `on_end` hook.
+
+    The group that owns the destination processor flushes and shuts it down.
+    """
+    processor: SpanProcessor
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult: ...
+
+def make_scrubbing_queue(processor: SpanProcessor, scrubber: BaseScrubber) -> BatchSpanProcessor:
+    """Queue records for scrubbing before delivering them to a processor."""
+
+class SpanProcessorGroup(SynchronousMultiSpanProcessor):
+    """Flush processors that may inherit a no-op force_flush returning None."""
+    def force_flush(self, timeout_millis: int = 30000) -> bool: ...
+
+@dataclass
+class BackgroundScrubbingSpanProcessor(WrapperSpanProcessor):
+    """Send completed spans to the synchronous processors and the scrubbing queue."""
+    synchronous_end_processor: SpanProcessor
+    background_end_processor: BatchSpanProcessor
+    def on_end(self, span: ReadableSpan) -> None: ...
+
 def guess_system(model: str, default: str = ''): ...

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/formatter.pyi

@@ -9,7 +9,7 @@ from _typeshed import Incomplete
 from collections.abc import Iterator
 from functools import lru_cache
 from string import Formatter
-from types import CodeType as CodeType
+from types import CodeType
 from typing import Any, Literal
 from typing_extensions import NotRequired, TypedDict
 
@@ -29,6 +29,10 @@ chunks_formatter: Incomplete
 
 def logfire_format(format_string: str, kwargs: dict[str, Any], scrubber: BaseScrubber) -> str: ...
 def logfire_format_with_magic(format_string: Any, kwargs: dict[str, Any], scrubber: BaseScrubber, fstring_frame: types.FrameType | None = None) -> tuple[str, dict[str, Any], str]: ...
+
+LOGFIRE_PACKAGE_DIR: Incomplete
+
+def is_logfire_code(code: CodeType) -> bool: ...
 @lru_cache
 def compile_formatted_value(node: ast.FormattedValue, ex_source: executing.Source) -> tuple[str, CodeType, CodeType]:
     """Returns three things that can be expensive to compute.

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/json_encoder.pyi

@@ -12,6 +12,11 @@ EncoderFunction: Incomplete
 
 @cache
 def encoder_by_type() -> dict[type[Any], EncoderFunction]: ...
+def numpy_scalar_to_python(o: Any) -> Any:
+    """Convert a NumPy bool, integer or floating scalar to the equivalent Python value, and return anything else as is.
+
+    Without this, a value like `numpy.int64(42)` (e.g. from `df['col'].sum()`) would be recorded as its repr.
+    """
 def to_json_value(o: Any, seen: set[int]) -> JsonValue: ...
 def logfire_json_dumps(obj: Any) -> str: ...
 def is_sqlalchemy(obj: Any) -> bool: ...

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/main.pyi

@@ -16,7 +16,6 @@ from ..integrations.sqlalchemy import CommenterOptions as SQLAlchemyCommenterOpt
 from ..integrations.wsgi import RequestHook as WSGIRequestHook, ResponseHook as WSGIResponseHook
 from ..variables import ResolveFunction as ResolveFunction, TemplateVariable as TemplateVariable, ValidationReport as ValidationReport, Variable as Variable, VariablesConfig as VariablesConfig
 from ..version import VERSION as VERSION
-from .agent_sandboxes import AgentSandboxPool as AgentSandboxPool
 from .auto_trace import AutoTraceModule as AutoTraceModule, install_auto_tracing as install_auto_tracing
 from .config import GLOBAL_CONFIG as GLOBAL_CONFIG, LogfireConfig as LogfireConfig, TemplateMismatchPolicy as TemplateMismatchPolicy
 from .config_params import PydanticPluginRecordValues as PydanticPluginRecordValues
@@ -31,7 +30,7 @@ from .integrations.mysql import MySQLConnection as MySQLConnection
 from .integrations.psycopg import Psycopg2Connection as Psycopg2Connection, PsycopgConnection as PsycopgConnection
 from .integrations.sqlite3 import SQLite3Connection as SQLite3Connection
 from .integrations.system_metrics import Base as SystemMetricsBase, Config as SystemMetricsConfig
-from .json_encoder import logfire_json_dumps as logfire_json_dumps
+from .json_encoder import logfire_json_dumps as logfire_json_dumps, numpy_scalar_to_python as numpy_scalar_to_python
 from .json_schema import JsonSchemaProperties as JsonSchemaProperties, attributes_json_schema as attributes_json_schema, attributes_json_schema_properties as attributes_json_schema_properties, create_json_schema as create_json_schema
 from .metrics import ProxyMeterProvider as ProxyMeterProvider
 from .stack_info import get_user_stack_info as get_user_stack_info
@@ -52,6 +51,7 @@ from opentelemetry.sdk.trace import ReadableSpan, Span
 from opentelemetry.trace import SpanContext, SpanKind
 from opentelemetry.util import types as otel_types
 from pydantic_evals.reporting import EvaluationReport
+from pydantic_monty import AsyncMontyRemote
 from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, CommandStartedEvent as CommandStartedEvent, CommandSucceededEvent as CommandSucceededEvent
 from snowflake.connector.connection import SnowflakeConnection
 from sqlalchemy import Engine
@@ -527,13 +527,13 @@ class Logfire:
         It records Monty sessions, executed code, inputs, outputs, external calls,
         exceptions, printed text, and pool metrics. Recorded values are subject to Logfire's configured scrubbing.
         """
-    def agent_sandboxes(self, *, api_key: str | None = None, url: str | None = None, max_processes: int | None | _Unset = ..., checkout_timeout: float | None | _Unset = ..., request_timeout: float | None | _Unset = ..., metadata: Callable[[], Mapping[str, str]] | None | _Unset = ..., connect_headers: Callable[[], Mapping[str, str]] | None | _Unset = ..., feed_duration_limit_grace: float | None | _Unset = ..., turn_duration_limit_grace: float | None | _Unset = ..., auto_resume: bool | _Unset = ..., **kwargs: Any) -> AgentSandboxPool:
+    def agent_sandboxes(self, *, api_key: str | None = None, url: str | None = None, max_processes: int | None | _Unset = ..., checkout_timeout: float | None | _Unset = ..., request_timeout: float | None | _Unset = ..., metadata: Callable[[], Mapping[str, str]] | None | _Unset = ..., connect_headers: Callable[[], Mapping[str, str]] | None | _Unset = ..., feed_duration_limit_grace: float | None | _Unset = ..., turn_duration_limit_grace: float | None | _Unset = ..., auto_resume: bool | _Unset = ..., **kwargs: Any) -> AsyncMontyRemote:
         """Connect to Logfire Agent Sandboxes, remote Pydantic Monty workers hosted by Logfire.
 
         Requires the `agent-sandboxes` extra, e.g. `pip install 'logfire[agent-sandboxes]'`.
 
-        Returns a wrapper around a [`pydantic_monty.AsyncMontyRemote`][pydantic_monty.AsyncMontyRemote] pool;
-        use it as an async context manager and check out sessions from it:
+        Returns a [`pydantic_monty.AsyncMontyRemote`][pydantic_monty.AsyncMontyRemote] pool that
+        authenticates with your Logfire API key. Use it as an async context manager and check out sessions from it:
 
         ```py
         import logfire
@@ -549,9 +549,16 @@ class Logfire:
 
         No connection is made until a session is checked out.
 
-        Checkout accepts the same options and yields the same Monty sessions as `AsyncMontyRemote`.
-        Authentication and capacity refusals raise `RuntimeError` with Logfire hints, chained from
-        the original `MontyRefusedError`. Other errors pass through unchanged.
+        Because the pool is a plain `AsyncMontyRemote`, you can pass this method wherever a Monty pool
+        factory is expected, for example `CodeMode(monty_sandbox=logfire.agent_sandboxes)` in Pydantic AI.
+
+        Checkout errors from the sandboxes server are Monty's own exceptions; this method does not wrap them.
+        An exception raised by your `metadata` callback propagates unchanged. A refused checkout raises
+        `MontyRefusedError`. For `UNAUTHENTICATED` or
+        `PERMISSION_DENIED`, check that the key is a project API key with the
+        `project:execute_agent_sandboxes` scope, that its region matches the server URL, and that Agent
+        Sandboxes are enabled for the project. For `RESOURCE_EXHAUSTED`, lower `max_processes` or retry
+        after a delay.
 
         The Logfire platform records sandbox usage itself. The current trace context is sent
         with each session so those spans join the caller's trace.

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/_internal/scrubbing.pyi

@@ -1,6 +1,7 @@
 import re
 import typing_extensions
 from .constants import ATTRIBUTES_CONFIG as ATTRIBUTES_CONFIG, ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_LOG_LEVEL_NAME_KEY as ATTRIBUTES_LOG_LEVEL_NAME_KEY, ATTRIBUTES_LOG_LEVEL_NUM_KEY as ATTRIBUTES_LOG_LEVEL_NUM_KEY, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_PACKAGE_VERSIONS as ATTRIBUTES_PACKAGE_VERSIONS, ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY as ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SCRUBBED_KEY as ATTRIBUTES_SCRUBBED_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT as MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT, RESOURCE_ATTRIBUTES_VERSION as RESOURCE_ATTRIBUTES_VERSION
+from .json_encoder import logfire_json_dumps as logfire_json_dumps
 from .stack_info import STACK_INFO_KEYS as STACK_INFO_KEYS
 from .utils import ReadableSpanDict as ReadableSpanDict, truncate_string as truncate_string
 from _typeshed import Incomplete
@@ -62,7 +63,7 @@ class SpanScrubber:
     and hold and mutate state about the span being scrubbed, specifically the scrubbed notes.
     """
     scrubbed: list[ScrubbedNote]
-    did_scrub: bool
+    scrub_count: int
     def __init__(self, parent: Scrubber) -> None: ...
     def scrub_span(self, span: ReadableSpanDict): ...
     def scrub_log(self, log: LogRecord) -> LogRecord: ...

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/integrations/logging.pyi

@@ -2,7 +2,6 @@ from .. import Logfire as Logfire
 from .._internal.constants import ATTRIBUTES_LOGGING_ARGS_KEY as ATTRIBUTES_LOGGING_ARGS_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, LOGGING_TO_OTEL_LEVEL_NUMBERS as LOGGING_TO_OTEL_LEVEL_NUMBERS
 from .._internal.utils import is_instrumentation_suppressed as is_instrumentation_suppressed
 from _typeshed import Incomplete
-from collections.abc import Mapping as Mapping
 from logging import Handler as LoggingHandler, LogRecord
 from typing import Any, ClassVar
 

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/sampling/_tail_sampling.pyi

@@ -77,9 +77,10 @@ class TailSamplingProcessor(WrapperSpanProcessor):
     """
     get_tail_sample_rate: Incomplete
     deferred_processor: Incomplete
+    prepare_ended_span: Incomplete
     traces: dict[int, TraceBuffer]
     lock: Incomplete
-    def __init__(self, processor: SpanProcessor, get_tail_sample_rate: Callable[[TailSamplingSpanInfo], float], deferred_processor: SpanProcessor | None = None) -> None: ...
+    def __init__(self, processor: SpanProcessor, get_tail_sample_rate: Callable[[TailSamplingSpanInfo], float], deferred_processor: SpanProcessor | None = None, *, prepare_ended_span: Callable[[ReadableSpan], ReadableSpan] | None = None) -> None: ...
     def on_start(self, span: Span, parent_context: context.Context | None = None) -> None: ...
     def on_end(self, span: ReadableSpan) -> None: ...
     def check_span(self, span_info: TailSamplingSpanInfo) -> bool:

{logfire_api-5.5.0 → logfire_api-5.6.0}/logfire_api/types.pyi

@@ -18,6 +18,9 @@ class SpanLevel:
     `<`, `>`, `<=`, or `>=`, so e.g. `level >= 'error'` is valid.
 
     Will raise an exception if compared to a non-string or an invalid level name.
+
+    Hashing a level warns and uses its name, so `level in {'warn', 'error'}` works,
+    but `level in {13}` does not. Prefer `level.name in {...}`.
     """
     number: int
     @classmethod

{logfire_api-5.5.0 → logfire_api-5.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "logfire-api"
-version = "5.5.0"
+version = "5.6.0"
 description = "Shim for the Logfire SDK which does nothing unless Logfire is installed"
 authors = [
     { name = "Pydantic Team", email = "engineering@pydantic.dev" },

logfire_api-5.5.0/logfire_api/_internal/agent_sandboxes.pyi

@@ -1,42 +0,0 @@
-from collections.abc import Awaitable as Awaitable, Callable, Mapping
-from contextlib import AbstractAsyncContextManager
-from logfire import Logfire as Logfire
-from logfire.exceptions import LogfireConfigError as LogfireConfigError
-from logfire.propagate import get_context as get_context
-from pydantic_monty import AsyncMontyRemote, AsyncMontySession as AsyncMontySession, ExternalModule as ExternalModule, OSPolicy, ResourceLimits, TypeCheckFormat
-from typing import Any
-from typing_extensions import TypedDict, Unpack
-
-class AgentSandboxCheckoutOptions(TypedDict, total=False):
-    """Keyword options forwarded unchanged to AsyncMontyRemote.checkout."""
-    script_name: str
-    limits: ResourceLimits | None
-    type_check: bool
-    type_check_stubs: str | None
-    type_check_format: TypeCheckFormat | None
-    type_check_color: bool
-    assert_message_annotations: bool | int
-    print_flush_interval: float | None
-    os_policy: OSPolicy | None
-    external_modules: Mapping[str, ExternalModule | Callable[[], Awaitable[ExternalModule]]] | None
-    ephemeral: bool | None
-    profile: str | None
-
-class AgentSandboxPool:
-    """An async Monty remote pool that adds Logfire hints when checkout is refused.
-
-    Monty's native pool and refusal exception cannot be subclassed. Hinted refusals raise
-    RuntimeError, with the original MontyRefusedError available as the chained cause.
-    """
-    def __init__(self, pool: AsyncMontyRemote) -> None: ...
-    async def __aenter__(self) -> AgentSandboxPool: ...
-    async def __aexit__(self, *args: Any) -> None: ...
-    def checkout(self, **kwargs: Unpack[AgentSandboxCheckoutOptions]) -> AbstractAsyncContextManager[AsyncMontySession]:
-        """Check out a session with the options and defaults of AsyncMontyRemote.checkout."""
-
-def agent_sandboxes_url(base_url: str) -> str:
-    """Validate and normalize a supplied or derived Logfire Agent Sandboxes URL.
-
-    The client opens its gRPC stream at the root of this URL, so the base URL must not have a path.
-    """
-def create_agent_sandboxes(logfire_instance: Logfire, *, api_key: str | None, url: str | None, metadata: Callable[[], Mapping[str, str]] | None = None, connect_headers: Callable[[], Mapping[str, str]] | None = None, **kwargs: Any) -> AgentSandboxPool: ...