@aiwg/cli 2026.8.17 → 2026.8.19

package/dist/src/a2a/codecs.js

@@ -0,0 +1,480 @@
+export function encodePushNotificationConfig(version, config) {
+    assertNonEmptyString(version, '$.url', config.url);
+    if (version === '0.3') {
+        return {
+            ...(config.configId ? { configId: config.configId } : {}),
+            url: config.url,
+            ...(config.secret ? { secret: config.secret } : {}),
+            ...(config.eventTypes ? { eventTypes: config.eventTypes } : {}),
+            ...(config.metadata ? { metadata: config.metadata } : {}),
+            ...(config.token ? { token: config.token } : {}),
+            ...(config.authentication ? { authentication: config.authentication } : {}),
+        };
+    }
+    const token = config.token ?? config.secret;
+    return {
+        ...(config.configId ? { id: config.configId } : {}),
+        url: config.url,
+        ...(token ? { token } : {}),
+        ...(config.authentication ? { authentication: config.authentication } : {}),
+    };
+}
+export function decodePushNotificationConfig(version, input, path = '$') {
+    const obj = objectAt(version, path, input);
+    const result = {
+        url: stringAt(version, `${path}.url`, obj.url),
+    };
+    const id = version === '1.0' ? obj.id : obj.configId;
+    assignOptionalString(version, result, 'configId', id, `${path}.${version === '1.0' ? 'id' : 'configId'}`);
+    assignOptionalString(version, result, 'token', obj.token, `${path}.token`);
+    if (version === '0.3') {
+        assignOptionalString(version, result, 'secret', obj.secret, `${path}.secret`);
+        if (obj.eventTypes !== undefined) {
+            const values = arrayAt(version, `${path}.eventTypes`, obj.eventTypes);
+            if (!values.every(value => ['task', 'message', 'status', 'artifact'].includes(String(value)))) {
+                fail(version, `${path}.eventTypes`, 'contains an unsupported normalized event type');
+            }
+            result.eventTypes = values;
+        }
+        assignOptionalJsonObject(version, result, 'metadata', obj.metadata, `${path}.metadata`);
+    }
+    else if (result.token) {
+        result.secret = result.token;
+    }
+    if (obj.authentication !== undefined) {
+        const auth = objectAt(version, `${path}.authentication`, obj.authentication);
+        result.authentication = {
+            scheme: stringAt(version, `${path}.authentication.scheme`, auth.scheme),
+            ...(auth.credentials !== undefined
+                ? { credentials: stringAt(version, `${path}.authentication.credentials`, auth.credentials) }
+                : {}),
+        };
+    }
+    return result;
+}
+export class A2AWireValidationError extends Error {
+    protocolVersion;
+    path;
+    constructor(protocolVersion, path, detail) {
+        super(`Invalid A2A ${protocolVersion} payload at ${path}: ${detail}`);
+        this.name = 'A2AWireValidationError';
+        this.protocolVersion = protocolVersion;
+        this.path = path;
+    }
+}
+const LEGACY_STATES = new Set([
+    'submitted', 'working', 'completed', 'failed', 'canceled',
+    'input-required', 'rejected', 'auth-required',
+]);
+const V1_TO_STATE = {
+    TASK_STATE_SUBMITTED: 'submitted',
+    TASK_STATE_WORKING: 'working',
+    TASK_STATE_COMPLETED: 'completed',
+    TASK_STATE_FAILED: 'failed',
+    TASK_STATE_CANCELED: 'canceled',
+    TASK_STATE_INPUT_REQUIRED: 'input-required',
+    TASK_STATE_REJECTED: 'rejected',
+    TASK_STATE_AUTH_REQUIRED: 'auth-required',
+};
+const STATE_TO_V1 = Object.fromEntries(Object.entries(V1_TO_STATE).map(([wire, normalized]) => [normalized, wire]));
+export function encodeMessage(version, message) {
+    assertNonEmptyString(version, '$.messageId', message.messageId);
+    if (message.role !== 'user' && message.role !== 'agent') {
+        fail(version, '$.role', 'must be user or agent');
+    }
+    if (!Array.isArray(message.parts) || message.parts.length === 0) {
+        fail(version, '$.parts', 'must contain at least one part');
+    }
+    const out = {
+        messageId: message.messageId,
+        role: version === '1.0' ? (message.role === 'user' ? 'ROLE_USER' : 'ROLE_AGENT') : message.role,
+        parts: message.parts.map((part, index) => encodePart(version, part, `$.parts[${index}]`)),
+    };
+    copyOptional(out, 'contextId', message.contextId);
+    copyOptional(out, 'taskId', message.taskId);
+    copyJsonObject(version, out, 'metadata', message.metadata, '$.metadata');
+    copyStringArray(version, out, 'extensions', message.extensions, '$.extensions');
+    copyStringArray(version, out, 'referenceTaskIds', message.referenceTaskIds, '$.referenceTaskIds');
+    return out;
+}
+export function decodeMessage(version, input, path = '$') {
+    const obj = objectAt(version, path, input);
+    const messageId = stringAt(version, `${path}.messageId`, obj.messageId);
+    const role = decodeRole(version, obj.role, `${path}.role`);
+    const partsRaw = arrayAt(version, `${path}.parts`, obj.parts);
+    if (partsRaw.length === 0)
+        fail(version, `${path}.parts`, 'must contain at least one part');
+    const message = {
+        messageId,
+        role,
+        parts: partsRaw.map((part, index) => decodePart(version, part, `${path}.parts[${index}]`)),
+    };
+    assignOptionalString(version, message, 'contextId', obj.contextId, `${path}.contextId`);
+    assignOptionalString(version, message, 'taskId', obj.taskId, `${path}.taskId`);
+    assignOptionalJsonObject(version, message, 'metadata', obj.metadata, `${path}.metadata`);
+    assignOptionalStringArray(version, message, 'extensions', obj.extensions, `${path}.extensions`);
+    assignOptionalStringArray(version, message, 'referenceTaskIds', obj.referenceTaskIds, `${path}.referenceTaskIds`);
+    return message;
+}
+export function encodeTask(version, task) {
+    assertNonEmptyString(version, '$.id', task.id);
+    const out = {
+        id: task.id,
+        status: encodeStatus(version, task.status, '$.status'),
+    };
+    copyOptional(out, 'contextId', task.contextId);
+    if (task.artifacts !== undefined) {
+        out.artifacts = task.artifacts.map((artifact, index) => encodeArtifact(version, artifact, `$.artifacts[${index}]`));
+    }
+    if (task.history !== undefined) {
+        out.history = task.history.map((message, index) => encodeMessageAt(version, message, `$.history[${index}]`));
+    }
+    copyJsonObject(version, out, 'metadata', task.metadata, '$.metadata');
+    copyStringArray(version, out, 'extensions', task.extensions, '$.extensions');
+    return out;
+}
+export function decodeTask(version, input, path = '$') {
+    const obj = objectAt(version, path, input);
+    if (version === '1.0' && typeof obj.kind === 'string') {
+        fail(version, `${path}.kind`, 'legacy kind discriminator is not valid in 1.0');
+    }
+    const task = {
+        id: stringAt(version, `${path}.id`, obj.id),
+        status: decodeStatus(version, obj.status, `${path}.status`),
+    };
+    assignOptionalString(version, task, 'contextId', obj.contextId, `${path}.contextId`);
+    if (obj.artifacts !== undefined) {
+        task.artifacts = arrayAt(version, `${path}.artifacts`, obj.artifacts)
+            .map((artifact, index) => decodeArtifact(version, artifact, `${path}.artifacts[${index}]`));
+    }
+    if (obj.history !== undefined) {
+        task.history = arrayAt(version, `${path}.history`, obj.history)
+            .map((message, index) => decodeMessage(version, message, `${path}.history[${index}]`));
+    }
+    assignOptionalJsonObject(version, task, 'metadata', obj.metadata, `${path}.metadata`);
+    assignOptionalStringArray(version, task, 'extensions', obj.extensions, `${path}.extensions`);
+    return task;
+}
+export function decodeSendMessageResponse(version, input) {
+    if (version === '0.3')
+        return decodeTask(version, input);
+    const obj = objectAt(version, '$', input);
+    const members = ['task', 'message'].filter(key => obj[key] !== undefined);
+    if (members.length !== 1) {
+        fail(version, '$', 'send response must contain exactly one of task or message');
+    }
+    if (members[0] !== 'task') {
+        fail(version, '$.message', 'AIWG mission dispatch requires a Task response');
+    }
+    return decodeTask(version, obj.task, '$.task');
+}
+export function encodeStatus(version, status, path = '$') {
+    const out = {
+        state: version === '1.0' ? STATE_TO_V1[status.state] : status.state,
+    };
+    if (!out.state)
+        fail(version, `${path}.state`, `unsupported normalized state ${String(status.state)}`);
+    if (status.message !== undefined)
+        out.message = encodeMessageAt(version, status.message, `${path}.message`);
+    if (status.timestamp !== undefined) {
+        assertTimestamp(version, `${path}.timestamp`, status.timestamp);
+        out.timestamp = status.timestamp;
+    }
+    copyStringArray(version, out, 'extensions', status.extensions, `${path}.extensions`);
+    if (status.summary !== undefined)
+        out.summary = status.summary;
+    if (status.exitCode !== undefined)
+        out[version === '0.3' ? 'exit_code' : 'exitCode'] = status.exitCode;
+    return out;
+}
+export function decodeStatus(version, input, path = '$') {
+    const obj = objectAt(version, path, input);
+    const rawState = stringAt(version, `${path}.state`, obj.state);
+    const state = version === '1.0'
+        ? V1_TO_STATE[rawState]
+        : LEGACY_STATES.has(rawState) ? rawState : undefined;
+    if (!state)
+        fail(version, `${path}.state`, `unsupported state '${rawState}'`);
+    const status = { state };
+    if (obj.message !== undefined)
+        status.message = decodeMessage(version, obj.message, `${path}.message`);
+    if (obj.timestamp !== undefined) {
+        const timestamp = stringAt(version, `${path}.timestamp`, obj.timestamp);
+        assertTimestamp(version, `${path}.timestamp`, timestamp);
+        status.timestamp = timestamp;
+    }
+    assignOptionalStringArray(version, status, 'extensions', obj.extensions, `${path}.extensions`);
+    if (obj.summary !== undefined)
+        status.summary = stringAt(version, `${path}.summary`, obj.summary);
+    const exitCode = version === '0.3' ? obj.exit_code : obj.exitCode;
+    if (exitCode !== undefined) {
+        if (typeof exitCode !== 'number' || !Number.isInteger(exitCode)) {
+            fail(version, `${path}.${version === '0.3' ? 'exit_code' : 'exitCode'}`, 'must be an integer');
+        }
+        status.exitCode = exitCode;
+    }
+    return status;
+}
+export function encodeArtifact(version, artifact, path = '$') {
+    assertNonEmptyString(version, `${path}.artifactId`, artifact.artifactId);
+    if (!Array.isArray(artifact.parts) || artifact.parts.length === 0) {
+        fail(version, `${path}.parts`, 'must contain at least one part');
+    }
+    const out = {
+        artifactId: artifact.artifactId,
+        parts: artifact.parts.map((part, index) => encodePart(version, part, `${path}.parts[${index}]`)),
+    };
+    copyOptional(out, 'name', artifact.name);
+    copyOptional(out, 'description', artifact.description);
+    copyJsonObject(version, out, 'metadata', artifact.metadata, `${path}.metadata`);
+    copyStringArray(version, out, 'extensions', artifact.extensions, `${path}.extensions`);
+    return out;
+}
+export function decodeArtifact(version, input, path = '$') {
+    const obj = objectAt(version, path, input);
+    const partsRaw = arrayAt(version, `${path}.parts`, obj.parts);
+    if (partsRaw.length === 0)
+        fail(version, `${path}.parts`, 'must contain at least one part');
+    const artifact = {
+        artifactId: stringAt(version, `${path}.artifactId`, obj.artifactId),
+        parts: partsRaw.map((part, index) => decodePart(version, part, `${path}.parts[${index}]`)),
+    };
+    assignOptionalString(version, artifact, 'name', obj.name, `${path}.name`);
+    assignOptionalString(version, artifact, 'description', obj.description, `${path}.description`);
+    assignOptionalJsonObject(version, artifact, 'metadata', obj.metadata, `${path}.metadata`);
+    assignOptionalStringArray(version, artifact, 'extensions', obj.extensions, `${path}.extensions`);
+    return artifact;
+}
+function encodeMessageAt(version, message, path) {
+    try {
+        return encodeMessage(version, message);
+    }
+    catch (error) {
+        if (error instanceof A2AWireValidationError) {
+            throw new A2AWireValidationError(version, `${path}${error.path.slice(1)}`, error.message.split(': ').slice(1).join(': '));
+        }
+        throw error;
+    }
+}
+function encodePart(version, part, path) {
+    const common = {};
+    copyJsonObject(version, common, 'metadata', part.metadata, `${path}.metadata`);
+    copyOptional(common, version === '0.3' ? 'mimeType' : 'mediaType', part.mediaType);
+    if (version === '0.3') {
+        if (part.type === 'text')
+            return { kind: 'text', text: part.text, ...common };
+        if (part.type === 'data')
+            return { kind: 'data', data: part.data, ...common };
+        assertFileOneOf(version, path, part);
+        return {
+            kind: 'file',
+            ...(part.raw !== undefined ? { bytes: part.raw } : { uri: part.url }),
+            ...(part.filename !== undefined ? { name: part.filename } : {}),
+            ...common,
+        };
+    }
+    if (part.type === 'text')
+        return { text: part.text, ...common };
+    if (part.type === 'data')
+        return { data: part.data, ...common };
+    assertFileOneOf(version, path, part);
+    return {
+        ...(part.raw !== undefined ? { raw: part.raw } : { url: part.url }),
+        ...(part.filename !== undefined ? { filename: part.filename } : {}),
+        ...common,
+    };
+}
+function decodePart(version, input, path) {
+    const obj = objectAt(version, path, input);
+    if (version === '0.3')
+        return decodeLegacyPart(obj, path);
+    return decodeV1Part(obj, path);
+}
+function decodeLegacyPart(obj, path) {
+    if (['raw', 'url', 'mediaType'].some(key => obj[key] !== undefined)) {
+        fail('0.3', path, 'contains A2A 1.0 part fields');
+    }
+    const kind = stringAt('0.3', `${path}.kind`, obj.kind);
+    const metadata = optionalJsonObject('0.3', obj.metadata, `${path}.metadata`);
+    if (kind === 'text') {
+        return { type: 'text', text: stringAt('0.3', `${path}.text`, obj.text), ...optionalCommon(obj, metadata, 'mimeType') };
+    }
+    if (kind === 'data') {
+        if (!hasOwn(obj, 'data'))
+            fail('0.3', `${path}.data`, 'is required');
+        assertJsonValue('0.3', `${path}.data`, obj.data);
+        return { type: 'data', data: obj.data, ...optionalCommon(obj, metadata, 'mimeType') };
+    }
+    if (kind !== 'file')
+        fail('0.3', `${path}.kind`, `unsupported kind '${kind}'`);
+    const members = ['bytes', 'uri'].filter(key => obj[key] !== undefined);
+    if (members.length !== 1)
+        fail('0.3', path, 'file part must contain exactly one of bytes or uri');
+    const raw = obj.bytes !== undefined ? stringAt('0.3', `${path}.bytes`, obj.bytes) : undefined;
+    if (raw !== undefined)
+        assertBase64('0.3', `${path}.bytes`, raw);
+    return {
+        type: 'file',
+        ...(raw !== undefined ? { raw } : { url: stringAt('0.3', `${path}.uri`, obj.uri) }),
+        ...(obj.name !== undefined ? { filename: stringAt('0.3', `${path}.name`, obj.name) } : {}),
+        ...optionalCommon(obj, metadata, 'mimeType'),
+    };
+}
+function decodeV1Part(obj, path) {
+    if (['kind', 'mimeType', 'bytes', 'uri'].some(key => obj[key] !== undefined)) {
+        fail('1.0', path, 'contains legacy A2A 0.3 part fields');
+    }
+    const members = ['text', 'raw', 'url', 'data'].filter(key => hasOwn(obj, key));
+    if (members.length !== 1)
+        fail('1.0', path, 'Part must contain exactly one of text, raw, url, or data');
+    const metadata = optionalJsonObject('1.0', obj.metadata, `${path}.metadata`);
+    const common = optionalCommon(obj, metadata, 'mediaType');
+    switch (members[0]) {
+        case 'text':
+            return { type: 'text', text: stringAt('1.0', `${path}.text`, obj.text), ...common };
+        case 'data':
+            assertJsonValue('1.0', `${path}.data`, obj.data);
+            return { type: 'data', data: obj.data, ...common };
+        case 'raw': {
+            const raw = stringAt('1.0', `${path}.raw`, obj.raw);
+            assertBase64('1.0', `${path}.raw`, raw);
+            return {
+                type: 'file', raw,
+                ...(obj.filename !== undefined ? { filename: stringAt('1.0', `${path}.filename`, obj.filename) } : {}),
+                ...common,
+            };
+        }
+        case 'url':
+            return {
+                type: 'file', url: stringAt('1.0', `${path}.url`, obj.url),
+                ...(obj.filename !== undefined ? { filename: stringAt('1.0', `${path}.filename`, obj.filename) } : {}),
+                ...common,
+            };
+        default:
+            fail('1.0', path, 'unknown Part member');
+    }
+}
+function optionalCommon(obj, metadata, mediaKey) {
+    return {
+        ...(obj[mediaKey] !== undefined ? { mediaType: stringAt(mediaKey === 'mimeType' ? '0.3' : '1.0', `$.${mediaKey}`, obj[mediaKey]) } : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function decodeRole(version, input, path) {
+    const role = stringAt(version, path, input);
+    if (version === '0.3') {
+        if (role === 'user' || role === 'agent')
+            return role;
+    }
+    else {
+        if (role === 'ROLE_USER')
+            return 'user';
+        if (role === 'ROLE_AGENT')
+            return 'agent';
+    }
+    fail(version, path, `unsupported role '${role}'`);
+}
+function assertFileOneOf(version, path, part) {
+    if ((part.raw === undefined) === (part.url === undefined)) {
+        fail(version, path, 'normalized file part must contain exactly one of raw or url');
+    }
+    if (part.raw !== undefined)
+        assertBase64(version, `${path}.raw`, part.raw);
+}
+function objectAt(version, path, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail(version, path, 'must be an object');
+    return value;
+}
+function arrayAt(version, path, value) {
+    if (!Array.isArray(value))
+        fail(version, path, 'must be an array');
+    return value;
+}
+function stringAt(version, path, value) {
+    if (typeof value !== 'string')
+        fail(version, path, 'must be a string');
+    return value;
+}
+function assertNonEmptyString(version, path, value) {
+    if (typeof value !== 'string' || value.length === 0)
+        fail(version, path, 'must be a non-empty string');
+}
+function assertTimestamp(version, path, value) {
+    if (!/^\d{4}-\d{2}-\d{2}T/.test(value) || !Number.isFinite(Date.parse(value))) {
+        fail(version, path, 'must be an RFC 3339 timestamp');
+    }
+}
+function assertBase64(version, path, value) {
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+        fail(version, path, 'must be canonical base64');
+    }
+}
+function assertJsonValue(version, path, value) {
+    if (value === null || ['string', 'boolean'].includes(typeof value))
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            fail(version, path, 'JSON numbers must be finite');
+        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 be a JSON value');
+}
+function optionalJsonObject(version, value, path) {
+    if (value === undefined)
+        return undefined;
+    const obj = objectAt(version, path, value);
+    assertJsonValue(version, path, obj);
+    return obj;
+}
+function copyOptional(out, key, value) {
+    if (value !== undefined)
+        out[key] = value;
+}
+function copyJsonObject(version, out, key, value, path) {
+    if (value === undefined)
+        return;
+    assertJsonValue(version, path, value);
+    out[key] = value;
+}
+function copyStringArray(version, out, key, value, path) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value) || value.some(entry => typeof entry !== 'string')) {
+        fail(version, path, 'must be an array of strings');
+    }
+    out[key] = [...value];
+}
+function assignOptionalString(version, out, key, value, path) {
+    if (value !== undefined)
+        out[key] = stringAt(version, path, value);
+}
+function assignOptionalJsonObject(version, out, key, value, path) {
+    const parsed = optionalJsonObject(version, value, path);
+    if (parsed !== undefined)
+        out[key] = parsed;
+}
+function assignOptionalStringArray(version, out, key, value, path) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value) || value.some(entry => typeof entry !== 'string')) {
+        fail(version, path, 'must be an array of strings');
+    }
+    out[key] = [...value];
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function fail(version, path, detail) {
+    throw new A2AWireValidationError(version, path, detail);
+}
+//# sourceMappingURL=codecs.js.map