@desplega.ai/agent-swarm 1.79.4 → 1.80.1

package/src/commands/setup.tsx

@@ -2,6 +2,7 @@
 import { Spinner, TextInput } from "@inkjs/ui";
 import { Box, Text, useApp } from "ink";
 import { useCallback, useEffect, useRef, useState } from "react";
+import { getApiKey } from "../utils/api-key.ts";
 import {
   createDefaultMcpJson,
   createDefaultSettingsLocal,
@@ -47,7 +48,7 @@ export function Setup({ dryRun = false, restore = false, yes = false }: SetupPro
   const { exit } = useApp();
   const [state, setState] = useState<SetupState>({
     step: restore ? "restoring" : "check_dirs",
-    token: yes ? process.env.API_KEY || "" : "",
+    token: yes ? getApiKey() : "",
     agentId: yes ? process.env.AGENT_ID || "" : "",
     existingToken: "",
     existingAgentId: "",
@@ -258,14 +259,15 @@ export function Setup({ dryRun = false, restore = false, yes = false }: SetupPro
 
       // In non-interactive mode (yes=true), skip prompts and go directly to updating
       if (yes) {
-        const token = process.env.API_KEY;
+        const token = getApiKey();
         const agentId = process.env.AGENT_ID;
 
         if (!token) {
           setState((s) => ({
             ...s,
             step: "error",
-            error: "API_KEY environment variable is required in non-interactive mode (-y/--yes)",
+            error:
+              "AGENT_SWARM_API_KEY (or legacy API_KEY) environment variable is required in non-interactive mode (-y/--yes)",
           }));
           return;
         }

package/src/hooks/hook.ts

@@ -10,6 +10,7 @@ import {
   type RetrievalRow,
 } from "../be/memory/raters/llm";
 import type { Agent } from "../types";
+import { getApiKey } from "../utils/api-key";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
 import { checkToolLoop, clearToolHistory } from "./tool-loop-detection";
 
@@ -150,7 +151,7 @@ async function fetchTaskDetails(
   taskId: string,
 ): Promise<{ id: string; task: string; progress?: string } | null> {
   const apiUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
-  const apiKey = process.env.API_KEY || "";
+  const apiKey = getApiKey();
   const headers: Record<string, string> = {};
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
 
@@ -301,7 +302,7 @@ export async function runStopHookSessionSummary(
     const { taskContext, taskId } = await resolveStopHookTaskContext(env);
 
     const apiUrl = env.MCP_BASE_URL || `http://localhost:${env.PORT || "3013"}`;
-    const apiKey = env.API_KEY || "";
+    const apiKey = getApiKey(env);
 
     // Memory-rater v1.5 step-4: piggyback per-memory ratings on the
     // existing summary call when MEMORY_RATERS includes `llm`.
@@ -1152,7 +1153,7 @@ ${hasAgentIdHeader() ? `You have a pre-defined agent ID via header: ${mcpConfig?
           try {
             const apiUrl =
               process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
-            const apiKey = process.env.API_KEY || "";
+            const apiKey = getApiKey();
             const fileContent = await Bun.file(editedPath).text();
             const isShared = editedPath.startsWith("/workspace/shared/");
             const fileName = editedPath.split("/").pop() ?? "unnamed";

package/src/http/context.ts

@@ -6,7 +6,7 @@ import {
   getContextSummaryByTaskId,
   getTaskById,
 } from "../be/db";
-import { ContextSnapshotEventTypeSchema } from "../types";
+import { ContextFormulaSchema, ContextSnapshotEventTypeSchema } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -25,10 +25,13 @@ const postContext = route({
     contextUsedTokens: z.number().int().min(0).optional(),
     contextTotalTokens: z.number().int().min(0).optional(),
     contextPercent: z.number().min(0).max(100).optional(),
-    compactTrigger: z.enum(["auto", "manual"]).optional(),
+    compactTrigger: z.enum(["auto", "manual", "auto-inferred"]).optional(),
     preCompactTokens: z.number().int().min(0).optional(),
     cumulativeInputTokens: z.number().int().min(0).optional(),
     cumulativeOutputTokens: z.number().int().min(0).optional(),
+    // Migration 063: adapters tag the formula they used so cross-provider
+    // comparisons can tell apples from oranges.
+    contextFormula: ContextFormulaSchema.optional(),
   }),
   responses: {
     200: { description: "Snapshot recorded" },
@@ -91,6 +94,7 @@ export async function handleContext(
       preCompactTokens: parsed.body.preCompactTokens,
       cumulativeInputTokens: parsed.body.cumulativeInputTokens,
       cumulativeOutputTokens: parsed.body.cumulativeOutputTokens,
+      contextFormula: parsed.body.contextFormula,
     });
 
     json(res, { ok: true, snapshotId: snapshot.id });

package/src/http/index.ts

@@ -14,8 +14,10 @@ import { initGitLab } from "../gitlab";
 import { stopHeartbeat } from "../heartbeat";
 import { initJira } from "../jira";
 import { initLinear } from "../linear";
+import { initOtel, isPollTracingEnabled, startSpan, withRemoteContext } from "../otel";
 import { startSlackApp, stopSlackApp } from "../slack";
 import { initTelemetry, telemetry } from "../telemetry";
+import { getApiKey } from "../utils/api-key";
 import { initWorkflows } from "../workflows";
 import { handleActiveSessions } from "./active-sessions";
 import { handleAgentRegister, handleAgentsRest } from "./agents";
@@ -44,6 +46,7 @@ import { handlePricing } from "./pricing";
 import { handlePromptTemplates } from "./prompt-templates";
 import { handleRepos } from "./repos";
 import { handleSchedules } from "./schedules";
+import { handleScripts } from "./scripts";
 import { handleSessionData } from "./session-data";
 import { handleSessions } from "./sessions";
 import { handleSkills } from "./skills";
@@ -68,7 +71,7 @@ process.on("unhandledRejection", (reason) => {
 });
 
 const port = parseInt(process.env.PORT || process.argv[2] || "3013", 10);
-const apiKey = process.env.API_KEY || "";
+const apiKey = getApiKey();
 
 // Use globalThis to persist state across hot reloads
 const globalState = globalThis as typeof globalThis & {
@@ -89,6 +92,7 @@ const transports: Record<string, StreamableHTTPServerTransport> = globalState.__
 const httpServer = createHttpServer(async (req, res) => {
   const startTime = performance.now();
   let statusCode = 200;
+  let spanEnded = false;
 
   // Wrap writeHead to capture status code
   const originalWriteHead = res.writeHead.bind(res);
@@ -113,76 +117,117 @@ const httpServer = createHttpServer(async (req, res) => {
     console.error(`[HTTP] ❌ ${req.method} ${req.url} → Error: ${err.message}`);
   });
 
-  setCorsHeaders(req, res);
-
-  // ── Core routes (OPTIONS, health, auth, /me, /cancelled-tasks, /ping, /close) ──
-  if (await handleCore(req, res, req.headers["x-agent-id"] as string | undefined, apiKey)) return;
-
-  const pathSegments = getPathSegments(req.url || "");
-  const queryParams = parseQueryParams(req.url || "");
-  const myAgentId = req.headers["x-agent-id"] as string | undefined;
-
-  // ── Route handlers (order matters — first match wins) ──
-  const handlers: (() => Promise<boolean>)[] = [
-    () => handleAgentRegister(req, res, pathSegments, myAgentId),
-    () => handlePoll(req, res, pathSegments, queryParams, myAgentId),
-    () => handleSessionData(req, res, pathSegments, queryParams, myAgentId),
-    () => handleEcosystem(req, res, pathSegments, myAgentId),
-    () => handleTrackers(req, res, pathSegments),
-    () => handleWebhooks(req, res, pathSegments),
-    () => handleAgentsRest(req, res, pathSegments, queryParams, myAgentId),
-    () => handleBudgets(req, res, pathSegments, queryParams, myAgentId),
-    () => handleContext(req, res, pathSegments, queryParams, myAgentId),
-    () => handleTasks(req, res, pathSegments, queryParams, myAgentId),
-    () => handleStats(req, res, pathSegments, queryParams),
-    () => handleStatus(req, res, pathSegments, queryParams),
-    () => handleActiveSessions(req, res, pathSegments, queryParams, myAgentId),
-    () => handlePricing(req, res, pathSegments, queryParams, myAgentId),
-    () => handleSchedules(req, res, pathSegments, queryParams, myAgentId),
-    () => handleWorkflows(req, res, pathSegments, queryParams, myAgentId),
-    () => handleWorkflowEvents(req, res, pathSegments, queryParams),
-    () => handleApprovalRequests(req, res, pathSegments, queryParams),
-    () => handleConfig(req, res, pathSegments, queryParams),
-    () => handleKv(req, res, pathSegments, queryParams),
-    () => handleIntegrations(req, res, pathSegments),
-    () => handlePromptTemplates(req, res, pathSegments, queryParams),
-    () => handleDbQuery(req, res, pathSegments, queryParams),
-    () => handleRepos(req, res, pathSegments, queryParams),
-    () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
-    () => handleMcpServers(req, res, pathSegments, queryParams),
-    () => handleMcpOAuth(req, res, pathSegments, queryParams),
-    () => handleMemory(req, res, pathSegments, myAgentId),
-    () => handlePagesPublic(req, res, pathSegments, queryParams),
-    () => handlePageProxy(req, res),
-    () => handlePages(req, res, pathSegments, queryParams, myAgentId),
-    () => handleApiKeys(req, res, pathSegments, queryParams),
-    () => handleHeartbeat(req, res, pathSegments),
-    () => handleEvents(req, res, pathSegments, queryParams, myAgentId),
-    () => handleUsers(req, res, pathSegments, queryParams),
-    () => handleSessions(req, res, pathSegments, queryParams),
-    () => handleInboxState(req, res, pathSegments, queryParams),
-    () => handleTaskTemplates(req, res, pathSegments, queryParams),
-    () => handleMcp(req, res, transports),
-  ];
-
-  try {
-    for (const handler of handlers) {
-      if (await handler()) return;
+  await withRemoteContext(req.headers as Record<string, unknown>, async () => {
+    const reqPath = req.url?.split("?")[0] ?? "";
+    const skipSpan = reqPath === "/api/poll" && !isPollTracingEnabled();
+    const span = skipSpan
+      ? null
+      : startSpan("http.server", {
+          "http.request.method": req.method ?? "",
+          "url.path": reqPath,
+          "agent.id": req.headers["x-agent-id"] as string | undefined,
+          "agentswarm.component": "api",
+        });
+
+    if (span) {
+      res.on("finish", () => {
+        if (spanEnded) return;
+        spanEnded = true;
+        span.setAttributes({
+          "http.response.status_code": statusCode,
+          "agentswarm.http.duration_ms": Math.round((performance.now() - startTime) * 10) / 10,
+        });
+        if (statusCode >= 500) {
+          span.setStatus({ code: 2, message: `HTTP ${statusCode}` });
+        }
+        span.end();
+      });
+
+      res.on("error", (err) => {
+        if (spanEnded) return;
+        spanEnded = true;
+        span.recordException(err);
+        span.setStatus({ code: 2, message: err.message });
+        span.end();
+      });
     }
 
-    // ── 404 ──
-    res.writeHead(404);
-    res.end("Not Found");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[HTTP] ❌ ${req.method} ${req.url} → ${message}`);
-    if (!res.headersSent) {
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: message }));
-    } else if (!res.writableEnded) {
-      res.end();
+    setCorsHeaders(req, res);
+
+    // ── Core routes (OPTIONS, health, auth, /me, /cancelled-tasks, /ping, /close) ──
+    if (await handleCore(req, res, req.headers["x-agent-id"] as string | undefined, apiKey)) return;
+
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+
+    // ── Route handlers (order matters — first match wins) ──
+    const handlers: (() => Promise<boolean>)[] = [
+      () => handleAgentRegister(req, res, pathSegments, myAgentId),
+      () => handlePoll(req, res, pathSegments, queryParams, myAgentId),
+      () => handleSessionData(req, res, pathSegments, queryParams, myAgentId),
+      () => handleEcosystem(req, res, pathSegments, myAgentId),
+      () => handleTrackers(req, res, pathSegments),
+      () => handleWebhooks(req, res, pathSegments),
+      () => handleAgentsRest(req, res, pathSegments, queryParams, myAgentId),
+      () => handleBudgets(req, res, pathSegments, queryParams, myAgentId),
+      () => handleContext(req, res, pathSegments, queryParams, myAgentId),
+      () => handleTasks(req, res, pathSegments, queryParams, myAgentId),
+      () => handleStats(req, res, pathSegments, queryParams),
+      () => handleStatus(req, res, pathSegments, queryParams),
+      () => handleActiveSessions(req, res, pathSegments, queryParams, myAgentId),
+      () => handlePricing(req, res, pathSegments, queryParams, myAgentId),
+      () => handleSchedules(req, res, pathSegments, queryParams, myAgentId),
+      () => handleWorkflows(req, res, pathSegments, queryParams, myAgentId),
+      () => handleWorkflowEvents(req, res, pathSegments, queryParams),
+      () => handleApprovalRequests(req, res, pathSegments, queryParams),
+      () => handleConfig(req, res, pathSegments, queryParams),
+      () => handleKv(req, res, pathSegments, queryParams),
+      () => handleIntegrations(req, res, pathSegments),
+      () => handlePromptTemplates(req, res, pathSegments, queryParams),
+      () => handleDbQuery(req, res, pathSegments, queryParams),
+      () => handleRepos(req, res, pathSegments, queryParams),
+      () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
+      () => handleScripts(req, res, pathSegments, queryParams, myAgentId),
+      () => handleMcpServers(req, res, pathSegments, queryParams),
+      () => handleMcpOAuth(req, res, pathSegments, queryParams),
+      () => handleMemory(req, res, pathSegments, myAgentId),
+      () => handlePagesPublic(req, res, pathSegments, queryParams),
+      () => handlePageProxy(req, res),
+      () => handlePages(req, res, pathSegments, queryParams, myAgentId),
+      () => handleApiKeys(req, res, pathSegments, queryParams),
+      () => handleHeartbeat(req, res, pathSegments),
+      () => handleEvents(req, res, pathSegments, queryParams, myAgentId),
+      () => handleUsers(req, res, pathSegments, queryParams),
+      () => handleSessions(req, res, pathSegments, queryParams),
+      () => handleInboxState(req, res, pathSegments, queryParams),
+      () => handleTaskTemplates(req, res, pathSegments, queryParams),
+      () => handleMcp(req, res, transports),
+    ];
+
+    try {
+      for (const handler of handlers) {
+        if (await handler()) return;
+      }
+
+      // ── 404 ──
+      res.writeHead(404);
+      res.end("Not Found");
+    } catch (err) {
+      if (span) {
+        span.recordException(err);
+        span.setStatus({ code: 2, message: err instanceof Error ? err.message : String(err) });
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[HTTP] ❌ ${req.method} ${req.url} → ${message}`);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: message }));
+      } else if (!res.writableEnded) {
+        res.end();
+      }
     }
-  }
+  });
 });
 
 // Store references in globalThis for hot reload persistence
@@ -250,9 +295,22 @@ try {
   throw err;
 }
 
+// Phase 2 of the cost-tracking plan: project the vendored models.dev snapshot
+// into pricing rows at boot. Lazy `getDb()` would also work, but doing it
+// here surfaces the count in the boot log and makes the API ready to recompute
+// USD before the first POST /api/session-costs lands.
+try {
+  const { seedPricingFromModelsDev } = await import("../be/seed-pricing");
+  seedPricingFromModelsDev();
+} catch (err) {
+  console.error("[startup] Failed to seed pricing rows:", err);
+}
+
 // business-use initialization (no-op if envs not set)
 initialize();
 
+await initOtel("api");
+
 httpServer
   .listen(port, async () => {
     console.log(`MCP HTTP server running on http://localhost:${port}/mcp`);

package/src/http/memory.ts

@@ -124,6 +124,20 @@ const deleteMemoryById = route({
   },
 });
 
+const getMemoryById = route({
+  method: "get",
+  path: "/api/memory/{id}",
+  pattern: ["api", "memory", null],
+  summary: "Get a single memory by ID",
+  tags: ["Memory"],
+  auth: { apiKey: true, agentId: true },
+  params: z.object({ id: z.string().uuid() }),
+  responses: {
+    200: { description: "Memory details" },
+    404: { description: "Memory not found" },
+  },
+});
+
 // Memory rater v1.5 — worker-facing rating endpoints. Plan:
 // thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-3.md
 //
@@ -618,5 +632,19 @@ export async function handleMemory(
     return true;
   }
 
+  if (getMemoryById.match(req.method, pathSegments)) {
+    const parsed = await getMemoryById.parse(req, res, pathSegments, new URLSearchParams());
+    if (!parsed) return true;
+
+    const memory = getMemoryStore().get(parsed.params.id);
+    if (!memory) {
+      jsonError(res, "Memory not found", 404);
+      return true;
+    }
+
+    json(res, { memory });
+    return true;
+  }
+
   return false;
 }

package/src/http/openapi.ts

@@ -64,6 +64,7 @@ export function generateOpenApiSpec(opts: OpenApiOptions): string {
     registry.registerPath({
       method: routeDef.method,
       path: routeDef.path,
+      operationId: routeDef.operationId,
       summary: routeDef.summary,
       description: routeDef.description,
       tags: routeDef.tags,

package/src/http/page-proxy.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getPage } from "../be/db";
+import { getApiKey } from "../utils/api-key";
 import { extractAndVerifyCookie } from "../utils/page-session";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
@@ -147,7 +148,7 @@ export async function handlePageProxy(req: IncomingMessage, res: ServerResponse)
   const baseUrl = `http://127.0.0.1:${port}`;
   const targetUrl = `${baseUrl}${rewrittenPath}${queryPart}`;
 
-  const apiKey = process.env.API_KEY ?? "";
+  const apiKey = getApiKey();
   // `X-Page-Id` is the trust anchor for page-scoped KV: only the page-proxy
   // ever sets it (any external `X-Page-Id` header is dropped because we don't
   // forward the original headers). The KV handler treats this as the highest-

package/src/http/route-def.ts

@@ -20,6 +20,7 @@ export interface RouteDef<
   path: string; // OpenAPI-style: "/api/tasks/{id}"
   pattern: readonly (string | null)[]; // matchRoute-style: ["api", "tasks", null]
   exact?: boolean; // default true
+  operationId?: string;
   summary: string;
   description?: string;
   tags: string[];

package/src/http/schedules.ts

@@ -8,6 +8,7 @@ import {
   getDb,
   getScheduledTaskById,
   getScheduledTaskByName,
+  getScheduledTasks,
   updateScheduledTask,
 } from "../be/db";
 import { calculateNextRun } from "../scheduler/scheduler";
@@ -64,6 +65,29 @@ const runScheduleNow = route({
   },
 });
 
+const listSchedules = route({
+  method: "get",
+  path: "/api/schedules",
+  pattern: ["api", "schedules"],
+  summary: "List schedules",
+  tags: ["Schedules"],
+  query: z.object({
+    enabled: z
+      .enum(["true", "false"])
+      .optional()
+      .transform((v) => (v === undefined ? undefined : v === "true")),
+    name: z.string().optional(),
+    scheduleType: z.enum(["recurring", "one_time"]).optional(),
+    hideCompleted: z
+      .enum(["true", "false"])
+      .optional()
+      .transform((v) => (v === undefined ? undefined : v === "true")),
+  }),
+  responses: {
+    200: { description: "List of schedules" },
+  },
+});
+
 const getSchedule = route({
   method: "get",
   path: "/api/schedules/{id}",
@@ -129,6 +153,19 @@ export async function handleSchedules(
   queryParams: URLSearchParams,
   _myAgentId: string | undefined,
 ): Promise<boolean> {
+  if (listSchedules.match(req.method, pathSegments)) {
+    const parsed = await listSchedules.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const schedules = getScheduledTasks({
+      enabled: parsed.query.enabled,
+      name: parsed.query.name,
+      scheduleType: parsed.query.scheduleType,
+      hideCompleted: parsed.query.hideCompleted,
+    });
+    json(res, { schedules, count: schedules.length });
+    return true;
+  }
+
   if (createSchedule.match(req.method, pathSegments)) {
     const parsed = await createSchedule.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;