@ai-agent-forge/agent-forge 0.86.7 → 0.87.0

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

@@ -5,6 +5,7 @@
  * facts shared by an embedded SDK binding and a service binding; it does not
  * import either binding or a runtime Agent object.
  */
+import { t } from "./i18n/index.js";
 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. */
@@ -82,7 +83,7 @@ function isPlainRecord(value) {
 }
 function assertPlainRecord(value, label) {
     if (!isPlainRecord(value))
-        throw new Error(`${label} must be a plain object`);
+        throw new Error(t("{label} must be a plain object", { label }));
 }
 function assertExactKeys(value, required, optional, label) {
     const allowed = new Set([...required, ...optional]);
@@ -90,24 +91,24 @@ function assertExactKeys(value, required, optional, label) {
         .filter((key) => !allowed.has(key))
         .sort();
     if (unsupported.length > 0)
-        throw new Error(`${label} has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("{label} has unsupported fields: {fields}", { label, fields: unsupported.join(", ") }));
     for (const key of required) {
         if (!(key in value))
-            throw new Error(`${label} is missing required field: ${key}`);
+            throw new Error(t("{label} is missing required field: {key}", { label, key }));
     }
 }
 function assertNonEmptyString(value, label) {
     if (typeof value !== "string" || value.trim().length === 0)
-        throw new Error(`${label} must be a non-empty string`);
+        throw new Error(t("{label} must be a non-empty string", { label }));
 }
 function assertPositiveSafeInteger(value, label) {
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
-        throw new Error(`${label} must be a positive safe integer`);
+        throw new Error(t("{label} must be a positive safe integer", { label }));
     }
 }
 function assertNonNegativeSafeInteger(value, label) {
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-        throw new Error(`${label} must be a non-negative safe integer`);
+        throw new Error(t("{label} must be a non-negative safe integer", { label }));
     }
 }
 function assertJsonValue(value, label, seen = new WeakSet()) {
@@ -116,12 +117,12 @@ function assertJsonValue(value, label, seen = new WeakSet()) {
     if (typeof value === "number") {
         if (Number.isFinite(value))
             return;
-        throw new Error(`${label} must contain finite JSON numbers`);
+        throw new Error(t("{label} must contain finite JSON numbers", { label }));
     }
     if (typeof value !== "object")
-        throw new Error(`${label} must be JSON-compatible`);
+        throw new Error(t("{label} must be JSON-compatible", { label }));
     if (seen.has(value))
-        throw new Error(`${label} must not contain cycles`);
+        throw new Error(t("{label} must not contain cycles", { label }));
     seen.add(value);
     if (Array.isArray(value)) {
         for (const [index, child] of value.entries())
@@ -129,7 +130,7 @@ function assertJsonValue(value, label, seen = new WeakSet()) {
     }
     else {
         if (!isPlainRecord(value))
-            throw new Error(`${label} must contain only plain JSON objects`);
+            throw new Error(t("{label} must contain only plain JSON objects", { label }));
         for (const [key, child] of Object.entries(value))
             assertJsonValue(child, `${label}.${key}`, seen);
     }
@@ -159,13 +160,16 @@ function capabilitySort(left, right) {
 }
 function validateCapabilityRefs(value, label) {
     if (!Array.isArray(value))
-        throw new Error(`${label} must be an array`);
+        throw new Error(t("{label} must be an array", { label }));
     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}`);
+            throw new Error(t("{label} contains duplicate capability: {capability}", {
+                label,
+                capability: `${ref.id}@${ref.version}`,
+            }));
         seen.add(key);
     }
     return Object.freeze(refs.sort(capabilitySort));
@@ -177,7 +181,7 @@ function validateHostTransport(value, label) {
         value !== "rpc" &&
         value !== "unix" &&
         value !== "websocket") {
-        throw new Error(`${label} is invalid`);
+        throw new Error(t("{label} is invalid", { label }));
     }
 }
 export function validateCapabilityRefV1(value, label = "Capability reference") {
@@ -194,23 +198,23 @@ 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");
+        throw new Error(t("Host context.mode is invalid"));
     if (!Array.isArray(value.features))
-        throw new Error("Host context.features must be an array");
+        throw new Error(t("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");
+        throw new Error(t("Host context.features must not contain duplicates"));
     if (!Array.isArray(value.transports))
-        throw new Error("Host context.transports must be an array");
+        throw new Error(t("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");
+        throw new Error(t("Host context.transports must not contain duplicates"));
     return detachedFreeze({
         mode: value.mode,
         features: [...features].sort(),
@@ -255,34 +259,34 @@ 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");
+        throw new Error(t("Contract compatibility result.version must be 1"));
     if (typeof value.compatible !== "boolean")
-        throw new Error("Contract compatibility result.compatible must be boolean");
+        throw new Error(t("Contract compatibility result.compatible must be boolean"));
     if (!Array.isArray(value.issues))
-        throw new Error("Contract compatibility result.issues must be an array");
+        throw new Error(t("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");
+        throw new Error(t("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");
+        throw new Error(t("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`);
+            throw new Error(t("Contract compatibility result.issues[{index}].code is invalid", { index }));
         }
         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`);
+                throw new Error(t("Contract compatibility result.issues[{index}].missingFeatures must be strings", { index }));
             }
         }
         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`);
+                throw new Error(t("Contract compatibility result.issues[{index}].missingTransports must be strings", { index }));
             }
         }
         const missingCapabilities = entry.missingCapabilities;
@@ -314,10 +318,10 @@ 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}`);
+        throw new Error(t("Agent capability contract.contractId must be {contractId}", { contractId: AGENT_CAPABILITY_CONTRACT_ID }));
     }
     if (value.version !== 1)
-        throw new Error("Agent capability contract.version must be 1");
+        throw new Error(t("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 });
@@ -333,13 +337,13 @@ export function validateAgentProfileV1(value) {
     assertNonEmptyString(value.rootAgent, "Agent profile.rootAgent");
     const validatePluginIds = (candidate, label) => {
         if (!Array.isArray(candidate))
-            throw new Error(`${label} must be an array`);
+            throw new Error(t("{label} must be an array", { label }));
         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`);
+            throw new Error(t("{label} must not contain duplicates", { label }));
         return Object.freeze([...ids].sort());
     };
     const requiredPlugins = validatePluginIds(value.requiredPlugins, "Agent profile.requiredPlugins");
@@ -347,7 +351,7 @@ export function validateAgentProfileV1(value) {
         ? undefined
         : validatePluginIds(value.optionalPlugins, "Agent profile.optionalPlugins");
     if (optionalPlugins?.some((id) => requiredPlugins.includes(id))) {
-        throw new Error("Agent profile.optionalPlugins must not overlap requiredPlugins");
+        throw new Error(t("Agent profile.optionalPlugins must not overlap requiredPlugins"));
     }
     if (value.defaults !== undefined)
         assertJsonValue(value.defaults, "Agent profile.defaults");
@@ -374,7 +378,7 @@ export function validateArtifactRefV1(value) {
     if (value.sizeBytes !== undefined)
         assertNonNegativeSafeInteger(value.sizeBytes, "Artifact reference.sizeBytes");
     if (typeof value.truncated !== "boolean")
-        throw new Error("Artifact reference.truncated must be boolean");
+        throw new Error(t("Artifact reference.truncated must be boolean"));
     assertNonNegativeSafeInteger(value.createdAt, "Artifact reference.createdAt");
     return detachedFreeze({
         sessionId: value.sessionId,
@@ -438,13 +442,13 @@ export function checkContractCompatibilityV1(candidateInput, requirementsInput)
 }
 function validateAgentRole(value, label) {
     if (value !== "root-agent-controller" && value !== "child-agent-controller")
-        throw new Error(`${label} is invalid`);
+        throw new Error(t("{label} is invalid", { label }));
 }
 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");
+        throw new Error(t("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");
@@ -467,7 +471,7 @@ 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");
+        throw new Error(t("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");
@@ -478,7 +482,7 @@ export function validateAgentInstanceSnapshotV1(value) {
         value.status !== "failed" &&
         value.status !== "cancelled" &&
         value.status !== "disposed") {
-        throw new Error("Agent instance snapshot.status is invalid");
+        throw new Error(t("Agent instance snapshot.status is invalid"));
     }
     assertNonNegativeSafeInteger(value.revision, "Agent instance snapshot.revision");
     if (value.parentInstanceId !== undefined)
@@ -504,13 +508,13 @@ 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");
+        throw new Error(t("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");
+        throw new Error(t("Session revision.leafId is required"));
     return detachedFreeze({
         version: 1,
         sessionId: value.sessionId,
@@ -525,11 +529,11 @@ 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");
+        throw new Error(t("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");
+        throw new Error(t("Session snapshot.revision.sessionId must match sessionId"));
     return detachedFreeze({ version: 1, sessionId: value.sessionId, revision });
 }
 export function buildSessionSnapshotV1(input) {
@@ -539,12 +543,12 @@ 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");
+        throw new Error(t("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");
+        throw new Error(t("Error envelope.message must be a string"));
     if (typeof value.retryable !== "boolean")
-        throw new Error("Error envelope.retryable must be a boolean");
+        throw new Error(t("Error envelope.retryable must be a boolean"));
     if (value.name !== undefined)
         assertNonEmptyString(value.name, "Error envelope.name");
     if (value.details !== undefined)
@@ -563,16 +567,16 @@ export function buildErrorEnvelopeV1(input) {
 }
 function validateOperationTerminalStatus(value, label) {
     if (value !== "succeeded" && value !== "failed" && value !== "cancelled" && value !== "timed_out") {
-        throw new Error(`${label} is invalid`);
+        throw new Error(t("{label} is invalid", { label }));
     }
 }
 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");
+        throw new Error(t("Operation terminal is missing required field: version or status"));
     }
     if (value.version !== 1)
-        throw new Error("Operation terminal.version must be 1");
+        throw new Error(t("Operation terminal.version must be 1"));
     validateOperationTerminalStatus(value.status, "Operation terminal.status");
     if (value.status === "succeeded") {
         assertExactKeys(value, ["version", "status"], ["result"], "Operation terminal");
@@ -595,7 +599,7 @@ 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");
+        throw new Error(t("Operation snapshot.version must be 1"));
     assertNonEmptyString(value.operationId, "Operation snapshot.operationId");
     assertNonEmptyString(value.kind, "Operation snapshot.kind");
     if (value.status !== "queued" &&
@@ -604,24 +608,24 @@ export function validateOperationSnapshotV1(value) {
         value.status !== "failed" &&
         value.status !== "cancelled" &&
         value.status !== "timed_out") {
-        throw new Error("Operation snapshot.status is invalid");
+        throw new Error(t("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");
+        throw new Error(t("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");
+        throw new Error(t("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");
+        throw new Error(t("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");
+        throw new Error(t("Operation snapshot.inputRevision.sessionId must match sessionId"));
     }
     return detachedFreeze({
         version: 1,
@@ -641,7 +645,7 @@ 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");
+        throw new Error(t("Command request.version must be 1"));
     assertNonEmptyString(value.operationId, "Command request.operationId");
     assertNonEmptyString(value.idempotencyKey, "Command request.idempotencyKey");
     assertNonEmptyString(value.command, "Command request.command");
@@ -649,7 +653,7 @@ export function validateCommandRequestV1(value) {
     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");
+        throw new Error(t("Command request.expectedRevision.sessionId does not match target"));
     }
     const hostContext = validateHostContextV1(value.hostContext);
     return detachedFreeze({
@@ -670,17 +674,17 @@ 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");
+        throw new Error(t("Command admission.version must be 1"));
     if (value.status !== "accepted" && value.status !== "existing" && value.status !== "rejected") {
-        throw new Error("Command admission.status is invalid");
+        throw new Error(t("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");
+        throw new Error(t("Command admission accepted status requires an operation"));
     }
     if (value.status === "rejected" && value.error === undefined) {
-        throw new Error("Command admission rejected status requires an error");
+        throw new Error(t("Command admission rejected status requires an error"));
     }
     const error = value.error === undefined ? undefined : validateErrorEnvelopeV1(value.error);
     return detachedFreeze({
@@ -724,7 +728,7 @@ export function createCommandOperationRegistryV1() {
         assertNonEmptyString(operationId, "operationId");
         const entry = entries.get(operationId);
         if (!entry)
-            throw new Error(`Operation is not retained: ${operationId}`);
+            throw new Error(t("Operation is not retained: {operationId}", { operationId }));
         return entry;
     };
     const write = (entry, operation) => {
@@ -784,7 +788,7 @@ export function createCommandOperationRegistryV1() {
             if (terminal(entry)) {
                 if (canonicalJson(entry.operation.terminal) !==
                     canonicalJson(nextTerminal)) {
-                    throw new Error(`Operation already has a different terminal result: ${operationId}`);
+                    throw new Error(t("Operation already has a different terminal result: {operationId}", { operationId }));
                 }
                 return entry.operation;
             }
@@ -881,7 +885,7 @@ export function buildCanonicalContractVectorsV1() {
     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");
+        throw new Error(t("Canonical contract vector admission failed"));
     }
     const running = registry.start(command.operationId);
     const terminal = registry.complete(command.operationId, {
@@ -946,7 +950,7 @@ export function buildCanonicalContractFixtureVectorsV1() {
         idempotencyKey: "fixture-request-failed",
     }), request.expectedRevision);
     if (failed.status !== "accepted")
-        throw new Error("Canonical contract failed vector admission failed");
+        throw new Error(t("Canonical contract failed vector admission failed"));
     const failedTerminal = registry.complete("fixture-operation-failed", {
         version: 1,
         status: "failed",
@@ -963,7 +967,7 @@ export function buildCanonicalContractFixtureVectorsV1() {
         idempotencyKey: "fixture-request-timeout",
     }), request.expectedRevision);
     if (timedOut.status !== "accepted")
-        throw new Error("Canonical contract timeout vector admission failed");
+        throw new Error(t("Canonical contract timeout vector admission failed"));
     const timedOutTerminal = registry.complete("fixture-operation-timeout", {
         version: 1,
         status: "timed_out",
@@ -1071,16 +1075,16 @@ 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");
+        throw new Error(t("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");
+        throw new Error(t("Event envelope.category is invalid"));
     }
     if (value.deliveryGuarantee !== "best-effort" && value.deliveryGuarantee !== "at-least-once") {
-        throw new Error("Event envelope.deliveryGuarantee is invalid");
+        throw new Error(t("Event envelope.deliveryGuarantee is invalid"));
     }
     assertNonNegativeSafeInteger(value.timestamp, "Event envelope.timestamp");
     assertJsonValue(value.data, "Event envelope.data");
@@ -1091,10 +1095,10 @@ export function validateEventEnvelopeV1(value) {
     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");
+        throw new Error(t("Event envelope.correlationId requires a real operationId"));
     }
     if (value.operationId !== undefined && value.correlationId === undefined) {
-        throw new Error("Event envelope.operationId requires correlationId");
+        throw new Error(t("Event envelope.operationId requires correlationId"));
     }
     return detachedFreeze({
         version: 1,