Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

feat: add provider trace backend abstraction for multi-backend telemetry (#8814)

Kian Jones9418ab98152e
diff --git a/alembic/versions/539afa667cff_add_telemetry_context_fields_to_.py b/alembic/versions/539afa667cff_add_telemetry_context_fields_to_.py
new file mode 100644
index 000000000..4e54ae09d
--- /dev/null
+++ b/alembic/versions/539afa667cff_add_telemetry_context_fields_to_.py
@@ -0,0 +1,33 @@
+"""add telemetry context fields to provider_traces
+
+Revision ID: 539afa667cff
+Revises: a1b2c3d4e5f7
+Create Date: 2026-01-16 18:29:29.811385
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "539afa667cff"
+down_revision: Union[str, None] = "a1b2c3d4e5f7"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.add_column("provider_traces", sa.Column("agent_id", sa.String(), nullable=True))
+ op.add_column("provider_traces", sa.Column("agent_tags", sa.JSON(), nullable=True))
+ op.add_column("provider_traces", sa.Column("call_type", sa.String(), nullable=True))
+ op.add_column("provider_traces", sa.Column("run_id", sa.String(), nullable=True))
+
+
+def downgrade() -> None:
+ op.drop_column("provider_traces", "run_id")
+ op.drop_column("provider_traces", "call_type")
+ op.drop_column("provider_traces", "agent_tags")
+ op.drop_column("provider_traces", "agent_id")
diff --git a/letta/adapters/letta_llm_request_adapter.py b/letta/adapters/letta_llm_request_adapter.py
index f045c0c2e..70cdca6d0 100644
--- a/letta/adapters/letta_llm_request_adapter.py
+++ b/letta/adapters/letta_llm_request_adapter.py
@@ -5,7 +5,7 @@ from letta.helpers.datetime_helpers import get_utc_timestamp_ns
from letta.otel.tracing import log_attributes, log_event, safe_json_dumps, trace_method
from letta.schemas.letta_message import LettaMessage
from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, TextContent
-from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.provider_trace import ProviderTrace
from letta.schemas.usage import normalize_cache_tokens, normalize_reasoning_tokens
from letta.schemas.user import User
from letta.settings import settings
@@ -120,7 +120,7 @@ class LettaLLMRequestAdapter(LettaLLMAdapter):
safe_create_task(
self.telemetry_manager.create_provider_trace_async(
actor=actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=self.request_data,
response_json=self.response_data,
step_id=step_id, # Use original step_id for telemetry
diff --git a/letta/adapters/letta_llm_stream_adapter.py b/letta/adapters/letta_llm_stream_adapter.py
index 1b4d7fe9e..7f96f9146 100644
--- a/letta/adapters/letta_llm_stream_adapter.py
+++ b/letta/adapters/letta_llm_stream_adapter.py
@@ -9,7 +9,7 @@ from letta.otel.tracing import log_attributes, safe_json_dumps, trace_method
from letta.schemas.enums import ProviderType
from letta.schemas.letta_message import LettaMessage
from letta.schemas.llm_config import LLMConfig
-from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.provider_trace import ProviderTrace
from letta.schemas.usage import LettaUsageStatistics
from letta.schemas.user import User
from letta.settings import settings
@@ -223,7 +223,7 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
safe_create_task(
self.telemetry_manager.create_provider_trace_async(
actor=actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=self.request_data,
response_json=response_json,
step_id=step_id, # Use original step_id for telemetry
diff --git a/letta/adapters/simple_llm_stream_adapter.py b/letta/adapters/simple_llm_stream_adapter.py
index ff3eca312..cad388249 100644
--- a/letta/adapters/simple_llm_stream_adapter.py
+++ b/letta/adapters/simple_llm_stream_adapter.py
@@ -13,7 +13,7 @@ from letta.otel.tracing import log_attributes, safe_json_dumps, trace_method
from letta.schemas.enums import ProviderType
from letta.schemas.letta_message import LettaMessage
from letta.schemas.letta_message_content import LettaMessageContentUnion
-from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.provider_trace import ProviderTrace
from letta.schemas.usage import LettaUsageStatistics
from letta.schemas.user import User
from letta.settings import settings
@@ -276,11 +276,10 @@ class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):
safe_create_task(
self.telemetry_manager.create_provider_trace_async(
actor=actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=self.request_data,
response_json=response_json,
- step_id=step_id, # Use original step_id for telemetry
- organization_id=actor.organization_id,
+ step_id=step_id,
),
),
label="create_provider_trace",
diff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.py
index 567b6e2be..1e5b85d65 100644
--- a/letta/agents/letta_agent.py
+++ b/letta/agents/letta_agent.py
@@ -49,7 +49,7 @@ from letta.schemas.openai.chat_completion_response import (
UsageStatisticsCompletionTokenDetails,
UsageStatisticsPromptTokenDetails,
)
-from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.provider_trace import ProviderTrace
from letta.schemas.step import StepProgression
from letta.schemas.step_metrics import StepMetrics
from letta.schemas.tool_execution_result import ToolExecutionResult
@@ -411,7 +411,7 @@ class LettaAgent(BaseAgent):
if settings.track_provider_trace:
await self.telemetry_manager.create_provider_trace_async(
actor=self.actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=request_data,
response_json=response_data,
step_id=step_id, # Use original step_id for telemetry
@@ -756,7 +756,7 @@ class LettaAgent(BaseAgent):
if settings.track_provider_trace:
await self.telemetry_manager.create_provider_trace_async(
actor=self.actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=request_data,
response_json=response_data,
step_id=step_id, # Use original step_id for telemetry
@@ -1190,7 +1190,7 @@ class LettaAgent(BaseAgent):
if settings.track_provider_trace:
await self.telemetry_manager.create_provider_trace_async(
actor=self.actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=request_data,
response_json={
"content": {
diff --git a/letta/llm_api/llm_api_tools.py b/letta/llm_api/llm_api_tools.py
index b8eddf215..0bee61a6b 100644
--- a/letta/llm_api/llm_api_tools.py
+++ b/letta/llm_api/llm_api_tools.py
@@ -27,7 +27,7 @@ from letta.schemas.enums import ProviderCategory
from letta.schemas.llm_config import LLMConfig
from letta.schemas.message import Message
from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
-from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.provider_trace import ProviderTrace
from letta.services.telemetry_manager import TelemetryManager
from letta.settings import ModelSettings
from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
@@ -241,7 +241,7 @@ def create(
telemetry_manager.create_provider_trace(
actor=actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=prepare_openai_payload(data),
response_json=response.model_json_schema(),
step_id=step_id,
diff --git a/letta/llm_api/llm_client_base.py b/letta/llm_api/llm_client_base.py
index 608451a82..5ed4b9e8d 100644
--- a/letta/llm_api/llm_client_base.py
+++ b/letta/llm_api/llm_client_base.py
@@ -14,7 +14,7 @@ from letta.schemas.enums import AgentType, ProviderCategory
from letta.schemas.llm_config import LLMConfig
from letta.schemas.message import Message
from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
-from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.provider_trace import ProviderTrace
from letta.services.telemetry_manager import TelemetryManager
from letta.settings import settings
@@ -71,7 +71,7 @@ class LLMClientBase:
if step_id and telemetry_manager:
telemetry_manager.create_provider_trace(
actor=self.actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=request_data,
response_json=response_data,
step_id=step_id,
@@ -104,7 +104,7 @@ class LLMClientBase:
if settings.track_provider_trace and telemetry_manager:
await telemetry_manager.create_provider_trace_async(
actor=self.actor,
- provider_trace_create=ProviderTraceCreate(
+ provider_trace=ProviderTrace(
request_json=request_data,
response_json=response_data,
step_id=step_id,
diff --git a/letta/orm/provider_trace.py b/letta/orm/provider_trace.py
index 69b7df14d..29e8a63f0 100644
--- a/letta/orm/provider_trace.py
+++ b/letta/orm/provider_trace.py
@@ -1,4 +1,5 @@
import uuid
+from typing import Optional
from sqlalchemy import JSON, Index, String
from sqlalchemy.orm import Mapped, mapped_column, relationship
@@ -20,7 +21,13 @@ class ProviderTrace(SqlalchemyBase, OrganizationMixin):
)
request_json: Mapped[dict] = mapped_column(JSON, doc="JSON content of the provider request")
response_json: Mapped[dict] = mapped_column(JSON, doc="JSON content of the provider response")
- step_id: Mapped[str] = mapped_column(String, nullable=True, doc="ID of the step that this trace is associated with")
+ step_id: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="ID of the step that this trace is associated with")
+
+ # Telemetry context fields
+ agent_id: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="ID of the agent that generated this trace")
+ agent_tags: Mapped[Optional[list]] = mapped_column(JSON, nullable=True, doc="Tags associated with the agent for filtering")
+ call_type: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="Type of call (agent_step, summarization, etc.)")
+ run_id: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="ID of the run this trace is associated with")
# Relationships
organization: Mapped["Organization"] = relationship("Organization", lazy="selectin")
diff --git a/letta/schemas/provider_trace.py b/letta/schemas/provider_trace.py
index 0e75d6253..a7493a580 100644
--- a/letta/schemas/provider_trace.py
+++ b/letta/schemas/provider_trace.py
@@ -3,7 +3,7 @@ from __future__ import annotations
from datetime import datetime
from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field
+from pydantic import Field
from letta.helpers.datetime_helpers import get_utc_time
from letta.schemas.enums import PrimitiveType
@@ -14,14 +14,6 @@ class BaseProviderTrace(OrmMetadataBase):
__id_prefix__ = PrimitiveType.PROVIDER_TRACE.value
-class ProviderTraceCreate(BaseModel):
- """Request to create a provider trace"""
-
- request_json: dict[str, Any] = Field(..., description="JSON content of the provider request")
- response_json: dict[str, Any] = Field(..., description="JSON content of the provider response")
- step_id: str = Field(None, description="ID of the step that this trace is associated with")
-
-
class ProviderTrace(BaseProviderTrace):
"""
Letta's internal representation of a provider trace.
@@ -31,6 +23,10 @@ class ProviderTrace(BaseProviderTrace):
request_json (Dict[str, Any]): JSON content of the provider request.
response_json (Dict[str, Any]): JSON content of the provider response.
step_id (str): ID of the step that this trace is associated with.
+ agent_id (str): ID of the agent that generated this trace.
+ agent_tags (list[str]): Tags associated with the agent for filtering.
+ call_type (str): Type of call (agent_step, summarization, etc.).
+ run_id (str): ID of the run this trace is associated with.
organization_id (str): The unique identifier of the organization.
created_at (datetime): The timestamp when the object was created.
"""
@@ -39,4 +35,11 @@ class ProviderTrace(BaseProviderTrace):
request_json: Dict[str, Any] = Field(..., description="JSON content of the provider request")
response_json: Dict[str, Any] = Field(..., description="JSON content of the provider response")
step_id: Optional[str] = Field(None, description="ID of the step that this trace is associated with")
+
+ # Telemetry context fields
+ agent_id: Optional[str] = Field(None, description="ID of the agent that generated this trace")
+ agent_tags: Optional[list[str]] = Field(None, description="Tags associated with the agent for filtering")
+ call_type: Optional[str] = Field(None, description="Type of call (agent_step, summarization, etc.)")
+ run_id: Optional[str] = Field(None, description="ID of the run this trace is associated with")
+
created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
diff --git a/letta/server/rest_api/routers/v1/runs.py b/letta/server/rest_api/routers/v1/runs.py
index 90de376b0..30316d46e 100644
--- a/letta/server/rest_api/routers/v1/runs.py
+++ b/letta/server/rest_api/routers/v1/runs.py
@@ -288,10 +288,10 @@ async def retrieve_trace_for_run(
Requires ClickHouse to be configured for trace storage.
"""
# OTEL traces are only available when ClickHouse is configured
- if not settings.use_clickhouse_for_provider_traces:
+ if not settings.clickhouse_endpoint:
raise HTTPException(
status_code=501,
- detail="OTEL traces require ClickHouse. Set use_clickhouse_for_provider_traces=true and configure ClickHouse connection.",
+ detail="OTEL traces require ClickHouse. Set LETTA_CLICKHOUSE_ENDPOINT and configure ClickHouse connection.",
)
actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
diff --git a/letta/services/clickhouse_otel_traces.py b/letta/services/clickhouse_otel_traces.py
index c7a48e8dd..1cc93d1c9 100644
--- a/letta/services/clickhouse_otel_traces.py
+++ b/letta/services/clickhouse_otel_traces.py
@@ -26,12 +26,9 @@ def _parse_clickhouse_endpoint(endpoint: str) -> tuple[str, int, bool]:
@singleton
class ClickhouseOtelTracesReader:
def __init__(self):
- self._client = None
+ pass
def _get_client(self):
- if self._client is not None:
- return self._client
-
import clickhouse_connect
if not settings.clickhouse_endpoint:
@@ -47,7 +44,7 @@ class ClickhouseOtelTracesReader:
if not password:
raise ValueError("CLICKHOUSE_PASSWORD is required")
- self._client = clickhouse_connect.get_client(
+ return clickhouse_connect.get_client(
host=host,
port=port,
username=username,
@@ -56,7 +53,6 @@ class ClickhouseOtelTracesReader:
secure=secure,
verify=True,
)
- return self._client
def _get_traces_by_trace_id_sync(self, trace_id: str, limit: int, filter_ui_spans: bool = False) -> list[dict[str, Any]]:
client = self._get_client()
diff --git a/letta/services/provider_trace_backends/__init__.py b/letta/services/provider_trace_backends/__init__.py
new file mode 100644
index 000000000..75c684327
--- /dev/null
+++ b/letta/services/provider_trace_backends/__init__.py
@@ -0,0 +1,20 @@
+"""
+Provider trace backend abstraction.
+
+Supports multiple storage backends for LLM telemetry:
+- postgres: Store in PostgreSQL (default)
+- clickhouse: Store in ClickHouse via OTEL instrumentation
+- socket: Send via Unix socket to external sidecar/service
+
+Multiple backends can be enabled simultaneously for dual-write scenarios.
+"""
+
+from letta.services.provider_trace_backends.base import ProviderTraceBackend, ProviderTraceBackendClient
+from letta.services.provider_trace_backends.factory import get_provider_trace_backend, get_provider_trace_backends
+
+__all__ = [
+ "ProviderTraceBackend",
+ "ProviderTraceBackendClient",
+ "get_provider_trace_backend",
+ "get_provider_trace_backends",
+]
diff --git a/letta/services/provider_trace_backends/base.py b/letta/services/provider_trace_backends/base.py
new file mode 100644
index 000000000..821d0253c
--- /dev/null
+++ b/letta/services/provider_trace_backends/base.py
@@ -0,0 +1,69 @@
+"""Base class for provider trace backends."""
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from letta.schemas.provider_trace import ProviderTrace
+ from letta.schemas.user import User
+
+
+class ProviderTraceBackend(str, Enum):
+ """Supported provider trace storage backends."""
+
+ POSTGRES = "postgres"
+ CLICKHOUSE = "clickhouse"
+ SOCKET = "socket"
+
+
+class ProviderTraceBackendClient(ABC):
+ """Abstract base class for provider trace storage backends."""
+
+ @abstractmethod
+ async def create_async(
+ self,
+ actor: "User",
+ provider_trace: "ProviderTrace",
+ ) -> "ProviderTrace | None":
+ """
+ Store a provider trace record.
+
+ Args:
+ actor: The user/actor creating the trace
+ provider_trace: The trace data to store
+
+ Returns:
+ The created ProviderTrace, or None if the backend doesn't return it
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ async def get_by_step_id_async(
+ self,
+ step_id: str,
+ actor: "User",
+ ) -> "ProviderTrace | None":
+ """
+ Retrieve a provider trace by step ID.
+
+ Args:
+ step_id: The step ID to look up
+ actor: The user/actor requesting the trace
+
+ Returns:
+ The ProviderTrace if found, None otherwise
+ """
+ raise NotImplementedError
+
+ def create_sync(
+ self,
+ actor: "User",
+ provider_trace: "ProviderTrace",
+ ) -> "ProviderTrace | None":
+ """
+ Synchronous version of create_async.
+
+ Default implementation does nothing. Override if sync support is needed.
+ """
+ return None
diff --git a/letta/services/provider_trace_backends/clickhouse.py b/letta/services/provider_trace_backends/clickhouse.py
new file mode 100644
index 000000000..1c5731f7d
--- /dev/null
+++ b/letta/services/provider_trace_backends/clickhouse.py
@@ -0,0 +1,42 @@
+"""ClickHouse provider trace backend."""
+
+from letta.schemas.provider_trace import ProviderTrace
+from letta.schemas.user import User
+from letta.services.clickhouse_provider_traces import ClickhouseProviderTraceReader
+from letta.services.provider_trace_backends.base import ProviderTraceBackendClient
+
+
+class ClickhouseProviderTraceBackend(ProviderTraceBackendClient):
+ """
+ Store provider traces in ClickHouse.
+
+ Writes flow through OTEL instrumentation, so create_async is a no-op.
+ Only reads are performed directly against ClickHouse.
+ """
+
+ def __init__(self):
+ self._reader = ClickhouseProviderTraceReader()
+
+ async def create_async(
+ self,
+ actor: User,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace:
+ # ClickHouse writes flow through OTEL instrumentation, not direct writes.
+ # Return a ProviderTrace with the same ID for consistency across backends.
+ return ProviderTrace(
+ id=provider_trace.id,
+ step_id=provider_trace.step_id,
+ request_json=provider_trace.request_json or {},
+ response_json=provider_trace.response_json or {},
+ )
+
+ async def get_by_step_id_async(
+ self,
+ step_id: str,
+ actor: User,
+ ) -> ProviderTrace | None:
+ return await self._reader.get_provider_trace_by_step_id_async(
+ step_id=step_id,
+ organization_id=actor.organization_id,
+ )
diff --git a/letta/services/provider_trace_backends/factory.py b/letta/services/provider_trace_backends/factory.py
new file mode 100644
index 000000000..ea1b93e56
--- /dev/null
+++ b/letta/services/provider_trace_backends/factory.py
@@ -0,0 +1,52 @@
+"""Factory for creating provider trace backends."""
+
+from functools import lru_cache
+
+from letta.services.provider_trace_backends.base import ProviderTraceBackend, ProviderTraceBackendClient
+
+
+def _create_backend(backend: ProviderTraceBackend | str) -> ProviderTraceBackendClient:
+ """Create a single backend instance."""
+ from letta.settings import telemetry_settings
+
+ backend_str = backend.value if isinstance(backend, ProviderTraceBackend) else backend
+
+ match backend_str:
+ case "clickhouse":
+ from letta.services.provider_trace_backends.clickhouse import ClickhouseProviderTraceBackend
+
+ return ClickhouseProviderTraceBackend()
+
+ case "socket":
+ from letta.services.provider_trace_backends.socket import SocketProviderTraceBackend
+
+ return SocketProviderTraceBackend(socket_path=telemetry_settings.socket_path)
+
+ case "postgres" | _:
+ from letta.services.provider_trace_backends.postgres import PostgresProviderTraceBackend
+
+ return PostgresProviderTraceBackend()
+
+
+@lru_cache(maxsize=1)
+def get_provider_trace_backends() -> list[ProviderTraceBackendClient]:
+ """
+ Get all configured provider trace backends.
+
+ Returns cached singleton instances for each configured backend.
+ Supports multiple backends for dual-write scenarios (e.g., migration).
+ """
+ from letta.settings import telemetry_settings
+
+ backends = telemetry_settings.provider_trace_backends
+ return [_create_backend(b) for b in backends]
+
+
+def get_provider_trace_backend() -> ProviderTraceBackendClient:
+ """
+ Get the primary (first) configured provider trace backend.
+
+ For backwards compatibility and read operations.
+ """
+ backends = get_provider_trace_backends()
+ return backends[0] if backends else _create_backend("postgres")
diff --git a/letta/services/provider_trace_backends/postgres.py b/letta/services/provider_trace_backends/postgres.py
new file mode 100644
index 000000000..9980cec9a
--- /dev/null
+++ b/letta/services/provider_trace_backends/postgres.py
@@ -0,0 +1,45 @@
+"""PostgreSQL provider trace backend."""
+
+from letta.helpers.json_helpers import json_dumps, json_loads
+from letta.orm.provider_trace import ProviderTrace as ProviderTraceModel
+from letta.schemas.provider_trace import ProviderTrace
+from letta.schemas.user import User
+from letta.server.db import db_registry
+from letta.services.provider_trace_backends.base import ProviderTraceBackendClient
+
+
+class PostgresProviderTraceBackend(ProviderTraceBackendClient):
+ """Store provider traces in PostgreSQL."""
+
+ async def create_async(
+ self,
+ actor: User,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace:
+ async with db_registry.async_session() as session:
+ provider_trace_model = ProviderTraceModel(**provider_trace.model_dump())
+ provider_trace_model.organization_id = actor.organization_id
+
+ if provider_trace.request_json:
+ request_json_str = json_dumps(provider_trace.request_json)
+ provider_trace_model.request_json = json_loads(request_json_str)
+
+ if provider_trace.response_json:
+ response_json_str = json_dumps(provider_trace.response_json)
+ provider_trace_model.response_json = json_loads(response_json_str)
+
+ await provider_trace_model.create_async(session, actor=actor, no_commit=True, no_refresh=True)
+ return provider_trace_model.to_pydantic()
+
+ async def get_by_step_id_async(
+ self,
+ step_id: str,
+ actor: User,
+ ) -> ProviderTrace | None:
+ async with db_registry.async_session() as session:
+ provider_trace_model = await ProviderTraceModel.read_async(
+ db_session=session,
+ step_id=step_id,
+ actor=actor,
+ )
+ return provider_trace_model.to_pydantic() if provider_trace_model else None
diff --git a/letta/services/provider_trace_backends/socket.py b/letta/services/provider_trace_backends/socket.py
new file mode 100644
index 000000000..6fb6097ce
--- /dev/null
+++ b/letta/services/provider_trace_backends/socket.py
@@ -0,0 +1,107 @@
+"""Unix socket provider trace backend."""
+
+import json
+import os
+import socket as socket_module
+import threading
+from datetime import datetime, timezone
+from typing import Any
+
+from letta.log import get_logger
+from letta.schemas.provider_trace import ProviderTrace
+from letta.schemas.user import User
+from letta.services.provider_trace_backends.base import ProviderTraceBackendClient
+
+logger = get_logger(__name__)
+
+# Protocol version for crouton communication.
+# Bump this when making breaking changes to the record schema.
+# Must match ProtocolVersion in apps/crouton/main.go.
+PROTOCOL_VERSION = 1
+
+
+class SocketProviderTraceBackend(ProviderTraceBackendClient):
+ """
+ Store provider traces via Unix socket.
+
+ Sends NDJSON telemetry records to a Unix socket. The receiving service
+ (sidecar) is responsible for storage (e.g., GCS, S3, local filesystem).
+
+ This is a write-only backend - reads are not supported.
+ """
+
+ def __init__(self, socket_path: str = "/var/run/telemetry/telemetry.sock"):
+ self.socket_path = socket_path
+
+ async def create_async(
+ self,
+ actor: User,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace | None:
+ self._send_to_crouton(provider_trace)
+
+ # Return a ProviderTrace with the same ID for consistency across backends
+ return ProviderTrace(
+ id=provider_trace.id,
+ step_id=provider_trace.step_id,
+ request_json=provider_trace.request_json or {},
+ response_json=provider_trace.response_json or {},
+ )
+
+ def create_sync(
+ self,
+ actor: User,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace | None:
+ self._send_to_crouton(provider_trace)
+ return None
+
+ async def get_by_step_id_async(
+ self,
+ step_id: str,
+ actor: User,
+ ) -> ProviderTrace | None:
+ # Socket backend is write-only - reads should go through the storage backend directly.
+ logger.warning("Socket backend does not support reads")
+ return None
+
+ def _send_to_crouton(self, provider_trace: ProviderTrace) -> None:
+ """Build telemetry record and send to Crouton sidecar (fire-and-forget)."""
+ response = provider_trace.response_json or {}
+ request = provider_trace.request_json or {}
+
+ # Extract error if present
+ error = response.get("error", {}).get("message") if isinstance(response.get("error"), dict) else None
+
+ record = {
+ "protocol_version": PROTOCOL_VERSION,
+ "provider_trace_id": provider_trace.id,
+ "agent_id": provider_trace.agent_id,
+ "run_id": provider_trace.run_id,
+ "step_id": provider_trace.step_id,
+ "tags": provider_trace.agent_tags or [],
+ "type": provider_trace.call_type or "agent_step",
+ "request": request,
+ "response": response if not error else None,
+ "error": error,
+ "timestamp": datetime.now(timezone.utc).isoformat(),
+ }
+
+ # Fire-and-forget in background thread
+ thread = threading.Thread(target=self._send_async, args=(record,), daemon=True)
+ thread.start()
+
+ def _send_async(self, record: dict[str, Any]) -> None:
+ """Send record to Unix socket (runs in background thread)."""
+ try:
+ if not os.path.exists(self.socket_path):
+ logger.warning(f"Crouton socket not found at {self.socket_path}")
+ return
+
+ with socket_module.socket(socket_module.AF_UNIX, socket_module.SOCK_STREAM) as sock:
+ sock.settimeout(5.0)
+ sock.connect(self.socket_path)
+ payload = json.dumps(record, default=str) + "\n"
+ sock.sendall(payload.encode())
+ except Exception as e:
+ logger.warning(f"Failed to send telemetry to Crouton: {e}")
diff --git a/letta/services/telemetry_manager.py b/letta/services/telemetry_manager.py
index cd1bb47de..0cfa20030 100644
--- a/letta/services/telemetry_manager.py
+++ b/letta/services/telemetry_manager.py
@@ -1,74 +1,117 @@
-from letta.helpers.json_helpers import json_dumps, json_loads
+import asyncio
+
from letta.helpers.singleton import singleton
-from letta.orm.provider_trace import ProviderTrace as ProviderTraceModel
+from letta.log import get_logger
from letta.otel.tracing import trace_method
-from letta.schemas.provider_trace import ProviderTrace as PydanticProviderTrace, ProviderTraceCreate
-from letta.schemas.step import Step as PydanticStep
+from letta.schemas.provider_trace import ProviderTrace
from letta.schemas.user import User as PydanticUser
-from letta.server.db import db_registry
-from letta.services.clickhouse_provider_traces import ClickhouseProviderTraceReader
-from letta.settings import settings
+from letta.services.provider_trace_backends import get_provider_trace_backend, get_provider_trace_backends
from letta.utils import enforce_types
+logger = get_logger(__name__)
+
class TelemetryManager:
+ """
+ Manages provider trace telemetry using configurable backends.
+
+ Supports multiple backends for dual-write scenarios (e.g., migration).
+ Configure via LETTA_TELEMETRY_PROVIDER_TRACE_BACKEND (comma-separated):
+ - postgres: Store in PostgreSQL (default)
+ - clickhouse: Store in ClickHouse via OTEL instrumentation
+ - socket: Store via Unix socket to Crouton sidecar (which writes to GCS)
+
+ Example: LETTA_TELEMETRY_PROVIDER_TRACE_BACKEND=postgres,socket
+
+ Multi-backend behavior:
+ - Writes: Sent to ALL configured backends concurrently via asyncio.gather.
+ Errors in one backend don't affect others (logged but not raised).
+ - Reads: Only from PRIMARY backend (first in the comma-separated list).
+ Secondary backends are write-only for this manager.
+ """
+
+ def __init__(self):
+ self._backends = get_provider_trace_backends()
+ self._primary_backend = self._backends[0] if self._backends else get_provider_trace_backend()
+
@enforce_types
@trace_method
async def get_provider_trace_by_step_id_async(
self,
step_id: str,
actor: PydanticUser,
- ) -> PydanticProviderTrace | None:
- # When ClickHouse is enabled, read only from ClickHouse (no Postgres fallback)
- if settings.use_clickhouse_for_provider_traces:
- return await ClickhouseProviderTraceReader().get_provider_trace_by_step_id_async(
- step_id=step_id,
- organization_id=actor.organization_id,
- )
-
- # Postgres storage backend
- async with db_registry.async_session() as session:
- provider_trace = await ProviderTraceModel.read_async(db_session=session, step_id=step_id, actor=actor)
- return provider_trace.to_pydantic()
+ ) -> ProviderTrace | None:
+ # Read from primary backend only
+ return await self._primary_backend.get_by_step_id_async(step_id=step_id, actor=actor)
@enforce_types
@trace_method
- async def create_provider_trace_async(self, actor: PydanticUser, provider_trace_create: ProviderTraceCreate) -> PydanticProviderTrace:
- # When ClickHouse is enabled, skip Postgres writes - data flows via OTEL instrumentation
- if settings.use_clickhouse_for_provider_traces:
- return PydanticProviderTrace(
- id=f"provider_trace-{provider_trace_create.step_id}",
- step_id=provider_trace_create.step_id,
- request_json=provider_trace_create.request_json or {},
- response_json=provider_trace_create.response_json or {},
- )
-
- async with db_registry.async_session() as session:
- provider_trace = ProviderTraceModel(**provider_trace_create.model_dump())
- provider_trace.organization_id = actor.organization_id
- if provider_trace_create.request_json:
- request_json_str = json_dumps(provider_trace_create.request_json)
- provider_trace.request_json = json_loads(request_json_str)
-
- if provider_trace_create.response_json:
- response_json_str = json_dumps(provider_trace_create.response_json)
- provider_trace.response_json = json_loads(response_json_str)
- await provider_trace.create_async(session, actor=actor, no_commit=True, no_refresh=True)
- pydantic_provider_trace = provider_trace.to_pydantic()
- return pydantic_provider_trace
+ async def create_provider_trace_async(
+ self,
+ actor: PydanticUser,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace:
+ # Write to all backends concurrently
+ tasks = [self._safe_create_async(backend, actor, provider_trace) for backend in self._backends]
+ results = await asyncio.gather(*tasks)
+
+ # Return first non-None result (from primary backend)
+ return next((r for r in results if r is not None), None)
+
+ async def _safe_create_async(
+ self,
+ backend,
+ actor: PydanticUser,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace | None:
+ """Create trace in a backend, catching and logging errors."""
+ try:
+ return await backend.create_async(actor=actor, provider_trace=provider_trace)
+ except Exception as e:
+ logger.warning(f"Failed to write to {backend.__class__.__name__}: {e}")
+ return None
+
+ def create_provider_trace(
+ self,
+ actor: PydanticUser,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace | None:
+ """Synchronous version - writes to all backends."""
+ result = None
+ for backend in self._backends:
+ try:
+ r = backend.create_sync(actor=actor, provider_trace=provider_trace)
+ if result is None:
+ result = r
+ except Exception as e:
+ logger.warning(f"Failed to write to {backend.__class__.__name__}: {e}")
+ return result
@singleton
class NoopTelemetryManager(TelemetryManager):
- """
- Noop implementation of TelemetryManager.
- """
+ """Noop implementation of TelemetryManager."""
+
+ def __init__(self):
+ pass # Don't initialize backend
- async def create_provider_trace_async(self, actor: PydanticUser, provider_trace_create: ProviderTraceCreate) -> PydanticProviderTrace:
- return
+ async def create_provider_trace_async(
+ self,
+ actor: PydanticUser,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace:
+ return None
- async def get_provider_trace_by_step_id_async(self, step_id: str, actor: PydanticUser) -> PydanticStep:
- return
+ async def get_provider_trace_by_step_id_async(
+ self,
+ step_id: str,
+ actor: PydanticUser,
+ ) -> ProviderTrace | None:
+ return None
- def create_provider_trace(self, actor: PydanticUser, provider_trace_create: ProviderTraceCreate) -> PydanticProviderTrace:
- return
+ def create_provider_trace(
+ self,
+ actor: PydanticUser,
+ provider_trace: ProviderTrace,
+ ) -> ProviderTrace:
+ return None
diff --git a/letta/settings.py b/letta/settings.py
index b7d3d65f8..a4d084cab 100644
--- a/letta/settings.py
+++ b/letta/settings.py
@@ -282,6 +282,28 @@ class Settings(BaseSettings):
# telemetry logging
otel_exporter_otlp_endpoint: str | None = None # otel default: "http://localhost:4317"
+
+ # clickhouse (for OTEL traces reader)
+ clickhouse_endpoint: str | None = Field(
+ default=None,
+ validation_alias=AliasChoices("CLICKHOUSE_ENDPOINT", "letta_clickhouse_endpoint"),
+ description="ClickHouse endpoint URL",
+ )
+ clickhouse_database: str | None = Field(
+ default="otel",
+ validation_alias=AliasChoices("CLICKHOUSE_DATABASE", "letta_clickhouse_database"),
+ description="ClickHouse database name",
+ )
+ clickhouse_username: str | None = Field(
+ default="default",
+ validation_alias=AliasChoices("CLICKHOUSE_USERNAME", "letta_clickhouse_username"),
+ description="ClickHouse username",
+ )
+ clickhouse_password: str | None = Field(
+ default=None,
+ validation_alias=AliasChoices("CLICKHOUSE_PASSWORD", "letta_clickhouse_password"),
+ description="ClickHouse password",
+ )
otel_preferred_temporality: int | None = Field(
default=1, ge=0, le=2, description="Exported metric temporality. {0: UNSPECIFIED, 1: DELTA, 2: CUMULATIVE}"
)
@@ -292,7 +314,6 @@ class Settings(BaseSettings):
track_stop_reason: bool = Field(default=True, description="Enable tracking stop reason on steps.")
track_agent_run: bool = Field(default=True, description="Enable tracking agent run with cancellation support")
track_provider_trace: bool = Field(default=True, description="Enable tracking raw llm request and response at each step")
- use_clickhouse_for_provider_traces: bool = Field(default=False, description="Use ClickHouse backend for provider traces instead of Postgres")
# FastAPI Application Settings
uvicorn_workers: int = 1
@@ -402,6 +423,15 @@ class Settings(BaseSettings):
plugins[name] = {"target": target}
return plugins
+ @property
+ def use_clickhouse_for_provider_traces(self) -> bool:
+ """Check if ClickHouse backend is configured for provider traces."""
+ # Access global telemetry_settings (defined at module level after this class)
+ import sys
+
+ module = sys.modules[__name__]
+ return "clickhouse" in getattr(module, "telemetry_settings").provider_trace_backends
+
class TestSettings(Settings):
model_config = SettingsConfigDict(env_prefix="letta_test_", extra="ignore")
@@ -459,6 +489,27 @@ class TelemetrySettings(BaseSettings):
description="Primary Python package name for source code linking. Datadog uses this setting to determine which code is 'yours' vs. third-party dependencies.",
)
+ # Provider trace backend selection (comma-separated for multi-backend support)
+ provider_trace_backend: str = Field(
+ default="postgres",
+ description="Provider trace storage backends (comma-separated): 'postgres', 'clickhouse', 'socket'. Example: 'postgres,socket' for dual-write.",
+ )
+ socket_path: str = Field(
+ default="/var/run/telemetry/telemetry.sock",
+ validation_alias=AliasChoices("TELEMETRY_SOCKET", "socket_path"),
+ description="Unix socket path for socket backend.",
+ )
+
+ @property
+ def provider_trace_backends(self) -> list[str]:
+ """Parse comma-separated backend list."""
+ return [b.strip() for b in self.provider_trace_backend.split(",") if b.strip()]
+
+ @property
+ def socket_backend_enabled(self) -> bool:
+ """Check if socket backend is enabled."""
+ return "socket" in self.provider_trace_backends
+
# singleton
settings = Settings(_env_parse_none_str="None")
diff --git a/pyproject.toml b/pyproject.toml
index b2d5d61f0..f8f81beb5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -74,6 +74,7 @@ dependencies = [
"psutil>=5.9.0",
"fastmcp>=2.12.5",
"ddtrace>=4.2.1",
+ "clickhouse-connect>=0.10.0",
]
[project.scripts]
diff --git a/tests/test_provider_trace_backends.py b/tests/test_provider_trace_backends.py
new file mode 100644
index 000000000..a088d3689
--- /dev/null
+++ b/tests/test_provider_trace_backends.py
@@ -0,0 +1,332 @@
+"""Unit tests for provider trace backends."""
+
+import asyncio
+import json
+import os
+import socket
+import tempfile
+import threading
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from letta.schemas.provider_trace import ProviderTrace
+from letta.schemas.user import User
+from letta.services.provider_trace_backends.base import ProviderTraceBackend, ProviderTraceBackendClient
+from letta.services.provider_trace_backends.socket import SocketProviderTraceBackend
+
+
+def mock_actor():
+ """Create a mock user/actor."""
+ return User(
+ id="user-00000000-0000-4000-8000-000000000000",
+ organization_id="org-00000000-0000-4000-8000-000000000000",
+ name="test_user",
+ )
+
+
+def sample_provider_trace():
+ """Create a sample ProviderTrace."""
+ return ProviderTrace(
+ request_json={
+ "model": "gpt-4o-mini",
+ "messages": [{"role": "user", "content": "Hello"}],
+ },
+ response_json={
+ "id": "chatcmpl-xyz",
+ "model": "gpt-4o-mini",
+ "choices": [{"message": {"content": "Hi!"}}],
+ "usage": {"prompt_tokens": 10, "completion_tokens": 5},
+ },
+ step_id="step-test-789",
+ run_id="run-test-abc",
+ )
+
+
+class TestProviderTraceBackendEnum:
+ """Tests for ProviderTraceBackend enum."""
+
+ def test_enum_values(self):
+ assert ProviderTraceBackend.POSTGRES.value == "postgres"
+ assert ProviderTraceBackend.CLICKHOUSE.value == "clickhouse"
+ assert ProviderTraceBackend.SOCKET.value == "socket"
+
+ def test_enum_string_comparison(self):
+ assert ProviderTraceBackend.POSTGRES == "postgres"
+ assert ProviderTraceBackend.SOCKET == "socket"
+
+
+class TestProviderTrace:
+ """Tests for ProviderTrace schema."""
+
+ def test_id_generation(self):
+ """Test that ID is auto-generated with correct prefix."""
+ trace = ProviderTrace(
+ request_json={"model": "test"},
+ response_json={"id": "test"},
+ step_id="step-123",
+ )
+ assert trace.id.startswith("provider_trace-")
+
+ def test_id_uniqueness(self):
+ """Test that each instance gets a unique ID."""
+ trace1 = ProviderTrace(request_json={}, response_json={}, step_id="step-1")
+ trace2 = ProviderTrace(request_json={}, response_json={}, step_id="step-2")
+ assert trace1.id != trace2.id
+
+ def test_optional_fields(self):
+ """Test optional telemetry fields."""
+ trace = ProviderTrace(
+ request_json={},
+ response_json={},
+ step_id="step-123",
+ agent_id="agent-456",
+ agent_tags=["env:dev", "team:ml"],
+ call_type="summarization",
+ run_id="run-789",
+ )
+ assert trace.agent_id == "agent-456"
+ assert trace.agent_tags == ["env:dev", "team:ml"]
+ assert trace.call_type == "summarization"
+ assert trace.run_id == "run-789"
+
+
+class TestSocketProviderTraceBackend:
+ """Tests for SocketProviderTraceBackend."""
+
+ def test_init_default_path(self):
+ """Test default socket path."""
+ backend = SocketProviderTraceBackend()
+ assert backend.socket_path == "/var/run/telemetry/telemetry.sock"
+
+ def test_init_custom_path(self):
+ """Test custom socket path."""
+ backend = SocketProviderTraceBackend(socket_path="/tmp/custom.sock")
+ assert backend.socket_path == "/tmp/custom.sock"
+
+ @pytest.mark.asyncio
+ async def test_create_async_returns_provider_trace(self, mock_actor, sample_provider_trace):
+ """Test that create_async returns a ProviderTrace."""
+ backend = SocketProviderTraceBackend(socket_path="/nonexistent/path.sock")
+
+ result = await backend.create_async(
+ actor=mock_actor,
+ provider_trace=sample_provider_trace,
+ )
+
+ assert isinstance(result, ProviderTrace)
+ assert result.id == sample_provider_trace.id
+ assert result.step_id == sample_provider_trace.step_id
+
+ @pytest.mark.asyncio
+ async def test_get_by_step_id_returns_none(self, mock_actor):
+ """Test that read operations return None (write-only backend)."""
+ backend = SocketProviderTraceBackend()
+
+ result = await backend.get_by_step_id_async(
+ step_id="step-123",
+ actor=mock_actor,
+ )
+
+ assert result is None
+
+ def test_send_to_socket_with_real_socket(self, sample_provider_trace):
+ """Test sending data to a real Unix socket."""
+ received_data = []
+
+ with tempfile.TemporaryDirectory() as tmpdir:
+ socket_path = os.path.join(tmpdir, "test.sock")
+
+ # Create a simple socket server
+ server_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ server_sock.bind(socket_path)
+ server_sock.listen(1)
+ server_sock.settimeout(5.0)
+
+ def accept_connection():
+ try:
+ conn, _ = server_sock.accept()
+ data = conn.recv(65536)
+ received_data.append(data.decode())
+ conn.close()
+ except socket.timeout:
+ pass # Expected - test socket has short timeout, data may not arrive
+ finally:
+ server_sock.close()
+
+ # Start server in background
+ server_thread = threading.Thread(target=accept_connection)
+ server_thread.start()
+
+ # Send data via backend
+ backend = SocketProviderTraceBackend(socket_path=socket_path)
+ backend._send_to_crouton(sample_provider_trace)
+
+ # Wait for send to complete
+ server_thread.join(timeout=5.0)
+
+ # Verify data was received
+ assert len(received_data) == 1
+ record = json.loads(received_data[0].strip())
+ assert record["provider_trace_id"] == sample_provider_trace.id
+ assert record["model"] == "gpt-4o-mini"
+ assert record["provider"] == "openai"
+ assert record["input_tokens"] == 10
+ assert record["output_tokens"] == 5
+ assert record["context"]["step_id"] == "step-test-789"
+ assert record["context"]["run_id"] == "run-test-abc"
+
+ def test_send_to_nonexistent_socket_does_not_raise(self, sample_provider_trace):
+ """Test that sending to nonexistent socket fails silently."""
+ backend = SocketProviderTraceBackend(socket_path="/nonexistent/path.sock")
+
+ # Should not raise
+ backend._send_to_crouton(sample_provider_trace)
+
+ def test_record_extracts_usage_from_openai_response(self):
+ """Test usage extraction from OpenAI-style response."""
+ trace = ProviderTrace(
+ request_json={"model": "gpt-4"},
+ response_json={
+ "usage": {
+ "prompt_tokens": 100,
+ "completion_tokens": 50,
+ }
+ },
+ step_id="step-123",
+ )
+
+ backend = SocketProviderTraceBackend(socket_path="/fake/path")
+
+ # Access internal method to build record
+ with patch.object(backend, "_send_async"):
+ backend._send_to_crouton(trace)
+
+ def test_record_extracts_usage_from_anthropic_response(self):
+ """Test usage extraction from Anthropic-style response."""
+ trace = ProviderTrace(
+ request_json={"model": "claude-3"},
+ response_json={
+ "usage": {
+ "input_tokens": 100,
+ "output_tokens": 50,
+ }
+ },
+ step_id="step-123",
+ )
+
+ backend = SocketProviderTraceBackend(socket_path="/fake/path")
+
+ with patch.object(backend, "_send_async"):
+ backend._send_to_crouton(trace)
+
+ def test_record_extracts_error_from_response(self):
+ """Test error extraction from response."""
+ trace = ProviderTrace(
+ request_json={"model": "gpt-4"},
+ response_json={
+ "error": {"message": "Rate limit exceeded"},
+ },
+ step_id="step-123",
+ )
+
+ backend = SocketProviderTraceBackend(socket_path="/fake/path")
+
+ # Capture the record sent to _send_async
+ captured_records = []
+
+ def capture_record(record):
+ captured_records.append(record)
+
+ with patch.object(backend, "_send_async", side_effect=capture_record):
+ backend._send_to_crouton(trace)
+
+ assert len(captured_records) == 1
+ assert captured_records[0]["error"] == "Rate limit exceeded"
+ assert captured_records[0]["response"] is None
+
+
+class TestBackendFactory:
+ """Tests for backend factory."""
+
+ def test_get_postgres_backend(self):
+ """Test getting postgres backend."""
+ from letta.services.provider_trace_backends.factory import _create_backend
+
+ backend = _create_backend("postgres")
+ assert backend.__class__.__name__ == "PostgresProviderTraceBackend"
+
+ def test_get_socket_backend(self):
+ """Test getting socket backend."""
+ with patch("letta.settings.telemetry_settings") as mock_settings:
+ mock_settings.socket_path = "/tmp/test.sock"
+
+ from letta.services.provider_trace_backends.factory import _create_backend
+
+ backend = _create_backend("socket")
+ assert backend.__class__.__name__ == "SocketProviderTraceBackend"
+
+ def test_get_multiple_backends(self):
+ """Test getting multiple backends via environment."""
+ import os
+
+ from letta.services.provider_trace_backends.factory import (
+ get_provider_trace_backends,
+ )
+
+ # Clear cache first
+ get_provider_trace_backends.cache_clear()
+
+ # This test just verifies the factory works - actual backend list
+ # depends on env var LETTA_TELEMETRY_PROVIDER_TRACE_BACKEND
+ backends = get_provider_trace_backends()
+ assert len(backends) >= 1
+ assert all(hasattr(b, "create_async") and hasattr(b, "get_by_step_id_async") for b in backends)
+
+ def test_unknown_backend_defaults_to_postgres(self):
+ """Test that unknown backend type defaults to postgres."""
+ from letta.services.provider_trace_backends.factory import _create_backend
+
+ backend = _create_backend("unknown_backend")
+ assert backend.__class__.__name__ == "PostgresProviderTraceBackend"
+
+
+class TestTelemetrySettings:
+ """Tests for telemetry settings."""
+
+ def test_provider_trace_backends_parsing(self):
+ """Test parsing comma-separated backend list."""
+ from letta.settings import TelemetrySettings
+
+ # Create a fresh settings object and set the value directly
+ settings = TelemetrySettings(provider_trace_backend="postgres,socket")
+ backends = settings.provider_trace_backends
+ assert backends == ["postgres", "socket"]
+
+ def test_provider_trace_backends_single(self):
+ """Test single backend."""
+ from letta.settings import TelemetrySettings
+
+ settings = TelemetrySettings(provider_trace_backend="postgres")
+ backends = settings.provider_trace_backends
+ assert backends == ["postgres"]
+
+ def test_provider_trace_backends_with_whitespace(self):
+ """Test backend list with whitespace."""
+ from letta.settings import TelemetrySettings
+
+ settings = TelemetrySettings(provider_trace_backend="postgres , socket , clickhouse")
+ backends = settings.provider_trace_backends
+ assert backends == ["postgres", "socket", "clickhouse"]
+
+ def test_socket_backend_enabled(self):
+ """Test socket_backend_enabled property."""
+ from letta.settings import TelemetrySettings
+
+ settings1 = TelemetrySettings(provider_trace_backend="postgres")
+ assert settings1.socket_backend_enabled is False
+
+ settings2 = TelemetrySettings(provider_trace_backend="postgres,socket")
+ assert settings2.socket_backend_enabled is True
diff --git a/uv.lock b/uv.lock
index be19c178a..22b7d46b0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -679,6 +679,45 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" },
]
+[[package]]
+name = "clickhouse-connect"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "lz4" },
+ { name = "pytz" },
+ { name = "urllib3" },
+ { name = "zstandard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7b/fd/f8bea1157d40f117248dcaa9abdbf68c729513fcf2098ab5cb4aa58768b8/clickhouse_connect-0.10.0.tar.gz", hash = "sha256:a0256328802c6e5580513e197cef7f9ba49a99fc98e9ba410922873427569564", size = 104753, upload-time = "2025-11-14T20:31:00.947Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/bf/4e/f90caf963d14865c7a3f0e5d80b77e67e0fe0bf39b3de84110707746fa6b/clickhouse_connect-0.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:195f1824405501b747b572e1365c6265bb1629eeb712ce91eda91da3c5794879", size = 272911, upload-time = "2025-11-14T20:29:57.129Z" },
+ { url = "https://files.pythonhosted.org/packages/50/c7/e01bd2dd80ea4fbda8968e5022c60091a872fd9de0a123239e23851da231/clickhouse_connect-0.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7907624635fe7f28e1b85c7c8b125a72679a63ecdb0b9f4250b704106ef438f8", size = 265938, upload-time = "2025-11-14T20:29:58.443Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/07/8b567b949abca296e118331d13380bbdefa4225d7d1d32233c59d4b4b2e1/clickhouse_connect-0.10.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60772faa54d56f0fa34650460910752a583f5948f44dddeabfafaecbca21fc54", size = 1113548, upload-time = "2025-11-14T20:29:59.781Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/13/11f2d37fc95e74d7e2d80702cde87666ce372486858599a61f5209e35fc5/clickhouse_connect-0.10.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7fe2a6cd98517330c66afe703fb242c0d3aa2c91f2f7dc9fb97c122c5c60c34b", size = 1135061, upload-time = "2025-11-14T20:30:01.244Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/d0/517181ea80060f84d84cff4d42d330c80c77bb352b728fb1f9681fbad291/clickhouse_connect-0.10.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a2427d312bc3526520a0be8c648479af3f6353da7a33a62db2368d6203b08efd", size = 1105105, upload-time = "2025-11-14T20:30:02.679Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/b2/4ad93e898562725b58c537cad83ab2694c9b1c1ef37fa6c3f674bdad366a/clickhouse_connect-0.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:63bbb5721bfece698e155c01b8fa95ce4377c584f4d04b43f383824e8a8fa129", size = 1150791, upload-time = "2025-11-14T20:30:03.824Z" },
+ { url = "https://files.pythonhosted.org/packages/45/a4/fdfbfacc1fa67b8b1ce980adcf42f9e3202325586822840f04f068aff395/clickhouse_connect-0.10.0-cp311-cp311-win32.whl", hash = "sha256:48554e836c6b56fe0854d9a9f565569010583d4960094d60b68a53f9f83042f0", size = 244014, upload-time = "2025-11-14T20:30:05.157Z" },
+ { url = "https://files.pythonhosted.org/packages/08/50/cf53f33f4546a9ce2ab1b9930db4850aa1ae53bff1e4e4fa97c566cdfa19/clickhouse_connect-0.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:9eb8df083e5fda78ac7249938691c2c369e8578b5df34c709467147e8289f1d9", size = 262356, upload-time = "2025-11-14T20:30:06.478Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/59/fadbbf64f4c6496cd003a0a3c9223772409a86d0eea9d4ff45d2aa88aabf/clickhouse_connect-0.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b090c7d8e602dd084b2795265cd30610461752284763d9ad93a5d619a0e0ff21", size = 276401, upload-time = "2025-11-14T20:30:07.469Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/e3/781f9970f2ef202410f0d64681e42b2aecd0010097481a91e4df186a36c7/clickhouse_connect-0.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b8a708d38b81dcc8c13bb85549c904817e304d2b7f461246fed2945524b7a31b", size = 268193, upload-time = "2025-11-14T20:30:08.503Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/e0/64ab66b38fce762b77b5203a4fcecc603595f2a2361ce1605fc7bb79c835/clickhouse_connect-0.10.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3646fc9184a5469b95cf4a0846e6954e6e9e85666f030a5d2acae58fa8afb37e", size = 1123810, upload-time = "2025-11-14T20:30:09.62Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/03/19121aecf11a30feaf19049be96988131798c54ac6ba646a38e5faecaa0a/clickhouse_connect-0.10.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fe7e6be0f40a8a77a90482944f5cc2aa39084c1570899e8d2d1191f62460365b", size = 1153409, upload-time = "2025-11-14T20:30:10.855Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/ee/63870fd8b666c6030393950ad4ee76b7b69430f5a49a5d3fa32a70b11942/clickhouse_connect-0.10.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:88b4890f13163e163bf6fa61f3a013bb974c95676853b7a4e63061faf33911ac", size = 1104696, upload-time = "2025-11-14T20:30:12.187Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/bc/fcd8da1c4d007ebce088783979c495e3d7360867cfa8c91327ed235778f5/clickhouse_connect-0.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6286832cc79affc6fddfbf5563075effa65f80e7cd1481cf2b771ce317c67d08", size = 1156389, upload-time = "2025-11-14T20:30:13.385Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/33/7cb99cc3fc503c23fd3a365ec862eb79cd81c8dc3037242782d709280fa9/clickhouse_connect-0.10.0-cp312-cp312-win32.whl", hash = "sha256:92b8b6691a92d2613ee35f5759317bd4be7ba66d39bf81c4deed620feb388ca6", size = 243682, upload-time = "2025-11-14T20:30:14.52Z" },
+ { url = "https://files.pythonhosted.org/packages/48/5c/12eee6a1f5ecda2dfc421781fde653c6d6ca6f3080f24547c0af40485a5a/clickhouse_connect-0.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:1159ee2c33e7eca40b53dda917a8b6a2ed889cb4c54f3d83b303b31ddb4f351d", size = 262790, upload-time = "2025-11-14T20:30:15.555Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/4a/197abf4d74c914cd11aff644c954f754562546a35015de466592a778f388/clickhouse_connect-0.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f927722c5e054cf833a4112cf82d633e37d3b329f01e232754cc2678be268020", size = 273670, upload-time = "2025-11-14T20:30:16.883Z" },
+ { url = "https://files.pythonhosted.org/packages/33/ec/5503e235b9588d178ad7777f0a6c61ede9cdfa1dfae1be08beaf18fe336b/clickhouse_connect-0.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ef58f431e2ef3c2a91a6d5535484186f2f57f50eff791410548b17017563784b", size = 265346, upload-time = "2025-11-14T20:30:18.154Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/83/5bc991215540b9c12c95452783b6b59e074d71391324d2a934c2e25a8afe/clickhouse_connect-0.10.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40b7cf86d016ae6c6c3af6a7b5786f41c18632bfbc9e58d0c4a21a4c5d50c674", size = 1104945, upload-time = "2025-11-14T20:30:19.35Z" },
+ { url = "https://files.pythonhosted.org/packages/67/74/93442c805f4ed7ad831ef412c7b94c3df492494fa49f30fa77ed8fd8673a/clickhouse_connect-0.10.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51193dc39f4169b0dd6da13003bbea60527dea92eb2408aecae7f1fb4ad2c5a4", size = 1137413, upload-time = "2025-11-14T20:30:20.932Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/9c/c885d6a726e35e489d874da8a592f0b6b0ac4d5f132e1126466c3143f263/clickhouse_connect-0.10.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b3e393dd95bcce02307f558f6aee53bf2a1bfc83f13030c9b4e47b2045de293f", size = 1086490, upload-time = "2025-11-14T20:30:22.195Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/a5/0980c9cb8ad13174840abcf31a085f3e5bb4026efb9271e4c757c40110ab/clickhouse_connect-0.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bd6e1870df82dd57a47bc2a2a6f39c57da8aee43cc291a44d04babfdec5986dc", size = 1140722, upload-time = "2025-11-14T20:30:23.446Z" },
+ { url = "https://files.pythonhosted.org/packages/12/6f/716e12a0e9a174dc3e422846a4e2f0ee73bcfc1f47b93bb02cf3d155bf0b/clickhouse_connect-0.10.0-cp313-cp313-win32.whl", hash = "sha256:d69b3f55a3a2f5414db7bed45afcca940e78ce1867cf5cc0c202f7be21cf48e9", size = 242997, upload-time = "2025-11-14T20:30:24.626Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/70/d0148812bec753767be39d528cffa48e7510718fb75fd2cf2b4dfdb24f37/clickhouse_connect-0.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:5fa4f3763d46b90dc28b1f38eba8de83fbf6c9928f071dd66074e7d6de80e21b", size = 261840, upload-time = "2025-11-14T20:30:25.686Z" },
+]
+
[[package]]
name = "cobble"
version = "0.1.4"
@@ -2481,6 +2520,7 @@ dependencies = [
{ name = "black", extra = ["jupyter"] },
{ name = "brotli" },
{ name = "certifi" },
+ { name = "clickhouse-connect" },
{ name = "colorama" },
{ name = "datadog" },
{ name = "datamodel-code-generator", extra = ["http"] },
@@ -2633,6 +2673,7 @@ requires-dist = [
{ name = "boto3", marker = "extra == 'bedrock'", specifier = ">=1.36.24" },
{ name = "brotli", specifier = ">=1.1.0" },
{ name = "certifi", specifier = ">=2025.6.15" },
+ { name = "clickhouse-connect", specifier = ">=0.10.0" },
{ name = "colorama", specifier = ">=0.4.6" },
{ name = "datadog", specifier = ">=0.49.1" },
{ name = "datamodel-code-generator", extras = ["http"], specifier = ">=0.25.0" },
@@ -3084,6 +3125,46 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/4e/0b/942cb7278d6caad79343ad2ddd636ed204a47909b969d19114a3097f5aa3/lxml_html_clean-0.4.2-py3-none-any.whl", hash = "sha256:74ccfba277adcfea87a1e9294f47dd86b05d65b4da7c5b07966e3d5f3be8a505", size = 14184, upload-time = "2025-04-09T11:33:57.988Z" },
]
+[[package]]
+name = "lz4"
+version = "4.4.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/51/f1b86d93029f418033dddf9b9f79c8d2641e7454080478ee2aab5123173e/lz4-4.4.5.tar.gz", hash = "sha256:5f0b9e53c1e82e88c10d7c180069363980136b9d7a8306c4dca4f760d60c39f0", size = 172886, upload-time = "2025-11-03T13:02:36.061Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/93/5b/6edcd23319d9e28b1bedf32768c3d1fd56eed8223960a2c47dacd2cec2af/lz4-4.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d6da84a26b3aa5da13a62e4b89ab36a396e9327de8cd48b436a3467077f8ccd4", size = 207391, upload-time = "2025-11-03T13:01:36.644Z" },
+ { url = "https://files.pythonhosted.org/packages/34/36/5f9b772e85b3d5769367a79973b8030afad0d6b724444083bad09becd66f/lz4-4.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:61d0ee03e6c616f4a8b69987d03d514e8896c8b1b7cc7598ad029e5c6aedfd43", size = 207146, upload-time = "2025-11-03T13:01:37.928Z" },
+ { url = "https://files.pythonhosted.org/packages/04/f4/f66da5647c0d72592081a37c8775feacc3d14d2625bbdaabd6307c274565/lz4-4.4.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:33dd86cea8375d8e5dd001e41f321d0a4b1eb7985f39be1b6a4f466cd480b8a7", size = 1292623, upload-time = "2025-11-03T13:01:39.341Z" },
+ { url = "https://files.pythonhosted.org/packages/85/fc/5df0f17467cdda0cad464a9197a447027879197761b55faad7ca29c29a04/lz4-4.4.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:609a69c68e7cfcfa9d894dc06be13f2e00761485b62df4e2472f1b66f7b405fb", size = 1279982, upload-time = "2025-11-03T13:01:40.816Z" },
+ { url = "https://files.pythonhosted.org/packages/25/3b/b55cb577aa148ed4e383e9700c36f70b651cd434e1c07568f0a86c9d5fbb/lz4-4.4.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:75419bb1a559af00250b8f1360d508444e80ed4b26d9d40ec5b09fe7875cb989", size = 1368674, upload-time = "2025-11-03T13:01:42.118Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/31/e97e8c74c59ea479598e5c55cbe0b1334f03ee74ca97726e872944ed42df/lz4-4.4.5-cp311-cp311-win32.whl", hash = "sha256:12233624f1bc2cebc414f9efb3113a03e89acce3ab6f72035577bc61b270d24d", size = 88168, upload-time = "2025-11-03T13:01:43.282Z" },
+ { url = "https://files.pythonhosted.org/packages/18/47/715865a6c7071f417bef9b57c8644f29cb7a55b77742bd5d93a609274e7e/lz4-4.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:8a842ead8ca7c0ee2f396ca5d878c4c40439a527ebad2b996b0444f0074ed004", size = 99491, upload-time = "2025-11-03T13:01:44.167Z" },
+ { url = "https://files.pythonhosted.org/packages/14/e7/ac120c2ca8caec5c945e6356ada2aa5cfabd83a01e3170f264a5c42c8231/lz4-4.4.5-cp311-cp311-win_arm64.whl", hash = "sha256:83bc23ef65b6ae44f3287c38cbf82c269e2e96a26e560aa551735883388dcc4b", size = 91271, upload-time = "2025-11-03T13:01:45.016Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/ac/016e4f6de37d806f7cc8f13add0a46c9a7cfc41a5ddc2bc831d7954cf1ce/lz4-4.4.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:df5aa4cead2044bab83e0ebae56e0944cc7fcc1505c7787e9e1057d6d549897e", size = 207163, upload-time = "2025-11-03T13:01:45.895Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/df/0fadac6e5bd31b6f34a1a8dbd4db6a7606e70715387c27368586455b7fc9/lz4-4.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6d0bf51e7745484d2092b3a51ae6eb58c3bd3ce0300cf2b2c14f76c536d5697a", size = 207150, upload-time = "2025-11-03T13:01:47.205Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/17/34e36cc49bb16ca73fb57fbd4c5eaa61760c6b64bce91fcb4e0f4a97f852/lz4-4.4.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7b62f94b523c251cf32aa4ab555f14d39bd1a9df385b72443fd76d7c7fb051f5", size = 1292045, upload-time = "2025-11-03T13:01:48.667Z" },
+ { url = "https://files.pythonhosted.org/packages/90/1c/b1d8e3741e9fc89ed3b5f7ef5f22586c07ed6bb04e8343c2e98f0fa7ff04/lz4-4.4.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c3ea562c3af274264444819ae9b14dbbf1ab070aff214a05e97db6896c7597e", size = 1279546, upload-time = "2025-11-03T13:01:50.159Z" },
+ { url = "https://files.pythonhosted.org/packages/55/d9/e3867222474f6c1b76e89f3bd914595af69f55bf2c1866e984c548afdc15/lz4-4.4.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24092635f47538b392c4eaeff14c7270d2c8e806bf4be2a6446a378591c5e69e", size = 1368249, upload-time = "2025-11-03T13:01:51.273Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/e7/d667d337367686311c38b580d1ca3d5a23a6617e129f26becd4f5dc458df/lz4-4.4.5-cp312-cp312-win32.whl", hash = "sha256:214e37cfe270948ea7eb777229e211c601a3e0875541c1035ab408fbceaddf50", size = 88189, upload-time = "2025-11-03T13:01:52.605Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/0b/a54cd7406995ab097fceb907c7eb13a6ddd49e0b231e448f1a81a50af65c/lz4-4.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:713a777de88a73425cf08eb11f742cd2c98628e79a8673d6a52e3c5f0c116f33", size = 99497, upload-time = "2025-11-03T13:01:53.477Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/7e/dc28a952e4bfa32ca16fa2eb026e7a6ce5d1411fcd5986cd08c74ec187b9/lz4-4.4.5-cp312-cp312-win_arm64.whl", hash = "sha256:a88cbb729cc333334ccfb52f070463c21560fca63afcf636a9f160a55fac3301", size = 91279, upload-time = "2025-11-03T13:01:54.419Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/46/08fd8ef19b782f301d56a9ccfd7dafec5fd4fc1a9f017cf22a1accb585d7/lz4-4.4.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6bb05416444fafea170b07181bc70640975ecc2a8c92b3b658c554119519716c", size = 207171, upload-time = "2025-11-03T13:01:56.595Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/3f/ea3334e59de30871d773963997ecdba96c4584c5f8007fd83cfc8f1ee935/lz4-4.4.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b424df1076e40d4e884cfcc4c77d815368b7fb9ebcd7e634f937725cd9a8a72a", size = 207163, upload-time = "2025-11-03T13:01:57.721Z" },
+ { url = "https://files.pythonhosted.org/packages/41/7b/7b3a2a0feb998969f4793c650bb16eff5b06e80d1f7bff867feb332f2af2/lz4-4.4.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:216ca0c6c90719731c64f41cfbd6f27a736d7e50a10b70fad2a9c9b262ec923d", size = 1292136, upload-time = "2025-11-03T13:02:00.375Z" },
+ { url = "https://files.pythonhosted.org/packages/89/d1/f1d259352227bb1c185288dd694121ea303e43404aa77560b879c90e7073/lz4-4.4.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:533298d208b58b651662dd972f52d807d48915176e5b032fb4f8c3b6f5fe535c", size = 1279639, upload-time = "2025-11-03T13:02:01.649Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/fb/ba9256c48266a09012ed1d9b0253b9aa4fe9cdff094f8febf5b26a4aa2a2/lz4-4.4.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:451039b609b9a88a934800b5fc6ee401c89ad9c175abf2f4d9f8b2e4ef1afc64", size = 1368257, upload-time = "2025-11-03T13:02:03.35Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/6d/dee32a9430c8b0e01bbb4537573cabd00555827f1a0a42d4e24ca803935c/lz4-4.4.5-cp313-cp313-win32.whl", hash = "sha256:a5f197ffa6fc0e93207b0af71b302e0a2f6f29982e5de0fbda61606dd3a55832", size = 88191, upload-time = "2025-11-03T13:02:04.406Z" },
+ { url = "https://files.pythonhosted.org/packages/18/e0/f06028aea741bbecb2a7e9648f4643235279a770c7ffaf70bd4860c73661/lz4-4.4.5-cp313-cp313-win_amd64.whl", hash = "sha256:da68497f78953017deb20edff0dba95641cc86e7423dfadf7c0264e1ac60dc22", size = 99502, upload-time = "2025-11-03T13:02:05.886Z" },
+ { url = "https://files.pythonhosted.org/packages/61/72/5bef44afb303e56078676b9f2486f13173a3c1e7f17eaac1793538174817/lz4-4.4.5-cp313-cp313-win_arm64.whl", hash = "sha256:c1cfa663468a189dab510ab231aad030970593f997746d7a324d40104db0d0a9", size = 91285, upload-time = "2025-11-03T13:02:06.77Z" },
+ { url = "https://files.pythonhosted.org/packages/49/55/6a5c2952971af73f15ed4ebfdd69774b454bd0dc905b289082ca8664fba1/lz4-4.4.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:67531da3b62f49c939e09d56492baf397175ff39926d0bd5bd2d191ac2bff95f", size = 207348, upload-time = "2025-11-03T13:02:08.117Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/d7/fd62cbdbdccc35341e83aabdb3f6d5c19be2687d0a4eaf6457ddf53bba64/lz4-4.4.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a1acbbba9edbcbb982bc2cac5e7108f0f553aebac1040fbec67a011a45afa1ba", size = 207340, upload-time = "2025-11-03T13:02:09.152Z" },
+ { url = "https://files.pythonhosted.org/packages/77/69/225ffadaacb4b0e0eb5fd263541edd938f16cd21fe1eae3cd6d5b6a259dc/lz4-4.4.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a482eecc0b7829c89b498fda883dbd50e98153a116de612ee7c111c8bcf82d1d", size = 1293398, upload-time = "2025-11-03T13:02:10.272Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/9e/2ce59ba4a21ea5dc43460cba6f34584e187328019abc0e66698f2b66c881/lz4-4.4.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e099ddfaa88f59dd8d36c8a3c66bd982b4984edf127eb18e30bb49bdba68ce67", size = 1281209, upload-time = "2025-11-03T13:02:12.091Z" },
+ { url = "https://files.pythonhosted.org/packages/80/4f/4d946bd1624ec229b386a3bc8e7a85fa9a963d67d0a62043f0af0978d3da/lz4-4.4.5-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2af2897333b421360fdcce895c6f6281dc3fab018d19d341cf64d043fc8d90d", size = 1369406, upload-time = "2025-11-03T13:02:13.683Z" },
+ { url = "https://files.pythonhosted.org/packages/02/a2/d429ba4720a9064722698b4b754fb93e42e625f1318b8fe834086c7c783b/lz4-4.4.5-cp313-cp313t-win32.whl", hash = "sha256:66c5de72bf4988e1b284ebdd6524c4bead2c507a2d7f172201572bac6f593901", size = 88325, upload-time = "2025-11-03T13:02:14.743Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/85/7ba10c9b97c06af6c8f7032ec942ff127558863df52d866019ce9d2425cf/lz4-4.4.5-cp313-cp313t-win_amd64.whl", hash = "sha256:cdd4bdcbaf35056086d910d219106f6a04e1ab0daa40ec0eeef1626c27d0fddb", size = 99643, upload-time = "2025-11-03T13:02:15.978Z" },
+ { url = "https://files.pythonhosted.org/packages/77/4d/a175459fb29f909e13e57c8f475181ad8085d8d7869bd8ad99033e3ee5fa/lz4-4.4.5-cp313-cp313t-win_arm64.whl", hash = "sha256:28ccaeb7c5222454cd5f60fcd152564205bcb801bd80e125949d2dfbadc76bbd", size = 91504, upload-time = "2025-11-03T13:02:17.313Z" },
+]
+
[[package]]
name = "magika"
version = "0.6.2"