@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/src/commands/runner.ts

@@ -610,7 +610,11 @@ async function pollAndStartSteeringDispatches(
       prepared.push(item);
       item.text =
         session.deliverSteering && !state.outcomes.has(message.id)
-          ? await renderSteeringDelivery(message.id, message.body)
+          ? await renderSteeringDelivery(
+              message.id,
+              message.body,
+              message.senderLabel ?? message.createdByKind,
+            )
           : undefined;
     }
   } catch (error) {
@@ -765,6 +769,9 @@ export interface ResolvedEnvResult {
   resolvedProvider: ProviderName;
 }
 
+// Preserve the deployment value before config reloads mutate process.env.
+const deploymentMemoryRaters = process.env.MEMORY_RATERS;
+
 export async function fetchResolvedEnv(
   apiUrl: string,
   apiKey: string,
@@ -792,6 +799,12 @@ export async function fetchResolvedEnv(
           configs: Array<{ key: string; value: string }>;
         };
 
+        // A deleted row restores the deployment value (including unset), while
+        // an explicit empty row below remains the disable-all-raters override.
+        // Only reset after a successful fetch so outages retain the current value.
+        env.MEMORY_RATERS =
+          baseEnv === process.env ? deploymentMemoryRaters : baseEnv.MEMORY_RATERS;
+
         if (data.configs?.length) {
           scriptsOnlyConfigValue = data.configs.find(
             (config) => config.key === "SCRIPTS_ONLY_MCP",
@@ -1060,7 +1073,10 @@ export function applyResolvedEnvToProcessEnv(
   const changed: string[] = [];
   for (const key of RELOADABLE_ENV_KEYS) {
     const next = freshEnv[key];
-    if (next !== undefined && next !== process.env[key]) {
+    if (key === "MEMORY_RATERS" && next === undefined && process.env[key] !== undefined) {
+      delete process.env[key];
+      changed.push(key);
+    } else if (next !== undefined && next !== process.env[key]) {
       const previous = process.env[key];
       process.env[key] = next;
       changed.push(key);

package/src/extensions/identity.ts

@@ -1,5 +1,6 @@
 import {
   createAgent,
+  EXTENSION_AGENT_ROLE,
   getAllAgents,
   getDbClient,
   updateAgentMaxTasks,
@@ -14,7 +15,9 @@ function extensionAgentName(name: string): string {
 export async function ensureExtensionAgent(name: string): Promise<string> {
   const agentName = extensionAgentName(name);
   return await getDbClient().transaction(async () => {
-    let agent = (await getAllAgents()).find((candidate) => candidate.name === agentName);
+    let agent = (await getAllAgents({ includeExtensions: true })).find(
+      (candidate) => candidate.name === agentName,
+    );
     if (!agent) {
       agent = await createAgent({
         name: agentName,
@@ -27,17 +30,22 @@ export async function ensureExtensionAgent(name: string): Promise<string> {
 
     if (agent.status !== "offline") await updateAgentStatus(agent.id, "offline");
     if (agent.maxTasks !== 0) await updateAgentMaxTasks(agent.id, 0);
-    await updateAgentProfile(agent.id, {
-      description: `System agent for extension ${name}`,
-      role: "extension",
-      capabilities: [],
-    });
+    await updateAgentProfile(
+      agent.id,
+      {
+        description: `System agent for extension ${name}`,
+        role: EXTENSION_AGENT_ROLE,
+        capabilities: [],
+      },
+      undefined,
+      { allowExtensionRole: true },
+    );
     return agent.id;
   });
 }
 
 export async function deactivateExtensionAgent(name: string): Promise<void> {
-  const agent = (await getAllAgents()).find(
+  const agent = (await getAllAgents({ includeExtensions: true })).find(
     (candidate) => candidate.name === extensionAgentName(name),
   );
   if (agent && agent.status !== "offline") await updateAgentStatus(agent.id, "offline");

package/src/extensions/lifecycle.ts

@@ -1,7 +1,6 @@
 import {
   activateExtensionVersionSnapshot,
   getExtensionById,
-  getExtensionFiles,
   getExtensionVersion,
   insertExtensionRun,
   listExtensions,
@@ -66,28 +65,23 @@ function maxUpdatedAt(extensions: Extension[]): string {
 }
 
 async function loadableExtension(record: Extension): Promise<LoadableExtension> {
-  if (record.activeVersion !== record.version) {
-    const version = await getExtensionVersion(record.id, record.activeVersion);
-    if (!version) {
-      throw new ExtensionLifecycleError(
-        `Extension version ${record.activeVersion} was not found`,
-        404,
-      );
-    }
-    return {
-      record: {
-        ...record,
-        manifestJson: version.manifestJson,
-        contentHash: version.contentHash,
-      },
-      manifest: ExtensionManifestSchema.parse(JSON.parse(version.manifestJson)),
-      files: JSON.parse(version.filesJson) as Record<string, string>,
-    };
+  // Always load the immutable selected version. The mutable current-file projection
+  // can advance while an agent stages a draft after we read the extension row.
+  const version = await getExtensionVersion(record.id, record.activeVersion);
+  if (!version) {
+    throw new ExtensionLifecycleError(
+      `Extension version ${record.activeVersion} was not found`,
+      404,
+    );
   }
   return {
-    record,
-    manifest: ExtensionManifestSchema.parse(JSON.parse(record.manifestJson)),
-    files: await getExtensionFiles(record.id),
+    record: {
+      ...record,
+      manifestJson: version.manifestJson,
+      contentHash: version.contentHash,
+    },
+    manifest: ExtensionManifestSchema.parse(JSON.parse(version.manifestJson)),
+    files: JSON.parse(version.filesJson) as Record<string, string>,
   };
 }
 

package/src/hooks/codex-hook.ts

@@ -100,7 +100,13 @@ export async function collectDeliverableSteering(
     } catch {
       continue;
     }
-    delivered.push(await renderSteeringDelivery(message.id, message.body));
+    delivered.push(
+      await renderSteeringDelivery(
+        message.id,
+        message.body,
+        message.senderLabel ?? message.createdByKind,
+      ),
+    );
   }
   return delivered;
 }

package/src/http/agents.ts

@@ -5,6 +5,7 @@ import {
   computeContentHash,
   createAgent,
   deleteSwarmConfigByKey,
+  EXTENSION_AGENT_ROLE,
   getAgentById,
   getAgentWithTasks,
   getAllAgents,
@@ -12,6 +13,7 @@ import {
   getDbClient,
   getResolvedConfig,
   getSwarmConfigs,
+  ReservedAgentRoleError,
   resetEmptyPollCount,
   setAgentHarnessProvider,
   updateAgentActivity,
@@ -181,7 +183,7 @@ const setAgentHarnessProviderRoute = route({
   },
 });
 
-const LocalHarnessProviderSchema = z.enum(["claude", "codex", "pi", "opencode", "acp"]);
+const LocalHarnessProviderSchema = z.enum(["claude", "codex", "pi", "opencode", "acp", "dsh"]);
 const AcpRuntimeConfigSchema = z
   .object({
     target: z.enum(ACP_TARGET_IDS),
@@ -339,7 +341,7 @@ const listAgents = route({
   pattern: ["api", "agents"],
   summary: "List all agents",
   description:
-    "Returns agents WITHOUT the six identity-markdown blobs (`claudeMd`/`soulMd`/`identityMd`/`toolsMd`/`heartbeatMd`/`setupScript`) by default — they bloat the list by ~16 KB/agent and the overview never renders them. Pass `fields=full` to restore them, or fetch a single agent via `GET /api/agents/{id}`.",
+    "Returns agents WITHOUT the six identity-markdown blobs (`claudeMd`/`soulMd`/`identityMd`/`toolsMd`/`heartbeatMd`/`setupScript`) by default — they bloat the list by ~16 KB/agent and the overview never renders them. Pass `fields=full` to restore them, or fetch a single agent via `GET /api/agents/{id}`. Extension identities (`ext:<name>`, role `extension`) are never listed; they are API principals, not workers.",
   tags: ["Agents"],
   query: z.object({
     include: z.enum(["tasks"]).optional(),
@@ -578,6 +580,12 @@ export async function handleAgentRegister(
     const parsed = await registerAgent.parse(req, res, pathSegments, new URLSearchParams());
     if (!parsed) return true;
 
+    // Extension identities are created only by the extension lifecycle.
+    if (parsed.body.role === EXTENSION_AGENT_ROLE) {
+      jsonError(res, `Role "${EXTENSION_AGENT_ROLE}" is reserved for extension identities.`, 400);
+      return true;
+    }
+
     const agentId = myAgentId || crypto.randomUUID();
     // Read once so one mode applies consistently even if a config reload
     // flips the flag mid-request.
@@ -877,7 +885,7 @@ export async function handleAgentsRest(
         },
       );
     } catch (error) {
-      if (error instanceof HeartbeatExpiryError) {
+      if (error instanceof HeartbeatExpiryError || error instanceof ReservedAgentRoleError) {
         jsonError(res, error.message, 400);
         return true;
       }
@@ -1046,7 +1054,7 @@ export async function handleAgentsRest(
               })
             )[0]?.value ?? "");
       const allowedLevels =
-        harness_provider === "acp"
+        harness_provider === "acp" || harness_provider === "dsh"
           ? []
           : reasoningCapability(harness_provider, modelForValidation ?? "").levels;
       if (!allowedLevels.includes(reasoning_effort)) {

package/src/http/config.ts

@@ -37,7 +37,7 @@ const SECRETS_FORCE_MASK_NOTE =
 // bootstrap admin key would let a compromised worker administer the shared org.
 // The API materializes these into its own process.env at boot via
 // getInjectableGlobalConfigs, so no HTTP consumer legitimately needs them.
-const API_ONLY_CONFIG_KEYS = new Set(["API_AGENT_FS_API_KEY"]);
+const API_ONLY_CONFIG_KEYS = new Set(["API_AGENT_FS_API_KEY", "SLACK_SIGNING_SECRET"]);
 
 function stripApiOnlyKeys<T extends { key: string }>(configs: T[]): T[] {
   return configs.filter((config) => !API_ONLY_CONFIG_KEYS.has(config.key));

package/src/http/core.ts

@@ -150,6 +150,10 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
 
   const updated = await loadGlobalConfigsIntoEnv(true);
 
+  // Retire the old transport before any other integration can fail during
+  // reload. HTTP/invalid selection must never leave the previous socket live.
+  await stopSlackApp();
+
   // File-storage provider selection reads process.env once and memoizes; the
   // env we just (re)hydrated may flip it (local-fs → agent-fs after late
   // provisioning, or a rotated bootstrap key). Reset so the next fs request
@@ -206,9 +210,7 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
   resetJira();
   if (await initJira()) integrations.push("jira");
 
-  await stopSlackApp();
-  await startSlackApp();
-  integrations.push("slack");
+  if (await startSlackApp()) integrations.push("slack");
 
   return {
     configsLoaded: updated.length,

package/src/http/extensions.ts

@@ -4,9 +4,11 @@ import { resolveHttpAuditUserId } from "../be/audit-user";
 import { getAgentById } from "../be/db";
 import {
   deleteExtension,
+  ExtensionOwnershipError,
   getExtensionById,
   getExtensionByName,
   getExtensionFiles,
+  type InstallExtensionResult,
   installExtension,
   listExtensionRuns,
   listExtensions,
@@ -23,8 +25,15 @@ import {
   reloadExtension,
 } from "../extensions/lifecycle";
 import { ExtensionConfigError } from "../extensions/loader";
-import { can, type PermissionVerb, type RbacPrincipal } from "../rbac";
 import {
+  can,
+  LEGACY_RULES,
+  type PermissionVerb,
+  type RbacPrincipal,
+  type RbacResource,
+} from "../rbac";
+import {
+  type Extension,
   ExtensionInstallBodySchema,
   ExtensionManifestSchema,
   ExtensionRunSchema,
@@ -44,6 +53,8 @@ const installRoute = route({
   pattern: ["api", "extensions", "install"],
   operationId: "extensions_install",
   summary: "Validate and install an extension bundle",
+  description:
+    "Any authenticated agent can install a disabled draft owned by its agent ID. Workers can update only their own bundles; activation remains lead/operator-only.",
   tags: ["Extensions"],
   body: ExtensionInstallBodySchema,
   responses: {
@@ -153,6 +164,8 @@ const patchRoute = route({
   pattern: ["api", "extensions", null],
   operationId: "extensions_update",
   summary: "Update extension priority, config, or description",
+  description:
+    "Workers may edit their own disabled extensions. Leads, operators, and dashboard users retain access to all extensions.",
   tags: ["Extensions"],
   params: idParamsSchema,
   body: z
@@ -177,6 +190,8 @@ const deleteRoute = route({
   pattern: ["api", "extensions", null],
   operationId: "extensions_delete",
   summary: "Uninstall a disabled extension",
+  description:
+    "Workers may uninstall their own disabled extensions. Leads, operators, and dashboard users retain access to all extensions.",
   tags: ["Extensions"],
   params: idParamsSchema,
   responses: {
@@ -316,14 +331,23 @@ async function extensionPrincipal(
   return { kind: "agent", agentId: "", isLead: false };
 }
 
+/** Restrict ordinary agents; retain the existing blanket access for elevated writers. */
+function ownerOnlyAgentId(principal: RbacPrincipal): string | undefined {
+  return principal.kind === "agent" &&
+    !LEGACY_RULES["lead-or-operator-or-user"].evaluate(principal, undefined)
+    ? principal.agentId
+    : undefined;
+}
+
 async function requirePermission(
   req: IncomingMessage,
   res: ServerResponse,
   callerAgentId: string | undefined,
   verb: Extract<PermissionVerb, "extension.write" | "extension.activate">,
+  resource: RbacResource = { kind: "none" },
 ): Promise<RbacPrincipal | null> {
   const principal = await extensionPrincipal(req, callerAgentId);
-  const decision = can({ principal, verb, resource: { kind: "none" }, source: "http" });
+  const decision = can({ principal, verb, resource, source: "http" });
   if (decision.allow) return principal;
   jsonError(res, `Forbidden: ${decision.reason}`, 403);
   return null;
@@ -331,11 +355,13 @@ async function requirePermission(
 
 function respondLifecycleError(res: ServerResponse, error: unknown): void {
   const status =
-    error instanceof ExtensionConfigError
-      ? 400
-      : error instanceof ExtensionLifecycleError
-        ? error.status
-        : 500;
+    error instanceof ExtensionOwnershipError
+      ? 403
+      : error instanceof ExtensionConfigError
+        ? 400
+        : error instanceof ExtensionLifecycleError
+          ? error.status
+          : 500;
   jsonError(res, scrubSecrets(error instanceof Error ? error.message : String(error)), status);
 }
 
@@ -349,26 +375,41 @@ export async function handleExtensions(
   if (installRoute.match(req.method, pathSegments)) {
     const parsed = await installRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const principal = await requirePermission(req, res, agentId, "extension.write");
+    const existing = await getExtensionByName(parsed.body.manifest.name);
+    const principal = await requirePermission(req, res, agentId, "extension.write", {
+      kind: "extension",
+      extensionId: existing?.id,
+      createdByAgentId: existing?.createdByAgentId,
+    });
     if (!principal) return true;
     const validation = await validateBundle(parsed.body);
     if (!validation.ok) {
       json(res, { error: "extension_validation_failed", diagnostics: validation.diagnostics }, 400);
       return true;
     }
-    const existing = await getExtensionByName(validation.manifest.name);
     const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
     const updatedBy = await resolveHttpAuditUserId(req, writerAgentId);
     const shouldActivate = principal.kind !== "agent" && existing?.enabled === true;
-    const result = await installExtension({
-      manifest: validation.manifest,
-      files: parsed.body.files,
-      priority: parsed.body.priority,
-      config: parsed.body.config,
-      agentId: writerAgentId,
-      createdBy: updatedBy,
-      activate: shouldActivate,
-    });
+    // Enforce ownership again inside the upsert transaction: validation can yield
+    // while another agent installs the same name.
+    const ownerOnly = ownerOnlyAgentId(principal);
+    let result: InstallExtensionResult;
+    try {
+      result = await installExtension({
+        manifest: validation.manifest,
+        files: parsed.body.files,
+        priority: parsed.body.priority,
+        config: parsed.body.config,
+        agentId: writerAgentId,
+        createdBy: updatedBy,
+        activate: shouldActivate,
+        ownerOnly,
+      });
+    } catch (error) {
+      if (!(error instanceof ExtensionOwnershipError)) throw error;
+      jsonError(res, error.message, 403);
+      return true;
+    }
     let extension = result.extension;
     if (shouldActivate) {
       try {
@@ -446,19 +487,42 @@ export async function handleExtensions(
   if (patchRoute.match(req.method, pathSegments)) {
     const parsed = await patchRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const principal = await requirePermission(req, res, agentId, "extension.write");
+    const stored = await getExtensionById(parsed.params.id);
+    if (!stored) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    const principal = await requirePermission(req, res, agentId, "extension.write", {
+      kind: "extension",
+      extensionId: stored.id,
+      createdByAgentId: stored.createdByAgentId,
+    });
     if (!principal) return true;
     const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
-    const stored = parsed.body.config ? await getExtensionById(parsed.params.id) : null;
-    const config =
-      parsed.body.config && stored
-        ? preserveRedactedConfigValues(parsed.body.config, stored.configJson)
-        : parsed.body.config;
-    let extension = await updateExtensionMeta(parsed.params.id, {
-      ...parsed.body,
-      ...(config === undefined ? {} : { config }),
-      updatedBy: await resolveHttpAuditUserId(req, writerAgentId),
-    });
+    const ownerOnly = ownerOnlyAgentId(principal);
+    // PATCH reloads live code; ordinary owners may edit only disabled drafts.
+    if (
+      stored.enabled &&
+      ownerOnly &&
+      !(await requirePermission(req, res, agentId, "extension.activate"))
+    ) {
+      return true;
+    }
+    const config = parsed.body.config
+      ? preserveRedactedConfigValues(parsed.body.config, stored.configJson)
+      : parsed.body.config;
+    let extension: Extension | null;
+    try {
+      extension = await updateExtensionMeta(parsed.params.id, {
+        ...parsed.body,
+        ...(config === undefined ? {} : { config }),
+        updatedBy: await resolveHttpAuditUserId(req, writerAgentId),
+        ownerOnly,
+      });
+    } catch (error) {
+      respondLifecycleError(res, error);
+      return true;
+    }
     if (!extension) {
       jsonError(res, "Extension not found", 404);
       return true;
@@ -478,18 +542,28 @@ export async function handleExtensions(
   if (deleteRoute.match(req.method, pathSegments)) {
     const parsed = await deleteRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const principal = await requirePermission(req, res, agentId, "extension.write");
-    if (!principal) return true;
-    const extension = await getExtensionById(parsed.params.id);
-    if (!extension) {
+    const stored = await getExtensionById(parsed.params.id);
+    if (!stored) {
       jsonError(res, "Extension not found", 404);
       return true;
     }
+    const principal = await requirePermission(req, res, agentId, "extension.write", {
+      kind: "extension",
+      extensionId: stored.id,
+      createdByAgentId: stored.createdByAgentId,
+    });
+    if (!principal) return true;
+    const extension = stored;
     if (extension.enabled) {
       jsonError(res, "Disable the extension before uninstalling it", 409);
       return true;
     }
-    await deleteExtension(extension.id);
+    try {
+      await deleteExtension(extension.id, ownerOnlyAgentId(principal));
+    } catch (error) {
+      respondLifecycleError(res, error);
+      return true;
+    }
     deleteRoute.respond(res, 200, { deleted: true });
     return true;
   }

package/src/http/poll.ts

@@ -21,6 +21,7 @@ import {
   getUnassignedTaskIdsForAgent,
   getUserById,
   hasCapacity,
+  isExtensionAgent,
   recordBudgetRefusalNotification,
   startTask,
   updateAgentStatusFromCapacity,
@@ -310,6 +311,12 @@ export async function handlePoll(
           return { error: "Agent not found", status: 404 };
         }
 
+        // Extension identities authenticate to the API but never execute
+        // work: no offers, no pending assignments, no pool claims.
+        if (isExtensionAgent(agent)) {
+          return { trigger: null };
+        }
+
         // A process whose runtime has been retired must not be handed work: it
         // would execute alongside whatever replaced it. Dispatch is gated on a
         // live runtime identity rather than on X-Agent-ID alone, which only

package/src/http/schedules.ts

@@ -6,11 +6,13 @@ import { resolveHttpAuditUserId } from "../be/audit-user";
 import {
   createScheduledTask,
   deleteScheduledTask,
+  extensionAgentAssignmentError,
   getAgentById,
   getScheduledTaskById,
   getScheduledTaskByName,
   getScheduledTasks,
   getWorkflow,
+  isExtensionAgent,
   updateScheduledTask,
   withFavoriteFlags,
 } from "../be/db";
@@ -355,6 +357,10 @@ export async function handleSchedules(
         jsonError(res, "Target agent not found", 400);
         return true;
       }
+      if (isExtensionAgent(agent)) {
+        jsonError(res, extensionAgentAssignmentError(agent), 400);
+        return true;
+      }
     }
 
     const targetType = body.targetType ?? "agent-task";
@@ -583,6 +589,10 @@ export async function handleSchedules(
         jsonError(res, "Target agent not found", 400);
         return true;
       }
+      if (isExtensionAgent(agent)) {
+        jsonError(res, extensionAgentAssignmentError(agent), 400);
+        return true;
+      }
     }
 
     // Cross-field targetType validation — merge patch over existing, then

package/src/http/script-runs.ts

@@ -7,6 +7,7 @@ import {
   countScriptRuns,
   createScriptRun,
   createTaskExtended,
+  ExtensionAgentAssignmentError,
   getAgentById,
   getDbClient,
   getLatestScriptRunStepTaskByContextKey,
@@ -618,32 +619,40 @@ export async function handleScriptRuns(
     const contextKey = `script-run:${run.id}:${parsed.body.stepKey}`;
     let task = await getLatestScriptRunStepTaskByContextKey(contextKey);
     if (!task) {
-      task = await createTaskExtended(
-        parsed.body.template ?? parsed.body.task ?? parsed.body.stepKey,
-        {
-          agentId: parsed.body.agentId,
-          routingReason:
-            parsed.body.routingReason ?? (parsed.body.agentId ? "human_pinned" : undefined),
-          routingNote: parsed.body.routingNote,
-          routingSource: parsed.body.routingReason
-            ? "declared"
-            : parsed.body.agentId
-              ? "engine_default"
-              : undefined,
-          tags: parsed.body.tags,
-          priority: parsed.body.priority,
-          offeredTo: parsed.body.offerMode ? parsed.body.agentId : undefined,
-          taskType: "script-run-step",
-          source: "mcp",
-          dir: parsed.body.dir,
-          vcsRepo: parsed.body.vcsRepo,
-          model: parsed.body.model,
-          parentTaskId: parsed.body.parentTaskId,
-          requestedByUserId: parsed.body.requestedByUserId ?? run.requestedByUserId,
-          outputSchema: parsed.body.outputSchema,
-          contextKey,
-        },
-      );
+      try {
+        task = await createTaskExtended(
+          parsed.body.template ?? parsed.body.task ?? parsed.body.stepKey,
+          {
+            agentId: parsed.body.agentId,
+            routingReason:
+              parsed.body.routingReason ?? (parsed.body.agentId ? "human_pinned" : undefined),
+            routingNote: parsed.body.routingNote,
+            routingSource: parsed.body.routingReason
+              ? "declared"
+              : parsed.body.agentId
+                ? "engine_default"
+                : undefined,
+            tags: parsed.body.tags,
+            priority: parsed.body.priority,
+            offeredTo: parsed.body.offerMode ? parsed.body.agentId : undefined,
+            taskType: "script-run-step",
+            source: "mcp",
+            dir: parsed.body.dir,
+            vcsRepo: parsed.body.vcsRepo,
+            model: parsed.body.model,
+            parentTaskId: parsed.body.parentTaskId,
+            requestedByUserId: parsed.body.requestedByUserId ?? run.requestedByUserId,
+            outputSchema: parsed.body.outputSchema,
+            contextKey,
+          },
+        );
+      } catch (error) {
+        if (error instanceof ExtensionAgentAssignmentError) {
+          jsonError(res, error.message, 400);
+          return true;
+        }
+        throw error;
+      }
     }
 
     const deadline = Date.now() + 30_000;