Setup, end to end: pick a Bot, connect a model, prove it answers

.env.example

@@ -160,6 +160,11 @@ OPENAI_API_KEY=
 #
 # OPENAI_BASE_URL=
 
+# Optional. Leave empty unless containers need a different route to the same compatible endpoint,
+# such as a locally hosted model whose host URL is localhost but whose Compose-network URL is a
+# service name. Empty means containers use OPENAI_BASE_URL too.
+# OPENAI_CONTAINER_BASE_URL=
+
 # The same for the other two providers, under the names the API server already reads. They are
 # different APIs rather than different URLs for this one, so each has its own.
 # ANTHROPIC_BASE_URL=

.github/published-images.json

@@ -1 +1,19 @@
-["agent-computer", "supervisor", "agent-bot", "agent-langgraph", "server"]
+[
+  "agent-computer",
+  "supervisor",
+  "agent-bot",
+  "agent-langgraph",
+  "server",
+  "agent-crewai",
+  "agent-llamaindex",
+  "agent-agno",
+  "agent-langgraph-agui",
+  "agent-adk",
+  "agent-pydantic-ai",
+  "agent-microsoft",
+  "agent-claude-sdk",
+  "agent-strands",
+  "agent-ag2",
+  "agent-langroid",
+  "agent-mastra"
+]

.github/workflows/ci.yml

@@ -215,6 +215,14 @@ jobs:
       # Bot's own tree and not in the root one.
       - run: bun install --frozen-lockfile
         working-directory: agent-langgraph
+      # Same for the Mastra Bot: root test discovery imports its receiver tests, which load Mastra
+      # from that Bot's own dependency tree.
+      - run: bun install
+        working-directory: agent-mastra
+      # Same for the desktop app: root test discovery imports its React tests, whose JSX runtime is
+      # pinned by the desktop lockfile rather than the root one.
+      - run: bun install --frozen-lockfile
+        working-directory: desktop
       # Not the db:migrate script: that one loads ../.env, which does not exist in CI. DATABASE_URL
       # comes from the job env instead, which drizzle.config.ts already reads.
       - run: bunx drizzle-kit migrate --config=drizzle.config.ts
@@ -223,6 +231,39 @@ jobs:
       # files before their tests are registered.
       - run: bun run test:ci
 
+  python-harness:
+    name: python harness regressions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version: 1.3.14
+      - name: CrewAI provider-boundary regression
+        run: |
+          set -euo pipefail
+          python -m venv .venv-crewai
+          . .venv-crewai/bin/activate
+          python -m pip install --requirement agent-crewai/requirements.txt --requirement agent-crewai/requirements-test.txt
+          python -m pytest agent-crewai/tests -q
+      - name: LangGraph AG-UI provider-boundary regressions
+        run: |
+          set -euo pipefail
+          python -m venv .venv-langgraph-agui
+          . .venv-langgraph-agui/bin/activate
+          python -m pip install --requirement agent-langgraph-agui/requirements.txt --requirement agent-langgraph-agui/requirements-test.txt
+          python -m pytest agent-langgraph-agui/tests -q
+      - run: bun install --frozen-lockfile
+      - run: bun test tests/compose.test.ts
+      - run: docker compose --env-file /dev/null --profile harness config --format json >/dev/null
+        env:
+          PICKED_HARNESS_IMAGE: openbot-agent-langgraph-agui:test
+
   build:
     name: build
     runs-on: ubuntu-latest
@@ -414,7 +455,7 @@ jobs:
     name: verify
     runs-on: ubuntu-latest
     if: always()
-    needs: [static, deployables, chart, test, build, migrations, image, component-dockerfiles]
+    needs: [static, deployables, chart, test, python-harness, build, migrations, image, component-dockerfiles]
     steps:
       - name: Require every check
         env:

.github/workflows/desktop.yml

@@ -2,7 +2,7 @@ name: Desktop
 
 # The shell is the one thing here that cannot be proved by running it on Linux: it is a macOS app, a
 # Windows app and a Linux app built from one tree, and the ways they differ are exactly the ways
-# this fails. So it builds on all three, on every change to it.
+# this fails. So it tests and builds on all three, on every change to it.
 on:
   pull_request:
     paths: ["desktop/**", ".github/workflows/desktop.yml"]
@@ -19,9 +19,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
 jobs:
-  # Fast, and the only job that runs the assertions about what the shell writes into `.env` and
-  # which socket it names. Those are the parts that carry what the platforms taught us, and they are
-  # plain Rust: no window, no engine, no waiting.
+  # Fast formatting and lint checks. Rust regression tests run once per platform below.
   core:
     name: core
     runs-on: ubuntu-latest
@@ -44,8 +42,6 @@ jobs:
         working-directory: desktop/src-tauri
       - run: cargo clippy --all-targets -- -D warnings
         working-directory: desktop/src-tauri
-      - run: cargo test --lib
-        working-directory: desktop/src-tauri
 
   # The three artifacts. Not `bundle`, which signs and notarizes: that is S7 and needs certificates
   # this workflow deliberately does not hold. This proves the tree builds into an app on each
@@ -95,6 +91,11 @@ jobs:
       # which a compile would miss.
       - run: bun run tauri build
         working-directory: desktop
+      # Frontend assets and platform dependencies are ready after the packaged build.
+      # Include main.rs regressions as well as lib.rs; ignored live tests remain opt-in.
+      - name: Rust regression tests
+        run: cargo test --locked --lib --bins
+        working-directory: desktop/src-tauri
       # Keep what was built. Without this the only way to try an installer is to build one on
       # the machine you are trying it on, which is not what anybody installs.
       - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1

agent-adk/Dockerfile

@@ -0,0 +1,19 @@
+# Google ADK, as a Bot. Python rather than Bun because that is what the integration is published in,
+# and the protocol is the only thing a Bot has to share with the others.
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Dependencies before source, so editing the Bot does not re-resolve the framework.
+COPY agent-adk/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY agent-adk/src ./src
+
+ENV PORT=4208
+EXPOSE 4208
+# 0.0.0.0, not `::`. uvicorn binds `::` as IPv6-only, with no v4-mapped addresses, so a container
+# started that way refuses 127.0.0.1: the Compose healthcheck never passes and the server cannot
+# reach the Bot. Measured, not assumed. Inside a container this is the container's own namespace,
+# and Compose is what decides which host addresses it is published on.
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "4208"]

agent-adk/requirements.txt

@@ -0,0 +1,6 @@
+ag-ui-adk
+google-adk
+litellm
+fastapi
+python-multipart
+uvicorn[standard]

agent-adk/src/main.py

@@ -0,0 +1,54 @@
+"""Google ADK as a Bot, through `ag_ui_adk`, which AG-UI maintains.
+
+ADK is Gemini-first and model-agnostic after that, so the provider stays the person's choice: ADK
+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 fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from google.adk.agents import Agent
+from google.adk.models.lite_llm import LiteLlm
+
+TOKEN_HEADER = "x-openbot-agent-token"
+
+
+def _model_id() -> str:
+    provider = (os.environ.get("BOT_PROVIDER") or "openai").strip()
+    model = (os.environ.get("BOT_MODEL") or "gpt-4o-mini").strip()
+    return model if "/" in model else f"{provider}/{model}"
+
+
+app = FastAPI()
+
+
+@app.middleware("http")
+async def refuse_without_the_server_token(request: Request, call_next):
+    if request.url.path != "/health":
+        expected = (os.environ.get("MANAGED_AGENT_TOKEN") or "").strip()
+        offered = (request.headers.get(TOKEN_HEADER) or "").strip()
+        if not expected or offered != expected:
+            return JSONResponse({"error": "unauthorised"}, status_code=401)
+    return await call_next(request)
+
+
+@app.get("/health")
+async def health():
+    return {"ok": True, "harness": "google-adk"}
+
+
+add_adk_fastapi_endpoint(
+    app,
+    ADKAgent(
+        adk_agent=Agent(
+            name="openbot",
+            model=LiteLlm(model=_model_id()),
+            instruction="Answer the question you are asked, briefly and correctly.",
+        ),
+        app_name="openbot",
+        user_id="openbot",
+    ),
+    path="/",
+)

agent-ag2/Dockerfile

@@ -0,0 +1,19 @@
+# AG2, as a Bot. Python rather than Bun because that is what the integration is published in,
+# and the protocol is the only thing a Bot has to share with the others.
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Dependencies before source, so editing the Bot does not re-resolve the framework.
+COPY agent-ag2/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY agent-ag2/src ./src
+
+ENV PORT=4210
+EXPOSE 4210
+# 0.0.0.0, not `::`. uvicorn binds `::` as IPv6-only, with no v4-mapped addresses, so a container
+# started that way refuses 127.0.0.1: the Compose healthcheck never passes and the server cannot
+# reach the Bot. Measured, not assumed. Inside a container this is the container's own namespace,
+# and Compose is what decides which host addresses it is published on.
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "4210"]

agent-ag2/requirements.txt

@@ -0,0 +1,4 @@
+ag2[ag-ui,openai]
+fastapi
+python-multipart
+uvicorn[standard]

agent-ag2/src/main.py

@@ -0,0 +1,39 @@
+"""AG2 as a Bot. AG-UI is an extra in AG2's own package, so `ag2[ag-ui]` is the dependency."""
+
+import os
+
+from ag2 import Agent
+from ag2.ag_ui import AGUIStream
+from ag2.config import OpenAIConfig
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+TOKEN_HEADER = "x-openbot-agent-token"
+
+agent = Agent(
+    name="openbot",
+    prompt="Answer the question you are asked, briefly and correctly.",
+    config=OpenAIConfig(model=(os.environ.get("BOT_MODEL") or "gpt-4o-mini").strip()),
+)
+stream = AGUIStream(agent)
+
+app = FastAPI()
+
+
+@app.middleware("http")
+async def refuse_without_the_server_token(request: Request, call_next):
+    if request.url.path != "/health":
+        expected = (os.environ.get("MANAGED_AGENT_TOKEN") or "").strip()
+        offered = (request.headers.get(TOKEN_HEADER) or "").strip()
+        if not expected or offered != expected:
+            return JSONResponse({"error": "unauthorised"}, status_code=401)
+    return await call_next(request)
+
+
+@app.get("/health")
+async def health():
+    return {"ok": True, "harness": "ag2"}
+
+
+# `build_asgi` rather than a helper: AG2 hands back a plain ASGI app to mount.
+app.mount("/", stream.build_asgi())

agent-agno/Dockerfile

@@ -0,0 +1,19 @@
+# Agno, as a Bot. Python rather than Bun because that is what the integration is published in,
+# and the protocol is the only thing a Bot has to share with the others.
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Dependencies before source, so editing the Bot does not re-resolve the framework.
+COPY agent-agno/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY agent-agno/src ./src
+
+ENV PORT=4203
+EXPOSE 4203
+# 0.0.0.0, not `::`. uvicorn binds `::` as IPv6-only, with no v4-mapped addresses, so a container
+# started that way refuses 127.0.0.1: the Compose healthcheck never passes and the server cannot
+# reach the Bot. Measured, not assumed. Inside a container this is the container's own namespace,
+# and Compose is what decides which host addresses it is published on.
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "4203"]

agent-agno/requirements.txt

@@ -0,0 +1,5 @@
+agno[agui]
+litellm
+fastapi
+python-multipart
+uvicorn[standard]

agent-agno/src/main.py

@@ -0,0 +1,59 @@
+"""Agno as a Bot.
+
+The AG-UI support is an extra in Agno's own package rather than a separate bridge, so `agno[agui]`
+is the whole dependency and `AGUIApp` is the whole integration. Nothing of the protocol is written
+here, which is the rule.
+"""
+
+import os
+
+from agno.agent import Agent
+from agno.db.in_memory import InMemoryDb
+from agno.models.litellm import LiteLLM
+from agno.os import AgentOS
+from agno.os.interfaces.agui import AGUI
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+TOKEN_HEADER = "x-openbot-agent-token"
+
+
+def _model_id() -> str:
+    """`provider/model`, which is how litellm addresses one and how OpenBot stores the choice."""
+    provider = (os.environ.get("BOT_PROVIDER") or "openai").strip()
+    model = (os.environ.get("BOT_MODEL") or "gpt-5.5").strip()
+    return model if "/" in model else f"{provider}/{model}"
+
+
+agent = Agent(
+    # In memory, because a Bot's history lives in OpenBot's database and not in the harness. Two
+    # places remembering the same conversation is how they come to disagree.
+    db=InMemoryDb(),
+    model=LiteLLM(id=_model_id()),
+    # No role, goal or backstory invented on somebody's behalf. A Bot answers the question it is
+    # asked, and anybody who wants a persona sets one in OpenBot where the rest of them live.
+    instructions="Answer the question you are asked, briefly and correctly.",
+)
+
+app = AgentOS(agents=[agent], interfaces=[AGUI(agent=agent)]).get_app()
+
+
+@app.middleware("http")
+async def refuse_without_the_server_token(request: Request, call_next):
+    """Everything but `/health` carries the server's token.
+
+    `/health` is exempt because Compose polls it before any token exists, and a healthcheck that
+    authenticates is a container that never reports healthy.
+    """
+    if request.url.path != "/health":
+        expected = (os.environ.get("MANAGED_AGENT_TOKEN") or "").strip()
+        offered = (request.headers.get(TOKEN_HEADER) or "").strip()
+        # Unset means unconfigured, not open.
+        if not expected or offered != expected:
+            return JSONResponse({"error": "unauthorised"}, status_code=401)
+    return await call_next(request)
+
+
+@app.get("/health")
+async def health():
+    return {"ok": True, "harness": "agno"}