agenticreplay 0.1.0 → 0.1.2

package/test/integrations/agents/browser_use_agent.py

@@ -1,24 +0,0 @@
-"""browser-use's LLM layer, without starting a browser.
-
-The question this answers is narrow on purpose: does the origin reach the proxy. `ChatOpenAI` here
-declares `base_url: str | httpx.URL | None = None` and passes it through, so an unset value falls
-to the official SDK's own `OPENAI_BASE_URL` — which is the whole reason browser-use needs no adapter
-and is worth a check rather than a claim.
-
-Driving an actual browser would need Chromium and would test Playwright, not agenticreplay.
-"""
-
-import asyncio
-
-from browser_use import ChatOpenAI
-from browser_use.llm.messages import UserMessage
-
-
-async def main() -> None:
-    llm = ChatOpenAI(model="stub-1")
-    print("base_url:", llm.get_client().base_url)
-    reply = await llm.ainvoke([UserMessage(content="hello")])
-    print("GOT:", reply.completion)
-
-
-asyncio.run(main())

package/test/integrations/agents/crewai_agent.py

@@ -1,44 +0,0 @@
-"""CrewAI itself — a real Agent, Task and Crew.
-
-Not a duplicate of `litellm_agent.py`, and since CrewAI 1.x not even the same route. CrewAI moved
-LiteLLM to an optional extra (`crewai[litellm]`) and grew native providers, so a default install
-reaches OpenAI through its own `crewai.llms.providers.openai.completion` and never loads LiteLLM at
-all. Covering the layer underneath stopped covering CrewAI the moment that happened, and only
-running CrewAI itself would have noticed.
-
-Two things this pins that the LiteLLM route cannot:
-
-  - the native provider reads `OPENAI_API_BASE` *and* `OPENAI_BASE_URL`, both of which
-    `generic-openai` sets — so the capture survived the change even though the reason for it did not
-  - a bare model name always reaches the native provider, whatever the name. A prefixed one that no
-    native provider claims falls through to LiteLLM, which 1.x does not install by default — so
-    `LLM(model="openai/stub-1")` resolves or raises depending on the machine. The bare form is used
-    here for that reason, and `crewai_model_names.py` pins both halves
-"""
-
-import os
-
-# Before importing crewai: telemetry is wired up at import time, and a run that phones home is doing
-# something this check did not ask for. Not agenticreplay's business to capture — it is not model traffic —
-# but a reader deciding whether a recording is complete should know the connection exists.
-os.environ["CREWAI_DISABLE_TELEMETRY"] = "true"
-os.environ["OTEL_SDK_DISABLED"] = "true"
-
-from crewai import Agent, Crew, LLM, Process, Task  # noqa: E402
-
-# Bare, not `openai/…`: see above — a prefixed name is validated, and `stub-1` is on no list.
-llm = LLM(model="stub-1")
-
-agent = Agent(
-    role="Responder",
-    goal="Answer the question you are given",
-    backstory="You answer in one short sentence.",
-    llm=llm,
-    verbose=False,
-)
-
-task = Task(description="Say hello.", expected_output="A short greeting.", agent=agent)
-
-crew = Crew(agents=[agent], tasks=[task], process=Process.sequential, verbose=False)
-result = crew.kickoff()
-print("GOT:", str(result).strip())

package/test/integrations/agents/crewai_model_names.py

@@ -1,72 +0,0 @@
-"""Which model names CrewAI 1.x resolves, and what decides it.
-
-Not a recording check — nothing here talks to a model. It pins a claim the docs make, and the claim
-has now been wrong twice, in two different ways, which is the reason it is pinned rather than
-described:
-
-  1. `docs/integrations.md` said a prefixed name "no longer resolves" on CrewAI 1.x. It does:
-     `openai/gpt-4o-mini` is fine. The measurement behind that had used `openai/stub-1`, and what
-     failed was `stub-1` — a name no known-model list contains.
-  2. The correction said a prefixed *unknown* name always raises. It does not: CrewAI falls back to
-     LiteLLM for anything its native providers do not claim, so `openai/my-gateway-model` resolves
-     wherever LiteLLM is installed. That was measured on a machine whose LiteLLM install was broken
-     (`litellm.__file__` was None), and a broken install reads exactly like an absent one to
-     `crewai.llm._ensure_litellm()`. CI, where LiteLLM works, disagreed — which is how it surfaced.
-
-So the rule has two halves and the second is conditional. This script asserts the half that always
-holds, and the conditional half against whichever way LiteLLM actually is on the machine running it.
-"""
-
-from crewai import LLM
-
-# A bare name always reaches the native OpenAI provider, recognised or not. Nothing is conditional
-# here — this is the half worth relying on, and the form the docs recommend.
-ALWAYS_RESOLVE = ["gpt-4o-mini", "o3-mini", "my-gateway-model", "stub-1"]
-
-# A prefixed name a native provider claims. Also unconditional.
-NATIVE_PREFIXED = ["openai/gpt-4o-mini", "openai/o3-mini"]
-
-# A prefixed name no native provider claims. These fall through to LiteLLM, so whether they resolve
-# is a fact about the environment rather than about CrewAI.
-NEEDS_LITELLM = ["openai/my-gateway-model", "openai/stub-1", "foo/gpt-4o-mini"]
-
-
-def resolves(spec: str) -> bool:
-    try:
-        LLM(model=spec)
-        return True
-    except Exception:  # noqa: BLE001 - any failure to construct is a refusal
-        return False
-
-
-def litellm_usable() -> bool:
-    """What `crewai.llm._ensure_litellm()` is really asking: can it be imported *and used*."""
-    try:
-        import litellm
-
-        return hasattr(litellm, "completion")
-    except Exception:  # noqa: BLE001
-        return False
-
-
-have_litellm = litellm_usable()
-print(f"  litellm usable: {have_litellm}")
-
-failures = []
-for spec in ALWAYS_RESOLVE + NATIVE_PREFIXED:
-    got = resolves(spec)
-    print(f"  {spec:28} {'resolves' if got else 'refused':9} {'ok' if got else 'UNEXPECTED'}")
-    if not got:
-        failures.append(f"{spec} should always resolve")
-
-for spec in NEEDS_LITELLM:
-    got = resolves(spec)
-    ok = got == have_litellm
-    note = "via litellm" if have_litellm else "no litellm to fall back to"
-    print(f"  {spec:28} {'resolves' if got else 'refused':9} {'ok' if ok else 'UNEXPECTED'}  {note}")
-    if not ok:
-        failures.append(f"{spec} resolved={got} with litellm usable={have_litellm}")
-
-if failures:
-    raise SystemExit("CrewAI disagreed with the docs: " + "; ".join(failures))
-print("GOT: every case matches what docs/integrations.md says")

package/test/integrations/agents/hardcoded_origin.mjs

@@ -1,13 +0,0 @@
-/**
- * A JS agent with its origin compiled in, which no environment variable can reach.
- *
- * This is the case the fetch hook exists for — anything that types a URL into its own source
- * reads nothing from the environment.
- */
-const res = await fetch('https://api.openai.com/v1/chat/completions', {
-  method: 'POST',
-  headers: { 'content-type': 'application/json', authorization: 'Bearer stub' },
-  body: JSON.stringify({ model: 'stub-1', messages: [{ role: 'user', content: 'hello' }] }),
-});
-const doc = await res.json();
-console.log('GOT:', doc.choices[0].message.content);

package/test/integrations/agents/haystack_pipeline.py

@@ -1,28 +0,0 @@
-"""A Haystack pipeline, in the shape their own quickstart uses.
-
-`Pipeline` rather than a bare generator: Haystack's unit of work is the pipeline, and a component
-inside one is constructed and run differently from one called directly. The generator is left
-without an `api_base_url` on purpose — that is the case agenticreplay has to capture, because it is what
-every Haystack example writes, and it means the origin comes from the environment through the
-OpenAI SDK rather than from the pipeline's own code.
-"""
-
-from haystack import Pipeline
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.dataclasses import ChatMessage
-
-pipeline = Pipeline()
-pipeline.add_component(
-    "prompt",
-    ChatPromptBuilder(
-        template=[ChatMessage.from_user("Answer in one word: what is the weather in {{city}}?")],
-        required_variables=["city"],
-    ),
-)
-# No api_base_url: the client reads OPENAI_BASE_URL, which is the variable `generic-openai` sets.
-pipeline.add_component("llm", OpenAIChatGenerator(model="stub-1"))
-pipeline.connect("prompt.prompt", "llm.messages")
-
-result = pipeline.run({"prompt": {"city": "Paris"}})
-print("GOT:", result["llm"]["replies"][0].text)

package/test/integrations/agents/haystack_rag.py

@@ -1,35 +0,0 @@
-"""A Haystack RAG pipeline: embed the documents, embed the query, retrieve, then answer.
-
-Separate from `haystack_pipeline.py` because it exercises a different half of capture. The chat
-call goes to the proxy as a model exchange; the two embedding calls are *retrieval* calls — an
-endpoint whose answer is a function of its request — and are replayed by looking that key up rather
-than by the matching ladder. A pipeline that embeds at query time is the ordinary RAG shape, and
-without this nothing proved it replays.
-"""
-from haystack import Document, Pipeline
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.embedders import OpenAIDocumentEmbedder, OpenAITextEmbedder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
-from haystack.dataclasses import ChatMessage
-from haystack.document_stores.in_memory import InMemoryDocumentStore
-
-store = InMemoryDocumentStore()
-docs = [Document(content="Paris is the capital of France."),
-        Document(content="Berlin is the capital of Germany.")]
-emb = OpenAIDocumentEmbedder(model="text-embedding-3-small")
-store.write_documents(emb.run(documents=docs)["documents"])
-
-p = Pipeline()
-p.add_component("q_emb", OpenAITextEmbedder(model="text-embedding-3-small"))
-p.add_component("retriever", InMemoryEmbeddingRetriever(document_store=store, top_k=1))
-p.add_component("prompt", ChatPromptBuilder(
-    template=[ChatMessage.from_user("Context: {{docs[0].content}}\nQ: {{q}}")],
-    required_variables=["docs", "q"]))
-p.add_component("llm", OpenAIChatGenerator(model="stub-1"))
-p.connect("q_emb.embedding", "retriever.query_embedding")
-p.connect("retriever.documents", "prompt.docs")
-p.connect("prompt.prompt", "llm.messages")
-
-r = p.run({"q_emb": {"text": "capital of France"}, "prompt": {"q": "capital of France?"}})
-print("GOT:", r["llm"]["replies"][0].text)

package/test/integrations/agents/langgraph_agent.py

@@ -1,54 +0,0 @@
-"""A two-node LangGraph, in the two shapes people actually write.
-
-`stream` and `tools` rather than a plain completion: SSE has to be parsed and re-emitted, and a
-tool call round-trips a structured payload through the trace. Those are the two places a recording
-proxy is most likely to break.
-"""
-
-import sys
-from typing import Annotated, TypedDict
-
-from langchain_core.messages import HumanMessage
-from langchain_core.tools import tool
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import add_messages
-
-MODE = sys.argv[1] if len(sys.argv) > 1 else "stream"
-
-
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
-
-
-@tool
-def get_weather(city: str) -> str:
-    """Look up the weather in a city."""
-    return f"it is sunny in {city}"
-
-
-llm = (
-    ChatOpenAI(model="stub-1").bind_tools([get_weather])
-    if MODE == "tools"
-    else ChatOpenAI(model="stub-1", streaming=True)
-)
-
-
-def first(state: State):
-    return {"messages": [llm.invoke(state["messages"])]}
-
-
-def second(state: State):
-    return {"messages": [llm.invoke(state["messages"] + [HumanMessage("again")])]}
-
-
-graph = StateGraph(State)
-graph.add_node("first", first)
-graph.add_node("second", second)
-graph.add_edge(START, "first")
-graph.add_edge("first", "second")
-graph.add_edge("second", END)
-
-out = graph.compile().invoke({"messages": [HumanMessage("what is the weather in Paris")]})
-print("TURNS:", len(out["messages"]))
-print("GOT:", out["messages"][-1].content or "(tool call)")

package/test/integrations/agents/langgraph_nodes.py

@@ -1,62 +0,0 @@
-"""A graph whose shape the proxy cannot see, for the adapter that reports it.
-
-`langgraph_agent.py` next door proves the traffic is captured. This one is about what the traffic
-does not contain, so every node here is chosen for that:
-
-  - `plan` calls the model, and runs an inner runnable that must *not* be reported as a node
-  - `validate` calls no model at all, so a proxy has no evidence it ran
-  - `route` is a conditional edge, which arrives at the callback looking exactly like a node
-  - `answer` calls the model again, in a later superstep
-
-Nothing here imports agenticreplay_langgraph. The point of the check is that `agenticreplay record` attaches it
-to a graph nobody edited.
-"""
-
-from typing import Annotated, TypedDict
-
-from langchain_core.messages import HumanMessage
-from langchain_core.runnables import RunnableLambda
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import add_messages
-
-llm = ChatOpenAI(model="stub-1")
-
-
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
-    checked: bool
-
-
-def plan(state: State):
-    # An inner runnable inside a node. It inherits `langgraph_node`, so anything keying off that
-    # alone reports it as a second `plan`.
-    RunnableLambda(lambda x: x).with_config({"run_name": "INNER-RUNNABLE"}).invoke({})
-    return {"messages": [llm.invoke(state["messages"])]}
-
-
-def validate(state: State):
-    """No model call. The whole reason this file exists."""
-    return {"checked": True}
-
-
-def route(state: State):
-    return "answer"
-
-
-def answer(state: State):
-    return {"messages": [llm.invoke(state["messages"] + [HumanMessage("again")])]}
-
-
-graph = StateGraph(State)
-graph.add_node("plan", plan)
-graph.add_node("validate", validate)
-graph.add_node("answer", answer)
-graph.add_edge(START, "plan")
-graph.add_edge("plan", "validate")
-graph.add_conditional_edges("validate", route, {"answer": "answer"})
-graph.add_edge("answer", END)
-
-out = graph.compile(name="the_graph").invoke({"messages": [HumanMessage("hello")], "checked": False})
-print("TURNS:", len(out["messages"]))
-print("GOT:", out["messages"][-1].content or "(tool call)")

package/test/integrations/agents/litellm_agent.py

@@ -1,11 +0,0 @@
-"""LiteLLM directly — the layer CrewAI, Aider and OpenHands all route through.
-
-Covering it covers them, which is why this file exists instead of three more.
-"""
-
-import litellm
-
-reply = litellm.completion(
-    model="openai/stub-1", messages=[{"role": "user", "content": "hello"}]
-)
-print("GOT:", reply.choices[0].message.content)

package/test/integrations/agents/llama_index_agent.py

@@ -1,27 +0,0 @@
-"""LlamaIndex's own OpenAI LLM, which reads the older base-URL variable and not the new one.
-
-Worth a check rather than a claim, and for a sharper reason than most of this corpus. LlamaIndex
-does not read `OPENAI_BASE_URL` at all — measured, not assumed:
-
-    OPENAI_BASE_URL set   →  client.base_url == https://api.openai.com/v1/     (ignored)
-    OPENAI_API_BASE set   →  client.base_url == http://127.0.0.1:8888/v1/      (honoured)
-
-`generic-openai` happens to set both, with a comment saying pre-1.0 SDKs and ports need the older
-name. This check is what turns that comment into something that fails when it stops being true:
-drop `OPENAI_API_BASE` from the adapter and every other check here still passes, because every
-other framework reads the new name.
-
-The model name is a real one rather than `stub-1` because LlamaIndex refuses anything outside its
-own built-in list — `ValueError: Unknown model 'stub-1'`, raised from `openai_modelname_to_contextsize`
-before a request is ever made, and there is no `context_window` argument to bypass it. That is a
-property of LlamaIndex, not of agenticreplay, and `llama_index_model_names.py` is what stops the claim
-drifting. The stub echoes whatever model it is given, so the name changes nothing here.
-"""
-
-from llama_index.core.llms import ChatMessage
-from llama_index.llms.openai import OpenAI
-
-llm = OpenAI(model="gpt-4o-mini")
-print("base_url:", llm._get_client().base_url)
-reply = llm.chat([ChatMessage(role="user", content="hello")])
-print("GOT:", reply.message.content)

package/test/integrations/agents/llama_index_model_names.py

@@ -1,67 +0,0 @@
-"""Which model names LlamaIndex's OpenAI LLM accepts, and when it decides.
-
-Not a recording check — nothing here talks to a model. It pins a claim `docs/integrations.md`
-makes, for the same reason the CrewAI one exists: a sentence about model names in someone else's
-library is exactly the kind of thing that is true when written and false two releases later, and
-we have already shipped that mistake once.
-
-The claim: LlamaIndex validates the model name against a list compiled into
-`llama_index.llms.openai.utils`, and refuses anything outside it *before any request is made*. So
-a name your gateway understands but OpenAI never published — the usual case when pointing
-LlamaIndex at a proxy, a local model, or an internal router — does not work, and no agenticreplay setting
-changes that, because nothing has reached the wire yet.
-
-Where it raises matters as much as that it raises. The check is not in the constructor: `OpenAI(...)`
-returns fine, and the ValueError arrives from `openai_modelname_to_contextsize` when `.metadata` is
-first read, which the chat path does on every call. A user therefore sees it at the first message
-rather than at setup, and there is no `context_window` argument to supply instead — asserted below,
-because if LlamaIndex adds one, that becomes the recommended workaround and the docs should say so.
-"""
-
-from llama_index.core.llms import ChatMessage
-from llama_index.llms.openai import OpenAI
-
-# Names from LlamaIndex's own list. These must keep working or the integration check is wrong too.
-KNOWN = ["gpt-4o-mini", "gpt-4.1-mini"]
-
-# What a gateway or a local model is actually called. None of these is in any OpenAI list.
-UNKNOWN = ["stub-1", "my-gateway-model", "llama-3.1-70b"]
-
-
-def accepts(name: str) -> tuple[bool, str]:
-    """Construct and read metadata, which is what the chat path does before sending anything."""
-    try:
-        llm = OpenAI(model=name, api_key="unused")
-        llm.metadata  # noqa: B018 - reading it is the operation under test
-        return True, ""
-    except Exception as exc:  # noqa: BLE001 - any refusal counts
-        return False, type(exc).__name__
-
-
-failures = []
-
-for name in KNOWN:
-    ok, why = accepts(name)
-    print(f"  {name:22} {'accepted' if ok else 'refused':9} {'ok' if ok else 'UNEXPECTED ' + why}")
-    if not ok:
-        failures.append(f"{name} should be accepted")
-
-for name in UNKNOWN:
-    ok, why = accepts(name)
-    print(f"  {name:22} {'accepted' if ok else 'refused':9} {'UNEXPECTED' if ok else 'ok — ' + why}")
-    if ok:
-        failures.append(f"{name} was accepted; LlamaIndex no longer gates on its own model list")
-
-# The constructor itself must stay permissive, or the sentence above about *where* it raises is
-# wrong — and that sentence is the difference between "fails at setup" and "fails at first message".
-try:
-    OpenAI(model="my-gateway-model", api_key="unused")
-except Exception as exc:  # noqa: BLE001
-    failures.append(f"the constructor now refuses too ({type(exc).__name__}); the docs describe the old behaviour")
-
-if "context_window" in OpenAI.model_fields:
-    failures.append("OpenAI now takes context_window — that is a supported escape hatch and the docs should recommend it")
-
-if failures:
-    raise SystemExit("LlamaIndex disagreed with the docs: " + "; ".join(failures))
-print("GOT: every case matches what docs/integrations.md says")

package/test/integrations/agents/mastra_agent.mjs

@@ -1,20 +0,0 @@
-/**
- * A Mastra agent, which is the Vercel AI SDK case with a framework on top of it.
- *
- * Mastra takes its model from `@ai-sdk/openai`, and that provider takes its origin as a
- * constructor argument rather than from the environment — so base-URL injection reaches nothing
- * here and the capture is the `NODE_OPTIONS` fetch hook, the same layer `hardcoded_origin.mjs`
- * covers. This check is the framework-shaped version of that one: it is worth having both, because
- * a hook that works on a bare `fetch` can still be defeated by a library that wraps it.
- */
-import { openai } from '@ai-sdk/openai';
-import { Agent } from '@mastra/core/agent';
-
-const agent = new Agent({
-  name: 'stub-agent',
-  instructions: 'Answer in one short sentence.',
-  model: openai('stub-1'),
-});
-
-const res = await agent.generate('hello');
-console.log('GOT:', res.text);

package/test/integrations/agents/mcp_agent.py

@@ -1,44 +0,0 @@
-"""An agent that talks to a model *and* to an MCP server it launches from a config file.
-
-Both halves on purpose. The model call is what every other check asserts and what makes the
-exchange counts comparable; the MCP session is the half no other check covers at all.
-
-It reads the config rather than building `StdioServerParameters` in code, because that is the shape
-agenticreplay can instrument — it rewrites the config to put its shim between client and server. A client
-that constructs the parameters itself leaves agenticreplay nothing to rewrite, and the session is then
-invisible to every capture layer: the transport is OS pipes, so the proxy never sees it, and
-`mcp.client.stdio` spawns in list form rather than through a shell, so the PATH shim never fires.
-That gap is real and is not what this check covers.
-"""
-
-import asyncio
-import json
-import os
-
-from mcp import ClientSession, StdioServerParameters, stdio_client
-from openai import OpenAI
-
-
-async def main() -> None:
-    with open(os.environ["MCP_CONFIG_PATH"], encoding="utf8") as fh:
-        config = json.load(fh)
-    name, entry = next(iter(config["mcpServers"].items()))
-    params = StdioServerParameters(
-        command=entry["command"], args=entry.get("args", []), env=entry.get("env")
-    )
-
-    async with stdio_client(params) as (read, write):
-        async with ClientSession(read, write) as session:
-            await session.initialize()
-            tools = await session.list_tools()
-            print("TOOLS:", [t.name for t in tools.tools])
-            result = await session.call_tool("lookup", {"key": "alpha"})
-            print("MCP:", result.content[0].text)
-
-    reply = OpenAI().chat.completions.create(
-        model="stub-1", messages=[{"role": "user", "content": "hello"}]
-    )
-    print("GOT:", reply.choices[0].message.content)
-
-
-asyncio.run(main())

package/test/integrations/agents/mcp_server.py

@@ -1,20 +0,0 @@
-"""An MCP server over stdio, for the check that records one and then takes it away.
-
-Deliberately trivial and deliberately deterministic: the point of the check is the transport and
-the replay, not the tool. `lookup` answers from its argument so a replay that served the wrong
-recorded frame is visible in the output rather than only in a count.
-"""
-
-from mcp.server.fastmcp import FastMCP
-
-app = FastMCP("agenticreplay-check")
-
-
-@app.tool()
-def lookup(key: str) -> str:
-    """Return a canned value for a key."""
-    return f"VALUE-FOR-{key}"
-
-
-if __name__ == "__main__":
-    app.run()

package/test/integrations/agents/openai_agents_handoff.py

@@ -1,52 +0,0 @@
-"""A two-agent run with a handoff and an input guardrail, configuring nothing.
-
-The point of this check is what the file does *not* contain. agenticreplay attaches its tracing processor
-through a `sitecustomize` on PYTHONPATH, so an agent that has never heard of agenticreplay still reports the
-three things a proxy cannot see: which agent a turn belonged to, that a handoff happened and from
-whom, and that a guardrail ran. If this file mentioned agenticreplay, it would be testing something else.
-
-The stub answers the first turn with a `transfer_to_*` call, so the handoff is real rather than
-simulated.
-"""
-
-import asyncio
-
-from agents import (
-    Agent,
-    GuardrailFunctionOutput,
-    RunContextWrapper,
-    Runner,
-    input_guardrail,
-)
-
-
-@input_guardrail
-async def not_empty(
-    ctx: RunContextWrapper[None], agent: Agent, user_input
-) -> GuardrailFunctionOutput:
-    text = user_input if isinstance(user_input, str) else str(user_input)
-    return GuardrailFunctionOutput(output_info={"length": len(text)}, tripwire_triggered=False)
-
-
-billing = Agent(
-    name="Billing Specialist",
-    instructions="Answer billing questions in one sentence.",
-    model="stub-1",
-)
-
-triage = Agent(
-    name="Triage",
-    instructions="Route the user to the right specialist.",
-    model="stub-1",
-    handoffs=[billing],
-    input_guardrails=[not_empty],
-)
-
-
-async def main() -> None:
-    result = await Runner.run(triage, "I was charged twice this month.")
-    print("GOT:", result.final_output)
-    print("LAST AGENT:", result.last_agent.name)
-
-
-asyncio.run(main())

package/test/integrations/agents/openai_agents_sdk.py

@@ -1,29 +0,0 @@
-"""The OpenAI Agents SDK itself, on the API it reaches for by default.
-
-Separate from `openai_async.py`, which covers the `AsyncOpenAI` client underneath it. That check
-proves the client can be redirected; it says nothing about the wire format the SDK actually speaks,
-because the SDK defaults to the **Responses API** and `AsyncOpenAI` in that check does not. So the
-path a real Agents SDK user takes had no end-to-end check until this one, on a claim the README has
-been making.
-
-Nothing here switches the SDK to chat completions. A check that did would prove the wrong path
-works.
-"""
-
-import asyncio
-
-from agents import Agent, Runner, set_tracing_disabled
-
-# The SDK ships its own traces to OpenAI, on a second connection that is not model traffic and that
-# agenticreplay does not capture. Off here so the run talks to nothing but the proxy — which is also what
-# makes this check deterministic, and what the docs tell a reader to decide about before a long run.
-set_tracing_disabled(True)
-
-
-async def main() -> None:
-    agent = Agent(name="Stub", instructions="Answer in one short sentence.", model="stub-1")
-    result = await Runner.run(agent, "hello")
-    print("GOT:", result.final_output)
-
-
-asyncio.run(main())

package/test/integrations/agents/openai_async.py

@@ -1,17 +0,0 @@
-"""`AsyncOpenAI`, which is what the OpenAI Agents SDK builds on."""
-
-import asyncio
-
-from openai import AsyncOpenAI
-
-
-async def main() -> None:
-    client = AsyncOpenAI()
-    print("base_url:", client.base_url)
-    reply = await client.chat.completions.create(
-        model="stub-1", messages=[{"role": "user", "content": "hello"}]
-    )
-    print("GOT:", reply.choices[0].message.content)
-
-
-asyncio.run(main())

package/test/integrations/agents/openai_sdk.py

@@ -1,10 +0,0 @@
-"""The official Python SDK with no base_url — the shape every env-var framework reduces to."""
-
-from openai import OpenAI
-
-client = OpenAI()
-print("base_url:", client.base_url)
-reply = client.chat.completions.create(
-    model="stub-1", messages=[{"role": "user", "content": "hello"}]
-)
-print("GOT:", reply.choices[0].message.content)