flyteplugins-agents-deepagents 2.5.15__py3-none-any.whl

flyteplugins/agents/deepagents/__init__.py

@@ -0,0 +1,27 @@
+"""Deep Agents adapter for Flyte.
+
+Bring your own `Deep Agent <https://docs.langchain.com/oss/python/deepagents/overview>`_
+— LangChain's agent harness with built-in planning, a virtual filesystem, and
+subagents — and run it durably on Flyte. The adapter provides:
+
+- :func:`tool` — turn a Flyte ``@env.task`` into a LangChain ``StructuredTool``
+  (a ``BaseTool``) that executes as a durable child action (own container/GPU,
+  retries, caching). Attach it to the main agent or to a subagent.
+- :func:`run_agent` — run the deep agent (a compiled ``create_deep_agent``
+  graph) inside your task and return the final answer. Either pass a pre-built
+  ``agent`` or let it build one from ``tools`` + ``model`` + ``instructions``
+  (Deep-Agents options like ``subagents=`` pass through).
+- :class:`DurableChatModel` — wrap any LangChain chat model so each model turn
+  is recorded/replayed via ``flyte.trace``; use it when building your own agent
+  with ``create_deep_agent(model=DurableChatModel(inner=...))``.
+
+Each tool call runs as a durable Flyte child action, and the run timeline is
+rendered into the Flyte task report. ``memory_key`` persists the conversation
+*and* the agent's virtual filesystem across runs.
+"""
+
+from ._durable import DurableChatModel
+from ._run import run_agent, run_agent_sync
+from ._tools import tool
+
+__all__ = ["DurableChatModel", "run_agent", "run_agent_sync", "tool"]

flyteplugins/agents/deepagents/_durable.py

@@ -0,0 +1,133 @@
+"""Durable, replayable model turns for Deep Agents chat models.
+
+A deep agent (``create_deep_agent``) is a compiled LangGraph graph whose loop
+calls the chat model once per iteration (a "model turn").
+:class:`DurableChatModel` wraps any LangChain ``BaseChatModel`` so every 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.deepagents.tool`), so the whole agent run becomes
+crash-resilient when the enclosing task carries ``retries=...``.
+
+The turn is recorded as JSON: the generated messages of the model's
+``ChatResult`` are serialized with ``message_to_dict`` and rebuilt with
+``messages_from_dict``, which keeps the recorded turn human-readable in the
+Flyte UI.
+
+Tool-calling still works because :meth:`DurableChatModel.bind_tools` delegates to
+the inner model to format the tools, then re-binds the resulting kwargs to *this*
+wrapper — so the deep agent's bound runnable still routes generation through the
+durable override. This also covers subagents: pass the wrapped model as a
+``SubAgent``'s ``model`` and its turns are durable too.
+"""
+
+from __future__ import annotations
+
+import json
+import typing
+
+from flyteplugins.agents.core import durable_step, fingerprint
+from langchain_core.language_models.chat_models import BaseChatModel
+
+if typing.TYPE_CHECKING:
+    from langchain_core.messages import BaseMessage
+    from langchain_core.outputs import ChatResult
+    from langchain_core.runnables import Runnable
+
+
+def _dumps_result(result: "ChatResult") -> str:
+    """Serialize a ``ChatResult``'s generated messages to JSON (readable in the UI)."""
+    from langchain_core.messages import message_to_dict
+
+    return json.dumps([message_to_dict(gen.message) for gen in result.generations])
+
+
+def _loads_result(payload: str) -> "ChatResult":
+    """Rebuild a ``ChatResult`` from the JSON written by :func:`_dumps_result`."""
+    from langchain_core.messages import messages_from_dict
+    from langchain_core.outputs import ChatGeneration, ChatResult
+
+    messages = messages_from_dict(json.loads(payload))
+    return ChatResult(generations=[ChatGeneration(message=m) for m in messages])
+
+
+class DurableChatModel(BaseChatModel):
+    """Wrap a ``BaseChatModel`` so each model turn is durable and replayable.
+
+    ``_agenerate`` (async) delegates to the inner model and records the turn via
+    ``durable_step``. Pass an instance as the deep agent's model —
+    ``create_deep_agent(model=DurableChatModel(inner=model), ...)`` — or as a
+    subagent's ``model``; ``bind_tools`` and other capabilities are delegated to
+    the inner model so tool-calling behaves exactly as the inner model does.
+
+    Durability is best-effort: if anything in the durable path raises, the turn
+    falls back to a direct inner call so a run is never broken by it.
+    """
+
+    inner: BaseChatModel
+    """The wrapped chat model that actually generates responses."""
+
+    @property
+    def _llm_type(self) -> str:
+        return f"durable-{self.inner._llm_type}"
+
+    def _turn_key(self, messages: typing.Sequence["BaseMessage"], **kwargs: typing.Any) -> str:
+        """Deterministic memo key for a model turn — serialized messages + bound tool names."""
+        from langchain_core.messages import messages_to_dict
+
+        tools = kwargs.get("tools") or []
+        tool_names = sorted(
+            (t.get("function", {}).get("name") or t.get("name") or str(t)) if isinstance(t, dict) else str(t)
+            for t in tools
+        )
+        return fingerprint(
+            {
+                "type": self._llm_type,
+                "messages": messages_to_dict(list(messages)),
+                "tools": tool_names,
+                "stop": kwargs.get("stop"),
+            }
+        )
+
+    async def _agenerate(self, messages, stop=None, run_manager=None, **kwargs) -> "ChatResult":  # type: ignore[override]
+        async def _call() -> "ChatResult":
+            return await self.inner._agenerate(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+        try:
+            key = self._turn_key(messages, stop=stop, **kwargs)
+            return await durable_step(
+                key,
+                _call,
+                name="model_turn",
+                dumps=_dumps_result,
+                loads=_loads_result,
+            )
+        except Exception:  # pragma: no cover - durability must never break a run
+            return await _call()
+
+    def _generate(self, messages, stop=None, run_manager=None, **kwargs) -> "ChatResult":  # type: ignore[override]
+        # ``durable_step`` is async; the sync path delegates straight through so
+        # sync callers keep working (durability applies to the async agent loop,
+        # which is the one Flyte tasks drive).
+        return self.inner._generate(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    def bind_tools(self, tools: typing.Sequence[typing.Any], **kwargs: typing.Any) -> "Runnable":
+        """Format tools via the inner model, but bind them to *this* wrapper.
+
+        The inner model knows how to convert tools into its provider format; we
+        reuse that, then re-bind the resulting kwargs to ``self`` so the runnable
+        the deep agent invokes still routes generation through the durable
+        override (rather than the inner model directly).
+        """
+        bound = self.inner.bind_tools(tools, **kwargs)
+        bound_kwargs = dict(getattr(bound, "kwargs", {}) or {})
+        return self.bind(**bound_kwargs)
+
+    def get_num_tokens(self, text: str) -> int:
+        return self.inner.get_num_tokens(text)
+
+    def get_num_tokens_from_messages(self, messages, tools=None) -> int:  # type: ignore[override]
+        if tools is not None:
+            return self.inner.get_num_tokens_from_messages(messages, tools=tools)
+        return self.inner.get_num_tokens_from_messages(messages)

flyteplugins/agents/deepagents/_memory.py

@@ -0,0 +1,93 @@
+"""Cross-run Deep Agents memory — a thin bridge over Flyte's keyed ``MemoryStore``.
+
+A deep agent is driven with a messages state (``graph.ainvoke({"messages":
+[...]})``) and also carries a virtual filesystem (the ``files`` state its
+built-in filesystem tools read and write). By default neither survives the run.
+This module bridges both: it resolves a keyed :class:`MemoryStore`, loads the
+prior conversation and files from path-addressed JSON slots, and writes them
+back after the run — so a later run with the same ``memory_key`` continues the
+conversation *and* sees the same virtual filesystem.
+
+The transcript is stored as ``messages_to_dict(...)`` output (rebuilt with
+``messages_from_dict``); the files state is stored as its plain
+``{path: contents}`` dict. All operations are best-effort: any failure leaves
+the run untouched (memory never breaks a run).
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyte._logging import logger
+from flyteplugins.agents.core import resolve_memory as _resolve_memory
+
+if typing.TYPE_CHECKING:
+    from langchain_core.messages import BaseMessage
+
+# Path-addressed memory slots inside the MemoryStore.
+_HISTORY_PATH = "deepagents/history.json"
+_FILES_PATH = "deepagents/files.json"
+
+
+async def resolve_memory(memory_key: str | None) -> typing.Any | None:
+    """Resolve a keyed MemoryStore for Deep Agents cross-run memory, or ``None``.
+
+    Best-effort: returns ``None`` when ``memory_key`` is falsy or no durable
+    store can be resolved, so memory never breaks a run.
+    """
+    if not memory_key:
+        return None
+    return await _resolve_memory(memory_key)
+
+
+async def load_history(store: typing.Any) -> list["BaseMessage"]:
+    """Load and deserialize the prior conversation from ``store``.
+
+    Returns an empty list when there is no prior history or on any error.
+    """
+    if store is None:
+        return []
+    try:
+        from langchain_core.messages import messages_from_dict
+
+        raw = await store.read_json.aio(_HISTORY_PATH, [])
+        return messages_from_dict(raw) if raw else []
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not load Deep Agents memory; continuing without prior history.")
+        return []
+
+
+async def load_files(store: typing.Any) -> dict[str, typing.Any]:
+    """Load the agent's prior virtual filesystem (``{path: contents}``) from ``store``.
+
+    Returns an empty dict when there are no prior files or on any error.
+    """
+    if store is None:
+        return {}
+    try:
+        return dict(await store.read_json.aio(_FILES_PATH, {}) or {})
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not load Deep Agents files; continuing without prior files.")
+        return {}
+
+
+async def save_state(
+    store: typing.Any,
+    messages: typing.Sequence["BaseMessage"],
+    files: typing.Mapping[str, typing.Any] | None = None,
+) -> None:
+    """Persist the conversation transcript and virtual filesystem to ``store``.
+
+    Best-effort: logs and returns on any error so memory never breaks a run.
+    """
+    if store is None or not messages:
+        return
+    try:
+        from langchain_core.messages import messages_to_dict
+
+        await store.write_json.aio(_HISTORY_PATH, messages_to_dict(list(messages)))
+        if files:
+            await store.write_json.aio(_FILES_PATH, dict(files))
+        await store.save.aio()
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not save Deep Agents memory; conversation will not be resumed.")

flyteplugins/agents/deepagents/_run.py

@@ -0,0 +1,207 @@
+"""``run_agent`` — run a LangChain Deep Agent on Flyte.
+
+Deep Agents (LangChain's agent harness) owns the loop: ``create_deep_agent``
+returns a compiled LangGraph graph with built-in planning (todos), a virtual
+filesystem, and subagents. ``run_agent`` runs that loop inside your
+``@env.task``: it builds a deep agent with Flyte-task tools, drives it, and
+returns the final answer. Each tool call runs as a durable Flyte child action
+(its own container/resources, with retries and caching).
+
+The graph is driven with a messages state: ``await graph.ainvoke({"messages":
+[{"role": "user", "content": input}]})``, and the final text is
+``result["messages"][-1].content``. The result state also carries ``files`` —
+the agent's virtual filesystem — which ``memory_key`` persists across runs
+alongside the conversation.
+
+Observability: the run timeline is rendered into the Flyte task report.
+
+The adapter minimizes delta between native Deep Agents code and Flyte
+integration by exposing tools that are drop-in ``BaseTool`` instances.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyteplugins.agents.core import ReportTimeline, flush_report, sync_variant
+
+from ._durable import DurableChatModel
+from ._memory import load_files, load_history, resolve_memory, save_state
+from ._tools import _coerce_tool
+
+# Module-level alias for test monkeypatching: tests substitute the graph builder
+# without importing a real provider model.
+_create_deep_agent = None
+
+
+def _resolve_chat_model(model: typing.Any) -> typing.Any:
+    """Return a LangChain chat model. A model instance passes through; a
+    ``provider:model`` string resolves via ``init_chat_model``. ``None`` is an
+    error — the caller must choose a model."""
+    if model is None:
+        raise ValueError(
+            "Provide `model=` when building the agent (or pass a pre-built `agent=`). "
+            'For example: `model="anthropic:claude-sonnet-4-6"` or a chat-model instance.'
+        )
+    from langchain_core.language_models.chat_models import BaseChatModel
+
+    if isinstance(model, BaseChatModel):
+        return model
+    from langchain.chat_models import init_chat_model
+
+    return init_chat_model(model)
+
+
+def _wrap_durable(model: typing.Any) -> typing.Any:
+    """Wrap a chat model in :class:`DurableChatModel` when possible.
+
+    Best-effort: only ``BaseChatModel`` instances are wrappable; anything else
+    (or any failure) is returned unchanged so durability never breaks a run.
+    """
+    try:
+        from langchain_core.language_models.chat_models import BaseChatModel
+
+        if isinstance(model, BaseChatModel) and not isinstance(model, DurableChatModel):
+            return DurableChatModel(inner=model)
+    except Exception:  # pragma: no cover - durability is best-effort, never fatal
+        pass
+    return model
+
+
+def _final_text(result: typing.Any) -> str:
+    """Extract the agent's final text from a compiled-graph result.
+
+    Deep agent graphs return a messages state ``{"messages": [...], "files":
+    {...}}``; the final answer is the content of the last message. Falls back
+    gracefully for other shapes.
+    """
+    if isinstance(result, dict):
+        messages = result.get("messages")
+        if messages:
+            content = getattr(messages[-1], "content", messages[-1])
+            return content if isinstance(content, str) else str(content)
+        return ""
+    return str(result)
+
+
+def _result_messages(result: typing.Any) -> list[typing.Any]:
+    """Extract the message list from a compiled-graph result (empty on other shapes)."""
+    if isinstance(result, dict):
+        messages = result.get("messages")
+        if messages:
+            return list(messages)
+    return []
+
+
+async def run_agent(
+    input: str,
+    *,
+    tools: typing.Sequence[typing.Any] = (),
+    model: typing.Any = None,
+    instructions: str | None = None,
+    agent: typing.Any = None,
+    name: str = "deep-agent",
+    durable: bool = True,
+    observability: bool = True,
+    memory_key: str | None = None,
+    **agent_kwargs: typing.Any,
+) -> str:
+    """Run a Deep Agent with the given tools and prompt; return the final text.
+
+    Await this from an async task as ``await run_agent(...)``; from a sync task
+    use :func:`run_agent_sync` instead.
+
+    Call this from inside an ``@env.task`` — that task is the durable parent.
+    Within it, 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 pre-built ``agent`` (a compiled graph from
+    ``create_deep_agent``) or ``tools`` + ``model`` to have one built for you.
+    Deep-Agents-specific options — ``subagents=``, ``skills=``, ``backend=``,
+    ``interrupt_on=``, … — pass through ``**agent_kwargs`` on the builder path.
+
+    Args:
+        input: The user prompt.
+        tools: ``tool``-wrapped tools or bare ``@env.task`` templates.
+        model: A LangChain chat model instance or a ``provider:model`` string
+            (e.g. ``"anthropic:claude-sonnet-4-6"``). Required when ``agent``
+            is not given.
+        instructions: System prompt for the built agent.
+        agent: A pre-built deep agent (a compiled ``create_deep_agent`` graph).
+            Mutually exclusive with ``tools``. To get durable model turns on this
+            path, build it with ``create_deep_agent(model=DurableChatModel(inner=...))``.
+        name: Agent name (for debugging/observability).
+        durable: Record/replay each model turn via ``flyte.trace``. Applies when
+            the agent is being built — the resolved model is wrapped in
+            :class:`DurableChatModel`. A fully pre-built compiled ``agent`` cannot
+            be rewrapped (wrap its model yourself, see above); its tool calls
+            remain durable regardless.
+        observability: Render the run timeline into the Flyte task report.
+        memory_key: Stable id (e.g. a user/thread id) for cross-run memory.
+            When set, the conversation *and* the agent's virtual filesystem are
+            persisted to a keyed ``MemoryStore`` and resumed on a later run with
+            the same key.
+        **agent_kwargs: Additional kwargs forwarded to ``create_deep_agent``
+            (``subagents=``, ``skills=``, ``backend=``, ...).
+
+    Returns:
+        The agent's final output as a string.
+    """
+    timeline = ReportTimeline() if observability else None
+    if timeline is not None:
+        timeline.heading("Deep agent")
+
+    if agent is not None and tools:
+        raise ValueError("Pass either `agent` (with its own tools) or `tools`, not both.")
+
+    # Build the agent (a compiled graph) if not provided.
+    if agent is None:
+        if _create_deep_agent is None:
+            from deepagents import create_deep_agent as create_deep_agent_fn
+        else:
+            create_deep_agent_fn = _create_deep_agent
+
+        chat_model = _resolve_chat_model(model)
+        # Wrap the chat model so each model turn is durable/replayable. We can
+        # only do this on the builder path (a fully pre-built compiled ``agent``
+        # owns its own model, which we cannot reach to rewrap).
+        if durable:
+            chat_model = _wrap_durable(chat_model)
+
+        tool_objs = [_coerce_tool(t) for t in tools]
+        system_prompt = instructions or f"You are a helpful assistant named {name}."
+        agent = create_deep_agent_fn(
+            model=chat_model,
+            tools=tool_objs,
+            system_prompt=system_prompt,
+            **agent_kwargs,
+        )
+
+    # Cross-run memory: load the prior conversation and virtual filesystem and
+    # seed the run with both, then persist the updated state back after.
+    store = await resolve_memory(memory_key)
+    prior = await load_history(store)
+    files = await load_files(store)
+
+    state: dict[str, typing.Any] = {"messages": [*prior, {"role": "user", "content": input}]}
+    if files:
+        state["files"] = files
+
+    result = await agent.ainvoke(state)
+
+    await save_state(
+        store,
+        _result_messages(result),
+        files=result.get("files") if isinstance(result, dict) else None,
+    )
+
+    final = _final_text(result)
+
+    if observability:
+        await flush_report()
+
+    return final or ""
+
+
+run_agent_sync = sync_variant(run_agent)

flyteplugins/agents/deepagents/_tools.py

@@ -0,0 +1,176 @@
+"""Turn Flyte tasks into Deep Agents tools that execute as durable actions.
+
+Deep Agents (LangChain's agent harness) accepts LangChain ``BaseTool`` instances
+as tools — both on the main agent (``create_deep_agent(tools=[...])``) and on
+subagents (``SubAgent(tools=[...])``). :func:`tool` wraps a Flyte ``@env.task``
+as a LangChain ``StructuredTool`` whose async coroutine dispatches to the task
+via ``task.aio()`` — so when the agent calls the tool, it runs as a durable
+Flyte child action (its own container/resources, with retries and caching)
+rather than inline in the agent's process.
+
+The returned object is a real ``StructuredTool`` (a ``BaseTool``), so it drops
+straight into ``create_deep_agent(tools=[...])`` or a subagent's tool list. It
+additionally exposes ``__wrapped_task__`` and ``task`` (via direct attribute
+assignment, which ``StructuredTool`` permits) and wires the backing task to
+:class:`~flyteplugins.agents.core.ToolTaskResolver` so it resolves to itself on
+the worker (no recursion).
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import typing
+from functools import partial
+
+from flyte._task import AsyncFunctionTaskTemplate
+from flyteplugins.agents.core import attach_tool_resolver, coerce_tool_args
+
+
+def tool(
+    func: AsyncFunctionTaskTemplate | typing.Callable | None = None,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> typing.Any:
+    """Convert a Flyte task (or plain callable) into a LangChain ``StructuredTool``.
+
+    - For an ``@env.task``: returns a ``StructuredTool`` whose async coroutine runs
+      the task as a durable Flyte child action when the agent invokes it. The input
+      schema is derived from the task's typed signature. The backing task is wired to
+      :class:`~flyteplugins.agents.core.ToolTaskResolver` and exposed via
+      ``__wrapped_task__`` so it resolves to itself on the worker (no recursion).
+    - For a plain (async) callable: returns a ``StructuredTool`` that runs it inline.
+
+    Usable bare, parametrized, or as a direct call::
+
+        @tool
+        @env.task
+        async def get_weather(city: str) -> str: ...
+    """
+    if func is None:
+        return partial(tool, name=name, description=description)
+    if isinstance(func, AsyncFunctionTaskTemplate):
+        return _task_to_tool(func, name=name, description=description)
+    return _callable_to_tool(func, name=name, description=description)
+
+
+def _task_to_tool(
+    task: AsyncFunctionTaskTemplate,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> typing.Any:
+    """Build a LangChain ``StructuredTool`` from a Flyte task."""
+    from langchain_core.tools import StructuredTool
+
+    tool_name = name or task.func.__name__
+    desc = (description or task.func.__doc__ or f"Run {tool_name}").strip()
+
+    async def _arun(**kwargs: typing.Any) -> str:
+        # In a Flyte task context this submits a durable child action; locally it
+        # runs inline. ``coerce_tool_args`` relaxes LLM int->float args so Flyte's
+        # type engine doesn't reject e.g. ``amount_usd=42`` for a ``float`` param.
+        result = await task.aio(**coerce_tool_args(task, kwargs or {}))
+        return _as_content(result)
+
+    # Wire the shared resolver so the task resolves to itself on the worker.
+    attach_tool_resolver(task)
+
+    # Derive an explicit args schema from the task's typed signature. The coroutine
+    # above is ``**kwargs``-only, so LangChain's own inference would produce a single
+    # ``kwargs`` object param — we build the real pydantic model instead.
+    args_schema = _args_schema_from_callable(task.func, tool_name)
+
+    structured = StructuredTool.from_function(
+        func=None,
+        coroutine=_arun,
+        name=tool_name,
+        description=desc,
+        args_schema=args_schema,
+    )
+
+    # Expose the real task and a convenient ``task`` alias so callers/tests can reach
+    # the backing task. ``StructuredTool`` is a pydantic model whose ``__setattr__``
+    # rejects non-field names, so set them through ``object.__setattr__`` (dunders
+    # like ``__wrapped_task__`` would bypass it, but keep both paths uniform).
+    object.__setattr__(structured, "__wrapped_task__", task)
+    object.__setattr__(structured, "task", task)
+    return structured
+
+
+def _callable_to_tool(
+    func: typing.Callable,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> typing.Any:
+    """Build a LangChain ``StructuredTool`` from a plain callable."""
+    from langchain_core.tools import StructuredTool
+
+    tool_name = name or getattr(func, "__name__", "tool")
+    desc = (description or func.__doc__ or f"Run {tool_name}").strip()
+
+    async def _arun(**kwargs: typing.Any) -> str:
+        out = func(**(kwargs or {}))
+        if inspect.isawaitable(out):
+            out = await out
+        return _as_content(out)
+
+    args_schema = _args_schema_from_callable(func, tool_name)
+
+    return StructuredTool.from_function(
+        func=None,
+        coroutine=_arun,
+        name=tool_name,
+        description=desc,
+        args_schema=args_schema,
+    )
+
+
+def _args_schema_from_callable(func: typing.Callable, tool_name: str) -> typing.Any | None:
+    """Build a pydantic ``args_schema`` from a callable's typed signature.
+
+    Returns ``None`` (letting LangChain infer) if the signature can't be resolved.
+    The model's fields mirror the callable's parameters, with annotations and
+    defaults preserved so the LLM sees a correct tool schema.
+    """
+    from pydantic import create_model
+
+    try:
+        hints = typing.get_type_hints(func)
+        sig = inspect.signature(func)
+    except Exception:  # pragma: no cover - unresolved annotations; let LangChain infer
+        return None
+
+    fields: dict[str, typing.Any] = {}
+    for pname, param in sig.parameters.items():
+        if pname == "self" or param.kind in (
+            inspect.Parameter.VAR_POSITIONAL,
+            inspect.Parameter.VAR_KEYWORD,
+        ):
+            continue
+        annotation = hints.get(pname, typing.Any)
+        default = ... if param.default is inspect.Parameter.empty else param.default
+        fields[pname] = (annotation, default)
+
+    if not fields:
+        return None
+    return create_model(f"{tool_name}Args", **fields)
+
+
+def _as_content(result: typing.Any) -> str:
+    """Convert a tool result to a string for LangChain's ToolMessage."""
+    if isinstance(result, str):
+        return result
+    try:
+        return json.dumps(result, default=str)
+    except (TypeError, ValueError):
+        return str(result)
+
+
+def _coerce_tool(t: typing.Any) -> typing.Any:
+    """Coerce a bare ``@env.task`` into a LangChain tool; pass everything else through."""
+    if isinstance(t, AsyncFunctionTaskTemplate):
+        return tool(t)
+    return t

flyteplugins_agents_deepagents-2.5.15.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: flyteplugins-agents-deepagents
+Version: 2.5.15
+Summary: Run LangChain Deep Agents on Flyte.
+Author-email: Niels Bantilan <niels@union.ai>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: flyteplugins-agents-core
+Requires-Dist: deepagents
+
+# flyteplugins-agents-deepagents
+
+Run [Deep Agents](https://docs.langchain.com/oss/python/deepagents/overview) —
+LangChain's agent harness with built-in planning, a virtual filesystem, and
+subagents — durably on Flyte.
+
+```bash
+pip install flyteplugins-agents-deepagents
+```
+
+You keep writing Deep Agents code; Flyte is the durable runtime underneath:
+
+- **Tools are Flyte tasks.** Stack `@tool` on `@env.task` and each tool call the
+  agent (or any of its subagents) makes runs as a durable child action — its own
+  container/resources, retries, and caching.
+- **Model turns are replayable.** On the builder path (or by wrapping your own
+  model in `DurableChatModel`), every model turn is recorded via `flyte.trace`,
+  so a crashed/retried run replays completed turns instead of re-calling (and
+  re-billing) the model.
+- **Memory spans runs.** `run_agent(..., memory_key=...)` persists the
+  conversation *and* the agent's virtual filesystem to a durable keyed store, so
+  a later run with the same key picks up both.
+
+```python
+import flyte
+from flyteplugins.agents.deepagents import run_agent, tool
+
+env = flyte.TaskEnvironment("deep-agent")
+
+@tool
+@env.task(cache="auto", retries=3)
+async def search_web(query: str) -> str:
+    """Search the web for a query."""
+    ...
+
+@env.task(report=True, retries=3)
+async def research_agent(question: str) -> str:
+    return await run_agent(
+        question,
+        tools=[search_web],
+        instructions="You are an expert researcher.",
+        model="anthropic:claude-sonnet-4-6",
+        subagents=[{
+            "name": "critic",
+            "description": "Critiques draft answers.",
+            "system_prompt": "You are a ruthless critic.",
+        }],
+    )
+```
+
+To bring your own agent, build it with `create_deep_agent` (attaching
+`@tool`-wrapped tasks natively) and pass it as `run_agent(agent=...)`; wrap the
+model in `DurableChatModel(inner=...)` to keep durable model turns on that path.
+See [examples/](examples/) for the full patterns.

flyteplugins_agents_deepagents-2.5.15.dist-info/RECORD

@@ -0,0 +1,9 @@
+flyteplugins/agents/deepagents/__init__.py,sha256=oUTjQAuCAcgvFBDkXNuo5cScllc0lgjRYhmyRg14MZA,1406
+flyteplugins/agents/deepagents/_durable.py,sha256=MfliWgoUVBPcj4zF3bZ6DDWxrC5xVhoq3__wlY17gq8,6068
+flyteplugins/agents/deepagents/_memory.py,sha256=403PfaIPl14YvdYcxJMUc2W1BpbZGmCRVPWPX2FjsKs,3636
+flyteplugins/agents/deepagents/_run.py,sha256=rgS_OwdROsDpUxKrl0NCBsB_iCjjp6e_HN52uhNbwtY,8324
+flyteplugins/agents/deepagents/_tools.py,sha256=KSo3m0yOdJB4RjU_aomBJGMI6nQ80oFM-ava07kIcj8,6794
+flyteplugins_agents_deepagents-2.5.15.dist-info/METADATA,sha256=ORAMIZ2NSrgJz8rxD8hID7mydEMdg8WikmlLb2iBCU8,2304
+flyteplugins_agents_deepagents-2.5.15.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flyteplugins_agents_deepagents-2.5.15.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_agents_deepagents-2.5.15.dist-info/RECORD,,

flyteplugins_agents_deepagents-2.5.15.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_deepagents-2.5.15.dist-info/top_level.txt

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