@desplega.ai/agent-swarm 1.74.4 → 1.76.0

package/src/providers/pi-mono-adapter.ts

@@ -28,6 +28,8 @@ import { createSwarmHooksExtension } from "./pi-mono-extension";
 import { McpHttpClient } from "./pi-mono-mcp-client";
 import type {
   CostData,
+  CredCheckOptions,
+  CredStatus,
   ProviderAdapter,
   ProviderEvent,
   ProviderResult,
@@ -35,6 +37,75 @@ import type {
   ProviderSessionConfig,
 } from "./types";
 
+/**
+ * Map a `MODEL_OVERRIDE` string to the env var that satisfies it. Mirrors
+ * `resolveModel` above (shortname → anthropic, `provider/model-id` → that
+ * provider). Returns `null` when the override is empty (boot-loop should
+ * treat it as the permissive case) or the provider can't be inferred.
+ */
+function modelToCredKey(modelStr: string | undefined): string | null {
+  if (!modelStr) return null;
+  const lower = modelStr.toLowerCase();
+  // Hard-coded shortnames map straight to anthropic.
+  if (lower === "opus" || lower === "sonnet" || lower === "haiku") {
+    return "ANTHROPIC_API_KEY";
+  }
+  if (modelStr.includes("/")) {
+    const provider = modelStr.slice(0, modelStr.indexOf("/")).toLowerCase();
+    if (provider === "anthropic") return "ANTHROPIC_API_KEY";
+    if (provider === "openrouter") return "OPENROUTER_API_KEY";
+    if (provider === "openai") return "OPENAI_API_KEY";
+    if (provider === "google") return "GOOGLE_API_KEY";
+  }
+  // Bare model name with no provider prefix — adapter falls through to a
+  // best-effort resolution against multiple providers, so the boot loop
+  // accepts any one of them.
+  return null;
+}
+
+/**
+ * Pi-mono is satisfied by ANY of:
+ *   1. `~/.pi/agent/auth.json` exists.
+ *   2. `MODEL_OVERRIDE` is set to a provider-prefixed model — only the
+ *      matching provider's key is required.
+ *   3. `MODEL_OVERRIDE` is empty / unprefixed — any one of the supported
+ *      keys (ANTHROPIC_API_KEY / OPENROUTER_API_KEY / OPENAI_API_KEY) is
+ *      enough.
+ */
+export function checkPiMonoCredentials(
+  env: Record<string, string | undefined>,
+  opts: CredCheckOptions = {},
+): CredStatus {
+  const homeDir = opts.homeDir ?? env.HOME ?? "/root";
+  const probe = opts.fs?.existsSync ?? existsSync;
+  const authFile = `${homeDir}/.pi/agent/auth.json`;
+  if (probe(authFile)) {
+    return { ready: true, missing: [], satisfiedBy: "file" };
+  }
+
+  const requiredKey = modelToCredKey(env.MODEL_OVERRIDE);
+  if (requiredKey) {
+    if (env[requiredKey]) {
+      return { ready: true, missing: [], satisfiedBy: "env" };
+    }
+    return {
+      ready: false,
+      missing: [requiredKey, authFile],
+      hint: `MODEL_OVERRIDE=${env.MODEL_OVERRIDE} requires ${requiredKey}; or run \`pi auth login\` to create ${authFile}.`,
+    };
+  }
+
+  // Permissive case: any one supported key works.
+  if (env.ANTHROPIC_API_KEY || env.OPENROUTER_API_KEY || env.OPENAI_API_KEY) {
+    return { ready: true, missing: [], satisfiedBy: "env" };
+  }
+  return {
+    ready: false,
+    missing: ["ANTHROPIC_API_KEY", "OPENROUTER_API_KEY", "OPENAI_API_KEY", authFile],
+    hint: "Set one of ANTHROPIC_API_KEY / OPENROUTER_API_KEY / OPENAI_API_KEY (any one suffices), or run `pi auth login` to create ~/.pi/agent/auth.json.",
+  };
+}
+
 /** Convert a JSON Schema object to a TypeBox TSchema using Type.Unsafe */
 function jsonSchemaToTypeBox(schema: Record<string, unknown>): TSchema {
   // Type.Unsafe wraps a plain JSON Schema as a TypeBox-compatible TSchema

package/src/providers/types.ts

@@ -111,3 +111,37 @@ export interface ProviderAdapter {
   canResume(sessionId: string): Promise<boolean>;
   formatCommand(commandName: string): string;
 }
+
+/**
+ * Status returned by per-adapter `checkCredentials(env, opts)` predicates.
+ *
+ * `ready=false` means the worker should park in the credential-wait loop
+ * (Phase 2). `missing` lists env-var names (or absolute file paths) the
+ * adapter would accept; the dashboard surfaces this list as the "blocked
+ * on …" hint.
+ *
+ * `satisfiedBy`:
+ * - `'env'` — env-var(s) directly satisfy the adapter
+ * - `'file'` — an existing on-disk auth.json was found
+ * - `'side-effect-pending'` — env-vars are present but a follow-up step
+ *   (e.g. `codex login --with-api-key`) still needs to run before the
+ *   adapter can use them. Workers should treat this as "ready" for the
+ *   purposes of the boot loop — the side-effect is the entrypoint's job.
+ */
+export interface CredStatus {
+  ready: boolean;
+  missing: string[];
+  satisfiedBy?: "env" | "file" | "side-effect-pending";
+  hint?: string;
+}
+
+/**
+ * Options threaded into `checkCredentials` for testability — the codex and
+ * pi/opencode predicates probe the filesystem for `~/.codex/auth.json`,
+ * `~/.pi/agent/auth.json`, `~/.local/share/opencode/auth.json`. Tests inject
+ * a fake `fs` + `homeDir` to exercise the file-vs-env branches deterministically.
+ */
+export interface CredCheckOptions {
+  homeDir?: string;
+  fs?: { existsSync(p: string): boolean };
+}

package/src/server.ts

@@ -29,6 +29,7 @@ import {
 // Memory capability
 import { registerMemoryDeleteTool } from "./tools/memory-delete";
 import { registerMemoryGetTool } from "./tools/memory-get";
+import { registerMemoryRateTool } from "./tools/memory-rate";
 import { registerMemorySearchTool } from "./tools/memory-search";
 import { registerMyAgentInfoTool } from "./tools/my-agent-info";
 import { registerPollTaskTool } from "./tools/poll-task";
@@ -241,6 +242,7 @@ export function createServer() {
     registerMemorySearchTool(server);
     registerMemoryGetTool(server);
     registerMemoryDeleteTool(server);
+    registerMemoryRateTool(server);
     registerInjectLearningTool(server);
   }
 

package/src/slack/handlers.ts

@@ -1,7 +1,6 @@
 import type { App } from "@slack/bolt";
 import type { WebClient } from "@slack/web-api";
 import {
-  createTaskExtended,
   getAgentById,
   getAgentWorkingOnThread,
   getLeadAgent,

package/src/tests/agents-harness-provider.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Phase 1.5 (cloud-personalization): per-agent harness_provider column +
+ * worker registration push + PATCH /api/agents/:id/harness-provider.
+ *
+ * Coverage:
+ *   - Migration applies cleanly (the test bootstrap runs `initDb` which
+ *     applies all migrations forward-only; existence of the column is
+ *     verified via PRAGMA below).
+ *   - Worker registration with `harness_provider` writes the column.
+ *   - Re-registration updates the column when the value changes.
+ *   - `PATCH /api/agents/:id/harness-provider` updates the column.
+ *   - Invalid provider names rejected with 400.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import {
+  closeDb,
+  createAgent,
+  getAgentById,
+  getAgentHarnessProviders,
+  getDb,
+  getSwarmConfigs,
+  initDb,
+  setAgentHarnessProvider,
+} from "../be/db";
+import { handleAgentRegister, handleAgentsRest } from "../http/agents";
+
+const TEST_DB_PATH = "./test-agents-harness-provider.sqlite";
+const TEST_PORT = 13059;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function makeTestServer(): Server {
+  return createHttpServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${TEST_PORT}`);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const queryParams = url.searchParams;
+    const myAgentId = (req.headers["x-agent-id"] as string | undefined) ?? undefined;
+
+    try {
+      if (await handleAgentRegister(req, res, pathSegments, myAgentId)) return;
+      if (await handleAgentsRest(req, res, pathSegments, queryParams, myAgentId)) return;
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: (err as Error).message }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+}
+
+let server: Server;
+const baseUrl = `http://localhost:${TEST_PORT}`;
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  server = makeTestServer();
+  await new Promise<void>((resolve) => {
+    server.listen(TEST_PORT, () => resolve());
+  });
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => {
+    server.close(() => resolve());
+  });
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(() => {
+  // Each test starts on an empty agents table.
+  getDb().prepare("DELETE FROM agents").run();
+  getDb().prepare("DELETE FROM swarm_config").run();
+});
+
+// ─── Migration: column exists ────────────────────────────────────────────────
+
+describe("migration 054_agent_harness_provider", () => {
+  test("`harness_provider` column exists on the `agents` table", () => {
+    const cols = getDb()
+      .prepare<{ name: string }, []>(`PRAGMA table_info(agents)`)
+      .all()
+      .map((r) => r.name);
+    expect(cols).toContain("harness_provider");
+  });
+
+  test("existing agent rows default to NULL `harness_provider`", () => {
+    const a = createAgent({
+      name: "legacy-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    expect(a.harnessProvider).toBeNull();
+  });
+});
+
+// ─── DB helpers ──────────────────────────────────────────────────────────────
+
+describe("DB helpers", () => {
+  test("setAgentHarnessProvider writes and returns the updated row", () => {
+    const a = createAgent({ name: "a1", isLead: false, status: "idle", capabilities: [] });
+    expect(a.harnessProvider).toBeNull();
+
+    const updated = setAgentHarnessProvider(a.id, "codex");
+    expect(updated?.harnessProvider).toBe("codex");
+
+    const fetched = getAgentById(a.id);
+    expect(fetched?.harnessProvider).toBe("codex");
+  });
+
+  test("setAgentHarnessProvider can clear the column with null", () => {
+    const a = createAgent({
+      name: "a-clear",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "claude",
+    });
+    expect(a.harnessProvider).toBe("claude");
+
+    const updated = setAgentHarnessProvider(a.id, null);
+    expect(updated?.harnessProvider).toBeNull();
+  });
+
+  test("setAgentHarnessProvider returns null when agent not found", () => {
+    const result = setAgentHarnessProvider("nonexistent-id", "claude");
+    expect(result).toBeNull();
+  });
+
+  test("getAgentHarnessProviders aggregates by provider, excluding NULL", () => {
+    createAgent({
+      name: "x1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "claude",
+    });
+    createAgent({
+      name: "x2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "claude",
+    });
+    createAgent({
+      name: "x3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "codex",
+    });
+    createAgent({ name: "x4", isLead: false, status: "idle", capabilities: [] }); // NULL — excluded
+
+    const counts = getAgentHarnessProviders();
+    expect(counts).toEqual([
+      { provider: "claude", count: 2 },
+      { provider: "codex", count: 1 },
+    ]);
+  });
+});
+
+// ─── Worker registration: HTTP path ──────────────────────────────────────────
+
+describe("POST /api/agents — worker registration pushes harness_provider", () => {
+  test("first-time register persists harness_provider", async () => {
+    const agentId = "agent-register-1";
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({
+        name: "worker-fresh",
+        isLead: false,
+        harness_provider: "claude",
+      }),
+    });
+    expect(res.status).toBe(201);
+
+    const row = getAgentById(agentId);
+    expect(row?.harnessProvider).toBe("claude");
+  });
+
+  test("re-register with a different harness_provider updates the column", async () => {
+    const agentId = "agent-register-2";
+    // First register with claude.
+    await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-rotating", isLead: false, harness_provider: "claude" }),
+    });
+
+    // Re-register with codex.
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-rotating", isLead: false, harness_provider: "codex" }),
+    });
+    expect(res.status).toBe(200);
+
+    const row = getAgentById(agentId);
+    expect(row?.harnessProvider).toBe("codex");
+  });
+
+  test("registration WITHOUT harness_provider leaves an existing column value untouched", async () => {
+    const agentId = "agent-register-3";
+    // First register with claude.
+    await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-quiet", isLead: false, harness_provider: "claude" }),
+    });
+
+    // Re-register without harness_provider (older worker).
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-quiet", isLead: false }),
+    });
+    expect(res.status).toBe(200);
+
+    // Existing value preserved (so PATCH overrides aren't clobbered by
+    // older workers re-registering without the field).
+    const row = getAgentById(agentId);
+    expect(row?.harnessProvider).toBe("claude");
+  });
+
+  test("rejects an unknown provider name with 400", async () => {
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": "agent-bad" },
+      body: JSON.stringify({
+        name: "worker-bad-provider",
+        isLead: false,
+        harness_provider: "rogue-llm",
+      }),
+    });
+    expect(res.status).toBe(400);
+  });
+});
+
+// ─── PATCH /api/agents/:id/harness-provider ─────────────────────────────────
+
+describe("PATCH /api/agents/:id/harness-provider", () => {
+  test("updates the column on a known agent", async () => {
+    const a = createAgent({
+      name: "patch-target-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "codex" }),
+    });
+    expect(res.status).toBe(200);
+
+    const row = getAgentById(a.id);
+    expect(row?.harnessProvider).toBe("codex");
+  });
+
+  test("rejects unknown provider names with 400", async () => {
+    const a = createAgent({
+      name: "patch-target-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "rogue" }),
+    });
+    expect(res.status).toBe(400);
+  });
+
+  test("returns 404 when agent does not exist", async () => {
+    const res = await fetch(`${baseUrl}/api/agents/nonexistent-agent-id/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "claude" }),
+    });
+    expect(res.status).toBe(404);
+  });
+
+  test("PATCH also upserts swarm_config (scope=agent) so the worker reconciles", async () => {
+    const a = createAgent({
+      name: "patch-target-3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "codex" }),
+    });
+    expect(res.status).toBe(200);
+
+    const rows = getSwarmConfigs({ scope: "agent", scopeId: a.id });
+    const harnessRow = rows.find((r) => r.key === "HARNESS_PROVIDER");
+    expect(harnessRow?.value).toBe("codex");
+
+    // Subsequent PATCH (different value) updates the row in place.
+    const res2 = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "claude" }),
+    });
+    expect(res2.status).toBe(200);
+
+    const rows2 = getSwarmConfigs({ scope: "agent", scopeId: a.id });
+    const harnessRow2 = rows2.find((r) => r.key === "HARNESS_PROVIDER");
+    expect(harnessRow2?.value).toBe("claude");
+    expect(rows2.filter((r) => r.key === "HARNESS_PROVIDER")).toHaveLength(1);
+  });
+});