flyteplugins-agents-langgraph 2.5.17__py3-none-any.whl

flyteplugins/agents/langgraph/__init__.py

@@ -0,0 +1,24 @@
+"""LangGraph adapter for Flyte.
+
+Bring your own LangGraph ``StateGraph`` and run it durably on Flyte. You build the
+graph; the adapter provides the durable, observable building blocks:
+
+- :func:`tool` — turn a Flyte ``@env.task`` into a LangChain ``StructuredTool``
+  (a first-class LangGraph tool) that executes as a durable child action (own
+  container/GPU, retries, caching).
+- :func:`ai_node` — the model-calling node: binds the tools to your chat model
+  and records each model turn durably (replayed on retry).
+- :func:`tool_node` — the tool-executing node: runs the model's tool calls as
+  durable Flyte child actions.
+- :func:`run_agent` — drive a compiled graph (or build a default one from tools)
+  inside your task and return the final answer.
+
+Each tool call runs as a durable Flyte child action, and the run timeline is
+rendered into the Flyte task report.
+"""
+
+from ._nodes import ai_node, tool_node
+from ._run import run_agent, run_agent_sync
+from ._tools import tool
+
+__all__ = ["ai_node", "run_agent", "run_agent_sync", "tool", "tool_node"]

flyteplugins/agents/langgraph/_memory.py

@@ -0,0 +1,59 @@
+"""Cross-run LangGraph memory — a thin bridge over Flyte's keyed ``MemoryStore``.
+
+LangGraph keeps conversation state in-memory. This module persists the message
+transcript to a durable, keyed :class:`~flyte.ai.agents.memory.MemoryStore` (an
+object-store slot addressed by ``memory_key``) so a later run with the same key
+continues the conversation — across workers and restarts.
+
+The transcript is stored (via ``read_json`` / ``write_json``) as the serialized
+LangChain message list, so it round-trips faithfully through
+``messages_from_dict`` / ``messages_to_dict``.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyte._logging import logger
+from flyteplugins.agents.core import resolve_memory as _resolve_memory
+
+# Path-addressed slot holding the serialized message transcript inside the MemoryStore.
+_MEMORY_HISTORY_PATH = "langgraph/history.json"
+
+
+async def resolve_memory(memory_key: str | None) -> typing.Any | None:
+    """Resolve a keyed MemoryStore for LangGraph 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_messages(store: typing.Any) -> list[typing.Any]:
+    """Load the prior conversation as LangChain messages (empty list if none)."""
+    if store is None:
+        return []
+    try:
+        from langchain_core.messages import messages_from_dict
+
+        raw = await store.read_json.aio(_MEMORY_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 LangGraph memory; continuing without prior history.")
+        return []
+
+
+async def save_messages(store: typing.Any, messages: typing.Sequence[typing.Any]) -> None:
+    """Persist the full conversation transcript back to the keyed store."""
+    if store is None or not messages:
+        return
+    try:
+        from langchain_core.messages import messages_to_dict
+
+        await store.write_json.aio(_MEMORY_HISTORY_PATH, messages_to_dict(list(messages)))
+        await store.save.aio()
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not persist LangGraph memory; continuing.")

flyteplugins/agents/langgraph/_nodes.py

@@ -0,0 +1,165 @@
+"""LangGraph node factories that make Flyte the durable runtime under a graph.
+
+The intended devex: you build the ``StateGraph`` yourself, and these two factories
+provide the nodes that Flyte makes durable and observable.
+
+- :func:`ai_node` — the model-calling node. It binds your ``@tool``-wrapped tasks
+  to the chat model and runs one model turn. Each turn is recorded as a durable
+  ``flyte.trace`` leaf (via :func:`~flyteplugins.agents.core.durable_step`), so a
+  crash/retry replays the recorded response instead of re-calling (and re-billing)
+  the model.
+- :func:`tool_node` — the tool-executing node. It runs the tool calls the model
+  emitted; each ``@tool``-wrapped task runs as a durable Flyte child action (its
+  own container/resources, retries, caching).
+
+Both render their turns into the Flyte task report. Wire them into a standard
+tool-calling loop::
+
+    from langgraph.graph import StateGraph, MessagesState, START
+    from langgraph.prebuilt import tools_condition
+
+    builder = StateGraph(MessagesState)
+    builder.add_node("ai", ai_node(model, tools))
+    builder.add_node("tools", tool_node(tools))
+    builder.add_edge(START, "ai")
+    builder.add_conditional_edges("ai", tools_condition)
+    builder.add_edge("tools", "ai")
+    graph = builder.compile()
+"""
+
+from __future__ import annotations
+
+import json
+import typing
+
+from flyteplugins.agents.core import ReportTimeline, abbrev, durable_step, fingerprint
+
+if typing.TYPE_CHECKING:
+    from langchain_core.language_models.chat_models import BaseChatModel
+
+# A node is an (optionally async) callable ``state -> partial_state``.
+Node = typing.Callable[[dict], typing.Awaitable[dict]]
+
+
+def _message_text(message: typing.Any) -> str:
+    content = getattr(message, "content", message)
+    return content if isinstance(content, str) else str(content)
+
+
+def ai_node(
+    model: "BaseChatModel",
+    tools: typing.Sequence[typing.Any],
+    *,
+    name: str = "ai",
+    durable: bool = True,
+    observability: bool = True,
+) -> Node:
+    """Build the model-calling node for a tool-calling graph.
+
+    The returned node binds ``tools`` to ``model`` and runs a single model turn
+    over ``state["messages"]``, appending the model's response. Pass
+    ``@tool``-wrapped tasks (or any LangChain ``BaseTool``) as ``tools``.
+
+    Args:
+        model: A LangChain chat model (e.g. ``ChatOpenAI(model="gpt-4o")``).
+        tools: The tools to expose to the model.
+        name: Node label (used for the graph node and the trace/report entry).
+        durable: Record each model turn via ``flyte.trace`` so retries replay it.
+        observability: Render each model turn into the Flyte task report.
+
+    Returns:
+        An async node ``state -> {"messages": [ai_message]}``.
+    """
+    bound = model.bind_tools(list(tools))
+    timeline = ReportTimeline() if observability else None
+
+    async def _ai(state: dict) -> dict:
+        from langchain_core.messages import message_to_dict, messages_from_dict, messages_to_dict
+
+        messages = state["messages"]
+
+        async def _call() -> typing.Any:
+            return await bound.ainvoke(messages)
+
+        if durable:
+            key = fingerprint({"node": name, "messages": messages_to_dict(list(messages))})
+            response = await durable_step(
+                key,
+                _call,
+                name=f"{name}:model",
+                dumps=lambda m: json.dumps(message_to_dict(m)),
+                loads=lambda s: messages_from_dict([json.loads(s)])[0],
+            )
+        else:
+            response = await _call()
+
+        if timeline is not None:
+            tool_calls = getattr(response, "tool_calls", None) or []
+            if tool_calls:
+                detail = "→ " + ", ".join(tc["name"] for tc in tool_calls)
+            else:
+                detail = abbrev(_message_text(response), 200)
+            timeline.row(icon="🤖", label=name, meta="assistant", detail=detail)
+
+        return {"messages": [response]}
+
+    _ai.__name__ = name
+    return _ai
+
+
+def tool_node(
+    tools: typing.Sequence[typing.Any],
+    *,
+    name: str = "tools",
+    observability: bool = True,
+) -> Node:
+    """Build the tool-executing node for a tool-calling graph.
+
+    The returned node reads the tool calls from the last message and runs each
+    one, appending a ``ToolMessage`` per call. ``@tool``-wrapped tasks run as
+    durable Flyte child actions; anything else runs as the tool defines.
+
+    Args:
+        tools: The tools available to execute (``@tool``-wrapped tasks or any
+            LangChain ``BaseTool``).
+        name: Node label (used for the report entry).
+        observability: Render each tool call/result into the Flyte task report.
+
+    Returns:
+        An async node ``state -> {"messages": [tool_message, ...]}``.
+    """
+    registry = {getattr(t, "name", getattr(t, "__name__", "")): t for t in tools}
+    timeline = ReportTimeline() if observability else None
+
+    async def _tools(state: dict) -> dict:
+        from langchain_core.messages import ToolMessage
+
+        messages = state["messages"]
+        last = messages[-1] if messages else None
+        calls = getattr(last, "tool_calls", None) or []
+
+        results: list[typing.Any] = []
+        for call in calls:
+            tool_name = call["name"]
+            args = call.get("args", {}) or {}
+            call_id = call.get("id", "")
+            if timeline is not None:
+                timeline.row(icon="🛠️", label=tool_name, meta="tool", detail=abbrev(str(args), 160))
+
+            selected = registry.get(tool_name)
+            if selected is None:
+                output = f"Error: unknown tool '{tool_name}'"
+            else:
+                try:
+                    output = await selected.ainvoke(args)
+                except Exception as exc:  # surface tool errors back to the model
+                    output = f"Error: {exc}"
+
+            if timeline is not None:
+                timeline.row(icon="🔧", label=tool_name, meta="tool result", detail=abbrev(str(output), 160))
+            results.append(ToolMessage(content=str(output), tool_call_id=call_id, name=tool_name))
+
+        return {"messages": results}
+
+    _tools.__name__ = name
+    return _tools

flyteplugins/agents/langgraph/_run.py

@@ -0,0 +1,196 @@
+"""``run_agent`` — drive a LangGraph graph on Flyte.
+
+The intended devex is that *you* build the ``StateGraph`` (with
+:func:`~flyteplugins.agents.langgraph.ai_node` /
+:func:`~flyteplugins.agents.langgraph.tool_node`), compile it, and hand the
+compiled graph to ``run_agent(agent=...)``. ``run_agent`` runs that graph inside
+your ``@env.task``: each model turn is durable (replayed on retry) and each tool
+call runs as a durable Flyte child action.
+
+As a convenience, passing ``tools`` (instead of ``agent``) builds a default
+tool-calling graph for you from the same ``ai_node`` / ``tool_node`` building
+blocks.
+
+Observability: the run timeline — model turns and tool calls — is rendered into
+the Flyte task report.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyteplugins.agents.core import ReportTimeline, flush_report, sync_variant
+
+from ._nodes import ai_node, tool_node
+from ._tools import _coerce_tool
+
+try:  # langgraph is a hard dependency; guarded only so imports never hard-crash.
+    from langgraph.graph import END, START, MessagesState, StateGraph
+    from langgraph.prebuilt import tools_condition
+except Exception:  # pragma: no cover - langgraph missing
+    END = START = MessagesState = StateGraph = tools_condition = None  # type: ignore[assignment]
+
+# Module-level aliases so the builder path can be redirected in tests.
+_StateGraph = StateGraph
+_MessagesState = MessagesState
+_START = START
+_tools_condition = tools_condition
+
+
+def _resolve_chat_model(model: typing.Any) -> typing.Any:
+    """Return a LangChain chat model for the default-graph builder.
+
+    A chat-model instance passes through unchanged. A ``provider:model`` string
+    resolves via ``langchain.chat_models.init_chat_model`` (requires the
+    ``langchain`` package). ``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=ChatOpenAI(model="gpt-4o")`.'
+        )
+    if not isinstance(model, str):
+        return model
+    try:
+        from langchain.chat_models import init_chat_model
+    except ImportError as e:
+        raise ImportError(
+            f"Resolving the model string {model!r} requires the `langchain` package. "
+            "Pass a chat-model instance instead, or install `langchain` to use "
+            "`provider:model` strings."
+        ) from e
+
+    return init_chat_model(model)
+
+
+def _build_default_graph(
+    *,
+    model: typing.Any,
+    tools: typing.Sequence[typing.Any],
+    durable: bool,
+    observability: bool,
+) -> typing.Any:
+    """Build the standard tool-calling graph from ``ai_node`` + ``tool_node``."""
+    chat_model = _resolve_chat_model(model)
+    builder = _StateGraph(_MessagesState)
+    builder.add_node("ai", ai_node(chat_model, tools, name="ai", durable=durable, observability=observability))
+    builder.add_node("tools", tool_node(tools, name="tools", observability=observability))
+    builder.add_edge(_START, "ai")
+    builder.add_conditional_edges("ai", _tools_condition)
+    builder.add_edge("tools", "ai")
+    return builder.compile()
+
+
+def _final_text(result: typing.Any) -> str:
+    """Extract the final assistant text from a graph's output state."""
+    if isinstance(result, dict):
+        messages = result.get("messages", [])
+        if messages:
+            last = messages[-1]
+            content = last.get("content") if isinstance(last, dict) else getattr(last, "content", None)
+            if content is not None:
+                return content if isinstance(content, str) else str(content)
+        return ""
+    return str(result) if result is not None else ""
+
+
+async def run_agent(
+    input: str | typing.Any,
+    *,
+    tools: typing.Sequence[typing.Any] = (),
+    model: typing.Any = None,
+    instructions: str | None = None,
+    agent: typing.Any = None,
+    name: str = "langgraph-agent",
+    durable: bool = True,
+    observability: bool = True,
+    memory_key: str | None = None,
+    **run_kwargs: typing.Any,
+) -> str:
+    """Run a LangGraph graph and 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 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 pre-built ``agent`` (a compiled ``StateGraph`` you built
+    with :func:`ai_node` / :func:`tool_node`) or ``tools`` to have a default
+    tool-calling graph built for you. The two are mutually exclusive.
+
+    Args:
+        input: The user prompt (a ``str``) or a full graph input state (a dict).
+        tools: ``@tool``-wrapped tools or bare ``@env.task`` templates (used only
+            when ``agent`` is not given).
+        model: A LangChain chat-model instance (e.g. ``ChatOpenAI(model="gpt-4o")``)
+            or a ``provider:model`` string (resolved via ``init_chat_model``, which
+            requires the ``langchain`` package). Required when building the graph
+            (i.e. when ``agent`` is not given).
+        instructions: System prompt prepended to a built graph's messages.
+        agent: A pre-built compiled LangGraph graph. Mutually exclusive with ``tools``.
+        name: Graph name (for debugging/observability).
+        durable: Record each model turn via ``flyte.trace`` (built graphs only).
+        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 transcript is persisted to a keyed ``MemoryStore``
+            and resumed on a later run with the same key.
+        **run_kwargs: Additional kwargs forwarded to the graph's ``ainvoke``.
+
+    Returns:
+        The graph's final assistant message as a string.
+    """
+    from langchain_core.messages import HumanMessage, SystemMessage
+
+    from ._memory import load_messages, resolve_memory, save_messages
+
+    if agent is not None and tools:
+        raise ValueError("Pass either `agent` (with its own tools) or `tools`, not both.")
+
+    timeline = ReportTimeline() if observability else None
+    if timeline is not None:
+        timeline.heading("LangGraph agent")
+
+    # Cross-run memory: the prior transcript (if any) is prepended to the run's
+    # messages, and the full transcript is persisted back afterwards.
+    store = await resolve_memory(memory_key)
+    prior = await load_messages(store)
+
+    if agent is None:
+        agent = _build_default_graph(
+            model=model,
+            tools=[_coerce_tool(t) for t in tools],
+            durable=durable,
+            observability=observability,
+        )
+        seed: list[typing.Any] = []
+        # The system prompt is only needed once; on resumed runs it already lives
+        # in the prior transcript.
+        if instructions and not prior:
+            seed.append(SystemMessage(content=instructions))
+        seed.extend(prior)
+        seed.append(HumanMessage(content=input))
+        input_state: typing.Any = {"messages": seed}
+    elif isinstance(input, str):
+        input_state = {"messages": [*prior, HumanMessage(content=input)]}
+    else:
+        input_state = input or {}
+        if prior:
+            input_state = {**input_state, "messages": [*prior, *input_state.get("messages", [])]}
+
+    try:
+        result = await agent.ainvoke(input_state, **run_kwargs)
+    finally:
+        if observability:
+            await flush_report()
+
+    if store is not None and isinstance(result, dict) and result.get("messages"):
+        await save_messages(store, result["messages"])
+
+    return _final_text(result)
+
+
+run_agent_sync = sync_variant(run_agent)

flyteplugins/agents/langgraph/_tools.py

@@ -0,0 +1,170 @@
+"""Turn Flyte tasks into LangGraph-compatible tools that run as durable actions.
+
+LangGraph (via LangChain) drives tools that are ``BaseTool`` instances: it binds
+them to the model (``model.bind_tools([...])``) so the LLM can call them, and it
+executes them from a tool node. :func:`tool` wraps a Flyte ``@env.task`` as a
+LangChain ``StructuredTool`` whose async body dispatches to the task via
+``task.aio()`` — so when the graph executes the tool, it runs as a durable Flyte
+child action (its own container/resources, with retries and caching) rather than
+inline in the graph's process.
+
+The returned tool is a first-class ``StructuredTool``: pass it straight to
+``model.bind_tools(...)``, to :func:`~flyteplugins.agents.langgraph.tool_node`,
+or to LangGraph's ``ToolNode``. It additionally exposes ``__wrapped_task__`` /
+``task`` (so the backing task resolves to itself on the worker, no recursion) and
+``__name__`` for convenience.
+"""
+
+from __future__ import annotations
+
+import functools
+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
+
+try:  # pragma: no cover - import shape only
+    from langchain_core.tools import StructuredTool
+except Exception:  # pragma: no cover
+    StructuredTool = None  # type: ignore[assignment,misc]
+
+
+if StructuredTool is not None:
+
+    class FlyteStructuredTool(StructuredTool):
+        """A LangChain ``StructuredTool`` backed by a Flyte task.
+
+        Behaves exactly like a ``StructuredTool`` (so LangGraph's ``bind_tools`` /
+        ``ToolNode`` accept it), while carrying the backing task so it resolves to
+        itself on the worker.
+        """
+
+        flyte_task: typing.Any = None
+
+        @property
+        def task(self) -> typing.Any:
+            return self.flyte_task
+
+        @property
+        def __wrapped_task__(self) -> typing.Any:
+            return self.flyte_task
+else:  # pragma: no cover - langchain-core missing
+    FlyteStructuredTool = None  # type: ignore[assignment,misc]
+
+
+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 body runs the
+      task as a durable Flyte child action when the graph invokes it. The input
+      schema is inferred 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.
+
+    The result is a first-class LangGraph tool — bind it to a model or hand it to
+    :func:`~flyteplugins.agents.langgraph.tool_node` /
+    :func:`~flyteplugins.agents.langgraph.ai_node`.
+
+    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."""
+    tool_name = name or task.func.__name__
+    desc = (description or task.func.__doc__ or f"Run {tool_name}").strip()
+
+    # ``functools.wraps`` copies the task function's signature (via ``__wrapped__``)
+    # so ``StructuredTool.from_function`` infers the correct args schema, while the
+    # body dispatches to ``task.aio`` for durable execution. ``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.
+    @functools.wraps(task.func)
+    async def _arun(**kwargs: typing.Any) -> str:
+        result = await task.aio(**coerce_tool_args(task, kwargs or {}))
+        return _as_content(result)
+
+    _arun.__name__ = tool_name
+
+    # Wire the shared resolver so the task resolves to itself on the worker.
+    attach_tool_resolver(task)
+
+    structured = FlyteStructuredTool.from_function(
+        coroutine=_arun,
+        name=tool_name,
+        description=desc,
+        flyte_task=task,
+    )
+    structured.__name__ = tool_name  # type: ignore[attr-defined]
+    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 as _StructuredTool
+
+    tool_name = name or getattr(func, "__name__", "tool")
+    desc = (description or func.__doc__ or f"Run {tool_name}").strip()
+
+    @functools.wraps(func)
+    async def _arun(**kwargs: typing.Any) -> str:
+        out = func(**(kwargs or {}))
+        if inspect.isawaitable(out):
+            out = await out
+        return _as_content(out)
+
+    _arun.__name__ = tool_name
+
+    structured = _StructuredTool.from_function(coroutine=_arun, name=tool_name, description=desc)
+    structured.__name__ = tool_name  # type: ignore[attr-defined]
+    return structured
+
+
+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`` (or plain callable) into a LangChain tool.
+
+    Already-wrapped tools (anything exposing ``ainvoke``) pass through unchanged.
+    """
+    if isinstance(t, AsyncFunctionTaskTemplate):
+        return tool(t)
+    if callable(t) and not hasattr(t, "ainvoke"):
+        return tool(t)
+    return t

flyteplugins_agents_langgraph-2.5.17.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: flyteplugins-agents-langgraph
+Version: 2.5.17
+Summary: Run LangGraph agents on Flyte.
+Author-email: Niels Bantilan <niels@union.ai>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: flyteplugins-agents-core
+Requires-Dist: langgraph

flyteplugins_agents_langgraph-2.5.17.dist-info/RECORD

@@ -0,0 +1,9 @@
+flyteplugins/agents/langgraph/__init__.py,sha256=cMXMElr3SPLkZvKoq1HMwebjOk9mqPDqeOR3512mTWk,1067
+flyteplugins/agents/langgraph/_memory.py,sha256=tgQ8Qp468m_xI2EI5RRWSVkvxjtBjr0dIiDP3AN8Vvk,2394
+flyteplugins/agents/langgraph/_nodes.py,sha256=RBv3O3ZCrz0R45oXf1JNcPk5bYP28m7X3NBIxggxQJg,6212
+flyteplugins/agents/langgraph/_run.py,sha256=DFCrgh6MQzH4RQqlp13v-i54gPoVp6hwWTpeOFPbibM,7958
+flyteplugins/agents/langgraph/_tools.py,sha256=88SckNo4v-sOoVTSFLNHXQP9hs2Qh1RjzqywgOD40PY,6262
+flyteplugins_agents_langgraph-2.5.17.dist-info/METADATA,sha256=01UTDZxL2vtuonG0bk-31mv6aUVeN2BjSopm_Oyxm3s,289
+flyteplugins_agents_langgraph-2.5.17.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flyteplugins_agents_langgraph-2.5.17.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_agents_langgraph-2.5.17.dist-info/RECORD,,

flyteplugins_agents_langgraph-2.5.17.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_langgraph-2.5.17.dist-info/top_level.txt

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