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

flyteplugins/agents/crewai/__init__.py

@@ -0,0 +1,18 @@
+"""CrewAI adapter for Flyte.
+
+Bring your own CrewAI ``Agent`` and run it durably on Flyte. The adapter
+provides:
+
+- :func:`tool` — turn a Flyte ``@env.task`` into a CrewAI tool that executes as
+  a durable child action (own container/GPU, retries, caching).
+- :func:`run_agent` — run the CrewAI agent loop 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 ._run import run_agent, run_agent_sync
+from ._tools import tool
+
+__all__ = ["run_agent", "run_agent_sync", "tool"]

flyteplugins/agents/crewai/_durable.py

@@ -0,0 +1,166 @@
+"""Durable, replayable model turns for CrewAI.
+
+CrewAI owns the agent loop and drives the model itself: during
+``Agent.kickoff_async`` it calls its ``crewai.LLM`` once per turn. To make that
+loop durable we swap in a durable ``LLM``: it records each turn through the
+shared :func:`~flyteplugins.agents.core.durable_step` (a ``flyte.trace`` leaf),
+so inside a Flyte task a crashed/retried run replays completed turns from their
+recorded completions instead of re-calling (and re-billing) the model. Tool
+calls run as durable child actions (see :func:`flyteplugins.agents.crewai.tool`),
+so the whole run becomes crash-resilient when the enclosing task carries
+``retries=...``.
+
+Two CrewAI facts shape the implementation:
+
+- ``crewai.LLM(model=...)`` is a *factory*: ``LLM.__new__`` dispatches on the
+  model name and returns a provider-specific subclass (``OpenAICompletion``,
+  ``AnthropicCompletion``, ...). A plain ``class D(LLM)`` therefore never sees the
+  provider's real ``call``. We instead subclass the *concrete* provider class of a
+  probe instance (``type(LLM(model=...))``) and instantiate through it, so the
+  durable overrides sit directly on top of the real completion methods.
+- ``kickoff_async`` invokes the **synchronous** ``call`` (verified on 1.15.2),
+  not ``acall``; we override both so durability applies whichever path runs.
+
+The turn result is the completion — a string, or an arbitrary object for
+structured outputs. Strings round-trip as-is; anything else is coerced to a
+string for the trace record (structured turns are recorded but rebuilt as text,
+which is a lossy but safe fallback and never the case for the default text loop).
+The concrete provider class is a heavy import, so the durable subclass is built
+lazily on first use.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyteplugins.agents.core import durable_step, fingerprint, jsonable
+
+# Sentinel prefix marking a completion we serialized as JSON (non-string result).
+# Plain string completions are stored verbatim; on load we only JSON-decode a
+# value carrying this prefix, so ordinary strings never get mis-parsed.
+_JSON_PREFIX = "\x00json\x00"
+
+
+def _messages_fingerprint(
+    messages: typing.Any,
+    tools: typing.Any,
+    extra: typing.Mapping[str, typing.Any] | None = None,
+) -> str:
+    """Deterministic memo key for a model turn — message content + tool names.
+
+    Fingerprints on serializable request identity only: the messages (a str or a
+    list of ``{"role", "content"}`` dicts) and the tool *names* — never callables
+    or live tool/agent objects.
+    """
+    payload: dict[str, typing.Any] = {
+        "messages": jsonable(messages),
+        "tools": sorted(_tool_names(tools)),
+    }
+    if extra:
+        payload.update(extra)
+    return fingerprint(payload)
+
+
+def _tool_names(tools: typing.Any) -> list[str]:
+    """Extract stable tool names from CrewAI's ``[{name: BaseTool}, ...]`` (or list)."""
+    names: list[str] = []
+    for entry in tools or []:
+        if isinstance(entry, dict):
+            names.extend(str(k) for k in entry.keys())
+        else:
+            names.append(str(getattr(entry, "name", entry)))
+    return names
+
+
+def _dumps(result: typing.Any) -> str:
+    """Serialize a turn result: strings verbatim, everything else JSON-tagged.
+
+    JSON-native structures (dict/list/scalars) serialize directly; SDK objects
+    are coerced via ``jsonable`` first. ``default=str`` catches any residue so
+    serialization never fails a turn.
+    """
+    if isinstance(result, str):
+        return result
+    import json
+
+    if isinstance(result, (dict, list, int, float, bool)) or result is None:
+        payload = result
+    else:
+        payload = jsonable(result)
+    return _JSON_PREFIX + json.dumps(payload, default=str)
+
+
+def _loads(recorded: str) -> typing.Any:
+    """Rebuild a turn result from its recorded string form."""
+    if recorded.startswith(_JSON_PREFIX):
+        import json
+
+        return json.loads(recorded[len(_JSON_PREFIX) :])
+    return recorded
+
+
+def _make_durable_llm_class(model: str) -> type:
+    """Build a durable ``LLM`` subclass over the concrete provider for ``model``.
+
+    Imported/derived lazily: ``crewai`` and its provider classes are heavy, and
+    the concrete class depends on the model name (provider dispatch).
+    """
+    from crewai import LLM
+
+    probe = LLM(model=model)
+    concrete_cls = type(probe)
+
+    class DurableLLM(concrete_cls):  # type: ignore[valid-type, misc]
+        """A ``crewai.LLM`` whose every model turn is recorded via ``durable_step``.
+
+        ``call`` (used by ``kickoff_async``) and ``acall`` both route the real
+        completion through the shared durable step so retries replay recorded
+        turns. Durability is guarded: if the trace layer misbehaves the real
+        call still runs, so it never breaks a run.
+        """
+
+        def call(self, messages: typing.Any, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            from flyte._utils.asyn import run_sync
+
+            tools = args[0] if args else kwargs.get("tools")
+            try:
+                return run_sync(
+                    durable_step,
+                    _messages_fingerprint(messages, tools),
+                    lambda: _as_awaitable(super(DurableLLM, self).call(messages, *args, **kwargs)),
+                    name="model_turn",
+                    dumps=_dumps,
+                    loads=_loads,
+                )
+            except Exception:  # pragma: no cover - durability never breaks a run
+                return super().call(messages, *args, **kwargs)
+
+        async def acall(self, messages: typing.Any, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            tools = args[0] if args else kwargs.get("tools")
+            try:
+                return await durable_step(
+                    _messages_fingerprint(messages, tools),
+                    lambda: _as_awaitable(super(DurableLLM, self).acall(messages, *args, **kwargs)),
+                    name="model_turn",
+                    dumps=_dumps,
+                    loads=_loads,
+                )
+            except Exception:  # pragma: no cover - durability never breaks a run
+                return await _as_awaitable(super().acall(messages, *args, **kwargs))
+
+    return DurableLLM
+
+
+async def _as_awaitable(value: typing.Any) -> typing.Any:
+    """Normalize a maybe-coroutine to an awaited value (``call`` returns eagerly)."""
+    import inspect
+
+    if inspect.isawaitable(value):
+        return await value
+    return value
+
+
+def make_durable_llm(model: str) -> typing.Any:
+    """Construct a durable ``crewai.LLM`` instance for the given ``model`` name."""
+    cls = _make_durable_llm_class(model)
+    return cls(model=model)

flyteplugins/agents/crewai/_memory.py

@@ -0,0 +1,70 @@
+"""Cross-run CrewAI memory — a thin handle over Flyte's keyed ``MemoryStore``.
+
+CrewAI keeps conversation state in-memory and ``kickoff_async`` does not thread a
+prior transcript back out (its ``LiteAgentOutput.messages`` holds only the
+system+user turns of the current call, not the assistant reply). So this module
+maintains the transcript itself: it resolves a keyed ``MemoryStore`` and stores
+the running conversation — a list of ``{"role", "content"}`` dicts — in a
+path-addressed JSON slot. A later run with the same ``memory_key`` loads that
+transcript and prepends it to the new prompt, continuing the conversation.
+
+Everything here is best-effort: a store that can't be resolved, or a read/write
+that fails, degrades to a memoryless run rather than breaking it.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyte._logging import logger
+from flyteplugins.agents.core import resolve_memory as _resolve_memory
+
+# Path-addressed memory slot holding a thread's conversation transcript
+# (a list of ``{"role", "content"}`` message dicts) inside the MemoryStore.
+_HISTORY_PATH = "crewai/history.json"
+
+
+async def resolve_memory(memory_key: str | None) -> typing.Any | None:
+    """Resolve a keyed MemoryStore for CrewAI 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[dict[str, typing.Any]]:
+    """Load the stored conversation transcript, or ``[]`` if none/unavailable."""
+    if store is None:
+        return []
+    try:
+        history = await store.read_json.aio(_HISTORY_PATH, default=[])
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not load CrewAI conversation history; continuing without it.")
+        return []
+    return history if isinstance(history, list) else []
+
+
+def build_input(history: list[dict[str, typing.Any]], user_input: str) -> list[dict[str, typing.Any]]:
+    """Build the kickoff message list from prior transcript + the new user turn."""
+    return [*history, {"role": "user", "content": user_input}]
+
+
+async def save_turn(store: typing.Any, user_input: str, assistant_output: str) -> None:
+    """Append the user + assistant turns to the transcript and persist it.
+
+    Best-effort: any failure is logged and swallowed so a run never breaks on
+    memory persistence.
+    """
+    if store is None:
+        return
+    try:
+        history = await load_history(store)
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": assistant_output})
+        await store.write_json.aio(_HISTORY_PATH, history)
+        await store.save.aio()
+    except Exception:  # pragma: no cover - memory is best-effort, never fatal
+        logger.warning("Could not persist CrewAI conversation history; continuing.")

flyteplugins/agents/crewai/_run.py

@@ -0,0 +1,158 @@
+"""``run_agent`` — run a CrewAI agent on Flyte.
+
+CrewAI owns the agent loop (it drives the model + tools). ``run_agent`` runs that
+loop inside your ``@env.task``: it builds an agent with Flyte-task tools, drives
+the agent via ``Agent.kickoff_async``, and returns the final answer. Each tool
+call runs as a durable Flyte child action (its own container/resources, with
+retries and caching).
+
+Observability: the run timeline — tool calls and AI message turns — is rendered
+into the Flyte task report.
+
+The adapter minimizes delta between native CrewAI code and Flyte integration by
+exposing tools that are drop-in ``crewai.tools.BaseTool`` instances.
+"""
+
+from __future__ import annotations
+
+import typing
+
+from flyteplugins.agents.core import ReportTimeline, flush_report, sync_variant
+
+from . import _memory
+from ._durable import make_durable_llm
+from ._tools import _coerce_tool
+
+if typing.TYPE_CHECKING:
+    from crewai import Agent as _CrewAgent
+else:
+    _CrewAgent = None
+
+
+def _extract_text(result: typing.Any) -> str:
+    """Pull the final answer out of a CrewAI ``LiteAgentOutput`` (or fallback)."""
+    if result is None:
+        return ""
+    raw = getattr(result, "raw", None)
+    if isinstance(raw, str):
+        return raw
+    return str(result)
+
+
+async def run_agent(
+    input: str,
+    *,
+    tools: typing.Sequence[typing.Any] = (),
+    model: str | None = None,
+    instructions: str | None = None,
+    agent: typing.Any = None,
+    name: str = "crewai-agent",
+    durable: bool = True,
+    observability: bool = True,
+    memory_key: str | None = None,
+    **run_kwargs: typing.Any,
+) -> str:
+    """Run a CrewAI 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`` (with its own tools already attached) or
+    ``tools`` + ``model`` to have one built for you — not both.
+
+    Args:
+        input: The user prompt.
+        tools: ``tool``-wrapped tools or bare ``@env.task`` templates. Attached
+            natively to the built ``Agent(tools=...)``. Ignored when ``agent`` is
+            given (a pre-built agent carries its own tools).
+        model: Model name (e.g. ``"gpt-4o"``) for the built agent. Required on
+            the builder path (no default is assumed — the adapter is provider
+            agnostic); ignored when a pre-built ``agent`` is given.
+        instructions: Extra guidance folded into the built agent's backstory.
+        agent: A pre-built CrewAI ``Agent``. Mutually exclusive with ``tools``.
+        name: Agent name (for debugging/observability).
+        durable: Record/replay each model turn via ``flyte.trace``. Applied only
+            when ``run_agent`` builds the agent (the builder sets a durable
+            ``llm``); a pre-built ``agent`` keeps its own ``llm`` and is not
+            rewrapped, so its turns are not durable.
+        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.
+        **run_kwargs: Additional kwargs forwarded to ``Agent.kickoff_async``.
+
+    Returns:
+        The agent's final output as a string.
+    """
+    timeline = ReportTimeline() if observability else None
+    if timeline is not None:
+        timeline.heading("CrewAI agent")
+
+    if agent is not None and tools:
+        raise ValueError("Pass either `agent` (with its own tools) or `tools`, not both.")
+
+    # Build the agent if not provided, attaching the Flyte-task tools natively.
+    if agent is None:
+        if model is None:
+            raise ValueError(
+                'No model was given. Provide `model=` (e.g. "gpt-4o") when building the agent '
+                "(or pass a pre-built `agent=`)."
+            )
+        if _CrewAgent is None:
+            from crewai import Agent as _LocalAgent
+        else:
+            _LocalAgent = _CrewAgent
+
+        backstory = f"You are a helpful assistant named {name}."
+        if instructions:
+            backstory = f"{backstory}\n\n{instructions}"
+
+        # When durable, drive the agent with a durable ``LLM`` so every model
+        # turn is recorded via ``flyte.trace`` and replayed on retry. For a
+        # PREBUILT agent we cannot safely rewrap its ``llm``, so durability is
+        # only applied on this builder path (see the module docstring / limitation).
+        if durable:
+            llm: typing.Any = make_durable_llm(model)
+        else:
+            llm = model
+
+        agent = _LocalAgent(
+            role="Assistant",
+            goal="Answer the user's question accurately and concisely.",
+            backstory=backstory,
+            tools=[_coerce_tool(t) for t in tools],
+            llm=llm,
+        )
+
+    # Cross-run memory: load the prior transcript (if any) and prepend it to the
+    # new user turn, so ``kickoff_async`` continues the conversation. Best-effort.
+    store = await _memory.resolve_memory(memory_key)
+    if store is not None:
+        history = await _memory.load_history(store)
+        kickoff_input: typing.Any = _memory.build_input(history, input)
+    else:
+        kickoff_input = input
+
+    # Drive the agent loop. ``kickoff_async`` takes the prompt (a str, or a list
+    # of ``{"role", "content"}`` message dicts when resuming memory) as its input;
+    # a pre-built agent already carries its own tools, so none are injected here.
+    result = await agent.kickoff_async(kickoff_input, **run_kwargs)
+
+    final = _extract_text(result)
+
+    # Persist this turn to the transcript for the next run with the same key.
+    if store is not None:
+        await _memory.save_turn(store, input, final)
+
+    if observability:
+        await flush_report()
+
+    return final or ""
+
+
+run_agent_sync = sync_variant(run_agent)

flyteplugins/agents/crewai/_tools.py

@@ -0,0 +1,229 @@
+"""Turn Flyte tasks into CrewAI tools that execute as durable actions.
+
+CrewAI requires tools attached to an ``Agent(tools=[...])`` to be
+``crewai.tools.BaseTool`` instances — plain callables are rejected by pydantic
+validation. :func:`tool` therefore wraps a Flyte ``@env.task`` as a ``BaseTool``
+subclass whose execution 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.
+
+Sync/async bridge: CrewAI invokes tools synchronously (``BaseTool.run`` ->
+``_run``; the agent loop routes through ``CrewStructuredTool.invoke``, which calls
+``self.func`` — our ``_run`` — and, if it returns a coroutine, ``asyncio.run``s it).
+``asyncio.run`` explodes inside the already-running loop of a Flyte task, so we make
+``_run`` a *synchronous* method that bridges to ``task.aio()`` via
+:func:`flyte._utils.asyn.run_sync`, which drives the coroutine on a dedicated
+background-thread loop and works from within a running loop. ``_arun`` awaits the
+task directly for CrewAI's native async path.
+"""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+import typing
+from functools import partial
+
+from flyte._task import AsyncFunctionTaskTemplate
+from flyte._utils.asyn import run_sync
+from flyte.models import NativeInterface
+from flyteplugins.agents.core import attach_tool_resolver, coerce_tool_args, task_json_schema
+
+
+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 CrewAI ``BaseTool``.
+
+    - For an ``@env.task``: returns a ``BaseTool`` whose execution runs the task as
+      a durable Flyte child action when the agent invokes it. The input schema is
+      derived from the task via the Flyte type engine. 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 ``BaseTool`` that runs it inline.
+
+    The returned object is a native ``crewai.tools.BaseTool`` instance, so it can be
+    attached directly to ``Agent(tools=[...])``.
+
+    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 _args_model_from_signature(fn: typing.Callable, model_name: str) -> type:
+    """Build a pydantic model describing ``fn``'s parameters for CrewAI's args schema.
+
+    CrewAI derives a tool's args schema from ``BaseTool.args_schema`` (or, failing
+    that, from the ``_run`` signature). Our ``_run`` takes ``**kwargs``, so we hand
+    CrewAI an explicit model built from the wrapped callable's annotations.
+    """
+    from pydantic import create_model
+
+    try:
+        hints = typing.get_type_hints(fn)
+    except Exception:  # pragma: no cover - unresolved annotations
+        hints = {}
+    fields: dict[str, typing.Any] = {}
+    for pname, param in inspect.signature(fn).parameters.items():
+        if pname in ("self", "return"):
+            continue
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+        fallback = param.annotation if param.annotation is not inspect.Parameter.empty else typing.Any
+        annotation = hints.get(pname, fallback)
+        if param.default is inspect.Parameter.empty:
+            fields[pname] = (annotation, ...)
+        else:
+            fields[pname] = (annotation, param.default)
+    return create_model(model_name, **fields)
+
+
+def _make_base_tool_class() -> type:
+    """Define the ``FlyteCrewAITool`` ``BaseTool`` subclass (imported lazily).
+
+    CrewAI is an optional heavy import, so the class is built on first use rather
+    than at module import time.
+    """
+    from crewai.tools import BaseTool
+
+    class FlyteCrewAITool(BaseTool):
+        """A CrewAI ``BaseTool`` backed by a Flyte task (or plain callable).
+
+        ``_run`` is synchronous by design: CrewAI's structured-tool path calls it
+        and ``asyncio.run``s any returned coroutine, which would fail inside a
+        Flyte task's running loop. We instead bridge to the async dispatcher via
+        :func:`run_sync` (a background-thread loop) and return a plain string.
+        """
+
+        # Pydantic model config: allow the non-field private attributes below.
+        _dispatch: typing.Callable[..., typing.Awaitable[typing.Any]]
+        _wrapped_task: typing.Any
+
+        def _run(self, **kwargs: typing.Any) -> str:
+            return run_sync(self._dispatch, **kwargs)
+
+        async def _arun(self, **kwargs: typing.Any) -> str:
+            return await self._dispatch(**kwargs)
+
+        @property
+        def __wrapped_task__(self) -> typing.Any:
+            return self._wrapped_task
+
+        @property
+        def task(self) -> typing.Any:
+            return self._wrapped_task
+
+    return FlyteCrewAITool
+
+
+@functools.lru_cache(maxsize=1)
+def _base_tool_class() -> type:
+    return _make_base_tool_class()
+
+
+def _build_tool(
+    *,
+    tool_name: str,
+    desc: str,
+    args_model: type,
+    dispatch: typing.Callable[..., typing.Awaitable[typing.Any]],
+    wrapped_task: typing.Any,
+) -> typing.Any:
+    cls = _base_tool_class()
+    instance = cls(name=tool_name, description=desc, args_schema=args_model)
+    # Private attrs live outside pydantic validation; set them directly.
+    object.__setattr__(instance, "_dispatch", dispatch)
+    object.__setattr__(instance, "_wrapped_task", wrapped_task)
+    return instance
+
+
+def _task_to_tool(
+    task: AsyncFunctionTaskTemplate,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> typing.Any:
+    """Build a CrewAI ``BaseTool`` from a Flyte task."""
+    tool_name = name or task.func.__name__
+    desc = (description or task.func.__doc__ or f"Run {tool_name}").strip()
+    task_json_schema(task)  # validate schema at construction time
+    args_model = _args_model_from_signature(task.func, f"{tool_name}_args")
+
+    async def _dispatch(**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)
+
+    return _build_tool(
+        tool_name=tool_name,
+        desc=desc,
+        args_model=args_model,
+        dispatch=_dispatch,
+        wrapped_task=task,
+    )
+
+
+def _callable_to_tool(
+    func: typing.Callable,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> typing.Any:
+    """Build a CrewAI ``BaseTool`` from a plain callable."""
+    tool_name = name or getattr(func, "__name__", "tool")
+    desc = (description or func.__doc__ or f"Run {tool_name}").strip()
+    NativeInterface.from_callable(func).json_schema  # validate schema at construction time
+    args_model = _args_model_from_signature(func, f"{tool_name}_args")
+
+    async def _dispatch(**kwargs: typing.Any) -> str:
+        out = func(**(kwargs or {}))
+        if inspect.isawaitable(out):
+            out = await out
+        return _as_content(out)
+
+    return _build_tool(
+        tool_name=tool_name,
+        desc=desc,
+        args_model=args_model,
+        dispatch=_dispatch,
+        wrapped_task=None,
+    )
+
+
+def _as_content(result: typing.Any) -> str:
+    """Convert a tool result to a string for CrewAI."""
+    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 CrewAI-compatible ``BaseTool``.
+
+    Bare ``@env.task`` templates are wrapped on the fly; already-wrapped tools
+    (``BaseTool`` instances) and other objects pass through unchanged.
+    """
+    if isinstance(t, AsyncFunctionTaskTemplate):
+        return tool(t)
+    return t

flyteplugins_agents_crewai-2.5.15.dist-info/METADATA

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

flyteplugins_agents_crewai-2.5.15.dist-info/RECORD

@@ -0,0 +1,9 @@
+flyteplugins/agents/crewai/__init__.py,sha256=A1LW9r9gjoreQxQmmh0YHX9V2XUW_ZE8vykTisWHQOI,598
+flyteplugins/agents/crewai/_durable.py,sha256=f3onOoWpINXQoZVa0onwp7uCY-sgLEVBlPwhVeHzEyI,6738
+flyteplugins/agents/crewai/_memory.py,sha256=CfcveVuJRIDBEt7B3SK_k2I5j0yI71LRlNIZQ8Kinsw,3041
+flyteplugins/agents/crewai/_run.py,sha256=_tIw3juVDtd6UxYyAyBLv5SpJNI4ZE7xTw4jPJq8AUc,6236
+flyteplugins/agents/crewai/_tools.py,sha256=YRJgraQn7IPh86JoX3Ln2RQTgc36i0I5WYefS7GcqNM,8641
+flyteplugins_agents_crewai-2.5.15.dist-info/METADATA,sha256=vaonWVyB0GMQ_LT2H-TFXWyzbyM3TiIZIc5xBreYGHY,280
+flyteplugins_agents_crewai-2.5.15.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flyteplugins_agents_crewai-2.5.15.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_agents_crewai-2.5.15.dist-info/RECORD,,

flyteplugins_agents_crewai-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_crewai-2.5.15.dist-info/top_level.txt

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