@ai-agent-forge/agent-forge 0.85.0

package/dist/core/agent-capability-contract.js

@@ -0,0 +1,1154 @@
+/**
+ * Transport-neutral Agent Capability Contract.
+ *
+ * This module is deliberately self contained.  It describes serializable
+ * facts shared by an embedded SDK binding and a service binding; it does not
+ * import either binding or a runtime Agent object.
+ */
+export const AGENT_CAPABILITY_CONTRACT_ID = "agent-forge/agent-capability-contract";
+export const AGENT_CAPABILITY_CONTRACT_VERSION = 1;
+/** Shared error-code registry for the canonical Agent contract. Extensions may use namespaced codes. */
+export const AGENT_ERROR_CODES_V1 = [
+    "provider_error",
+    "operation_timeout",
+    "operation_cancelled",
+    "idempotency_conflict",
+    "revision_conflict",
+    "revision_unavailable",
+    "unsupported_capability",
+    "invalid_request",
+    "invalid_ref",
+    "not_found",
+    "cancelled",
+    "unsupported",
+    "busy",
+    "session_locked",
+    "unauthorized",
+    "not_implemented",
+    "internal_error",
+];
+const agentErrorCodeSet = new Set(AGENT_ERROR_CODES_V1);
+export function isRegisteredAgentErrorCodeV1(code) {
+    return agentErrorCodeSet.has(code);
+}
+/**
+ * Frozen mapping from protocol/server transport error codes onto canonical
+ * agent error codes. Codes outside this table pass through unchanged so plugin
+ * namespaced codes (e.g. `plugin.custom_failure`) survive projection.
+ */
+export const PROTOCOL_ERROR_CODE_TO_AGENT_CODE_V1 = Object.freeze({
+    version: "unsupported",
+    busy: "busy",
+    session_locked: "session_locked",
+    not_found: "not_found",
+    invalid_request: "invalid_request",
+    unauthorized: "unauthorized",
+    not_implemented: "not_implemented",
+    internal_error: "internal_error",
+});
+export function mapProtocolErrorCodeToAgentErrorV1(code) {
+    return PROTOCOL_ERROR_CODE_TO_AGENT_CODE_V1[code];
+}
+/**
+ * Projects an arbitrary caught error onto a canonical detached error envelope.
+ * Transport errors carrying a mappable `code` are mapped; already canonical or
+ * namespaced codes pass through; anything else falls back to `internal_error`.
+ */
+export function toErrorEnvelopeV1(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const name = error instanceof Error ? error.name : undefined;
+    let code;
+    if (error && typeof error === "object" && "code" in error) {
+        const raw = error.code;
+        if (typeof raw === "string" && raw.trim() !== "")
+            code = raw;
+    }
+    if (code === undefined)
+        code = "internal_error";
+    const mapped = PROTOCOL_ERROR_CODE_TO_AGENT_CODE_V1[code];
+    return buildErrorEnvelopeV1({
+        version: 1,
+        code: mapped ?? code,
+        message,
+        retryable: false,
+        ...(name === undefined ? {} : { name }),
+    });
+}
+function isPlainRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function assertPlainRecord(value, label) {
+    if (!isPlainRecord(value))
+        throw new Error(`${label} must be a plain object`);
+}
+function assertExactKeys(value, required, optional, label) {
+    const allowed = new Set([...required, ...optional]);
+    const unsupported = Object.keys(value)
+        .filter((key) => !allowed.has(key))
+        .sort();
+    if (unsupported.length > 0)
+        throw new Error(`${label} has unsupported fields: ${unsupported.join(", ")}`);
+    for (const key of required) {
+        if (!(key in value))
+            throw new Error(`${label} is missing required field: ${key}`);
+    }
+}
+function assertNonEmptyString(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error(`${label} must be a non-empty string`);
+}
+function assertPositiveSafeInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive safe integer`);
+    }
+}
+function assertNonNegativeSafeInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative safe integer`);
+    }
+}
+function assertJsonValue(value, label, seen = new WeakSet()) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return;
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            return;
+        throw new Error(`${label} must contain finite JSON numbers`);
+    }
+    if (typeof value !== "object")
+        throw new Error(`${label} must be JSON-compatible`);
+    if (seen.has(value))
+        throw new Error(`${label} must not contain cycles`);
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const [index, child] of value.entries())
+            assertJsonValue(child, `${label}[${index}]`, seen);
+    }
+    else {
+        if (!isPlainRecord(value))
+            throw new Error(`${label} must contain only plain JSON objects`);
+        for (const [key, child] of Object.entries(value))
+            assertJsonValue(child, `${label}.${key}`, seen);
+    }
+    seen.delete(value);
+}
+function detachedFreeze(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== "object")
+        return value;
+    const existing = seen.get(value);
+    if (existing !== undefined)
+        return existing;
+    if (Array.isArray(value)) {
+        const result = [];
+        seen.set(value, result);
+        for (const child of value)
+            result.push(detachedFreeze(child, seen));
+        return Object.freeze(result);
+    }
+    const result = {};
+    seen.set(value, result);
+    for (const [key, child] of Object.entries(value))
+        result[key] = detachedFreeze(child, seen);
+    return Object.freeze(result);
+}
+function capabilitySort(left, right) {
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : left.version - right.version;
+}
+function validateCapabilityRefs(value, label) {
+    if (!Array.isArray(value))
+        throw new Error(`${label} must be an array`);
+    const refs = value.map((item, index) => validateCapabilityRefV1(item, `${label}[${index}]`));
+    const seen = new Set();
+    for (const ref of refs) {
+        const key = `${ref.id}\u0000${ref.version}`;
+        if (seen.has(key))
+            throw new Error(`${label} contains duplicate capability: ${ref.id}@${ref.version}`);
+        seen.add(key);
+    }
+    return Object.freeze(refs.sort(capabilitySort));
+}
+function validateHostTransport(value, label) {
+    if (value !== "in-process" &&
+        value !== "stdio" &&
+        value !== "http" &&
+        value !== "rpc" &&
+        value !== "unix" &&
+        value !== "websocket") {
+        throw new Error(`${label} is invalid`);
+    }
+}
+export function validateCapabilityRefV1(value, label = "Capability reference") {
+    assertPlainRecord(value, label);
+    assertExactKeys(value, ["id", "version"], [], label);
+    assertNonEmptyString(value.id, `${label}.id`);
+    assertPositiveSafeInteger(value.version, `${label}.version`);
+    return detachedFreeze({ id: value.id, version: value.version });
+}
+export function buildCapabilityRefV1(input) {
+    return validateCapabilityRefV1(input);
+}
+export function validateHostContextV1(value) {
+    assertPlainRecord(value, "Host context");
+    assertExactKeys(value, ["mode", "features", "transports"], [], "Host context");
+    if (value.mode !== "readonly" && value.mode !== "full-control")
+        throw new Error("Host context.mode is invalid");
+    if (!Array.isArray(value.features))
+        throw new Error("Host context.features must be an array");
+    const features = value.features.map((feature, index) => {
+        assertNonEmptyString(feature, `Host context.features[${index}]`);
+        return feature;
+    });
+    if (new Set(features).size !== features.length)
+        throw new Error("Host context.features must not contain duplicates");
+    if (!Array.isArray(value.transports))
+        throw new Error("Host context.transports must be an array");
+    const transports = value.transports.map((transport, index) => {
+        validateHostTransport(transport, `Host context.transports[${index}]`);
+        return transport;
+    });
+    if (new Set(transports).size !== transports.length)
+        throw new Error("Host context.transports must not contain duplicates");
+    return detachedFreeze({
+        mode: value.mode,
+        features: [...features].sort(),
+        transports: [...transports].sort(),
+    });
+}
+export function buildHostContextV1(input) {
+    return validateHostContextV1(input);
+}
+export function validateContractCompatibilityRequirementsV1(value) {
+    assertPlainRecord(value, "Contract compatibility requirements");
+    assertExactKeys(value, ["contractId", "version", "mode", "features", "transports", "capabilities"], [], "Contract compatibility requirements");
+    assertNonEmptyString(value.contractId, "Contract compatibility requirements.contractId");
+    assertPositiveSafeInteger(value.version, "Contract compatibility requirements.version");
+    const hostContext = validateHostContextV1({
+        mode: value.mode,
+        features: value.features,
+        transports: value.transports,
+    });
+    const capabilities = validateCapabilityRefs(value.capabilities, "Contract compatibility requirements.capabilities");
+    return detachedFreeze({
+        contractId: value.contractId,
+        version: value.version,
+        mode: hostContext.mode,
+        features: hostContext.features,
+        transports: hostContext.transports,
+        capabilities,
+    });
+}
+export function buildContractCompatibilityRequirementsV1(input) {
+    return validateContractCompatibilityRequirementsV1(input);
+}
+const CONTRACT_COMPATIBILITY_ISSUE_CODES_V1 = [
+    "unsupported_contract",
+    "host_mode_mismatch",
+    "unsupported_feature",
+    "unsupported_transport",
+    "unsupported_capability",
+];
+/** Validates frozen compatibility results so both bindings share one matrix shape. */
+export function validateContractCompatibilityResultV1(value) {
+    assertPlainRecord(value, "Contract compatibility result");
+    assertExactKeys(value, ["version", "compatible", "issues"], [], "Contract compatibility result");
+    if (value.version !== 1)
+        throw new Error("Contract compatibility result.version must be 1");
+    if (typeof value.compatible !== "boolean")
+        throw new Error("Contract compatibility result.compatible must be boolean");
+    if (!Array.isArray(value.issues))
+        throw new Error("Contract compatibility result.issues must be an array");
+    if (value.compatible && value.issues.length > 0) {
+        throw new Error("Contract compatibility result.compatible must be false when issues exist");
+    }
+    if (!value.compatible && value.issues.length === 0) {
+        throw new Error("Contract compatibility result.compatible must be true when no issues exist");
+    }
+    const issues = value.issues.map((entry, index) => {
+        assertPlainRecord(entry, `Contract compatibility result.issues[${index}]`);
+        assertExactKeys(entry, ["code", "error"], ["missingFeatures", "missingTransports", "missingCapabilities"], `Contract compatibility result.issues[${index}]`);
+        if (!CONTRACT_COMPATIBILITY_ISSUE_CODES_V1.includes(entry.code)) {
+            throw new Error(`Contract compatibility result.issues[${index}].code is invalid`);
+        }
+        const error = validateErrorEnvelopeV1(entry.error);
+        const missingFeatures = entry.missingFeatures;
+        if (missingFeatures !== undefined) {
+            if (!Array.isArray(missingFeatures) || missingFeatures.some((item) => typeof item !== "string")) {
+                throw new Error(`Contract compatibility result.issues[${index}].missingFeatures must be strings`);
+            }
+        }
+        const missingTransports = entry.missingTransports;
+        if (missingTransports !== undefined) {
+            if (!Array.isArray(missingTransports) || missingTransports.some((item) => typeof item !== "string")) {
+                throw new Error(`Contract compatibility result.issues[${index}].missingTransports must be strings`);
+            }
+        }
+        const missingCapabilities = entry.missingCapabilities;
+        if (missingCapabilities !== undefined) {
+            validateCapabilityRefs(missingCapabilities, `Contract compatibility result.issues[${index}].missingCapabilities`);
+        }
+        const issue = {
+            code: entry.code,
+            error,
+            ...(missingFeatures === undefined
+                ? {}
+                : { missingFeatures: Object.freeze(missingFeatures.map((item) => item)) }),
+            ...(missingTransports === undefined
+                ? {}
+                : { missingTransports: Object.freeze(missingTransports.map((item) => item)) }),
+            ...(missingCapabilities === undefined
+                ? {}
+                : { missingCapabilities: validateCapabilityRefs(missingCapabilities, "missingCapabilities") }),
+        };
+        return detachedFreeze(issue);
+    });
+    return detachedFreeze({
+        version: 1,
+        compatible: value.compatible,
+        issues: Object.freeze(issues),
+    });
+}
+export function validateAgentCapabilityContractV1(value) {
+    assertPlainRecord(value, "Agent capability contract");
+    assertExactKeys(value, ["contractId", "version", "capabilities", "hostContext"], [], "Agent capability contract");
+    if (value.contractId !== AGENT_CAPABILITY_CONTRACT_ID) {
+        throw new Error(`Agent capability contract.contractId must be ${AGENT_CAPABILITY_CONTRACT_ID}`);
+    }
+    if (value.version !== 1)
+        throw new Error("Agent capability contract.version must be 1");
+    const capabilities = validateCapabilityRefs(value.capabilities, "Agent capability contract.capabilities");
+    const hostContext = validateHostContextV1(value.hostContext);
+    return detachedFreeze({ contractId: value.contractId, version: 1, capabilities, hostContext });
+}
+export function buildAgentCapabilityContractV1(input) {
+    return validateAgentCapabilityContractV1({ ...input, version: input.version ?? 1 });
+}
+export function validateAgentProfileV1(value) {
+    assertPlainRecord(value, "Agent profile");
+    assertExactKeys(value, ["id", "version", "rootAgent", "requiredPlugins"], ["optionalPlugins", "defaults"], "Agent profile");
+    assertNonEmptyString(value.id, "Agent profile.id");
+    assertPositiveSafeInteger(value.version, "Agent profile.version");
+    assertNonEmptyString(value.rootAgent, "Agent profile.rootAgent");
+    const validatePluginIds = (candidate, label) => {
+        if (!Array.isArray(candidate))
+            throw new Error(`${label} must be an array`);
+        const ids = candidate.map((id, index) => {
+            assertNonEmptyString(id, `${label}[${index}]`);
+            return id;
+        });
+        if (new Set(ids).size !== ids.length)
+            throw new Error(`${label} must not contain duplicates`);
+        return Object.freeze([...ids].sort());
+    };
+    const requiredPlugins = validatePluginIds(value.requiredPlugins, "Agent profile.requiredPlugins");
+    const optionalPlugins = value.optionalPlugins === undefined
+        ? undefined
+        : validatePluginIds(value.optionalPlugins, "Agent profile.optionalPlugins");
+    if (optionalPlugins?.some((id) => requiredPlugins.includes(id))) {
+        throw new Error("Agent profile.optionalPlugins must not overlap requiredPlugins");
+    }
+    if (value.defaults !== undefined)
+        assertJsonValue(value.defaults, "Agent profile.defaults");
+    return detachedFreeze({
+        id: value.id,
+        version: value.version,
+        rootAgent: value.rootAgent,
+        requiredPlugins,
+        ...(optionalPlugins === undefined ? {} : { optionalPlugins }),
+        ...(value.defaults === undefined ? {} : { defaults: value.defaults }),
+    });
+}
+export function buildAgentProfileV1(input) {
+    return validateAgentProfileV1(input);
+}
+export function validateArtifactRefV1(value) {
+    assertPlainRecord(value, "Artifact reference");
+    assertExactKeys(value, ["sessionId", "operationId", "artifactId", "kind", "mediaType", "truncated", "createdAt"], ["sizeBytes"], "Artifact reference");
+    assertNonEmptyString(value.sessionId, "Artifact reference.sessionId");
+    assertNonEmptyString(value.operationId, "Artifact reference.operationId");
+    assertNonEmptyString(value.artifactId, "Artifact reference.artifactId");
+    assertNonEmptyString(value.kind, "Artifact reference.kind");
+    assertNonEmptyString(value.mediaType, "Artifact reference.mediaType");
+    if (value.sizeBytes !== undefined)
+        assertNonNegativeSafeInteger(value.sizeBytes, "Artifact reference.sizeBytes");
+    if (typeof value.truncated !== "boolean")
+        throw new Error("Artifact reference.truncated must be boolean");
+    assertNonNegativeSafeInteger(value.createdAt, "Artifact reference.createdAt");
+    return detachedFreeze({
+        sessionId: value.sessionId,
+        operationId: value.operationId,
+        artifactId: value.artifactId,
+        kind: value.kind,
+        mediaType: value.mediaType,
+        ...(value.sizeBytes === undefined ? {} : { sizeBytes: value.sizeBytes }),
+        truncated: value.truncated,
+        createdAt: value.createdAt,
+    });
+}
+export function buildArtifactRefV1(input) {
+    return validateArtifactRefV1(input);
+}
+/**
+ * Compare a candidate contract to explicitly requested semantics. V1 has no
+ * version upcast/downcast: a different contract ID or version is unsupported.
+ */
+export function checkContractCompatibilityV1(candidateInput, requirementsInput) {
+    const candidate = validateAgentCapabilityContractV1(candidateInput);
+    const requirements = validateContractCompatibilityRequirementsV1(requirementsInput);
+    const issues = [];
+    if (candidate.contractId !== requirements.contractId || candidate.version !== requirements.version) {
+        issues.push({
+            code: "unsupported_contract",
+            error: commandError("unsupported_contract", `Contract is unsupported: ${requirements.contractId}@${requirements.version}`),
+        });
+    }
+    if (candidate.hostContext.mode !== requirements.mode) {
+        issues.push({
+            code: "host_mode_mismatch",
+            error: commandError("host_mode_mismatch", `Host mode is incompatible: required ${requirements.mode}, received ${candidate.hostContext.mode}`),
+        });
+    }
+    const missingFeatures = requirements.features.filter((feature) => !candidate.hostContext.features.includes(feature));
+    if (missingFeatures.length > 0) {
+        issues.push({
+            code: "unsupported_feature",
+            error: commandError("unsupported_feature", `Host features are unsupported: ${missingFeatures.join(", ")}`),
+            missingFeatures: Object.freeze([...missingFeatures]),
+        });
+    }
+    const missingTransports = requirements.transports.filter((transport) => !candidate.hostContext.transports.includes(transport));
+    if (missingTransports.length > 0) {
+        issues.push({
+            code: "unsupported_transport",
+            error: commandError("unsupported_transport", `Host transports are unsupported: ${missingTransports.join(", ")}`),
+            missingTransports: Object.freeze([...missingTransports]),
+        });
+    }
+    const missingCapabilities = requirements.capabilities.filter((required) => !candidate.capabilities.some((available) => available.id === required.id && available.version === required.version));
+    if (missingCapabilities.length > 0) {
+        issues.push({
+            code: "unsupported_capability",
+            error: commandError("unsupported_capability", `Capabilities are unsupported: ${missingCapabilities.map((item) => `${item.id}@${item.version}`).join(", ")}`),
+            missingCapabilities: Object.freeze([...missingCapabilities]),
+        });
+    }
+    return detachedFreeze({ version: 1, compatible: issues.length === 0, issues });
+}
+function validateAgentRole(value, label) {
+    if (value !== "root-agent-controller" && value !== "child-agent-controller")
+        throw new Error(`${label} is invalid`);
+}
+export function validateAgentDefinitionSnapshotV1(value) {
+    assertPlainRecord(value, "Agent definition snapshot");
+    assertExactKeys(value, ["version", "id", "definitionVersion", "role", "capabilities"], ["owner"], "Agent definition snapshot");
+    if (value.version !== 1)
+        throw new Error("Agent definition snapshot.version must be 1");
+    assertNonEmptyString(value.id, "Agent definition snapshot.id");
+    assertPositiveSafeInteger(value.definitionVersion, "Agent definition snapshot.definitionVersion");
+    validateAgentRole(value.role, "Agent definition snapshot.role");
+    const capabilities = validateCapabilityRefs(value.capabilities, "Agent definition snapshot.capabilities");
+    if (value.owner !== undefined)
+        assertNonEmptyString(value.owner, "Agent definition snapshot.owner");
+    return detachedFreeze({
+        version: 1,
+        id: value.id,
+        definitionVersion: value.definitionVersion,
+        role: value.role,
+        capabilities,
+        ...(value.owner === undefined ? {} : { owner: value.owner }),
+    });
+}
+export function buildAgentDefinitionSnapshotV1(input) {
+    return validateAgentDefinitionSnapshotV1(input);
+}
+export function validateAgentInstanceSnapshotV1(value) {
+    assertPlainRecord(value, "Agent instance snapshot");
+    assertExactKeys(value, ["version", "id", "definitionId", "definitionVersion", "role", "status", "revision"], ["parentInstanceId", "leaseOwner"], "Agent instance snapshot");
+    if (value.version !== 1)
+        throw new Error("Agent instance snapshot.version must be 1");
+    assertNonEmptyString(value.id, "Agent instance snapshot.id");
+    assertNonEmptyString(value.definitionId, "Agent instance snapshot.definitionId");
+    assertPositiveSafeInteger(value.definitionVersion, "Agent instance snapshot.definitionVersion");
+    validateAgentRole(value.role, "Agent instance snapshot.role");
+    if (value.status !== "created" &&
+        value.status !== "running" &&
+        value.status !== "succeeded" &&
+        value.status !== "failed" &&
+        value.status !== "cancelled" &&
+        value.status !== "disposed") {
+        throw new Error("Agent instance snapshot.status is invalid");
+    }
+    assertNonNegativeSafeInteger(value.revision, "Agent instance snapshot.revision");
+    if (value.parentInstanceId !== undefined)
+        assertNonEmptyString(value.parentInstanceId, "Agent instance snapshot.parentInstanceId");
+    if (value.leaseOwner !== undefined)
+        assertNonEmptyString(value.leaseOwner, "Agent instance snapshot.leaseOwner");
+    return detachedFreeze({
+        version: 1,
+        id: value.id,
+        definitionId: value.definitionId,
+        definitionVersion: value.definitionVersion,
+        role: value.role,
+        status: value.status,
+        revision: value.revision,
+        ...(value.parentInstanceId === undefined ? {} : { parentInstanceId: value.parentInstanceId }),
+        ...(value.leaseOwner === undefined ? {} : { leaseOwner: value.leaseOwner }),
+    });
+}
+export function buildAgentInstanceSnapshotV1(input) {
+    return validateAgentInstanceSnapshotV1(input);
+}
+export function validateSessionRevisionV1(value) {
+    assertPlainRecord(value, "Session revision");
+    assertExactKeys(value, ["version", "sessionId", "sequence", "leafId"], [], "Session revision");
+    if (value.version !== 1)
+        throw new Error("Session revision.version must be 1");
+    assertNonEmptyString(value.sessionId, "Session revision.sessionId");
+    assertNonNegativeSafeInteger(value.sequence, "Session revision.sequence");
+    if (value.leafId !== null && value.leafId !== undefined)
+        assertNonEmptyString(value.leafId, "Session revision.leafId");
+    if (value.leafId === undefined)
+        throw new Error("Session revision.leafId is required");
+    return detachedFreeze({
+        version: 1,
+        sessionId: value.sessionId,
+        sequence: value.sequence,
+        leafId: value.leafId,
+    });
+}
+export function buildSessionRevisionV1(input) {
+    return validateSessionRevisionV1(input);
+}
+export function validateSessionSnapshotV1(value) {
+    assertPlainRecord(value, "Session snapshot");
+    assertExactKeys(value, ["version", "sessionId", "revision"], [], "Session snapshot");
+    if (value.version !== 1)
+        throw new Error("Session snapshot.version must be 1");
+    assertNonEmptyString(value.sessionId, "Session snapshot.sessionId");
+    const revision = validateSessionRevisionV1(value.revision);
+    if (revision.sessionId !== value.sessionId)
+        throw new Error("Session snapshot.revision.sessionId must match sessionId");
+    return detachedFreeze({ version: 1, sessionId: value.sessionId, revision });
+}
+export function buildSessionSnapshotV1(input) {
+    return validateSessionSnapshotV1(input);
+}
+export function validateErrorEnvelopeV1(value) {
+    assertPlainRecord(value, "Error envelope");
+    assertExactKeys(value, ["version", "code", "message", "retryable"], ["details", "name"], "Error envelope");
+    if (value.version !== 1)
+        throw new Error("Error envelope.version must be 1");
+    assertNonEmptyString(value.code, "Error envelope.code");
+    if (typeof value.message !== "string")
+        throw new Error("Error envelope.message must be a string");
+    if (typeof value.retryable !== "boolean")
+        throw new Error("Error envelope.retryable must be a boolean");
+    if (value.name !== undefined)
+        assertNonEmptyString(value.name, "Error envelope.name");
+    if (value.details !== undefined)
+        assertJsonValue(value.details, "Error envelope.details");
+    return detachedFreeze({
+        version: 1,
+        code: value.code,
+        message: value.message,
+        retryable: value.retryable,
+        ...(value.details === undefined ? {} : { details: value.details }),
+        ...(value.name === undefined ? {} : { name: value.name }),
+    });
+}
+export function buildErrorEnvelopeV1(input) {
+    return validateErrorEnvelopeV1(input);
+}
+function validateOperationTerminalStatus(value, label) {
+    if (value !== "succeeded" && value !== "failed" && value !== "cancelled" && value !== "timed_out") {
+        throw new Error(`${label} is invalid`);
+    }
+}
+export function validateOperationTerminalV1(value) {
+    assertPlainRecord(value, "Operation terminal");
+    if (!("version" in value) || !("status" in value)) {
+        throw new Error("Operation terminal is missing required field: version or status");
+    }
+    if (value.version !== 1)
+        throw new Error("Operation terminal.version must be 1");
+    validateOperationTerminalStatus(value.status, "Operation terminal.status");
+    if (value.status === "succeeded") {
+        assertExactKeys(value, ["version", "status"], ["result"], "Operation terminal");
+        if (value.result !== undefined)
+            assertJsonValue(value.result, "Operation terminal.result");
+        return detachedFreeze({
+            version: 1,
+            status: "succeeded",
+            ...(value.result === undefined ? {} : { result: value.result }),
+        });
+    }
+    assertExactKeys(value, ["version", "status", "error"], [], "Operation terminal");
+    const error = validateErrorEnvelopeV1(value.error);
+    return detachedFreeze({ version: 1, status: value.status, error });
+}
+export function buildOperationTerminalV1(input) {
+    return validateOperationTerminalV1(input);
+}
+export function validateOperationSnapshotV1(value) {
+    assertPlainRecord(value, "Operation snapshot");
+    assertExactKeys(value, ["version", "operationId", "kind", "status"], ["terminal", "instanceId", "sessionId", "inputRevision"], "Operation snapshot");
+    if (value.version !== 1)
+        throw new Error("Operation snapshot.version must be 1");
+    assertNonEmptyString(value.operationId, "Operation snapshot.operationId");
+    assertNonEmptyString(value.kind, "Operation snapshot.kind");
+    if (value.status !== "queued" &&
+        value.status !== "running" &&
+        value.status !== "succeeded" &&
+        value.status !== "failed" &&
+        value.status !== "cancelled" &&
+        value.status !== "timed_out") {
+        throw new Error("Operation snapshot.status is invalid");
+    }
+    if ((value.status === "queued" || value.status === "running") && value.terminal !== undefined) {
+        throw new Error("Operation snapshot active status must not have a terminal");
+    }
+    if (value.status !== "queued" && value.status !== "running" && value.terminal === undefined) {
+        throw new Error("Operation snapshot terminal status requires a terminal");
+    }
+    const terminal = value.terminal === undefined ? undefined : validateOperationTerminalV1(value.terminal);
+    if (terminal !== undefined && terminal.status !== value.status)
+        throw new Error("Operation snapshot.terminal.status must match status");
+    if (value.instanceId !== undefined)
+        assertNonEmptyString(value.instanceId, "Operation snapshot.instanceId");
+    if (value.sessionId !== undefined)
+        assertNonEmptyString(value.sessionId, "Operation snapshot.sessionId");
+    const inputRevision = value.inputRevision === undefined ? undefined : validateSessionRevisionV1(value.inputRevision);
+    if (inputRevision !== undefined && value.sessionId !== undefined && inputRevision.sessionId !== value.sessionId) {
+        throw new Error("Operation snapshot.inputRevision.sessionId must match sessionId");
+    }
+    return detachedFreeze({
+        version: 1,
+        operationId: value.operationId,
+        kind: value.kind,
+        status: value.status,
+        ...(terminal === undefined ? {} : { terminal }),
+        ...(value.instanceId === undefined ? {} : { instanceId: value.instanceId }),
+        ...(value.sessionId === undefined ? {} : { sessionId: value.sessionId }),
+        ...(inputRevision === undefined ? {} : { inputRevision }),
+    });
+}
+export function buildOperationSnapshotV1(input) {
+    return validateOperationSnapshotV1(input);
+}
+export function validateCommandRequestV1(value) {
+    assertPlainRecord(value, "Command request");
+    assertExactKeys(value, ["version", "operationId", "idempotencyKey", "command", "target", "input", "hostContext"], ["expectedRevision"], "Command request");
+    if (value.version !== 1)
+        throw new Error("Command request.version must be 1");
+    assertNonEmptyString(value.operationId, "Command request.operationId");
+    assertNonEmptyString(value.idempotencyKey, "Command request.idempotencyKey");
+    assertNonEmptyString(value.command, "Command request.command");
+    assertNonEmptyString(value.target, "Command request.target");
+    assertJsonValue(value.input, "Command request.input");
+    const expectedRevision = value.expectedRevision === undefined ? undefined : validateSessionRevisionV1(value.expectedRevision);
+    if (expectedRevision !== undefined && expectedRevision.sessionId !== value.target) {
+        throw new Error("Command request.expectedRevision.sessionId does not match target");
+    }
+    const hostContext = validateHostContextV1(value.hostContext);
+    return detachedFreeze({
+        version: 1,
+        operationId: value.operationId,
+        idempotencyKey: value.idempotencyKey,
+        command: value.command,
+        target: value.target,
+        input: value.input,
+        ...(expectedRevision === undefined ? {} : { expectedRevision }),
+        hostContext,
+    });
+}
+export function buildCommandRequestV1(input) {
+    return validateCommandRequestV1({ ...input, version: input.version ?? 1 });
+}
+export function validateCommandAdmissionV1(value) {
+    assertPlainRecord(value, "Command admission");
+    assertExactKeys(value, ["version", "status", "request"], ["operation", "error"], "Command admission");
+    if (value.version !== 1)
+        throw new Error("Command admission.version must be 1");
+    if (value.status !== "accepted" && value.status !== "existing" && value.status !== "rejected") {
+        throw new Error("Command admission.status is invalid");
+    }
+    const request = validateCommandRequestV1(value.request);
+    const operation = value.operation === undefined ? undefined : validateOperationSnapshotV1(value.operation);
+    if ((value.status === "accepted" || value.status === "existing") && operation === undefined) {
+        throw new Error("Command admission accepted status requires an operation");
+    }
+    if (value.status === "rejected" && value.error === undefined) {
+        throw new Error("Command admission rejected status requires an error");
+    }
+    const error = value.error === undefined ? undefined : validateErrorEnvelopeV1(value.error);
+    return detachedFreeze({
+        version: 1,
+        status: value.status,
+        request,
+        ...(operation === undefined ? {} : { operation }),
+        ...(error === undefined ? {} : { error }),
+    });
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+        .join(",")}}`;
+}
+function sameRevision(left, right) {
+    return left.sessionId === right.sessionId && left.sequence === right.sequence && left.leafId === right.leafId;
+}
+function commandError(code, message, details) {
+    return buildErrorEnvelopeV1({
+        version: 1,
+        code,
+        message,
+        retryable: false,
+        ...(details === undefined ? {} : { details: details }),
+    });
+}
+function rejectedAdmission(request, error) {
+    return detachedFreeze({ version: 1, status: "rejected", request, error });
+}
+/** Create the reference command admission registry used by deterministic fixtures. */
+export function createCommandOperationRegistryV1() {
+    const entries = new Map();
+    const read = (operationId) => {
+        assertNonEmptyString(operationId, "operationId");
+        const entry = entries.get(operationId);
+        if (!entry)
+            throw new Error(`Operation is not retained: ${operationId}`);
+        return entry;
+    };
+    const write = (entry, operation) => {
+        entry.operation = operation;
+        return operation;
+    };
+    const terminal = (entry) => entry.operation.terminal !== undefined;
+    return Object.freeze({
+        admit(input, currentRevision) {
+            const request = validateCommandRequestV1(input);
+            const current = currentRevision === undefined ? undefined : validateSessionRevisionV1(currentRevision);
+            const fingerprint = canonicalJson(request);
+            const existing = entries.get(request.operationId);
+            if (existing) {
+                if (existing.fingerprint === fingerprint) {
+                    return detachedFreeze({
+                        version: 1,
+                        status: "existing",
+                        request,
+                        operation: existing.operation,
+                    });
+                }
+                return rejectedAdmission(request, commandError("idempotency_conflict", `Operation ID is already bound to different input: ${request.operationId}`));
+            }
+            if (request.expectedRevision !== undefined) {
+                if (current === undefined) {
+                    return rejectedAdmission(request, commandError("revision_unavailable", `Current revision is required for: ${request.target}`));
+                }
+                if (!sameRevision(request.expectedRevision, current)) {
+                    return rejectedAdmission(request, commandError("revision_conflict", `Expected revision does not match: ${request.target}`, {
+                        expectedRevision: request.expectedRevision,
+                        currentRevision: current,
+                    }));
+                }
+            }
+            const operation = buildOperationSnapshotV1({
+                version: 1,
+                operationId: request.operationId,
+                kind: `command:${request.command}`,
+                status: "queued",
+                ...(request.expectedRevision === undefined
+                    ? {}
+                    : { sessionId: request.expectedRevision.sessionId, inputRevision: request.expectedRevision }),
+            });
+            entries.set(request.operationId, { request, fingerprint, operation });
+            return detachedFreeze({ version: 1, status: "accepted", request, operation });
+        },
+        start(operationId) {
+            const entry = read(operationId);
+            if (entry.operation.status !== "queued")
+                return entry.operation;
+            return write(entry, buildOperationSnapshotV1({ ...entry.operation, status: "running" }));
+        },
+        complete(operationId, terminalSnapshot) {
+            const entry = read(operationId);
+            const nextTerminal = validateOperationTerminalV1(terminalSnapshot);
+            if (terminal(entry)) {
+                if (canonicalJson(entry.operation.terminal) !==
+                    canonicalJson(nextTerminal)) {
+                    throw new Error(`Operation already has a different terminal result: ${operationId}`);
+                }
+                return entry.operation;
+            }
+            return write(entry, buildOperationSnapshotV1({ ...entry.operation, status: nextTerminal.status, terminal: nextTerminal }));
+        },
+        cancel(operationId) {
+            const entry = read(operationId);
+            if (terminal(entry))
+                return entry.operation;
+            return write(entry, buildOperationSnapshotV1({
+                ...entry.operation,
+                status: "cancelled",
+                terminal: {
+                    version: 1,
+                    status: "cancelled",
+                    error: commandError("operation_cancelled", `Operation cancelled: ${operationId}`),
+                },
+            }));
+        },
+        get(operationId) {
+            assertNonEmptyString(operationId, "operationId");
+            return entries.get(operationId)?.operation;
+        },
+        release(operationId) {
+            assertNonEmptyString(operationId, "operationId");
+            entries.delete(operationId);
+        },
+    });
+}
+/** Build the stable semantic vector used by embedded and future service bindings. */
+export function buildCanonicalContractVectorsV1() {
+    const hostContext = buildHostContextV1({
+        mode: "full-control",
+        features: ["agent.run", "session.snapshot"],
+        transports: ["in-process"],
+    });
+    const contract = buildAgentCapabilityContractV1({
+        contractId: AGENT_CAPABILITY_CONTRACT_ID,
+        capabilities: [{ id: "agent.run", version: 1 }],
+        hostContext,
+    });
+    const profile = buildAgentProfileV1({
+        id: "coding-agent",
+        version: 1,
+        rootAgent: "coding-agent.root",
+        requiredPlugins: ["bootstrap-tools"],
+        optionalPlugins: ["bootstrap-skills"],
+        defaults: { mode: "full-control", context: { strategy: "default" } },
+    });
+    const artifact = buildArtifactRefV1({
+        sessionId: "session-vector-1",
+        operationId: "vector-operation-1",
+        artifactId: "artifact-vector-1",
+        kind: "operation_record",
+        mediaType: "application/json",
+        sizeBytes: 13,
+        truncated: false,
+        createdAt: 0,
+    });
+    const revision = buildSessionRevisionV1({ version: 1, sessionId: "session-vector-1", sequence: 0, leafId: null });
+    const definition = buildAgentDefinitionSnapshotV1({
+        version: 1,
+        id: "coding-agent.root",
+        definitionVersion: 1,
+        role: "root-agent-controller",
+        capabilities: [{ id: "agent.run", version: 1 }],
+        owner: "coding-agent",
+    });
+    const instance = buildAgentInstanceSnapshotV1({
+        version: 1,
+        id: "instance-vector-1",
+        definitionId: definition.id,
+        definitionVersion: definition.definitionVersion,
+        role: definition.role,
+        status: "created",
+        revision: 0,
+    });
+    const session = buildSessionSnapshotV1({ version: 1, sessionId: revision.sessionId, revision });
+    const error = buildErrorEnvelopeV1({
+        version: 1,
+        code: "provider_error",
+        message: "provider failed",
+        retryable: true,
+    });
+    const command = buildCommandRequestV1({
+        operationId: "vector-operation-1",
+        idempotencyKey: "vector-request-1",
+        command: "agent.run",
+        target: "session-vector-1",
+        input: { prompt: "vector" },
+        expectedRevision: { version: 1, sessionId: "session-vector-1", sequence: 0, leafId: null },
+        hostContext,
+    });
+    const registry = createCommandOperationRegistryV1();
+    const accepted = registry.admit(command, command.expectedRevision);
+    if (accepted.status !== "accepted" || accepted.operation === undefined) {
+        throw new Error("Canonical contract vector admission failed");
+    }
+    const running = registry.start(command.operationId);
+    const terminal = registry.complete(command.operationId, {
+        version: 1,
+        status: "succeeded",
+        result: { ok: true },
+    });
+    const event = buildEventEnvelopeV1({
+        id: "vector-event-1",
+        deliveryId: "vector-delivery-1",
+        type: "operation.end",
+        source: "canonical-vector",
+        category: "authoritative",
+        deliveryGuarantee: "best-effort",
+        timestamp: 0,
+        operationId: command.operationId,
+        correlationId: command.operationId,
+        data: { version: 1, operationId: command.operationId, operationKind: command.command, status: "succeeded" },
+    });
+    return detachedFreeze({
+        version: 1,
+        contract,
+        definition,
+        instance,
+        session,
+        revision,
+        error,
+        profile,
+        artifact,
+        command,
+        accepted,
+        running,
+        terminal,
+        event,
+    });
+}
+/**
+ * Stable V1 fixture vectors. They intentionally model contract outcomes, not
+ * SDK/runtime implementation details, so each binding can consume them.
+ */
+export function buildCanonicalContractFixtureVectorsV1() {
+    const base = buildCanonicalContractVectorsV1();
+    const registry = createCommandOperationRegistryV1();
+    const request = buildCommandRequestV1({
+        operationId: "fixture-operation-1",
+        idempotencyKey: "fixture-request-1",
+        command: "agent.run",
+        target: "session-fixture-1",
+        input: { prompt: "fixture" },
+        expectedRevision: { version: 1, sessionId: "session-fixture-1", sequence: 1, leafId: "leaf-1" },
+        hostContext: base.contract.hostContext,
+    });
+    registry.admit(request, request.expectedRevision);
+    const existing = registry.admit(request, request.expectedRevision);
+    const idempotencyConflict = registry.admit({ ...request, input: { prompt: "different" } }, request.expectedRevision);
+    const revisionConflict = registry.admit({ ...request, operationId: "fixture-operation-2", idempotencyKey: "fixture-request-2" }, { version: 1, sessionId: "session-fixture-1", sequence: 2, leafId: "leaf-2" });
+    const cancelled = registry.cancel(request.operationId);
+    const terminalReplay = registry.complete(request.operationId, cancelled.terminal);
+    const failed = registry.admit(buildCommandRequestV1({
+        ...request,
+        operationId: "fixture-operation-failed",
+        idempotencyKey: "fixture-request-failed",
+    }), request.expectedRevision);
+    if (failed.status !== "accepted")
+        throw new Error("Canonical contract failed vector admission failed");
+    const failedTerminal = registry.complete("fixture-operation-failed", {
+        version: 1,
+        status: "failed",
+        error: buildErrorEnvelopeV1({
+            version: 1,
+            code: "provider_error",
+            message: "provider failed",
+            retryable: true,
+        }),
+    });
+    const timedOut = registry.admit(buildCommandRequestV1({
+        ...request,
+        operationId: "fixture-operation-timeout",
+        idempotencyKey: "fixture-request-timeout",
+    }), request.expectedRevision);
+    if (timedOut.status !== "accepted")
+        throw new Error("Canonical contract timeout vector admission failed");
+    const timedOutTerminal = registry.complete("fixture-operation-timeout", {
+        version: 1,
+        status: "timed_out",
+        error: buildErrorEnvelopeV1({
+            version: 1,
+            code: "operation_timeout",
+            message: "operation timed out",
+            retryable: true,
+        }),
+    });
+    const unsupported = buildUnsupportedCapabilityV1({ id: "fixture.missing", version: 1 });
+    const observation = buildEventEnvelopeV1({
+        id: "fixture-event-1",
+        deliveryId: "fixture-delivery-1",
+        type: "fixture.observation",
+        source: "canonical-vector",
+        timestamp: 0,
+        data: { observed: true },
+    });
+    const correlated = buildEventEnvelopeV1({
+        id: "fixture-event-correlated",
+        deliveryId: "fixture-delivery-correlated",
+        type: "operation.end",
+        source: "canonical-vector",
+        category: "authoritative",
+        timestamp: 0,
+        operationId: "fixture-operation-1",
+        correlationId: "fixture-operation-1",
+        data: { status: "cancelled" },
+    });
+    const steer = buildCommandRequestV1({
+        operationId: "fixture-operation-steer",
+        idempotencyKey: "fixture-request-steer",
+        command: "session.steer",
+        target: "session-fixture-1",
+        input: { text: "steer" },
+        expectedRevision: request.expectedRevision,
+        hostContext: base.contract.hostContext,
+    });
+    const operationStep = buildEventEnvelopeV1({
+        id: "fixture-event-step",
+        deliveryId: "fixture-delivery-step",
+        type: "operation.step",
+        source: "canonical-vector",
+        category: "progress",
+        timestamp: 0,
+        operationId: "fixture-operation-steer",
+        correlationId: "fixture-operation-steer",
+        data: {
+            version: 1,
+            operationId: "fixture-operation-steer",
+            operationKind: "session.steer",
+            step: 1,
+            message: "accepted",
+        },
+    });
+    const compatibilityRequirements = (overrides) => buildContractCompatibilityRequirementsV1({
+        contractId: AGENT_CAPABILITY_CONTRACT_ID,
+        version: 1,
+        mode: "full-control",
+        features: [],
+        transports: [],
+        capabilities: [],
+        ...overrides,
+    });
+    const compatibilityAccepted = checkContractCompatibilityV1(base.contract, compatibilityRequirements({
+        features: ["agent.run", "session.snapshot"],
+        transports: ["in-process"],
+        capabilities: [{ id: "agent.run", version: 1 }],
+    }));
+    const compatibilityContractUnsupported = checkContractCompatibilityV1(base.contract, compatibilityRequirements({ version: 2 }));
+    const compatibilityCapabilityVersionUnsupported = checkContractCompatibilityV1(base.contract, compatibilityRequirements({ capabilities: [{ id: "agent.run", version: 2 }] }));
+    const compatibilityFeatureSubset = checkContractCompatibilityV1(base.contract, compatibilityRequirements({ features: ["agent.run", "session.compact"] }));
+    return detachedFreeze([
+        { id: "agent-definition", value: base.definition },
+        { id: "agent-instance", value: base.instance },
+        { id: "session-snapshot", value: base.session },
+        { id: "session-revision", value: base.revision },
+        { id: "error-envelope", value: base.error },
+        { id: "profile-snapshot", value: base.profile },
+        { id: "artifact-reference", value: base.artifact },
+        { id: "command-success", value: base.terminal },
+        { id: "command-failed-terminal", value: failedTerminal },
+        { id: "command-timed-out-terminal", value: timedOutTerminal },
+        { id: "command-idempotency-replay", value: existing },
+        { id: "command-idempotency-conflict", value: idempotencyConflict },
+        { id: "command-revision-conflict", value: revisionConflict },
+        { id: "command-cancel-terminal", value: cancelled },
+        { id: "command-terminal-replay", value: terminalReplay },
+        { id: "capability-unsupported", value: unsupported },
+        { id: "event-without-operation", value: observation },
+        { id: "event-with-operation", value: correlated },
+        { id: "command-steer", value: steer },
+        { id: "event-operation-step", value: operationStep },
+        { id: "compatibility-accepted", value: compatibilityAccepted },
+        { id: "compatibility-contract-unsupported", value: compatibilityContractUnsupported },
+        {
+            id: "compatibility-capability-version-unsupported",
+            value: compatibilityCapabilityVersionUnsupported,
+        },
+        { id: "compatibility-feature-subset", value: compatibilityFeatureSubset },
+    ]);
+}
+export function validateEventEnvelopeV1(value) {
+    assertPlainRecord(value, "Event envelope");
+    assertExactKeys(value, ["version", "id", "deliveryId", "type", "source", "category", "deliveryGuarantee", "timestamp", "data"], ["operationId", "correlationId", "causationId"], "Event envelope");
+    if (value.version !== 1)
+        throw new Error("Event envelope.version must be 1");
+    assertNonEmptyString(value.id, "Event envelope.id");
+    assertNonEmptyString(value.deliveryId, "Event envelope.deliveryId");
+    assertNonEmptyString(value.type, "Event envelope.type");
+    assertNonEmptyString(value.source, "Event envelope.source");
+    if (value.category !== "authoritative" && value.category !== "progress" && value.category !== "observation") {
+        throw new Error("Event envelope.category is invalid");
+    }
+    if (value.deliveryGuarantee !== "best-effort" && value.deliveryGuarantee !== "at-least-once") {
+        throw new Error("Event envelope.deliveryGuarantee is invalid");
+    }
+    assertNonNegativeSafeInteger(value.timestamp, "Event envelope.timestamp");
+    assertJsonValue(value.data, "Event envelope.data");
+    if (value.operationId !== undefined)
+        assertNonEmptyString(value.operationId, "Event envelope.operationId");
+    if (value.correlationId !== undefined)
+        assertNonEmptyString(value.correlationId, "Event envelope.correlationId");
+    if (value.causationId !== undefined)
+        assertNonEmptyString(value.causationId, "Event envelope.causationId");
+    if (value.operationId === undefined && value.correlationId !== undefined) {
+        throw new Error("Event envelope.correlationId requires a real operationId");
+    }
+    if (value.operationId !== undefined && value.correlationId === undefined) {
+        throw new Error("Event envelope.operationId requires correlationId");
+    }
+    return detachedFreeze({
+        version: 1,
+        id: value.id,
+        deliveryId: value.deliveryId,
+        type: value.type,
+        source: value.source,
+        category: value.category,
+        deliveryGuarantee: value.deliveryGuarantee,
+        timestamp: value.timestamp,
+        data: value.data,
+        ...(value.operationId === undefined ? {} : { operationId: value.operationId }),
+        ...(value.correlationId === undefined ? {} : { correlationId: value.correlationId }),
+        ...(value.causationId === undefined ? {} : { causationId: value.causationId }),
+    });
+}
+export function buildEventEnvelopeV1(input) {
+    return validateEventEnvelopeV1({
+        ...input,
+        version: input.version ?? 1,
+        category: input.category ?? "observation",
+        deliveryGuarantee: input.deliveryGuarantee ?? "best-effort",
+    });
+}
+export function buildUnsupportedCapabilityV1(capability) {
+    const reference = validateCapabilityRefV1(capability);
+    const error = buildErrorEnvelopeV1({
+        version: 1,
+        code: "unsupported_capability",
+        message: `Capability is unsupported: ${reference.id}@${reference.version}`,
+        retryable: false,
+    });
+    return detachedFreeze({ status: "unsupported", capability: reference, error });
+}
+export function resolveCapabilityV1(requested, supported) {
+    const reference = validateCapabilityRefV1(requested);
+    const available = validateCapabilityRefs(supported, "Supported capabilities");
+    const found = available.some((candidate) => candidate.id === reference.id && candidate.version === reference.version);
+    return found
+        ? detachedFreeze({ status: "supported", capability: reference })
+        : buildUnsupportedCapabilityV1(reference);
+}
+export function assertCapabilitySupportedV1(requested, supported) {
+    const resolution = resolveCapabilityV1(requested, supported);
+    if (resolution.status === "unsupported")
+        throw new Error(resolution.error.message);
+    return resolution.capability;
+}
+// Short aliases keep consumers from having to repeat the schema suffix when
+// they only support the currently frozen version.
+export const validateAgentCapabilityContract = validateAgentCapabilityContractV1;
+export const buildAgentCapabilityContract = buildAgentCapabilityContractV1;
+export const validateEventEnvelope = validateEventEnvelopeV1;
+export const buildEventEnvelope = buildEventEnvelopeV1;
+export const validateCommandRequest = validateCommandRequestV1;
+export const buildCommandRequest = buildCommandRequestV1;
+//# sourceMappingURL=agent-capability-contract.js.map