@desplega.ai/agent-swarm 1.57.4 → 1.58.0

package/src/tools/tool-config.ts

@@ -133,6 +133,10 @@ export const DEFERRED_TOOLS = new Set([
   "mcp-server-uninstall",
   "mcp-server-update",
 
+  // User Identity (2)
+  "resolve-user",
+  "manage-user",
+
   // Other (3)
   "cancel-task",
   "inject-learning",

package/src/types.ts

@@ -153,8 +153,34 @@ export const AgentTaskSchema = z.object({
   // Credential tracking
   credentialKeySuffix: z.string().optional(),
   credentialKeyType: z.string().optional(),
+
+  // User identity — canonical user who requested this task
+  requestedByUserId: z.string().optional(),
+});
+
+// ============================================================================
+// User Identity Types
+// ============================================================================
+
+export const UserSchema = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  email: z.string().optional(),
+  role: z.string().optional(),
+  notes: z.string().optional(),
+  slackUserId: z.string().optional(),
+  linearUserId: z.string().optional(),
+  githubUsername: z.string().optional(),
+  gitlabUsername: z.string().optional(),
+  emailAliases: z.array(z.string()).default([]),
+  preferredChannel: z.string().default("slack"),
+  timezone: z.string().optional(),
+  createdAt: z.iso.datetime(),
+  lastUpdatedAt: z.iso.datetime(),
 });
 
+export type User = z.infer<typeof UserSchema>;
+
 export const AgentStatusSchema = z.enum(["idle", "busy", "offline"]);
 
 export const AgentSchema = z.object({

package/src/workflows/engine.ts

@@ -19,7 +19,7 @@ import type { ExecutorRegistry } from "./executors/registry";
 import { resolveInputs } from "./input";
 import { validateJsonSchema } from "./json-schema-validator";
 import { deepInterpolate } from "./template";
-import { runStepValidation } from "./validation";
+import { runStepValidation, type ValidationRunResult } from "./validation";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_ITERATIONS = Number(process.env.WORKFLOW_MAX_ITERATIONS) || 100;
@@ -526,8 +526,9 @@ async function executeStep(
   }
 
   // 7. Run validation if configured
+  let validationResult: ValidationRunResult | undefined;
   if (node.validation) {
-    const validationResult = await runStepValidation(registry, node, result.output, ctx, meta);
+    validationResult = await runStepValidation(registry, node, result.output, ctx, meta);
 
     if (validationResult.outcome === "halt") {
       const errorMsg = "Validation failed (mustPass)";
@@ -555,10 +556,23 @@ async function executeStep(
     }
   }
 
-  // 8. Checkpoint success
+  // 8. Set nextPort from validation result for record-based routing
+  // When validation determines pass/fail and the node uses port-based `next`,
+  // route to the correct port instead of activating all ports.
+  if (
+    validationResult?.passed !== undefined &&
+    !result.nextPort &&
+    node.next &&
+    typeof node.next === "object" &&
+    !Array.isArray(node.next)
+  ) {
+    result.nextPort = validationResult.passed ? "pass" : "fail";
+  }
+
+  // 9. Checkpoint success
   checkpointStep(runId, stepId, node.id, result, ctx);
 
-  // 9. Determine successors based on nextPort
+  // 10. Determine successors based on nextPort
   // If executor returned a specific port, use it. Otherwise, get all successors
   // (fan-out behavior for non-branching nodes with record-based `next`).
   const successors = result.nextPort

package/src/workflows/executors/script.ts

@@ -41,9 +41,24 @@ export class ScriptExecutor extends BaseExecutor<
     try {
       const result = await Promise.race([this.runScript(config), this.timeoutPromise(timeoutMs)]);
 
+      // If stdout is valid JSON object, merge parsed fields into output
+      // so downstream nodes can access them via {{myScript.field}} interpolation
+      // (mirrors how agent-task nodes parse JSON in resume.ts)
+      let output: Record<string, unknown> = result;
+      if (result.exitCode === 0 && result.stdout) {
+        try {
+          const parsed = JSON.parse(result.stdout);
+          if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            output = { ...result, ...parsed };
+          }
+        } catch {
+          // Not valid JSON — keep raw {exitCode, stdout, stderr}
+        }
+      }
+
       return {
         status: "success",
-        output: result,
+        output: output as typeof result,
         nextPort: result.exitCode === 0 ? "success" : "failure",
       };
     } catch (err) {

package/src/workflows/validation.ts

@@ -5,6 +5,8 @@ export type ValidationOutcome = "pass" | "halt" | "retry";
 
 export interface ValidationRunResult {
   outcome: ValidationOutcome;
+  /** Whether the validation actually passed (true) or failed (false). */
+  passed?: boolean;
   /** Context additions if retry is needed */
   retryContext?: Record<string, unknown>;
 }
@@ -82,7 +84,7 @@ export async function runStepValidation(
   const passed = result.status === "success" && extractPassResult(executorType, result.output);
 
   if (passed) {
-    return { outcome: "pass" };
+    return { outcome: "pass", passed: true };
   }
 
   // Validation failed
@@ -90,15 +92,16 @@ export async function runStepValidation(
     if (validation.retry) {
       return {
         outcome: "retry",
+        passed: false,
         retryContext: {
           previousOutput: stepOutput,
           validationResult: result.output,
         },
       };
     }
-    return { outcome: "halt" };
+    return { outcome: "halt", passed: false };
   }
 
   // mustPass is false — treat failure as pass (advisory validation)
-  return { outcome: "pass" };
+  return { outcome: "pass", passed: false };
 }