flyteplugins-agents-openai 2.5.9__py3-none-any.whl

flyteplugins/agents/openai/__init__.py

@@ -0,0 +1,35 @@
+"""OpenAI Agents SDK adapter for Flyte.
+
+Bring your own ``openai-agents`` ``Agent`` (tools, handoffs, guardrails) and run
+it durably on Flyte. The adapter provides three things, each independently
+usable:
+
+- :func:`tool` — turn a Flyte ``@env.task`` into an OpenAI Agents tool
+  that executes as a durable child action (own container/GPU, retries,
+  caching) when the agent calls it.
+- :class:`FlyteModelProvider` — a ``ModelProvider`` wrapper that records each
+  model turn through ``flyte.trace`` so a crashed/retried run replays
+  completed turns instead of re-calling (and re-billing) the LLM.
+- :class:`FlyteTracingProcessor` — forwards the OpenAI Agents trace (turns, tool
+  calls, handoffs, token usage) into the Flyte task report for observability.
+
+:func:`run_agent` wires all three together for the common case. For full control,
+use them directly with ``Runner.run`` and a ``RunConfig``.
+"""
+
+from ._durable import FlyteModel, FlyteModelProvider
+from ._memory import FlyteSession
+from ._observability import FlyteTracingProcessor, install_flyte_tracing
+from ._run import run_agent
+from ._tools import FunctionTool, tool
+
+__all__ = [
+    "FlyteModel",
+    "FlyteModelProvider",
+    "FlyteSession",
+    "FlyteTracingProcessor",
+    "FunctionTool",
+    "install_flyte_tracing",
+    "run_agent",
+    "tool",
+]

flyteplugins/agents/openai/_durable.py

@@ -0,0 +1,111 @@
+"""Durable, replayable model turns for the OpenAI Agents SDK.
+
+The OpenAI Agents ``Runner`` owns the agent loop. To make that loop durable we
+swap in a :class:`FlyteModelProvider`: it wraps the real model so every
+``get_response`` (one model turn) is recorded through the shared
+:func:`~flyteplugins.agents.core.durable_step` (a ``flyte.trace`` leaf). Inside a
+Flyte task this means a crashed/retried run replays completed turns from
+their recorded outputs instead of re-calling (and re-billing) the model. Tool
+calls run as durable child actions (see :func:`flyteplugins.agents.openai.tool`),
+so the whole agent run becomes crash-resilient and self-healing when the enclosing task
+carries ``retries=...``.
+
+The turn is recorded as JSON (pydantic round-trips the SDK's ``ModelResponse``
+faithfully and stays readable in the Flyte UI). The non-serializable real call is
+captured in a closure passed to ``durable_step``.
+"""
+
+from __future__ import annotations
+
+import typing
+from collections.abc import AsyncIterator
+
+from agents.items import ModelResponse
+from agents.models.interface import Model, ModelProvider
+from agents.models.multi_provider import MultiProvider
+from flyteplugins.agents.core import durable_step, fingerprint, jsonable
+from pydantic import TypeAdapter
+
+# pydantic round-trips ModelResponse (and its nested OpenAI types) faithfully;
+# storing JSON keeps the recorded turn human-readable in the Flyte UI.
+_RESPONSE_ADAPTER: TypeAdapter[ModelResponse] = TypeAdapter(ModelResponse)
+
+# Positional parameters of ``Model.get_response`` used for fingerprinting
+# (``tracing`` and the keyword-only ids are intentionally ignored).
+_GET_RESPONSE_PARAMS = (
+    "system_instructions",
+    "input",
+    "model_settings",
+    "tools",
+    "output_schema",
+    "handoffs",
+)
+
+
+def _bind(args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]) -> dict[str, typing.Any]:
+    bound = dict(kwargs)
+    for name, value in zip(_GET_RESPONSE_PARAMS, args):
+        bound.setdefault(name, value)
+    return bound
+
+
+def _request_fingerprint(args: tuple[typing.Any, ...], kwargs: dict[str, typing.Any]) -> str:
+    """Deterministic memo key for a model turn — tool/handoff names, not callables."""
+    bound = _bind(args, kwargs)
+    return fingerprint(
+        {
+            "system": bound.get("system_instructions"),
+            "input": jsonable(bound.get("input")),
+            "model_settings": jsonable(bound.get("model_settings")),
+            "tools": sorted(getattr(t, "name", str(t)) for t in (bound.get("tools") or [])),
+            "handoffs": sorted(
+                getattr(h, "agent_name", getattr(h, "tool_name", str(h))) for h in (bound.get("handoffs") or [])
+            ),
+            "output_schema": getattr(bound.get("output_schema"), "name", None),
+        }
+    )
+
+
+class FlyteModel(Model):
+    """Wrap a :class:`~agents.models.interface.Model` so each turn is durable.
+
+    ``get_response`` is recorded/replayed via ``durable_step``. ``stream_response``
+    is delegated unchanged: streamed turns are not memoized in this version (tool
+    calls remain durable regardless).
+    """
+
+    def __init__(self, inner: Model):
+        self._inner = inner
+
+    async def get_response(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+        return await durable_step(
+            _request_fingerprint(args, kwargs),
+            lambda: self._inner.get_response(*args, **kwargs),
+            name="model_turn",
+            dumps=lambda response: _RESPONSE_ADAPTER.dump_json(response).decode("utf-8"),
+            loads=_RESPONSE_ADAPTER.validate_json,
+        )
+
+    def stream_response(self, *args: typing.Any, **kwargs: typing.Any) -> AsyncIterator[typing.Any]:
+        return self._inner.stream_response(*args, **kwargs)
+
+    async def close(self) -> None:
+        await self._inner.close()
+
+
+class FlyteModelProvider(ModelProvider):
+    """Wrap a ``ModelProvider`` so every model it returns produces durable turns.
+
+    Pass an explicit ``inner`` provider to keep custom routing (Azure, a gateway,
+    a local OpenAI-compatible server); defaults to the SDK's ``MultiProvider``.
+    Set it on ``RunConfig.model_provider`` (``run_agent`` does this for you).
+    """
+
+    def __init__(self, inner: ModelProvider | None = None):
+        self._inner = inner or MultiProvider()
+
+    def get_model(self, model_name: str | None) -> Model:
+        return FlyteModel(self._inner.get_model(model_name))
+
+    async def aclose(self) -> None:
+        await self._inner.aclose()

flyteplugins/agents/openai/_memory.py

@@ -0,0 +1,47 @@
+"""OpenAI Agents ``Session`` backed by a keyed Flyte ``MemoryStore``.
+
+The OpenAI Agents SDK reads and writes conversation history through a ``Session``
+(``get_items`` / ``add_items`` / ``pop_item`` / ``clear_session``).
+:class:`FlyteSession` implements that protocol over a durable, cross-run
+:class:`~flyte.ai.agents.memory.MemoryStore` (keyed by a ``memory_key``), so
+passing ``session=FlyteSession(store)`` to ``Runner.run`` gives the agent memory
+that survives across runs and workers — backed by object storage rather than the
+SDK's default local SQLite (which doesn't persist on a distributed backend).
+"""
+
+from __future__ import annotations
+
+import typing
+
+
+class FlyteSession:
+    """An ``agents`` ``Session`` whose items live in a keyed Flyte ``MemoryStore``.
+
+    The store's ``messages`` transcript is the session item list; ``add_items``
+    persists durably (an object-store upload) so the next run for the same key
+    resumes the conversation.
+    """
+
+    def __init__(self, store: typing.Any) -> None:
+        self._store = store
+
+    async def get_items(self, limit: int | None = None) -> list[dict[str, typing.Any]]:
+        items = list(self._store.messages)
+        return items[-limit:] if limit else items
+
+    async def add_items(self, items: list[dict[str, typing.Any]]) -> None:
+        if not items:
+            return
+        self._store.extend(items)
+        await self._store.save.aio()
+
+    async def pop_item(self) -> dict[str, typing.Any] | None:
+        if not self._store.messages:
+            return None
+        item = self._store.messages.pop()
+        await self._store.save.aio()
+        return item
+
+    async def clear_session(self) -> None:
+        self._store.messages.clear()
+        await self._store.save.aio()

flyteplugins/agents/openai/_observability.py

@@ -0,0 +1,106 @@
+"""Forward the OpenAI Agents trace into the Flyte task report.
+
+The OpenAI Agents SDK emits a structured trace of every run (agent spans, model
+``generation``/``response`` turns, ``function`` tool calls, ``handoff`` and
+``guardrail`` spans). :class:`FlyteTracingProcessor` is a ``TracingProcessor``
+that maps those spans onto the shared :class:`~flyteplugins.agents.core.ReportTimeline`,
+rendering an in-run timeline (timings, token usage, tool inputs/outputs) into a tab of
+the enclosing task's Flyte report, alongside the tool tasks that already show up as
+Flyte actions.
+
+It is best-effort by contract: a processor must never raise into the agent loop,
+and report writes are skipped silently when there is no active report.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from agents import add_trace_processor, set_trace_processors
+from agents.tracing.processor_interface import TracingProcessor
+from flyte._logging import logger
+from flyteplugins.agents.core import ReportTimeline, abbrev, duration_ms
+
+_ICONS = {
+    "agent": "🤖",
+    "generation": "🧠",
+    "response": "🧠",
+    "function": "🛠️",
+    "handoff": "🔀",
+    "guardrail": "🛡️",
+    "mcp_tools": "🔌",
+}
+
+
+def _summarize(kind: str, export: dict[str, typing.Any]) -> str:
+    """Render the OpenAI-specific span payload as a compact HTML detail string."""
+    if kind == "function":
+        return f"<code>{abbrev(export.get('input'), 160)}</code> → <code>{abbrev(export.get('output'), 160)}</code>"
+    if kind in ("generation", "response"):
+        usage = export.get("usage") or {}
+        if usage:
+            parts = ", ".join(f"{k}={v}" for k, v in usage.items())
+            return f'<span style="opacity:.7">{abbrev(parts)}</span>'
+        return ""
+    if kind == "handoff":
+        return f"{abbrev(export.get('from_agent'))} → {abbrev(export.get('to_agent'))}"
+    return ""
+
+
+class FlyteTracingProcessor(TracingProcessor):
+    """Map OpenAI Agents spans onto the shared :class:`ReportTimeline`."""
+
+    def __init__(self, tab_name: str = "Agent"):
+        self._timeline = ReportTimeline(tab_name)
+
+    def on_trace_start(self, trace: typing.Any) -> None:
+        self._timeline.heading("OpenAI agent")
+
+    def on_trace_end(self, trace: typing.Any) -> None:
+        pass
+
+    def on_span_start(self, span: typing.Any) -> None:
+        pass
+
+    def on_span_end(self, span: typing.Any) -> None:
+        try:
+            self._render(span)
+        except Exception:  # pragma: no cover - observability must never break the loop
+            logger.debug("FlyteTracingProcessor failed to render a span", exc_info=True)
+
+    def shutdown(self) -> None:
+        pass
+
+    def force_flush(self) -> None:
+        pass
+
+    def _render(self, span: typing.Any) -> None:
+        data = getattr(span, "span_data", None)
+        if data is None:
+            return
+        kind = getattr(data, "type", "custom")
+        export = data.export() if hasattr(data, "export") else {}
+        duration = duration_ms(getattr(span, "started_at", None), getattr(span, "ended_at", None))
+        self._timeline.row(
+            icon=_ICONS.get(kind, "•"),
+            label=export.get("name") or kind,
+            meta=" · ".join(p for p in (kind, duration) if p),
+            detail=_summarize(kind, export),
+            error=getattr(span, "error", None),
+        )
+
+
+def install_flyte_tracing(*, exclusive: bool = True, tab_name: str = "Agent") -> FlyteTracingProcessor:
+    """Install a :class:`FlyteTracingProcessor` as a global trace processor.
+
+    With ``exclusive=True`` (default) it replaces all processors, so traces are
+    rendered only into the Flyte report and nothing is uploaded to OpenAI's
+    tracing backend. Set ``exclusive=False`` to keep the SDK's default processors
+    (e.g. to also export to the OpenAI dashboard) and add Flyte alongside.
+    """
+    processor = FlyteTracingProcessor(tab_name=tab_name)
+    if exclusive:
+        set_trace_processors([processor])
+    else:
+        add_trace_processor(processor)
+    return processor

flyteplugins/agents/openai/_run.py

@@ -0,0 +1,99 @@
+"""``run_agent`` — the one-call path to run an OpenAI agent durably on Flyte."""
+
+from __future__ import annotations
+
+import typing
+
+from agents import Agent, RunConfig, Runner
+from flyte._task import TaskTemplate
+from flyteplugins.agents.core import flush_report, resolve_memory
+
+from ._durable import FlyteModelProvider
+from ._memory import FlyteSession
+from ._observability import install_flyte_tracing
+from ._tools import tool
+
+
+def _normalize_tools(tools: typing.Sequence[typing.Any]) -> list[typing.Any]:
+    """Accept bare ``@env.task`` templates as tools by wrapping them on the fly."""
+    normalized: list[typing.Any] = []
+    for t in tools or ():
+        normalized.append(tool(t) if isinstance(t, TaskTemplate) else t)
+    return normalized
+
+
+async def run_agent(
+    input: str | list[typing.Any],
+    *,
+    agent: Agent | None = None,
+    tools: typing.Sequence[typing.Any] = (),
+    model: str = "gpt-4.1",
+    instructions: str | None = None,
+    name: str = "flyte-agent",
+    max_turns: int = 10,
+    durable: bool = True,
+    observability: bool = True,
+    run_config: RunConfig | None = None,
+    memory_key: str | None = None,
+) -> str:
+    """Run an OpenAI Agents SDK agent with Flyte providing the runtime.
+
+    Call this from inside an ``@env.task`` — that task is the durable parent.
+    Within it, each model turn is recorded via ``flyte.trace`` (replayed on
+    retry) and each tool call runs as a durable Flyte child action. Give the
+    enclosing task ``retries=...`` for self-healing and ``report=True`` to see
+    the agent timeline.
+
+    Provide either a fully-built ``agent`` (keeping its handoffs/guardrails), or
+    ``tools`` + ``instructions`` + ``model`` to have one built for you. ``tools``
+    may be :func:`tool`-wrapped tools or bare ``@env.task`` templates
+    (wrapped automatically).
+
+    Args:
+        input: The user prompt (or a list of input items).
+        agent: A pre-built ``agents.Agent``. Mutually exclusive with ``tools``.
+        tools: Tools to expose (when ``agent`` is not given).
+        model: Model name (when ``agent`` is not given).
+        instructions: System instructions (when ``agent`` is not given).
+        name: Agent name (when ``agent`` is not given).
+        max_turns: Maximum model to tool turns and vice versa before the SDK raises.
+        durable: Record/replay each model turn via ``flyte.trace``.
+        observability: Render the run timeline into the Flyte task report.
+        run_config: A custom ``RunConfig``; ``model_provider`` is wrapped for
+            durability unless ``durable=False``.
+        memory_key: Stable id (e.g. a user/thread id) for cross-run memory.
+            When set, conversation history is loaded from and saved to a durable,
+            keyed ``MemoryStore`` (via the SDK's ``Session``), so a later run with
+            the same key continues the conversation. ``None`` disables memory.
+
+    Returns:
+        The agent's final output as a string.
+    """
+    if agent is not None and tools:
+        raise ValueError("Pass either `agent` (with its own tools) or `tools`, not both.")
+
+    if agent is None:
+        agent = Agent(
+            name=name,
+            instructions=instructions or "You are a helpful assistant.",
+            model=model,
+            tools=_normalize_tools(tools),
+        )
+
+    config = run_config or RunConfig()
+    if durable:
+        config.model_provider = FlyteModelProvider(config.model_provider)
+    if observability:
+        install_flyte_tracing()
+
+    store = await resolve_memory(memory_key)
+    session = FlyteSession(store) if store is not None else None
+
+    try:
+        result = await Runner.run(agent, input, max_turns=max_turns, run_config=config, session=session)
+    finally:
+        if observability:
+            await flush_report()
+
+    final = result.final_output
+    return final if isinstance(final, str) else str(final)

flyteplugins/agents/openai/_tools.py

@@ -0,0 +1,124 @@
+"""Turn Flyte tasks into OpenAI Agents tools that execute as durable actions."""
+
+from __future__ import annotations
+
+import inspect
+import json
+import typing
+from dataclasses import dataclass
+from functools import partial
+
+from agents import FunctionTool as OpenAIFunctionTool
+from agents import function_tool as openai_function_tool
+from agents.function_schema import function_schema
+from agents.tool_context import ToolContext
+from flyte._task import AsyncFunctionTaskTemplate, TaskTemplate
+from flyte.models import NativeInterface
+from flyteplugins.agents.core import attach_tool_resolver
+
+
+@dataclass
+class FunctionTool(OpenAIFunctionTool):
+    """An OpenAI Agents ``FunctionTool`` backed by a Flyte task.
+
+    Behaves exactly like ``agents.FunctionTool`` from the SDK's perspective, but
+    when the agent invokes it the call is dispatched to the underlying Flyte task
+    — so it runs as a durable child action (its own container/resources, with
+    retries and caching) rather than inline in the agent's process.
+    """
+
+    task: TaskTemplate | None = None
+    native_interface: NativeInterface | None = None
+    report: bool = False
+
+    async def execute(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+        """Run the wrapped task directly (a durable child action in a task context)."""
+        if self.task is None:  # pragma: no cover - defensive
+            raise RuntimeError("FunctionTool has no backing task to execute.")
+        return await self.task.aio(*args, **kwargs)
+
+    @property
+    def __wrapped_task__(self) -> typing.Any:
+        """The backing :class:`TaskTemplate` so :class:`ToolTaskResolver` can recover it.
+
+        Stacking ``@tool`` on ``@env.task`` rebinds the module attribute
+        to this tool, hiding the task from the default resolver;
+        ``flyteplugins.agents.core.ToolTaskResolver`` uses this hook to recover the
+        real task on the worker (so the task runs its own body instead of
+        re-dispatching itself, which would otherwise recurse indefinitely).
+        """
+        return self.task if isinstance(self.task, TaskTemplate) else None
+
+
+def tool(
+    func: AsyncFunctionTaskTemplate | typing.Callable | None = None,
+    **kwargs: typing.Any,
+) -> FunctionTool | OpenAIFunctionTool:
+    """Flyte-aware replacement for ``agents.function_tool`` — named ``tool`` for consistency.
+
+    - For an ``@env.task`` (an ``AsyncFunctionTaskTemplate``): returns a
+      :class:`FunctionTool` whose invocation runs the task as a durable Flyte
+      action. The tool's JSON schema, name and description are derived by the
+      OpenAI Agents SDK from the task's function signature, so strict-mode tool
+      calling works unchanged.
+    - For a plain callable or a ``@flyte.trace`` helper: forwards to the native
+      ``agents.function_tool`` (runs inline; ``@flyte.trace`` helpers are still
+      recorded for observability when inside a task).
+
+    ``**kwargs`` (e.g. ``name_override``, ``description_override``) are forwarded
+    to ``agents.function_tool`` in both cases.
+
+    Usable as a bare decorator, a parametrized decorator, or a direct call::
+
+        @tool
+        @env.task
+        async def get_weather(city: str) -> str: ...
+
+        weather = tool(get_weather, name_override="weather")
+    """
+    if func is None:
+        return partial(tool, **kwargs)
+
+    if isinstance(func, AsyncFunctionTaskTemplate):
+        return _task_to_tool(func, **kwargs)
+
+    # Plain callables and @flyte.trace-decorated functions use the native path.
+    return openai_function_tool(func, **kwargs)
+
+
+def _task_to_tool(task: AsyncFunctionTaskTemplate, **kwargs: typing.Any) -> FunctionTool:
+    """Build a :class:`FunctionTool` from a Flyte task.
+
+    Only the stable, public fields of ``agents.FunctionTool`` are copied from a
+    base tool built by ``agents.function_tool`` — we deliberately do not reflect
+    over private fields, so this stays robust across SDK versions.
+    """
+    base = openai_function_tool(task.func, **kwargs)
+
+    async def _on_invoke_tool(ctx: ToolContext[typing.Any], input: str) -> typing.Any:
+        data: dict[str, typing.Any] = json.loads(input) if input else {}
+        schema = function_schema(task.func)
+        parsed = schema.params_pydantic_model(**data) if data else schema.params_pydantic_model()
+        args, kwargs_ = schema.to_call_args(parsed)
+        # In a Flyte task context, calling the task submits a durable child
+        # action through the controller; locally it runs inline. Sync tasks
+        # return a value directly, async tasks return an awaitable.
+        out = task(*args, **kwargs_)
+        if inspect.isawaitable(out):
+            out = await out
+        return out
+
+    # The returned tool shadows the task at module scope, so point the task at the
+    # shared resolver that recovers it on the worker via ``__wrapped_task__``.
+    attach_tool_resolver(task)
+
+    return FunctionTool(
+        name=base.name,
+        description=base.description,
+        params_json_schema=base.params_json_schema,
+        on_invoke_tool=_on_invoke_tool,
+        strict_json_schema=base.strict_json_schema,
+        task=task,
+        native_interface=task.native_interface,
+        report=task.report,
+    )

flyteplugins_agents_openai-2.5.9.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: flyteplugins-agents-openai
+Version: 2.5.9
+Summary: Run OpenAI Agents SDK agents on Flyte.
+Author-email: Samhita Alla <samhita@union.ai>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: flyteplugins-agents-core
+Requires-Dist: openai-agents
+
+# flyteplugins-agents-openai
+
+Run [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) agents on
+Flyte. You keep writing agents in the SDK's own idioms; Flyte is the durable
+orchestration runtime underneath — replay, automatic retries / self-healing,
+per-tool containerized execution (CPU/GPU, caching), and observability.
+
+```bash
+pip install flyteplugins-agents-openai
+```
+
+```python
+import flyte
+from flyteplugins.agents.openai import tool, run_agent
+
+env = flyte.TaskEnvironment(
+    "openai-agent",
+    secrets=[flyte.Secret(key="openai_api_key", as_env_var="OPENAI_API_KEY")],
+)
+
+# A tool that is also a durable, cached Flyte task.
+@tool
+@env.task(cache="auto", retries=3)
+async def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    return f"The weather in {city} is sunny, 22°C."
+
+# The durable parent. retries=3 -> self-healing; report=True -> agent timeline.
+@env.task(report=True, retries=3)
+async def city_agent(question: str) -> str:
+    return await run_agent(
+        question,
+        tools=[get_weather],
+        instructions="You are a concise assistant. Use the tools to answer.",
+        model="gpt-4.1",
+    )
+```
+
+## How it maps to Flyte
+
+- The SDK owns the loop — we don't reimplement it. `run_agent` drives the
+  OpenAI Agents `Runner`; the agent run is your `@env.task` (the durable
+  parent) and the SDK runs its agent loop inside it.
+- Tools as durable child actions. `tool` wraps an `@env.task` so that
+  when the agent calls a tool, the task runs as a durable Flyte child action
+  (its own container/resources, retries, caching) — not inline in the agent
+  process. The SDK derives the tool's JSON schema, name and description from the
+  task signature, so strict tool-calling works unchanged.
+- Durable, replayable model turns. Each model turn is recorded via
+  `flyte.trace` by tracing the seam below the loop — a `FlyteModelProvider`
+  set on `RunConfig.model_provider`. If the task crashes and Flyte retries it,
+  completed turns and tool calls replay from their recorded outputs instead of
+  re-calling (and re-billing) the model.
+- Self-healing. `retries=...` on the agent task plus per-turn / per-tool replay
+  means transient failures recover automatically without redoing completed work.
+- Observability. The OpenAI Agents trace (turns, tool calls, handoffs, token
+  usage) renders into the task report (`report=True`); `install_flyte_tracing()`
+  replaces the OpenAI exporter (`exclusive=True`) so nothing is uploaded
+  externally.
+
+The API key is read from the environment. Wire it as a Flyte secret.
+
+### Bring your own agent
+
+Already wrote an `agents.Agent` with handoffs and guardrails? Pass it through:
+
+```python
+from agents import Agent
+
+triage = Agent(name="triage", handoffs=[...], input_guardrails=[...])
+
+@env.task(report=True, retries=3)
+async def run(goal: str) -> str:
+    return await run_agent(goal, agent=triage)
+```
+
+### Power-user building blocks
+
+`run_agent` wires three independently usable pieces; reach for them directly when
+driving `Runner.run` yourself:
+
+- `tool` — turn a Flyte task into an OpenAI Agents tool.
+- `FlyteModelProvider` — set on `RunConfig.model_provider` to make model turns
+  durable (the seam below the loop).
+- `install_flyte_tracing()` / `FlyteTracingProcessor` — render the trace into the
+  report (`exclusive=True` by default replaces the OpenAI exporter so nothing is
+  uploaded externally).
+
+## Memory
+
+Pass `memory_key` (a user/thread id) for cross-run memory — the agent continues
+the same conversation across separate runs, workers and restarts:
+
+```python
+await run_agent(message, model="gpt-4.1", memory_key="user-alice")
+```
+
+It backs the OpenAI Agents SDK `Session` with a durable, keyed `MemoryStore` (object
+storage), so unlike the SDK's default local-SQLite session, it persists on a
+distributed backend. The same store also holds path-addressed facts for long-term
+`remember` / `recall` memory.
+
+## Examples
+
+See [`examples/`](examples/):
+
+- [`openai_durable_agent.py`](examples/openai_durable_agent.py) — a single durable
+  agent: tools as Flyte tasks, traced model turns, agent timeline in the report.
+- [`openai_multi_agent.py`](examples/openai_multi_agent.py) — multi-agent
+  orchestration: a planner agent decomposes a topic, researcher agents fan out
+  in parallel, an editor agent synthesizes — each agent its own durable action.
+- [`openai_handoffs.py`](examples/openai_handoffs.py) — handoffs + HITL: a
+  triage agent hands off to billing / technical specialists inside one
+  `Runner.run`; durability spans the handoff (a mid-chain crash replays both
+  agents' turns), a sensitive `issue_refund` tool is gated on a human-approval
+  form, and a diagnostic tool runs in a higher-CPU environment.
+- [`openai_crash_resume.py`](examples/openai_crash_resume.py) — crash &
+  resume: the task crashes on its first attempt after doing real work; on retry
+  the completed model turns replay from their `flyte.trace` records and the tool
+  calls are cache hits, so it finishes without re-calling the model. Run on a
+  backend to see the replay.
+- [`openai_memory.py`](examples/openai_memory.py) — cross-run memory: two
+  separate runs share a `memory_key`; the agent learns a fact in run 1 and recalls
+  it in run 2.
+
+## Notes
+
+- Streamed runs (`Runner.run_streamed`) are not memoized per-turn in this
+  version; tool calls remain durable regardless.
+
+## Conformance
+
+This adapter passes the shared `flyteplugins.agents.core.testing.assert_adapter_conforms`
+check, so it follows the common format (`tool` + `run_agent`, tool tasks wired
+to the resolver), shared with the Claude and Mistral adapters.

flyteplugins_agents_openai-2.5.9.dist-info/RECORD

@@ -0,0 +1,10 @@
+flyteplugins/agents/openai/__init__.py,sha256=bovIL0Nb3f6wB_AjkYmN9tmtSK2vBtbUoUglCmgwgaA,1323
+flyteplugins/agents/openai/_durable.py,sha256=vjQzhHUu8Uauknht99tOY35cDz4cWO1rz7YkR8gqdWI,4503
+flyteplugins/agents/openai/_memory.py,sha256=tTF74A3jVxcfw1NQAQfaXWqPJs6rprC_tjkX8-pCnNw,1762
+flyteplugins/agents/openai/_observability.py,sha256=4Ba7qvvZahmPmxVECvO7IOqa041fQzunW_yLYPlxA-w,4054
+flyteplugins/agents/openai/_run.py,sha256=2xsxk9hrfj9SRIlZ5EiccpAqVa03dzcSMAyC3DoN44M,3897
+flyteplugins/agents/openai/_tools.py,sha256=TVhMKuzi-8ExVNWGQ8GZ71y-ur-Wi2dvFlfWxTiJ6q8,5234
+flyteplugins_agents_openai-2.5.9.dist-info/METADATA,sha256=JCQwCKUs14X9JrP7WhYfjMBZkL9yrHvDbzGJuGQPeVs,5970
+flyteplugins_agents_openai-2.5.9.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flyteplugins_agents_openai-2.5.9.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_agents_openai-2.5.9.dist-info/RECORD,,

flyteplugins_agents_openai-2.5.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flyteplugins_agents_openai-2.5.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyteplugins