@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/fixtures/catalog-table-definition.json.txt

@@ -0,0 +1,468 @@
+{
+  "models": {
+    "order": {
+      "columns": {
+        "title": {
+          "kind": "string",
+          "required": true
+        },
+        "status": {
+          "kind": "enum",
+          "enum": [
+            "pending",
+            "in_progress",
+            "completed",
+            "failed"
+          ],
+          "default": "pending"
+        },
+        "owner": {
+          "kind": "string"
+        },
+        "amount": {
+          "kind": "number"
+        },
+        "placedAt": {
+          "kind": "date"
+        }
+      }
+    }
+  },
+  "queries": {
+    "allOrders": {
+      "model": "order",
+      "sort": {
+        "column": "createdAt",
+        "dir": "asc"
+      }
+    },
+    "orderDetail": {
+      "model": "order",
+      "filter": {
+        "id": {
+          "$param": "panel"
+        }
+      },
+      "limit": 1
+    }
+  },
+  "actions": {
+    "triage": {
+      "kind": "task",
+      "prompt": "Review the current orders and flag anything stuck"
+    }
+  },
+  "pages": {
+    "main": {
+      "title": "Orders",
+      "params": {
+        "panel": {
+          "kind": "string"
+        }
+      },
+      "root": "root",
+      "elements": {
+        "root": {
+          "type": "Container",
+          "props": {},
+          "children": [
+            "heading",
+            "alert",
+            "metrics",
+            "filters",
+            "tableCard",
+            "toolbar",
+            "formCard",
+            "drawer"
+          ]
+        },
+        "heading": {
+          "type": "Heading",
+          "props": {
+            "text": "Catalog demo",
+            "level": "h1"
+          }
+        },
+        "alert": {
+          "type": "Alert",
+          "props": {
+            "tone": "warning",
+            "title": "Two orders failed",
+            "message": "Review the failed orders before the end-of-day settlement run.",
+            "icon": "rocket"
+          }
+        },
+        "metrics": {
+          "type": "Grid",
+          "props": {
+            "columns": 3,
+            "gap": "md"
+          },
+          "children": [
+            "mOpen",
+            "mRevenue",
+            "mFailed"
+          ]
+        },
+        "mOpen": {
+          "type": "Metric",
+          "props": {
+            "label": "Open orders",
+            "value": 5,
+            "loading": {
+              "$state": "/queries/allOrders/loading"
+            },
+            "icon": "activity"
+          }
+        },
+        "mRevenue": {
+          "type": "Metric",
+          "props": {
+            "label": "Revenue (EUR)",
+            "value": "4,982.50",
+            "loading": {
+              "$state": "/queries/allOrders/loading"
+            },
+            "icon": "dollar-sign"
+          }
+        },
+        "mFailed": {
+          "type": "Metric",
+          "props": {
+            "label": "Failed",
+            "value": 2,
+            "loading": {
+              "$state": "/queries/allOrders/loading"
+            },
+            "icon": "alert-triangle"
+          }
+        },
+        "filters": {
+          "type": "Stack",
+          "props": {
+            "direction": "row",
+            "gap": "sm",
+            "align": "end",
+            "collapseBelow": "sm"
+          },
+          "children": [
+            "search",
+            "statusFilter"
+          ]
+        },
+        "search": {
+          "type": "SearchInput",
+          "props": {
+            "id": "search",
+            "label": "Search",
+            "placeholder": "Search orders"
+          }
+        },
+        "statusFilter": {
+          "type": "Select",
+          "props": {
+            "id": "statusFilter",
+            "label": "Status",
+            "placeholder": "All statuses",
+            "options": [
+              {
+                "value": "pending",
+                "label": "Pending"
+              },
+              {
+                "value": "in_progress",
+                "label": "In progress"
+              },
+              {
+                "value": "completed",
+                "label": "Completed"
+              },
+              {
+                "value": "failed",
+                "label": "Failed"
+              }
+            ]
+          }
+        },
+        "tableCard": {
+          "type": "Card",
+          "props": {
+            "title": "Orders"
+          },
+          "children": [
+            "table"
+          ]
+        },
+        "table": {
+          "type": "Table",
+          "props": {
+            "data": {
+              "$state": "/queries/allOrders/data"
+            },
+            "loading": {
+              "$state": "/queries/allOrders/loading"
+            },
+            "error": {
+              "$state": "/queries/allOrders/error"
+            },
+            "search": {
+              "$state": "/ui/search/value"
+            },
+            "filters": {
+              "status": {
+                "$state": "/ui/statusFilter/value"
+              }
+            },
+            "emptyMessage": "No orders match",
+            "columns": [
+              {
+                "key": "title",
+                "label": "Order",
+                "icon": "file-text"
+              },
+              {
+                "key": "status",
+                "label": "Status",
+                "kind": "status"
+              },
+              {
+                "key": "owner",
+                "label": "Owner",
+                "kind": "user"
+              },
+              {
+                "key": "amount",
+                "label": "Amount",
+                "kind": "number",
+                "icon": "dollar-sign"
+              },
+              {
+                "key": "placedAt",
+                "label": "Placed",
+                "kind": "relative"
+              },
+              {
+                "key": "id",
+                "label": "ID",
+                "kind": "copy",
+                "truncate": "middle",
+                "width": 150
+              }
+            ],
+            "rowActions": [
+              {
+                "label": "Delete",
+                "icon": "trash-2",
+                "variant": "destructive-outline",
+                "placement": "menu",
+                "confirm": {
+                  "title": "Delete order?",
+                  "description": "This removes the row.",
+                  "confirmLabel": "Delete"
+                },
+                "actions": [
+                  {
+                    "action": "app.mutate",
+                    "params": {
+                      "model": "order",
+                      "op": "delete",
+                      "rowId": {
+                        "$row": "id"
+                      }
+                    }
+                  }
+                ]
+              }
+            ],
+            "onRowClick": [
+              {
+                "action": "app.navigate",
+                "params": {
+                  "page": "main",
+                  "params": {
+                    "panel": {
+                      "$row": "id"
+                    }
+                  }
+                }
+              }
+            ],
+            "selectedId": {
+              "$state": "/route/params/panel"
+            },
+            "emptyState": {
+              "icon": "search",
+              "title": "No orders match",
+              "body": "Try another status or clear the search."
+            },
+            "mobileFields": {
+              "title": "title",
+              "status": "status",
+              "meta": [
+                "owner",
+                "placedAt"
+              ]
+            }
+          }
+        },
+        "toolbar": {
+          "type": "Stack",
+          "props": {
+            "direction": "row",
+            "gap": "sm",
+            "align": "center"
+          },
+          "children": [
+            "badge",
+            "triageBtn"
+          ]
+        },
+        "badge": {
+          "type": "Badge",
+          "props": {
+            "text": "Live",
+            "tone": "active",
+            "icon": "zap"
+          }
+        },
+        "triageBtn": {
+          "type": "Button",
+          "props": {
+            "label": "Ask swarm to triage",
+            "variant": "secondary",
+            "busyWith": "triage",
+            "icon": "sparkles"
+          },
+          "on": {
+            "press": [
+              {
+                "action": "app.action",
+                "params": {
+                  "name": "triage"
+                }
+              }
+            ]
+          }
+        },
+        "formCard": {
+          "type": "Card",
+          "props": {
+            "title": "New order"
+          },
+          "children": [
+            "form"
+          ]
+        },
+        "form": {
+          "type": "Form",
+          "props": {
+            "id": "newOrder",
+            "fields": [
+              {
+                "name": "title",
+                "label": "Title",
+                "required": true,
+                "placeholder": "Order title"
+              },
+              {
+                "name": "owner",
+                "label": "Owner",
+                "placeholder": "Who owns it"
+              },
+              {
+                "name": "amount",
+                "label": "Amount",
+                "kind": "number"
+              },
+              {
+                "name": "status",
+                "label": "Status",
+                "kind": "enum",
+                "options": [
+                  "pending",
+                  "in_progress",
+                  "completed",
+                  "failed"
+                ]
+              }
+            ],
+            "submitLabel": "Create order",
+            "onSubmit": [
+              {
+                "action": "app.mutate",
+                "params": {
+                  "model": "order",
+                  "op": "create",
+                  "values": {
+                    "$form": ""
+                  }
+                }
+              }
+            ]
+          }
+        },
+        "drawer": {
+          "type": "Drawer",
+          "props": {
+            "param": "panel",
+            "title": "Order detail",
+            "description": "Read-only view of one order",
+            "size": "md"
+          },
+          "children": [
+            "detail"
+          ]
+        },
+        "detail": {
+          "type": "DetailList",
+          "props": {
+            "data": {
+              "$state": "/queries/orderDetail/data/0"
+            },
+            "loading": {
+              "$state": "/queries/orderDetail/loading"
+            },
+            "emptyMessage": "Order not found",
+            "fields": [
+              {
+                "key": "title",
+                "label": "Order"
+              },
+              {
+                "key": "status",
+                "label": "Status",
+                "kind": "badge",
+                "tones": {
+                  "pending": "pending",
+                  "in_progress": "active",
+                  "completed": "success",
+                  "failed": "error"
+                }
+              },
+              {
+                "key": "owner",
+                "label": "Owner"
+              },
+              {
+                "key": "amount",
+                "label": "Amount",
+                "kind": "number"
+              },
+              {
+                "key": "placedAt",
+                "label": "Placed",
+                "kind": "date"
+              },
+              {
+                "key": "id",
+                "label": "Row id",
+                "kind": "code"
+              }
+            ]
+          }
+        }
+      }
+    }
+  },
+  "defaultPage": "main"
+}

package/src/tests/fixtures/chat-sdk/telegram-private-text.json

@@ -0,0 +1,10 @@
+{
+  "update_id": 900001,
+  "message": {
+    "message_id": 11,
+    "date": 1760400000,
+    "chat": { "id": 555001, "type": "private", "first_name": "Taras", "username": "taras_test" },
+    "from": { "id": 555001, "is_bot": false, "first_name": "Taras", "username": "taras_test" },
+    "text": "hello swarm, please summarize the open tasks"
+  }
+}

package/src/tests/fixtures/extensions/route-chat-channel-to-agent/hooks.ts

@@ -0,0 +1,27 @@
+import { modify, type SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+export const config = z.object({ adapter: z.string(), channelId: z.string(), agentId: z.string() });
+
+const manifest = {
+  name: "route-chat-channel-to-agent",
+  description: "Routes one Chat SDK channel to a configured agent",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.chat.route", (event, ctx) => {
+    if (event.adapter !== ctx.config.adapter || event.channelId !== ctx.config.channelId) return;
+    return modify({ target: { kind: "agent", agentId: ctx.config.agentId } });
+  });
+
+  api.on("post.chat.message", async (event, ctx) => {
+    if (event.direction !== "inbound" || !event.userId) return;
+    await ctx.state.set(`chat:${event.channelId}`, event.userId);
+  });
+};
+
+export default extension;

package/src/tests/fixtures/extensions/route-chat-channel-to-agent/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "route-chat-channel-to-agent",
+  "description": "Routes one Chat SDK channel to a configured agent",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/openai-compatible-registry-extension.child.ts

@@ -0,0 +1,146 @@
+/**
+ * Proof that adding an OpenAI-compatible provider takes one registry entry.
+ *
+ * A fake `testgw` entry is added to the registry table
+ * (`packages/model-catalog/src/openai-compatible-providers.ts`) through
+ * `mock.module`, without editing any production file, and must reach
+ * credential routing, the opencode config, the pi models.json writer, the
+ * dashboard integration cards and the model picker groups.
+ *
+ * The mock is installed before any consumer below is imported (dynamic
+ * imports). Consumers cache derivations of the table at import (the
+ * integration cards, the picker constants), and `mock.module` cannot undo
+ * those, so this file only runs in its own `bun test` child process,
+ * spawned by `src/tests/openai-compatible-registry-extension.test.ts`. Its
+ * name keeps it out of the root test glob.
+ */
+import { afterAll, describe, expect, mock, test } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const REGISTRY_MODULE = "../../../packages/model-catalog/src/openai-compatible-providers.ts";
+
+const TESTGW = {
+  id: "testgw",
+  displayName: "TestGW",
+  description: "A fake gateway for the registry extension test.",
+  baseUrl: "https://testgw.invalid/v1",
+  docsUrl: "https://testgw.invalid/docs",
+  envVar: "TESTGW_API_KEY",
+  aliasEnvVars: [],
+  catalog: "registry",
+  npm: "@ai-sdk/openai-compatible",
+  models: [
+    {
+      id: "m1",
+      name: "Test Model 1",
+      contextWindow: 131072,
+      maxOutputTokens: 8192,
+      input: ["text"],
+      reasoning: true,
+      compat: { supportsDeveloperRole: true },
+      reasoningEfforts: ["low", "high"],
+    },
+  ],
+} as const;
+
+const real = (await import(REGISTRY_MODULE)) as {
+  OPENAI_COMPATIBLE_PROVIDERS: Record<string, unknown>;
+};
+const original = real.OPENAI_COMPATIBLE_PROVIDERS;
+mock.module(REGISTRY_MODULE, () => ({
+  OPENAI_COMPATIBLE_PROVIDERS: { ...original, testgw: TESTGW },
+}));
+
+// The test preload already loaded `src/utils/credentials.ts`, so only its
+// call-time paths (routing, pooling) see the mock; `CREDENTIAL_POOL_VARS` is
+// fixed at import and covered by the registry spread in its declaration.
+const { getModelAwareCredentialVars, resolveCredentialPools } = await import(
+  "../../utils/credentials"
+);
+const { applyProviderKeySplice } = await import("../../providers/opencode-adapter");
+type OpencodeConfig = import("../../providers/opencode-adapter").OpencodeConfig;
+const { writeSessionModelsJson } = await import("../../providers/pi-mono-adapter");
+const { INTEGRATIONS } = await import("../../../apps/ui/src/lib/integrations-catalog");
+const { modelGroupsForHarness } = await import("../../../apps/ui/src/lib/agent-runtime-models");
+
+const tmpDirs: string[] = [];
+afterAll(async () => {
+  for (const dir of tmpDirs) await rm(dir, { recursive: true, force: true });
+});
+
+describe("a new registry entry (testgw) reaches every derived surface", () => {
+  test("credential routing picks its key on pi and opencode", () => {
+    expect(getModelAwareCredentialVars("pi", "testgw/x")).toEqual(["TESTGW_API_KEY"]);
+    expect(getModelAwareCredentialVars("opencode", "testgw/x")).toEqual(["TESTGW_API_KEY"]);
+  });
+
+  test("its key pools alone for a testgw/* model", async () => {
+    const env: Record<string, string | undefined> = {
+      TESTGW_API_KEY: "example-gw-a,example-gw-b",
+      OPENROUTER_API_KEY: "example-or-a,example-or-b",
+    };
+    const selections = await resolveCredentialPools(env, { provider: "pi", model: "testgw/m1" });
+    expect(["example-gw-a", "example-gw-b"]).toContain(env.TESTGW_API_KEY ?? "");
+    expect(selections.map((s) => [s.keyType, s.total])).toEqual([["TESTGW_API_KEY", 2]]);
+    expect(env.OPENROUTER_API_KEY).toBe("example-or-a,example-or-b");
+  });
+
+  test("opencode gets a custom block with the picked key at the base URL", () => {
+    const config: OpencodeConfig = {};
+    const picked = applyProviderKeySplice(config, "testgw/m1", { TESTGW_API_KEY: "k1,k2" });
+    expect(picked).toEqual({ key: "k1", name: "TESTGW_API_KEY" });
+    const block = config.provider?.testgw;
+    expect(block?.npm).toBe("@ai-sdk/openai-compatible");
+    expect(block?.env).toEqual([]);
+    expect(block?.options).toEqual({ baseURL: "https://testgw.invalid/v1", apiKey: "k1" });
+    expect(block?.models?.m1).toMatchObject({ name: "Test Model 1", tool_call: true });
+
+    const overridden: OpencodeConfig = {};
+    applyProviderKeySplice(overridden, "testgw/m1", {
+      TESTGW_API_KEY: "k1",
+      TESTGW_BASE_URL: "http://127.0.0.1:9/v1",
+    });
+    expect(overridden.provider?.testgw?.options?.baseURL).toBe("http://127.0.0.1:9/v1");
+  });
+
+  test("the pi models.json writer adds its provider block", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "testgw-pi-"));
+    tmpDirs.push(dir);
+    const models = await writeSessionModelsJson(dir, { TESTGW_API_KEY: "k1" }, "testgw/m1");
+    const written = JSON.parse(await readFile(models.modelsPath as string, "utf-8"));
+    await models.dispose();
+    expect(written.providers.testgw).toMatchObject({
+      baseUrl: "https://testgw.invalid/v1",
+      api: "openai-completions",
+      apiKey: "$TESTGW_API_KEY",
+    });
+    expect(written.providers.testgw.models.map((m: { id: string }) => m.id)).toEqual(["m1"]);
+  });
+
+  test("the dashboard lists an integration card with its key and base URL", () => {
+    const card = INTEGRATIONS.find((def) => def.id === "testgw");
+    expect(card?.name).toBe("TestGW");
+    expect(card?.providerIconKey as string | undefined).toBe("testgw");
+    expect(card?.fields.map((f) => [f.key, f.isSecret])).toEqual([
+      ["TESTGW_API_KEY", true],
+      ["TESTGW_BASE_URL", false],
+    ]);
+  });
+
+  test("the picker shows its models, locked without a key and enabled with one", () => {
+    for (const harness of ["pi", "opencode"] as const) {
+      const locked = modelGroupsForHarness(harness, [], {}).find((g) => g.provider === "TestGW");
+      expect(locked?.enabled).toBe(false);
+      expect(locked?.requiredKey).toBe("TESTGW_API_KEY");
+      expect(locked?.models.map((m) => m.id)).toEqual(["testgw/m1"]);
+      expect(locked?.models[0]?.reasoningLevels).toEqual(["low", "high"]);
+
+      const enabled = modelGroupsForHarness(harness, [], { TESTGW_API_KEY: true }).find(
+        (g) => g.provider === "TestGW",
+      );
+      expect(enabled?.enabled).toBe(true);
+    }
+  });
+});

package/src/tests/fixtures/runner-identity-refresh.ts

@@ -16,6 +16,7 @@ let claims = 0;
 let firstCompleted = false;
 let editDuringRefresh = false;
 let baselineAtFirstSpawn = "";
+let workspaceClaudeMdAtFirstSpawn = "";
 const bootProfile = {
   name: "Fixture agent",
   description: "Runner integration fixture",
@@ -84,6 +85,7 @@ mock.module("../../providers/index", () => ({
         captures.push(config.systemPrompt);
         if (captures.length === 1) {
           baselineAtFirstSpawn = readFileSync(baselinesPath, "utf8");
+          workspaceClaudeMdAtFirstSpawn = readFileSync(join(directory, "CLAUDE.md"), "utf8");
         } else {
           writeFileSync(
             join(directory, "result.json"),
@@ -95,6 +97,7 @@ mock.module("../../providers/index", () => ({
               editDuringRefresh,
               tools: readFileSync(toolsPath, "utf8"),
               baselineAtFirstSpawn,
+              workspaceClaudeMdAtFirstSpawn,
               baselineAtSecondSpawn: readFileSync(baselinesPath, "utf8"),
             }),
           );