@evalops/maestro 0.10.18 → 0.10.20

package/dist/platform/agent-runtime-client.js

@@ -1,20 +1,60 @@
+import { EVALOPS_ACCESS_TOKEN_ENV_VARS, EVALOPS_ORGANIZATION_ID_ENV_VARS, EVALOPS_WORKSPACE_ID_ENV_VARS, } from "../evalops/env-aliases.js";
+import { isAbortError } from "../utils/abort-error.js";
+import { buildA2AUserMessage, getA2ATask, resolveA2AServiceConfig, resolveA2ATraceContext, sendA2AMessage, } from "./a2a-client.js";
 import { gatherMaestroSessionFactsContext, } from "./cerebro-facts-client.js";
-import { postPlatformConnect, resolvePlatformServiceConfig, trimString, } from "./client.js";
+import { getEnvValue, normalizeBaseUrl, postPlatformConnect, resolvePlatformServiceConfig, trimString, } from "./client.js";
 import { PLATFORM_CONNECT_METHODS, PLATFORM_CONNECT_SERVICES, platformConnectMethodPath, platformConnectServicePath, } from "./core-services.js";
 const DEFAULT_TIMEOUT_MS = 2_000;
 const DEFAULT_MAX_ATTEMPTS = 2;
+const AGENT_RUNTIME_A2A_ENABLED_ENV_VARS = [
+    "MAESTRO_AGENT_RUNTIME_A2A_ENABLED",
+    "MAESTRO_PLATFORM_A2A_ENABLED",
+];
+const DEDICATED_A2A_BASE_URL_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_URL",
+    "MAESTRO_A2A_URL",
+];
+const DEDICATED_A2A_TOKEN_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_TOKEN",
+    "MAESTRO_A2A_TOKEN",
+];
+const DEDICATED_A2A_ORGANIZATION_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_ORG_ID",
+    "MAESTRO_A2A_ORG_ID",
+];
+const DEDICATED_A2A_WORKSPACE_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_WORKSPACE_ID",
+    "MAESTRO_A2A_WORKSPACE_ID",
+];
+const DEDICATED_A2A_TIMEOUT_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_TIMEOUT_MS",
+    "MAESTRO_A2A_TIMEOUT_MS",
+];
+const DEDICATED_A2A_MAX_ATTEMPTS_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_MAX_ATTEMPTS",
+    "MAESTRO_A2A_MAX_ATTEMPTS",
+];
+const DEDICATED_A2A_CALLBACK_URL_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_CALLBACK_URL",
+    "MAESTRO_A2A_CALLBACK_URL",
+];
+const DEDICATED_A2A_CALLBACK_TOKEN_ENV_VARS = [
+    "MAESTRO_PLATFORM_A2A_CALLBACK_TOKEN",
+    "MAESTRO_A2A_CALLBACK_TOKEN",
+];
 const HANDLE_TRIGGER_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.handleTrigger);
 const CLAIM_NEXT_RUN_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.claimNextRun);
 const RECORD_RUN_STEP_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.recordRunStep);
+const RECORD_RUN_EVENT_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.recordRunEvent);
+const RECORD_RUN_COST_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.recordRunCost);
+const RECORD_RUN_WORK_ITEM_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.recordRunWorkItem);
+const UPDATE_RUN_WORK_ITEM_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.updateRunWorkItem);
 const WAIT_RUN_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.waitRun);
 const RESUME_RUN_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.resumeRun);
 const COMPLETE_RUN_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.completeRun);
 const FAIL_RUN_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.failRun);
 const GET_RUN_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.getRun);
 const LIST_RUN_EVENTS_PATH = platformConnectMethodPath(PLATFORM_CONNECT_METHODS.agentRuntime.listRunEvents);
-function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
 const AGENT_RUNTIME_BASE_URL_ENV_VARS = [
     "MAESTRO_AGENT_RUNTIME_SERVICE_URL",
     "AGENT_RUNTIME_SERVICE_URL",
@@ -22,21 +62,18 @@ const AGENT_RUNTIME_BASE_URL_ENV_VARS = [
 const AGENT_RUNTIME_TOKEN_ENV_VARS = [
     "MAESTRO_AGENT_RUNTIME_SERVICE_TOKEN",
     "AGENT_RUNTIME_SERVICE_TOKEN",
-    "MAESTRO_EVALOPS_ACCESS_TOKEN",
-    "EVALOPS_TOKEN",
+    ...EVALOPS_ACCESS_TOKEN_ENV_VARS,
 ];
 const AGENT_RUNTIME_ORGANIZATION_ENV_VARS = [
     "MAESTRO_AGENT_RUNTIME_ORG_ID",
     "AGENT_RUNTIME_ORGANIZATION_ID",
-    "MAESTRO_EVALOPS_ORG_ID",
-    "EVALOPS_ORGANIZATION_ID",
-    "MAESTRO_ENTERPRISE_ORG_ID",
+    ...EVALOPS_ORGANIZATION_ID_ENV_VARS,
 ];
 const AGENT_RUNTIME_WORKSPACE_ENV_VARS = [
     "MAESTRO_AGENT_RUNTIME_WORKSPACE_ID",
     "AGENT_RUNTIME_WORKSPACE_ID",
     "MAESTRO_WORKSPACE_ID",
-    "EVALOPS_WORKSPACE_ID",
+    ...EVALOPS_WORKSPACE_ID_ENV_VARS.filter((name) => name !== "MAESTRO_WORKSPACE_ID"),
 ];
 const AGENT_RUNTIME_TIMEOUT_ENV_VARS = [
     "MAESTRO_AGENT_RUNTIME_TIMEOUT_MS",
@@ -71,6 +108,9 @@ export var PlatformRuntimeEventTypeValue;
     PlatformRuntimeEventTypeValue["RunResumed"] = "RUNTIME_EVENT_TYPE_RUN_RESUMED";
     PlatformRuntimeEventTypeValue["RunSucceeded"] = "RUNTIME_EVENT_TYPE_RUN_SUCCEEDED";
     PlatformRuntimeEventTypeValue["RunFailed"] = "RUNTIME_EVENT_TYPE_RUN_FAILED";
+    PlatformRuntimeEventTypeValue["AgentProgressRecorded"] = "RUNTIME_EVENT_TYPE_AGENT_PROGRESS_RECORDED";
+    PlatformRuntimeEventTypeValue["ModelResponseRecorded"] = "RUNTIME_EVENT_TYPE_MODEL_RESPONSE_RECORDED";
+    PlatformRuntimeEventTypeValue["ApprovalRequested"] = "RUNTIME_EVENT_TYPE_APPROVAL_REQUESTED";
 })(PlatformRuntimeEventTypeValue || (PlatformRuntimeEventTypeValue = {}));
 export var PlatformAgentRunStateValue;
 (function (PlatformAgentRunStateValue) {
@@ -108,6 +148,28 @@ export var PlatformAgentRunWaitTypeValue;
     PlatformAgentRunWaitTypeValue["Event"] = "AGENT_RUN_WAIT_TYPE_EVENT";
     PlatformAgentRunWaitTypeValue["Timer"] = "AGENT_RUN_WAIT_TYPE_TIMER";
 })(PlatformAgentRunWaitTypeValue || (PlatformAgentRunWaitTypeValue = {}));
+export var PlatformAgentWorkItemKindValue;
+(function (PlatformAgentWorkItemKindValue) {
+    PlatformAgentWorkItemKindValue["Root"] = "AGENT_WORK_ITEM_KIND_ROOT";
+    PlatformAgentWorkItemKindValue["ModelCall"] = "AGENT_WORK_ITEM_KIND_MODEL_CALL";
+    PlatformAgentWorkItemKindValue["ToolCall"] = "AGENT_WORK_ITEM_KIND_TOOL_CALL";
+    PlatformAgentWorkItemKindValue["ChildRun"] = "AGENT_WORK_ITEM_KIND_CHILD_RUN";
+    PlatformAgentWorkItemKindValue["Wait"] = "AGENT_WORK_ITEM_KIND_WAIT";
+    PlatformAgentWorkItemKindValue["Memory"] = "AGENT_WORK_ITEM_KIND_MEMORY";
+    PlatformAgentWorkItemKindValue["UserInput"] = "AGENT_WORK_ITEM_KIND_USER_INPUT";
+    PlatformAgentWorkItemKindValue["Followup"] = "AGENT_WORK_ITEM_KIND_FOLLOWUP";
+    PlatformAgentWorkItemKindValue["Recovery"] = "AGENT_WORK_ITEM_KIND_RECOVERY";
+})(PlatformAgentWorkItemKindValue || (PlatformAgentWorkItemKindValue = {}));
+export var PlatformAgentWorkItemStateValue;
+(function (PlatformAgentWorkItemStateValue) {
+    PlatformAgentWorkItemStateValue["Pending"] = "AGENT_WORK_ITEM_STATE_PENDING";
+    PlatformAgentWorkItemStateValue["Running"] = "AGENT_WORK_ITEM_STATE_RUNNING";
+    PlatformAgentWorkItemStateValue["Waiting"] = "AGENT_WORK_ITEM_STATE_WAITING";
+    PlatformAgentWorkItemStateValue["Blocked"] = "AGENT_WORK_ITEM_STATE_BLOCKED";
+    PlatformAgentWorkItemStateValue["Succeeded"] = "AGENT_WORK_ITEM_STATE_SUCCEEDED";
+    PlatformAgentWorkItemStateValue["Failed"] = "AGENT_WORK_ITEM_STATE_FAILED";
+    PlatformAgentWorkItemStateValue["Cancelled"] = "AGENT_WORK_ITEM_STATE_CANCELLED";
+})(PlatformAgentWorkItemStateValue || (PlatformAgentWorkItemStateValue = {}));
 export var MaestroAgentRuntimeSourceEventType;
 (function (MaestroAgentRuntimeSourceEventType) {
     MaestroAgentRuntimeSourceEventType["SessionStarted"] = "maestro.session_started";
@@ -121,6 +183,9 @@ function pickString(record, ...names) {
     }
     return undefined;
 }
+// Platform service responses can arrive from Connect JSON, protojson fixtures,
+// or A2A metadata. Keep casing tolerance here so HTTP handlers consume one
+// Maestro-owned shape instead of duplicating wire compatibility checks.
 function pickRecord(record, ...names) {
     for (const name of names) {
         const value = record?.[name];
@@ -210,6 +275,30 @@ function normalizeStep(value) {
         linkage: normalizeLinkage(record.linkage),
     };
 }
+function normalizeCost(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    const id = pickString(record, "id");
+    if (!id) {
+        return undefined;
+    }
+    return {
+        id,
+        linkage: normalizeLinkage(record.linkage),
+        stepId: pickString(record, "stepId", "step_id"),
+        meterRef: pickString(record, "meterRef", "meter_ref"),
+        provider: pickString(record, "provider"),
+        model: pickString(record, "model"),
+        inputTokens: pickNumber(record, "inputTokens", "input_tokens"),
+        outputTokens: pickNumber(record, "outputTokens", "output_tokens"),
+        totalTokens: pickNumber(record, "totalTokens", "total_tokens"),
+        currency: pickString(record, "currency"),
+        estimatedCostMicros: pickNumber(record, "estimatedCostMicros", "estimated_cost_micros"),
+        recordedAt: pickString(record, "recordedAt", "recorded_at"),
+    };
+}
 function normalizeCheckpoint(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return undefined;
@@ -245,6 +334,49 @@ function normalizeWait(value) {
         linkage: normalizeLinkage(record.linkage),
     };
 }
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const strings = value.filter((item) => typeof item === "string" && item.length > 0);
+    return strings.length > 0 ? strings : undefined;
+}
+function normalizeWorkItem(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    const id = pickString(record, "id");
+    if (!id) {
+        return undefined;
+    }
+    return {
+        id,
+        linkage: normalizeLinkage(record.linkage),
+        autonomySessionId: pickString(record, "autonomySessionId", "autonomy_session_id"),
+        runId: pickString(record, "runId", "run_id"),
+        workEnvelopeId: pickString(record, "workEnvelopeId", "work_envelope_id"),
+        parentWorkItemId: pickString(record, "parentWorkItemId", "parent_work_item_id"),
+        ownerChildRunId: pickString(record, "ownerChildRunId", "owner_child_run_id"),
+        kind: pickString(record, "kind"),
+        state: pickString(record, "state"),
+        title: pickString(record, "title"),
+        goal: pickString(record, "goal"),
+        nextAction: pickString(record, "nextAction", "next_action"),
+        blocker: pickString(record, "blocker"),
+        waitId: pickString(record, "waitId", "wait_id"),
+        toolExecutionId: pickString(record, "toolExecutionId", "tool_execution_id"),
+        evidenceRefs: normalizeStringArray(record.evidenceRefs ?? record.evidence_refs),
+        completionGate: pickString(record, "completionGate", "completion_gate"),
+        payload: pickRecord(record, "payload"),
+        createdAt: pickString(record, "createdAt", "created_at"),
+        updatedAt: pickString(record, "updatedAt", "updated_at"),
+        startedAt: pickString(record, "startedAt", "started_at"),
+        completedAt: pickString(record, "completedAt", "completed_at"),
+        failedAt: pickString(record, "failedAt", "failed_at"),
+        cancelledAt: pickString(record, "cancelledAt", "cancelled_at"),
+    };
+}
 function normalizeRun(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return undefined;
@@ -284,6 +416,7 @@ function normalizeEvent(value) {
         stepId: pickString(record, "stepId", "step_id"),
         waitId: pickString(record, "waitId", "wait_id"),
         checkpointId: pickString(record, "checkpointId", "checkpoint_id"),
+        costId: pickString(record, "costId", "cost_id"),
         attributes: pickRecord(record, "attributes"),
         occurredAt: pickString(record, "occurredAt", "occurred_at"),
     };
@@ -352,6 +485,10 @@ export function buildMaestroSessionRuntimeTrigger(input, fallbackWorkspaceId) {
         ["maestro-session", workspaceId, sessionId].join(":");
     const correlationId = trimString(input.correlationId) ?? ["maestro-session", sessionId].join(":");
     const actorId = trimString(input.actorId);
+    const traceContext = maestroRuntimeTraceContext(input);
+    // Session starts are idempotent per workspace/session pair. The channel and
+    // payload stay Maestro-shaped, while Platform receives enough typed linkage
+    // to build timelines, traces, and support views around the same session.
     return {
         workspaceId,
         agentId,
@@ -372,11 +509,14 @@ export function buildMaestroSessionRuntimeTrigger(input, fallbackWorkspaceId) {
                 route: "maestro_session",
                 maestro_session_id: sessionId,
                 source: "maestro",
+                traceparent: traceContext?.traceparent,
+                tracestate: traceContext?.tracestate,
             }),
         },
         triggerKind: PlatformRuntimeTriggerKindValue.Api,
         payload: {
             maestroSessionId: sessionId,
+            ...(traceContext ? { trace_context: traceContext } : {}),
             ...(input.metadata ? { metadata: input.metadata } : {}),
             ...(input.factsContext ? { facts_context: input.factsContext } : {}),
         },
@@ -411,6 +551,74 @@ export async function recordAgentRuntimeRunStep(input, options) {
         event: normalizeEvent(payload.event),
     };
 }
+export async function recordAgentRuntimeRunEvent(input, options) {
+    const payload = await postAgentRuntimeOperation(RECORD_RUN_EVENT_PATH, {
+        runId: input.runId,
+        type: input.type,
+        message: input.message,
+        ...(input.attributes ? { attributes: input.attributes } : {}),
+        ...(input.stepId ? { stepId: input.stepId } : {}),
+        ...(input.checkpointId ? { checkpointId: input.checkpointId } : {}),
+        ...(input.artifactId ? { artifactId: input.artifactId } : {}),
+        ...(input.costId ? { costId: input.costId } : {}),
+        ...(input.waitId ? { waitId: input.waitId } : {}),
+        ...(input.visibility ? { visibility: input.visibility } : {}),
+    }, options);
+    return {
+        run: normalizeRequiredRun(payload),
+        event: normalizeEvent(payload.event),
+    };
+}
+export async function recordAgentRuntimeRunCost(input, options) {
+    const payload = await postAgentRuntimeOperation(RECORD_RUN_COST_PATH, {
+        runId: input.runId,
+        leaseToken: input.leaseToken,
+        cost: input.cost,
+    }, options);
+    return {
+        run: normalizeRequiredRun(payload),
+        cost: normalizeCost(payload.cost),
+        event: normalizeEvent(payload.event),
+    };
+}
+export async function recordAgentRuntimeRunWorkItem(input, options) {
+    const payload = await postAgentRuntimeOperation(RECORD_RUN_WORK_ITEM_PATH, {
+        runId: input.runId,
+        workItem: input.workItem,
+    }, options);
+    return {
+        run: normalizeRequiredRun(payload),
+        workItem: normalizeWorkItem(payload.workItem ?? payload.work_item),
+        event: normalizeEvent(payload.event),
+    };
+}
+export async function updateAgentRuntimeRunWorkItem(input, options) {
+    const payload = await postAgentRuntimeOperation(UPDATE_RUN_WORK_ITEM_PATH, {
+        runId: input.runId,
+        workItemId: input.workItemId,
+        state: input.state,
+        ...(input.nextAction !== undefined
+            ? { nextAction: input.nextAction }
+            : {}),
+        ...(input.blocker !== undefined ? { blocker: input.blocker } : {}),
+        ...(input.waitId !== undefined ? { waitId: input.waitId } : {}),
+        ...(input.toolExecutionId !== undefined
+            ? { toolExecutionId: input.toolExecutionId }
+            : {}),
+        ...(input.evidenceRefs !== undefined
+            ? { evidenceRefs: input.evidenceRefs }
+            : {}),
+        ...(input.completionGate !== undefined
+            ? { completionGate: input.completionGate }
+            : {}),
+        ...(input.payload ? { payload: input.payload } : {}),
+    }, options);
+    return {
+        run: normalizeRequiredRun(payload),
+        workItem: normalizeWorkItem(payload.workItem ?? payload.work_item),
+        event: normalizeEvent(payload.event),
+    };
+}
 export async function waitAgentRuntimeRun(input, options) {
     const payload = await postAgentRuntimeOperation(WAIT_RUN_PATH, {
         runId: input.runId,
@@ -476,6 +684,12 @@ export async function listAgentRuntimeRunEvents(input, options) {
     return { events: normalizeEvents(payload) };
 }
 export async function recordMaestroSessionRuntimeTrigger(input, options) {
+    // Keep transport selection behind this adapter. Headless session handlers
+    // should only know whether a Platform correlation handle was recorded, not
+    // whether the deployment used Connect or the A2A facade.
+    if (isAgentRuntimeA2AEnabled()) {
+        return await recordMaestroSessionRuntimeTriggerViaA2A(input, options);
+    }
     const config = options?.config ?? (await resolveAgentRuntimeServiceConfig());
     if (!config) {
         return null;
@@ -512,4 +726,247 @@ export async function recordMaestroSessionRuntimeTrigger(input, options) {
         return null;
     }
 }
+async function recordMaestroSessionRuntimeTriggerViaA2A(input, options) {
+    const serviceConfig = options?.config
+        ? {
+            ...options.config,
+            baseUrl: normalizeBaseUrl(options.config.baseUrl, AGENT_RUNTIME_BASE_URL_SUFFIXES),
+        }
+        : await resolveAgentRuntimeServiceConfig();
+    const dedicatedWorkspaceId = getEnvValue(DEDICATED_A2A_WORKSPACE_ENV_VARS);
+    // Dedicated A2A env vars deliberately override shared AgentRuntime config,
+    // but managed deployments can omit them and reuse the same service identity
+    // while only flipping the transport feature flag.
+    const config = await resolveA2AServiceConfig({
+        baseUrl: hasDedicatedA2AEnv(DEDICATED_A2A_BASE_URL_ENV_VARS)
+            ? undefined
+            : serviceConfig?.baseUrl,
+        token: hasDedicatedA2AEnv(DEDICATED_A2A_TOKEN_ENV_VARS)
+            ? undefined
+            : serviceConfig?.token,
+        organizationId: hasDedicatedA2AEnv(DEDICATED_A2A_ORGANIZATION_ENV_VARS)
+            ? undefined
+            : serviceConfig?.organizationId,
+        workspaceId: trimString(input.workspaceId) ??
+            (dedicatedWorkspaceId ? undefined : serviceConfig?.workspaceId),
+        agentId: input.agentId ?? "maestro",
+        sessionId: input.sessionId,
+        actorId: input.actorId ?? "maestro",
+        timeoutMs: hasDedicatedA2AEnv(DEDICATED_A2A_TIMEOUT_ENV_VARS)
+            ? undefined
+            : serviceConfig?.timeoutMs,
+        maxAttempts: hasDedicatedA2AEnv(DEDICATED_A2A_MAX_ATTEMPTS_ENV_VARS)
+            ? undefined
+            : serviceConfig?.maxAttempts,
+    });
+    if (!config) {
+        return null;
+    }
+    let factsContext = input.factsContext;
+    if (!factsContext) {
+        try {
+            factsContext = await gatherMaestroSessionFactsContext({
+                ...input,
+                workspaceId: input.workspaceId ?? config.workspaceId,
+            }, { signal: options?.signal });
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                throw error;
+            }
+            factsContext = undefined;
+        }
+    }
+    const workspaceId = trimString(input.workspaceId) ?? config.workspaceId;
+    const sessionId = trimString(input.sessionId);
+    if (!workspaceId || !sessionId) {
+        return null;
+    }
+    const idempotencyKey = trimString(input.idempotencyKey) ??
+        ["maestro-session", workspaceId, sessionId].join(":");
+    const correlationId = trimString(input.correlationId) ?? ["maestro-session", sessionId].join(":");
+    const traceContext = maestroRuntimeTraceContext(input);
+    const pushNotificationConfig = platformA2APushNotificationConfig(sessionId);
+    try {
+        const sent = await sendA2AMessage(config, {
+            message: buildA2AUserMessage({
+                messageId: idempotencyKey,
+                contextId: `maestro-session:${sessionId}`,
+                text: `Start Maestro hosted session ${sessionId}`,
+                metadata: {
+                    workspaceId,
+                    agentId: config.agentId ?? "maestro",
+                    sessionId,
+                    actorId: config.actorId ?? input.actorId ?? "maestro",
+                    correlationId,
+                    ...(traceContext?.traceparent
+                        ? { traceparent: traceContext.traceparent }
+                        : {}),
+                    ...(traceContext?.tracestate
+                        ? { tracestate: traceContext.tracestate }
+                        : {}),
+                    sourceEventId: trimString(input.sourceEventId) ?? idempotencyKey,
+                    sourceEventType: MaestroAgentRuntimeSourceEventType.SessionStarted,
+                    metadata: input.metadata,
+                    ...(factsContext ? { facts_context: factsContext } : {}),
+                },
+            }),
+            configuration: {
+                returnImmediately: true,
+                ...(pushNotificationConfig
+                    ? { taskPushNotificationConfig: pushNotificationConfig }
+                    : {}),
+            },
+            metadata: {
+                route: "maestro_session",
+                transport: "a2a",
+            },
+            traceContext,
+        }, { signal: options?.signal });
+        let task = sent.task;
+        try {
+            task = mergeA2ATaskLookupResult(sent.task, await getA2ATask(config, sent.task.id, {
+                signal: options?.signal,
+                traceContext,
+            }));
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                throw error;
+            }
+        }
+        return a2aTaskToAgentRuntimeTriggerResult(task, config);
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function platformA2APushNotificationConfig(sessionId) {
+    const url = getEnvValue(DEDICATED_A2A_CALLBACK_URL_ENV_VARS);
+    if (!url) {
+        return undefined;
+    }
+    const token = getEnvValue(DEDICATED_A2A_CALLBACK_TOKEN_ENV_VARS);
+    return {
+        id: `maestro-session-${sessionId}`,
+        url,
+        ...(token ? { token } : {}),
+    };
+}
+function isAgentRuntimeA2AEnabled() {
+    const value = getEnvValue(AGENT_RUNTIME_A2A_ENABLED_ENV_VARS)?.toLowerCase();
+    return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function hasDedicatedA2AEnv(names) {
+    return getEnvValue(names) !== undefined;
+}
+function mergeA2ATaskLookupResult(sent, lookup) {
+    const preservedMetadata = { ...(sent.metadata ?? {}) };
+    delete preservedMetadata.agentRunState;
+    delete preservedMetadata.agent_run_state;
+    return {
+        ...sent,
+        ...lookup,
+        metadata: {
+            ...preservedMetadata,
+            ...(lookup.metadata ?? {}),
+        },
+    };
+}
+function a2aTaskToAgentRuntimeTriggerResult(task, config) {
+    const metadata = task.metadata ?? {};
+    // A2A returns a task, while the rest of Maestro expects AgentRuntime-shaped
+    // correlation. Prefer Platform-projected metadata and fall back to the task
+    // id so health and identity endpoints still have a durable handle.
+    const runId = pickString(metadata, "agentRunId", "agent_run_id") ?? task.id;
+    const a2aMessageId = pickString(metadata, "a2aMessageId", "a2a_message_id");
+    const a2aTaskId = pickString(metadata, "a2aTaskId", "a2a_task_id") ?? task.id;
+    const agentId = pickString(metadata, "agentId", "agent_id") ?? config.agentId ?? "maestro";
+    const workspaceId = pickString(metadata, "workspaceId", "workspace_id") ?? config.workspaceId;
+    const workerQueue = pickString(metadata, "workerQueue", "worker_queue");
+    const correlationId = pickString(metadata, "correlationId", "correlation_id");
+    const correlationPath = pickString(metadata, "correlationPath", "correlation_path");
+    const traceparent = pickString(metadata, "traceparent", "trace_parent");
+    const tracestate = pickString(metadata, "tracestate", "trace_state");
+    const idempotencyKey = pickString(metadata, "idempotencyKey", "idempotency_key");
+    return {
+        run: {
+            id: runId,
+            state: pickString(metadata, "agentRunState", "agent_run_state") ??
+                platformRunStateFromA2ATaskState(task.status?.state),
+            linkage: {
+                runId,
+                workspaceId,
+                agentId,
+            },
+            updatedAt: task.status?.timestamp,
+        },
+        events: [
+            {
+                type: "maestro.platform_runtime.a2a_correlated",
+                runId,
+                message: "Maestro A2A task linked to Platform AgentRuntime run",
+                attributes: {
+                    ...(a2aMessageId ? { a2a_message_id: a2aMessageId } : {}),
+                    a2a_task_id: a2aTaskId,
+                    platform_agent_run_id: runId,
+                    ...(workerQueue ? { worker_queue: workerQueue } : {}),
+                    ...(correlationId ? { correlation_id: correlationId } : {}),
+                    ...(correlationPath ? { correlation_path: correlationPath } : {}),
+                    ...(traceparent ? { traceparent } : {}),
+                    ...(tracestate ? { tracestate } : {}),
+                    ...(idempotencyKey ? { idempotency_key: idempotencyKey } : {}),
+                },
+            },
+        ],
+        idempotentReplay: pickBoolean(metadata, "idempotentReplay", "idempotent_replay"),
+    };
+}
+function platformRunStateFromA2ATaskState(state) {
+    switch (state?.trim().toLowerCase()) {
+        case "task_state_working":
+        case "working":
+            return PlatformAgentRunStateValue.Running;
+        case "task_state_input_required":
+        case "input-required":
+            return PlatformAgentRunStateValue.Waiting;
+        case "task_state_completed":
+        case "completed":
+            return PlatformAgentRunStateValue.Succeeded;
+        case "task_state_failed":
+        case "task_state_rejected":
+        case "failed":
+        case "rejected":
+            return PlatformAgentRunStateValue.Failed;
+        case "task_state_auth_required":
+        case "auth-required":
+            return PlatformAgentRunStateValue.Waiting;
+        case "task_state_canceled":
+        case "task_state_cancelled":
+        case "canceled":
+        case "cancelled":
+            return PlatformAgentRunStateValue.Cancelled;
+        default:
+            return PlatformAgentRunStateValue.Queued;
+    }
+}
+function maestroRuntimeTraceContext(input) {
+    const traceparent = trimString(input.traceparent) ??
+        pickString(input.metadata, "traceparent", "trace_parent");
+    const tracestate = trimString(input.tracestate) ??
+        pickString(input.metadata, "tracestate", "trace_state");
+    if (traceparent || tracestate) {
+        return resolveA2ATraceContext({
+            traceparent,
+            tracestate,
+        }, { envFallback: false });
+    }
+    return resolveA2ATraceContext({
+        traceparent,
+        tracestate,
+    });
+}
 //# sourceMappingURL=agent-runtime-client.js.map