@aiwg/cli 2026.8.17 → 2026.8.19

package/dist/src/a2a/events.js

@@ -0,0 +1,226 @@
+import { decodeArtifact, decodeMessage, decodeStatus, decodeTask, A2AWireValidationError, } from './codecs.js';
+import { isTerminalTaskState, } from './types.js';
+/** Strict 1.0 StreamResponse decoder and separate 0.3 compatibility decoder. */
+export function decodeStreamResponse(version, input, opts = {}) {
+    return version === '1.0'
+        ? decodeV1StreamResponse(input, opts)
+        : decodeLegacyStreamEvent(input, opts);
+}
+export function decodeV1StreamResponse(input, opts = {}) {
+    const obj = objectAt('1.0', '$', input);
+    if (typeof obj.kind === 'string') {
+        fail('1.0', '$.kind', 'legacy event discriminator is not valid in StreamResponse');
+    }
+    const members = ['task', 'message', 'statusUpdate', 'artifactUpdate']
+        .filter(key => Object.prototype.hasOwnProperty.call(obj, key));
+    if (members.length !== 1) {
+        fail('1.0', '$', 'StreamResponse must contain exactly one of task, message, statusUpdate, artifactUpdate');
+    }
+    const base = eventBase('1.0', opts);
+    switch (members[0]) {
+        case 'task':
+            return { ...base, type: 'task', task: decodeTask('1.0', obj.task, '$.task') };
+        case 'message':
+            return { ...base, type: 'message', message: decodeMessage('1.0', obj.message, '$.message') };
+        case 'statusUpdate': {
+            const update = objectAt('1.0', '$.statusUpdate', obj.statusUpdate);
+            return {
+                ...base,
+                type: 'status',
+                taskId: stringAt('1.0', '$.statusUpdate.taskId', update.taskId),
+                contextId: stringAt('1.0', '$.statusUpdate.contextId', update.contextId),
+                status: decodeStatus('1.0', update.status, '$.statusUpdate.status'),
+                ...(update.metadata !== undefined
+                    ? { metadata: jsonObjectAt('1.0', '$.statusUpdate.metadata', update.metadata) }
+                    : {}),
+            };
+        }
+        case 'artifactUpdate': {
+            const update = objectAt('1.0', '$.artifactUpdate', obj.artifactUpdate);
+            return {
+                ...base,
+                type: 'artifact',
+                taskId: stringAt('1.0', '$.artifactUpdate.taskId', update.taskId),
+                contextId: stringAt('1.0', '$.artifactUpdate.contextId', update.contextId),
+                artifact: decodeArtifact('1.0', update.artifact, '$.artifactUpdate.artifact'),
+                ...(update.append !== undefined ? { append: booleanAt('1.0', '$.artifactUpdate.append', update.append) } : {}),
+                ...(update.lastChunk !== undefined ? { lastChunk: booleanAt('1.0', '$.artifactUpdate.lastChunk', update.lastChunk) } : {}),
+                ...(update.metadata !== undefined
+                    ? { metadata: jsonObjectAt('1.0', '$.artifactUpdate.metadata', update.metadata) }
+                    : {}),
+            };
+        }
+        default:
+            fail('1.0', '$', 'unknown StreamResponse member');
+    }
+}
+export function decodeLegacyStreamEvent(input, opts = {}) {
+    const obj = objectAt('0.3', '$', input);
+    const base = eventBase('0.3', opts);
+    // Some 0.3 subscriptions use the SSE event name for a full initial Task.
+    if (typeof obj.id === 'string' && obj.status !== undefined) {
+        return { ...base, type: 'task', task: decodeTask('0.3', obj) };
+    }
+    const kind = typeof obj.kind === 'string' ? obj.kind : opts.eventName;
+    if (!kind)
+        fail('0.3', '$', 'legacy stream event requires kind or SSE event name');
+    switch (kind) {
+        case 'task-state':
+            return { ...base, type: 'task', task: decodeTask('0.3', obj.task, '$.task') };
+        case 'status-update':
+            return {
+                ...base,
+                type: 'status',
+                taskId: stringAt('0.3', '$.taskId', obj.taskId),
+                status: decodeStatus('0.3', obj.status, '$.status'),
+            };
+        case 'artifact-update':
+            return {
+                ...base,
+                type: 'artifact',
+                taskId: stringAt('0.3', '$.taskId', obj.taskId),
+                artifact: decodeArtifact('0.3', obj.artifact, '$.artifact'),
+                ...(obj.append !== undefined ? { append: booleanAt('0.3', '$.append', obj.append) } : {}),
+            };
+        default:
+            fail('0.3', '$.kind', `unsupported legacy event '${kind}'`);
+    }
+}
+/**
+ * Shared ordering/ownership/state-transition gate for SSE and push. It returns
+ * null for an exact duplicate and throws before state mutation for invalid
+ * ownership, out-of-order delivery, missing initial snapshots, or terminal
+ * regression.
+ */
+export class A2AEventReconciler {
+    taskId;
+    contextId;
+    initialized;
+    terminal;
+    lastSequence;
+    eventIds = new Set();
+    constructor(opts) {
+        this.taskId = opts.taskId;
+        this.contextId = opts.contextId ?? opts.initialTask?.contextId;
+        this.initialized = opts.initialTask !== undefined || opts.requireInitialSnapshot !== true;
+        this.terminal = opts.initialTask ? isTerminalTaskState(opts.initialTask.status.state) : false;
+    }
+    accept(event) {
+        if (event.eventId && this.eventIds.has(event.eventId))
+            return null;
+        if (event.sequence !== undefined) {
+            if (this.lastSequence !== undefined && event.sequence <= this.lastSequence) {
+                if (event.sequence === this.lastSequence)
+                    return null;
+                throw new Error(`A2A event sequence regressed from ${this.lastSequence} to ${event.sequence}`);
+            }
+            if (this.lastSequence !== undefined && event.sequence !== this.lastSequence + 1) {
+                throw new Error(`A2A event sequence gap after ${this.lastSequence}: received ${event.sequence}`);
+            }
+        }
+        const eventTaskId = taskIdOf(event);
+        if (eventTaskId && eventTaskId !== this.taskId) {
+            throw new Error(`A2A event belongs to task ${eventTaskId}, expected ${this.taskId}`);
+        }
+        const eventContextId = contextIdOf(event);
+        if (this.contextId && eventContextId && this.contextId !== eventContextId) {
+            throw new Error(`A2A event belongs to context ${eventContextId}, expected ${this.contextId}`);
+        }
+        if (!this.initialized) {
+            if (event.type !== 'task') {
+                throw new Error('A2A subscription must begin with a Task snapshot before deltas');
+            }
+            this.initialized = true;
+        }
+        if (this.terminal && event.type !== 'task') {
+            throw new Error(`A2A event '${event.type}' arrived after task ${this.taskId} became terminal`);
+        }
+        if (event.type === 'task') {
+            if (this.terminal && !isTerminalTaskState(event.task.status.state)) {
+                throw new Error(`A2A task ${this.taskId} cannot regress from terminal state`);
+            }
+            this.contextId ??= event.task.contextId;
+            this.terminal = isTerminalTaskState(event.task.status.state);
+        }
+        else if (event.type === 'status') {
+            this.contextId ??= event.contextId;
+            this.terminal = isTerminalTaskState(event.status.state);
+        }
+        else if (event.type === 'message') {
+            this.contextId ??= event.message.contextId;
+        }
+        else {
+            this.contextId ??= event.contextId;
+        }
+        if (event.eventId)
+            this.eventIds.add(event.eventId);
+        if (event.sequence !== undefined)
+            this.lastSequence = event.sequence;
+        return event;
+    }
+    isTerminal() {
+        return this.terminal;
+    }
+}
+function taskIdOf(event) {
+    if (event.type === 'task')
+        return event.task.id;
+    if (event.type === 'message')
+        return event.message.taskId;
+    return event.taskId;
+}
+function contextIdOf(event) {
+    if (event.type === 'task')
+        return event.task.contextId;
+    if (event.type === 'message')
+        return event.message.contextId;
+    return event.contextId;
+}
+function eventBase(version, opts) {
+    return {
+        protocolVersion: version,
+        ...(opts.sequence !== undefined ? { sequence: opts.sequence } : {}),
+        ...(opts.eventId !== undefined ? { eventId: opts.eventId } : {}),
+    };
+}
+function objectAt(version, path, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail(version, path, 'must be an object');
+    return value;
+}
+function stringAt(version, path, value) {
+    if (typeof value !== 'string' || !value)
+        fail(version, path, 'must be a non-empty string');
+    return value;
+}
+function booleanAt(version, path, value) {
+    if (typeof value !== 'boolean')
+        fail(version, path, 'must be a boolean');
+    return value;
+}
+function jsonObjectAt(version, path, value) {
+    const object = objectAt(version, path, value);
+    assertJsonValue(version, path, object);
+    return object;
+}
+function assertJsonValue(version, path, value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => assertJsonValue(version, `${path}[${index}]`, entry));
+        return;
+    }
+    if (value && typeof value === 'object') {
+        for (const [key, entry] of Object.entries(value)) {
+            assertJsonValue(version, `${path}.${key}`, entry);
+        }
+        return;
+    }
+    fail(version, path, 'must contain only JSON values');
+}
+function fail(version, path, detail) {
+    throw new A2AWireValidationError(version, path, detail);
+}
+//# sourceMappingURL=events.js.map

package/dist/src/a2a/hitl-driver.js

@@ -337,13 +337,13 @@ export async function driveOnePrompt(opts) {
 }
 // ── helpers ────────────────────────────────────────────────────────────
 function extractEnvelopeFromEvent(event) {
-    if (event.kind === 'task-state') {
+    if (event.type === 'task') {
         const result = extractHitlEnvelope(event.task);
         if (result?.ok)
             return result.envelope;
         return null;
     }
-    if (event.kind === 'status-update') {
+    if (event.type === 'status') {
         const result = extractHitlEnvelope(event.status);
         if (result?.ok)
             return result.envelope;
@@ -352,14 +352,16 @@ function extractEnvelopeFromEvent(event) {
     return null;
 }
 function inferEventContext(event) {
-    if (event.kind === 'task-state') {
+    if (event.type === 'task') {
         return event.task.contextId !== undefined
             ? { contextId: event.task.contextId }
             : {};
     }
-    // status-update / artifact-update don't carry a contextId; the caller
-    // can pass one through `driveOnePrompt` directly if it has one cached.
-    return {};
+    return event.type === 'status' || event.type === 'artifact'
+        ? event.contextId !== undefined ? { contextId: event.contextId } : {}
+        : event.type === 'message' && event.message.contextId !== undefined
+            ? { contextId: event.message.contextId }
+            : {};
 }
 function parseDeadline(deadline) {
     if (!deadline)

package/dist/src/a2a/hitl.js

@@ -110,11 +110,12 @@ export function buildHitlResponseMessage(opts) {
         role: 'user',
         parts: [
             {
-                kind: 'data',
+                type: 'data',
                 data: opts.response,
             },
         ],
         metadata: {
+            ...(opts.metadata ?? {}),
             hitl_response_for: {
                 prompt_id: opts.promptId,
                 payload: opts.response,

package/dist/src/a2a/http.js

@@ -15,12 +15,24 @@ export class A2AError extends Error {
     status;
     problem;
     path;
-    constructor(status, path, problem) {
+    category;
+    versionNotSupported;
+    constructor(status, path, problem, category) {
         super(`${status} ${problem.code ?? problem.title}: ${problem.detail ?? problem.title}`);
         this.name = 'A2AError';
         this.status = status;
         this.problem = problem;
         this.path = path;
+        this.versionNotSupported = isVersionNotSupportedProblem(problem);
+        this.category = category ?? (this.versionNotSupported
+            ? 'negotiation'
+            : status === 401 || status === 403
+                ? 'authorization'
+                : status === 0
+                    ? 'transport'
+                    : status >= 400
+                        ? 'application'
+                        : 'transport');
     }
 }
 const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
@@ -34,6 +46,7 @@ export class A2AHttpClient {
     onExtensionEchoMissing;
     /** Per-process dedupe set: one log per (path, sunset_date). */
     seenDeprecations = new Set();
+    protocolVersion;
     constructor(opts) {
         this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
         this.bearer = opts.bearer;
@@ -42,16 +55,21 @@ export class A2AHttpClient {
         this.fetchImpl = opts.fetch ?? fetch;
         this.onDeprecation = opts.onDeprecation;
         this.onExtensionEchoMissing = opts.onExtensionEchoMissing;
+        this.protocolVersion = opts.protocolVersion ?? '0.3';
     }
     async request(path, options = {}) {
         const method = (options.method ?? 'GET').toUpperCase();
         const url = path.startsWith('http') ? path : this.baseUrl + path;
+        const protocolVersion = options.protocolVersion ?? this.protocolVersion;
+        const mediaType = protocolVersion === '1.0' ? 'application/a2a+json' : 'application/json';
         const headers = {
             authorization: `Bearer ${options.bearer ?? this.bearer}`,
-            accept: 'application/json',
+            accept: mediaType,
         };
+        if (protocolVersion === '1.0')
+            headers['a2a-version'] = '1.0';
         if (options.body !== undefined && options.bodyRaw === undefined) {
-            headers['content-type'] = 'application/json';
+            headers['content-type'] = mediaType;
         }
         // Inject A2A-Extensions on mutating calls. Caller can override with
         // options.extensions (empty array clears injection).
@@ -74,7 +92,18 @@ export class A2AHttpClient {
         else if (options.body !== undefined) {
             init.body = JSON.stringify(options.body);
         }
-        const resp = await this.fetchImpl(url, init);
+        let resp;
+        try {
+            resp = await this.fetchImpl(url, init);
+        }
+        catch (error) {
+            throw new A2AError(0, path, {
+                type: 'about:blank',
+                title: 'A2A transport failure',
+                detail: error instanceof Error ? error.message : String(error),
+                code: 'aiwg.transport_failure',
+            }, 'transport');
+        }
         // Capture deprecation headers regardless of status.
         const deprecation = captureDeprecation(path, resp.headers);
         if (deprecation) {
@@ -121,6 +150,18 @@ export class A2AHttpClient {
         // Parse body (JSON, problem+json, or empty).
         let body;
         const ct = resp.headers.get('content-type') ?? '';
+        if (protocolVersion === '1.0'
+            && resp.status < 400
+            && resp.status !== 204
+            && resp.status !== 205
+            && !ct.toLowerCase().includes('application/a2a+json')) {
+            throw new A2AError(502, path, {
+                type: 'about:blank',
+                title: 'Invalid A2A 1.0 content type',
+                detail: `Expected application/a2a+json, received ${ct || '(missing)'}`,
+                code: 'aiwg.invalid_content_type',
+            }, 'transport');
+        }
         if (resp.status !== 204 && resp.status !== 205) {
             const text = await resp.text();
             if (text.length > 0) {
@@ -143,7 +184,7 @@ export class A2AHttpClient {
             }
         }
         if (resp.status >= 400) {
-            const problem = body ?? {
+            const problem = normalizeProblemDetails(resp.status, body) ?? {
                 type: 'about:blank',
                 title: `HTTP ${resp.status}`,
             };
@@ -159,6 +200,45 @@ export class A2AHttpClient {
         };
     }
 }
+export function isVersionNotSupportedProblem(problem) {
+    const type = problem.type?.toLowerCase() ?? '';
+    const code = problem.code?.toLowerCase() ?? '';
+    return type.includes('version-not-supported')
+        || code === 'versionnotsupportederror'
+        || code === 'version_not_supported'
+        || code === 'a2a.version_not_supported'
+        || code === '-32009';
+}
+function normalizeProblemDetails(status, body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return undefined;
+    const obj = body;
+    // HTTP+JSON uses RFC 7807. JSON-RPC bindings may nest the standard code.
+    const nested = obj.error && typeof obj.error === 'object' && !Array.isArray(obj.error)
+        ? obj.error
+        : undefined;
+    const source = nested ?? obj;
+    const codeValue = source.code;
+    const code = typeof codeValue === 'string' || typeof codeValue === 'number'
+        ? String(codeValue)
+        : undefined;
+    const title = typeof obj.title === 'string'
+        ? obj.title
+        : typeof source.message === 'string'
+            ? source.message
+            : `HTTP ${status}`;
+    const problem = {
+        type: typeof obj.type === 'string' ? obj.type : 'about:blank',
+        title,
+        status,
+        ...(typeof obj.detail === 'string' ? { detail: obj.detail } : {}),
+        ...(code ? { code } : {}),
+        ...(Array.isArray(obj.supportedVersions) && obj.supportedVersions.every(v => typeof v === 'string')
+            ? { supportedVersions: obj.supportedVersions }
+            : {}),
+    };
+    return problem;
+}
 // ---------- header helpers ----------
 function parseExtensionList(header) {
     if (!header)

package/dist/src/a2a/protocol.js

@@ -0,0 +1,136 @@
+export const A2A_HTTP_JSON_BINDING = 'HTTP+JSON';
+export const A2A_LEGACY_REST_BINDING = 'REST';
+export class A2ANegotiationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'A2ANegotiationError';
+        this.code = code;
+    }
+}
+export function normalizeProtocolVersion(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = /^(0\.3|1\.0)(?:\.\d+)?$/.exec(value.trim());
+    return match?.[1] ?? null;
+}
+/**
+ * Parse 0.3 top-level cards and 1.0 per-interface cards into one discovery
+ * model. A card that claims top-level 1.0 while retaining only 0.3 interface
+ * fields is rejected instead of being treated as proof of 1.0 support.
+ */
+export function normalizeAgentCard(card) {
+    if (!card || typeof card !== 'object') {
+        throw new A2ANegotiationError('agent_card.invalid', 'AgentCard must be an object');
+    }
+    if (typeof card.name !== 'string' || !card.name.trim()) {
+        throw new A2ANegotiationError('agent_card.name_missing', 'AgentCard.name is required');
+    }
+    if (typeof card.version !== 'string' || !card.version.trim()) {
+        throw new A2ANegotiationError('agent_card.version_missing', 'AgentCard.version is required');
+    }
+    const topVersion = normalizeProtocolVersion(card.protocolVersion);
+    if (card.protocolVersion !== undefined && !topVersion) {
+        throw new A2ANegotiationError('agent_card.protocol_version_invalid', `Unsupported AgentCard.protocolVersion '${String(card.protocolVersion)}'`);
+    }
+    const interfaces = [];
+    for (const [preference, entry] of (card.supportedInterfaces ?? []).entries()) {
+        if (!entry || typeof entry !== 'object' || typeof entry.url !== 'string') {
+            throw new A2ANegotiationError('agent_card.interface_invalid', `supportedInterfaces[${preference}] must contain an absolute URL`);
+        }
+        assertAbsoluteUrl(entry.url, `supportedInterfaces[${preference}].url`);
+        const interfaceVersion = normalizeProtocolVersion(entry.protocolVersion);
+        if (entry.protocolVersion !== undefined && !interfaceVersion) {
+            throw new A2ANegotiationError('agent_card.interface_version_invalid', `supportedInterfaces[${preference}].protocolVersion is unsupported`);
+        }
+        if (interfaceVersion) {
+            if (typeof entry.protocolBinding !== 'string' || !entry.protocolBinding.trim()) {
+                throw new A2ANegotiationError('agent_card.interface_binding_missing', `supportedInterfaces[${preference}] declares ${interfaceVersion} without protocolBinding`);
+            }
+            interfaces.push({
+                url: trimUrl(entry.url),
+                protocolBinding: entry.protocolBinding,
+                protocolVersion: interfaceVersion,
+                ...(entry.tenant ? { tenant: entry.tenant } : {}),
+                preference,
+                legacy: false,
+            });
+            continue;
+        }
+        // 0.3 cards put the version at top level and binding under `transport`.
+        if (topVersion !== '0.3') {
+            throw new A2ANegotiationError('agent_card.mixed_interface_shape', `supportedInterfaces[${preference}] uses legacy transport fields without a 0.3 top-level declaration`);
+        }
+        if (typeof entry.transport !== 'string' || !entry.transport.trim()) {
+            throw new A2ANegotiationError('agent_card.interface_transport_missing', `supportedInterfaces[${preference}] requires transport for the 0.3 card shape`);
+        }
+        interfaces.push({
+            url: trimUrl(entry.url),
+            protocolBinding: entry.transport,
+            protocolVersion: '0.3',
+            ...(entry.tenant ? { tenant: entry.tenant } : {}),
+            preference,
+            legacy: true,
+        });
+    }
+    // Legacy cards commonly omit supportedInterfaces entirely.
+    if (topVersion === '0.3' && typeof card.url === 'string') {
+        assertAbsoluteUrl(card.url, 'AgentCard.url');
+        if (!interfaces.some(entry => entry.protocolVersion === '0.3' && entry.url === trimUrl(card.url))) {
+            interfaces.push({
+                url: trimUrl(card.url),
+                protocolBinding: card.preferredTransport ?? A2A_LEGACY_REST_BINDING,
+                protocolVersion: '0.3',
+                preference: interfaces.length,
+                legacy: true,
+            });
+        }
+    }
+    if (topVersion === '1.0' && interfaces.length === 0) {
+        throw new A2ANegotiationError('agent_card.v1_interfaces_missing', 'A2A 1.0 cards must declare versioned supportedInterfaces; top-level protocolVersion/url are 0.3 fields');
+    }
+    if (interfaces.length === 0) {
+        throw new A2ANegotiationError('agent_card.interfaces_missing', 'AgentCard exposes no usable protocol interface');
+    }
+    return { card, interfaces };
+}
+export function selectAgentInterface(input, opts) {
+    const normalized = 'interfaces' in input ? input : normalizeAgentCard(input);
+    const bindings = opts.bindings ?? [A2A_HTTP_JSON_BINDING, A2A_LEGACY_REST_BINDING];
+    const versions = opts.policy === 'auto'
+        ? opts.versionPreference ?? ['1.0', '0.3']
+        : [opts.policy];
+    for (const version of versions) {
+        for (const binding of bindings) {
+            const selected = normalized.interfaces
+                .filter(entry => entry.protocolVersion === version && sameBinding(entry.protocolBinding, binding))
+                .sort((a, b) => a.preference - b.preference)[0];
+            if (selected)
+                return selected;
+        }
+    }
+    const available = normalized.interfaces
+        .map(entry => `${entry.protocolVersion}/${entry.protocolBinding}@${entry.url}`)
+        .join(', ');
+    throw new A2ANegotiationError('agent_card.no_compatible_interface', `No compatible A2A interface for policy=${opts.policy}; available: ${available || 'none'}`);
+}
+export function agentInterfaceCacheKey(host, instanceId, selected) {
+    return [host, instanceId, selected.protocolVersion, selected.protocolBinding, selected.url].join('|');
+}
+function sameBinding(actual, supported) {
+    return actual.trim().toUpperCase() === supported.trim().toUpperCase();
+}
+function trimUrl(value) {
+    return value.replace(/\/+$/, '');
+}
+function assertAbsoluteUrl(value, field) {
+    try {
+        const url = new URL(value);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new Error('not HTTP(S)');
+    }
+    catch {
+        throw new A2ANegotiationError('agent_card.url_invalid', `${field} must be an absolute HTTP(S) URL`);
+    }
+}
+//# sourceMappingURL=protocol.js.map

package/dist/src/a2a/types.js

@@ -1,17 +1,7 @@
-// A2A protocol types — the subset AIWG needs to talk to an agentic-sandbox v2
-// executor. Modelled from the executor's wire surface
-// (`agentic-sandbox/management/agentic-sandbox-executor`):
-//
-//   - send_message.rs   — POST /agents/{id}/v1/messages:send
-//   - get_task.rs       — GET  /agents/{id}/v1/tasks/{tid}
-//   - cancel_task.rs    — POST /agents/{id}/v1/tasks/{tid}/cancel
-//   - subscribe_task    — GET  /agents/{id}/v1/tasks/{tid}/subscribe (SSE)
-//   - push_delivery.rs  — *   /agents/{id}/v1/tasks/{tid}/pushNotificationConfigs/*
-//   - agent_card.rs     — GET  /agents/{id}/.well-known/agent-card.json
-//                          GET  /agents/{id}/v1/extendedAgentCard
-//
-// Types are intentionally permissive (extra fields allowed). We track only
-// what the AIWG orchestrator inspects; the rest is forwarded opaquely.
+// Normalized A2A domain types. Protocol 0.3 and 1.0 wire values are decoded
+// into these types at the boundary in codecs.ts. Application code must not
+// depend on either version's enum spellings, kind fields, or oneof layout.
+export { AIWG_GRAPH_METADATA_KEY } from '../flow/graph-metadata.js';
 export const TERMINAL_TASK_STATES = [
     'completed',
     'failed',