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

flyteplugins/agents/langchain/__init__.py

@@ -0,0 +1,19 @@
+"""LangChain adapter for Flyte.
+
+Bring your own LangChain agent 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).
+- :func:`run_agent` — run the LangChain agent (a compiled ``create_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``.
+
+Each tool call runs as a durable Flyte child action, and the run timeline is
+rendered into the Flyte task report.
+"""
+
+from ._run import run_agent, run_agent_sync
+from ._tools import tool
+
+__all__ = ["run_agent", "run_agent_sync", "tool"]

flyteplugins/agents/langchain/_durable.py

@@ -0,0 +1,132 @@
+"""Durable, replayable model turns for LangChain chat models.
+
+LangChain's ``create_agent`` graph owns the agent loop; each iteration calls the
+chat model once (a "model turn"). :class:`DurableChatModel` wraps any
+``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.langchain.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`` (the same round-trip the langgraph adapter uses), 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 ``create_agent``'s bound runnable still routes generation through the
+durable override.
+"""
+
+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) and ``_generate`` (sync) delegate to the inner model
+    and record the turn via ``durable_step``. Pass an instance to
+    ``create_agent(DurableChatModel(inner=model), tools, ...)``; ``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
+        # ``create_agent``'s 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
+        ``create_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/langchain/_memory.py

@@ -0,0 +1,72 @@
+"""Cross-run LangChain memory — a thin bridge over Flyte's keyed ``MemoryStore``.
+
+LangChain's ``create_agent`` graph is driven with a messages state
+(``graph.ainvoke({"messages": [...]})``) and, by default, keeps no state across
+runs. This module bridges that: it resolves a keyed :class:`MemoryStore`, loads a
+prior conversation from a path-addressed JSON slot, and writes the full
+transcript back after the run — so a later run with the same ``memory_key``
+continues the conversation.
+
+The transcript is stored as ``messages_to_dict(...)`` output (the same
+serialization the langgraph adapter uses) in a single JSON slot, and rebuilt with
+``messages_from_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 slot holding the serialized conversation transcript
+# (``messages_to_dict`` output) inside the MemoryStore.
+_HISTORY_PATH = "langchain/history.json"
+
+
+async def resolve_memory(memory_key: str | None) -> typing.Any | None:
+    """Resolve a keyed MemoryStore for LangChain 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 LangChain memory; continuing without prior history.")
+        return []
+
+
+async def save_history(store: typing.Any, messages: typing.Sequence["BaseMessage"]) -> None:
+    """Serialize the full conversation ``messages`` and persist them 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)))
+        await store.save.aio()
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not save LangChain memory; conversation will not be resumed.")

flyteplugins/agents/langchain/_run.py

@@ -0,0 +1,175 @@
+"""``run_agent`` — run a LangChain agent on Flyte.
+
+LangChain's agent framework owns the loop. ``run_agent`` runs that loop inside your
+``@env.task``: it builds an agent (a compiled LangGraph graph) 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).
+
+In langchain 1.x the agent is built with ``langchain.agents.create_agent(model, tools,
+system_prompt=...)``, which returns a compiled graph that is driven with a messages
+state: ``await graph.ainvoke({"messages": [{"role": "user", "content": input}]})``, and
+the final text is ``result["messages"][-1].content``.
+
+Observability: the run timeline is rendered into the Flyte task report.
+
+The adapter minimizes delta between native LangChain 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_history, resolve_memory, save_history
+from ._tools import _coerce_tool
+
+# Module-level alias for test monkeypatching: ``_create_agent`` lets tests
+# substitute the graph builder without constructing a real model or graph.
+_create_agent = None
+
+
+def _final_text(result: typing.Any) -> str:
+    """Extract the agent's final text from a compiled-graph result.
+
+    ``create_agent`` graphs return a messages state ``{"messages": [...]}``; the
+    final answer is the content of the last message. Falls back gracefully for
+    other shapes (e.g. a legacy ``{"output": ...}`` dict or a bare string).
+    """
+    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)
+        if "output" in result:
+            return str(result["output"])
+        return ""
+    return str(result)
+
+
+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 = "langchain-agent",
+    durable: bool = True,
+    observability: bool = True,
+    memory_key: str | None = None,
+    **agent_kwargs: typing.Any,
+) -> str:
+    """Run a LangChain 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_agent``)
+    or ``tools`` + ``model`` to have one built for you.
+
+    Args:
+        input: The user prompt.
+        tools: ``tool``-wrapped tools or bare ``@env.task`` templates.
+        model: A LangChain-compatible chat model (e.g.
+            ``ChatOpenAI(model="gpt-4o")``). Required when ``agent`` is not
+            given — one is built using this model.
+        instructions: System prompt for the built agent.
+        agent: A pre-built LangChain agent (a compiled ``create_agent`` graph).
+            Mutually exclusive with ``tools``.
+        name: Agent name (for debugging/observability).
+        durable: Record/replay each model turn via ``flyte.trace``. Applies when
+            a model is being built (``tools`` + ``model``, or a caller-passed
+            ``BaseChatModel``) — the model is wrapped in :class:`DurableChatModel`.
+            A fully pre-built compiled ``agent`` cannot be rewrapped, so its model
+            turns are not made durable (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, conversation history is persisted to a keyed ``MemoryStore``
+            and resumed on a later run with the same key.
+        **agent_kwargs: Additional kwargs forwarded to ``create_agent``.
+
+    Returns:
+        The agent's final output as a string.
+    """
+    timeline = ReportTimeline() if observability else None
+    if timeline is not None:
+        timeline.heading("LangChain 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_agent is None:
+            from langchain.agents import create_agent as create_agent_fn
+        else:
+            create_agent_fn = _create_agent
+
+        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")`.'
+            )
+
+        # Wrap the inner 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:
+            model = _wrap_durable(model)
+
+        tool_objs = [_coerce_tool(t) for t in tools]
+        system_prompt = instructions or f"You are a helpful assistant named {name}."
+        agent = create_agent_fn(model, tool_objs, system_prompt=system_prompt, **agent_kwargs)
+
+    # Cross-run memory: load prior history and prepend it to the messages passed
+    # to the graph, then persist the full transcript back after the run.
+    store = await resolve_memory(memory_key)
+    prior = await load_history(store)
+    messages = [*prior, {"role": "user", "content": input}]
+
+    result = await agent.ainvoke({"messages": messages})
+
+    await save_history(store, _result_messages(result))
+
+    final = _final_text(result)
+
+    if observability:
+        await flush_report()
+
+    return final or ""
+
+
+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 _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 []
+
+
+run_agent_sync = sync_variant(run_agent)

flyteplugins/agents/langchain/_tools.py

@@ -0,0 +1,174 @@
+"""Turn Flyte tasks into LangChain tools that execute as durable actions.
+
+LangChain accepts ``BaseTool`` instances as 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_agent(model, tools=[...])``. 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 tool to a LangChain-compatible tool."""
+    if isinstance(t, AsyncFunctionTaskTemplate):
+        return tool(t)
+    return t

flyteplugins_agents_langchain-2.5.15.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: flyteplugins-agents-langchain
+Version: 2.5.15
+Summary: Run LangChain 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: langchain

flyteplugins_agents_langchain-2.5.15.dist-info/RECORD

@@ -0,0 +1,9 @@
+flyteplugins/agents/langchain/__init__.py,sha256=OedlCjF8pH0Q36z04eVKpaIDVeezFvee3WNdWFkjCIg,773
+flyteplugins/agents/langchain/_durable.py,sha256=grIsJkTLfTVM-m-AB8cBWQoNV3llDgEpdvtwAcBKYHI,5953
+flyteplugins/agents/langchain/_memory.py,sha256=jaeO5CPUKOh4ii2Q5pBRIPMNFyiDvKI96Em0GViKGtI,2874
+flyteplugins/agents/langchain/_run.py,sha256=BMkupLSV4yYQYl5jiW0MLDqc1b6xJmgUno8RSL3x78o,7152
+flyteplugins/agents/langchain/_tools.py,sha256=HSXsjLxXzDIx6sw81rBy_KjBps6lH_Q6PHRENa6q-Hc,6584
+flyteplugins_agents_langchain-2.5.15.dist-info/METADATA,sha256=Sq0MS7bSkdiJ_8mcd1gEzcLerTnrVo8vvXG8TbEqaJs,289
+flyteplugins_agents_langchain-2.5.15.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flyteplugins_agents_langchain-2.5.15.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_agents_langchain-2.5.15.dist-info/RECORD,,

flyteplugins_agents_langchain-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_langchain-2.5.15.dist-info/top_level.txt

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