@desplega.ai/agent-swarm 1.92.2 → 1.94.0

package/src/http/index.ts

@@ -458,10 +458,12 @@ try {
 // Seed the built-in entity catalog (scripts today; more kinds later) so
 // `script-search` & co. return useful hits from a fresh DB. Idempotent and
 // version-aware: a pristine entity updates when its source changes, a
-// user-modified one is preserved. See src/be/seed for the framework.
+// user-modified one is preserved. Script embeddings are deferred to a
+// post-listen backfill so boot doesn't block on embedding provider calls.
+// See src/be/seed for the framework.
 try {
   const { runAllSeeders } = await import("../be/seed");
-  await runAllSeeders();
+  await runAllSeeders({ scriptEmbeddingMode: "skip" });
 } catch (err) {
   console.error("[startup] Failed to seed built-in entities:", err);
 }
@@ -565,6 +567,15 @@ httpServer
       .catch((err) => {
         console.error("[boot-reembed] startup backfill failed (non-fatal):", err);
       });
+
+    // Background backfill: embed any scripts that were seeded without embeddings
+    // (scriptEmbeddingMode: "skip" during boot). Non-blocking, idempotent, no-op
+    // when every non-scratch script already has an embedding.
+    import("../be/scripts/boot-reembed")
+      .then(({ runBootReembedScripts }) => runBootReembedScripts())
+      .catch((err) => {
+        console.error("[boot-reembed-scripts] startup backfill failed (non-fatal):", err);
+      });
   })
   .on("error", (err) => {
     console.error("HTTP Server Error:", err);

package/src/http/mcp-bridge.ts

@@ -16,7 +16,7 @@ function getBridgeServer(): McpServer {
 }
 
 type RegisteredTool = {
-  handler: Function;
+  handler: (argsOrExtra: unknown, extra?: unknown) => unknown | Promise<unknown>;
   inputSchema?: unknown;
   enabled?: boolean;
 };

package/src/http/memory.ts

@@ -406,6 +406,7 @@ export async function handleMemory(
 
     const { query, agentId, scope, source, sourcePath, limit, offset } = parsed.body;
     const store = getMemoryStore();
+    const pageLimit = Math.min(limit, 100);
     const pathNeedle = sourcePath?.trim().toLowerCase();
     const matchesPath = (p: string | null) =>
       !pathNeedle || (p?.toLowerCase().includes(pathNeedle) ?? false);
@@ -416,11 +417,14 @@ export async function handleMemory(
         const queryEmbedding = await provider.embed(query.trim());
 
         if (!queryEmbedding) {
-          json(res, { results: [], total: 0, mode: "semantic" });
+          json(res, { results: [], total: 0, limit: pageLimit, offset, mode: "semantic" });
           return true;
         }
 
-        const candidateLimit = Math.min(limit, 100) * CANDIDATE_SET_MULTIPLIER;
+        const candidateLimit = Math.min(
+          4096,
+          Math.max(offset + pageLimit, pageLimit) * CANDIDATE_SET_MULTIPLIER,
+        );
         let candidates = store.search(queryEmbedding, agentId ?? "", {
           scope,
           limit: candidateLimit,
@@ -433,10 +437,11 @@ export async function handleMemory(
         if (pathNeedle) {
           candidates = candidates.filter((c) => matchesPath(c.sourcePath));
         }
-        const ranked = rerank(candidates, { limit: Math.min(limit, 100) });
+        const ranked = rerank(candidates, { limit: candidates.length });
+        const page = ranked.slice(offset, offset + pageLimit);
 
         json(res, {
-          results: ranked.map((r) => ({
+          results: page.map((r) => ({
             id: r.id,
             name: r.name,
             content: r.content,
@@ -457,33 +462,25 @@ export async function handleMemory(
             totalChunks: r.totalChunks,
             tags: r.tags,
           })),
-          total: ranked.length,
+          total: candidates.length,
+          limit: pageLimit,
+          offset,
           mode: "semantic",
         });
         return true;
       }
 
-      // When filtering by sourcePath, over-fetch then post-filter so the visible
-      // page isn't gutted by the in-memory filter.
-      const fetchLimit = pathNeedle
-        ? Math.min(500, Math.max(limit * 10, 100))
-        : Math.min(limit, 100);
-      let rows = store.list(agentId ?? "", {
+      const listOptions = {
         scope,
-        limit: fetchLimit,
+        limit: pageLimit,
         offset,
         isLead: true,
-      });
-      if (agentId) {
-        rows = rows.filter((r) => r.agentId === agentId);
-      }
-      if (source) {
-        rows = rows.filter((r) => r.source === source);
-      }
-      if (pathNeedle) {
-        rows = rows.filter((r) => matchesPath(r.sourcePath));
-      }
-      rows = rows.slice(0, Math.min(limit, 100));
+        ownerAgentId: agentId,
+        source,
+        sourcePath: pathNeedle,
+      };
+      const rows = store.list(agentId ?? "", listOptions);
+      const total = store.count(agentId ?? "", listOptions);
 
       json(res, {
         results: rows.map((r) => ({
@@ -504,7 +501,9 @@ export async function handleMemory(
           totalChunks: r.totalChunks,
           tags: r.tags,
         })),
-        total: rows.length,
+        total,
+        limit: pageLimit,
+        offset,
         mode: "list",
       });
     } catch (err) {

package/src/http/metrics.ts

@@ -48,12 +48,48 @@ function slugify(input: string): string {
 
 function validateMetricDefinition(definition: unknown) {
   const parsed = MetricDefinitionSchema.parse(definition);
+  for (const variable of parsed.variables ?? []) {
+    if (variable.optionsQuery) {
+      assertSelectOnlyQuery(variable.optionsQuery.sql);
+    }
+  }
   for (const widget of parsed.widgets) {
     assertSelectOnlyQuery(widget.query.sql);
   }
   return parsed;
 }
 
+function resolveVariableOptionValues(variable: MetricVariable) {
+  if (!variable.optionsQuery) return variable.options ?? [];
+  assertSelectOnlyQuery(variable.optionsQuery.sql);
+  const result = executeReadOnlyQuery(variable.optionsQuery.sql, [], HARD_METRIC_MAX_ROWS);
+  return result.rows.map((row) => {
+    const record = Object.fromEntries(
+      result.columns.map((column, index) => [column, row[index] as MetricParam]),
+    );
+    const value = record[variable.optionsQuery!.valueKey];
+    const labelKey = variable.optionsQuery!.labelKey ?? variable.optionsQuery!.valueKey;
+    const label = record[labelKey] ?? value;
+    return {
+      label: label == null ? "" : String(label),
+      value: value == null ? null : value,
+    };
+  });
+}
+
+function resolveVariableOptions(metric: Metric) {
+  const optionsByKey: Record<string, Array<{ label: string; value: MetricParam }>> = {};
+  const variables = (metric.definition.variables ?? []).map((variable) => {
+    if (!variable.optionsQuery) {
+      return variable;
+    }
+    const options = resolveVariableOptionValues(variable);
+    optionsByKey[variable.key] = options;
+    return { ...variable, options };
+  });
+  return { variables, optionsByKey };
+}
+
 function coerceVariableValue(variable: MetricVariable, raw: unknown): MetricParam {
   if (raw == null || raw === "") {
     return variable.defaultValue ?? null;
@@ -71,12 +107,21 @@ function coerceVariableValue(variable: MetricVariable, raw: unknown): MetricPara
   return String(raw);
 }
 
-function resolveMetricVariables(metric: Metric, provided: Record<string, unknown>) {
+function resolveMetricVariables(
+  metric: Metric,
+  provided: Record<string, unknown>,
+  dynamicOptionsByKey: Record<string, Array<{ label: string; value: MetricParam }>> = {},
+) {
   const values: Record<string, MetricParam> = {};
   for (const variable of metric.definition.variables ?? []) {
-    const value = coerceVariableValue(variable, provided[variable.key]);
-    if (variable.options?.length) {
-      const allowed = variable.options.some((option) => option.value === value);
+    const options = dynamicOptionsByKey[variable.key] ?? variable.options;
+    const raw = provided[variable.key];
+    const value =
+      (raw == null || raw === "") && variable.defaultValue === undefined && options?.length
+        ? options[0]!.value
+        : coerceVariableValue(variable, raw);
+    if (options?.length) {
+      const allowed = options.some((option) => option.value === value);
       if (!allowed) {
         throw new Error(`Metric variable "${variable.key}" must match one of its options`);
       }
@@ -125,10 +170,14 @@ function runMetricWidget(widget: MetricWidget, variables: Record<string, MetricP
 }
 
 function runMetric(metric: Metric, providedVariables: Record<string, unknown> = {}) {
-  const variables = resolveMetricVariables(metric, providedVariables);
+  const resolved = resolveVariableOptions(metric);
+  const variables = resolveMetricVariables(metric, providedVariables, resolved.optionsByKey);
   const widgets = metric.definition.widgets.map((widget) => runMetricWidget(widget, variables));
   return {
-    metric,
+    metric: {
+      ...metric,
+      definition: { ...metric.definition, variables: resolved.variables },
+    },
     variables,
     widgets,
     // Kept as the first widget result for older callers during the PR cycle.

package/src/http/schedules.ts

@@ -12,9 +12,8 @@ import {
   updateScheduledTask,
 } from "../be/db";
 import { mergeScheduleTiming, validateRecurringTiming } from "../be/schedules/validate";
-import { calculateNextRun } from "../scheduler/scheduler";
-import { scheduleContextKey } from "../tasks/context-key";
-import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
+import { calculateNextRun, createStandaloneScheduleTask } from "../scheduler/scheduler";
 import { getExecutorRegistry } from "../workflows";
 import { handleScheduleTrigger } from "../workflows/triggers";
 import { route } from "./route-def";
@@ -41,6 +40,7 @@ const createSchedule = route({
     enabled: z.boolean().optional(),
     timezone: z.string().optional(),
     model: z.string().optional(),
+    modelTier: ModelTierSchema.optional(),
     scheduleType: z.enum(["recurring", "one_time"]).optional(),
     delayMs: z.number().int().optional(),
     runAt: z.string().optional(),
@@ -126,6 +126,7 @@ const updateSchedule = route({
     enabled: z.boolean().optional(),
     timezone: z.string().optional(),
     model: z.string().optional(),
+    modelTier: ModelTierSchema.nullable().optional(),
     nextRunAt: z.string().nullable().optional(),
   }),
   responses: {
@@ -270,7 +271,7 @@ export async function handleSchedules(
         enabled: body.enabled,
         nextRunAt,
         timezone: body.timezone,
-        model: body.model,
+        ...splitLegacyModelAlias({ model: body.model, modelTier: body.modelTier }),
         scheduleType: body.scheduleType,
       });
 
@@ -333,17 +334,7 @@ export async function handleSchedules(
       const now = new Date().toISOString();
 
       const task = getDb().transaction(() => {
-        const createdTask = createTaskWithSiblingAwareness(schedule.taskTemplate, {
-          creatorAgentId: schedule.createdByAgentId,
-          taskType: schedule.taskType,
-          tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "manual-run"],
-          priority: schedule.priority,
-          agentId: schedule.targetAgentId,
-          model: schedule.model,
-          scheduleId: schedule.id,
-          source: "schedule",
-          contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-        });
+        const createdTask = createStandaloneScheduleTask(schedule, ["manual-run"]);
 
         if (schedule.scheduleType === "one_time") {
           updateScheduledTask(schedule.id, {
@@ -388,6 +379,16 @@ export async function handleSchedules(
     const parsed = await updateSchedule.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
     const body = parsed.body as Record<string, unknown>;
+    if (parsed.body.model !== undefined || parsed.body.modelTier !== undefined) {
+      const normalizedModel = splitLegacyModelAlias({
+        model: parsed.body.model,
+        modelTier: parsed.body.modelTier,
+      });
+      if (parsed.body.model !== undefined) body.model = normalizedModel.model ?? null;
+      if (parsed.body.modelTier !== undefined || normalizedModel.modelTier) {
+        body.modelTier = normalizedModel.modelTier ?? null;
+      }
+    }
 
     const existing = getScheduledTaskById(parsed.params.id);
     if (!existing) {

package/src/http/script-runs.ts

@@ -51,6 +51,7 @@ const createScriptRunBodySchema = z.object({
 const listScriptRunsQuerySchema = z.object({
   status: ScriptRunStatusSchema.optional(),
   agentId: z.string().optional(),
+  scriptName: z.string().optional(),
   limit: z.coerce.number().int().min(1).max(500).optional(),
   offset: z.coerce.number().int().min(0).optional(),
 });
@@ -367,12 +368,17 @@ export async function handleScriptRuns(
     const opts = {
       status: parsed.query.status,
       agentId: parsed.query.agentId,
+      scriptName: parsed.query.scriptName,
       limit: parsed.query.limit ?? 50,
       offset: parsed.query.offset ?? 0,
     };
     json(res, {
       runs: listScriptRuns(opts),
-      total: countScriptRuns({ status: opts.status, agentId: opts.agentId }),
+      total: countScriptRuns({
+        status: opts.status,
+        agentId: opts.agentId,
+        scriptName: opts.scriptName,
+      }),
     });
     return true;
   }

package/src/http/scripts.ts

@@ -2,14 +2,23 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import { getAgentById, recordInlineScriptRun, upsertKv } from "../be/db";
 import { createEvent } from "../be/events";
-import { deleteScript, getScript, upsertScriptByName } from "../be/scripts/db";
+import {
+  deleteScript,
+  getScript,
+  getScriptById,
+  listScripts,
+  listScriptVersions,
+  upsertScriptByName,
+} from "../be/scripts/db";
 import { searchScripts } from "../be/scripts/embeddings";
 import { extractArgsJsonSchema } from "../be/scripts/extract-schema";
 import { SCRIPT_SDK_TYPES, SCRIPT_STDLIB_TYPES, typecheckScript } from "../be/scripts/typecheck";
 import { extractScriptSignature } from "../scripts-runtime/extract-signature";
 import { runScript } from "../scripts-runtime/loader";
 import {
+  type ScriptDetail,
   ScriptFsModeSchema,
+  type ScriptListItem,
   type ScriptRecord,
   type ScriptScope,
   ScriptScopeSchema,
@@ -52,6 +61,11 @@ const searchBodySchema = z.object({
 const nameParamsSchema = z.object({ name: scriptNameSchema });
 const scopeQuerySchema = z.object({ scope: ScriptScopeSchema.default("agent") });
 const optionalScopeQuerySchema = z.object({ scope: ScriptScopeSchema.optional() });
+const idParamsSchema = z.object({ id: z.string().uuid() });
+const listScriptsQuerySchema = z.object({
+  scope: ScriptScopeSchema.optional(),
+  includeScratch: z.enum(["true", "false"]).optional(),
+});
 
 const upsertRoute = route({
   method: "post",
@@ -133,6 +147,74 @@ const typesRoute = route({
   },
 });
 
+// ── Dashboard read routes ──
+// The worker-facing routes above resolve scripts relative to the calling agent
+// and therefore requireAgent (X-Agent-ID). The routes below are cross-scope
+// admin reads for the dashboard: API-key auth only, no agent identity — the
+// same model as /api/script-runs.
+
+const listScriptsRoute = route({
+  method: "get",
+  path: "/api/scripts",
+  pattern: ["api", "scripts"],
+  operationId: "scripts_list",
+  summary: "List saved scripts",
+  description:
+    "Dashboard read: lean projection without source. Scratch scripts are excluded unless includeScratch=true.",
+  tags: ["Scripts"],
+  query: listScriptsQuerySchema,
+  responses: {
+    200: { description: "Saved scripts" },
+    400: { description: "Validation error" },
+  },
+});
+
+// Declared (and matched) BEFORE the by-id route: the by-id pattern
+// ["api", "scripts", null] matches any single segment, so the literal
+// "type-defs" segment must win first.
+const typeDefsRoute = route({
+  method: "get",
+  path: "/api/scripts/type-defs",
+  pattern: ["api", "scripts", "type-defs"],
+  operationId: "scripts_type_defs",
+  summary: "Get script SDK and stdlib type definitions",
+  description: "Static .d.ts blobs for editor integration (e.g. Monaco extraLibs). Cacheable.",
+  tags: ["Scripts"],
+  responses: {
+    200: { description: "SDK and stdlib type definition blobs" },
+  },
+});
+
+const getScriptByIdRoute = route({
+  method: "get",
+  path: "/api/scripts/{id}",
+  pattern: ["api", "scripts", null],
+  operationId: "scripts_get",
+  summary: "Get a saved script by id",
+  description: "Dashboard read: full record including source and parsed signature.",
+  tags: ["Scripts"],
+  params: idParamsSchema,
+  responses: {
+    200: { description: "Script detail" },
+    404: { description: "Script not found" },
+  },
+});
+
+const listVersionsRoute = route({
+  method: "get",
+  path: "/api/scripts/{id}/versions",
+  pattern: ["api", "scripts", null, "versions"],
+  operationId: "scripts_versions",
+  summary: "List versions of a saved script",
+  description: "Dashboard read: version history, newest first.",
+  tags: ["Scripts"],
+  params: idParamsSchema,
+  responses: {
+    200: { description: "Script versions" },
+    404: { description: "Script not found" },
+  },
+});
+
 function requireAgent(res: ServerResponse, agentId: string | undefined) {
   if (!agentId) {
     jsonError(res, "X-Agent-ID required for scripts API", 400);
@@ -413,6 +495,70 @@ export async function handleScripts(
     return true;
   }
 
+  // ── Dashboard reads (no requireAgent — API-key auth only, like /api/script-runs) ──
+
+  if (listScriptsRoute.match(req.method, pathSegments)) {
+    const parsed = await listScriptsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const scripts: ScriptListItem[] = listScripts({
+      scope: parsed.query.scope,
+      includeScratch: parsed.query.includeScratch === "true",
+    }).map((script) => ({
+      id: script.id,
+      name: script.name,
+      scope: script.scope,
+      scopeId: script.scopeId,
+      description: script.description,
+      intent: script.intent,
+      version: script.version,
+      isScratch: script.isScratch,
+      typeChecked: script.typeChecked,
+      fsMode: script.fsMode,
+      createdByAgentId: script.createdByAgentId,
+      createdAt: script.createdAt,
+      updatedAt: script.updatedAt,
+    }));
+    json(res, { scripts });
+    return true;
+  }
+
+  // Must be matched before getScriptByIdRoute — its ["api", "scripts", null]
+  // pattern would otherwise swallow the literal "type-defs" segment.
+  if (typeDefsRoute.match(req.method, pathSegments)) {
+    json(res, { sdkTypes: SCRIPT_SDK_TYPES, stdlibTypes: SCRIPT_STDLIB_TYPES });
+    return true;
+  }
+
+  if (getScriptByIdRoute.match(req.method, pathSegments)) {
+    const parsed = await getScriptByIdRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const script = getScriptById(parsed.params.id);
+    if (!script) {
+      jsonError(res, "Script not found", 404);
+      return true;
+    }
+    // `source` is author-supplied TS (same trust surface as script_runs.source,
+    // already served raw by GET /api/script-runs/{id}) — no env/secret material.
+    const detail: ScriptDetail = {
+      ...script,
+      signature: JSON.parse(script.signatureJson) as unknown,
+      argsJsonSchema: script.argsJsonSchema ? (JSON.parse(script.argsJsonSchema) as unknown) : null,
+    };
+    json(res, { script: detail });
+    return true;
+  }
+
+  if (listVersionsRoute.match(req.method, pathSegments)) {
+    const parsed = await listVersionsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!getScriptById(parsed.params.id)) {
+      jsonError(res, "Script not found", 404);
+      return true;
+    }
+    json(res, { versions: listScriptVersions(parsed.params.id) });
+    return true;
+  }
+
   if (typesRoute.match(req.method, pathSegments)) {
     const parsed = await typesRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/http/tasks.ts

@@ -23,6 +23,7 @@ import {
   updateTaskProgress,
   updateTaskVcs,
 } from "../be/db";
+import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { createResumeFollowUp, createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 import { telemetry } from "../telemetry";
@@ -91,6 +92,8 @@ const createTask = route({
     outputSchema: z.record(z.string(), z.unknown()).optional(),
     contextKey: z.string().optional(),
     requestedByUserId: z.string().optional(),
+    model: z.string().optional(),
+    modelTier: ModelTierSchema.optional(),
   }),
   responses: {
     201: { description: "Task created" },
@@ -98,11 +101,11 @@ const createTask = route({
   },
 });
 
-const updateClaudeSession = route({
+const updateSession = route({
   method: "put",
-  path: "/api/tasks/{id}/claude-session",
-  pattern: ["api", "tasks", null, "claude-session"],
-  summary: "Update Claude session ID for a task",
+  path: "/api/tasks/{id}/session",
+  pattern: ["api", "tasks", null, "session"],
+  summary: "Update provider session ID and harness metadata for a task",
   tags: ["Tasks"],
   params: z.object({ id: z.string() }),
   body: z.union([
@@ -121,6 +124,8 @@ const updateClaudeSession = route({
       provider: ProviderNameSchema.exclude(["devin"]).optional(),
       model: z.string().optional(),
       providerMeta: z.object({}).optional(),
+      harnessVariant: z.string().optional(),
+      harnessVariantMeta: z.record(z.string(), z.unknown()).optional(),
     }),
   ]),
   responses: {
@@ -393,6 +398,10 @@ export async function handleTasks(
         outputSchema: parsed.body.outputSchema || undefined,
         contextKey: parsed.body.contextKey || undefined,
         requestedByUserId,
+        ...splitLegacyModelAlias({
+          model: parsed.body.model,
+          modelTier: parsed.body.modelTier,
+        }),
       });
 
       ensure({
@@ -427,8 +436,8 @@ export async function handleTasks(
     return true;
   }
 
-  if (updateClaudeSession.match(req.method, pathSegments)) {
-    const parsed = await updateClaudeSession.parse(req, res, pathSegments, queryParams);
+  if (updateSession.match(req.method, pathSegments)) {
+    const parsed = await updateSession.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
     const task = updateTaskClaudeSessionId(
       parsed.params.id,
@@ -436,6 +445,8 @@ export async function handleTasks(
       parsed.body.provider,
       parsed.body.providerMeta,
       parsed.body.model,
+      "harnessVariant" in parsed.body ? parsed.body.harnessVariant : undefined,
+      "harnessVariantMeta" in parsed.body ? parsed.body.harnessVariantMeta : undefined,
     );
     if (!task) {
       jsonError(res, "Task not found", 404);