> ## Documentation Index
> Fetch the complete documentation index at: https://docs.impact.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Python integration catalogue

> Check Python capture owners, versions, operation boundaries and limits.

`runtime.status().integration_details` reports each operation set's support state, exact package versions,
activation, limitations and suggested fixes for the installed artifact. For `impact==1.2.0rc10`, the catalogue
entries below are **Unassessed** as whole operation sets. The [quickstart](https://docs.impact.ai/quickstart.md#python-example) uses
synchronous OpenAI Responses on the public route. A narrower observed profile covers synchronous Responses and
Chat Completions calls and caller-consumed Chat streaming with OpenAI 3.46.0 on Python 3.11.18 and 3.14.10,
plus a synchronous application-owned tool inside a logical request on Python 3.14.10. Verify the matching
operation in your Product to confirm capture, admission and readback.

## Activation

Automatic integrations default to `"auto"`. To keep an installed owner under application control, disable its
Impact integration. Set the route with [normal setup](https://docs.impact.ai/sdk/python/setup.md#application-startup) before running
this example.

```python theme={null}
import impact

runtime = impact.init(
    service_name="support-agent",
    integrations=impact.IntegrationOptions(
        openai="disabled",
        langchain="disabled",
    ),
)
```

The other integration keys are `google`, `google_adk`, `anthropic`, `openai_agents`, `llama_index`, `agno`,
`pydantic_ai`, `aws_bedrock`, `microsoft_agent_framework` and `mcp`. Selections are frozen, appear in
`status().integrations` and form part of initialization identity. Repeated `init()` calls must use equivalent
selections. Realtime uses [explicit attachment](#openai-realtime-attachment) to the application-owned
connection.

A single paid call can produce distinct framework and provider spans. Existing customer instrumentation and
destinations remain customer-owned.

The base package includes the retained capture machinery and a compatible `websockets` 15–17 transport. It
installs upstream capture owners where needed and adapts native client telemetry where the client supplies it.
Provider clients, application frameworks and the MCP SDK remain application-owned. `impact.init()` checks for
those customer libraries without importing absent or disabled integrations and activates only the applicable
owners.

See [dependency compatibility](https://docs.impact.ai/sdk/python/setup.md#dependency-compatibility) for separate Google and ADK extras.
The OpenAI Realtime convenience extra retains its native websockets `<16` bound.

See the setup instructions for [LlamaIndex](#llamaindex-setup), [PydanticAI](#pydanticai-setup) or
[Microsoft Agent Framework](#microsoft-agent-framework-setup).

## Operation catalogue

### OpenAI and Anthropic

#### OpenAI background, resumed and media operations

`py.openai.extended.v1` · `openai 3.46.0` · Impact supplement

`openai.responses.create(background=true)`, `openai.responses.retrieve`, `openai.responses.cancel`,
`openai.responses.retrieve(stream=true,starting_after)`, `openai.images.generate`, `openai.images.edit`,
`openai.audio.speech.create`, `openai.audio.transcriptions.create`, `openai.audio.translations.create`.

Provider resumed-stream replay can stall before headers/events even after normal completion. Public OpenAI
route only. Azure, Foundry and compatible-route extensions are outside this operation set. Unread raw/media
bodies remain unobserved. Background operation availability and media model entitlement belong to the
provider.

#### OpenAI public inference

`py.openai.public.v1` · OpenAI `3.46.0` · official owner `1.3b0` plus Impact supplement

Responses, Chat Completions and Embeddings create, including sync and async unary calls, selected helpers and
consumed streams.

Raw response bodies that the application does not parse or consume do not expose semantic output.

#### Azure OpenAI

`py.openai.azure.v1` · `AzureOpenAI` with `openai` 3.46.0 and OpenTelemetry GenAI OpenAI `1.3b0` plus the
Impact supplement

Responses, Chat Completions and Embeddings create.

Deployment, API version, credentials, region and entitlement remain customer-owned.

#### Microsoft Foundry

`py.openai.foundry.v1` · Standard OpenAI client at an explicit Foundry endpoint

Responses, Chat Completions and Embeddings create.

No Foundry project, resource, retrieval, Search or control-plane claim.

#### OpenAI-compatible routes

`py.openai.compatible.v1` · Standard OpenAI client at an explicit private/local base URL

Responses, Chat Completions and Embeddings create.

No arbitrary dialect, named vendor, tool, stream or usage compatibility follows.

#### Anthropic Messages

`py.anthropic.public.v1` · Anthropic `2.6.0` · native tracing plus Impact outgoing-copy supplement

Messages create/stream, typed parse, sync/async consumed streams.

Public Messages only. Explicit native content mode and post-init clients for enrichment. Native citation and
opaque-output omissions remain. Incomplete or unknown native endings retain that outcome. Claude on Google
Cloud is not supported.

### Google and ADK

#### Google Interactions background and resumed operations

`py.google.background.v1` · `google-genai 3.0.0` · Developer API v1beta · Impact supplement

`google.interactions.create(background=true,store=true)`, later `google.interactions.get(stream=false)`, then
`google.interactions.get(stream=true,last_event_id)`.

Developer API background creation and application-driven terminal/reconnected observation with
`gemini-3.7-flash`. No SDK polling or resume orchestration. Availability remains model-owned. Cancel/delete
belong to the base Interactions claim. Built-in agents and Vertex Interactions are outside this operation set.

#### Google Gen AI Models via Developer API

`py.google.models.developer.v1` · Google Gen AI `3.0.0` · official owner `1.3b0` plus Impact supplement

`generate_content`, `generate_content_stream`, `embed_content`.

Already-constructed clients cannot be discovered through the public SDK.

#### Google Gen AI Models via Vertex AI

`py.google.models.vertex.v1` · Vertex-configured Google Gen AI `3.0.0` client · official owner `1.3b0` plus
Impact supplement

`generate_content`, `generate_content_stream`, `embed_content`.

Project, location, ADC and model entitlement remain customer/cloud responsibilities.

#### Google Interactions via Developer API

`py.google.interactions.v1` · Google Gen AI `3.0.0` · Developer API · official owner plus Impact lifecycle
supplement

model create/stream/tool continuation plus application-called get/cancel/delete.

Background/reconnect and unary built-in-agent create have separate exact claims. Agent streaming/lifecycle and
Vertex require independent evidence.

#### Google Interactions built-in agent creation

`py.google.interactions.agent-create.v1` · Google Gen AI `3.0.0` · Developer API · retained client-response
owner

application-called unary `interactions.create(agent=...)`.

Available native agent/interaction/environment IDs, code call/result, native status and separate explicit
input/output/thought/total usage. Native incomplete stays incomplete. No inferred final answer/thought text,
local execution span, SDK polling/continuation, agent stream/get/cancel/delete parity or hosted telemetry
acquisition.

#### Google ADK Runner

`py.google-adk.runner.v1` · Google ADK `2.14.1`, Gen AI `2.34.0`, OpenTelemetry SDK `1.45.2` · Impact runner
events plus provider owner

`Runner.run` and `run_async`, including model/tool/session events.

Impact supplies native telemetry defaults when `RunConfig.telemetry` is unset and preserves an explicit
application value. Shutdown marks the observation partial and stops capture without closing the native
iterator. JSON-native action state deltas are retained without invoking ADK serializers. Custom-serialized
`long_running_tool_ids` are omitted and reported as partial.

### Amazon Bedrock

#### Bedrock Nova InvokeModel

`py.bedrock.invoke.v1` · `boto3 1.43.126`, `botocore 1.43.126` · Impact supplement

`bedrock-runtime.InvokeModel(Nova)`, `bedrock-runtime.InvokeModelWithResponseStream(Nova)`.

This claim covers the selected Nova dialects. Claude through Bedrock, ApplyGuardrail, Agents, aiobotocore and
other partner dialects are unassessed. Caller-stopped or incomplete streams remain partial. Partial content
policy never reads an opaque body ahead.

#### Bedrock Knowledge Bases

`py.bedrock.knowledge-bases.v1` · `boto3 1.43.126`, `botocore 1.43.126` · Impact supplement

`bedrock-agent-runtime.Retrieve`, `bedrock-agent-runtime.RetrieveAndGenerate`.

Application-called Knowledge Base retrieval/generation. Agent orchestration, source crawling and extra
retrieval remain unassessed. Cloud Knowledge Base access and model entitlement remain application-owned.

#### Bedrock Converse

`py.bedrock.converse.v1` · Boto3/Botocore `1.43.126` · Botocore owner `0.66b2` plus Impact supplement

Converse and caller-consumed ConverseStream.

Nova InvokeModel and Knowledge Base operations have separate claims. ApplyGuardrail, aiobotocore and partner
dialects remain unassessed.

### Frameworks and MCP

#### MCP server tools

`py.mcp.server-tools.v1` · `mcp 2.3.0` · Impact supplement

`mcp.server.tools.call`.

Initialize Impact before server construction and handler registration over stdio and Streamable HTTP. Existing
pre-init servers, resources, prompts and custom transports are unassessed. No SDK-owned connection or
invocation.

#### LangChain and LangGraph

`py.langgraph.langchain.v1` · LangChain `1.4.9`, core `1.7.6`, OpenAI adapter `1.7.4`, LangGraph `1.2.20` ·
official owner `1.3b0`

runnable/graph unary, graph stream, tools and retrieval.

Live hooks expose semantic output and provider identity, while raw SSE remains unavailable. Framework and
provider IDs may differ.

#### LlamaIndex

`py.llama-index.agent-rag.v1` · LlamaIndex core `0.14.25`, workflows `2.26.1`, instrumentation `0.6.0` ·
official owner `1.3b0` plus outgoing-copy supplement

awaited nonstream `FunctionAgent.run`, async `TextNode` retrieval and actual `FunctionTool.acall`.

Streaming, custom node subclasses, rerankers and other agent/workflow families remain unassessed.

##### LlamaIndex setup

Install base `impact` beside the application's native dependencies, or use the optional `llama-index` extra to
select the core, workflows and instrumentation versions above. Choose the model connector and provider client
in the application. The selected connector `llama-index-llms-openai==0.8.3` uses `openai==2.54.0` in this
application tuple. Install base `impact` with those dependencies; the OpenAI 3.46 convenience extra conflicts
with this connector.

Initialize Impact before constructing agent, model or retrieval work. Set
`IntegrationOptions(llama_index="disabled")` to leave this owner inactive.

Available returned text, identity, metadata and score enrich only Impact outgoing copies. Enrichment is
bounded to 64 documents, 1 MiB per observed span and 16 MiB across 4,096 pending spans. A pre-existing
customer owner keeps its native content choices. Impact omits source references containing query, fragment
or userinfo components and never fetches referenced content.

#### OpenAI Agents

`py.openai-agents.runner.v1` · OpenAI Agents `0.24.0` · official owner `1.3b0` plus provider owner

run, run\_sync, run\_streamed, including tools and handoffs.

The Runner result owns delivered final output and aggregate usage. A provider child need not expose either
independently.

#### Agno

`py.agno.agent.v1` · Agno `3.1.12` · official owner `1.3b0` plus Impact stream supplement

`Agent.run`/`arun`, unary and caller-consumed sync/async streams.

Team and Workflow are unassessed. Shutdown leaves native streams usable but observation partial.

#### PydanticAI

`py.pydantic-ai.agent.v1` · PydanticAI slim `2.66.0` · native instrumentation plus provider owner

Agent run, run\_sync and run\_stream.

##### PydanticAI setup

When the selected PydanticAI peer is installed, `impact.init()` automatically activates the framework's global
instrumentation default with Impact's tracer and content settings. Construct agents after `init()` to use
that default. Existing enabled global instrumentation and explicit per-Agent settings, including
`instrument=False`, remain authoritative. For explicit per-Agent setup, import `instrumentation_capabilities`
from `impact.integrations.pydantic_ai`.

PydanticAI uses the same global `False` value for its untouched default and for `Agent.instrument_all(False)`.
Impact cannot distinguish those states. To prevent Impact from activating PydanticAI across the process, use
`impact.init(integrations=impact.IntegrationOptions(pydantic_ai="disabled"))`. Calling
`Agent.instrument_all(False)` before ordinary Impact initialization does not provide that opt-out.

Add an enclosing `impact.span` only when the application wants to name and correlate a larger execution
boundary that PydanticAI cannot infer. Native PydanticAI metric export remains customer-owned.

#### Microsoft Agent Framework

`py.microsoft-agent-framework.v1` · Agent Framework core `1.24.0`, OpenAI adapter `1.18.0`, orchestrations
`1.4.1` · native telemetry plus Impact supplement

`Agent.run(stream=False|True)` and `Workflow.run(stream=False|True)`, tools and selected orchestration.

Core 1.19 through 1.22, unselected combinations, cross-task consumption, buffered streams/blocking gates and
durable checkpoint restoration remain unassessed.

##### Microsoft Agent Framework setup

Existing MAF applications install base `impact` beside their own compatible framework dependencies. For a
new application, `impact[microsoft-agent-framework]` selects the core, OpenAI adapter and orchestrations
versions above. This OpenAI adapter uses the Responses API through its public `OpenAIChatClient`.

MAF defaults to metadata-only telemetry: `OBSERVABILITY_SETTINGS.enable_sensitive_data` is `False`. Impact
preserves that setting for native telemetry and its own supplements, including customer destinations.
Available model, response identity, usage and outcome facts remain observable. Message, tool, routing and
workflow content requires an explicit native opt-in. Suppressed Impact facets use
`omitted.native-sensitive-data` capture markers. Keep native `False` when content is unwanted.

For an application that intentionally captures content, set `ENABLE_SENSITIVE_DATA=true` before starting
Python, or use the framework's public API before `impact.init()`:

```python theme={null}
from agent_framework.observability import enable_sensitive_telemetry
import impact

enable_sensitive_telemetry()
runtime = impact.init(service_name="maf-app")
```

On the selected core, use the native `async with response_stream` or `await response_stream.close()` when
stopping early. Impact records that observation as partial and preserves native cleanup, customer hooks and
errors. Closing an unstarted native Agent stream can finalize its inner model call. Impact preserves that
native effect. A bare early break settles on release or SDK shutdown. Core `1.17`/`1.18` has no native
close/context-manager API, so early-break timing remains application/runtime dependent. See
[Python setup](https://docs.impact.ai/sdk/python/setup.md) for teardown.

A prior framework `disable_instrumentation()` call remains in force. Impact does not enable disabled native
instrumentation or change a native sensitive-data restriction. Use the
[same destination settings](https://docs.impact.ai/sdk/python/setup.md#opentelemetry-routing) as for other integrations.

#### MCP client tools

`py.mcp.client-tools.v1` · Official MCP SDK `2.3.0` · customer-owned connections

caller-owned connect/initialize, list\_tools, call\_tool and close over stdio and Streamable HTTP.

Passive observation of application-initiated discovery, capabilities, protocol/request IDs and actual tool
input/result/error. No SDK-initiated connection, background discovery or invocation.

#### OpenAI Realtime server WebSocket

`py.openai-realtime.server.v1` · OpenAI Realtime `3.46.0`, websockets `15.0.1` · explicit Impact attachment

caller-owned server WebSocket control, response, tool, usage and terminal events.

Browser media, SIP, RTP, playback and SDK-owned connections are outside this claim.

## Anthropic native content settings

For Anthropic `2.6.0`, initialize Impact before constructing clients. The native SDK owns the model span.
Impact enriches its outgoing copy with request schemas, tools, media and actually consumed direct-stream
output. Enable native content explicitly when prompts and responses are wanted:

```python theme={null}
runtime = impact.init()
from anthropic import Anthropic

client = Anthropic(open_telemetry={"traces": {"content_mode": "content"}})
```

Anthropic defaults to metadata only. Impact preserves that setting and `open_telemetry=False`. With a customer
tracer provider, pass the same provider to `impact.init(tracer_provider=provider)` and the native client's
`open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}}` option. Customer
destinations keep their original spans. The supplement observes public Messages create/parse/stream calls
without a second model span, extra request or stream read-ahead. Each observation respects the native
content-byte limit up to 1 MiB. Each observation buffer has a weak reference to its application object. The
per-observation limit does not impose an aggregate memory limit. Existing clients retain native tracing with
no request or stream enrichment. Citations and opaque content omitted by the native owner remain unavailable.
Without a confirmed end, the outcome stays partial or unknown. Shutdown stops Impact observation and leaves
customer streams and spans under native ownership. Request enrichment accepts plain JSON lists and
dictionaries. The native client owns custom containers and application iterables. Explicit
`output_config.format.schema` dictionaries are captured. Typed `output_format` schema generation stays native
and is marked unavailable to the supplement. User schema hooks execute only in the native client. Native
recorded input stays authoritative. Request wrappers, middleware, body overrides or mismatched native evidence
can make secondary enrichment unavailable. Impact keeps the native evidence and reports that limitation.

## OpenAI Realtime attachment

Attach a caller-owned Realtime connection before its first response request with
`runtime.attach_realtime(connection, connection_id=connection_id, correlation_metadata_key="request_id")` when
the app already supplies a unique string in `response.create.response.metadata["request_id"]`. The SDK
snapshots the active Interaction/Session/User and actual native parent at the outbound send. Only a unique
matching native metadata echo at the first observed response event binds later response-ID events to that
snapshot. It never adds metadata, treats the echo value as a business ID, or guesses from FIFO order or the
context active during receive. The default, VAD, ambiguous and unmatched responses keep native facts and
remain logically unassigned.

The configured key allows 64 UTF-8 bytes and nonempty native values allow 512 UTF-8 bytes. Values must be
unique for the native connection's lifetime, including across detachment. Observed reused values stay
unmatched. After 4,096 retained key identities, new associations remain unavailable with an explicit capacity
diagnosis while native event capture continues. Late callbacks do not reopen a logical Interaction. Await the
actual result inside `interaction`, or use the application-owned handoff/continuation boundary. Provider
session/conversation/response IDs and genuine provider `gen_ai.interaction.id` remain separate from canonical
`impact.session.id` / `impact.interaction.id`.

After Realtime attachment, `status().realtime` reports active connections and cumulative
observed/captured/dropped counts, including completed connections. Use Trace fields to verify logical
association and useful capture even when the local counters show events. A successful `flush()` establishes
only local exporter completion. Check the matching Trace through authenticated Product readback.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.