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.ymlindex c3fe3fbb..56535d4b 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -311,7 +311,14 @@ jobs:. .venv-pydantic-ai/bin/activatepython -m pip install --requirement agent-pydantic-ai/requirements.txt --requirement agent-pydantic-ai/requirements-test.txtpython -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 regressionsrun: |set -euo pipefailpython -m venv .venv-langroiddiff --git a/agent-adk/requirements-test.txt b/agent-adk/requirements-test.txtnew file mode 100644index 00000000..a91d60c6--- /dev/null+++ b/agent-adk/requirements-test.txt@@ -0,0 +1,2 @@+httpx==0.28.1+pytest==9.0.2diff --git a/agent-adk/src/main.py b/agent-adk/src/main.pyindex 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_endpointfrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponsefrom 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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_appfrom fastapi import Requestfrom fastapi.responses import JSONResponsefrom langroid import ChatAgent, ChatAgentConfigfrom 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.pynew file mode 100644index 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]