@evalops/maestro 0.10.22 → 0.10.24

package/dist/agent/swarm/executor.js

@@ -6,7 +6,7 @@
  * the Oracle tool pattern.
  */
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -15,11 +15,12 @@ import { codexSubagentTypeA2ASkillID } from "../../codex/subagent-dispatch-table
 import { buildEvalOpsDelegationEnvironment, issueEvalOpsDelegationToken, } from "../../oauth/index.js";
 import { rankA2ACapabilityPeers } from "../../platform/a2a-capability-market.js";
 import { buildA2AUserMessage, cancelA2ATask, getA2ATask, normalizeA2ABaseUrl, sendA2AMessage, } from "../../platform/a2a-client.js";
+import { a2aDelegationLaneId } from "../../platform/a2a-completion-audit.js";
 import { resolveA2APeer, } from "../../platform/a2a-peer-registry.js";
 import { extractA2ATaskText, isTerminalA2AState, recordA2ATaskStart, updateA2ATaskInLedger, } from "../../platform/a2a-task-ledger.js";
 import { PlatformAgentStatusValue, listA2APeerCandidatesWithPlatform, resolveAgentRegistryServiceConfig, } from "../../platform/agent-registry-client.js";
 import { getEnvValue, trimString } from "../../platform/client.js";
-import { recordSubagentDispatch } from "../../telemetry.js";
+import { recordA2ADelegationTelemetry as recordA2ADelegationTelemetryEvent, recordSubagentDispatch, } from "../../telemetry.js";
 import { createLogger } from "../../utils/logger.js";
 import { parseMode, resolveSubagentDispatch, } from "../modes.js";
 import { publishSwarmRuntimeEvent } from "./runtime-events.js";
@@ -214,6 +215,47 @@ function resolveA2APushNotificationConfig(configured) {
 function a2aStateCompleted(state) {
     return /COMPLETED/u.test((state ?? "").toUpperCase().replace(/[\s-]+/gu, "_"));
 }
+function hashA2AEndpointUrlForTelemetry(url) {
+    const trimmed = url?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const canonical = canonicalizeA2AEndpointUrlForTelemetry(trimmed);
+    return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+}
+function platformA2APeerRouteName(candidate, endpointHash = hashA2AEndpointUrlForTelemetry(candidate.endpointUrl)) {
+    const configuredName = trimString(candidate.agent.name) ?? trimString(candidate.agent.id);
+    if (configuredName) {
+        return configuredName;
+    }
+    return endpointHash
+        ? `endpoint:${endpointHash}`
+        : "platform-agent-registry-peer";
+}
+function canonicalizeA2AEndpointUrlForTelemetry(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.username = "";
+        parsed.password = "";
+        parsed.search = "";
+        parsed.hash = "";
+        parsed.pathname = parsed.pathname.replace(/\/+$/u, "") || "/";
+        return normalizeA2ABaseUrl(parsed.toString().replace(/\/$/u, ""));
+    }
+    catch {
+        return normalizeA2ABaseUrl(url.replace(/[?#].*$/u, "").replace(/\/+$/u, ""));
+    }
+}
+function a2aTerminalPhase(state) {
+    const normalized = (state ?? "").toUpperCase().replace(/[\s-]+/gu, "_");
+    if (normalized.includes("COMPLETED")) {
+        return "task_completed";
+    }
+    if (normalized.includes("CANCEL")) {
+        return "task_cancelled";
+    }
+    return "task_failed";
+}
 function buildDispatchEnv(dispatch, reasoningEffortOverride, runtimeSelection) {
     if (!dispatch) {
         return {};
@@ -238,6 +280,7 @@ export class SwarmExecutor {
     constructor(config) {
         this.processes = new Map();
         this.remoteA2ATasks = new Map();
+        this.remoteA2ACancelTasks = new Map();
         this.a2aRouteCursor = 0;
         this.eventHandlers = new Set();
         // Validate config
@@ -340,22 +383,32 @@ export class SwarmExecutor {
         logger.info("Swarm cancelled", { swarmId: this.state.id });
     }
     async cancelRemoteA2ATask(teammateId, remoteTask) {
-        try {
-            const cancelledTask = await cancelA2ATask(remoteTask.route.config, remoteTask.taskId);
-            await this.updateA2ASwarmTaskLedger(remoteTask.route, cancelledTask);
-        }
-        catch (error) {
-            logger.warn("Failed to cancel remote A2A swarm task", {
-                error: error instanceof Error ? error.message : String(error),
-                swarmId: this.state.id,
-                teammateId,
-                remoteTaskId: remoteTask.taskId,
-                peer: remoteTask.route.name,
-            });
-        }
-        finally {
-            this.remoteA2ATasks.delete(teammateId);
+        const existingCancel = this.remoteA2ACancelTasks.get(teammateId);
+        if (existingCancel) {
+            return existingCancel;
         }
+        const cancelTask = (async () => {
+            try {
+                const cancelledTask = await cancelA2ATask(remoteTask.route.config, remoteTask.taskId);
+                await this.updateA2ASwarmTaskLedger(remoteTask.route, cancelledTask);
+                return cancelledTask;
+            }
+            catch (error) {
+                logger.warn("Failed to cancel remote A2A swarm task", {
+                    error: error instanceof Error ? error.message : String(error),
+                    swarmId: this.state.id,
+                    teammateId,
+                    remoteTaskId: remoteTask.taskId,
+                    peer: remoteTask.route.name,
+                });
+                return undefined;
+            }
+            finally {
+                this.remoteA2ATasks.delete(teammateId);
+            }
+        })();
+        this.remoteA2ACancelTasks.set(teammateId, cancelTask);
+        return cancelTask;
     }
     /**
      * Execute the swarm - runs all tasks with available teammates.
@@ -537,7 +590,7 @@ export class SwarmExecutor {
         }
         const mode = this.resolveParentMode();
         const parentProvider = this.resolveParentModelProvider();
-        const dispatch = resolveSubagentDispatch(mode, subagentType, parentProvider ?? "anthropic");
+        const dispatch = resolveSubagentDispatch(mode, subagentType, parentProvider ?? "openai-codex");
         if (!parentProvider && dispatch.modelTier && !options.hasModelOverride) {
             this.recordTaskDispatch(task, dispatch, Math.max(0, Date.now() - startedAt), false, {
                 parentMode: mode,
@@ -639,13 +692,16 @@ export class SwarmExecutor {
             timeoutMs: options.timeoutMs,
             maxAttempts: options.maxAttempts,
         });
+        const skillId = this.resolveA2ASkillId(task, options, peer);
         return {
             name: peer.name,
             displayName: peer.entry.displayName,
             config: peer.config,
-            skillId: this.resolveA2ASkillId(task, options, peer),
+            skillId,
+            taskClass: this.resolveA2ATaskClass(task, options, skillId),
             role: options.role ?? task.subagentType,
             tasksPath: options.tasksPath,
+            peerEndpointHash: hashA2AEndpointUrlForTelemetry(peer.config.baseUrl),
             source: "registry",
         };
     }
@@ -697,13 +753,20 @@ export class SwarmExecutor {
             skillId: ranked.selectedSkill?.id ?? skillId,
         });
         const config = await this.a2aConfigForPlatformCandidate(candidate, options);
+        const selectedSkillId = ranked.selectedSkill?.id ?? skillId;
+        const endpointHash = hashA2AEndpointUrlForTelemetry(candidate.endpointUrl);
+        const routeName = platformA2APeerRouteName(candidate, endpointHash);
         return {
-            name: candidate.agent.name ?? candidate.agent.id ?? candidate.endpointUrl,
+            name: routeName,
             displayName: candidate.agent.name,
             config,
-            skillId: ranked.selectedSkill?.id ?? skillId,
+            skillId: selectedSkillId,
+            taskClass: this.resolveA2ATaskClass(task, options, selectedSkillId),
             role: options.role ?? task.subagentType,
             tasksPath: options.tasksPath,
+            peerAgentId: candidate.agent.id,
+            peerEndpointHash: endpointHash,
+            peerEndpointKind: candidate.endpointKind,
             source: "platform-agent-registry",
         };
     }
@@ -1008,10 +1071,20 @@ export class SwarmExecutor {
         });
     }
     async spawnA2ATeammate(teammate, task, prompt, tmpFile, options) {
+        let route;
+        let messageId;
+        let contextId;
+        let a2aTaskId;
+        const startedAt = Date.now();
         try {
-            const route = await this.resolveA2ATeammateRoute(teammate, task, options);
-            const messageId = `maestro-swarm-message-${randomUUID()}`;
-            const contextId = `maestro-swarm:${this.state.id}:${task.id}`;
+            route = await this.resolveA2ATeammateRoute(teammate, task, options);
+            messageId = `maestro-swarm-message-${randomUUID()}`;
+            contextId = `maestro-swarm:${this.state.id}:${task.id}`;
+            this.recordA2ADelegationTelemetry("peer_selected", route, teammate, task, {
+                contextId,
+                messageId,
+            });
+            const dispatchStartedAt = Date.now();
             const sent = await sendA2AMessage(route.config, {
                 message: buildA2AUserMessage({
                     messageId,
@@ -1038,16 +1111,27 @@ export class SwarmExecutor {
                     source: route.source,
                 },
             });
+            a2aTaskId = sent.task.id;
+            contextId = sent.task.contextId ?? contextId;
+            const dispatchLatencyMs = Math.max(0, Date.now() - dispatchStartedAt);
             teammate.a2a = {
                 peer: route.name,
                 peerDisplayName: route.displayName,
                 source: route.source,
+                parentTaskId: task.id,
                 taskId: sent.task.id,
-                contextId: sent.task.contextId ?? contextId,
+                contextId,
                 messageId,
                 skillId: route.skillId,
                 role: route.role,
             };
+            this.recordA2ADelegationTelemetry("task_dispatched", route, teammate, task, {
+                a2aTaskId: sent.task.id,
+                contextId,
+                messageId,
+                status: sent.task.status.state,
+                latencyMs: dispatchLatencyMs,
+            });
             this.remoteA2ATasks.set(teammate.id, {
                 route,
                 taskId: sent.task.id,
@@ -1058,28 +1142,77 @@ export class SwarmExecutor {
             });
             if (this.state.status === "cancelled" ||
                 this.abortController.signal.aborted) {
-                await this.cancelRemoteA2ATask(teammate.id, {
+                const cancelledTask = await this.cancelRemoteA2ATask(teammate.id, {
                     route,
                     taskId: sent.task.id,
                 });
+                if (!cancelledTask) {
+                    return;
+                }
+                this.recordA2ADelegationTelemetry(a2aTerminalPhase(cancelledTask.status.state), route, teammate, task, {
+                    a2aTaskId: cancelledTask.id,
+                    contextId: cancelledTask.contextId ?? sent.task.contextId ?? contextId,
+                    messageId,
+                    status: cancelledTask.status.state,
+                    terminal: true,
+                    success: a2aStateCompleted(cancelledTask.status.state),
+                    durationMs: Math.max(0, Date.now() - startedAt),
+                });
                 return;
             }
             const remoteTask = await this.waitForA2ASwarmTask(route.config, sent.task, options);
             await this.updateA2ASwarmTaskLedger(route, remoteTask);
+            this.recordA2ADelegationTelemetry(a2aTerminalPhase(remoteTask.status.state), route, teammate, task, {
+                a2aTaskId: remoteTask.id,
+                contextId: remoteTask.contextId ?? contextId,
+                messageId,
+                status: remoteTask.status.state,
+                terminal: true,
+                success: a2aStateCompleted(remoteTask.status.state),
+                durationMs: Math.max(0, Date.now() - startedAt),
+            });
             this.completeA2ATeammate(teammate, task, remoteTask, route);
         }
         catch (error) {
-            if (this.state.status !== "cancelled" &&
-                !this.abortController.signal.aborted) {
-                const remoteTask = this.remoteA2ATasks.get(teammate.id);
-                if (remoteTask) {
-                    await this.cancelRemoteA2ATask(teammate.id, remoteTask);
+            const wasCancelled = this.state.status === "cancelled" ||
+                this.abortController.signal.aborted ||
+                teammate.status === "cancelled";
+            const remoteTask = this.remoteA2ATasks.get(teammate.id);
+            const pendingCancelTask = this.remoteA2ACancelTasks.get(teammate.id);
+            const cancelledTask = wasCancelled
+                ? await (pendingCancelTask ??
+                    (remoteTask
+                        ? this.cancelRemoteA2ATask(teammate.id, remoteTask)
+                        : Promise.resolve(undefined)))
+                : undefined;
+            if (!wasCancelled && remoteTask) {
+                await this.cancelRemoteA2ATask(teammate.id, remoteTask);
+            }
+            if (route) {
+                if (!wasCancelled || cancelledTask) {
+                    this.recordA2ADelegationTelemetry(wasCancelled
+                        ? a2aTerminalPhase(cancelledTask?.status.state)
+                        : "task_failed", route, teammate, task, {
+                        a2aTaskId: cancelledTask?.id ?? a2aTaskId,
+                        contextId: cancelledTask?.contextId ?? contextId,
+                        messageId,
+                        status: cancelledTask?.status.state ?? "TASK_STATE_FAILED",
+                        terminal: true,
+                        success: a2aStateCompleted(cancelledTask?.status.state),
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                        metadata: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
                 }
             }
-            this.failA2ATeammate(teammate, task, error);
+            this.failA2ATeammate(teammate, task, error, {
+                preserveA2A: Boolean(a2aTaskId),
+            });
         }
         finally {
             this.remoteA2ATasks.delete(teammate.id);
+            this.remoteA2ACancelTasks.delete(teammate.id);
             try {
                 unlinkSync(tmpFile);
             }
@@ -1088,6 +1221,40 @@ export class SwarmExecutor {
             }
         }
     }
+    recordA2ADelegationTelemetry(phase, route, _teammate, task, options = {}) {
+        const laneId = a2aDelegationLaneId(route.name, task.id);
+        recordA2ADelegationTelemetryEvent({
+            phase,
+            swarmId: this.state.id,
+            laneId,
+            parentTaskId: task.id,
+            a2aTaskId: options.a2aTaskId,
+            a2aMessageId: options.messageId,
+            contextId: options.contextId,
+            peerAgentId: route.peerAgentId,
+            peerName: route.name,
+            peerEndpointHash: route.peerEndpointHash,
+            peerEndpointUrl: undefined,
+            peerEndpointKind: route.peerEndpointKind,
+            skillId: route.skillId,
+            taskClass: route.taskClass,
+            source: route.source,
+            status: options.status,
+            terminal: options.terminal,
+            success: options.success,
+            latencyMs: options.latencyMs,
+            durationMs: options.durationMs,
+            metadata: options.metadata,
+            correlation: {
+                attributes: {
+                    swarm_id: this.state.id,
+                    lane_id: laneId,
+                    parent_task_id: task.id,
+                    peer: route.name,
+                },
+            },
+        });
+    }
     buildA2ASwarmMessageMetadata(teammate, task, route) {
         const currentDelegationId = `${this.state.id}:${task.id}`;
         const contextId = `maestro-swarm:${this.state.id}:${task.id}`;
@@ -1113,7 +1280,7 @@ export class SwarmExecutor {
         const peerControl = {
             schema: "evalops.maestro.a2a-peer-control.v1",
             parentSwarmId: this.state.id,
-            laneId: teammate.id,
+            laneId: a2aDelegationLaneId(route.name, task.id),
             taskId: task.id,
             contextId,
             controlModes: ["followup", "steer", "interrupt", "cancel"],
@@ -1217,7 +1384,7 @@ export class SwarmExecutor {
             teammate.error = undefined;
         }
     }
-    failA2ATeammate(teammate, task, error) {
+    failA2ATeammate(teammate, task, error, options = {}) {
         this.state.activeTasks.delete(task.id);
         teammate.completedAt = Date.now();
         teammate.currentTask = undefined;
@@ -1230,7 +1397,9 @@ export class SwarmExecutor {
             });
             return;
         }
-        if (teammate.a2a && !this.remoteA2ATasks.has(teammate.id)) {
+        if (teammate.a2a &&
+            !options.preserveA2A &&
+            !this.remoteA2ATasks.has(teammate.id)) {
             teammate.a2a = undefined;
         }
         teammate.status = "failed";
@@ -1338,6 +1507,10 @@ function platformA2ACandidateMatchesPeer(candidate, peer) {
         candidate.endpointUrl,
         candidate.agentCardUrl,
     ];
+    const endpointHash = hashA2AEndpointUrlForTelemetry(candidate.endpointUrl);
+    if (endpointHash) {
+        values.push(endpointHash, `endpoint:${endpointHash}`);
+    }
     return values.some((value) => {
         const candidateSelector = normalizePeerSelector(value);
         if (candidateSelector && candidateSelector === selector) {