@desplega.ai/agent-swarm 2.4.0 → 2.4.1

package/src/http/apps.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import * as z from "zod";
 import type { AppActionCaller } from "../apps/action-caller";
+import { runAppAction } from "../apps/action-runner";
 import {
   type AppDefinition,
   AppNameSchema,
@@ -61,14 +62,9 @@ import {
   rollbackApp,
   snapshotApp,
 } from "../apps/version";
-import { normalizeAssetKey } from "../assets/key";
-import { getAgentById, getAppVersion, getAppVersions, getLeadAgent } from "../be/db";
-import { getScriptById } from "../be/scripts/db";
-import { getSavedScriptOwnerAgentId, runSavedScriptAsAgent } from "../be/scripts/run-saved";
-import { resolveTemplate } from "../prompts/resolver";
+import { getAgentById, getAppVersion, getAppVersions } from "../be/db";
 import type { RbacPrincipal, RbacResource } from "../rbac";
 import { can } from "../rbac";
-import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { AgentTaskStatusSchema } from "../types";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { scrubObject } from "../utils/secret-scrubber";
@@ -77,8 +73,8 @@ import { route } from "./route-def";
 import { BODY_TOO_LARGE, enforceContentLengthCap, json, jsonError } from "./utils";
 
 const MAX_APP_BODY_BYTES = 5 * 1024 * 1024;
-const MAX_APP_ROW_BODY_BYTES = 1 * 1024 * 1024;
-const MAX_APP_BULK_ROWS_BODY_BYTES = 10 * 1024 * 1024;
+export const MAX_APP_ROW_BODY_BYTES = 1 * 1024 * 1024;
+export const MAX_APP_BULK_ROWS_BODY_BYTES = 10 * 1024 * 1024;
 const MAX_USER_CONFIG_BODY_BYTES = 64 * 1024;
 const MAX_USER_CONFIG_VALUES_BYTES = 16 * 1024;
 const DECIMAL_NUMBER_PATTERN = /^[+-]?\d+(?:\.\d+)?$/;
@@ -756,17 +752,6 @@ function definitionNeedsRepair(
   return true;
 }
 
-/**
- * One `error` string for a sync result, or undefined when every pass succeeded.
- * Each failed pair is named so a multi-pair sync says which one broke; the pass
- * list in `result.passes` carries the rest.
- */
-function syncPassError(sync: Awaited<ReturnType<typeof runAppSync>>): string | undefined {
-  const failed = sync.passes.filter((pass) => pass.error !== undefined);
-  if (failed.length === 0) return undefined;
-  return failed.map((pass) => `${pass.model}.${pass.source}: ${pass.error}`).join("; ");
-}
-
 function snapshotFailure(res: ServerResponse): void {
   jsonError(res, "failed to snapshot app", 500);
 }
@@ -991,6 +976,10 @@ function rowValue(row: AppRow, column: string): unknown {
   return Object.hasOwn(row, column) ? row[column] : undefined;
 }
 
+export function rowMatchesFilters(row: AppRow, filters: RowFilter[]): boolean {
+  return filters.every((filter) => rowValue(row, filter.column) === filter.value);
+}
+
 export function applyQuery(
   rows: AppRow[],
   query: AppQueryDef,
@@ -1019,6 +1008,59 @@ export function applyQuery(
   return selected.slice(0, query.limit ?? 200);
 }
 
+export async function selectAppRows(
+  appId: string,
+  modelName: string,
+  model: ModelDef,
+  filters: RowFilter[],
+  sortRaw?: string,
+  limit = 200,
+  systemColumns = false,
+) {
+  // SQL narrows the scan; the `===` re-check keeps the exact filter semantics.
+  const rows = (
+    await listAppRows(
+      appId,
+      modelName,
+      filters.flatMap((filter) =>
+        typeof filter.value === "string" ||
+        typeof filter.value === "number" ||
+        typeof filter.value === "boolean"
+          ? [{ column: filter.column, value: filter.value }]
+          : [],
+      ),
+    )
+  ).filter((row) => rowMatchesFilters(row, filters));
+
+  if (sortRaw) {
+    const [column, dir, extra] = sortRaw.split(":");
+    if (
+      extra !== undefined ||
+      !column ||
+      (dir !== "asc" && dir !== "desc") ||
+      (!SORTABLE_SYSTEM_DATE_COLUMNS.has(column) &&
+        !(systemColumns && Object.hasOwn(SYSTEM_COLUMN_KINDS, column)) &&
+        (!Object.hasOwn(model.columns, column) || model.columns[column]!.hidden === true))
+    ) {
+      throw new AppRowValidationError([
+        { path: "sort", message: "must be <column>:<asc|desc> for a known column" },
+      ]);
+    }
+    rows.sort((a, b) => {
+      const result = compareValues(
+        rowValue(a, column),
+        rowValue(b, column),
+        dir,
+        SORTABLE_SYSTEM_DATE_COLUMNS.has(column) ||
+          (Object.hasOwn(model.columns, column) && model.columns[column]!.kind === "date"),
+      );
+      return result;
+    });
+  }
+  const total = rows.length;
+  return { rows: rows.slice(0, limit), total };
+}
+
 export async function handleApps(
   req: IncomingMessage,
   res: ServerResponse,
@@ -1189,55 +1231,23 @@ export async function handleApps(
       json(res, { error: "invalid row query", issues }, 400);
       return true;
     }
-    // SQL narrows the scan; the `===` re-check keeps the exact filter semantics.
-    const rows = (
-      await listAppRows(
-        parsed.params.id,
-        parsed.params.model,
-        filters.flatMap((filter) =>
-          typeof filter.value === "string" ||
-          typeof filter.value === "number" ||
-          typeof filter.value === "boolean"
-            ? [{ column: filter.column, value: filter.value }]
-            : [],
+    try {
+      listRowsRoute.respond(
+        res,
+        200,
+        await selectAppRows(
+          parsed.params.id,
+          parsed.params.model,
+          resolved.model,
+          filters,
+          parsed.query.sort,
+          parsed.query.limit,
         ),
-      )
-    ).filter((row) => filters.every((filter) => rowValue(row, filter.column) === filter.value));
-    const sortRaw = parsed.query.sort;
-    if (sortRaw) {
-      const [column, dir, extra] = sortRaw.split(":");
-      if (
-        extra !== undefined ||
-        !column ||
-        (dir !== "asc" && dir !== "desc") ||
-        (!SORTABLE_SYSTEM_DATE_COLUMNS.has(column) &&
-          (!Object.hasOwn(resolved.model.columns, column) ||
-            resolved.model.columns[column]!.hidden === true))
-      ) {
-        json(
-          res,
-          {
-            error: "invalid sort",
-            issues: [{ path: "sort", message: "must be <column>:<asc|desc> for a known column" }],
-          },
-          400,
-        );
-        return true;
-      }
-      rows.sort((a, b) => {
-        const result = compareValues(
-          rowValue(a, column),
-          rowValue(b, column),
-          dir,
-          SORTABLE_SYSTEM_DATE_COLUMNS.has(column) ||
-            (Object.hasOwn(resolved.model.columns, column) &&
-              resolved.model.columns[column]!.kind === "date"),
-        );
-        return result;
-      });
+      );
+    } catch (error) {
+      if (!(error instanceof AppRowValidationError)) throw error;
+      json(res, { error: "invalid sort", issues: error.issues }, 400);
     }
-    const total = rows.length;
-    listRowsRoute.respond(res, 200, { rows: rows.slice(0, parsed.query.limit ?? 200), total });
     return true;
   }
 
@@ -1359,122 +1369,15 @@ export async function handleApps(
       return true;
     }
     if (definitionNeedsRepair(res, app)) return true;
-    const actions = app.definition.actions;
-    if (!actions || !Object.hasOwn(actions, parsed.params.name)) {
-      jsonError(res, "app action not found", 404);
-      return true;
-    }
-
-    const action = actions[parsed.params.name]!;
-    const input = parsed.body.input ?? {};
-    if (action.kind === "script") {
-      const script = await getScriptById(action.scriptId);
-      if (!script) {
-        json(
-          res,
-          {
-            error: "invalid app action",
-            issues: [
-              {
-                path: `actions.${parsed.params.name}.scriptId`,
-                message: `script "${action.scriptId}" no longer exists`,
-              },
-            ],
-          },
-          400,
-        );
-        return true;
-      }
-
-      // Script actions run with the OWNER's bindings by design: wiring a script
-      // into an app is the owner's delegation. parseAppDefinition enforces at
-      // write time that an agent may only wire scripts it owns (or global ones),
-      // so a foreign script id cannot be smuggled in here. Invoker-brokered
-      // credentials remain a possible future tightening.
-      const runAsAgentId = getSavedScriptOwnerAgentId(script);
-      if (!runAsAgentId) {
-        jsonError(res, "agentId is required: this script has no owning agent to run as", 400);
-        return true;
-      }
-
-      const output = await runSavedScriptAsAgent({
-        script,
-        input: { ...action.args, ...input, app: { id: app.id }, caller },
-        agentId: runAsAgentId,
-      });
-      const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
-      const error = ok
-        ? undefined
-        : output.runtimeError
-          ? `${output.runtimeError.name}: ${output.runtimeError.message}`
-          : (output.error ?? `Script exited with code ${output.exitCode}`);
-      runActionRoute.respond(
-        res,
-        200,
-        scrubObject({
-          ok,
-          result: output.result,
-          stdout: output.stdout,
-          ...(error === undefined ? {} : { error }),
-          durationMs: output.durationMs,
-        }),
-      );
-      return true;
-    }
-
-    if (action.kind === "sync") {
-      const startedAt = Date.now();
-      const sync = await runAppSync({
-        appId: app.id,
-        ...(action.model === undefined ? {} : { model: action.model }),
-        ...(action.source === undefined ? {} : { source: action.source }),
-        invokedBy: actor,
-      });
-      const durationMs = Date.now() - startedAt;
-      if (sync.issues && sync.issues.length > 0) {
-        json(res, { error: "invalid sync action", issues: sync.issues }, 400);
-        return true;
-      }
-      // Deliberately the SCRIPT-action response shape, minus `taskId`:
-      // app-surface.tsx branches on `taskId` first, so omitting it gives the
-      // dashboard running -> ok/error + refetchAll() with zero UI changes.
-      const error = syncPassError(sync);
-      runActionRoute.respond(
-        res,
-        200,
-        scrubObject({
-          ok: sync.ok,
-          result: { passes: sync.passes },
-          ...(error === undefined ? {} : { error }),
-          durationMs,
-        }),
-      );
-      return true;
-    }
-
-    const lead = action.agentId ? null : await getLeadAgent();
-    const taskPrompt = resolveTemplate("task.app.action", {
-      prompt: action.prompt,
-      app_id: app.id,
-      action_name: parsed.params.name,
-      input_json: JSON.stringify(input),
-      caller_json: JSON.stringify(caller),
+    const output = await runAppAction({
+      app,
+      name: parsed.params.name,
+      input: parsed.body.input,
+      caller,
+      actor,
     });
-    const task = await createTaskWithSiblingAwareness(
-      taskPrompt.text,
-      {
-        source: "api",
-        agentId: action.agentId ?? lead?.id,
-        routingReason: action.agentId ? "human_pinned" : lead ? "skill" : undefined,
-        routingSource: action.agentId || lead ? "engine_default" : undefined,
-        // App-spawned tasks group under the app's asset namespace so a
-        // swarm-tasks source can pull them back via config.assetKey.
-        key: normalizeAssetKey(`shared/app:${app.id}/action:${parsed.params.name}/`),
-        ...(actor.startsWith("user:") ? { requestedByUserId: actor.slice("user:".length) } : {}),
-      },
-      { origin: "app" },
-    );
-    runActionRoute.respond(res, 200, { ok: true, taskId: task.id, status: task.status });
+    if (output.status === 200) runActionRoute.respond(res, 200, output.body);
+    else json(res, output.body, output.status);
     return true;
   }
 

package/src/http/fleet-benchmark.ts

@@ -1,6 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import { getSwarmConfigs } from "../be/db";
 import { getLocalFleetStats } from "../be/fleet-benchmark-stats";
 import {
   compareWithFleet,
@@ -12,6 +11,9 @@ import {
   localTasksPerWeek,
 } from "../fleet-benchmark";
 import { isTelemetryEnabled } from "../telemetry";
+import { COMPANY_TEAM_SIZES, COMPANY_USE_CASES } from "../utils/company-profile";
+import { normalizeOrgWebsite } from "../utils/org-website";
+import { globalConfig } from "./global-config";
 import { rejectGuest } from "./request-principal";
 import { route } from "./route-def";
 import { telemetryProxyEndpoint } from "./used-by";
@@ -34,6 +36,14 @@ const FleetStateSchema = z.enum([
 
 const FleetBenchmarkResponseSchema = z.object({
   state: FleetStateSchema,
+  level: z.enum(["basic", "full"]),
+  peerGroup: z
+    .object({
+      teamSize: z.string().nullable(),
+      useCase: z.string().nullable(),
+      orgs: z.number().int(),
+    })
+    .nullable(),
   local: z
     .object({
       tasksPerWeek: z.number(),
@@ -67,7 +77,7 @@ const fleetBenchmark = route({
   pattern: ["api", "fleet-benchmark"],
   summary: "Compare this swarm with similar swarms",
   description:
-    "Places this swarm's tasks per week and task success rate (last 30 days) in the fleet percentiles published by the telemetry proxy, against swarms with the same agent count when enough exist. Needs telemetry on and an organization name; otherwise `state` says what is missing and the proxy is not called. `unavailable` also covers an install whose first event the proxy saw cannot be established locally (until 30 days after the first accepted event). The fleet numbers are cached for a day.",
+    "Compares local task volume and success rate with fleet percentiles over the last 30 days. Comparisons require telemetry, an organization name, and a known proxy ingest date. A website, team size, and use case enable full comparisons with peer filters. The response includes the proxy's peer group when available. With telemetry off, it returns local DB counts without a proxy request. The fleet cache key includes the peer filters.",
   tags: ["Telemetry"],
   responses: {
     200: {
@@ -81,8 +91,12 @@ const fleetBenchmark = route({
 
 // ─── Caches ──────────────────────────────────────────────────────────────────
 
-let fleetCache: { value: FleetBenchmarks | null; until: number } | null = null;
-let localCache: { value: LocalFleetStats | null; until: number } | null = null;
+let fleetCache: { key: string; value: ProxyFleetBenchmarks | null; until: number } | null = null;
+let localCache: {
+  requireIngestAnchor: boolean;
+  value: LocalFleetStats | null;
+  until: number;
+} | null = null;
 
 const ProxyMetricSchema = z.object({
   n: z.number(),
@@ -112,19 +126,34 @@ const ProxyFleetBenchmarksSchema = z.object({
     "2-5": ProxyBlockSchema.optional(),
     "6+": ProxyBlockSchema.optional(),
   }),
+  peer_group: z
+    .object({
+      team_size: z.string().nullable(),
+      use_case: z.string().nullable(),
+      orgs: z.number().int().nonnegative(),
+    })
+    .nullable()
+    .optional(),
 }) satisfies z.ZodType<FleetBenchmarks>;
 
+type ProxyFleetBenchmarks = z.infer<typeof ProxyFleetBenchmarksSchema>;
+
 /** The proxy's fleet percentiles. The request carries no install ID. */
-async function fleetBenchmarks(now: number): Promise<FleetBenchmarks | null> {
-  if (fleetCache && fleetCache.until > now) return fleetCache.value;
-  let value: FleetBenchmarks | null = null;
+async function fleetBenchmarks(
+  now: number,
+  peerGroup: { teamSize: string; useCase: string } | null,
+): Promise<ProxyFleetBenchmarks | null> {
+  const endpoint = new URL(await telemetryProxyEndpoint("/v1/fleet/benchmarks"));
+  endpoint.searchParams.set("window", "30d");
+  if (peerGroup) {
+    endpoint.searchParams.set("team_size", peerGroup.teamSize);
+    endpoint.searchParams.set("use_case", peerGroup.useCase);
+  }
+  const key = endpoint.toString();
+  if (fleetCache?.key === key && fleetCache.until > now) return fleetCache.value;
+  let value: ProxyFleetBenchmarks | null = null;
   try {
-    const response = await fetch(
-      `${await telemetryProxyEndpoint("/v1/fleet/benchmarks")}?window=30d`,
-      {
-        signal: AbortSignal.timeout(TIMEOUT_MS),
-      },
-    );
+    const response = await fetch(key, { signal: AbortSignal.timeout(TIMEOUT_MS) });
     if (response.ok) {
       const parsed = ProxyFleetBenchmarksSchema.safeParse(await response.json());
       if (parsed.success) value = parsed.data;
@@ -132,38 +161,46 @@ async function fleetBenchmarks(now: number): Promise<FleetBenchmarks | null> {
   } catch {
     // Unreachable proxy: the card says the comparison is unavailable.
   }
-  fleetCache = { value, until: now + (value ? FLEET_TTL_MS : FLEET_FAILURE_TTL_MS) };
+  fleetCache = { key, value, until: now + (value ? FLEET_TTL_MS : FLEET_FAILURE_TTL_MS) };
   return value;
 }
 
-async function localStats(now: Date): Promise<LocalFleetStats | null> {
-  if (localCache && localCache.until > now.getTime()) return localCache.value;
-  const value = await getLocalFleetStats(now);
-  localCache = { value, until: now.getTime() + LOCAL_TTL_MS };
+async function localStats(now: Date, requireIngestAnchor = true): Promise<LocalFleetStats | null> {
+  if (localCache?.requireIngestAnchor === requireIngestAnchor && localCache.until > now.getTime())
+    return localCache.value;
+  const value = await getLocalFleetStats(now, { requireIngestAnchor });
+  localCache = { requireIngestAnchor, value, until: now.getTime() + LOCAL_TTL_MS };
   return value;
 }
 
-async function orgName(): Promise<string | undefined> {
-  const stored = (
-    await getSwarmConfigs({ scope: "global", key: "SWARM_ORG_NAME" })
-  )?.[0]?.value?.trim();
-  return stored || process.env.SWARM_ORG_NAME?.trim() || undefined;
-}
-
 export async function buildFleetBenchmarkResponse(
   now = new Date(),
 ): Promise<FleetBenchmarkResponse> {
+  const [name, website, teamSize, useCase] = await Promise.all([
+    globalConfig("SWARM_ORG_NAME"),
+    globalConfig("SWARM_ORG_WEBSITE"),
+    globalConfig("SWARM_ORG_TEAM_SIZE"),
+    globalConfig("SWARM_ORG_USE_CASE"),
+  ]);
+  const team = z.enum(COMPANY_TEAM_SIZES).safeParse(teamSize);
+  const use = z.enum(COMPANY_USE_CASES).safeParse(useCase);
+  const peerGroup =
+    normalizeOrgWebsite(website) && team.success && use.success
+      ? { teamSize: team.data, useCase: use.data }
+      : null;
   const empty = {
+    level: peerGroup ? ("full" as const) : ("basic" as const),
+    peerGroup: null,
     local: null,
     minFinishedTasks: FLEET_MIN_FINISHED_TASKS,
     generatedAt: null,
     comparisons: [],
   };
   // Telemetry off means no call to our proxy at all, not even an anonymous one.
-  if (!isTelemetryEnabled()) return { state: "telemetry_off", ...empty };
-  if (!(await orgName())) return { state: "no_org_name", ...empty };
+  const telemetryEnabled = isTelemetryEnabled();
+  if (telemetryEnabled && !name) return { state: "no_org_name", ...empty };
 
-  const stats = await localStats(now);
+  const stats = await localStats(now, telemetryEnabled);
   // Where the proxy started counting this install is unknown: no comparison.
   if (!stats) return { state: "unavailable", ...empty };
   const finishedTasks = stats.tasksCompleted + stats.tasksFailed;
@@ -174,14 +211,26 @@ export async function buildFleetBenchmarkResponse(
     agents: stats.agents,
     bucket: fleetBucketFor(stats.agents),
   };
+  if (!telemetryEnabled) return { ...empty, state: "telemetry_off", local };
   if (finishedTasks < FLEET_MIN_FINISHED_TASKS)
     return { ...empty, state: "not_enough_tasks", local };
 
-  const fleet = await fleetBenchmarks(now.getTime());
+  const fleet = await fleetBenchmarks(now.getTime(), peerGroup);
+  const responsePeerGroup =
+    peerGroup && fleet?.peer_group
+      ? {
+          teamSize: fleet.peer_group.team_size,
+          useCase: fleet.peer_group.use_case,
+          orgs: fleet.peer_group.orgs,
+        }
+      : null;
   const comparisons = fleet ? compareWithFleet(stats, fleet, now) : [];
-  if (!fleet || comparisons.length === 0) return { ...empty, state: "unavailable", local };
+  if (!fleet || comparisons.length === 0)
+    return { ...empty, state: "unavailable", local, peerGroup: responsePeerGroup };
   return {
+    ...empty,
     state: "ready",
+    peerGroup: responsePeerGroup,
     local,
     minFinishedTasks: FLEET_MIN_FINISHED_TASKS,
     generatedAt: fleet.generatedAt,

package/src/http/global-config.ts

@@ -0,0 +1,7 @@
+import { getSwarmConfigs } from "../be/db";
+
+/** Stored values, including empty strings, override env values, as on config reload. */
+export async function globalConfig(key: string): Promise<string | undefined> {
+  const stored = (await getSwarmConfigs({ scope: "global", key }))?.[0]?.value;
+  return (stored ?? process.env[key])?.trim() || undefined;
+}