Merge branch 'main' into fix/shared-computer-run-identity

Author: davidmckayv

.env.example

@@ -132,6 +132,15 @@ INTELLIGENCE_API_KEY=
 # it is forwarded to the runtime; startup does not require it.
 COPILOTKIT_LICENSE_TOKEN=
 
+# Optional Automatic Learning default. Create this container in the same Intelligence project.
+# Admin → Automatic Learning can enable/disable, override per Bot, and save settings in the DB.
+# Saved settings take precedence, including a saved off state. Unset means Learning is off.
+# Project credentials remain server-side; review and publish skills in the Intelligence UI.
+# CPK_INTELLIGENCE_LEARNING_CONTAINER_ID=support-learning
+# Optional opaque published revision ID; omit to follow latest.
+# CPK_INTELLIGENCE_SKILLS_REVISION=exact-revision-id
+# See docs/automatic-learning.md for managed/self-hosted setup and permissions.
+
 # How long a Bot's stream may say nothing before this deployment gives up on the turn, in
 # milliseconds. A Bot is any AG-UI endpoint, which means it will be redeployed mid-answer, its own
 # upstream will time out, and it will sometimes accept a connection and then write nothing at all.

agent-adk/src/main.py

@@ -15,6 +15,33 @@
 TOKEN_HEADER = "x-openbot-agent-token"
 
 
+class CompleteToolCallsLiteLlm(LiteLlm):
+    """Keep tool args together at AG-UI's long-running tool boundary.
+
+    ADK 2.10 streams partial FunctionCalls before their args exist. AG-UI 0.7
+    treats the first long-running FunctionCall as complete and deduplicates the
+    final one, losing its arguments. Wait for the complete call, while allowing
+    ordinary text deltas to stream normally. No tool is executed here.
+    """
+
+    async def generate_content_async(self, llm_request, stream=False):
+        async for response in super().generate_content_async(llm_request, stream):
+            if response.partial and response.content and any(
+                part.function_call for part in response.content.parts or []
+            ):
+                remaining = [
+                    part for part in response.content.parts or []
+                    if not part.function_call
+                ]
+                if not remaining:
+                    continue
+                response = response.model_copy(update={
+                    "content": response.content.model_copy(update={"parts": remaining})
+                })
+            yield response
+
+
+
 def _model_id() -> str:
     """`provider/model`, which is how litellm addresses one.
 
@@ -55,7 +82,7 @@ async def health():
         adk_agent=Agent(
             name="openbot",
             tools=[AGUIToolset()],
-            model=LiteLlm(model=_model_id()),
+            model=CompleteToolCallsLiteLlm(model=_model_id()),
             instruction="Answer the question you are asked, briefly and correctly.",
         ),
         app_name="openbot",

agent-adk/tests/test_learning_delivery.py

@@ -0,0 +1,45 @@
+"""Exercise learned skill reads through the real bundled framework."""
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tests"))
+sys.path.insert(0, str(ROOT / "agent-adk"))
+
+from learning_harness_contract import assert_learning_delivery
+
+
+def test_learned_catalog_and_both_read_tools_reach_the_model(monkeypatch):
+    assert_learning_delivery(monkeypatch, "agent-adk", "/")
+
+
+def test_partial_tool_arguments_wait_without_dropping_neighboring_text(monkeypatch):
+    import asyncio
+    import importlib
+    from google.adk.models.lite_llm import LiteLlm
+    from google.adk.models.llm_response import LlmResponse
+    from google.genai import types
+
+    monkeypatch.setenv("BOT_MODEL", "gpt-4.1-mini")
+    main = importlib.import_module("src.main")
+
+    async def provider(self, request, stream=False):
+        yield LlmResponse(partial=True, content=types.Content(role="model", parts=[
+            types.Part(text="Looking up the policy."),
+            types.Part(function_call=types.FunctionCall(id="call", name="copilotkit_load_skill", will_continue=True)),
+        ]))
+        yield LlmResponse(partial=False, content=types.Content(role="model", parts=[
+            types.Part(function_call=types.FunctionCall(id="call", name="copilotkit_load_skill", args={"skill_name": "refunds"})),
+        ]))
+
+    monkeypatch.setattr(LiteLlm, "generate_content_async", provider)
+
+    async def collect():
+        model = main.CompleteToolCallsLiteLlm(model="openai/gpt-4.1-mini")
+        return [response async for response in model.generate_content_async(None, True)]
+
+    responses = asyncio.run(collect())
+    assert responses[0].content.parts == [types.Part(text="Looking up the policy.")]
+    assert responses[1].content.parts[0].function_call.args == {"skill_name": "refunds"}
+    assert responses[1].content.parts[0].function_call.id == "call"

agent-ag2/tests/test_learning_delivery.py

@@ -0,0 +1,14 @@
+"""Exercise learned skill reads through the real bundled framework."""
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tests"))
+sys.path.insert(0, str(ROOT / "agent-ag2"))
+
+from learning_harness_contract import assert_learning_delivery
+
+
+def test_learned_catalog_and_both_read_tools_reach_the_model(monkeypatch):
+    assert_learning_delivery(monkeypatch, "agent-ag2", "/")

agent-agno/tests/test_learning_delivery.py

@@ -0,0 +1,14 @@
+"""Exercise learned skill reads through the real bundled framework."""
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tests"))
+sys.path.insert(0, str(ROOT / "agent-agno"))
+
+from learning_harness_contract import assert_learning_delivery
+
+
+def test_learned_catalog_and_both_read_tools_reach_the_model(monkeypatch):
+    assert_learning_delivery(monkeypatch, "agent-agno", "/agui")

agent-claude-sdk/tests/test_tool_continuation.py

@@ -27,7 +27,7 @@
 from src.adapter import OpenBotClaudeAgentAdapter
 
 
-def request(thread="thread-a", run="run-1", results=(), tool_count=1):
+def request(thread="thread-a", run="run-1", results=(), tool_count=1, tool_name="computer_navigate"):
     return RunAgentInput.model_validate(
         {
             "threadId": thread,
@@ -47,19 +47,24 @@ def request(thread="thread-a", run="run-1", results=(), tool_count=1):
             ],
             "tools": [
                 {
-                    "name": "computer_navigate",
+                    "name": tool_name,
                     "description": "Navigate",
                     "parameters": {"type": "object", "properties": {}},
                 }
             ],
-            "context": [],
+            "context": [{"description": "OpenBot learned skills", "value": "LEARNED_CATALOG_MARKER"}],
             "forwardedProps": {},
         }
     )
 
 
 @pytest.fixture
-def sdk(monkeypatch):
+def tool_name():
+    return "computer_navigate"
+
+
+@pytest.fixture
+def sdk(monkeypatch, tool_name):
     clients = []
 
     class Client:
@@ -106,7 +111,7 @@ async def receive_response(self):
             calls = [
                 ToolUseBlock(
                     id=f"{thread}-tool-{i}",
-                    name="mcp__ag_ui__computer_navigate",
+                    name=f"mcp__ag_ui__{tool_name}",
                     input={},
                 )
                 for i in range(count)
@@ -206,15 +211,16 @@ async def events(adapter, input_data):
 
 @pytest.mark.parametrize("streaming", [False, True])
 @pytest.mark.parametrize("model_only", [False, True])
-def test_client_result_resumes_original_sdk_query(sdk, streaming, model_only):
+@pytest.mark.parametrize("tool_name", ["computer_navigate", "copilotkit_load_skill", "copilotkit_read_skill_file"])
+def test_client_result_resumes_original_sdk_query(sdk, streaming, model_only, tool_name):
     async def scenario():
         adapter = OpenBotClaudeAgentAdapter(
             name="test",
             options={"include_partial_messages": streaming},
             model_only=model_only,
         )
         try:
-            first = await events(adapter, request())
+            first = await events(adapter, request(tool_name=tool_name))
             assert any(event.type == "TOOL_CALL_END" for event in first)
             opened = [
                 event.message_id
@@ -231,6 +237,7 @@ async def scenario():
                 adapter,
                 request(
                     run="run-2",
+                    tool_name=tool_name,
                     results=[
                         (
                             "thread-a-tool-0",
@@ -239,6 +246,7 @@ async def scenario():
                     ],
                 ),
             )
+            assert "LEARNED_CATALOG_MARKER" in str(sdk[0].options.system_prompt)
             assert sdk[0].queries == [("1", "thread-a")], (
                 "a tool result must not become another SDK user prompt"
             )

agent-crewai/tests/test_learning_delivery.py

@@ -0,0 +1,14 @@
+"""Exercise learned skill reads through the real bundled framework."""
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tests"))
+sys.path.insert(0, str(ROOT / "agent-crewai"))
+
+from learning_harness_contract import assert_learning_delivery
+
+
+def test_learned_catalog_and_both_read_tools_reach_the_model(monkeypatch):
+    assert_learning_delivery(monkeypatch, "agent-crewai", "/")

agent-langgraph-agui/tests/test_tool_protocol.py

@@ -315,10 +315,12 @@ async def test_a2ui_catalog_context_reaches_model_without_entering_history(bound
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("name", ["computer_navigate", "computer_run_command"])
+@pytest.mark.parametrize("name", ["computer_navigate", "computer_run_command", "copilotkit_load_skill", "copilotkit_read_skill_file"])
 async def test_surface_tool_calls_end_then_consume_actual_client_result(boundary, name):
     body = run_input([name])
+    body["context"] = [{"description": "OpenBot learned skills", "value": "LEARNED_CATALOG_MARKER"}]
     first = await run_protocol(body)
+    assert "LEARNED_CATALOG_MARKER" in json.dumps(boundary["model"][0]["messages"])
     assert [t["function"]["name"] for t in boundary["model"][0].get("tools", [])] == [
         name
     ]

agent-langroid/tests/test_learning_delivery.py

@@ -0,0 +1,14 @@
+"""Exercise learned skill reads through the real bundled framework."""
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tests"))
+sys.path.insert(0, str(ROOT / "agent-langroid"))
+
+from learning_harness_contract import assert_learning_delivery
+
+
+def test_learned_catalog_and_both_read_tools_reach_the_model(monkeypatch):
+    assert_learning_delivery(monkeypatch, "agent-langroid", "/")

agent-llamaindex/tests/test_learning_delivery.py

@@ -0,0 +1,14 @@
+"""Exercise learned skill reads through the real bundled framework."""
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "tests"))
+sys.path.insert(0, str(ROOT / "agent-llamaindex"))
+
+from learning_harness_contract import assert_learning_delivery
+
+
+def test_learned_catalog_and_both_read_tools_reach_the_model(monkeypatch):
+    assert_learning_delivery(monkeypatch, "agent-llamaindex", "/run")