trustmodel 2.1.0__tar.gz → 2.2.1__tar.gz

trustmodel-2.1.0/README.md → trustmodel-2.2.1/PKG-INFO

@@ -1,3 +1,71 @@
+Metadata-Version: 2.4
+Name: trustmodel
+Version: 2.2.1
+Summary: Official Python SDK for TrustModel AI evaluation platform
+Project-URL: Homepage, https://trustmodel.ai
+Author-email: TrustModel <info@predixtions.com>
+License: Proprietary - TrustModel Python SDK License
+License-File: LICENSE
+Keywords: ai,api,evaluation,sdk,trustmodel
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Requires-Dist: eval-type-backport>=0.2.0; python_version < '3.10'
+Requires-Dist: importlib-metadata>=4.0.0; python_version < '3.8'
+Requires-Dist: pydantic<2.0.0,>=1.10.0; python_version < '3.8'
+Requires-Dist: pydantic<3.0.0,>=2.0.0; python_version >= '3.8'
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: requests<3.0.0,>=2.25.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: black<23.0.0,>=22.0.0; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: black>=23.0.0; (python_version >= '3.8') and extra == 'dev'
+Requires-Dist: bump2version>=1.0.1; extra == 'dev'
+Requires-Dist: importlib-metadata>=4.0.0; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: isort<5.12.0,>=5.11.0; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: isort>=5.12.0; (python_version >= '3.8') and extra == 'dev'
+Requires-Dist: mypy<1.5.0,>=1.0.0; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: mypy>=1.5.0; (python_version >= '3.8') and extra == 'dev'
+Requires-Dist: pytest-cov<5.0.0,>=4.0.0; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; (python_version >= '3.8') and extra == 'dev'
+Requires-Dist: pytest<8.0.0,>=7.0.0; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: pytest>=7.0.0; (python_version >= '3.8') and extra == 'dev'
+Requires-Dist: ruff<0.1.0,>=0.0.277; (python_version < '3.8') and extra == 'dev'
+Requires-Dist: ruff>=0.1.0; (python_version >= '3.8') and extra == 'dev'
+Requires-Dist: types-requests>=2.25.0; extra == 'dev'
+Requires-Dist: types-tqdm>=4.60.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx-autodoc-typehints>=1.24.0; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == 'docs'
+Requires-Dist: sphinx>=7.0.0; extra == 'docs'
+Provides-Extra: telemetry
+Requires-Dist: openinference-instrumentation-anthropic>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-bedrock>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-crewai>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-dspy>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-groq>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-langchain>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-llama-index>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-mistralai>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-openai>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: openinference-instrumentation-vertexai>=0.1.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: opentelemetry-api>=1.20.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; (python_version >= '3.10') and extra == 'telemetry'
+Requires-Dist: opentelemetry-sdk>=1.20.0; (python_version >= '3.10') and extra == 'telemetry'
+Description-Content-Type: text/markdown
+
 <p align="center">
   <a href="https://www.trustmodel.ai">
     <img src="https://www.trustmodel.ai/assets/trustmodel-wordmark-CfuXSOoK.svg" alt="TrustModel" width="400">
@@ -23,6 +91,36 @@
 
 Evaluate AI models for safety, bias, and performance with a simple, intuitive interface.
 
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Prerequisites](#prerequisites)
+- [Quick Start](#quick-start)
+- [Authentication](#authentication)
+- [Evaluation Modes](#evaluation-modes)
+  - [Getting Available Vendors](#getting-available-vendors)
+  - [Getting Available Models](#getting-available-models)
+  - [Platform Key (Default)](#platform-key-default)
+  - [BYOK (Bring Your Own Key)](#byok-bring-your-own-key)
+  - [Custom Endpoint](#custom-endpoint)
+- [Core Concepts](#core-concepts)
+  - [Models](#models)
+  - [Evaluations](#evaluations)
+  - [Configuration](#configuration)
+  - [Credits Management](#credits-management)
+- [Error Handling](#error-handling)
+- [Rate Limiting](#rate-limiting)
+- [Webhook Notifications](#webhook-notifications)
+- [Advanced Usage](#advanced-usage)
+- [Framework Integration](#framework-integration)
+- [Zero-Config Auto-Capture (`auto_init`)](#zero-config-auto-capture-auto_init)
+- [Agentic Trace Evaluation](#agentic-trace-evaluation)
+- [Galileo Integration](#galileo-integration)
+- [Requirements](#requirements)
+- [Support](#support)
+- [License](#license)
+
 ## Features
 
 - 🚀 **Simple Interface**: Easy-to-use client for all TrustModel operations
@@ -31,13 +129,24 @@ Evaluate AI models for safety, bias, and performance with a simple, intuitive in
 - 🔄 **Reliable**: Automatic retries and comprehensive error handling
 - 📊 **Comprehensive**: Support for all evaluation types and configurations
 - 🌍 **Framework Agnostic**: Works with any Python framework or standalone scripts
+- 🛰️ **Zero-Config Auto-Capture**: Add two lines (`auto_init`) and every OpenAI / Anthropic / LangChain / CrewAI / etc. call is automatically traced and evaluated
 
 ## Installation
 
+Core SDK (works on Python 3.7+):
+
 ```bash
 pip install trustmodel
 ```
 
+Add the `telemetry` extra to enable zero-config auto-capture of AI agent calls (Python 3.10+ required):
+
+```bash
+pip install "trustmodel[telemetry]"
+```
+
+The `telemetry` extra installs OpenTelemetry plus all OpenInference instrumentors (OpenAI, Anthropic, LangChain, LlamaIndex, Bedrock, Mistral, Groq, CrewAI, VertexAI, DSPy). See [Zero-Config Auto-Capture](#zero-config-auto-capture-auto_init) below.
+
 ## Prerequisites
 
 Before using the SDK, you **must** complete the following setup in the [TrustModel Dashboard](https://app.trustmodel.ai/app/keys):
@@ -1008,6 +1117,140 @@ def evaluate():
     })
 ```
 
+## Zero-Config Auto-Capture (`auto_init`)
+
+Capture every LLM and tool call your AI agent makes — without changing your existing code. Two lines, and TrustModel takes care of trace collection, batching, transport, and evaluation.
+
+### How It Works
+
+1. You call `auto_init(api_key, agent_id, ...)` once at startup.
+2. The SDK auto-detects which AI libraries you're using (OpenAI, Anthropic, LangChain, etc.) and installs an OpenInference instrumentor for each.
+3. Every subsequent LLM / tool call is captured as an OpenTelemetry span and streamed to the TrustModel gateway.
+4. The TrustModel Control Plane buffers traces server-side, groups them by `agent_id` + `domain` + `frameworks`, and runs evaluation on the schedule you configure (daily, weekly, or monthly).
+
+### Installation
+
+```bash
+pip install "trustmodel[telemetry]"
+```
+
+This installs OpenTelemetry plus the OpenInference instrumentors. **Python 3.10+ required** for the telemetry extra.
+
+If you only want the core SDK (e.g., `client.evaluations.create()`), `pip install trustmodel` works on Python 3.7+ but `auto_init` will not be available.
+
+### Quick Start
+
+```python
+from trustmodel.telemetry import auto_init
+
+auto_init(
+    api_key="tm-...",                       # your TrustModel API key
+    agent_id="my-customer-support-agent",    # any identifier you choose
+    domain="general_ai",                     # fair_lending | hr_bias | healthcare | general_ai
+    frameworks=["nist-ai-rmf"],              # one or more compliance framework slugs
+)
+
+# Your existing agent code — no changes needed
+import openai
+client = openai.OpenAI()
+client.chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+That's it. The OpenAI call is automatically captured and streamed to TrustModel.
+
+### Discovering Domains and Frameworks
+
+Use the `client.frameworks` endpoint to list available domains and the compliance frameworks within each:
+
+```python
+from trustmodel import TrustModelClient
+
+client = TrustModelClient(api_key="tm-...")
+
+# All available domains
+print(client.frameworks.list_domains())
+# ['fair_lending', 'hr_bias', 'healthcare', 'general_ai']
+
+# Frameworks for a specific domain
+for f in client.frameworks.list(domain="fair_lending"):
+    print(f"{f.slug}: {f.name} ({f.credits} credits)")
+```
+
+Use the `slug` values when calling `auto_init(frameworks=[...])`.
+
+### Supported AI Libraries
+
+`auto_init` will automatically activate instrumentation for any of these libraries that you have installed:
+
+| Library | Auto-detected via |
+|---------|-------------------|
+| OpenAI | `openinference-instrumentation-openai` |
+| Anthropic (Claude) | `openinference-instrumentation-anthropic` |
+| LangChain | `openinference-instrumentation-langchain` |
+| LlamaIndex | `openinference-instrumentation-llama-index` |
+| AWS Bedrock | `openinference-instrumentation-bedrock` |
+| Mistral AI | `openinference-instrumentation-mistralai` |
+| Groq | `openinference-instrumentation-groq` |
+| CrewAI | `openinference-instrumentation-crewai` |
+| Vertex AI | `openinference-instrumentation-vertexai` |
+| DSPy | `openinference-instrumentation-dspy` |
+
+All ten are installed by `pip install "trustmodel[telemetry]"`. The instrumentors are no-ops when the underlying library isn't being used — there's no overhead.
+
+### Existing OpenTelemetry Setup (Datadog, Jaeger, Honeycomb, Arize)
+
+If your application already has OpenTelemetry configured for another observability backend, `auto_init` detects this and **adds TrustModel as an additional exporter** rather than replacing your setup.
+
+```python
+# Your existing OTel setup (e.g., Datadog APM, Jaeger, Honeycomb)
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+provider = TracerProvider(...)
+trace.set_tracer_provider(provider)
+
+# Then add TrustModel — both backends now receive every span
+from trustmodel.telemetry import auto_init
+auto_init(api_key="tm-...", agent_id="my-agent")
+```
+
+Spans fan out to both your existing exporter and TrustModel's. Nothing in your existing pipeline is modified or replaced.
+
+### Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `api_key` | yes | Your TrustModel API key (`tm-...`) |
+| `agent_id` | yes | Any string you choose. All traces sharing this `agent_id` are grouped together for evaluation. |
+| `domain` | yes | One of `fair_lending`, `hr_bias`, `healthcare`, `general_ai`. Determines which evaluators run. |
+| `frameworks` | yes | List of compliance framework slugs (e.g., `["ecoa-regb", "fcra"]`). Use `client.frameworks.list(domain=...)` to discover. |
+| `service_name` | no | Logical service name (default: `"default"`) |
+
+### Schedule and Evaluation
+
+Configure when buffered traces are evaluated in the [Control Plane dashboard](https://app.trustmodel.ai):
+
+- **Manual** — only when you click "Trigger Evaluation Now"
+- **Daily / Weekly / Monthly** — automatically via cron at midnight UTC
+
+Each evaluation produces:
+- An overall trust score
+- Per-category breakdowns (safety, fairness, accuracy, etc.)
+- Findings and recommendations
+
+### Failure Modes (Safe by Design)
+
+`auto_init` wraps everything in `try/except`. If anything fails — missing dependencies, network issues, an instrumentor crash — your application keeps running. Telemetry is best-effort; nothing TrustModel does will break your agent.
+
+If the `[telemetry]` extras aren't installed and you try to import the telemetry module directly, you get a clear error:
+
+```
+ImportError: TrustModel telemetry requires extra dependencies.
+Install with: pip install "trustmodel[telemetry]"
+```
+
 ## Agentic Trace Evaluation
 
 Evaluate AI agent execution traces for safety, reasoning quality, tool usage, and goal completion. Upload a JSON or JSONL trace file and get scored across 14 dimensions.

trustmodel-2.1.0/PKG-INFO → trustmodel-2.2.1/README.md

@@ -1,57 +1,3 @@
-Metadata-Version: 2.4
-Name: trustmodel
-Version: 2.1.0
-Summary: Official Python SDK for TrustModel AI evaluation platform
-Project-URL: Homepage, https://trustmodel.ai
-Author-email: TrustModel <info@predixtions.com>
-License: Proprietary - TrustModel Python SDK License
-License-File: LICENSE
-Keywords: ai,api,evaluation,sdk,trustmodel
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
-Requires-Dist: eval-type-backport>=0.2.0; python_version < '3.10'
-Requires-Dist: importlib-metadata>=4.0.0; python_version < '3.8'
-Requires-Dist: pydantic<2.0.0,>=1.10.0; python_version < '3.8'
-Requires-Dist: pydantic<3.0.0,>=2.0.0; python_version >= '3.8'
-Requires-Dist: python-dateutil>=2.8.0
-Requires-Dist: requests<3.0.0,>=2.25.0
-Requires-Dist: tqdm>=4.60.0
-Requires-Dist: typing-extensions>=4.0.0
-Provides-Extra: dev
-Requires-Dist: black<23.0.0,>=22.0.0; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: black>=23.0.0; (python_version >= '3.8') and extra == 'dev'
-Requires-Dist: bump2version>=1.0.1; extra == 'dev'
-Requires-Dist: importlib-metadata>=4.0.0; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: isort<5.12.0,>=5.11.0; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: isort>=5.12.0; (python_version >= '3.8') and extra == 'dev'
-Requires-Dist: mypy<1.5.0,>=1.0.0; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: mypy>=1.5.0; (python_version >= '3.8') and extra == 'dev'
-Requires-Dist: pytest-cov<5.0.0,>=4.0.0; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: pytest-cov>=4.0.0; (python_version >= '3.8') and extra == 'dev'
-Requires-Dist: pytest<8.0.0,>=7.0.0; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: pytest>=7.0.0; (python_version >= '3.8') and extra == 'dev'
-Requires-Dist: ruff<0.1.0,>=0.0.277; (python_version < '3.8') and extra == 'dev'
-Requires-Dist: ruff>=0.1.0; (python_version >= '3.8') and extra == 'dev'
-Requires-Dist: types-requests>=2.25.0; extra == 'dev'
-Requires-Dist: types-tqdm>=4.60.0; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: sphinx-autodoc-typehints>=1.24.0; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == 'docs'
-Requires-Dist: sphinx>=7.0.0; extra == 'docs'
-Description-Content-Type: text/markdown
-
 <p align="center">
   <a href="https://www.trustmodel.ai">
     <img src="https://www.trustmodel.ai/assets/trustmodel-wordmark-CfuXSOoK.svg" alt="TrustModel" width="400">
@@ -77,6 +23,36 @@ Description-Content-Type: text/markdown
 
 Evaluate AI models for safety, bias, and performance with a simple, intuitive interface.
 
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Prerequisites](#prerequisites)
+- [Quick Start](#quick-start)
+- [Authentication](#authentication)
+- [Evaluation Modes](#evaluation-modes)
+  - [Getting Available Vendors](#getting-available-vendors)
+  - [Getting Available Models](#getting-available-models)
+  - [Platform Key (Default)](#platform-key-default)
+  - [BYOK (Bring Your Own Key)](#byok-bring-your-own-key)
+  - [Custom Endpoint](#custom-endpoint)
+- [Core Concepts](#core-concepts)
+  - [Models](#models)
+  - [Evaluations](#evaluations)
+  - [Configuration](#configuration)
+  - [Credits Management](#credits-management)
+- [Error Handling](#error-handling)
+- [Rate Limiting](#rate-limiting)
+- [Webhook Notifications](#webhook-notifications)
+- [Advanced Usage](#advanced-usage)
+- [Framework Integration](#framework-integration)
+- [Zero-Config Auto-Capture (`auto_init`)](#zero-config-auto-capture-auto_init)
+- [Agentic Trace Evaluation](#agentic-trace-evaluation)
+- [Galileo Integration](#galileo-integration)
+- [Requirements](#requirements)
+- [Support](#support)
+- [License](#license)
+
 ## Features
 
 - 🚀 **Simple Interface**: Easy-to-use client for all TrustModel operations
@@ -85,13 +61,24 @@ Evaluate AI models for safety, bias, and performance with a simple, intuitive in
 - 🔄 **Reliable**: Automatic retries and comprehensive error handling
 - 📊 **Comprehensive**: Support for all evaluation types and configurations
 - 🌍 **Framework Agnostic**: Works with any Python framework or standalone scripts
+- 🛰️ **Zero-Config Auto-Capture**: Add two lines (`auto_init`) and every OpenAI / Anthropic / LangChain / CrewAI / etc. call is automatically traced and evaluated
 
 ## Installation
 
+Core SDK (works on Python 3.7+):
+
 ```bash
 pip install trustmodel
 ```
 
+Add the `telemetry` extra to enable zero-config auto-capture of AI agent calls (Python 3.10+ required):
+
+```bash
+pip install "trustmodel[telemetry]"
+```
+
+The `telemetry` extra installs OpenTelemetry plus all OpenInference instrumentors (OpenAI, Anthropic, LangChain, LlamaIndex, Bedrock, Mistral, Groq, CrewAI, VertexAI, DSPy). See [Zero-Config Auto-Capture](#zero-config-auto-capture-auto_init) below.
+
 ## Prerequisites
 
 Before using the SDK, you **must** complete the following setup in the [TrustModel Dashboard](https://app.trustmodel.ai/app/keys):
@@ -1062,6 +1049,140 @@ def evaluate():
     })
 ```
 
+## Zero-Config Auto-Capture (`auto_init`)
+
+Capture every LLM and tool call your AI agent makes — without changing your existing code. Two lines, and TrustModel takes care of trace collection, batching, transport, and evaluation.
+
+### How It Works
+
+1. You call `auto_init(api_key, agent_id, ...)` once at startup.
+2. The SDK auto-detects which AI libraries you're using (OpenAI, Anthropic, LangChain, etc.) and installs an OpenInference instrumentor for each.
+3. Every subsequent LLM / tool call is captured as an OpenTelemetry span and streamed to the TrustModel gateway.
+4. The TrustModel Control Plane buffers traces server-side, groups them by `agent_id` + `domain` + `frameworks`, and runs evaluation on the schedule you configure (daily, weekly, or monthly).
+
+### Installation
+
+```bash
+pip install "trustmodel[telemetry]"
+```
+
+This installs OpenTelemetry plus the OpenInference instrumentors. **Python 3.10+ required** for the telemetry extra.
+
+If you only want the core SDK (e.g., `client.evaluations.create()`), `pip install trustmodel` works on Python 3.7+ but `auto_init` will not be available.
+
+### Quick Start
+
+```python
+from trustmodel.telemetry import auto_init
+
+auto_init(
+    api_key="tm-...",                       # your TrustModel API key
+    agent_id="my-customer-support-agent",    # any identifier you choose
+    domain="general_ai",                     # fair_lending | hr_bias | healthcare | general_ai
+    frameworks=["nist-ai-rmf"],              # one or more compliance framework slugs
+)
+
+# Your existing agent code — no changes needed
+import openai
+client = openai.OpenAI()
+client.chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+That's it. The OpenAI call is automatically captured and streamed to TrustModel.
+
+### Discovering Domains and Frameworks
+
+Use the `client.frameworks` endpoint to list available domains and the compliance frameworks within each:
+
+```python
+from trustmodel import TrustModelClient
+
+client = TrustModelClient(api_key="tm-...")
+
+# All available domains
+print(client.frameworks.list_domains())
+# ['fair_lending', 'hr_bias', 'healthcare', 'general_ai']
+
+# Frameworks for a specific domain
+for f in client.frameworks.list(domain="fair_lending"):
+    print(f"{f.slug}: {f.name} ({f.credits} credits)")
+```
+
+Use the `slug` values when calling `auto_init(frameworks=[...])`.
+
+### Supported AI Libraries
+
+`auto_init` will automatically activate instrumentation for any of these libraries that you have installed:
+
+| Library | Auto-detected via |
+|---------|-------------------|
+| OpenAI | `openinference-instrumentation-openai` |
+| Anthropic (Claude) | `openinference-instrumentation-anthropic` |
+| LangChain | `openinference-instrumentation-langchain` |
+| LlamaIndex | `openinference-instrumentation-llama-index` |
+| AWS Bedrock | `openinference-instrumentation-bedrock` |
+| Mistral AI | `openinference-instrumentation-mistralai` |
+| Groq | `openinference-instrumentation-groq` |
+| CrewAI | `openinference-instrumentation-crewai` |
+| Vertex AI | `openinference-instrumentation-vertexai` |
+| DSPy | `openinference-instrumentation-dspy` |
+
+All ten are installed by `pip install "trustmodel[telemetry]"`. The instrumentors are no-ops when the underlying library isn't being used — there's no overhead.
+
+### Existing OpenTelemetry Setup (Datadog, Jaeger, Honeycomb, Arize)
+
+If your application already has OpenTelemetry configured for another observability backend, `auto_init` detects this and **adds TrustModel as an additional exporter** rather than replacing your setup.
+
+```python
+# Your existing OTel setup (e.g., Datadog APM, Jaeger, Honeycomb)
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+provider = TracerProvider(...)
+trace.set_tracer_provider(provider)
+
+# Then add TrustModel — both backends now receive every span
+from trustmodel.telemetry import auto_init
+auto_init(api_key="tm-...", agent_id="my-agent")
+```
+
+Spans fan out to both your existing exporter and TrustModel's. Nothing in your existing pipeline is modified or replaced.
+
+### Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `api_key` | yes | Your TrustModel API key (`tm-...`) |
+| `agent_id` | yes | Any string you choose. All traces sharing this `agent_id` are grouped together for evaluation. |
+| `domain` | yes | One of `fair_lending`, `hr_bias`, `healthcare`, `general_ai`. Determines which evaluators run. |
+| `frameworks` | yes | List of compliance framework slugs (e.g., `["ecoa-regb", "fcra"]`). Use `client.frameworks.list(domain=...)` to discover. |
+| `service_name` | no | Logical service name (default: `"default"`) |
+
+### Schedule and Evaluation
+
+Configure when buffered traces are evaluated in the [Control Plane dashboard](https://app.trustmodel.ai):
+
+- **Manual** — only when you click "Trigger Evaluation Now"
+- **Daily / Weekly / Monthly** — automatically via cron at midnight UTC
+
+Each evaluation produces:
+- An overall trust score
+- Per-category breakdowns (safety, fairness, accuracy, etc.)
+- Findings and recommendations
+
+### Failure Modes (Safe by Design)
+
+`auto_init` wraps everything in `try/except`. If anything fails — missing dependencies, network issues, an instrumentor crash — your application keeps running. Telemetry is best-effort; nothing TrustModel does will break your agent.
+
+If the `[telemetry]` extras aren't installed and you try to import the telemetry module directly, you get a clear error:
+
+```
+ImportError: TrustModel telemetry requires extra dependencies.
+Install with: pip install "trustmodel[telemetry]"
+```
+
 ## Agentic Trace Evaluation
 
 Evaluate AI agent execution traces for safety, reasoning quality, tool usage, and goal completion. Upload a JSON or JSONL trace file and get scored across 14 dimensions.

{trustmodel-2.1.0 → trustmodel-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trustmodel"
-version = "2.1.0"
+version = "2.2.1"
 authors = [
     {name = "TrustModel", email = "info@predixtions.com"},
 ]
@@ -40,6 +40,24 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+# Auto-capture AI agent traces and stream them to TrustModel.
+# Install with: pip install "trustmodel[telemetry]"
+# Requires Python 3.10+ because several OpenInference instrumentors do.
+telemetry = [
+    "opentelemetry-api>=1.20.0; python_version>='3.10'",
+    "opentelemetry-sdk>=1.20.0; python_version>='3.10'",
+    "opentelemetry-exporter-otlp-proto-http>=1.20.0; python_version>='3.10'",
+    "openinference-instrumentation-openai>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-anthropic>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-langchain>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-llama-index>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-bedrock>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-mistralai>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-groq>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-crewai>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-vertexai>=0.1.0; python_version>='3.10'",
+    "openinference-instrumentation-dspy>=0.1.0; python_version>='3.10'",
+]
 dev = [
     "pytest>=7.0.0,<8.0.0; python_version<'3.8'",
     "pytest>=7.0.0; python_version>='3.8'",
@@ -119,6 +137,15 @@ strict_equality = true
 module = "tests.*"
 disallow_untyped_defs = false
 
+[[tool.mypy.overrides]]
+# Optional telemetry deps — installed via [telemetry] extra. CI runs mypy
+# without these installed, so suppress missing-import errors.
+module = [
+    "opentelemetry.*",
+    "openinference.*",
+]
+ignore_missing_imports = true
+
 [tool.ruff]
 target-version = "py37"
 line-length = 100
@@ -159,6 +186,12 @@ source = ["src/trustmodel"]
 omit = [
     "*/tests/*",
     "*/test_*",
+    # Telemetry code paths require real OTel runtime + live OpenInference
+    # instrumentors to exercise meaningfully — covered by integration tests
+    # in trus638-testing rather than unit tests here.
+    "*/telemetry/*",
+    "*/endpoints/frameworks.py",
+    "*/models/frameworks.py",
 ]
 
 [tool.coverage.report]

{trustmodel-2.1.0 → trustmodel-2.2.1}/src/trustmodel/__init__.py

@@ -30,6 +30,17 @@ try:
 except PackageNotFoundError:
     # Package not installed, use fallback
     __version__ = "0.1.0"
+
+# Telemetry (auto_init) is an optional feature.
+# Install with: pip install "trustmodel[telemetry]"
+# If telemetry deps are missing, importing the SDK still works.
+try:
+    from .telemetry import auto_init  # noqa: F401
+
+    _HAS_TELEMETRY = True
+except ImportError:
+    _HAS_TELEMETRY = False
+
 __all__ = [
     "TrustModelClient",
     "TrustModelError",
@@ -40,3 +51,5 @@ __all__ = [
     "InsufficientCreditsError",
     "ConnectionValidationError",
 ]
+if _HAS_TELEMETRY:
+    __all__.append("auto_init")

{trustmodel-2.1.0 → trustmodel-2.2.1}/src/trustmodel/client.py

@@ -18,6 +18,7 @@ from .endpoints.batch_jobs import BatchJobsEndpoint
 from .endpoints.config import ConfigEndpoint
 from .endpoints.credits import CreditsEndpoint
 from .endpoints.evaluations import EvaluationsEndpoint
+from .endpoints.frameworks import FrameworksEndpoint
 from .endpoints.galileo import GalileoEndpoint
 from .endpoints.models import ModelsEndpoint
 from .exceptions import (
@@ -120,6 +121,7 @@ class TrustModelClient:
         self.batch_jobs = BatchJobsEndpoint(self)
         self.agentic = AgenticEndpoint(self)
         self.galileo = GalileoEndpoint(self)
+        self.frameworks = FrameworksEndpoint(self)
 
     def _request(
         self,

trustmodel-2.2.1/src/trustmodel/endpoints/frameworks.py

@@ -0,0 +1,94 @@
+"""
+Frameworks endpoint wrapper for the TrustModel SDK.
+
+Lets users discover available compliance frameworks and domains
+for use with `auto_init(domain=..., frameworks=[...])`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from ..models.frameworks import Framework
+
+if TYPE_CHECKING:
+    from ..client import TrustModelClient
+
+
+# Hardcoded list mirrors EvaluationSubTypeChoices on the backend.
+# Update if backend adds new domains.
+_KNOWN_DOMAINS = [
+    "fair_lending",
+    "hr_bias",
+    "healthcare",
+    "general_ai",
+]
+
+
+class FrameworksEndpoint:
+    """
+    Interface for compliance framework discovery.
+
+    Frameworks are organized by domain (framework_type). Use these methods
+    to discover what's available before calling auto_init().
+
+    Example:
+        >>> client = TrustModelClient(api_key="tm-...")
+        >>> domains = client.frameworks.list_domains()
+        >>> # ['fair_lending', 'hr_bias', 'healthcare', 'general_ai']
+        >>> frameworks = client.frameworks.list(domain="fair_lending")
+        >>> for f in frameworks:
+        ...     print(f"{f.slug}: {f.name}")
+    """
+
+    def __init__(self, client: TrustModelClient) -> None:
+        self._client = client
+
+    def list_domains(self) -> List[str]:
+        """
+        Get list of available domain identifiers.
+
+        Returns:
+            List of domain strings. Pass any of these as `domain` to
+            `auto_init()` or as the `?framework_type=...` query parameter.
+
+        Example:
+            >>> client.frameworks.list_domains()
+            ['fair_lending', 'hr_bias', 'healthcare', 'general_ai']
+        """
+        return list(_KNOWN_DOMAINS)
+
+    def list(self, domain: Optional[str] = None) -> List[Framework]:
+        """
+        List available compliance frameworks.
+
+        Args:
+            domain: Optional domain filter (e.g., 'fair_lending'). If omitted,
+                    returns all active frameworks across all domains.
+
+        Returns:
+            List of Framework objects. Use the `slug` field as the framework
+            identifier when calling auto_init(frameworks=[...]).
+
+        Example:
+            >>> frameworks = client.frameworks.list(domain="fair_lending")
+            >>> auto_init(
+            ...     api_key="tm-...",
+            ...     agent_id="my-agent",
+            ...     domain="fair_lending",
+            ...     frameworks=[f.slug for f in frameworks[:2]],
+            ... )
+        """
+        params = {}
+        if domain:
+            params["framework_type"] = domain
+
+        response: Any = self._client.get("/api/agent-evaluation/frameworks/", params=params)
+
+        # API may return a list or a paginated object {results: [...]}
+        if isinstance(response, list):
+            items = response
+        else:
+            items = response.get("results", [])
+
+        return [Framework(**item) for item in items]

{trustmodel-2.1.0 → trustmodel-2.2.1}/src/trustmodel/models/evaluation.py

@@ -18,6 +18,7 @@ class EvaluationStatus(str, Enum):
     RUNNING = "running"
     COMPLETED = "completed"
     FAILED = "failed"
+    PAYMENT_PENDING = "payment_pending"
 
 
 class ApplicationType(str, Enum):
@@ -30,6 +31,8 @@ class ApplicationType(str, Enum):
     CLASSIFICATION = "classification"
     CODE_GENERATION = "code_generation"
     TRANSLATION = "translation"
+    EVALUATION_WIZARD = "evaluation_wizard"
+    AUTOMATION_AGENT = "automation-agent"
 
 
 class UserPersona(str, Enum):
@@ -143,9 +146,9 @@ class Evaluation(BaseModel):
     status: EvaluationStatus
     model_identifier: str
     vendor_identifier: Optional[str] = None
-    model_config_name: str
-    application_type: ApplicationType
-    user_personas: List[str]
+    model_config_name: Optional[str] = None
+    application_type: Optional[ApplicationType] = None
+    user_personas: Optional[List[str]] = None
     application_description: Optional[str] = None
     domain_expert_description: Optional[str] = None
     completion_percentage: int = Field(..., ge=0, le=100)

trustmodel-2.2.1/src/trustmodel/models/frameworks.py

@@ -0,0 +1,27 @@
+"""Pydantic models for compliance frameworks."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class Framework(BaseModel):
+    """A compliance framework that can be selected for evaluation."""
+
+    id: str
+    name: str
+    subtitle: Optional[str] = ""
+    slug: str
+    description: Optional[str] = ""
+    credits: Decimal = Field(default=Decimal("0"))
+    framework_type: Optional[str] = Field(
+        default=None,
+        description="Domain classification (fair_lending, hr_bias, healthcare, general_ai)",
+    )
+
+    class Config:
+        # allow extra fields from API to not fail
+        extra = "allow"

trustmodel-2.2.1/src/trustmodel/telemetry/__init__.py

@@ -0,0 +1,22 @@
+"""
+TrustModel Telemetry — auto-capture AI agent calls via OpenTelemetry.
+
+Requires the `telemetry` extra:
+    pip install "trustmodel[telemetry]"
+
+Usage:
+    from trustmodel.telemetry import auto_init
+    auto_init(api_key="tm-...", agent_id="my-agent")
+"""
+
+try:
+    import opentelemetry  # noqa: F401
+except ImportError as exc:
+    raise ImportError(
+        "TrustModel telemetry requires extra dependencies. "
+        'Install with: pip install "trustmodel[telemetry]"'
+    ) from exc
+
+from .auto_init import auto_init, flush
+
+__all__ = ["auto_init", "flush"]

trustmodel-2.2.1/src/trustmodel/telemetry/_constants.py

@@ -0,0 +1,33 @@
+"""
+OpenInference semantic convention attribute keys.
+
+Reference for the OTLP → agentic trace converter on the gateway side.
+"""
+
+# Span classification
+OPENINFERENCE_SPAN_KIND = "openinference.span.kind"
+
+# LLM attributes
+LLM_MODEL_NAME = "llm.model_name"
+LLM_TOKEN_COUNT_PROMPT = "llm.token_count.prompt"
+LLM_TOKEN_COUNT_COMPLETION = "llm.token_count.completion"
+LLM_OUTPUT_MESSAGES = "llm.output_messages"
+LLM_INPUT_MESSAGES = "llm.input_messages"
+LLM_INVOCATION_PARAMETERS = "llm.invocation_parameters"
+
+# Tool attributes
+TOOL_NAME = "tool.name"
+TOOL_PARAMETERS = "tool.parameters"
+TOOL_DESCRIPTION = "tool.description"
+
+# I/O attributes
+INPUT_VALUE = "input.value"
+INPUT_MIME_TYPE = "input.mime_type"
+OUTPUT_VALUE = "output.value"
+OUTPUT_MIME_TYPE = "output.mime_type"
+
+# Retriever attributes
+RETRIEVAL_DOCUMENTS = "retrieval.documents"
+
+# Embedding attributes
+EMBEDDING_MODEL_NAME = "embedding.model_name"

trustmodel-2.2.1/src/trustmodel/telemetry/_instrumentors.py

@@ -0,0 +1,53 @@
+"""
+Auto-detect and install OpenInference instrumentors.
+
+Each instrumentor wraps a specific AI library (OpenAI, Anthropic, LangChain, etc.)
+to emit OTel spans with OpenInference semantic attributes.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+# (module_path, class_name) — order doesn't matter
+_KNOWN_INSTRUMENTORS = [
+    ("openinference.instrumentation.openai", "OpenAIInstrumentor"),
+    ("openinference.instrumentation.anthropic", "AnthropicInstrumentor"),
+    ("openinference.instrumentation.langchain", "LangChainInstrumentor"),
+    ("openinference.instrumentation.llama_index", "LlamaIndexInstrumentor"),
+    ("openinference.instrumentation.bedrock", "BedrockInstrumentor"),
+    ("openinference.instrumentation.mistralai", "MistralAIInstrumentor"),
+    ("openinference.instrumentation.groq", "GroqInstrumentor"),
+    ("openinference.instrumentation.crewai", "CrewAIInstrumentor"),
+    ("openinference.instrumentation.vertexai", "VertexAIInstrumentor"),
+    ("openinference.instrumentation.dspy", "DSPyInstrumentor"),
+]
+
+
+def install_instrumentors() -> List[str]:
+    """
+    Attempt to import and instrument each known OpenInference instrumentor.
+
+    Only instrumentors whose packages are installed will be activated.
+    Failures are logged and silently skipped — never crash the customer's app.
+
+    Returns:
+        List of successfully installed instrumentor names.
+    """
+    installed = []
+    for module_path, class_name in _KNOWN_INSTRUMENTORS:
+        try:
+            module = __import__(module_path, fromlist=[class_name])
+            instrumentor_cls = getattr(module, class_name)
+            instrumentor_cls().instrument()
+            installed.append(class_name)
+            logger.debug("TrustModel telemetry: installed %s", class_name)
+        except ImportError:
+            # Package not installed — expected, skip silently
+            pass
+        except Exception:
+            logger.debug("TrustModel telemetry: failed to install %s", class_name, exc_info=True)
+    return installed

trustmodel-2.2.1/src/trustmodel/telemetry/auto_init.py

@@ -0,0 +1,289 @@
+"""
+auto_init() — 2-line setup for automatic AI agent trace capture.
+
+Usage:
+    from trustmodel.telemetry import auto_init
+    auto_init(api_key="tm-...", agent_id="my-weather-agent")
+
+    # All subsequent OpenAI/Anthropic/LangChain calls are now traced.
+"""
+
+from __future__ import annotations
+
+import atexit
+import logging
+import uuid as _uuid
+from typing import TYPE_CHECKING, Any, List, Optional
+
+if TYPE_CHECKING:
+    from opentelemetry.sdk.trace import TracerProvider as SDKTracerProvider
+
+logger = logging.getLogger(__name__)
+
+_initialized = False
+_tracer_provider: Optional[SDKTracerProvider] = None
+
+ENVIRONMENT_URLS = {
+    "local": "http://localhost:8000",
+    "qa": "https://api-trustmodel.pdxqa.com",
+    "production": "https://api.trustmodel.ai",
+}
+
+
+def auto_init(
+    api_key: str,
+    *,
+    agent_id: str,
+    domain: str,
+    frameworks: List[str],
+    service_name: str = "default",
+    environment: str = "production",
+    base_url: Optional[str] = None,
+) -> List[str]:
+    """
+    Initialize automatic OTel trace capture and export to TrustModel.
+
+    Safe to call from any Python app — wraps everything in try/except
+    so it never crashes the customer's application.
+
+    Args:
+        api_key: TrustModel API key (tm-...).
+        agent_id: Unique identifier for this agent. All traces are grouped
+                  and evaluated per agent_id.
+        domain: Domain classification — one of 'fair_lending', 'hr_bias',
+                'healthcare', 'general_ai'. Required. Use
+                TrustModelClient.frameworks.list_domains() to discover.
+        frameworks: List of compliance framework slugs (e.g.,
+                ['eu-ai-act-high-risk', 'iso-42001']). Required and must
+                be non-empty. Use TrustModelClient.frameworks.list(domain=...)
+                to discover available slugs.
+        service_name: Logical service name for this application.
+        environment: One of 'local', 'qa', 'production'.
+        base_url: Explicit base URL (overrides environment).
+
+    Returns:
+        List of instrumentor names that were successfully installed.
+
+    Raises:
+        ValueError: If `domain` is empty or `frameworks` is empty/missing.
+    """
+    global _initialized, _tracer_provider
+
+    if not domain:
+        raise ValueError("auto_init() requires a non-empty 'domain' argument.")
+    if not frameworks:
+        raise ValueError(
+            "auto_init() requires a non-empty 'frameworks' list. "
+            "Use TrustModelClient.frameworks.list(domain=...) to discover slugs."
+        )
+
+    if _initialized:
+        logger.debug("TrustModel telemetry already initialized, skipping.")
+        return []
+
+    try:
+        return _do_init(api_key, agent_id, domain, frameworks, service_name, environment, base_url)
+    except Exception:
+        logger.debug("TrustModel telemetry: auto_init failed", exc_info=True)
+        return []
+
+
+def _do_init(
+    api_key: str,
+    agent_id: str,
+    domain: str,
+    frameworks: List[str],
+    service_name: str,
+    environment: str,
+    base_url: Optional[str],
+) -> List[str]:
+    global _initialized, _tracer_provider
+
+    from opentelemetry import trace
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+    session_id = str(_uuid.uuid4())
+
+    # Resolve endpoint — with explicit endpoint param, the exporter
+    # does NOT append /v1/traces, so we include the full path.
+    if base_url:
+        endpoint = base_url.rstrip("/") + "/sdk/v1/otel/v1/traces"
+    else:
+        if environment not in ENVIRONMENT_URLS:
+            raise ValueError(
+                f"Invalid environment '{environment}'. "
+                f"Must be one of: {', '.join(ENVIRONMENT_URLS)}"
+            )
+        endpoint = ENVIRONMENT_URLS[environment] + "/sdk/v1/otel/v1/traces"
+
+    exporter = OTLPSpanExporter(
+        endpoint=endpoint,
+        headers={"X-API-Key": api_key},
+    )
+
+    # Normalize domain + frameworks (both required, validated upstream)
+    domain_str = domain
+    frameworks_str = ",".join(frameworks)
+
+    # Wrap exporter so agent_id + session_id + domain + frameworks are always
+    # injected as resource attributes, even when piggybacking on a customer's
+    # existing TracerProvider.
+    wrapped_exporter = _make_trustmodel_exporter(
+        exporter, agent_id, session_id, domain_str, frameworks_str
+    )
+    processor = BatchSpanProcessor(wrapped_exporter)
+
+    current_provider = trace.get_tracer_provider()
+
+    if isinstance(current_provider, TracerProvider):
+        # Customer already has OTel set up — just add our exporter
+        current_provider.add_span_processor(processor)
+        _tracer_provider = current_provider
+        logger.debug("TrustModel telemetry: added exporter to existing TracerProvider")
+    else:
+        # No existing OTel — create our own provider
+        resource_attrs = {
+            "service.name": service_name,
+            "trustmodel.agent_id": agent_id,
+            "trustmodel.session_id": session_id,
+        }
+        if domain_str:
+            resource_attrs["trustmodel.domain"] = domain_str
+        if frameworks_str:
+            resource_attrs["trustmodel.frameworks"] = frameworks_str
+        resource = Resource.create(resource_attrs)
+        provider = TracerProvider(resource=resource)
+        provider.add_span_processor(processor)
+        trace.set_tracer_provider(provider)
+        _tracer_provider = provider
+        logger.debug("TrustModel telemetry: created new TracerProvider")
+
+    # Auto-detect and install instrumentors
+    from ._instrumentors import install_instrumentors
+
+    installed = install_instrumentors()
+
+    _initialized = True
+    atexit.register(_shutdown)
+
+    if installed:
+        logger.info("TrustModel telemetry: active — instrumentors: %s", ", ".join(installed))
+    else:
+        logger.info(
+            "TrustModel telemetry: active — no instrumentors found (install openinference-instrumentation-*)"
+        )
+
+    return installed
+
+
+def flush(
+    api_key: str,
+    *,
+    environment: str = "production",
+    base_url: Optional[str] = None,
+) -> None:
+    """
+    Flush buffered OTel traces to trigger evaluation.
+
+    Call this when the agent session is complete.
+
+    Args:
+        api_key: TrustModel API key.
+        environment: One of 'local', 'qa', 'production'.
+        base_url: Explicit base URL (overrides environment).
+    """
+    import requests
+
+    if base_url:
+        url = base_url.rstrip("/") + "/sdk/v1/otel/v1/flush"
+    else:
+        url = (
+            ENVIRONMENT_URLS.get(environment, ENVIRONMENT_URLS["production"])
+            + "/sdk/v1/otel/v1/flush"
+        )
+
+    # Force-flush any pending spans first
+    if _tracer_provider is not None:
+        try:
+            _tracer_provider.force_flush(timeout_millis=5000)
+        except Exception:
+            logger.debug("TrustModel telemetry: force_flush failed", exc_info=True)
+
+    response = requests.post(
+        url,
+        headers={"X-API-Key": api_key, "Content-Type": "application/json"},
+        json={},
+        timeout=30,
+    )
+    response.raise_for_status()
+    data = response.json()
+    logger.info(
+        "TrustModel telemetry: flushed %d evaluation(s)",
+        data.get("count", 0),
+    )
+
+
+def _make_trustmodel_exporter(
+    inner_exporter: Any,
+    agent_id: str,
+    session_id: str,
+    domain: str = "",
+    frameworks: str = "",
+) -> Any:
+    """
+    Build a SpanExporter subclass that wraps the inner exporter and injects
+    TrustModel resource attributes on every exported span. Implemented as a
+    factory so SpanExporter can be a runtime base class without polluting
+    module-level imports (telemetry extras may be missing at import time).
+    """
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace.export import SpanExporter as _SpanExporter
+
+    class _TrustModelExporter(_SpanExporter):
+        def __init__(self) -> None:
+            self._inner = inner_exporter
+            self._agent_id = agent_id
+            self._session_id = session_id
+            self._domain = domain
+            self._frameworks = frameworks
+
+        def export(self, spans):  # type: ignore[no-untyped-def]
+            attrs = {
+                "trustmodel.agent_id": self._agent_id,
+                "trustmodel.session_id": self._session_id,
+            }
+            if self._domain:
+                attrs["trustmodel.domain"] = self._domain
+            if self._frameworks:
+                attrs["trustmodel.frameworks"] = self._frameworks
+            patched_resource = Resource.create(attrs)
+
+            patched = []
+            for span in spans:
+                merged = span.resource.merge(patched_resource)
+                span._resource = merged
+                patched.append(span)
+
+            return self._inner.export(patched)
+
+        def shutdown(self) -> None:
+            self._inner.shutdown()
+
+        def force_flush(self, timeout_millis: int = 30000) -> bool:
+            if hasattr(self._inner, "force_flush"):
+                return bool(self._inner.force_flush(timeout_millis))
+            return True
+
+    return _TrustModelExporter()
+
+
+def _shutdown() -> None:
+    """Graceful shutdown — flush pending spans on process exit."""
+    if _tracer_provider is not None:
+        try:
+            _tracer_provider.shutdown()
+        except Exception:
+            pass