runtype-pydantic-ai 0.2.0__tar.gz

runtype_pydantic_ai-0.2.0/.gitignore

@@ -0,0 +1,6 @@
+.venv*/
+__pycache__/
+*.egg-info/
+dist/
+.pytest_cache/
+.probe/

runtype_pydantic_ai-0.2.0/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @runtypelabs/pydantic-ai-otel
+
+## 0.2.0
+
+### Minor Changes
+
+- 9f1faab: Add `runtype-pydantic-ai`, a Python adapter that sends Pydantic AI 1.x and 2.x agent runs to Runtype at full fidelity through one `instrument()` call. It composes with Logfire and any OpenTelemetry provider.

runtype_pydantic_ai-0.2.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.5
+Name: runtype-pydantic-ai
+Version: 0.2.0
+Summary: Send Pydantic AI agent runs to Runtype at full fidelity: one call, composes with Logfire and any OpenTelemetry setup.
+Project-URL: Homepage, https://runtype.com
+Project-URL: Documentation, https://docs.runtype.com
+Author-email: Runtype Labs <dev@runtype.com>
+License-Expression: MIT
+Keywords: gen-ai,observability,opentelemetry,otel,pydantic-ai,runtype
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.30
+Requires-Dist: opentelemetry-sdk>=1.30
+Requires-Dist: pydantic-ai-slim<3,>=1.90
+Provides-Extra: dev
+Requires-Dist: logfire>=4.40; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# runtype-pydantic-ai
+
+Send [Pydantic AI](https://ai.pydantic.dev) agent runs to [Runtype](https://runtype.com). Each run
+appears as a first-class execution: transcript, system prompt, model calls, tool calls with arguments
+and results, token usage, cache usage, cost, loop iterations, stop reason and sub-agents.
+
+- Works with `pydantic-ai` 1.90+ and 2.x from one entry point.
+- Composes with Logfire and any OpenTelemetry setup. Your other exporters keep receiving the original
+  spans, and only agent-run spans reach Runtype.
+- Sends everything Runtype can show by default. Every content kind has its own off switch, and
+  `content=False` sends shape and cost only. Exception messages and stack traces never leave the
+  process; a failed run reports the exception class name.
+
+## Install
+
+```bash
+pip install runtype-pydantic-ai
+```
+
+## Quick start
+
+Set `RUNTYPE_API_KEY` to a key with the `TELEMETRY:WRITE` scope and `RUNTYPE_AGENT_ID` to the Runtype
+agent that owns the runs. Then add one call at startup:
+
+```python
+import runtype_pydantic_ai
+
+runtype_pydantic_ai.instrument()
+```
+
+Every `Agent` in the process is now traced. In a short-lived script, keep the handle and flush before
+exit:
+
+```python
+handle = runtype_pydantic_ai.instrument()
+...
+handle.force_flush()
+```
+
+## With Logfire
+
+Call `instrument()` after `logfire.configure()` and it joins Logfire's provider. Alternatively, pass
+the processor in:
+
+```python
+import logfire
+import runtype_pydantic_ai
+
+logfire.configure(additional_span_processors=[runtype_pydantic_ai.span_processor()])
+logfire.instrument_pydantic_ai(include_content=True, version=5)
+```
+
+Use `version=5` on `pydantic-ai` 1.x. The 1.x default, format 2, is still understood, but it reports
+less.
+
+## With another OpenTelemetry provider
+
+`instrument()` leaves a global non-Logfire provider alone and traces through a private one, because
+prompt content would otherwise reach every exporter on it. To share a provider, pass it:
+
+```python
+runtype_pydantic_ai.instrument(tracer_provider=provider)
+```
+
+Its other exporters then receive raw content, and `redact` does not apply to them. Use `content=False`
+to keep content off every exporter.
+
+If `Agent.instrument_all()` already ran, `instrument()` keeps those settings and joins the provider
+they use, and raises if it cannot reach that provider. An agent with its own instrumentation, such as
+`Agent(instrument=True)`, traces to its own provider, so pass that provider too.
+
+## Several agents in one process
+
+Map Pydantic AI agent names to Runtype agents, or pin a block of code to one:
+
+```python
+runtype_pydantic_ai.instrument(agent_ids={"chat": "agent_a", "run": "agent_b"})
+
+with runtype_pydantic_ai.runtype_agent("agent_c"):
+    await agent.run("...")
+```
+
+A sub-agent called from a tool stays a branch of the outer run, under the outer run's Runtype agent.
+
+Every top-level run is its own Runtype execution, even when several share a web request's span. A run
+under such a span gets a new trace id in Runtype, so it will not match the id in your other backend.
+
+## One agent only
+
+To trace a single agent rather than all of them:
+
+```python
+handle = runtype_pydantic_ai.instrument()
+Agent.instrument_all(False)
+agent = Agent("openai:gpt-5-mini", capabilities=[runtype_pydantic_ai.capability(handle)])
+```
+
+Early 1.x releases have no public `Instrumentation` capability, and `capability()` says so. Use
+`Agent(instrument=handle.settings)` there.
+
+## Content
+
+```python
+from runtype_pydantic_ai import ContentOptions
+
+runtype_pydantic_ai.instrument(content=False)
+runtype_pydantic_ai.instrument(content=ContentOptions(tool_results=False, max_chars=16_384))
+runtype_pydantic_ai.instrument(content=ContentOptions(redact=lambda value, attribute: scrub(value)))
+```
+
+Each switch also applies inside message lists. `tool_arguments=False` and `tool_results=False` remove
+those payloads from tool call parts, `system_instructions=False` removes system messages, and
+`output_messages=False` removes earlier assistant turns from `gen_ai.input.messages`.
+
+`redact` receives the parsed value and the attribute name. Returning `None`, or raising, drops that one
+attribute and keeps the span.
+
+Values are capped to fit ingest's limits. Oversized message lists stay valid JSON: large parts become a
+marker, then the oldest turns are dropped and the newest kept.
+
+## Custom attributes
+
+Attributes are allow-listed. To send your own, name their prefixes:
+
+```python
+runtype_pydantic_ai.instrument(passthrough_attribute_prefixes=["myapp."])
+```
+
+## Options
+
+| Environment variable | Purpose                                                                  |
+| -------------------- | ------------------------------------------------------------------------ |
+| `RUNTYPE_API_KEY`    | Runtype key with the `TELEMETRY:WRITE` scope. Required.                  |
+| `RUNTYPE_AGENT_ID`   | Default Runtype agent for runs.                                          |
+| `RUNTYPE_OTLP_URL`   | Full trace URL. Defaults to `https://api.runtype.com/v1/otel/v1/traces`. |

runtype_pydantic_ai-0.2.0/README.md

@@ -0,0 +1,135 @@
+# runtype-pydantic-ai
+
+Send [Pydantic AI](https://ai.pydantic.dev) agent runs to [Runtype](https://runtype.com). Each run
+appears as a first-class execution: transcript, system prompt, model calls, tool calls with arguments
+and results, token usage, cache usage, cost, loop iterations, stop reason and sub-agents.
+
+- Works with `pydantic-ai` 1.90+ and 2.x from one entry point.
+- Composes with Logfire and any OpenTelemetry setup. Your other exporters keep receiving the original
+  spans, and only agent-run spans reach Runtype.
+- Sends everything Runtype can show by default. Every content kind has its own off switch, and
+  `content=False` sends shape and cost only. Exception messages and stack traces never leave the
+  process; a failed run reports the exception class name.
+
+## Install
+
+```bash
+pip install runtype-pydantic-ai
+```
+
+## Quick start
+
+Set `RUNTYPE_API_KEY` to a key with the `TELEMETRY:WRITE` scope and `RUNTYPE_AGENT_ID` to the Runtype
+agent that owns the runs. Then add one call at startup:
+
+```python
+import runtype_pydantic_ai
+
+runtype_pydantic_ai.instrument()
+```
+
+Every `Agent` in the process is now traced. In a short-lived script, keep the handle and flush before
+exit:
+
+```python
+handle = runtype_pydantic_ai.instrument()
+...
+handle.force_flush()
+```
+
+## With Logfire
+
+Call `instrument()` after `logfire.configure()` and it joins Logfire's provider. Alternatively, pass
+the processor in:
+
+```python
+import logfire
+import runtype_pydantic_ai
+
+logfire.configure(additional_span_processors=[runtype_pydantic_ai.span_processor()])
+logfire.instrument_pydantic_ai(include_content=True, version=5)
+```
+
+Use `version=5` on `pydantic-ai` 1.x. The 1.x default, format 2, is still understood, but it reports
+less.
+
+## With another OpenTelemetry provider
+
+`instrument()` leaves a global non-Logfire provider alone and traces through a private one, because
+prompt content would otherwise reach every exporter on it. To share a provider, pass it:
+
+```python
+runtype_pydantic_ai.instrument(tracer_provider=provider)
+```
+
+Its other exporters then receive raw content, and `redact` does not apply to them. Use `content=False`
+to keep content off every exporter.
+
+If `Agent.instrument_all()` already ran, `instrument()` keeps those settings and joins the provider
+they use, and raises if it cannot reach that provider. An agent with its own instrumentation, such as
+`Agent(instrument=True)`, traces to its own provider, so pass that provider too.
+
+## Several agents in one process
+
+Map Pydantic AI agent names to Runtype agents, or pin a block of code to one:
+
+```python
+runtype_pydantic_ai.instrument(agent_ids={"chat": "agent_a", "run": "agent_b"})
+
+with runtype_pydantic_ai.runtype_agent("agent_c"):
+    await agent.run("...")
+```
+
+A sub-agent called from a tool stays a branch of the outer run, under the outer run's Runtype agent.
+
+Every top-level run is its own Runtype execution, even when several share a web request's span. A run
+under such a span gets a new trace id in Runtype, so it will not match the id in your other backend.
+
+## One agent only
+
+To trace a single agent rather than all of them:
+
+```python
+handle = runtype_pydantic_ai.instrument()
+Agent.instrument_all(False)
+agent = Agent("openai:gpt-5-mini", capabilities=[runtype_pydantic_ai.capability(handle)])
+```
+
+Early 1.x releases have no public `Instrumentation` capability, and `capability()` says so. Use
+`Agent(instrument=handle.settings)` there.
+
+## Content
+
+```python
+from runtype_pydantic_ai import ContentOptions
+
+runtype_pydantic_ai.instrument(content=False)
+runtype_pydantic_ai.instrument(content=ContentOptions(tool_results=False, max_chars=16_384))
+runtype_pydantic_ai.instrument(content=ContentOptions(redact=lambda value, attribute: scrub(value)))
+```
+
+Each switch also applies inside message lists. `tool_arguments=False` and `tool_results=False` remove
+those payloads from tool call parts, `system_instructions=False` removes system messages, and
+`output_messages=False` removes earlier assistant turns from `gen_ai.input.messages`.
+
+`redact` receives the parsed value and the attribute name. Returning `None`, or raising, drops that one
+attribute and keeps the span.
+
+Values are capped to fit ingest's limits. Oversized message lists stay valid JSON: large parts become a
+marker, then the oldest turns are dropped and the newest kept.
+
+## Custom attributes
+
+Attributes are allow-listed. To send your own, name their prefixes:
+
+```python
+runtype_pydantic_ai.instrument(passthrough_attribute_prefixes=["myapp."])
+```
+
+## Options
+
+| Environment variable | Purpose                                                                  |
+| -------------------- | ------------------------------------------------------------------------ |
+| `RUNTYPE_API_KEY`    | Runtype key with the `TELEMETRY:WRITE` scope. Required.                  |
+| `RUNTYPE_AGENT_ID`   | Default Runtype agent for runs.                                          |
+| `RUNTYPE_OTLP_URL`   | Full trace URL. Defaults to `https://api.runtype.com/v1/otel/v1/traces`. |

runtype_pydantic_ai-0.2.0/examples/test_app.py

@@ -0,0 +1,229 @@
+"""A small support-desk Pydantic AI app, for proving the adapter end to end.
+
+Runs offline on FunctionModel, so the same scenarios work on every supported pydantic-ai version:
+
+    RUNTYPE_API_KEY=... RUNTYPE_AGENT_ID=agent_... python examples/test_app.py
+
+`TEST_APP_MODEL=openai:gpt-5-mini` swaps in a real model for the plain tool scenario.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+from opentelemetry import trace
+from pydantic import BaseModel
+from pydantic_ai import Agent, ModelRetry
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelResponse,
+    RequestUsage,
+    TextPart,
+    ToolCallPart,
+    ToolReturnPart,
+)
+from pydantic_ai.models.function import AgentInfo, DeltaToolCall, FunctionModel
+
+import runtype_pydantic_ai
+
+
+class Ticket(BaseModel):
+    summary: str
+    priority: int
+
+
+def _tool_returns(messages: list[ModelMessage]) -> list[ToolReturnPart]:
+    return [
+        part
+        for message in messages
+        for part in message.parts
+        if isinstance(part, ToolReturnPart)
+    ]
+
+
+def _usage() -> RequestUsage:
+    return RequestUsage(input_tokens=120, output_tokens=30, cache_read_tokens=40)
+
+
+def weather_model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    if not _tool_returns(messages):
+        call = ToolCallPart(
+            "lookup_order", {"order_id": "ord_42"}, tool_call_id="call_lookup"
+        )
+        return ModelResponse(
+            parts=[call],
+            usage=_usage(),
+            model_name="test-model",
+            finish_reason="tool_call",
+        )
+    return ModelResponse(
+        parts=[TextPart("Order ord_42 shipped on Monday.")],
+        usage=_usage(),
+        model_name="test-model",
+        finish_reason="stop",
+    )
+
+
+async def weather_stream(messages: list[ModelMessage], info: AgentInfo):
+    if not _tool_returns(messages):
+        yield {
+            0: DeltaToolCall(
+                name="lookup_order",
+                json_args='{"order_id":"ord_42"}',
+                tool_call_id="call_lookup",
+            )
+        }
+    else:
+        yield "Order ord_42 "
+        yield "shipped on Monday."
+
+
+def structured_model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    output_tool = info.output_tools[0].name
+    call = ToolCallPart(
+        output_tool,
+        {"summary": "Refund request", "priority": 2},
+        tool_call_id="call_out",
+    )
+    return ModelResponse(
+        parts=[call], usage=_usage(), model_name="test-model", finish_reason="tool_call"
+    )
+
+
+def retry_model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    attempts = sum(1 for message in messages if isinstance(message, ModelResponse))
+    if attempts < 2:
+        call = ToolCallPart(
+            "flaky_lookup", {"attempt": attempts}, tool_call_id=f"call_retry_{attempts}"
+        )
+        return ModelResponse(
+            parts=[call],
+            usage=_usage(),
+            model_name="test-model",
+            finish_reason="tool_call",
+        )
+    return ModelResponse(
+        parts=[TextPart("Recovered.")],
+        usage=_usage(),
+        model_name="test-model",
+        finish_reason="stop",
+    )
+
+
+def delegating_model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    if not _tool_returns(messages):
+        call = ToolCallPart(
+            "ask_specialist",
+            {"question": "refund policy?"},
+            tool_call_id="call_delegate",
+        )
+        return ModelResponse(
+            parts=[call],
+            usage=_usage(),
+            model_name="test-model",
+            finish_reason="tool_call",
+        )
+    return ModelResponse(
+        parts=[TextPart("30 days.")],
+        usage=_usage(),
+        model_name="test-model",
+        finish_reason="stop",
+    )
+
+
+def specialist_model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    return ModelResponse(
+        parts=[TextPart("Refunds: 30 days")],
+        usage=_usage(),
+        model_name="specialist",
+        finish_reason="stop",
+    )
+
+
+def failing_model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+    raise RuntimeError("secret upstream detail: sk-should-never-export")
+
+
+def build_support_agent() -> Agent:
+    model = os.environ.get("TEST_APP_MODEL") or FunctionModel(
+        weather_model, stream_function=weather_stream, model_name="test-model"
+    )
+    agent = Agent(
+        model, name="support", instructions="You are the support desk. Be brief."
+    )
+
+    @agent.tool_plain
+    def lookup_order(order_id: str) -> str:
+        """Find an order's status."""
+        return f"{order_id}: shipped Monday"
+
+    return agent
+
+
+def build_agents() -> dict[str, Agent]:
+    structured = Agent(
+        FunctionModel(structured_model),
+        name="triage",
+        output_type=Ticket,
+        instructions="Triage.",
+    )
+    retrying = Agent(
+        FunctionModel(retry_model), name="retrier", instructions="Retry on failure."
+    )
+
+    @retrying.tool_plain(retries=3)
+    def flaky_lookup(attempt: int) -> str:
+        if attempt == 0:
+            raise ModelRetry("try again")
+        return "ok"
+
+    specialist = Agent(
+        FunctionModel(specialist_model), name="specialist", instructions="Know refunds."
+    )
+    delegating = Agent(
+        FunctionModel(delegating_model), name="frontdesk", instructions="Delegate."
+    )
+
+    @delegating.tool_plain
+    async def ask_specialist(question: str) -> str:
+        result = await specialist.run(question)
+        return result.output
+
+    failing = Agent(FunctionModel(failing_model), name="failing", instructions="Fail.")
+    return {
+        "support": build_support_agent(),
+        "triage": structured,
+        "retrier": retrying,
+        "frontdesk": delegating,
+        "failing": failing,
+    }
+
+
+async def run_all(agents: dict[str, Agent]) -> None:
+    first = await agents["support"].run("Where is order ord_42?")
+    await agents["support"].run(
+        "Thanks, and when did it ship?", message_history=first.all_messages()
+    )
+    await agents["triage"].run("I want a refund")
+    await agents["retrier"].run("Look it up")
+    await agents["frontdesk"].run("What is the refund policy?")
+    async with agents["support"].run_stream("Stream the status of ord_42") as stream:
+        await stream.get_output()
+    with trace.get_tracer("test-app").start_as_current_span("POST /chat"):
+        await agents["support"].run("Inside a web request")
+    try:
+        await agents["failing"].run("This one fails")
+    except RuntimeError:
+        pass
+
+
+def main() -> None:
+    handle = runtype_pydantic_ai.instrument()
+    asyncio.run(run_all(build_agents()))
+    handle.force_flush()
+    print("sent 8 runs to", os.environ.get("RUNTYPE_OTLP_URL", "api.runtype.com"))
+
+
+if __name__ == "__main__":
+    main()

runtype_pydantic_ai-0.2.0/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@runtypelabs/pydantic-ai-otel",
+  "version": "0.2.0",
+  "private": true,
+  "description": "Changesets anchor for the Pydantic AI adapter (published to PyPI as runtype-pydantic-ai, not npm). The version here is mirrored into pyproject.toml and runtype_pydantic_ai/_version.py by scripts/sync-sdk-versions.mjs.",
+  "license": "MIT"
+}

runtype_pydantic_ai-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "runtype-pydantic-ai"
+version = "0.2.0"
+description = "Send Pydantic AI agent runs to Runtype at full fidelity: one call, composes with Logfire and any OpenTelemetry setup."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Runtype Labs", email = "dev@runtype.com" }
+]
+keywords = ["runtype", "pydantic-ai", "opentelemetry", "otel", "gen-ai", "observability"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Monitoring",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic-ai-slim>=1.90,<3",
+    "opentelemetry-sdk>=1.30",
+    "opentelemetry-exporter-otlp-proto-http>=1.30",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+    "logfire>=4.40",
+]
+
+[project.urls]
+Homepage = "https://runtype.com"
+Documentation = "https://docs.runtype.com"
+
+[tool.hatch.build.targets.wheel]
+packages = ["runtype_pydantic_ai"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]