@desplega.ai/agent-swarm 1.131.1 → 1.134.0

package/src/http/prompt-templates.ts

@@ -10,9 +10,10 @@ import {
   resolvePromptTemplate,
   upsertPromptTemplate,
 } from "../be/db";
+import { getPromptTemplateDefaultDrift } from "../prompts/default-drift";
 import { getAllTemplateDefinitions, getTemplateDefinition } from "../prompts/registry";
 import { resolveTemplate } from "../prompts/resolver";
-import { PromptTemplateHistorySchema, PromptTemplateSchema } from "../types";
+import { type PromptTemplate, PromptTemplateHistorySchema, PromptTemplateSchema } from "../types";
 import { interpolate } from "../utils/template";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
@@ -35,6 +36,19 @@ const EventTemplateDefinitionResponseSchema = z.object({
   category: z.enum(["event", "system", "common", "task_lifecycle", "session"]),
 });
 
+const PromptTemplateResponseSchema = PromptTemplateSchema.extend({
+  defaultDrifted: z.boolean(),
+}).openapi("PromptTemplateResponse");
+
+function toPromptTemplateResponse(template: PromptTemplate) {
+  const definition = getTemplateDefinition(template.eventType);
+  const defaultDrifted = definition
+    ? getPromptTemplateDefaultDrift(template, definition.defaultBody).defaultDrifted
+    : false;
+
+  return { ...template, defaultDrifted };
+}
+
 /** Mirrors `ResolveResult` from src/prompts/resolver.ts */
 const ResolveResultSchema = z.object({
   text: z.string(),
@@ -46,7 +60,10 @@ const ResolveResultSchema = z.object({
 
 /** Mirrors the return type of `resolvePromptTemplate` in src/be/db.ts */
 const DbResolveResultSchema = z
-  .union([z.object({ template: PromptTemplateSchema }), z.object({ skip: z.literal(true) })])
+  .union([
+    z.object({ template: PromptTemplateResponseSchema }),
+    z.object({ skip: z.literal(true) }),
+  ])
   .nullable();
 
 // ─── Route Definitions ───────────────────────────────────────────────────────
@@ -142,7 +159,7 @@ const checkoutRoute = route({
   responses: {
     200: {
       description: "Checked-out template",
-      schema: z.object({ template: PromptTemplateSchema }),
+      schema: z.object({ template: PromptTemplateResponseSchema }),
     },
     400: { description: "Validation error" },
     404: { description: "Template or version not found" },
@@ -158,7 +175,10 @@ const resetRoute = route({
   tags: ["PromptTemplates"],
   params: z.object({ id: z.string() }),
   responses: {
-    200: { description: "Reset template", schema: z.object({ template: PromptTemplateSchema }) },
+    200: {
+      description: "Reset template",
+      schema: z.object({ template: PromptTemplateResponseSchema }),
+    },
     404: { description: "Template not found or no code default available" },
   },
   auth: { apiKey: true },
@@ -175,7 +195,7 @@ const getByIdRoute = route({
     200: {
       description: "Template with history",
       schema: z.object({
-        template: PromptTemplateSchema,
+        template: PromptTemplateResponseSchema,
         history: z.array(PromptTemplateHistorySchema),
       }),
     },
@@ -217,7 +237,7 @@ const listRoute = route({
   responses: {
     200: {
       description: "List of prompt templates",
-      schema: z.object({ templates: z.array(PromptTemplateSchema) }),
+      schema: z.object({ templates: z.array(PromptTemplateResponseSchema) }),
     },
   },
   auth: { apiKey: true },
@@ -241,7 +261,7 @@ const upsertRoute = route({
   responses: {
     200: {
       description: "Upserted template",
-      schema: z.object({ template: PromptTemplateSchema }),
+      schema: z.object({ template: PromptTemplateResponseSchema }),
     },
     400: { description: "Validation error" },
   },
@@ -273,7 +293,10 @@ export async function handlePromptTemplates(
 
     resolvedRoute.respond(res, 200, {
       resolution: result,
-      dbResult,
+      dbResult:
+        dbResult && "template" in dbResult
+          ? { template: toPromptTemplateResponse(dbResult.template) }
+          : dbResult,
       definition: definition
         ? {
             eventType: definition.eventType,
@@ -339,7 +362,7 @@ export async function handlePromptTemplates(
 
     try {
       const template = checkoutPromptTemplate(parsed.params.id, parsed.body.version);
-      checkoutRoute.respond(res, 200, { template });
+      checkoutRoute.respond(res, 200, { template: toPromptTemplateResponse(template) });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       if (message.includes("not found")) {
@@ -370,7 +393,7 @@ export async function handlePromptTemplates(
 
     try {
       const template = resetPromptTemplateToDefault(parsed.params.id, definition.defaultBody);
-      resetRoute.respond(res, 200, { template });
+      resetRoute.respond(res, 200, { template: toPromptTemplateResponse(template) });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       jsonError(res, message, 400);
@@ -390,7 +413,7 @@ export async function handlePromptTemplates(
     }
 
     const history = getPromptTemplateHistory(parsed.params.id);
-    getByIdRoute.respond(res, 200, { template, history });
+    getByIdRoute.respond(res, 200, { template: toPromptTemplateResponse(template), history });
     return true;
   }
 
@@ -425,7 +448,7 @@ export async function handlePromptTemplates(
       isDefault: parsed.query.isDefault ? parsed.query.isDefault === "true" : undefined,
     });
 
-    listRoute.respond(res, 200, { templates });
+    listRoute.respond(res, 200, { templates: templates.map(toPromptTemplateResponse) });
     return true;
   }
 
@@ -464,7 +487,7 @@ export async function handlePromptTemplates(
         changedBy,
         changeReason,
       });
-      upsertRoute.respond(res, 200, { template });
+      upsertRoute.respond(res, 200, { template: toPromptTemplateResponse(template) });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       jsonError(res, message, 500);

package/src/http/route-def.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import type { PermissionVerb } from "../rbac";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { jsonError, matchRoute, parseBody } from "./utils";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -25,6 +26,24 @@ type ResponsesDef = Record<number, RouteResponseDef>;
 /** Extracts the payload type respond() accepts for one response def. */
 type ResponseData<R> = R extends { schema: infer S extends z.ZodType } ? z.input<S> : never;
 
+/**
+ * Optional `X-Runtime-Instance-ID` header shared by the lifecycle and poll
+ * routes. Optional in the schema because the requirement is conditional:
+ * only multi-runtime mode needs it, and legacy deployments must keep working
+ * without it.
+ */
+export const runtimeInstanceHeader = (operation: string) =>
+  z.object({
+    "X-Runtime-Instance-ID": z
+      .string()
+      .optional()
+      .describe(
+        "Identifies the concrete runtime instance (worker process) making the call, " +
+          `as generated at its boot. Required to ${operation} when multi-runtime mode ` +
+          "(MULTI_RUNTIME_ENABLED) is on; ignored otherwise.",
+      ),
+  });
+
 export interface RouteDef<
   TParams extends z.ZodType = z.ZodType,
   TQuery extends z.ZodType = z.ZodType,
@@ -41,6 +60,14 @@ export interface RouteDef<
   tags: string[];
   params?: TParams;
   query?: TQuery;
+  /**
+   * Request headers to publish as OpenAPI parameters, beyond the global
+   * `Authorization`/`X-Agent-ID` security schemes. Declaration-only: handlers
+   * still read headers off `req`, so adding this to a route changes the
+   * generated spec and nothing else. Mark each property `.optional()` unless
+   * the header is unconditionally required.
+   */
+  headers?: z.ZodObject;
   body?: TBody;
   responses: TResponses;
   auth?: {
@@ -187,10 +214,14 @@ export function describeRequestRoute(
 // ─── Factory ─────────────────────────────────────────────────────────────────
 
 /**
- * Runtime response validation gate for `respond()`. NODE_ENV is deliberately
- * unset on prod deploys, so this is opt-in outside `bun test` (which sets
- * NODE_ENV=test): response schemas must never introduce a production failure
- * mode — they fail loudly in tests and (opt-in) local dev instead.
+ * Runtime response validation gate for `respond()`. Only `bun test`
+ * (NODE_ENV=test) fails hard on a violation: one bad row must never take an
+ * endpoint down outside tests (2026-08-18 incident — a single priority='high'
+ * row 500'd every task listing). When the gate is on outside tests
+ * (NODE_ENV=development, or VALIDATE_HTTP_RESPONSES=true), `respond()` logs
+ * the violation and sends the response anyway. Note: the compiled Bun binary
+ * defaults NODE_ENV to "development", so deploys must also set
+ * NODE_ENV=production explicitly (see the deploy-env change in the fix PR).
  */
 const VALIDATE_RESPONSES =
   process.env.NODE_ENV === "test" ||
@@ -216,12 +247,15 @@ export function route<
         if (schema) {
           const result = schema.safeParse(data);
           if (!result.success) {
-            throw new Error(
+            const detail =
               `Response schema violation: ${def.method.toUpperCase()} ${def.path} ${code} — ` +
-                result.error.issues
-                  .map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
-                  .join("; "),
-            );
+              result.error.issues
+                .map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`)
+                .join("; ");
+            if (process.env.NODE_ENV === "test") {
+              throw new Error(detail);
+            }
+            console.error(`[route-def] ${scrubSecrets(detail)}`);
           }
         }
       }

package/src/http/schedules.ts

@@ -40,7 +40,7 @@ const scheduleUpdateBodySchema = z.object({
   taskTemplate: z.string().optional(),
   taskType: z.string().optional(),
   tags: z.array(z.string()).optional(),
-  priority: z.number().int().optional(),
+  priority: z.number().int().min(0).max(100).optional(),
   targetAgentId: z.string().nullable().optional(),
   enabled: z.boolean().optional(),
   timezone: z.string().optional(),
@@ -96,7 +96,7 @@ const createSchedule = route({
     taskTemplate: z.string().min(1).optional(),
     taskType: z.string().optional(),
     tags: z.array(z.string()).optional(),
-    priority: z.number().int().optional(),
+    priority: z.number().int().min(0).max(100).optional(),
     targetAgentId: z.string().optional(),
     enabled: z.boolean().optional(),
     timezone: z.string().optional(),

package/src/http/scripts.ts

@@ -53,7 +53,7 @@ import {
   ScriptVersionRecordSchema,
 } from "../types";
 import { scrubObject, scrubSecrets } from "../utils/secret-scrubber";
-import { route } from "./route-def";
+import { route, runtimeInstanceHeader } from "./route-def";
 import { json, jsonError } from "./utils";
 
 const scriptNameSchema = z.string().min(1).max(200);
@@ -244,6 +244,7 @@ const runRoute = route({
   description:
     "Inline source skips typecheck and is auto-saved as a scratch script only on success.",
   tags: ["Scripts"],
+  headers: runtimeInstanceHeader("acquire work through the script SDK"),
   body: runBodySchema,
   responses: {
     200: { description: "Script run completed", schema: scriptRunResponseSchema },
@@ -695,6 +696,13 @@ export async function handleScripts(
     const agent = requireAgent(res, agentId);
     if (!agent) return true;
 
+    // Per-boot identity of the invoking worker process. Carried into the
+    // script runtime as system context so SDK work-acquisition calls present
+    // the same runtime the worker itself would — never script input.
+    const runtimeInstanceId = ((h) => (Array.isArray(h) ? h[0] : h))(
+      req.headers["x-runtime-instance-id"],
+    );
+
     let source = parsed.body.source;
     let fsMode = parsed.body.fsMode;
     let namedScript: ScriptRecord | null = null;
@@ -726,6 +734,7 @@ export async function handleScripts(
       args: parsed.body.args,
       fsMode,
       agentId: agent.id,
+      runtimeInstanceId,
       egressSecrets: credentials.egressSecrets,
       failedBindings: credentials.failedBindings,
       apiConnections: getScriptApiConnectionDescriptors({ agentId: agent.id }),

package/src/http/session-data.ts

@@ -5,6 +5,7 @@ import {
   createSessionLogs,
   getActivePricingRow,
   getAllSessionCosts,
+  getAttributionByPerson,
   getDashboardCostSummary,
   getSessionCostSummary,
   getSessionCostsByAgentId,
@@ -34,6 +35,9 @@ const SessionCostSummaryTotalsSchema = z.object({
   totalSessions: z.number().int(),
   avgCostPerSession: z.number(),
   attributedCostUsd: z.number(),
+  attributableCostUsd: z.number(),
+  excludedCostUsd: z.number(),
+  excludedTaskCount: z.number().int(),
 });
 
 /** Mirrors `SessionCostDailyRow` in src/be/db.ts. */
@@ -79,6 +83,17 @@ const DashboardCostSummarySchema = z.object({
   costMtd: z.number(),
 });
 
+/** Mirrors `AttributionByPersonRow` in src/be/db.ts. */
+const AttributionByPersonRowSchema = z.object({
+  userId: z.string(),
+  problemsInitiated: z.number().int(),
+  problemsShipped: z.number().int(),
+  agentsReached: z.number().int(),
+  reposReached: z.number().int(),
+  surfacesReached: z.number().int(),
+  firstPassYield: z.null(),
+});
+
 // ─── Route Definitions ───────────────────────────────────────────────────────
 
 const createSessionLogsRoute = route({
@@ -203,6 +218,24 @@ const getSessionCostSummaryRoute = route({
   },
 });
 
+const getAttributionByPersonRoute = route({
+  method: "get",
+  path: "/api/attribution/by-person",
+  pattern: ["api", "attribution", "by-person"],
+  summary: "Four-metric per-person attribution (problems initiated/shipped, reach)",
+  tags: ["Session Data"],
+  query: z.object({
+    startDate: z.string().optional(),
+    endDate: z.string().optional(),
+  }),
+  responses: {
+    200: {
+      description: "Per-person attribution rows",
+      schema: z.object({ rows: z.array(AttributionByPersonRowSchema) }),
+    },
+  },
+});
+
 const getDashboardCosts = route({
   method: "get",
   path: "/api/session-costs/dashboard",
@@ -403,6 +436,17 @@ export async function handleSessionData(
     return true;
   }
 
+  if (getAttributionByPersonRoute.match(req.method, pathSegments)) {
+    const parsed = await getAttributionByPersonRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const rows = getAttributionByPerson({
+      startDate: parsed.query.startDate || undefined,
+      endDate: parsed.query.endDate || undefined,
+    });
+    getAttributionByPersonRoute.respond(res, 200, { rows });
+    return true;
+  }
+
   if (listSessionCosts.match(req.method, pathSegments)) {
     const parsed = await listSessionCosts.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/http/tasks.ts

@@ -220,7 +220,7 @@ const createTask = route({
     agentId: z.string().optional(),
     taskType: z.string().optional(),
     tags: z.array(z.string()).optional(),
-    priority: z.number().int().optional(),
+    priority: z.number().int().min(0).max(100).optional(),
     dependsOn: z.array(z.string()).optional(),
     offeredTo: z.string().optional(),
     dir: z.string().optional(),
@@ -760,7 +760,7 @@ export async function handleTasks(
         creatorAgentId: myAgentId || undefined,
         taskType: parsed.body.taskType || undefined,
         tags: parsed.body.tags || undefined,
-        priority: parsed.body.priority || 50,
+        priority: parsed.body.priority,
         dependsOn: parsed.body.dependsOn || undefined,
         offeredTo: parsed.body.offeredTo || undefined,
         dir: parsed.body.dir || undefined,

package/src/http/users.ts

@@ -32,6 +32,7 @@ import {
   deleteKv,
   deleteUser,
   getAllUsers,
+  getDb,
   getUserById,
   listKv,
   updateUser,
@@ -48,7 +49,7 @@ import {
   revokeToken,
   unlinkIdentity,
 } from "../be/users";
-import { UserSchema } from "../types";
+import { UserCommsPrefsSchema, UserSchema } from "../types";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { getOperatorActor } from "./operator-actor";
 import { route } from "./route-def";
@@ -296,6 +297,11 @@ const updateUserRoute = route({
       preferredChannel: z.string().optional(),
       timezone: z.string().optional(),
       metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+      comms: UserCommsPrefsSchema.nullable()
+        .optional()
+        .describe(
+          "Merges into metadata.comms without touching sibling metadata keys; null removes only the comms key. When metadata is also provided, it is applied first and replaces the whole blob.",
+        ),
       dailyBudgetUsd: z.number().nullable().optional(),
       status: z.enum(["invited", "active", "suspended"]).optional(),
       // Complete-list diff: passing this replaces the user's identity set,
@@ -776,60 +782,63 @@ export async function handleUsers(
     }
 
     try {
-      // Move every identity from source → target.
-      for (const ident of sourceBefore.identities) {
-        unlinkIdentity(sourceId, ident.kind, ident.externalId, actor);
-        linkIdentity(targetId, ident.kind, ident.externalId, actor);
-      }
+      const mergedUser = getDb().transaction(() => {
+        // Move every identity from source → target.
+        for (const ident of sourceBefore.identities) {
+          unlinkIdentity(sourceId, ident.kind, ident.externalId, actor);
+          linkIdentity(targetId, ident.kind, ident.externalId, actor);
+        }
 
-      // Merge email aliases — append source.email + source.emailAliases into
-      // target.emailAliases (de-duped). Emit `email_added` per added alias.
-      const targetAliases = new Set(targetBefore.emailAliases ?? []);
-      const targetPrimary = (targetBefore.email ?? "").toLowerCase();
-      const newAliases: string[] = [];
-      const candidates = [
-        ...(sourceBefore.email ? [sourceBefore.email] : []),
-        ...(sourceBefore.emailAliases ?? []),
-      ];
-      for (const candidate of candidates) {
-        const lower = candidate.toLowerCase();
-        if (!lower || lower === targetPrimary) continue;
-        if (
-          ![...targetAliases].some((a) => a.toLowerCase() === lower) &&
-          !newAliases.some((a) => a.toLowerCase() === lower)
-        ) {
-          newAliases.push(candidate);
+        // Merge email aliases — append source.email + source.emailAliases into
+        // target.emailAliases (de-duped). Emit `email_added` per added alias.
+        const targetAliases = new Set(targetBefore.emailAliases ?? []);
+        const targetPrimary = (targetBefore.email ?? "").toLowerCase();
+        const newAliases: string[] = [];
+        const candidates = [
+          ...(sourceBefore.email ? [sourceBefore.email] : []),
+          ...(sourceBefore.emailAliases ?? []),
+        ];
+        for (const candidate of candidates) {
+          const lower = candidate.toLowerCase();
+          if (!lower || lower === targetPrimary) continue;
+          if (
+            ![...targetAliases].some((a) => a.toLowerCase() === lower) &&
+            !newAliases.some((a) => a.toLowerCase() === lower)
+          ) {
+            newAliases.push(candidate);
+          }
         }
-      }
-      if (newAliases.length > 0) {
-        const merged = [...(targetBefore.emailAliases ?? []), ...newAliases];
-        updateUser(targetId, { emailAliases: merged });
-        for (const alias of newAliases) {
-          recordIdentityEvent(targetId, "email_added", actor, null, { email: alias });
+        if (newAliases.length > 0) {
+          const merged = [...(targetBefore.emailAliases ?? []), ...newAliases];
+          updateUser(targetId, { emailAliases: merged });
+          for (const alias of newAliases) {
+            recordIdentityEvent(targetId, "email_added", actor, null, { email: alias });
+          }
         }
-      }
 
-      // Delete source — CASCADE cleans up any leftover external_ids row that
-      // we may have missed (and clears tasks.requestedByUserId pointers).
-      deleteUser(sourceId);
-
-      // Single manual_merge event on target capturing the before/after rows.
-      // The source row is deleted above, so carry a minimal snapshot of the
-      // source user ({id, name, email}) inside the `after` payload under
-      // `source` — this lets the UI render "Merged manually from X → Y".
-      const targetAfter = composeUser(targetId);
-      recordIdentityEvent(targetId, "manual_merge", actor, targetBefore, {
-        ...targetAfter,
-        source: {
-          id: sourceBefore.id,
-          name: sourceBefore.name,
-          email: sourceBefore.email,
-        },
-      });
+        // Delete source — CASCADE cleans up any leftover external_ids row that
+        // we may have missed. Retained user references move to the target.
+        deleteUser(sourceId, targetId);
+
+        // Single manual_merge event on target capturing the before/after rows.
+        // The source row is deleted above, so carry a minimal snapshot of the
+        // source user ({id, name, email}) inside the `after` payload under
+        // `source` — this lets the UI render "Merged manually from X → Y".
+        const targetAfter = composeUser(targetId);
+        recordIdentityEvent(targetId, "manual_merge", actor, targetBefore, {
+          ...targetAfter,
+          source: {
+            id: sourceBefore.id,
+            name: sourceBefore.name,
+            email: sourceBefore.email,
+          },
+        });
 
-      // Re-compose AFTER the event so the response surfaces the merge event in
-      // recentEvents (otherwise the timeline is missing the event we just wrote).
-      mergeUsersRoute.respond(res, 200, { user: composeUser(targetId) });
+        // Re-compose AFTER the event so the response surfaces the merge event in
+        // recentEvents (otherwise the timeline is missing the event we just wrote).
+        return composeUser(targetId);
+      })();
+      mergeUsersRoute.respond(res, 200, { user: mergedUser });
     } catch (err) {
       jsonError(res, err instanceof Error ? err.message : "Failed to merge users", 500);
     }
@@ -863,10 +872,23 @@ export async function handleUsers(
     }
 
     try {
-      const { identities, metadata, ...rest } = parsed.body;
+      const { identities, metadata, comms, ...rest } = parsed.body;
       // updateUser doesn't accept `metadata: null` directly — passthrough via cast.
       const update: Parameters<typeof updateUser>[1] = { ...rest };
-      if (metadata !== undefined) {
+      if (comms !== undefined) {
+        // Merge-safe write: metadata (if provided) is applied first and
+        // replaces the whole blob, then comms is merged into it so sibling
+        // metadata keys survive.
+        const base: Record<string, unknown> = {
+          ...(metadata !== undefined ? (metadata ?? {}) : (before.metadata ?? {})),
+        };
+        if (comms === null) {
+          delete base.comms;
+        } else {
+          base.comms = comms;
+        }
+        update.metadata = Object.keys(base).length > 0 ? base : null;
+      } else if (metadata !== undefined) {
         update.metadata = metadata as Record<string, unknown> | null;
       }
       const updated = updateUser(parsed.params.id, update);

package/src/http/webhooks.ts

@@ -50,7 +50,7 @@ import {
 import type { KapsoConfig } from "../integrations/kapso/config";
 import { getKapsoConfig } from "../integrations/kapso/config";
 import type { KapsoWebhookPayload } from "../integrations/kapso/inbound";
-import { routeKapsoInbound } from "../integrations/kapso/inbound";
+import { resolveKapsoRequestedByUserId, routeKapsoInbound } from "../integrations/kapso/inbound";
 import { getExecutorRegistry } from "../workflows";
 import { workflowEventBus } from "../workflows/event-bus";
 import { handleWebhookTrigger, verifyHmacSignature, WebhookError } from "../workflows/triggers";
@@ -600,7 +600,10 @@ export async function handleWebhooks(
             rawBody,
             req.headers,
             getExecutorRegistry(),
-            { alreadyAuthenticated: true },
+            {
+              alreadyAuthenticated: true,
+              requestedByUserId: resolveKapsoRequestedByUserId(payload),
+            },
           );
           break;
         case "no_mapping":

package/src/http/workflows.ts

@@ -31,7 +31,6 @@ import {
   WorkflowSchema,
   WorkflowVersionSchema,
 } from "../types";
-import { getRequestAuth } from "../utils/request-auth-context";
 import { getExecutorRegistry, startWorkflowExecution } from "../workflows";
 import {
   applyDefinitionPatch,
@@ -827,13 +826,11 @@ export async function handleWorkflows(
       return true;
     }
     const body = await parseBody<Record<string, unknown>>(req);
-    const auth = getRequestAuth(req);
-
     let runId: string;
     try {
       runId = await startWorkflowExecution(workflow, body, getExecutorRegistry(), {
         triggerType: "api",
-        requestedByUserId: auth?.kind === "user" ? auth.userId : workflow.createdBy,
+        requestedByUserId: resolveHttpAuditUserId(req, myAgentId) ?? undefined,
       });
     } catch (err) {
       if (err instanceof TriggerSchemaError) {

package/src/integrations/kapso/inbound.ts

@@ -80,7 +80,7 @@ function resolveKapsoIdentity(externalId: string): IdentityResolution {
   return kapsoResolution;
 }
 
-function resolveKapsoRequestedByUserId(payload: KapsoWebhookPayload): string | undefined {
+export function resolveKapsoRequestedByUserId(payload: KapsoWebhookPayload): string | undefined {
   const externalId = normalizeKapsoSender(payload);
   if (!externalId) return undefined;