graph-agents-cli 0.3.1__py3-none-any.whl

graph_agents_cli/scaffold/agents/langgraph/tests/conftest.py

@@ -0,0 +1,376 @@
+# Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Shared test setup: the tests see neither `.env` nor the developer's app settings,
+and the server tests bring their own tool.
+
+`{{cookiecutter.agent_directory}}/agent.py` calls `load_dotenv()` when it is imported, which
+would pull a developer's `.env` (a provider key, `AUTH_JWT_*`, ...) into the
+test process: a test could then pass in CI and fail on a laptop, or the other
+way round. This file is loaded before any test module imports the app, so it
+switches `.env` loading off (in this process and in the subprocesses tests
+start) and removes every app setting from the environment: each setting
+`.env.example` documents, plus the provider, auth, tracing and LangChain
+variables and the other settings the app reads (`A2A_NAME`, `RUNTIME`, ...).
+Each test module then sets exactly what it needs. Opt-ins the tests read
+themselves (`TEST_*`, such as `TEST_POSTGRES_DSN`) are kept.
+
+The project's response schema (`<agent directory>/response_schema.json`,
+structured final answers) is switched off the same way
+(`RESPONSE_SCHEMA_PATH=none`): the tests exercise the runtime with text
+answers, whatever shape the project declares. The tests of structured answers
+set a schema of their own, and `tests/unit/test_structured.py` checks the
+project's own schema and that the agent answers in it.
+
+The server tests exercise the plumbing (tool events, redaction, a run stopped
+mid-call) with a test-only tool through the `use_test_tools` fixture, never
+with the project's own tools, which are yours to replace or delete: while a
+test module has imported the agent, each test serves a graph built like
+`agent.py`'s but with no tools (the fake model would otherwise call a project
+tool whose name a test prompt happens to mention). A test that needs the
+project's own graph is marked `@pytest.mark.project_graph`.
+
+`openai_compatible` is an OpenAI-compatible server in process (behind
+`httpx.MockTransport`, no network) that refuses a chat history the way OpenAI
+does: the tests that keep a thread valid for providers run the agent on
+`ChatOpenAI` against it.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from collections.abc import Callable, Iterator, Sequence
+from pathlib import Path
+from typing import Any, ClassVar
+
+import dotenv
+import dotenv.main
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+# Settings the app reads that a developer's shell may carry, beyond `.env.example`.
+_SETTING_PREFIXES = (
+    "AUTH_",
+    "MODEL_",
+    "JUDGE_",
+    "LANGSMITH_",
+    "LANGCHAIN_",
+    "OTEL_",
+    "TRACE_",
+    "TRACING_",
+    "TOKEN_EXCHANGE_",
+)
+_PROVIDER_VARIABLES = {"OPENAI_API_KEY", "OPENAI_BASE_URL", "ANTHROPIC_API_KEY", "GOOGLE_API_KEY"}
+# Settings the app reads that `.env.example` leaves out (the runtime and the
+# server set some of them; a developer's shell may carry any).
+_APP_VARIABLES = {
+    "A2A_NAME",
+    "A2A_DESCRIPTION",
+    "AGENT_VERSION",
+    "DATABASE_URI",
+    "REDIS_URI",
+    "HOST",
+    "LANGGRAPH_SERVER",
+    "LANGGRAPH_SERVER_URL",
+    "LANGSERVE_GRAPHS",
+    "PGCONNECT_TIMEOUT",
+    "RUNTIME",
+}
+_ASSIGNMENT = re.compile(r"^\s*#?\s*(?:export\s+)?([A-Z][A-Z0-9_]*)\s*=")
+
+
+def _documented_settings() -> set[str]:
+    """Every variable `.env.example` assigns, commented-out examples included."""
+    try:
+        text = (PROJECT_ROOT / ".env.example").read_text(encoding="utf-8")
+    except OSError:
+        return set()
+    return {m.group(1) for line in text.splitlines() if (m := _ASSIGNMENT.match(line))}
+
+
+def _is_app_setting(name: str) -> bool:
+    if name.startswith("TEST_"):
+        return False
+    return (
+        name in _PROVIDER_VARIABLES or name in _APP_VARIABLES or name.startswith(_SETTING_PREFIXES)
+    )
+
+
+def _no_dotenv(*args: Any, **kwargs: Any) -> bool:
+    return False
+
+
+# python-dotenv >= 1.2 honours PYTHON_DOTENV_DISABLED (inherited by subprocesses);
+# replacing load_dotenv covers older versions in this process.
+os.environ["PYTHON_DOTENV_DISABLED"] = "1"
+dotenv.load_dotenv = _no_dotenv
+dotenv.main.load_dotenv = _no_dotenv
+for _name in _documented_settings() | {n for n in list(os.environ) if _is_app_setting(n)}:
+    if not _name.startswith("TEST_") and _name != "PYTHON_DOTENV_DISABLED":
+        os.environ.pop(_name, None)
+# No response schema unless a test sets one (see the module docstring); subprocesses inherit it.
+os.environ["RESPONSE_SCHEMA_PATH"] = "none"
+
+
+def build_test_graph(tools: Sequence[Any]) -> Any:
+    """The agent's graph as `agent.py` builds it, with `tools` instead of the project's."""
+    from langchain.agents import create_agent
+
+    from {{cookiecutter.agent_directory}} import agent
+    from {{cookiecutter.agent_directory}}.app_utils.limits import recursion_limit
+    from {{cookiecutter.agent_directory}}.app_utils.model import get_model
+    from {{cookiecutter.agent_directory}}.app_utils.structured import response_format
+
+    model = get_model()
+    return create_agent(
+        model=model,
+        tools=list(tools),
+        system_prompt=agent.SYSTEM_PROMPT,
+        middleware=agent.middleware(),
+        context_schema=agent.AgentContext,
+        response_format=response_format(model, list(tools)),
+        name="test-agent",
+    ).with_config({"recursion_limit": recursion_limit()})
+
+
+AGENT_MODULE = "{{cookiecutter.agent_directory}}.agent"
+APP_MODULE = "{{cookiecutter.agent_directory}}.fast_api_app"
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers", "project_graph: serve the project's own graph (its tools included)"
+    )
+
+
+@pytest.fixture(autouse=True)
+def _no_project_tools(
+    request: pytest.FixtureRequest, monkeypatch: pytest.MonkeyPatch
+) -> Iterator[None]:
+    """Serve a graph without the project's tools (see the module docstring).
+
+    Only where the test module already imported the agent or the app (with its
+    settings); the app binds its checkpointer to whichever graph `agent.graph`
+    is at startup, and reads `agent.graph` again for every run.
+    """
+    agent = sys.modules.get(AGENT_MODULE)
+    if (agent is not None or APP_MODULE in sys.modules) and not os.environ.get("MODEL_PROVIDER"):
+        # A module that imported the app without setting a model (a test of
+        # its routes): the graph runs on the fake model.
+        monkeypatch.setenv("MODEL_PROVIDER", "fake")
+    if agent is None and APP_MODULE in sys.modules:
+        import importlib
+
+        agent = importlib.import_module(AGENT_MODULE)
+    if agent is not None and request.node.get_closest_marker("project_graph") is None:
+        graph = build_test_graph([])
+        graph.checkpointer = agent.graph.checkpointer
+        monkeypatch.setattr(agent, "graph", graph)
+    yield
+
+
+@pytest.fixture
+def use_test_tools(monkeypatch: pytest.MonkeyPatch) -> Callable[..., Any]:
+    """Serve a graph with only the given tools for this test (call it once the app has started).
+
+    The fake model calls a bound tool when the message mentions it (its name, or
+    a distinctive word of it), so `probe` is called for "Run the probe for Paris"
+    with `query="Paris"`. The graph keeps the checkpointer the app bound at startup.
+    """
+
+    def install(*tools: Any) -> Any:
+        from {{cookiecutter.agent_directory}} import agent
+
+        graph = build_test_graph(tools)
+        graph.checkpointer = agent.graph.checkpointer
+        monkeypatch.setattr(agent, "graph", graph)
+        return graph
+
+    return install
+
+
+# --- an OpenAI-compatible server that checks the history, in process ----------------------
+
+
+def openai_history_problem(messages: list[dict[str, Any]]) -> str | None:
+    """Why OpenAI would refuse this chat history (a 400), or None.
+
+    An assistant message with `tool_calls` must be followed by one tool message
+    per call before anything else, and a tool message must answer such a call.
+    """
+    pending: list[str] = []
+    for message in messages:
+        role = message.get("role")
+        if pending and role != "tool":
+            return (
+                "An assistant message with 'tool_calls' must be followed by tool messages "
+                "responding to each 'tool_call_id'. The following tool_call_ids did not have "
+                f"response messages: {', '.join(pending)}"
+            )
+        if role == "tool":
+            if message.get("tool_call_id") not in pending:
+                return "messages with role 'tool' must be a response to a preceding 'tool_calls'"
+            pending.remove(message.get("tool_call_id"))
+        elif role == "assistant":
+            pending = [call.get("id") for call in message.get("tool_calls") or []]
+    if pending:
+        return f"tool_call_ids did not have response messages: {', '.join(pending)}"
+    return None
+
+
+class OpenAICompatibleFake:
+    """A scripted OpenAI-compatible chat server behind `httpx.MockTransport`.
+
+    It refuses a history OpenAI refuses (`openai_history_problem`, a 400), and
+    answers the last message: a user message naming a script word gets that
+    reply (see `SCRIPTS`: arguments that are not valid JSON, one id for two
+    calls), a tool result gets `Found: <results>` (unless the user asked for
+    `ALWAYSBAD`: invalid arguments again), anything else `ok`. Tool calls go
+    to the first tool of the request. Replies put in `queue` come first, in
+    order: `(text, [(call id, tool name, raw arguments), ...])`, text and
+    calls together in one message when both are given. `requests` keeps every
+    request body; `refusals` every 400.
+    """
+
+    SCRIPTS: ClassVar[dict[str, list[tuple[str, str]]]] = {
+        # (call id, raw arguments) per tool call
+        "BADARGS": [("call_0", "{'query': 'SF'}")],
+        "TRAILINGCOMMA": [("call_0", '{"query": "SF",}')],
+        "DUPIDS": [("dup", '{"query": "SF"}'), ("dup", '{"query": "Rome"}')],
+        "BADANDGOOD": [("call_0", '{"query": "SF"}'), ("call_1", "query=Rome")],
+    }
+
+    def __init__(self) -> None:
+        self.requests: list[dict[str, Any]] = []
+        self.refusals: list[str] = []
+        self.queue: list[tuple[str | None, list[tuple[str, str, str]]]] = []
+
+    def model(self) -> Any:
+        import httpx
+        from langchain_openai import ChatOpenAI
+
+        transport = httpx.MockTransport(self._handle)
+        return ChatOpenAI(
+            model="fake-gpt",
+            api_key="test",
+            base_url="http://openai-compatible.test/v1",
+            max_retries=0,
+            http_client=httpx.Client(transport=transport),
+            http_async_client=httpx.AsyncClient(transport=transport),
+        )
+
+    def _reply(self, body: dict[str, Any]) -> tuple[str | None, list[dict[str, Any]]]:
+        if self.queue:
+            text, queued = self.queue.pop(0)
+            return text, [
+                {
+                    "index": i,
+                    "id": call_id,
+                    "type": "function",
+                    "function": {"name": name, "arguments": arguments},
+                }
+                for i, (call_id, name, arguments) in enumerate(queued)
+            ]
+        messages = body.get("messages") or []
+        last = messages[-1] if messages else {}
+        asked = next((str(m.get("content")) for m in reversed(messages) if m["role"] == "user"), "")
+        tools = [t["function"]["name"] for t in body.get("tools") or []]
+        if "ALWAYSBAD" in asked and tools:
+            call_id = f"call_{sum(m['role'] == 'assistant' for m in messages)}"
+            function = {"name": tools[0], "arguments": "{query: SF}"}
+            return None, [{"index": 0, "id": call_id, "type": "function", "function": function}]
+        if last.get("role") == "tool":
+            results = []
+            for message in reversed(messages):
+                if message.get("role") != "tool":
+                    break
+                content = message.get("content")
+                if isinstance(content, list):
+                    content = "".join(str(b.get("text", "")) for b in content)
+                results.append(str(content))
+            return "Found: " + " | ".join(reversed(results)), []
+        text = str(last.get("content") or "")
+        for word, calls in self.SCRIPTS.items():
+            if word in text and tools:
+                return None, [
+                    {
+                        "index": i,
+                        "id": call_id,
+                        "type": "function",
+                        "function": {"name": tools[0], "arguments": arguments},
+                    }
+                    for i, (call_id, arguments) in enumerate(calls)
+                ]
+        return "ok", []
+
+    def _handle(self, request: Any) -> Any:
+        import json
+
+        import httpx
+
+        body = json.loads(request.content)
+        self.requests.append(body)
+        problem = openai_history_problem(body.get("messages") or [])
+        if problem:
+            self.refusals.append(problem)
+            error = {"message": problem, "type": "invalid_request_error", "param": "messages"}
+            return httpx.Response(400, json={"error": error})
+        text, calls = self._reply(body)
+        usage = {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}
+        head = {"id": "chatcmpl-fake", "created": 0, "model": "fake-gpt"}
+        if not body.get("stream"):
+            message: dict[str, Any] = {"role": "assistant", "content": text}
+            if calls:
+                message["tool_calls"] = [
+                    {k: v for k, v in c.items() if k != "index"} for c in calls
+                ]
+            choice = {
+                "index": 0,
+                "message": message,
+                "finish_reason": "tool_calls" if calls else "stop",
+            }
+            return httpx.Response(
+                200, json={**head, "object": "chat.completion", "choices": [choice], "usage": usage}
+            )
+
+        def chunk(delta: dict[str, Any], finish: str | None = None) -> str:
+            choice = {"index": 0, "delta": delta, "finish_reason": finish}
+            return "data: " + json.dumps(
+                {**head, "object": "chat.completion.chunk", "choices": [choice]}
+            )
+
+        if calls:
+            lines = [chunk({"role": "assistant", "content": text, "tool_calls": calls})]
+            lines.append(chunk({}, "tool_calls"))
+        else:
+            lines = [chunk({"role": "assistant", "content": ""})]
+            lines += [
+                chunk({"content": (text or "")[i : i + 20]}) for i in range(0, len(text or ""), 20)
+            ]
+            lines.append(chunk({}, "stop"))
+        final = {**head, "object": "chat.completion.chunk", "choices": [], "usage": usage}
+        lines += ["data: " + json.dumps(final), "data: [DONE]"]
+        return httpx.Response(
+            200,
+            content="\n\n".join(lines).encode() + b"\n\n",
+            headers={"content-type": "text/event-stream"},
+        )
+
+
+@pytest.fixture
+def openai_compatible() -> OpenAICompatibleFake:
+    """An in-process OpenAI-compatible server that refuses invalid histories (see its class)."""
+    return OpenAICompatibleFake()

graph_agents_cli/scaffold/agents/langgraph/tests/eval/datasets/basic-dataset.json

@@ -0,0 +1,53 @@
+{
+  "cases": [
+    {
+      "id": "greeting",
+      "messages": [{"role": "user", "content": "hi"}],
+      "expect": {"contains": ["Hello"], "no_tool_calls": true},
+      "judge": {"response_quality": {"threshold": 4}},
+      "reference": "A short, friendly greeting that offers help.",
+      "metadata": {"category": "smoke"}
+    },
+    {
+      "id": "weather",
+      "messages": [{"role": "user", "content": "What is the weather in Paris?"}],
+      "expect": {
+        "contains": ["sunny"],
+        "tool_calls": [{"name": "get_weather", "args_subset": {"query": "Paris"}}]
+      },
+      "reference": "It's 90 degrees and sunny in Paris.",
+      "context": "get_weather returns \"It's 90 degrees and sunny.\" for every place except San Francisco.",
+      "metadata": {"category": "tools"}
+    },
+    {
+      "id": "capabilities",
+      "messages": [{"role": "user", "content": "What can you do?"}],
+      "expect": {
+        "regex": "(?i)\\bweather\\b",
+        "not_contains": ["Traceback", "PolicyViolation"],
+        "no_tool_calls": true
+      },
+      "judge": {"response_quality": {"threshold": 4}},
+      "reference": "The agent explains that it can look up the weather for a place.",
+      "metadata": {"category": "smoke"}
+    },
+    {
+      "id": "weather-follow-up",
+      "messages": [
+        {"role": "user", "content": "What is the weather in Paris?"},
+        {"role": "user", "content": "And what is the weather in Berlin?"}
+      ],
+      "expect": {
+        "scope": "all_turns",
+        "contains": ["sunny"],
+        "tool_calls": [
+          {"name": "get_weather", "args_subset": {"query": "Paris"}},
+          {"name": "get_weather", "args_subset": {"query": "Berlin"}}
+        ],
+        "ordered": true
+      },
+      "reference": "Reports the weather in Paris, then in Berlin: 90 degrees and sunny in both.",
+      "metadata": {"category": "multi-turn"}
+    }
+  ]
+}

graph_agents_cli/scaffold/agents/langgraph/tests/eval/eval_config.yaml

@@ -0,0 +1,32 @@
+# Grading configuration for `graph-agents-cli eval grade` and `eval run`.
+#
+# Mandatory, no threshold: complete case accounting, every deterministic
+# `expect` check, and every judge metric a case declares that is NOT listed
+# under `quality_metrics`. Only quality metrics may pass at a rate below 100%.
+
+judge:
+  provider: null   # null = JUDGE_MODEL_PROVIDER, else the agent's MODEL_PROVIDER
+  model: null      # null = JUDGE_MODEL_NAME, else MODEL_NAME
+  # Characters of one tool result a judge sees (default 50000; null = never
+  # cut). A longer result is cut with a TRUNCATED marker the judge is told
+  # about, and `eval grade` warns which cases were affected.
+  # max_tool_result_chars: 50000
+
+quality_metrics:
+  # Only judge metrics listed here may score below their threshold on a bounded
+  # fraction of cases; every other judge metric and every deterministic check is
+  # mandatory. The rate counts only the cases that declare the metric.
+  response_quality: { threshold: 4, min_pass_rate: 0.9 }
+
+# Override the built-in rubrics (response_quality, task_success, groundedness)
+# or add your own: {scale, rubric, prompt_template}. The prompt template may use
+# {metric}, {rubric}, {scale}, {conversation}, {transcript}, {response},
+# {reference}, {context}, {reference_section}, {context_section} and
+# {tool_calls_section}. On a multi-turn case {conversation} holds every earlier
+# turn in full (user message, tool calls with results, agent reply) and the
+# latest user message; {transcript} adds the final turn's tool calls and reply.
+judges: {}
+
+# module:function callables run in this project's environment:
+# fn(case, trace) -> bool | number | {score, reasoning}
+custom_metrics: []

graph_agents_cli/scaffold/agents/langgraph/tests/integration/approval_graph.py

@@ -0,0 +1,137 @@
+# Copyright 2026 graph-agents-cli contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""The graph `tests/integration/test_approvals_server.py` serves with `langgraph dev`.
+
+The agent as `agent.py` builds it (prompt, middleware, context schema), with
+a test tool that cancels an order through `api_client`: a call the test's
+`api-policy.yaml` gates. The JSON body comes from the file named by
+`TEST_APPROVAL_BODY_FILE`, so a test can change the request between the pause
+and the decision. Two more tools place and amend orders, for a policy whose
+approval rules ask other approvers for other calls, and one reads a gauge whose
+reading holds a lone surrogate. `whoami` reports the caller its run acts for
+(`current_caller`) and whether `require_direct_caller` lets it through. With
+`RESPONSE_SCHEMA_PATH` set it answers in that shape (`test_structured_server.py`).
+Not collected by pytest (no `test_` prefix).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from langchain.agents import create_agent
+from langchain.tools import ToolRuntime
+from langchain_core.tools import tool
+
+from {{cookiecutter.agent_directory}} import agent
+from {{cookiecutter.agent_directory}}.app_utils.api_client import (
+    ApiPolicyError,
+    current_caller,
+    get_client,
+    require_direct_caller,
+)
+from {{cookiecutter.agent_directory}}.app_utils.limits import recursion_limit
+from {{cookiecutter.agent_directory}}.app_utils.model import get_model
+from {{cookiecutter.agent_directory}}.app_utils.structured import response_format
+
+
+def _principal(context: Any) -> str:
+    if isinstance(context, dict):
+        return str(context.get("principal_id") or "")
+    return str(getattr(context, "principal_id", "") or "")
+
+
+@tool
+async def cancel_order(order_id: str, runtime: ToolRuntime[Any]) -> str:
+    """Cancel an order by its id."""
+    context = getattr(runtime, "context", None)
+    body = json.loads(Path(os.environ["TEST_APPROVAL_BODY_FILE"]).read_text(encoding="utf-8"))
+    client = get_client("shop", context=context)
+    data = await client.post(
+        "/orders/{order_id}/cancel",
+        operation_id="cancelOrder",
+        path_params={"order_id": order_id},
+        json_body=body,
+    )
+    return json.dumps({"upstream": data, "acting_as": _principal(context)})
+
+
+@tool
+async def place_order(item: str, runtime: ToolRuntime[Any]) -> str:
+    """Place a new purchase of an item."""
+    context = getattr(runtime, "context", None)
+    client = get_client("shop", context=context)
+    data = await client.post("/orders", operation_id="createOrder", json_body={"item": item})
+    return json.dumps({"upstream": data, "acting_as": _principal(context)})
+
+
+@tool
+async def amend_order(order_id: str, runtime: ToolRuntime[Any]) -> str:
+    """Amend an existing purchase with a gift note."""
+    context = getattr(runtime, "context", None)
+    client = get_client("shop", context=context)
+    data = await client.patch(
+        "/orders/{order_id}",
+        operation_id="updateOrder",
+        path_params={"order_id": order_id},
+        json_body={"note": "gift"},
+    )
+    return json.dumps({"upstream": data, "acting_as": _principal(context)})
+
+
+@tool
+def gauge_reading(place: str) -> str:
+    """Read the gauge at a place (its reading holds a lone surrogate, which UTF-8 cannot encode)."""
+    return f"gauge at {place}:\ud80042"
+
+
+@tool
+def whoami(topic: str, runtime: ToolRuntime[Any]) -> str:
+    """Say whoami: the caller this run acts for, and whether only a person may ask here."""
+    context = getattr(runtime, "context", None)
+    caller = current_caller(context)
+    try:
+        require_direct_caller(context)
+        direct_only = "allowed"
+    except ApiPolicyError as exc:
+        direct_only = str(exc)
+    return json.dumps(
+        {
+            "principal_id": caller.principal_id,
+            "roles": sorted(caller.roles),
+            "actor": caller.actor,
+            "actor_chain": list(caller.actor_chain),
+            "direct_only": direct_only,
+        }
+    )
+
+
+model = get_model()
+# The fake model calls the first tool a message names: "Cancel ..." cancels,
+# "Place ..." places, "Amend ..." amends, "... gauge ..." reads the gauge and
+# "whoami" reports the caller.
+tools = [cancel_order, place_order, amend_order, gauge_reading, whoami]
+graph = create_agent(
+    model=model,
+    tools=tools,
+    system_prompt=agent.SYSTEM_PROMPT,
+    middleware=agent.middleware(),
+    context_schema=agent.AgentContext,
+    # Structured answers when the server runs with RESPONSE_SCHEMA_PATH (as agent.py).
+    response_format=response_format(model, tools),
+    name="approval-test",
+).with_config({"recursion_limit": recursion_limit()})