Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

Fix supplied tool calls in ADK and Langroid Bots (#615)

David McKay61cc46ae0217
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c3fe3fbb..56535d4b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -311,7 +311,14 @@ jobs:
. .venv-pydantic-ai/bin/activate
python -m pip install --requirement agent-pydantic-ai/requirements.txt --requirement agent-pydantic-ai/requirements-test.txt
python -m pytest agent-pydantic-ai/tests -q
- - name: Langroid model-choice regression
+ - name: Google ADK tool-call regressions
+ run: |
+ set -euo pipefail
+ python -m venv .venv-adk
+ . .venv-adk/bin/activate
+ python -m pip install --requirement agent-adk/requirements.txt --requirement agent-adk/requirements-test.txt
+ python -m pytest agent-adk/tests -q
+ - name: Langroid model-choice and tool-call regressions
run: |
set -euo pipefail
python -m venv .venv-langroid
diff --git a/agent-adk/requirements-test.txt b/agent-adk/requirements-test.txt
new file mode 100644
index 00000000..a91d60c6
--- /dev/null
+++ b/agent-adk/requirements-test.txt
@@ -0,0 +1,2 @@
+httpx==0.28.1
+pytest==9.0.2
diff --git a/agent-adk/src/main.py b/agent-adk/src/main.py
index 0ed02c2c..33b65997 100644
--- a/agent-adk/src/main.py
+++ b/agent-adk/src/main.py
@@ -6,7 +6,7 @@ reads LiteLLM model strings, and OpenBot writes the one it was told.
import os
-from ag_ui_adk import ADKAgent, add_adk_fastapi_endpoint
+from ag_ui_adk import ADKAgent, AGUIToolset, add_adk_fastapi_endpoint
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from google.adk.agents import Agent
@@ -44,6 +44,7 @@ add_adk_fastapi_endpoint(
ADKAgent(
adk_agent=Agent(
name="openbot",
+ tools=[AGUIToolset()],
model=LiteLlm(model=_model_id()),
instruction="Answer the question you are asked, briefly and correctly.",
),
diff --git a/agent-adk/tests/test_main.py b/agent-adk/tests/test_main.py
new file mode 100644
index 00000000..2bd70092
--- /dev/null
+++ b/agent-adk/tests/test_main.py
@@ -0,0 +1,172 @@
+"""Real ADK/LiteLLM roundtrip; only the provider's HTTP responses are synthetic."""
+
+import asyncio
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import importlib
+import json
+from pathlib import Path
+import sys
+from threading import Thread
+
+import httpx
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+TOKEN = "test-managed-token"
+TOOL_NAME = "read_probe_value"
+TOOL_VALUE = "value-returned-by-the-client-tool"
+TOOL = {
+ "name": TOOL_NAME,
+ "description": "Read a validation value.",
+ "parameters": {
+ "type": "object",
+ "properties": {"request_id": {"type": "string"}},
+ "required": ["request_id"],
+ },
+}
+USER = {"id": "user", "role": "user", "content": "Read the probe value."}
+
+
+def provider():
+ seen = []
+
+ class Provider(BaseHTTPRequestHandler):
+ def log_message(self, *args):
+ pass
+
+ def do_POST(self):
+ body = json.loads(self.rfile.read(int(self.headers["content-length"])))
+ seen.append((self.path, self.headers.get("authorization"), body))
+ names = [tool["function"]["name"] for tool in body.get("tools", [])]
+ results = [message for message in body["messages"] if message["role"] == "tool"]
+ delta = {"role": "assistant", "content": "No callable tool was supplied."}
+ reason = "stop"
+ if results and TOOL_VALUE in json.dumps(results):
+ delta = {"role": "assistant", "content": TOOL_VALUE}
+ elif TOOL_NAME in names:
+ delta = {
+ "role": "assistant",
+ "tool_calls": [{
+ "index": 0,
+ "id": "call_probe",
+ "type": "function",
+ "function": {"name": TOOL_NAME, "arguments": '{"request_id":"probe"}'},
+ }],
+ }
+ reason = "tool_calls"
+ base = {"id": "chat_probe", "object": "chat.completion.chunk", "created": 0, "model": body["model"]}
+ chunks = [
+ {**base, "choices": [{"index": 0, "delta": delta, "finish_reason": None}]},
+ {**base, "choices": [{"index": 0, "delta": {}, "finish_reason": reason}]},
+ ]
+ data = ("".join(f"data: {json.dumps(chunk)}\n\n" for chunk in chunks) + "data: [DONE]\n\n").encode()
+ self.send_response(200)
+ self.send_header("Content-Type", "text/event-stream")
+ self.send_header("Content-Length", str(len(data)))
+ self.end_headers()
+ self.wfile.write(data)
+
+ server = ThreadingHTTPServer(("127.0.0.1", 0), Provider)
+ thread = Thread(target=server.serve_forever, daemon=True)
+ thread.start()
+ try:
+ yield f"http://127.0.0.1:{server.server_port}/v1", seen
+ finally:
+ server.shutdown()
+ server.server_close()
+ thread.join(timeout=5)
+
+
+def harness(monkeypatch, provider):
+ base_url, seen = provider
+ for name, value in {
+ "OPENAI_API_KEY": "synthetic-test-key",
+ "OPENAI_BASE_URL": base_url,
+ "BOT_PROVIDER": "openai",
+ "BOT_MODEL": "gpt-4.1-mini",
+ "MANAGED_AGENT_TOKEN": TOKEN,
+ "OTEL_SDK_DISABLED": "true",
+ }.items():
+ monkeypatch.setenv(name, value)
+ monkeypatch.delenv("OPENAI_API_BASE", raising=False)
+ from src import main
+
+ return importlib.reload(main).app, seen
+
+
+def decode(response):
+ assert response.status_code == 200
+ events = [json.loads(line[5:]) for line in response.text.splitlines() if line.startswith("data:")]
+ assert not any(event["type"] == "RUN_ERROR" for event in events), events
+ assert any(event["type"] == "RUN_FINISHED" for event in events), events
+ return events
+
+
+def test_client_tool_executes_and_its_result_reaches_the_followup_model(harness):
+ app, seen = harness
+ executed = []
+
+ def read_probe_value(request_id):
+ executed.append(request_id)
+ assert request_id == "probe"
+ return {"value": TOOL_VALUE}
+
+ async def roundtrip():
+ body = {
+ "threadId": "tool-roundtrip",
+ "runId": "first-run",
+ "state": {},
+ "context": [],
+ "forwardedProps": {},
+ "messages": [USER],
+ "tools": [TOOL],
+ }
+ async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://harness") as client:
+ first = decode(await client.post("/", headers={"x-openbot-agent-token": TOKEN}, json=body))
+ calls = [event for event in first if event["type"] == "TOOL_CALL_START"]
+ assert len(calls) == 1, first
+ call = calls[0]
+ assert call["toolCallName"] == TOOL_NAME
+ arguments = "".join(event["delta"] for event in first if event["type"] == "TOOL_CALL_ARGS" and event["toolCallId"] == call["toolCallId"])
+ result = read_probe_value(**json.loads(arguments))
+ body.update(runId="followup-run", messages=[
+ USER,
+ {"id": call.get("parentMessageId", "assistant-tool-call"), "role": "assistant", "toolCalls": [{
+ "id": call["toolCallId"], "type": "function",
+ "function": {"name": TOOL_NAME, "arguments": arguments},
+ }]},
+ {"id": "tool-result", "role": "tool", "toolCallId": call["toolCallId"], "content": json.dumps(result)},
+ ])
+ return decode(await client.post("/", headers={"x-openbot-agent-token": TOKEN}, json=body))
+
+ final = asyncio.run(asyncio.wait_for(roundtrip(), timeout=30))
+ assert executed == ["probe"]
+ assert len(seen) == 2
+ for path, authorization, body in seen:
+ assert path == "/v1/chat/completions"
+ assert authorization == "Bearer synthetic-test-key"
+ assert body["model"] == "gpt-4.1-mini"
+ tools = seen[0][2]["tools"]
+ assert [tool["function"]["name"] for tool in tools] == [TOOL_NAME]
+ assert tools[0]["function"]["parameters"]["properties"]["request_id"]["type"] == "string"
+ assert tools[0]["function"]["parameters"]["required"] == ["request_id"]
+ results = [message for message in seen[1][2]["messages"] if message["role"] == "tool"]
+ assert len(results) == 1
+ assert TOOL_VALUE in results[0]["content"]
+ answer = "".join(event["delta"] for event in final if event["type"] == "TEXT_MESSAGE_CONTENT")
+ assert answer == TOOL_VALUE
+
+
[email protected]("headers", [{}, {"x-openbot-agent-token": "wrong-token"}])
+def test_client_tools_still_require_the_server_token(harness, headers):
+ app, seen = harness
+
+ async def rejected():
+ async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://harness") as client:
+ return await client.post("/", headers=headers, json={"tools": [TOOL]})
+
+ assert asyncio.run(rejected()).status_code == 401
+ assert seen == []
diff --git a/agent-langroid/src/frontend_tools.py b/agent-langroid/src/frontend_tools.py
new file mode 100644
index 00000000..34f64a43
--- /dev/null
+++ b/agent-langroid/src/frontend_tools.py
@@ -0,0 +1,80 @@
+"""Supply AG-UI tool schemas and returned history to Langroid's public LLM API."""
+
+from copy import deepcopy
+
+from ag_ui.core import RunAgentInput, Tool
+from ag_ui_langroid import LangroidAgent
+from langroid import ChatAgent, ChatAgentConfig, ChatDocument, ToolMessage
+from langroid.language_models.base import LLMFunctionSpec, LLMMessage, OpenAIToolCall, Role
+
+
+def _tool_message(tool: Tool) -> type[ToolMessage]:
+ class FrontendTool(ToolMessage):
+ request: str = tool.name
+ purpose: str = tool.description
+ strict: bool = False
+
+ @classmethod
+ def llm_function_schema(cls, request=False, defaults=True):
+ return LLMFunctionSpec(
+ name=tool.name,
+ description=tool.description,
+ parameters=deepcopy(tool.parameters),
+ )
+
+ return FrontendTool
+
+
+def _messages(input_data: RunAgentInput, system_message: str) -> list[LLMMessage]:
+ messages = [LLMMessage(role=Role.SYSTEM, content=system_message)]
+ for message in input_data.messages:
+ content = getattr(message, "content", None)
+ if isinstance(content, list):
+ content = "\n".join(part.text for part in content if part.type == "text")
+ calls = getattr(message, "tool_calls", None)
+ messages.append(
+ LLMMessage(
+ role=Role.SYSTEM if message.role == "developer" else Role(message.role),
+ content=content,
+ tool_call_id=getattr(message, "tool_call_id", None),
+ tool_calls=[OpenAIToolCall.from_dict(call.model_dump()) for call in calls]
+ if calls
+ else None,
+ )
+ )
+ return messages
+
+
+class _RequestAgent(ChatAgent):
+ def __init__(self, config: ChatAgentConfig):
+ super().__init__(config)
+ self.input_messages: list[LLMMessage] = []
+ self.response_ids: list[str] = []
+
+ def _clone_extra_state(self, new_agent):
+ new_agent.input_messages = self.input_messages
+ new_agent.response_ids = self.response_ids
+
+ def llm_response(self, message=None):
+ response = self.llm_response_messages(self.input_messages)
+ if response is not None:
+ self.response_ids.append(response.id())
+ return response
+
+
+class FrontendToolsAgent(LangroidAgent):
+ async def run(self, input_data: RunAgentInput):
+ # ag-ui-langroid 0.1.1 forwards only tool names and the latest user text.
+ # https://github.com/ag-ui-protocol/ag-ui/tree/main/integrations/langroid
+ # Keep its event encoding, but use each run's complete history and schemas.
+ agent = _RequestAgent(self._agent.config.model_copy(deep=True))
+ agent.input_messages = _messages(input_data, agent.config.system_message)
+ for tool in input_data.tools:
+ agent.enable_message(_tool_message(tool), use=True, handle=False)
+ adapter = LangroidAgent(name=self.name, agent=agent)
+ try:
+ async for event in adapter.run(input_data):
+ yield event
+ finally:
+ for response_id in agent.response_ids:
+ ChatDocument.delete_id(response_id)
diff --git a/agent-langroid/src/main.py b/agent-langroid/src/main.py
index c8468de4..58b59c2d 100644
--- a/agent-langroid/src/main.py
+++ b/agent-langroid/src/main.py
@@ -2,12 +2,14 @@
import os
-from ag_ui_langroid import LangroidAgent, create_langroid_app
+from ag_ui_langroid import create_langroid_app
from fastapi import Request
from fastapi.responses import JSONResponse
from langroid import ChatAgent, ChatAgentConfig
from langroid.language_models import OpenAIGPTConfig
+from .frontend_tools import FrontendToolsAgent
+
TOKEN_HEADER = "x-openbot-agent-token"
@@ -33,12 +35,15 @@ if not os.environ.get("OPENAI_API_KEY"):
agent = ChatAgent(
ChatAgentConfig(
- llm=OpenAIGPTConfig(chat_model=_model_id()),
+ llm=OpenAIGPTConfig(chat_model=_model_id(), parallel_tool_calls=False),
+ add_to_registry=False,
+ use_functions_api=True,
+ use_tools=False,
system_message="Answer the question you are asked, briefly and correctly.",
)
)
-app = create_langroid_app(LangroidAgent(name="openbot", agent=agent))
+app = create_langroid_app(FrontendToolsAgent(name="openbot", agent=agent))
@app.middleware("http")
diff --git a/agent-langroid/tests/test_tools.py b/agent-langroid/tests/test_tools.py
new file mode 100644
index 00000000..65395aa7
--- /dev/null
+++ b/agent-langroid/tests/test_tools.py
@@ -0,0 +1,199 @@
+"""The real Langroid/AG-UI stack, with only provider HTTP replaced."""
+
+import importlib
+import json
+import sys
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from copy import deepcopy
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+from fastapi.testclient import TestClient
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+ARGUMENTS = {"selection": {"labels": ["first", "second"], "enabled": True}}
+TOOL = {
+ "name": "read_selection",
+ "description": "Read the selected items.",
+ "parameters": {
+ "type": "object",
+ "properties": {"selection": {"$ref": "#/$defs/Selection"}},
+ "required": ["selection"],
+ "additionalProperties": False,
+ "$defs": {
+ "Selection": {
+ "type": "object",
+ "properties": {
+ "labels": {"type": "array", "items": {"type": "string"}},
+ "enabled": {"type": "boolean"},
+ },
+ "required": ["labels", "enabled"],
+ "additionalProperties": False,
+ }
+ },
+ },
+}
+
+
+def boundary(monkeypatch):
+ requests = []
+
+ class Provider(BaseHTTPRequestHandler):
+ def log_message(self, *args):
+ pass
+
+ def do_POST(self):
+ body = json.loads(self.rfile.read(int(self.headers["content-length"])))
+ requests.append(body)
+ last = body["messages"][-1]
+ if last["role"] == "tool" and last["content"] != "CALL_AGAIN":
+ message = {"role": "assistant", "content": "Observed: " + last["content"]}
+ finish = "stop"
+ elif body.get("tools"):
+ name = body["tools"][0]["function"]["name"]
+ message = {
+ "role": "assistant",
+ "tool_calls": [{"id": "provider-call", "type": "function", "function": {
+ "name": name, "arguments": json.dumps(ARGUMENTS),
+ }}],
+ }
+ finish = "tool_calls"
+ else:
+ message = {"role": "assistant", "content": "No tools offered: " + last["content"]}
+ finish = "stop"
+ if body.get("stream"):
+ delta = deepcopy(message)
+ for call in delta.get("tool_calls", []):
+ call["index"] = 0
+ base = {"id": "chat", "object": "chat.completion.chunk", "created": 0, "model": body["model"]}
+ chunks = [
+ {**base, "choices": [{"index": 0, "delta": delta, "finish_reason": None}]},
+ {**base, "choices": [{"index": 0, "delta": {}, "finish_reason": finish}]},
+ ]
+ data = ("".join("data: " + json.dumps(chunk) + "\n\n" for chunk in chunks) + "data: [DONE]\n\n").encode()
+ content_type = "text/event-stream"
+ else:
+ data = json.dumps({"id": "chat", "object": "chat.completion", "created": 0, "model": body["model"],
+ "choices": [{"index": 0, "message": message, "finish_reason": finish}],
+ "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}}).encode()
+ content_type = "application/json"
+ self.send_response(200)
+ self.send_header("Content-Type", content_type)
+ self.send_header("Content-Length", str(len(data)))
+ self.end_headers()
+ self.wfile.write(data)
+
+ provider = ThreadingHTTPServer(("127.0.0.1", 0), Provider)
+ thread = threading.Thread(target=provider.serve_forever, daemon=True)
+ thread.start()
+ monkeypatch.setenv("OPENAI_API_KEY", "synthetic-key")
+ monkeypatch.setenv("BOT_PROVIDER", "openai")
+ monkeypatch.setenv("BOT_MODEL", "gpt-4.1-mini")
+ # Each test owns a different HTTP server; don't reuse a client for a closed port.
+ monkeypatch.setenv("OPENAI_USE_CACHED_CLIENT", "false")
+ monkeypatch.setenv("OPENAI_BASE_URL", f"http://127.0.0.1:{provider.server_port}/v1")
+ monkeypatch.setenv("MANAGED_AGENT_TOKEN", "test-token")
+ monkeypatch.delenv("OPENAI_API_BASE", raising=False)
+ try:
+ from src import main
+
+ main = importlib.reload(main)
+ yield TestClient(main.app), requests
+ finally:
+ provider.shutdown()
+ provider.server_close()
+ thread.join(timeout=5)
+
+
+def body(*, tools=None, messages=None, thread=None):
+ return {
+ "threadId": thread or str(uuid4()), "runId": str(uuid4()), "state": {},
+ "messages": messages or [{"id": "user", "role": "user", "content": "Read the selected items."}],
+ "tools": [deepcopy(TOOL)] if tools is None else tools,
+ "context": [], "forwardedProps": {},
+ }
+
+
+def run(client, request):
+ response = client.post("/", json=request, headers={"x-openbot-agent-token": "test-token"})
+ assert response.status_code == 200
+ events = [json.loads(line[5:]) for line in response.text.splitlines() if line.startswith("data:")]
+ assert not [event for event in events if event["type"] == "RUN_ERROR"], events
+ assert events[-1]["type"] == "RUN_FINISHED", events
+ return events
+
+
+def tool_call(events):
+ start = next(event for event in events if event["type"] == "TOOL_CALL_START")
+ arguments = "".join(event["delta"] for event in events if event["type"] == "TOOL_CALL_ARGS")
+ return start, json.loads(arguments)
+
+
+def result_history(request, start, arguments, result):
+ return [*request["messages"], {
+ "id": start["parentMessageId"], "role": "assistant", "toolCalls": [{
+ "id": start["toolCallId"], "type": "function",
+ "function": {"name": start["toolCallName"], "arguments": json.dumps(arguments)},
+ }],
+ }, {"id": "result", "role": "tool", "toolCallId": start["toolCallId"], "content": result}]
+
+
+def test_dynamic_nested_schema_and_real_result_reach_the_sdk(boundary):
+ from langroid.utils.object_registry import ObjectRegistry
+
+ client, requests = boundary
+ registered_before = set(ObjectRegistry.registry)
+ request = body()
+ start, arguments = tool_call(run(client, request))
+ assert requests[0]["tools"][0]["function"]["parameters"] == TOOL["parameters"]
+ assert requests[0]["parallel_tool_calls"] is False
+ assert arguments == ARGUMENTS
+ result = "returned-value-" + str(uuid4())
+ followup = body(thread=request["threadId"], messages=result_history(request, start, arguments, result))
+ events = run(client, followup)
+ assert requests[1]["messages"][-1] == {"role": "tool", "content": result, "tool_call_id": start["toolCallId"]}
+ assert result in "".join(e.get("delta", "") for e in events if e["type"] == "TEXT_MESSAGE_CONTENT")
+ assert all(m.get("content") not in {"Done", "Done!"} for m in requests[1]["messages"])
+ assert set(ObjectRegistry.registry) == registered_before
+
+
+def test_followup_can_request_another_tool(boundary):
+ client, requests = boundary
+ request = body()
+ start, arguments = tool_call(run(client, request))
+ followup = body(thread=request["threadId"], messages=result_history(request, start, arguments, "CALL_AGAIN"))
+ next_start, next_arguments = tool_call(run(client, followup))
+ assert next_start["toolCallName"] == TOOL["name"]
+ assert next_arguments == ARGUMENTS
+ assert requests[1]["messages"][-1]["content"] == "CALL_AGAIN"
+
+
+def test_current_input_replaces_tools_and_history_even_on_the_same_thread(boundary):
+ client, requests = boundary
+ thread = str(uuid4())
+ run(client, body(thread=thread))
+ run(client, body(thread=thread, tools=[], messages=[{"id": "new", "role": "user", "content": "Independent current history."}]))
+ assert not requests[1].get("tools")
+ assert [m["content"] for m in requests[1]["messages"] if m["role"] == "user"] == ["Independent current history."]
+ assert not any(m.get("tool_calls") or m["role"] == "tool" for m in requests[1]["messages"])
+
+
+def test_concurrent_runs_do_not_share_tool_schemas_or_messages(boundary):
+ client, requests = boundary
+ thread = str(uuid4())
+ inputs = []
+ for name in ["first", "second"]:
+ tool = {**deepcopy(TOOL), "name": name}
+ inputs.append(body(thread=thread, tools=[tool], messages=[{"id": name, "role": "user", "content": name}]))
+ with ThreadPoolExecutor(max_workers=2) as pool:
+ outputs = list(pool.map(lambda request: run(client, request), inputs))
+ assert [tool_call(events)[0]["toolCallName"] for events in outputs] == ["first", "second"]
+ assert len(requests) == 2
+ for request in requests:
+ tool_name = request["tools"][0]["function"]["name"]
+ assert [m["content"] for m in request["messages"] if m["role"] == "user"] == [tool_name]