@desplega.ai/agent-swarm 1.83.1 → 1.83.2

package/src/providers/opencode-adapter.ts

@@ -100,6 +100,74 @@ function isAssistantMessage(msg: unknown): msg is AssistantMessage {
 }
 
 const DOCKER_PLUGIN_PATH = "/home/worker/.config/opencode/plugins/agent-swarm.ts";
+const MODEL_CACHE_REFRESH_TIMEOUT_MS = 15_000;
+
+function isOpenRouterModel(model: string | undefined): boolean {
+  return Boolean(model?.toLowerCase().startsWith("openrouter/"));
+}
+
+function isModelNotFoundError(message: string): boolean {
+  return /model not found:/i.test(message);
+}
+
+async function readSpawnOutput(stream: ReadableStream<Uint8Array> | null): Promise<string> {
+  if (!stream) return "";
+  return await new Response(stream).text();
+}
+
+function formatUnknownError(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+async function refreshOpenRouterModelCache(
+  opencodeConfig: Config & { plugin?: string[] },
+  configFilePath: string,
+  dataHomePath: string,
+): Promise<void> {
+  const binary = process.env.OPENCODE_BINARY || "opencode";
+  const proc = Bun.spawn([binary, "models", "--refresh", "openrouter"], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      OPENCODE_CONFIG: configFilePath,
+      OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig),
+      OPENCODE_DATA_HOME: dataHomePath,
+    },
+  });
+
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    proc.kill();
+  }, MODEL_CACHE_REFRESH_TIMEOUT_MS);
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    readSpawnOutput(proc.stdout),
+    readSpawnOutput(proc.stderr),
+    proc.exited,
+  ]).finally(() => clearTimeout(timeout));
+
+  if (timedOut) {
+    throw new Error(
+      `opencode models --refresh openrouter timed out after ${MODEL_CACHE_REFRESH_TIMEOUT_MS}ms`,
+    );
+  }
+  if (exitCode !== 0) {
+    const detail = scrubSecrets([stderr.trim(), stdout.trim()].filter(Boolean).join("\n"));
+    throw new Error(
+      `opencode models --refresh openrouter exited with code ${exitCode}${detail ? `: ${detail}` : ""}`,
+    );
+  }
+}
+
+let refreshOpenRouterModelCacheImpl = refreshOpenRouterModelCache;
+
+export function _setOpenRouterModelCacheRefreshForTests(
+  fn: typeof refreshOpenRouterModelCache | null,
+): void {
+  refreshOpenRouterModelCacheImpl = fn ?? refreshOpenRouterModelCache;
+}
 
 function resolvePluginPath(): string {
   const override = process.env.OPENCODE_SWARM_PLUGIN_PATH;
@@ -141,6 +209,8 @@ export class OpencodeSession implements ProviderSession {
   private agentFilePath: string;
   private configFilePath: string;
   private dataHomePath: string;
+  private retryAfterModelRefresh?: () => Promise<boolean>;
+  private modelRefreshRecoveryInFlight = false;
 
   // Track which tool callIDs have already emitted tool_start, so transitions
   // through pending → running → completed don't fire duplicate events.
@@ -155,6 +225,7 @@ export class OpencodeSession implements ProviderSession {
     agentFilePath: string,
     configFilePath: string,
     dataHomePath: string,
+    retryAfterModelRefresh?: () => Promise<boolean>,
   ) {
     this._sessionId = sessionId;
     this.server = server;
@@ -164,6 +235,7 @@ export class OpencodeSession implements ProviderSession {
     this.agentFilePath = agentFilePath;
     this.configFilePath = configFilePath;
     this.dataHomePath = dataHomePath;
+    this.retryAfterModelRefresh = retryAfterModelRefresh;
     this.completionPromise = new Promise<ProviderResult>((resolve, reject) => {
       this.completionResolve = resolve;
       this.completionReject = reject;
@@ -211,6 +283,33 @@ export class OpencodeSession implements ProviderSession {
     for (const l of this.listeners) l(event);
   }
 
+  emitModelCacheRefreshProgress(): void {
+    this.emit({
+      type: "progress",
+      message: "opencode model cache is stale; refreshing OpenRouter models and retrying once",
+    });
+  }
+
+  emitModelCacheRefreshFailure(message: string, err: unknown): void {
+    this.emitError(`${message}; OpenRouter model cache refresh failed: ${formatUnknownError(err)}`);
+  }
+
+  private recoverFromModelNotFound(message: string): void {
+    if (!this.retryAfterModelRefresh || this.modelRefreshRecoveryInFlight) {
+      this.emitError(message);
+      return;
+    }
+    this.modelRefreshRecoveryInFlight = true;
+    this.emitModelCacheRefreshProgress();
+    this.retryAfterModelRefresh()
+      .then((retried) => {
+        if (!retried) this.emitError(message);
+      })
+      .catch((err: unknown) => {
+        this.emitModelCacheRefreshFailure(message, err);
+      });
+  }
+
   /** Best-effort cleanup of per-task isolation files and directories. */
   private async cleanupFiles(): Promise<void> {
     try {
@@ -361,6 +460,10 @@ export class OpencodeSession implements ProviderSession {
           ev.properties.error && "message" in ev.properties.error
             ? String((ev.properties.error as { message?: string }).message ?? "unknown error")
             : "opencode session error";
+        if (isModelNotFoundError(errMsg)) {
+          this.recoverFromModelNotFound(errMsg);
+          break;
+        }
         this.emitError(errMsg);
         break;
       }
@@ -562,6 +665,30 @@ export class OpencodeAdapter implements ProviderAdapter {
     const opencodeSession = createResult.data;
     const sessionId = opencodeSession.id;
 
+    let promptRefreshAttempted = false;
+    let promptRefreshPromise: Promise<boolean> | undefined;
+    const sendPrompt = async () => {
+      await client.session.prompt({
+        path: { id: sessionId },
+        query: { directory: config.cwd },
+        body: {
+          agent: agentName,
+          parts: [{ type: "text", text: config.prompt }],
+        },
+      });
+    };
+    const refreshOpenRouterAndRetryPrompt = async (): Promise<boolean> => {
+      if (promptRefreshPromise) return await promptRefreshPromise;
+      if (promptRefreshAttempted || !isOpenRouterModel(config.model)) return false;
+      promptRefreshAttempted = true;
+      promptRefreshPromise = (async () => {
+        await refreshOpenRouterModelCacheImpl(opencodeConfig, configFilePath, dataHomePath);
+        await sendPrompt();
+        return true;
+      })();
+      return await promptRefreshPromise;
+    };
+
     const session = new OpencodeSession(
       sessionId,
       server,
@@ -571,6 +698,7 @@ export class OpencodeAdapter implements ProviderAdapter {
       agentFilePath,
       configFilePath,
       dataHomePath,
+      isOpenRouterModel(config.model) ? refreshOpenRouterAndRetryPrompt : undefined,
     );
 
     // Emit session_init synchronously; the session buffers events until the
@@ -594,21 +722,28 @@ export class OpencodeAdapter implements ProviderAdapter {
       });
 
     // Fire-and-forget: send the prompt using the per-task agent
-    client.session
-      .prompt({
-        path: { id: sessionId },
-        query: { directory: config.cwd },
-        body: {
-          agent: agentName,
-          parts: [{ type: "text", text: config.prompt }],
-        },
-      })
-      .catch((err: unknown) => {
-        session.handleOpencodeEvent({
-          type: "session.error",
-          properties: { sessionID: sessionId, error: { message: String(err) } as never },
-        });
+    sendPrompt().catch((err: unknown) => {
+      const message = formatUnknownError(err);
+      if (isModelNotFoundError(message) && isOpenRouterModel(config.model)) {
+        session.emitModelCacheRefreshProgress();
+        refreshOpenRouterAndRetryPrompt()
+          .then((retried) => {
+            if (retried) return;
+            session.handleOpencodeEvent({
+              type: "session.error",
+              properties: { sessionID: sessionId, error: { message } as never },
+            });
+          })
+          .catch((retryErr: unknown) => {
+            session.emitModelCacheRefreshFailure(message, retryErr);
+          });
+        return;
+      }
+      session.handleOpencodeEvent({
+        type: "session.error",
+        properties: { sessionID: sessionId, error: { message } as never },
       });
+    });
 
     return session;
   }

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

@@ -17,9 +17,11 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import {
   type AgentSession,
+  AuthStorage,
   createAgentSession,
   DefaultResourceLoader,
   getAgentDir,
+  ModelRegistry,
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { type TSchema, Type } from "typebox";
@@ -180,6 +182,39 @@ function envHasAnthropicCred(env: Record<string, string | undefined>): boolean {
   return !!(env.ANTHROPIC_API_KEY || env.ANTHROPIC_OAUTH_TOKEN);
 }
 
+const PI_RUNTIME_API_KEYS = [
+  ["OPENROUTER_API_KEY", "openrouter"],
+  ["ANTHROPIC_API_KEY", "anthropic"],
+  ["OPENAI_API_KEY", "openai"],
+  ["GOOGLE_API_KEY", "google"],
+] as const;
+
+/**
+ * Build pi-coding-agent auth services from the runner's per-task resolved env.
+ *
+ * The runner intentionally does not copy rotated credential-pool selections
+ * into `process.env` because that would freeze rotation globally. pi-mono runs
+ * in-process, so pass selected keys through pi's runtime auth override instead
+ * of relying on environment lookup.
+ */
+export function createPiRuntimeAuth(env: Record<string, string | undefined> = process.env): {
+  authStorage: AuthStorage;
+  modelRegistry: ModelRegistry;
+} {
+  const authStorage = AuthStorage.create();
+  for (const [envKey, provider] of PI_RUNTIME_API_KEYS) {
+    const apiKey = env[envKey];
+    if (apiKey) {
+      authStorage.setRuntimeApiKey(provider, apiKey);
+    }
+  }
+
+  return {
+    authStorage,
+    modelRegistry: ModelRegistry.create(authStorage),
+  };
+}
+
 /**
  * Resolve a model string to a pi-ai Model object.
  *
@@ -672,8 +707,11 @@ export class PiMonoAdapter implements ProviderAdapter {
       }
     }
 
+    const sessionEnv = config.env ?? process.env;
+
     // 3. Resolve model
-    const model = resolveModel(config.model);
+    const model = resolveModel(config.model, sessionEnv);
+    const { authStorage, modelRegistry } = createPiRuntimeAuth(sessionEnv);
 
     // 4. Create swarm hooks extension
     const swarmExtension = createSwarmHooksExtension({
@@ -698,6 +736,8 @@ export class PiMonoAdapter implements ProviderAdapter {
       model,
       customTools,
       resourceLoader,
+      authStorage,
+      modelRegistry,
     };
 
     // 7. Create the session

package/src/providers/types.ts

@@ -125,7 +125,7 @@ export interface ProviderResult {
    * ISO timestamp of the rate limit reset time, parsed from a structured
    * `rate_limit_event` line in the Claude CLI stream. Only set by the Claude
    * adapter when a `status: "rejected"` event is present. Already clamped to
-   * [now+60s, now+6h] at the source. The runner uses this as tier-1 of the
+   * [now+60s, now+7d] at the source. The runner uses this as tier-1 of the
    * three-tier cooldown resolver.
    */
   rateLimitResetAt?: string;

package/src/server-user.ts

@@ -0,0 +1,117 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import pkg from "../package.json";
+import {
+  cancelTaskHandler,
+  cancelTaskInputSchema,
+  cancelTaskOutputSchema,
+} from "./tools/cancel-task";
+import {
+  getTaskDetailsHandler,
+  getTaskDetailsInputSchema,
+  getTaskDetailsOutputSchema,
+} from "./tools/get-task-details";
+import { getTasksHandler, getTasksInputSchema, getTasksOutputSchema } from "./tools/get-tasks";
+import { sendTaskHandler, sendTaskOutputSchema } from "./tools/send-task";
+import {
+  taskActionHandler,
+  taskActionInputSchema,
+  taskActionOutputSchema,
+} from "./tools/task-action";
+import { userCtx } from "./tools/task-tool-ctx";
+import { createToolRegistrar } from "./tools/utils";
+import type { User } from "./types";
+
+const userSendTaskInputSchema = z.object({
+  task: z.string().min(1).describe("The task description to send."),
+  taskType: z.string().max(50).optional().describe("Task type (e.g., 'bug', 'feature', 'review')."),
+  tags: z.array(z.string()).optional().describe("Tags for filtering (e.g., ['urgent'])."),
+  priority: z.number().int().min(0).max(100).optional().describe("Priority 0-100 (default: 50)."),
+  model: z
+    .enum(["haiku", "sonnet", "opus"])
+    .optional()
+    .describe("Model to use for this task ('haiku', 'sonnet', or 'opus')."),
+});
+
+export function createUserServer(user: User): McpServer {
+  const server = new McpServer(
+    {
+      name: `${pkg.name}-user`,
+      version: pkg.version,
+      description: "End-user task MCP surface for Agent Swarm.",
+    },
+    {
+      capabilities: {
+        logging: {},
+      },
+    },
+  );
+
+  const registerTool = createToolRegistrar(server);
+
+  registerTool(
+    "send-task",
+    {
+      title: "Send a task",
+      annotations: { destructiveHint: false },
+      description: "Creates an unassigned task requested by the authenticated user.",
+      inputSchema: userSendTaskInputSchema,
+      outputSchema: sendTaskOutputSchema,
+    },
+    async (args, info, _meta) =>
+      sendTaskHandler(userCtx(user, info.sessionId), {
+        offerMode: false,
+        allowDuplicate: false,
+        ...args,
+      }),
+  );
+
+  registerTool(
+    "get-tasks",
+    {
+      title: "Get tasks",
+      description: "Returns tasks requested by the authenticated user.",
+      annotations: { readOnlyHint: true },
+      inputSchema: getTasksInputSchema,
+      outputSchema: getTasksOutputSchema,
+    },
+    async (args, info, _meta) => getTasksHandler(userCtx(user, info.sessionId), args),
+  );
+
+  registerTool(
+    "get-task-details",
+    {
+      title: "Get task details",
+      description: "Returns detailed information about one of your tasks.",
+      annotations: { readOnlyHint: true },
+      inputSchema: getTaskDetailsInputSchema,
+      outputSchema: getTaskDetailsOutputSchema,
+    },
+    async (args, info, _meta) => getTaskDetailsHandler(userCtx(user, info.sessionId), args),
+  );
+
+  registerTool(
+    "cancel-task",
+    {
+      title: "Cancel Task",
+      description: "Cancel one of your pending or in-progress tasks.",
+      annotations: { destructiveHint: true },
+      inputSchema: cancelTaskInputSchema,
+      outputSchema: cancelTaskOutputSchema,
+    },
+    async (args, info, _meta) => cancelTaskHandler(userCtx(user, info.sessionId), args),
+  );
+
+  registerTool(
+    "task-action",
+    {
+      title: "Task Pool Action",
+      description: "Move one of your tasks to or from backlog.",
+      inputSchema: taskActionInputSchema,
+      outputSchema: taskActionOutputSchema,
+    },
+    async (args, info, _meta) => taskActionHandler(userCtx(user, info.sessionId), args),
+  );
+
+  return server;
+}

package/src/tests/artifact-sdk.test.ts

@@ -2,7 +2,11 @@ import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { BROWSER_SDK_JS } from "../artifact-sdk/browser-sdk";
 import { getAvailablePort } from "../artifact-sdk/port";
-import { createArtifactServer } from "../artifact-sdk/server";
+import {
+  createArtifactServer,
+  createBunHonoFetchHandler,
+  createBunResponse,
+} from "../artifact-sdk/server";
 import { getBasePrompt } from "../prompts/base-prompt";
 
 // ─── Port allocation tests ──────────────────────────────────────────────
@@ -25,7 +29,7 @@ describe("getAvailablePort", () => {
     // Try to start a Bun server on the port — should succeed
     const server = Bun.serve({
       port,
-      fetch: () => new Response("ok"),
+      fetch: () => createBunResponse("ok"),
     });
     expect(server.port).toBe(port);
     server.stop();
@@ -172,7 +176,7 @@ describe("createArtifactServer", () => {
       });
       honoApp.route("/", app);
 
-      const server = Bun.serve({ port, fetch: honoApp.fetch });
+      const server = Bun.serve({ port, fetch: createBunHonoFetchHandler(honoApp) });
 
       try {
         // Test content serving
@@ -211,7 +215,7 @@ describe("createArtifactServer", () => {
       const app = new Hono();
       app.use("/*", serveStatic({ root: testDir }));
 
-      const server = Bun.serve({ port, fetch: app.fetch });
+      const server = Bun.serve({ port, fetch: createBunHonoFetchHandler(app) });
 
       try {
         const res = await fetch(`http://localhost:${port}/index.html`);
@@ -244,7 +248,7 @@ describe("createArtifactServer", () => {
         }
       });
 
-      const server = Bun.serve({ port, fetch: app.fetch });
+      const server = Bun.serve({ port, fetch: createBunHonoFetchHandler(app) });
 
       try {
         const res = await fetch(`http://localhost:${port}/@swarm/api/agents`);
@@ -272,7 +276,7 @@ describe("createArtifactServer", () => {
         });
       });
 
-      const server = Bun.serve({ port, fetch: app.fetch });
+      const server = Bun.serve({ port, fetch: createBunHonoFetchHandler(app) });
 
       try {
         const res = await fetch(`http://localhost:${port}/@swarm/api/tasks`, {
@@ -303,7 +307,7 @@ describe("createArtifactServer", () => {
           for (const [key, value] of req.headers.entries()) {
             capturedHeaders[key.toLowerCase()] = value;
           }
-          return new Response(JSON.stringify({ success: true }), {
+          return createBunResponse(JSON.stringify({ success: true }), {
             headers: { "Content-Type": "application/json" },
           });
         },
@@ -336,7 +340,7 @@ describe("createArtifactServer", () => {
         }
       });
 
-      const proxy = Bun.serve({ port: proxyPort, fetch: app.fetch });
+      const proxy = Bun.serve({ port: proxyPort, fetch: createBunHonoFetchHandler(app) });
 
       try {
         // Test GET request headers
@@ -369,7 +373,7 @@ describe("createArtifactServer", () => {
       const mockMcp = Bun.serve({
         port: mockMcpPort,
         fetch: () =>
-          new Response(JSON.stringify({ ok: true }), {
+          createBunResponse(JSON.stringify({ ok: true }), {
             headers: { "Content-Type": "application/json" },
           }),
       });
@@ -393,7 +397,7 @@ describe("createArtifactServer", () => {
         }
       });
 
-      const proxy = Bun.serve({ port: proxyPort, fetch: app.fetch });
+      const proxy = Bun.serve({ port: proxyPort, fetch: createBunHonoFetchHandler(app) });
 
       try {
         const res = await fetch(`http://localhost:${proxyPort}/@swarm/api/agents`);
@@ -415,7 +419,7 @@ describe("createArtifactServer", () => {
         port: mockMcpPort,
         fetch: (req) => {
           capturedPath = new URL(req.url).pathname;
-          return new Response(JSON.stringify({ ok: true }));
+          return createBunResponse(JSON.stringify({ ok: true }));
         },
       });
 
@@ -431,7 +435,7 @@ describe("createArtifactServer", () => {
         }
       });
 
-      const proxy = Bun.serve({ port: proxyPort, fetch: app.fetch });
+      const proxy = Bun.serve({ port: proxyPort, fetch: createBunHonoFetchHandler(app) });
 
       try {
         await fetch(`http://localhost:${proxyPort}/@swarm/api/tasks/123/progress`);
@@ -535,7 +539,7 @@ describe("artifact CLI command", () => {
         fetch: (req) => {
           const url = new URL(req.url);
           if (url.pathname === "/api/services") {
-            return new Response(
+            return createBunResponse(
               JSON.stringify({
                 services: [
                   {
@@ -561,7 +565,7 @@ describe("artifact CLI command", () => {
               }),
             );
           }
-          return new Response("Not found", { status: 404 });
+          return createBunResponse("Not found", { status: 404 });
         },
       });
 
@@ -595,7 +599,7 @@ describe("artifact CLI command", () => {
       const mockPort = await getAvailablePort();
       const mockServer = Bun.serve({
         port: mockPort,
-        fetch: () => new Response(JSON.stringify({ services: [] })),
+        fetch: () => createBunResponse(JSON.stringify({ services: [] })),
       });
 
       const origEnv = { ...process.env };
@@ -627,7 +631,7 @@ describe("artifact CLI command", () => {
       const mockServer = Bun.serve({
         port: mockPort,
         fetch: () =>
-          new Response(
+          createBunResponse(
             JSON.stringify({
               services: [
                 {
@@ -685,7 +689,7 @@ describe("artifact CLI command", () => {
         fetch: (req) => {
           const url = new URL(req.url);
           if (req.method === "GET" && url.pathname === "/api/services") {
-            return new Response(
+            return createBunResponse(
               JSON.stringify({
                 services: [
                   {
@@ -699,9 +703,9 @@ describe("artifact CLI command", () => {
           }
           if (req.method === "DELETE" && url.pathname.startsWith("/api/services/")) {
             deletedServiceId = url.pathname.split("/").pop() || "";
-            return new Response(JSON.stringify({ success: true }));
+            return createBunResponse(JSON.stringify({ success: true }));
           }
-          return new Response("Not found", { status: 404 });
+          return createBunResponse("Not found", { status: 404 });
         },
       });