@evalops/maestro 0.10.31 → 0.10.33

package/dist/cli/commands/a2a.js

@@ -7,166 +7,18 @@ import { buildA2ACockpit } from "../../platform/a2a-cockpit.js";
 import { inspectA2AFleet } from "../../platform/a2a-fleet.js";
 import { buildMaestroA2APeerProjection, defaultMaestroA2ACapabilities, } from "../../platform/a2a-maestro-peer.js";
 import { createA2APeerPairingPayload, createA2APeerPairingPayloadFromAgentCard, decodeA2APeerPairingCode, encodeA2APeerPairingCode, resolveA2AAgentCardUrl, } from "../../platform/a2a-peer-pairing.js";
-import { listA2APeers, loadA2APeerRegistry, normalizePeerName, resolveA2APeer, saveA2APeerRegistry, upsertA2APeerFromPairingPayload, } from "../../platform/a2a-peer-registry.js";
+import { listA2APeers, loadA2APeerRegistry, resolveA2APeer, saveA2APeerRegistry, upsertA2APeerFromPairingPayload, } from "../../platform/a2a-peer-registry.js";
 import { extractA2ATaskText, getA2ATaskLedgerPath, isActionRequiredA2AState, isFinalA2AState, isTerminalA2AState, listA2ATaskEntries, loadA2ATaskLedger, recordA2ATaskReply, recordA2ATaskStart, updateA2ATaskInLedger, } from "../../platform/a2a-task-ledger.js";
 import { inspectA2ATelemetry, } from "../../platform/a2a-telemetry-inspect.js";
 import { extractA2AWorkGraphMetadata, formatA2AWorkGraphCodexSubagents, formatA2AWorkGraphSummary, } from "../../platform/a2a-work-graph.js";
 import { PlatformA2ADelegationTaskControlModeValue, PlatformAgentStatusValue, controlA2ADelegationTaskWithPlatform, delegateAgentWithPlatform, getA2ADelegationGraphWithPlatform, heartbeatAgentWithPlatform, isAgentAlreadyExistsError, listA2APeerCandidatesWithEvidenceWithPlatform, registerAgentWithPlatform, updateAgentWithPlatform, } from "../../platform/agent-registry-client.js";
 import { getEnvValue } from "../../platform/client.js";
 import { isAbortError } from "../../utils/abort-error.js";
+import { booleanFlag, canonicalA2ASubcommand, minutesFlag, nonNegativeNumberFlag, numberFlag, parseA2AArgs, stringFlag, stringListFlag, } from "./a2a/args.js";
+import { a2ADiscoveryEvidenceMetadata, a2ADiscoverySelectionPayload, a2APeerMetadataWithoutDiscoveryEvidence, compactA2APeerMetadata, discoveredPeerJson, discoveredPeerName, printA2ADiscoveryEvidence, uniqueDiscoveredPeerName, } from "./a2a/discovery.js";
+export { parseA2AArgs } from "./a2a/args.js";
 const DEFAULT_WAIT_MS = 300_000;
 const DEFAULT_WAIT_INTERVAL_MS = 5_000;
-const A2A_VALUE_FLAGS_BY_SUBCOMMAND = {
-    accept: [
-        "--name",
-        "--organization-id",
-        "--registry",
-        "--token-env",
-        "--token-file",
-        "--workspace-id",
-    ],
-    card: ["--registry", "--timeout-ms"],
-    cockpit: ["--registry", "--tasks", "--timeout-ms", "--peer", "--limit"],
-    discover: [
-        "--capability",
-        "--limit",
-        "--offset",
-        "--registry",
-        "--skill",
-        "--status",
-        "--surface",
-        "--workspace-id",
-    ],
-    delegate: [
-        "--capability",
-        "--cwd",
-        "--from-agent-id",
-        "--interval-ms",
-        "--limit",
-        "--max-wait-ms",
-        "--objective-id",
-        "--offset",
-        "--registry",
-        "--reason",
-        "--role",
-        "--skill",
-        "--status",
-        "--surface",
-        "--tasks",
-        "--timeout-ms",
-        "--to-agent-id",
-        "--workspace-id",
-        "--workflow-run-id",
-        "--workflow-step-id",
-    ],
-    coordinate: [
-        "--interval-ms",
-        "--max-wait-ms",
-        "--registry",
-        "--reply",
-        "--tasks",
-        "--timeout-ms",
-    ],
-    control: [
-        "--child-run-id",
-        "--delegation-id",
-        "--idempotency-key",
-        "--message",
-        "--mode",
-        "--subagent-lane-id",
-        "--target-run-id",
-        "--work-item-id",
-        "--workspace-id",
-    ],
-    fleet: ["--registry", "--tasks", "--timeout-ms"],
-    graph: [
-        "--delegation-id",
-        "--limit",
-        "--max-depth",
-        "--root",
-        "--root-delegation-id",
-        "--workspace-id",
-    ],
-    offer: [
-        "--agent-card-url",
-        "--base-url",
-        "--name",
-        "--peer-id",
-        "--ttl-minutes",
-        "--url",
-    ],
-    peers: ["--registry"],
-    register: [
-        "--agent-card-etag",
-        "--agent-card-hash",
-        "--agent-card-url",
-        "--agent-id",
-        "--capabilities",
-        "--description",
-        "--internal-url",
-        "--name",
-        "--owner-id",
-        "--protocol-version",
-        "--public-url",
-        "--security-schemes",
-        "--status",
-        "--surface",
-        "--surface-types",
-        "--type",
-        "--url",
-        "--workspace-id",
-    ],
-    reply: [
-        "--interval-ms",
-        "--max-wait-ms",
-        "--registry",
-        "--tasks",
-        "--timeout-ms",
-    ],
-    send: [
-        "--interval-ms",
-        "--max-wait-ms",
-        "--registry",
-        "--tasks",
-        "--timeout-ms",
-    ],
-    tasks: ["--registry", "--tasks", "--timeout-ms"],
-    telemetry: ["--events", "--swarm-id"],
-    wait: [
-        "--interval-ms",
-        "--max-wait-ms",
-        "--registry",
-        "--tasks",
-        "--timeout-ms",
-    ],
-};
-const A2A_BOOLEAN_FLAGS_BY_SUBCOMMAND = {
-    accept: ["--default"],
-    cockpit: ["--json"],
-    coordinate: ["--json", "--refresh", "--wait", "--work-graph"],
-    delegate: [
-        "--discover",
-        "--platform",
-        "--prefer-internal",
-        "--wait",
-        "--work-graph",
-    ],
-    discover: ["--default", "--import", "--json", "--prefer-internal"],
-    fleet: ["--json"],
-    graph: ["--json"],
-    register: ["--heartbeat-only", "--json", "--no-heartbeat", "--update-only"],
-    reply: ["--wait", "--work-graph"],
-    send: ["--wait", "--work-graph"],
-    tasks: ["--json", "--refresh", "--work-graph"],
-    telemetry: ["--json"],
-    wait: ["--work-graph"],
-};
-const A2A_COLLECT_VALUE_FLAGS_BY_SUBCOMMAND = {
-    coordinate: ["--reply"],
-    control: ["--message"],
-};
-const A2A_LEADING_VALUE_FLAGS = new Set(Object.values(A2A_VALUE_FLAGS_BY_SUBCOMMAND).flat());
-const A2A_LEADING_BOOLEAN_FLAGS = new Set(Object.values(A2A_BOOLEAN_FLAGS_BY_SUBCOMMAND).flat());
 export async function handleA2ACommand(args) {
     const parsed = parseA2AArgs(args);
     const subcommand = canonicalA2ASubcommand(parsed.positionals.shift());
@@ -232,137 +84,6 @@ export async function handleA2ACommand(args) {
             printA2AHelp();
     }
 }
-export function parseA2AArgs(args) {
-    const flags = new Map();
-    const positionals = [];
-    const subcommandIndex = findA2ASubcommandIndex(args);
-    const subcommand = subcommandIndex >= 0
-        ? canonicalA2ASubcommand(args[subcommandIndex])
-        : "help";
-    const valueFlags = new Set(A2A_VALUE_FLAGS_BY_SUBCOMMAND[subcommand] ?? []);
-    const booleanFlags = new Set(A2A_BOOLEAN_FLAGS_BY_SUBCOMMAND[subcommand] ?? []);
-    if (subcommand === "delegate" && args.includes("--platform")) {
-        booleanFlags.add("--json");
-    }
-    const collectValueFlags = new Set(A2A_COLLECT_VALUE_FLAGS_BY_SUBCOMMAND[subcommand] ?? []);
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        if (!arg)
-            continue;
-        if (arg === "--") {
-            positionals.push(...args.slice(index + 1));
-            break;
-        }
-        if (arg.startsWith("--")) {
-            const [flag, inlineValue] = arg.split("=", 2);
-            if (!flag) {
-                continue;
-            }
-            if (index < subcommandIndex &&
-                !valueFlags.has(flag) &&
-                !booleanFlags.has(flag) &&
-                (A2A_LEADING_VALUE_FLAGS.has(flag) ||
-                    A2A_LEADING_BOOLEAN_FLAGS.has(flag))) {
-                if (A2A_LEADING_VALUE_FLAGS.has(flag) && inlineValue === undefined) {
-                    index++;
-                }
-                continue;
-            }
-            if (!valueFlags.has(flag) && !booleanFlags.has(flag)) {
-                positionals.push(arg);
-                continue;
-            }
-            if (inlineValue !== undefined) {
-                if (collectValueFlags.has(flag) && !inlineValue.trim()) {
-                    throw new Error(collectValueFlagMissingTextMessage(flag, subcommand));
-                }
-                flags.set(flag, inlineValue);
-                continue;
-            }
-            if (booleanFlags.has(flag)) {
-                flags.set(flag, true);
-                continue;
-            }
-            if (collectValueFlags.has(flag)) {
-                const values = [];
-                while (args[index + 1] && args[index + 1] !== "--") {
-                    const next = args[index + 1];
-                    const [nextFlag] = next.split("=", 2);
-                    if (next.startsWith("--") &&
-                        nextFlag &&
-                        (valueFlags.has(nextFlag) || booleanFlags.has(nextFlag))) {
-                        break;
-                    }
-                    values.push(next);
-                    index++;
-                }
-                const value = values.join(" ").trim();
-                if (!value) {
-                    throw new Error(collectValueFlagMissingTextMessage(flag, subcommand));
-                }
-                flags.set(flag, value);
-                continue;
-            }
-            const next = args[index + 1];
-            if (next && next !== "--") {
-                flags.set(flag, next);
-                index++;
-                continue;
-            }
-            flags.set(flag, true);
-            continue;
-        }
-        positionals.push(arg);
-    }
-    return { flags, positionals };
-}
-function collectValueFlagMissingTextMessage(flag, subcommand) {
-    const usage = subcommand === "coordinate" && flag === "--reply"
-        ? "\nUsage: maestro a2a coordinate [peer] --reply <text> [--wait]"
-        : "";
-    return `${flag} requires text${usage}`;
-}
-function findA2ASubcommandIndex(args) {
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        if (!arg || arg === "--") {
-            break;
-        }
-        if (!arg.startsWith("--")) {
-            return index;
-        }
-        const [flag = "", inlineValue] = arg.split("=", 2);
-        if (A2A_LEADING_VALUE_FLAGS.has(flag) && inlineValue === undefined) {
-            index++;
-            continue;
-        }
-        if (A2A_LEADING_VALUE_FLAGS.has(flag) ||
-            A2A_LEADING_BOOLEAN_FLAGS.has(flag)) {
-            continue;
-        }
-        break;
-    }
-    return -1;
-}
-function canonicalA2ASubcommand(input) {
-    switch (input?.toLowerCase()) {
-        case "pair":
-        case "create":
-            return "offer";
-        case "list":
-            return "peers";
-        case "dashboard":
-            return "cockpit";
-        case "delegation":
-            return "delegate";
-        case "continue":
-            return "reply";
-        case "publish":
-            return "register";
-        default:
-            return input?.toLowerCase() ?? "help";
-    }
-}
 async function handleA2AOffer(parsed) {
     const baseUrl = stringFlag(parsed, "--url") ?? stringFlag(parsed, "--base-url");
     const agentCardUrl = resolveA2AAgentCardUrl(stringFlag(parsed, "--agent-card-url") ??
@@ -1768,154 +1489,7 @@ function printWorkGraphLines(workGraph, includeDetails) {
         console.log(chalk.dim(`  Correlation: ${workGraph.correlationPath}`));
     }
 }
-function printA2ADiscoveryEvidence(evidence) {
-    if (!evidence) {
-        return;
-    }
-    const summary = [
-        evidence.decision ? `decision=${evidence.decision}` : undefined,
-        evidence.reason ? `reason=${evidence.reason}` : undefined,
-        evidence.matchedCount !== undefined
-            ? `matched=${evidence.matchedCount}`
-            : undefined,
-        evidence.candidateCount !== undefined
-            ? `candidates=${evidence.candidateCount}`
-            : undefined,
-        evidence.a2aSkillId ? `skill=${evidence.a2aSkillId}` : undefined,
-        evidence.capability ? `capability=${evidence.capability}` : undefined,
-    ]
-        .filter(Boolean)
-        .join(" ");
-    if (summary) {
-        console.log(chalk.dim(`  discovery ${summary}`));
-    }
-    if (evidence.exclusions?.length) {
-        const exclusions = evidence.exclusions
-            .map((exclusion) => [
-            exclusion.reason,
-            exclusion.count !== undefined ? `count=${exclusion.count}` : "",
-        ]
-            .filter(Boolean)
-            .join(":"))
-            .filter(Boolean)
-            .join(", ");
-        if (exclusions) {
-            console.log(chalk.dim(`  exclusions ${exclusions}`));
-        }
-    }
-}
 export const isA2AWaitCompletionState = isTerminalA2AState;
-function discoveredPeerJson(candidate) {
-    return {
-        ...(candidate.agent.id ? { agentId: candidate.agent.id } : {}),
-        ...(candidate.agent.name ? { name: candidate.agent.name } : {}),
-        ...(candidate.agent.status ? { status: candidate.agent.status } : {}),
-        endpointUrl: candidate.endpointUrl,
-        ...(candidate.endpointKind ? { endpointKind: candidate.endpointKind } : {}),
-        ...(candidate.agentCardUrl ? { agentCardUrl: candidate.agentCardUrl } : {}),
-        ...(candidate.protocolBinding
-            ? { protocolBinding: candidate.protocolBinding }
-            : {}),
-        ...(candidate.protocolVersion
-            ? { protocolVersion: candidate.protocolVersion }
-            : {}),
-        skills: candidate.skills,
-        ...(candidate.supportedExtensions
-            ? { supportedExtensions: candidate.supportedExtensions }
-            : {}),
-        ...(candidate.pushNotifications === undefined
-            ? {}
-            : { pushNotifications: candidate.pushNotifications }),
-    };
-}
-function discoveredPeerName(candidate, index) {
-    const raw = candidate.agent.id ??
-        candidate.agent.name ??
-        `platform-a2a-peer-${index + 1}`;
-    const sanitized = raw
-        .trim()
-        .replace(/[^A-Za-z0-9_.-]+/gu, "-")
-        .replace(/^-+|-+$/gu, "")
-        .slice(0, 80) || `platform-a2a-peer-${index + 1}`;
-    return normalizePeerName(sanitized);
-}
-function uniqueDiscoveredPeerName(input) {
-    for (let suffix = 1; suffix <= 100; suffix++) {
-        const name = suffix === 1 ? input.baseName : suffixedPeerName(input.baseName, suffix);
-        const existing = input.peers[name];
-        const hasSameAgentId = Boolean(existing?.agentId &&
-            input.candidate.agent.id &&
-            existing.agentId === input.candidate.agent.id);
-        const hasSameEndpoint = existing?.url === input.candidate.endpointUrl;
-        if (!input.importedNames.has(name) &&
-            (!existing || hasSameAgentId || hasSameEndpoint)) {
-            input.importedNames.add(name);
-            return name;
-        }
-    }
-    throw new Error(`Could not derive a unique A2A peer name for ${input.baseName}`);
-}
-function suffixedPeerName(baseName, suffix) {
-    const suffixText = `-${suffix}`;
-    return normalizePeerName(`${baseName.slice(0, 80 - suffixText.length)}${suffixText}`);
-}
-function a2ADiscoveryEvidenceMetadata(evidence) {
-    if (!evidence) {
-        return {};
-    }
-    return (compactA2APeerMetadata({
-        platformDiscoverySchema: evidence.schema,
-        platformDiscoveryDecision: evidence.decision,
-        platformDiscoveryReason: evidence.reason,
-        platformDiscoveryWorkspaceId: evidence.workspaceId,
-        platformDiscoveryCapability: evidence.capability,
-        platformDiscoveryAgentType: evidence.agentType,
-        platformDiscoveryA2ASkillId: evidence.a2aSkillId,
-        platformDiscoveryTaskClass: evidence.taskClass,
-        platformDiscoveryRequireA2ADispatch: evidence.requireA2ADispatch,
-        platformDiscoverySurface: evidence.surface,
-        platformDiscoveryStatus: evidence.status,
-        platformDiscoveryCandidateCount: evidence.candidateCount,
-        platformDiscoveryMatchedCount: evidence.matchedCount,
-    }) ?? {});
-}
-function a2APeerMetadataWithoutDiscoveryEvidence(metadata) {
-    if (!metadata) {
-        return undefined;
-    }
-    const entries = Object.entries(metadata).filter(([key]) => !key.startsWith("platformDiscovery"));
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function a2ADiscoverySelectionPayload(selection) {
-    if (!selection) {
-        return undefined;
-    }
-    return compactA2AUnknownRecord({
-        source: selection.source,
-        ...a2ADiscoveryEvidenceMetadata(selection.evidence),
-        selectedAgentId: selection.selectedAgentId,
-        selectedAgentName: selection.selectedAgentName,
-        selectedEndpointUrl: selection.selectedEndpointUrl,
-        selectedEndpointKind: selection.selectedEndpointKind,
-        score: selection.score,
-        reasons: selection.reasons,
-        candidateCount: selection.candidateCount,
-        matchedCount: selection.matchedCount,
-    });
-}
-function compactA2AUnknownRecord(record) {
-    const entries = Object.entries(record).filter(([, value]) => {
-        if (value === undefined) {
-            return false;
-        }
-        return !Array.isArray(value) || value.length > 0;
-    });
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function compactA2APeerMetadata(record) {
-    const entries = Object.entries(record).filter((entry) => entry[1] !== undefined);
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
 function baseUrlFromAgentCardUrl(agentCardUrl) {
     const parsed = new URL(agentCardUrl);
     parsed.pathname = parsed.pathname.replace(/\/\.well-known\/agent-card\.json$/u, "");
@@ -1923,50 +1497,6 @@ function baseUrlFromAgentCardUrl(agentCardUrl) {
     parsed.hash = "";
     return parsed.toString().replace(/\/+$/u, "");
 }
-function stringFlag(parsed, name) {
-    const value = parsed.flags.get(name);
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function stringListFlag(parsed, name, fallback) {
-    const value = stringFlag(parsed, name);
-    if (!value) {
-        return fallback;
-    }
-    const parsedValues = value
-        .split(",")
-        .map((item) => item.trim())
-        .filter(Boolean);
-    return parsedValues.length > 0 ? parsedValues : fallback;
-}
-function numberFlag(parsed, name) {
-    const value = stringFlag(parsed, name);
-    if (!value) {
-        return undefined;
-    }
-    const parsedValue = Number(value);
-    if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
-        throw new Error(`${name} must be a positive number`);
-    }
-    return parsedValue;
-}
-function nonNegativeNumberFlag(parsed, name) {
-    const value = stringFlag(parsed, name);
-    if (!value) {
-        return undefined;
-    }
-    const parsedValue = Number(value);
-    if (!Number.isFinite(parsedValue) || parsedValue < 0) {
-        throw new Error(`${name} must be a non-negative number`);
-    }
-    return parsedValue;
-}
-function minutesFlag(parsed, name) {
-    const value = numberFlag(parsed, name);
-    return value === undefined ? undefined : value * 60 * 1000;
-}
-function booleanFlag(parsed, name) {
-    return parsed.flags.get(name) === true;
-}
 function formatCockpitTaskStatus(status) {
     switch (status) {
         case "waiting":