@desplega.ai/agent-swarm 1.123.0 → 1.124.0

package/src/be/models-catalog.ts

@@ -0,0 +1,156 @@
+import { loadModelsDevCache, type ModelsDevCache, type ModelsDevModel } from "./modelsdev-cache";
+
+/**
+ * Live model catalog for the UI model picker.
+ *
+ * The pricing-refresh loop (`src/be/pricing-refresh.ts`) already fetches the
+ * full models.dev payload at boot and every 12h. This module keeps a slim
+ * in-memory projection of that payload — only the providers the four local
+ * harnesses' pickers can reach, and only the fields the picker reads — and
+ * serves it through `GET /api/models-catalog` (`src/http/models-catalog.ts`).
+ *
+ * Until the first successful fetch (or if models.dev is unreachable), the
+ * vendored `src/be/modelsdev-cache.json` snapshot is slimmed and served
+ * instead, so the endpoint is never empty. The UI additionally bundles the
+ * same snapshot as its own fallback while the request is in flight.
+ */
+
+/** Mirrors `SNAPSHOT_ORDER` + `BEDROCK_SNAPSHOT_ID` in `apps/ui/src/lib/agent-runtime-models.ts`. */
+export const CATALOG_PROVIDER_IDS = [
+  "openrouter",
+  "anthropic",
+  "openai",
+  "amazon-bedrock",
+] as const;
+
+export type CatalogProviderId = (typeof CATALOG_PROVIDER_IDS)[number];
+
+/**
+ * Limited-availability models that are intentionally vendored even when
+ * models.dev does not list them yet, as "provider/model-id". Shared with
+ * `scripts/refresh-modelsdev-pricing.ts` (which pins them into the snapshot)
+ * — the live catalog re-merges them from the snapshot so they never drop out
+ * of the picker between models.dev listing gaps.
+ */
+export const PINNED_MODELSDEV_ENTRIES = [
+  "anthropic/claude-mythos-5",
+  "anthropic/claude-sonnet-5",
+  "amazon-bedrock/anthropic.claude-sonnet-5",
+] as const;
+
+export interface CatalogReasoningOption {
+  type: string;
+  values?: string[];
+}
+
+/** Field names deliberately match raw models.dev (`reasoning_options`, not camelCase) so the UI can treat live and bundled-snapshot data identically. */
+export interface CatalogModel {
+  id: string;
+  name?: string;
+  cost?: { input?: number; output?: number };
+  limit?: { context?: number };
+  reasoning?: boolean;
+  reasoning_options?: CatalogReasoningOption[];
+}
+
+export interface CatalogProvider {
+  id: string;
+  name?: string;
+  models: Record<string, CatalogModel>;
+}
+
+export type ModelsCatalog = Partial<Record<CatalogProviderId, CatalogProvider>>;
+
+export interface ModelsCatalogResult {
+  source: "live" | "snapshot";
+  /** Epoch ms of the last successful models.dev fetch; null for snapshot data. */
+  updatedAt: number | null;
+  providers: ModelsCatalog;
+}
+
+function slimModel(modelKey: string, model: ModelsDevModel): CatalogModel {
+  const reasoningOptions = Array.isArray(model.reasoning_options)
+    ? model.reasoning_options
+        .filter((o) => typeof o.type === "string")
+        .map((o) => ({
+          type: o.type as string,
+          ...(Array.isArray(o.values) ? { values: o.values } : {}),
+        }))
+    : [];
+  return {
+    id: model.id ?? modelKey,
+    ...(model.name !== undefined ? { name: model.name } : {}),
+    ...(model.cost !== undefined
+      ? { cost: { input: model.cost.input, output: model.cost.output } }
+      : {}),
+    ...(model.limit?.context !== undefined ? { limit: { context: model.limit.context } } : {}),
+    ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {}),
+    ...(reasoningOptions.length > 0 ? { reasoning_options: reasoningOptions } : {}),
+  };
+}
+
+/** Slim a full models.dev payload down to the picker-reachable providers/fields. */
+export function buildModelsCatalog(cache: ModelsDevCache): ModelsCatalog {
+  const catalog: ModelsCatalog = {};
+  for (const providerId of CATALOG_PROVIDER_IDS) {
+    const provider = cache[providerId];
+    if (!provider?.models) continue;
+    const models: Record<string, CatalogModel> = {};
+    for (const [modelKey, model] of Object.entries(provider.models)) {
+      models[modelKey] = slimModel(modelKey, model);
+    }
+    catalog[providerId] = {
+      id: provider.id ?? providerId,
+      ...(provider.name !== undefined ? { name: provider.name } : {}),
+      models,
+    };
+  }
+  return catalog;
+}
+
+let liveCatalog: ModelsCatalog | null = null;
+let liveUpdatedAt: number | null = null;
+/** Memoized slim of the vendored snapshot; `null` = load attempted and failed. */
+let snapshotCatalog: ModelsCatalog | null | undefined;
+
+function bundledSnapshotCatalog(): ModelsCatalog {
+  if (snapshotCatalog === undefined) {
+    const raw = loadModelsDevCache();
+    snapshotCatalog = raw ? buildModelsCatalog(raw) : null;
+  }
+  return snapshotCatalog ?? {};
+}
+
+function mergePinnedEntries(catalog: ModelsCatalog): void {
+  const snapshot = bundledSnapshotCatalog();
+  for (const entryPath of PINNED_MODELSDEV_ENTRIES) {
+    const slashIndex = entryPath.indexOf("/");
+    const providerId = entryPath.slice(0, slashIndex) as CatalogProviderId;
+    const modelId = entryPath.slice(slashIndex + 1);
+    if (catalog[providerId]?.models[modelId]) continue;
+    const pinned = snapshot[providerId]?.models[modelId];
+    if (!pinned) continue;
+    catalog[providerId] ??= { id: providerId, models: {} };
+    catalog[providerId].models[modelId] = pinned;
+  }
+}
+
+/** Called by the pricing-refresh loop after every successful full models.dev fetch. */
+export function updateLiveModelsCatalog(cache: ModelsDevCache, now = Date.now()): void {
+  const catalog = buildModelsCatalog(cache);
+  mergePinnedEntries(catalog);
+  liveCatalog = catalog;
+  liveUpdatedAt = now;
+}
+
+export function getModelsCatalog(): ModelsCatalogResult {
+  if (liveCatalog) {
+    return { source: "live", updatedAt: liveUpdatedAt, providers: liveCatalog };
+  }
+  return { source: "snapshot", updatedAt: null, providers: bundledSnapshotCatalog() };
+}
+
+export function resetModelsCatalogForTests(): void {
+  liveCatalog = null;
+  liveUpdatedAt = null;
+}

package/src/be/modelsdev-cache.ts

@@ -8,12 +8,23 @@ export interface ModelsDevCostBlock {
   cache_write?: number;
 }
 
+export interface ModelsDevReasoningOption {
+  type?: string;
+  values?: string[];
+}
+
 export interface ModelsDevModel {
   id?: string;
+  name?: string;
   cost?: ModelsDevCostBlock;
+  limit?: { context?: number };
+  reasoning?: boolean;
+  reasoning_options?: ModelsDevReasoningOption[];
 }
 
 export interface ModelsDevProvider {
+  id?: string;
+  name?: string;
   models?: Record<string, ModelsDevModel>;
 }
 
@@ -28,7 +39,9 @@ export const MODELSDEV_CACHE_PATH = path.join("src", "be", "modelsdev-cache.json
  * This file is now fallback-only for pricing freshness: boot seeding uses it
  * when the DB is empty or models.dev is unavailable, while
  * `src/be/pricing-refresh.ts` owns live price updates. The UI model picker
- * still imports the same snapshot for names, labels, and context windows.
+ * fetches the live catalog from `GET /api/models-catalog`
+ * (`src/be/models-catalog.ts`) and only falls back to its bundled copy of
+ * this snapshot when that request hasn't resolved.
  */
 export function loadModelsDevCache(): ModelsDevCache | null {
   const explicitPath = process.env.MODELSDEV_CACHE_PATH;

package/src/be/pricing-refresh.ts

@@ -6,6 +6,7 @@ import {
   type InsertPricingRowInput,
   insertPricingRow,
 } from "./db";
+import { updateLiveModelsCatalog } from "./models-catalog";
 import type { ModelsDevCache } from "./modelsdev-cache";
 import { buildModelsDevSeedRows, type PricingSeedRow } from "./seed-pricing";
 
@@ -148,6 +149,7 @@ export async function refreshPricingFromModelsDev(
 
   const cache = (await response.json()) as ModelsDevCache;
   const etag = response.headers.get("etag");
+  updateLiveModelsCatalog(cache, now);
   const rows = buildModelsDevSeedRows(cache);
   const { inserted, unchanged } = insertChangedPricingRows(rows, now);
   const pruned = prunePricingHistory(2);

package/src/be/scripts/typecheck.ts

@@ -106,7 +106,7 @@ export interface SwarmSdk {
   // --- workflows ---
   workflow_list(args?: { enabled?: boolean; includeFull?: boolean; consecutiveErrorsMin?: number; lastRunStatus?: "running" | "waiting" | "completed" | "failed" | "skipped" | "cancelled" }): Promise<unknown>;
   workflow_get(args: { id: string }): Promise<unknown>;
-  workflow_listRuns(args: { workflowId: string; status?: "running" | "waiting" | "completed" | "failed" | "skipped" | "cancelled" }): Promise<unknown>;
+  workflow_listRuns(args: { workflowId: string; status?: "running" | "waiting" | "completed" | "failed" | "skipped" | "cancelled"; limit?: number; offset?: number }): Promise<unknown>;
   workflow_getRun(args: { id: string }): Promise<unknown>;
   // --- prompt templates ---
   prompt_list(args?: { eventType?: string; scope?: "global" | "agent" | "repo"; scopeId?: string; isDefault?: boolean }): Promise<unknown>;
@@ -295,6 +295,17 @@ export interface ScriptContext {
   logger: ScriptLogger;
 }
 
+/**
+ * A swarm script's default export. \`args\` comes FIRST, \`ctx\` second — never swap them.
+ *
+ * @example
+ * import type { ScriptContext } from "swarm-sdk";
+ *
+ * export default async function (args: { name: string }, ctx: ScriptContext) {
+ *   await ctx.logger.log(\`hello \${args.name}\`);
+ *   return { ok: true };
+ * }
+ */
 // biome-ignore lint/suspicious/noExplicitAny: scripts may narrow their args type at the entrypoint.
 export type ScriptMain = (args: any, ctx: ScriptContext) => unknown | Promise<unknown>;
 `;
@@ -878,15 +889,17 @@ void _scriptMain;
 
   if (diagnostics.length === 0) return { ok: true };
 
-  const formatted = ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+  const formatHost: ts.FormatDiagnosticsHost = {
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => "/virtual",
     getNewLine: () => "\n",
-  });
+  };
 
   return {
     ok: false,
-    diagnostics: formatted.split("\n\n").filter(Boolean),
+    diagnostics: diagnostics.map((diagnostic) =>
+      ts.formatDiagnosticsWithColorAndContext([diagnostic], formatHost).trimEnd(),
+    ),
     structured: diagnostics.map(toStructured),
   };
 }

package/src/be/seed-scripts/catalog/task-context-gathering.ts

@@ -81,7 +81,7 @@ export default async function taskContextGathering(args: any, ctx: any) {
   memories.sort((a: any, b: any) => b.compositeScore - a.compositeScore);
 
   return {
-    task: slimTask(taskPayload?.task),
+    task: slimTask(taskPayload),
     requestedBy: taskPayload?.requestedBy,
     attachments: taskPayload?.attachments ?? [],
     queriesRun: queries.length,

package/src/commands/onboard/env-generator.ts

@@ -16,6 +16,18 @@ export function generateEnv(state: OnboardState): string {
   lines.push(`MCP_BASE_URL=http://localhost:${port}`);
   lines.push("APP_URL=https://app.agent-swarm.dev");
 
+  // Install path — read by src/telemetry.ts at boot to attribute the
+  // "which entry point produced this install" cohort. Boolean/enum only,
+  // never an identifier. Installs that never ran the wizard (hand-written
+  // docker-compose, manual `bun run start:http`) simply won't have this
+  // var set, and telemetry falls back to "manual".
+  lines.push(
+    `INSTALL_METHOD=${state.nonInteractive ? "onboard_noninteractive" : "onboard_interactive"}`,
+  );
+  if (state.presetId) {
+    lines.push(`INSTALL_PRESET=${state.presetId}`);
+  }
+
   // ── Authentication ──
   lines.push("");
   lines.push("# === Authentication ===");

package/src/e2b/env.ts

@@ -36,10 +36,6 @@ export const DEFAULT_E2B_FORWARD_KEYS = [
   "MANAGED_ENVIRONMENT_ID",
   "MANAGED_AGENT_MODEL",
   "MANAGED_GITHUB_TOKEN",
-  "ARCHIL_MOUNT_TOKEN",
-  "ARCHIL_REGION",
-  "ARCHIL_SHARED_DISK_NAME",
-  "ARCHIL_PERSONAL_DISK_NAME",
   "HARNESS_PROVIDER",
   "MODEL_OVERRIDE",
   "STARTUP_SCRIPT_STRICT",

package/src/hooks/hook.ts

@@ -105,31 +105,6 @@ export function shouldShowRegistrationNudge(opts: {
   return true;
 }
 
-/**
- * Check if a path is under the agent's own subdirectory on the shared disk.
- * Shared disk categories: thoughts, memory, downloads, misc.
- * Each agent can only write to /workspace/shared/{category}/{agentId}/
- */
-function isOwnedSharedPath(path: string, agentId: string): boolean {
-  const sharedCategories = ["thoughts", "memory", "downloads", "misc"];
-  return sharedCategories.some((cat) => path.startsWith(`/workspace/shared/${cat}/${agentId}/`));
-}
-
-/**
- * Build the shared disk write warning message for a given agent ID.
- */
-function sharedDiskWriteWarning(agentId: string): string {
-  return (
-    `⚠️ This write will fail: You don't have write access to this directory.\n\n` +
-    `On shared workspaces, each agent can only write to their own directories:\n` +
-    `- /workspace/shared/thoughts/${agentId}/\n` +
-    `- /workspace/shared/memory/${agentId}/\n` +
-    `- /workspace/shared/downloads/${agentId}/\n` +
-    `- /workspace/shared/misc/${agentId}/\n\n` +
-    `You CAN read any file on the shared disk. For writes, use your own subdirectory.`
-  );
-}
-
 /**
  * Hook response for blocking actions
  * See: https://code.claude.com/docs/en/hooks
@@ -1089,20 +1064,6 @@ export async function handleHook(): Promise<void> {
         }
       }
 
-      // Shared disk write prevention (Archil only — skip in local dev)
-      if (process.env.ARCHIL_MOUNT_TOKEN) {
-        const preAgentId = process.env.AGENT_ID;
-        if (preAgentId && (msg.tool_name === "Write" || msg.tool_name === "Edit")) {
-          const targetPath =
-            (msg.tool_input as { file_path?: string } | undefined)?.file_path ?? "";
-          if (
-            targetPath.startsWith("/workspace/shared/") &&
-            !isOwnedSharedPath(targetPath, preAgentId)
-          ) {
-            console.log(sharedDiskWriteWarning(preAgentId));
-          }
-        }
-      }
       break;
     }
 
@@ -1128,34 +1089,6 @@ export async function handleHook(): Promise<void> {
         });
       }
 
-      // Shared disk write failure detection (Archil only — safety net)
-      if (process.env.ARCHIL_MOUNT_TOKEN) {
-        const postAgentId = process.env.AGENT_ID;
-        if (
-          postAgentId &&
-          (msg.tool_name === "Write" || msg.tool_name === "Edit" || msg.tool_name === "Bash")
-        ) {
-          const toolResponse = msg.tool_response as
-            | { output?: string; stderr?: string }
-            | undefined;
-          const responseStr = JSON.stringify(toolResponse ?? "");
-          if (responseStr.includes("Read-only file system")) {
-            const postTargetPath =
-              (msg.tool_input as { file_path?: string; command?: string } | undefined)?.file_path ??
-              "";
-            if (
-              postTargetPath.startsWith("/workspace/shared/") &&
-              !isOwnedSharedPath(postTargetPath, postAgentId)
-            ) {
-              console.log(sharedDiskWriteWarning(postAgentId));
-            } else if (!postTargetPath) {
-              // Bash tool — no file_path, just warn generically
-              console.log(sharedDiskWriteWarning(postAgentId));
-            }
-          }
-        }
-      }
-
       if (agentInfo) {
         // Sync workspace file edits back to DB
         const toolName = msg.tool_name;

package/src/http/all-routes.ts

@@ -29,6 +29,7 @@ import "./integrations";
 import "./kv";
 import "./memory";
 import "./metrics";
+import "./models-catalog";
 import "./oauth-locks";
 import "./oauth-callback";
 import "./oauth-generic";

package/src/http/index.ts

@@ -72,6 +72,7 @@ import { handleMcpServers } from "./mcp-servers";
 import { closeIdleMcpUserTransports, handleMcpUser } from "./mcp-user";
 import { handleMemory, startMemoryGc, stopMemoryGc } from "./memory";
 import { handleMetrics } from "./metrics";
+import { handleModelsCatalog } from "./models-catalog";
 import { handleOAuthCallback, startOAuthPendingGc, stopOAuthPendingGc } from "./oauth-callback";
 import { handleGenericOAuth } from "./oauth-generic";
 import { handleOAuthLocks } from "./oauth-locks";
@@ -329,6 +330,7 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handlePromptTemplates(req, res, pathSegments, queryParams),
         () => handleDbQuery(req, res, pathSegments, queryParams),
         () => handleMetrics(req, res, pathSegments, queryParams, myAgentId),
+        () => handleModelsCatalog(req, res, pathSegments, queryParams),
         () => handleRepos(req, res, pathSegments, queryParams),
         () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
         () => handleScriptConnections(req, res, pathSegments, queryParams, myAgentId),

package/src/http/models-catalog.ts

@@ -0,0 +1,65 @@
+// Live model catalog for the UI model picker.
+//
+// Serves the slim in-memory projection of the models.dev payload maintained
+// by the pricing-refresh loop (`src/be/models-catalog.ts`). Read-only: the
+// catalog is refreshed server-side (boot + every 12h); the UI polls this
+// endpoint instead of relying on the build-time snapshot bundled into the SPA.
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import { getModelsCatalog } from "../be/models-catalog";
+import { route } from "./route-def";
+import { json } from "./utils";
+
+const CatalogModelSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  cost: z.object({ input: z.number().optional(), output: z.number().optional() }).optional(),
+  limit: z.object({ context: z.number().optional() }).optional(),
+  reasoning: z.boolean().optional(),
+  reasoning_options: z
+    .array(z.object({ type: z.string(), values: z.array(z.string()).optional() }))
+    .optional(),
+});
+
+const CatalogProviderSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  models: z.record(z.string(), CatalogModelSchema),
+});
+
+const getCatalog = route({
+  method: "get",
+  path: "/api/models-catalog",
+  pattern: ["api", "models-catalog"],
+  summary: "Get the live model catalog for the picker-reachable providers",
+  description:
+    "Slim projection of the models.dev payload (openrouter / anthropic / openai / amazon-bedrock only), refreshed server-side at boot and every 12h by the pricing-refresh loop. `source` is 'snapshot' with `updatedAt: null` until the first successful fetch (or when models.dev is unreachable), in which case the vendored snapshot is served instead.",
+  tags: ["Pricing"],
+  responses: {
+    200: {
+      description: "Model catalog",
+      schema: z.object({
+        source: z.enum(["live", "snapshot"]),
+        updatedAt: z.number().nullable(),
+        providers: z.record(z.string(), CatalogProviderSchema),
+      }),
+    },
+  },
+});
+
+export async function handleModelsCatalog(
+  req: IncomingMessage,
+  res: ServerResponse,
+  pathSegments: string[],
+  queryParams: URLSearchParams,
+): Promise<boolean> {
+  if (getCatalog.match(req.method, pathSegments)) {
+    const parsed = await getCatalog.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    json(res, getModelsCatalog());
+    return true;
+  }
+
+  return false;
+}

package/src/http/workflows.ts

@@ -11,6 +11,7 @@ import {
   getWorkflowVersion,
   getWorkflowVersions,
   listWorkflowRuns,
+  listWorkflowRunsPage,
   listWorkflows,
   updateWorkflow,
   withFavoriteFlags,
@@ -209,6 +210,8 @@ const listWorkflowRunsRoute = route({
   params: z.object({ id: z.string() }),
   query: z.object({
     status: WorkflowRunStatusSchema.optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    offset: z.coerce.number().int().min(0).optional(),
   }),
   responses: {
     200: { description: "Workflow run list" },
@@ -754,11 +757,20 @@ export async function handleWorkflows(
   if (listWorkflowRunsRoute.match(req.method, pathSegments)) {
     const parsed = await listWorkflowRunsRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    let runs = listWorkflowRuns(parsed.params.id);
-    // Apply optional status filter
-    if (parsed.query?.status) {
-      runs = runs.filter((r) => r.status === parsed.query.status);
+    const paginationRequested =
+      parsed.query?.limit !== undefined || parsed.query?.offset !== undefined;
+    if (paginationRequested) {
+      const page = listWorkflowRunsPage(parsed.params.id, {
+        status: parsed.query?.status,
+        limit: parsed.query?.limit ?? 20,
+        offset: parsed.query?.offset ?? 0,
+      });
+      json(res, page);
+      return true;
     }
+    // Preserve the pre-pagination response for the UI when limit/offset are
+    // omitted: a bare array containing every matching run.
+    const runs = listWorkflowRuns(parsed.params.id, { status: parsed.query?.status });
     json(res, runs);
     return true;
   }

package/src/prompts/base-prompt.ts

@@ -116,15 +116,16 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
   if (!hasMcp) {
     // If no MCP, role cannot be lead
     compositeEventType = "system.session.worker.remote";
+  } else if (args.provider === "pi") {
+    // Pi has no context-mode MCP wiring yet, so it uses composites that omit
+    // the context-mode tool list while still including the shared script
+    // rubric (and its authoring contract) plus seed-script guidance. Checked
+    // before the role branch so pi *leads* aren't told about `ctx_*` tools that
+    // don't exist for them either. All other local providers (claude, codex,
+    // opencode) keep the full context block via the standard composites.
+    compositeEventType = role === "lead" ? "system.session.lead.pi" : "system.session.worker.pi";
   } else if (role === "lead") {
     compositeEventType = "system.session.lead";
-  } else if (args.provider === "pi") {
-    // Pi has no context-mode MCP wiring yet, so it uses a worker composite that
-    // omits the context-mode tool list while still including the shared script
-    // rubric and seed-script guidance. All other local providers (claude,
-    // codex, opencode) keep the full context block via the standard worker
-    // composite.
-    compositeEventType = "system.session.worker.pi";
   } else {
     compositeEventType = "system.session.worker";
   }