cade-cli 0.19.2__tar.gz → 0.20.0__tar.gz

{cade_cli-0.19.2 → cade_cli-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.19.2
+Version: 0.20.0
 Summary: Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://arcadeagent.dev/docs
@@ -76,6 +76,10 @@ Requires-Dist: ruff<1.0.0,>=0.5.0; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material<10.0.0,>=9.5.0; extra == 'docs'
 Requires-Dist: mkdocs<2.0.0,>=1.6.0; extra == 'docs'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api<2.0.0,>=1.27.0; extra == 'otel'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http<2.0.0,>=1.27.0; extra == 'otel'
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.27.0; extra == 'otel'
 Provides-Extra: training
 Requires-Dist: accelerate>=0.27.0; extra == 'training'
 Requires-Dist: safetensors>=0.4.2; extra == 'training'
@@ -137,9 +141,9 @@ CADE_VERSION=0.16.9 CADE_INSTALL_DIR=/usr/local/bin \
   sh -c "$(curl -fsSL https://arcadeagent.dev/install)"
 ```
 
-On Linux the installer auto-picks a **cpu** or **gpu** build (GPU when
-`nvidia-smi` detects a card; the GPU build bundles the CUDA stack and is a much
-larger download). Force it with `CADE_VARIANT=cpu` or `CADE_VARIANT=gpu`.
+On Linux the installer ships the **cpu** build today (gpu release assets are
+paused). Force a variant later with `CADE_VARIANT=cpu` or `CADE_VARIANT=gpu`
+when gpu builds return.
 
 ### Alternatives
 

{cade_cli-0.19.2 → cade_cli-0.20.0}/README.md

@@ -46,9 +46,9 @@ CADE_VERSION=0.16.9 CADE_INSTALL_DIR=/usr/local/bin \
   sh -c "$(curl -fsSL https://arcadeagent.dev/install)"
 ```
 
-On Linux the installer auto-picks a **cpu** or **gpu** build (GPU when
-`nvidia-smi` detects a card; the GPU build bundles the CUDA stack and is a much
-larger download). Force it with `CADE_VARIANT=cpu` or `CADE_VARIANT=gpu`.
+On Linux the installer ships the **cpu** build today (gpu release assets are
+paused). Force a variant later with `CADE_VARIANT=cpu` or `CADE_VARIANT=gpu`
+when gpu builds return.
 
 ### Alternatives
 

{cade_cli-0.19.2 → cade_cli-0.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.19.2"
+version = "0.20.0"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -85,6 +85,11 @@ voice = [
     # PyInstaller (see .github/workflows/release.yml), and cade.spec bundles it
     # so misaki never downloads it at runtime in the frozen app.
 ]
+otel = [
+    "opentelemetry-api>=1.27.0,<2.0.0",
+    "opentelemetry-sdk>=1.27.0,<2.0.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.27.0,<2.0.0",
+]
 training = [
     "torch>=2.1.0",
     "transformers>=4.38.0",

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/cli/app.py

@@ -365,6 +365,11 @@ def main_callback(
     ctx.ensure_object(dict)
     ctx.obj["verbose"] = verbose
 
+    # Optional OpenTelemetry (CADE_OTEL=1 + cade-cli[otel]). No-op otherwise.
+    from cadecoder.telemetry import init_telemetry
+
+    init_telemetry()
+
     # Agent management and inspection commands manage their own (possibly empty)
     # agent state and must not auto-create a `default` agent — that would clobber
     # the empty-state UX of `cade list` / `cade status` on a fresh install.

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/daemon/runner_main.py

@@ -27,6 +27,9 @@ async def _serve(agent_name: str, fd: int) -> None:
     from cadecoder.core import agent as agent_mod
     from cadecoder.daemon.control import ControlServer
     from cadecoder.daemon.runner import InProcessRunner
+    from cadecoder.telemetry import init_telemetry
+
+    init_telemetry()
 
     agent = agent_mod.resolve(agent_name)
     if agent is None:

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/daemon/server.py

@@ -115,6 +115,10 @@ async def run_daemon(
     # Same SSL_CERT_FILE footgun as the CLI — scrub before Telegram/MCP/Anthropic.
     prepare_ssl_env()
 
+    from cadecoder.telemetry import init_telemetry
+
+    init_telemetry()
+
     host, port = _parse_bind(bind)
     _guard_auth_bind(host, require_auth)
     prewarm = prewarm or []

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/execution/orchestrator.py

@@ -246,9 +246,23 @@ class Orchestrator:
         )
 
     async def stream(self, context: ExecutionContext) -> AsyncIterator[ExecutionEvent]:
-        """Stream execution events."""
-        async for event in self._stream_inner(context):
-            yield event
+        """Stream execution events, wrapping the turn in an OTEL span when enabled."""
+        from cadecoder.telemetry import set_span_output, trace_turn
+
+        with trace_turn(
+            thread_id=str(context.metadata.get("thread_id") or ""),
+            conversation_id=str(context.metadata.get("conversation_id") or ""),
+            agent=str(context.metadata.get("agent") or self._persona or ""),
+            model=self.default_model,
+            prompt=context.task,
+        ) as turn_span:
+            reply_parts: list[str] = []
+            async for event in self._stream_inner(context):
+                if event.type == ExecutionEventType.CONTENT and event.content:
+                    reply_parts.append(event.content)
+                yield event
+            if reply_parts:
+                set_span_output(turn_span, "".join(reply_parts))
 
     async def _stream_inner(self, context: ExecutionContext) -> AsyncIterator[ExecutionEvent]:
         """Core streaming implementation."""
@@ -368,69 +382,104 @@ class Orchestrator:
             invalid_tool_pairs = False
             stream_error = False
 
+            from cadecoder.telemetry import (
+                record_message_parts,
+                record_usage,
+                set_span_output,
+                trace_llm_call,
+            )
+
+            provider_name = ""
             try:
-                async for stream_event in self.provider.stream(request):
-                    # Handle error events from the provider
-                    if stream_event.type == "error" and stream_event.content:
-                        error_text = str(stream_event.content)
-                        if "prompt is too long" in error_text or (
-                            "too long" in error_text and "token" in error_text
-                        ):
-                            log.warning(
-                                f"Prompt too long for API, forcing compaction: {error_text[:200]}"
-                            )
-                            prompt_too_long = True
-                            break
-                        elif "tool_use" in error_text and "tool_result" in error_text:
-                            # Orphaned tool_use/tool_result from bad compaction
-                            log.warning(
-                                f"Invalid tool_use/tool_result pairing, "
-                                f"attempting repair: {error_text[:200]}"
-                            )
-                            invalid_tool_pairs = True
-                            break
-                        else:
-                            # Surface non-recoverable stream errors to the user
-                            log.error(f"Provider stream error: {error_text[:300]}")
+                provider_name = str(getattr(self.provider, "provider_type", "") or "")
+            except Exception:  # noqa: BLE001
+                provider_name = ""
+
+            with trace_llm_call(
+                model=self.default_model,
+                iteration=iteration,
+                provider=provider_name,
+                estimated_prompt_tokens=context_status.get("token_count"),
+            ) as llm_span:
+                record_message_parts(
+                    llm_span,
+                    messages,
+                    chars_per_token=self.context_manager.chars_per_token,
+                )
+                try:
+                    async for stream_event in self.provider.stream(request):
+                        usage = stream_event.metadata.get("usage")
+                        if usage:
+                            record_usage(llm_span, usage)
+
+                        # Handle error events from the provider
+                        if stream_event.type == "error" and stream_event.content:
+                            error_text = str(stream_event.content)
+                            if "prompt is too long" in error_text or (
+                                "too long" in error_text and "token" in error_text
+                            ):
+                                log.warning(
+                                    f"Prompt too long for API, forcing compaction: "
+                                    f"{error_text[:200]}"
+                                )
+                                prompt_too_long = True
+                                break
+                            elif "tool_use" in error_text and "tool_result" in error_text:
+                                # Orphaned tool_use/tool_result from bad compaction
+                                log.warning(
+                                    f"Invalid tool_use/tool_result pairing, "
+                                    f"attempting repair: {error_text[:200]}"
+                                )
+                                invalid_tool_pairs = True
+                                break
+                            else:
+                                # Surface non-recoverable stream errors to the user
+                                log.error(f"Provider stream error: {error_text[:300]}")
+                                yield ExecutionEvent(
+                                    type=ExecutionEventType.CONTENT,
+                                    content=f"\n\nError from provider: {error_text}\n",
+                                )
+                                stream_error = True
+                                break
+
+                        if stream_event.content:
+                            accumulated_content += stream_event.content
                             yield ExecutionEvent(
                                 type=ExecutionEventType.CONTENT,
-                                content=f"\n\nError from provider: {error_text}\n",
+                                content=stream_event.content,
                             )
-                            stream_error = True
-                            break
-
-                    if stream_event.content:
-                        accumulated_content += stream_event.content
-                        yield ExecutionEvent(
-                            type=ExecutionEventType.CONTENT,
-                            content=stream_event.content,
-                        )
 
-                    # Handle tool call events from provider
-                    if stream_event.type == ExecutionEventType.TOOL_CALL.value:
-                        tool_call = stream_event.metadata.get("tool_call")
-                        if tool_call:
-                            tool_calls.append(tool_call)
-                            # Surface read-only classification so the UI can
-                            # render mutating calls more prominently than
-                            # idempotent reads. Best-effort — old/incompatible
-                            # tool managers just won't set the flag.
-                            tc_name = tool_call.get("function", {}).get("name", "")
-                            is_read_only = self._classify_read_only(tc_name)
-                            event_meta: dict[str, Any] = {"tool_call": tool_call}
-                            if is_read_only is not None:
-                                event_meta["is_read_only"] = is_read_only
-                            yield ExecutionEvent(
-                                type=ExecutionEventType.TOOL_CALL,
-                                metadata=event_meta,
-                            )
-            except Exception as e:
-                log.error(f"Provider stream failed: {e}")
-                yield ExecutionEvent(
-                    type=ExecutionEventType.CONTENT,
-                    content=f"\n\nProvider error: {e}\n",
-                )
-                stream_error = True
+                        # Handle tool call events from provider
+                        if stream_event.type == ExecutionEventType.TOOL_CALL.value:
+                            tool_call = stream_event.metadata.get("tool_call")
+                            if tool_call:
+                                tool_calls.append(tool_call)
+                                # Surface read-only classification so the UI can
+                                # render mutating calls more prominently than
+                                # idempotent reads. Best-effort — old/incompatible
+                                # tool managers just won't set the flag.
+                                tc_name = tool_call.get("function", {}).get("name", "")
+                                is_read_only = self._classify_read_only(tc_name)
+                                event_meta: dict[str, Any] = {"tool_call": tool_call}
+                                if is_read_only is not None:
+                                    event_meta["is_read_only"] = is_read_only
+                                yield ExecutionEvent(
+                                    type=ExecutionEventType.TOOL_CALL,
+                                    metadata=event_meta,
+                                )
+                except Exception as e:
+                    log.error(f"Provider stream failed: {e}")
+                    yield ExecutionEvent(
+                        type=ExecutionEventType.CONTENT,
+                        content=f"\n\nProvider error: {e}\n",
+                    )
+                    stream_error = True
+                finally:
+                    if accumulated_content:
+                        set_span_output(llm_span, accumulated_content)
+                    if tool_calls:
+                        if llm_span is not None:
+                            llm_span.set_attribute("cade.tool_call_count", len(tool_calls))
 
             # Stop the execution loop on non-recoverable stream errors
             if stream_error:

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/execution/parallel.py

@@ -194,78 +194,95 @@ class AsyncToolExecutor:
         timeout: float = 120.0,
     ) -> ToolExecutionResult:
         """Execute a single tool with timeout and cancellation support."""
+        from cadecoder.telemetry import set_tool_result, trace_tool_call
+
         function = tool_call.get("function", {})
         name = function.get("name", "unknown")
         tool_call_id = tool_call.get("id", "unknown")
+        args_str = function.get("arguments", "{}") or "{}"
 
         try:
-            args_str = function.get("arguments", "{}") or "{}"
             args = json.loads(args_str)
-            log.debug(f"Executing tool: {name} with args: {args}")
+        except json.JSONDecodeError:
+            args = args_str  # span preview only; execute path will error below
 
+        with trace_tool_call(name=name, tool_call_id=tool_call_id, arguments=args) as tool_span:
             try:
-                result_content = await asyncio.wait_for(
-                    self.tool_manager.execute(name, args),
-                    timeout=timeout,
-                )
-            except TimeoutError:
-                log.warning(f"Tool {name} timed out after {timeout}s")
-                if isinstance(name, str) and name.startswith("Memory_"):
-                    content = (
-                        f"Memory tool timed out after {timeout:.0f}s (often a cold "
-                        "embedder load). Retry Memory_SearchLibrary once; do not fall "
-                        "back to Local_* filesystem tools for library recall."
+                if not isinstance(args, dict):
+                    raise ValueError(f"Tool arguments must be a JSON object, got: {args_str[:120]}")
+                log.debug(f"Executing tool: {name} with args: {args}")
+
+                try:
+                    result_content = await asyncio.wait_for(
+                        self.tool_manager.execute(name, args),
+                        timeout=timeout,
                     )
-                else:
-                    content = f"Tool execution timed out after {timeout} seconds"
+                except TimeoutError:
+                    log.warning(f"Tool {name} timed out after {timeout}s")
+                    if isinstance(name, str) and name.startswith("Memory_"):
+                        content = (
+                            f"Memory tool timed out after {timeout:.0f}s (often a cold "
+                            "embedder load). Retry Memory_SearchLibrary once; do not fall "
+                            "back to Local_* filesystem tools for library recall."
+                        )
+                    else:
+                        content = f"Tool execution timed out after {timeout} seconds"
+                    set_tool_result(tool_span, status="error", content=content, error="timeout")
+                    return ToolExecutionResult(
+                        tool_call_id=tool_call_id,
+                        name=name,
+                        content=content,
+                        status="error",
+                        error="timeout",
+                        authorization_url=None,
+                    )
+                except asyncio.CancelledError:
+                    log.info(f"Tool {name} was cancelled")
+                    set_tool_result(
+                        tool_span,
+                        status="cancelled",
+                        content="Tool execution was cancelled",
+                        error="cancelled",
+                    )
+                    return ToolExecutionResult(
+                        tool_call_id=tool_call_id,
+                        name=name,
+                        content="Tool execution was cancelled",
+                        status="cancelled",
+                        error="cancelled",
+                        authorization_url=None,
+                    )
+
+                actual_content = extract_tool_output_content(result_content)
+                set_tool_result(tool_span, status="success", content=actual_content)
                 return ToolExecutionResult(
                     tool_call_id=tool_call_id,
                     name=name,
-                    content=content,
-                    status="error",
-                    error="timeout",
+                    content=actual_content,
+                    status="success",
+                    error=None,
                     authorization_url=None,
                 )
-            except asyncio.CancelledError:
-                log.info(f"Tool {name} was cancelled")
+
+            except Exception as e:
+                auth_url = None
+                if isinstance(e, ToolAuthorizationRequired):
+                    auth_url = e.authorization_url
+                    log.error(f"Authorization required for tool {name}")
+                else:
+                    log.error(f"Tool execution failed for {name}: {e}")
+                    log.exception(e)
+
+                set_tool_result(tool_span, status="error", content=str(e), error=str(e))
                 return ToolExecutionResult(
                     tool_call_id=tool_call_id,
                     name=name,
-                    content="Tool execution was cancelled",
-                    status="cancelled",
-                    error="cancelled",
-                    authorization_url=None,
+                    content=str(e),
+                    status="error",
+                    error=str(e),
+                    authorization_url=auth_url,
                 )
 
-            actual_content = extract_tool_output_content(result_content)
-
-            return ToolExecutionResult(
-                tool_call_id=tool_call_id,
-                name=name,
-                content=actual_content,
-                status="success",
-                error=None,
-                authorization_url=None,
-            )
-
-        except Exception as e:
-            auth_url = None
-            if isinstance(e, ToolAuthorizationRequired):
-                auth_url = e.authorization_url
-                log.error(f"Authorization required for tool {name}")
-            else:
-                log.error(f"Tool execution failed for {name}: {e}")
-                log.exception(e)
-
-            return ToolExecutionResult(
-                tool_call_id=tool_call_id,
-                name=name,
-                content=str(e),
-                status="error",
-                error=str(e),
-                authorization_url=auth_url,
-            )
-
     def _analyze_tool_dependencies(self, tool_calls: ToolCallList) -> ToolGroups:
         """Analyze tool dependencies to determine execution groups.
 

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/host_plugin/assets/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cade",
   "description": "Your persistent on-device agent: notes memory, durable tasks, and connected tools via Ask.",
-  "version": "0.19.2",
+  "version": "0.20.0",
   "author": {
     "name": "Arcade.dev",
     "url": "https://docs.cade.dev"

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/host_plugin/assets/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "cade",
   "displayName": "Cade",
   "description": "Your persistent on-device agent: notes memory, durable tasks, and connected tools via Ask.",
-  "version": "0.19.2",
+  "version": "0.20.0",
   "author": {
     "name": "Arcade.dev",
     "email": "support@arcade.dev"

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/providers/anthropic.py

@@ -329,6 +329,25 @@ class AnthropicProvider(Provider):
                             },
                         )
 
+            # Final message carries authoritative input/output token counts.
+            try:
+                final = await stream.get_final_message()
+                if final is not None and getattr(final, "usage", None) is not None:
+                    usage = {
+                        "prompt_tokens": int(final.usage.input_tokens or 0),
+                        "completion_tokens": int(final.usage.output_tokens or 0),
+                        "total_tokens": int(
+                            (final.usage.input_tokens or 0) + (final.usage.output_tokens or 0)
+                        ),
+                    }
+                    yield StreamEvent(
+                        type=ExecutionEventType.COMPLETE.value,
+                        content=None,
+                        metadata={"usage": usage, "model": request.model},
+                    )
+            except Exception as exc:  # noqa: BLE001
+                log.debug(f"Anthropic stream usage unavailable: {exc}")
+
     @staticmethod
     def _default_max_tokens(request: ProviderRequest, streaming: bool) -> int:
         """Return the default output-token cap for a request without one.

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/providers/ollama.py

@@ -354,13 +354,24 @@ class OllamaProvider(Provider):
                         )
 
                 if chunk.get("done"):
+                    complete_meta: dict[str, Any] = {
+                        "finish_reason": "tool_calls" if saw_tool_calls else "stop",
+                        "model": request.model,
+                    }
+                    prompt_tokens = chunk.get("prompt_eval_count")
+                    completion_tokens = chunk.get("eval_count")
+                    if prompt_tokens is not None or completion_tokens is not None:
+                        p = int(prompt_tokens or 0)
+                        c = int(completion_tokens or 0)
+                        complete_meta["usage"] = {
+                            "prompt_tokens": p,
+                            "completion_tokens": c,
+                            "total_tokens": p + c,
+                        }
                     yield StreamEvent(
                         type=ExecutionEventType.COMPLETE.value,
                         content=None,
-                        metadata={
-                            "finish_reason": "tool_calls" if saw_tool_calls else "stop",
-                            "model": request.model,
-                        },
+                        metadata=complete_meta,
                     )
                     break
 

{cade_cli-0.19.2 → cade_cli-0.20.0}/src/cadecoder/providers/openai.py

@@ -217,13 +217,44 @@ class OpenAIProvider(Provider):
         """Yield one attempt's worth of stream events. Raises on error."""
         openai_request = self._build_openai_request(request)
         openai_request["stream"] = True
+        # Ask OpenAI (and compatible servers that honor it) for a final usage
+        # chunk so OTEL spans can record prompt/completion tokens. Some local
+        # OpenAI-compatible servers reject stream_options — fall back cleanly.
+        want_usage = os.environ.get("CADE_OTEL", "").strip().lower() in (
+            "1",
+            "true",
+            "yes",
+            "on",
+        )
+        if want_usage:
+            openai_request["stream_options"] = {"include_usage": True}
 
-        stream = await self.client.chat.completions.create(**openai_request)
+        try:
+            stream = await self.client.chat.completions.create(**openai_request)
+        except Exception as exc:
+            if want_usage and "stream_options" in openai_request:
+                log.debug(
+                    f"stream_options.include_usage rejected by endpoint; "
+                    f"retrying without usage: {exc}"
+                )
+                openai_request.pop("stream_options", None)
+                stream = await self.client.chat.completions.create(**openai_request)
+            else:
+                raise
         current_tool_calls: dict[int, dict[str, Any]] = {}
+        usage: dict[str, int] | None = None
+        usage_emitted = False
 
         async for chunk in stream:
             chunk = cast(ChatCompletionChunk, chunk)
 
+            if chunk.usage is not None:
+                usage = {
+                    "prompt_tokens": chunk.usage.prompt_tokens or 0,
+                    "completion_tokens": chunk.usage.completion_tokens or 0,
+                    "total_tokens": chunk.usage.total_tokens or 0,
+                }
+
             # Handle content delta
             if chunk.choices and chunk.choices[0].delta.content:
                 yield StreamEvent(
@@ -259,15 +290,27 @@ class OpenAIProvider(Provider):
                         metadata={"tool_call": tool_call},
                     )
 
+                complete_meta: dict[str, Any] = {
+                    "finish_reason": chunk.choices[0].finish_reason,
+                    "model": chunk.model,
+                }
+                if usage:
+                    complete_meta["usage"] = usage
+                    usage_emitted = True
                 yield StreamEvent(
                     type=ExecutionEventType.COMPLETE.value,
                     content=None,
-                    metadata={
-                        "finish_reason": chunk.choices[0].finish_reason,
-                        "model": chunk.model,
-                    },
+                    metadata=complete_meta,
                 )
 
+        # Usage often arrives on a trailing empty-choices chunk after finish.
+        if usage and not usage_emitted:
+            yield StreamEvent(
+                type=ExecutionEventType.COMPLETE.value,
+                content=None,
+                metadata={"usage": usage},
+            )
+
     def _build_openai_request(self, request: ProviderRequest) -> dict[str, Any]:
         """Build OpenAI API request from unified request.
 

cade_cli-0.20.0/src/cadecoder/telemetry/__init__.py

@@ -0,0 +1,45 @@
+"""Optional OpenTelemetry tracing for Cade agent turns.
+
+Enable with ``CADE_OTEL=1`` (requires the ``otel`` extra). Spans cover each
+agent turn, every LLM call inside it, and every tool invocation — with
+latency, tool names/args/status, and token usage when the provider reports it.
+
+Export defaults to OTLP HTTP at ``http://127.0.0.1:6006/v1/traces`` (Arize
+Phoenix). Override with the standard ``OTEL_EXPORTER_OTLP_*`` env vars.
+
+Example::
+
+    CADE_OTEL=1 cade chat
+    # another terminal:
+    make otel-ui
+"""
+
+from __future__ import annotations
+
+from cadecoder.telemetry.otel import (
+    init_telemetry,
+    is_enabled,
+    record_message_parts,
+    record_usage,
+    set_span_output,
+    set_tool_result,
+    shutdown_telemetry,
+    start_span,
+    trace_llm_call,
+    trace_tool_call,
+    trace_turn,
+)
+
+__all__ = [
+    "init_telemetry",
+    "is_enabled",
+    "record_message_parts",
+    "record_usage",
+    "set_span_output",
+    "set_tool_result",
+    "shutdown_telemetry",
+    "start_span",
+    "trace_llm_call",
+    "trace_tool_call",
+    "trace_turn",
+]