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

package/dist/core/extensions/lifecycle-catalog.js

@@ -1,3 +1,4 @@
+import { t } from "../i18n/index.js";
 export const PLUGIN_DISPOSE_EVENT_ID = "plugin.dispose";
 export const PLUGIN_DISPOSE_EVENT_VERSION = 1;
 export const PLUGIN_READY_EVENT_ID = "plugin.ready";
@@ -70,7 +71,7 @@ export const OPERATION_END_EVENT_ID = "operation.end";
 export const OPERATION_END_EVENT_VERSION = 1;
 function assertString(value, label) {
     if (typeof value !== "string" || value.trim() === "")
-        throw new Error(`${label} must be a non-empty string`);
+        throw new Error(t("{label} must be a non-empty string", { label }));
 }
 function assertJsonSafe(value, label, seen = new Set()) {
     if (value === null || typeof value === "string" || typeof value === "boolean")
@@ -78,12 +79,12 @@ function assertJsonSafe(value, label, seen = new Set()) {
     if (typeof value === "number") {
         if (Number.isFinite(value))
             return;
-        throw new Error(`${label} must contain only finite JSON numbers`);
+        throw new Error(t("{label} must contain only finite JSON numbers", { label }));
     }
     if (typeof value !== "object")
-        throw new Error(`${label} must be JSON-safe`);
+        throw new Error(t("{label} must be JSON-safe", { 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, entry] of value.entries())
@@ -94,7 +95,7 @@ function assertJsonSafe(value, label, seen = new Set()) {
             assertJsonSafe(entry, `${label}.${key}`, seen);
     }
     else {
-        throw new Error(`${label} must contain only JSON arrays and plain objects`);
+        throw new Error(t("{label} must contain only JSON arrays and plain objects", { label }));
     }
     seen.delete(value);
 }
@@ -103,19 +104,19 @@ export function validatePluginDisposeEventDataV1(value) {
         typeof value !== "object" ||
         Array.isArray(value) ||
         Object.getPrototypeOf(value) !== Object.prototype) {
-        throw new Error("plugin.dispose data must be a plain object");
+        throw new Error(t("plugin.dispose data must be a plain object"));
     }
     const record = value;
     const keys = Object.keys(record).sort();
     if (keys.join(",") !== "pluginId,pluginVersion,status,version") {
-        throw new Error("plugin.dispose data has unsupported fields");
+        throw new Error(t("plugin.dispose data has unsupported fields"));
     }
     if (record.version !== 1)
-        throw new Error("plugin.dispose data.version must be 1");
+        throw new Error(t("plugin.dispose data.version must be 1"));
     assertString(record.pluginId, "plugin.dispose data.pluginId");
     assertString(record.pluginVersion, "plugin.dispose data.pluginVersion");
     if (record.status !== "disposed" && record.status !== "failed") {
-        throw new Error("plugin.dispose data.status is invalid");
+        throw new Error(t("plugin.dispose data.status is invalid"));
     }
     return value;
 }
@@ -135,15 +136,15 @@ export function validatePluginReadyEventDataV1(value) {
         typeof value !== "object" ||
         Array.isArray(value) ||
         Object.getPrototypeOf(value) !== Object.prototype) {
-        throw new Error("plugin.ready data must be a plain object");
+        throw new Error(t("plugin.ready data must be a plain object"));
     }
     const record = value;
     const keys = Object.keys(record).sort();
     if (keys.join(",") !== "pluginId,pluginVersion,version") {
-        throw new Error("plugin.ready data has unsupported fields");
+        throw new Error(t("plugin.ready data has unsupported fields"));
     }
     if (record.version !== 1)
-        throw new Error("plugin.ready data.version must be 1");
+        throw new Error(t("plugin.ready data.version must be 1"));
     assertString(record.pluginId, "plugin.ready data.pluginId");
     assertString(record.pluginVersion, "plugin.ready data.pluginVersion");
     return value;
@@ -166,19 +167,19 @@ export function validatePluginRejectedEventDataV1(value) {
         typeof value !== "object" ||
         Array.isArray(value) ||
         Object.getPrototypeOf(value) !== Object.prototype) {
-        throw new Error("plugin.rejected data must be a plain object");
+        throw new Error(t("plugin.rejected data must be a plain object"));
     }
     const record = value;
     const keys = Object.keys(record)
         .filter((key) => key !== "pluginId")
         .sort();
     if (keys.join(",") !== "code,manifestPath,message,version") {
-        throw new Error("plugin.rejected data has unsupported fields");
+        throw new Error(t("plugin.rejected data has unsupported fields"));
     }
     if (record.version !== 1)
-        throw new Error("plugin.rejected data.version must be 1");
+        throw new Error(t("plugin.rejected data.version must be 1"));
     if (record.pluginId !== undefined && typeof record.pluginId !== "string") {
-        throw new Error("plugin.rejected data.pluginId must be a string when present");
+        throw new Error(t("plugin.rejected data.pluginId must be a string when present"));
     }
     assertString(record.manifestPath, "plugin.rejected data.manifestPath");
     assertString(record.message, "plugin.rejected data.message");
@@ -186,7 +187,7 @@ export function validatePluginRejectedEventDataV1(value) {
         record.code !== "duplicate_plugin_id" &&
         record.code !== "missing_dependency" &&
         record.code !== "plugin_load_failed") {
-        throw new Error("plugin.rejected data.code is invalid");
+        throw new Error(t("plugin.rejected data.code is invalid"));
     }
     return value;
 }
@@ -215,29 +216,31 @@ export function validateSessionContextReplacedEventDataV1(value) {
         typeof value !== "object" ||
         Array.isArray(value) ||
         Object.getPrototypeOf(value) !== Object.prototype) {
-        throw new Error("session.context.replaced data must be a plain object");
+        throw new Error(t("session.context.replaced data must be a plain object"));
     }
     const record = value;
     const allowed = new Set(["version", "sessionId", "reason", "messageCount", "strategyName"]);
     const unsupported = Object.keys(record).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`session.context.replaced data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("session.context.replaced data has unsupported fields: {unsupported}", {
+            unsupported: unsupported.join(", "),
+        }));
     }
     for (const key of ["version", "sessionId", "reason", "messageCount"]) {
         if (!(key in record))
-            throw new Error(`session.context.replaced data is missing required field: ${key}`);
+            throw new Error(t("session.context.replaced data is missing required field: {key}", { key }));
     }
     if (record.version !== 1)
-        throw new Error("session.context.replaced data.version must be 1");
+        throw new Error(t("session.context.replaced data.version must be 1"));
     assertString(record.sessionId, "session.context.replaced data.sessionId");
     if (typeof record.reason !== "string" ||
         !contextReasons.has(record.reason)) {
-        throw new Error("session.context.replaced data.reason is invalid");
+        throw new Error(t("session.context.replaced data.reason is invalid"));
     }
     if (typeof record.messageCount !== "number" ||
         !Number.isSafeInteger(record.messageCount) ||
         record.messageCount < 0) {
-        throw new Error("session.context.replaced data.messageCount must be a non-negative safe integer");
+        throw new Error(t("session.context.replaced data.messageCount must be a non-negative safe integer"));
     }
     if (record.strategyName !== undefined) {
         assertString(record.strategyName, "session.context.replaced data.strategyName");
@@ -257,18 +260,18 @@ export function sessionContextReplacedEventDefinition() {
 }
 export function validateSessionReloadEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.reload data must be a plain object");
+        throw new Error(t("session.reload data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "generation,reason,sessionId,version") {
-        throw new Error("session.reload data has unsupported fields");
+        throw new Error(t("session.reload data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("session.reload data.version must be 1");
+        throw new Error(t("session.reload data.version must be 1"));
     assertString(value.sessionId, "session.reload data.sessionId");
     if (typeof value.generation !== "number" || !Number.isSafeInteger(value.generation) || value.generation < 1) {
-        throw new Error("session.reload data.generation must be a positive safe integer");
+        throw new Error(t("session.reload data.generation must be a positive safe integer"));
     }
     if (value.reason !== "reload")
-        throw new Error("session.reload data.reason is invalid");
+        throw new Error(t("session.reload data.reason is invalid"));
     return value;
 }
 export function sessionReloadEventDefinition() {
@@ -284,12 +287,12 @@ export function sessionReloadEventDefinition() {
 }
 export function validateAgentLifecycleEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("agent lifecycle data must be a plain object");
+        throw new Error(t("agent lifecycle data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "sessionId,version") {
-        throw new Error("agent lifecycle data has unsupported fields");
+        throw new Error(t("agent lifecycle data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("agent lifecycle data.version must be 1");
+        throw new Error(t("agent lifecycle data.version must be 1"));
     assertString(value.sessionId, "agent lifecycle data.sessionId");
     return value;
 }
@@ -317,48 +320,48 @@ export function agentSettledEventDefinition() {
 }
 export function validateTurnStartEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("turn.start data must be a plain object");
+        throw new Error(t("turn.start data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "sessionId,turnIndex,version") {
-        throw new Error("turn.start data has unsupported fields");
+        throw new Error(t("turn.start data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("turn.start data.version must be 1");
+        throw new Error(t("turn.start data.version must be 1"));
     assertString(value.sessionId, "turn.start data.sessionId");
     if (typeof value.turnIndex !== "number" || !Number.isSafeInteger(value.turnIndex) || value.turnIndex < 0) {
-        throw new Error("turn.start data.turnIndex must be a non-negative safe integer");
+        throw new Error(t("turn.start data.turnIndex must be a non-negative safe integer"));
     }
     return value;
 }
 export function validateTurnEndEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("turn.end data must be a plain object");
+        throw new Error(t("turn.end data must be a plain object"));
     const keys = Object.keys(value).sort().join(",");
     if (keys !== "messageCount,sessionId,turnIndex,version" &&
         keys !== "messageCount,outcome,sessionId,turnIndex,version") {
-        throw new Error("turn.end data has unsupported fields");
+        throw new Error(t("turn.end data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("turn.end data.version must be 1");
+        throw new Error(t("turn.end data.version must be 1"));
     assertString(value.sessionId, "turn.end data.sessionId");
     if (typeof value.turnIndex !== "number" || !Number.isSafeInteger(value.turnIndex) || value.turnIndex < 0) {
-        throw new Error("turn.end data.turnIndex must be a non-negative safe integer");
+        throw new Error(t("turn.end data.turnIndex must be a non-negative safe integer"));
     }
     if (typeof value.messageCount !== "number" || !Number.isSafeInteger(value.messageCount) || value.messageCount < 0) {
-        throw new Error("turn.end data.messageCount must be a non-negative safe integer");
+        throw new Error(t("turn.end data.messageCount must be a non-negative safe integer"));
     }
     if (value.outcome !== undefined && value.outcome !== "aborted" && value.outcome !== "error") {
-        throw new Error("turn.end data.outcome is invalid");
+        throw new Error(t("turn.end data.outcome is invalid"));
     }
     return value;
 }
 export function validateMessageBoundaryEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("message lifecycle data must be a plain object");
+        throw new Error(t("message lifecycle data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "role,sessionId,version") {
-        throw new Error("message lifecycle data has unsupported fields");
+        throw new Error(t("message lifecycle data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("message lifecycle data.version must be 1");
+        throw new Error(t("message lifecycle data.version must be 1"));
     assertString(value.sessionId, "message lifecycle data.sessionId");
     assertString(value.role, "message lifecycle data.role");
     return value;
@@ -409,12 +412,12 @@ export function messageEndEventDefinition() {
 }
 export function validateToolExecutionStartEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.execution.start data must be a plain object");
+        throw new Error(t("tool.execution.start data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "sessionId,toolCallId,toolName,version") {
-        throw new Error("tool.execution.start data has unsupported fields");
+        throw new Error(t("tool.execution.start data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("tool.execution.start data.version must be 1");
+        throw new Error(t("tool.execution.start data.version must be 1"));
     assertString(value.sessionId, "tool.execution.start data.sessionId");
     assertString(value.toolCallId, "tool.execution.start data.toolCallId");
     assertString(value.toolName, "tool.execution.start data.toolName");
@@ -433,28 +436,28 @@ export function toolExecutionStartEventDefinition() {
 }
 export function validateModelSelectEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("model.select data must be a plain object");
+        throw new Error(t("model.select data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "id,provider,sessionId,source,version") {
-        throw new Error("model.select data has unsupported fields");
+        throw new Error(t("model.select data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("model.select data.version must be 1");
+        throw new Error(t("model.select data.version must be 1"));
     assertString(value.sessionId, "model.select data.sessionId");
     assertString(value.provider, "model.select data.provider");
     assertString(value.id, "model.select data.id");
     if (value.source !== "set" && value.source !== "cycle" && value.source !== "restore") {
-        throw new Error("model.select data.source is invalid");
+        throw new Error(t("model.select data.source is invalid"));
     }
     return value;
 }
 export function validateThinkingLevelSelectEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("thinking_level.select data must be a plain object");
+        throw new Error(t("thinking_level.select data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "level,previousLevel,sessionId,version") {
-        throw new Error("thinking_level.select data has unsupported fields");
+        throw new Error(t("thinking_level.select data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("thinking_level.select data.version must be 1");
+        throw new Error(t("thinking_level.select data.version must be 1"));
     assertString(value.sessionId, "thinking_level.select data.sessionId");
     assertString(value.level, "thinking_level.select data.level");
     assertString(value.previousLevel, "thinking_level.select data.previousLevel");
@@ -484,13 +487,13 @@ export function thinkingLevelSelectEventDefinition() {
 }
 export function validateSessionInfoChangedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.info.changed data must be a plain object");
+        throw new Error(t("session.info.changed data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "sessionId,version" &&
         Object.keys(value).sort().join(",") !== "name,sessionId,version") {
-        throw new Error("session.info.changed data has unsupported fields");
+        throw new Error(t("session.info.changed data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("session.info.changed data.version must be 1");
+        throw new Error(t("session.info.changed data.version must be 1"));
     assertString(value.sessionId, "session.info.changed data.sessionId");
     if (value.name !== undefined)
         assertString(value.name, "session.info.changed data.name");
@@ -498,12 +501,12 @@ export function validateSessionInfoChangedEventDataV1(value) {
 }
 export function validateSessionEntryAppendedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.entry.appended data must be a plain object");
+        throw new Error(t("session.entry.appended data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "entryId,entryType,sessionId,version") {
-        throw new Error("session.entry.appended data has unsupported fields");
+        throw new Error(t("session.entry.appended data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("session.entry.appended data.version must be 1");
+        throw new Error(t("session.entry.appended data.version must be 1"));
     assertString(value.sessionId, "session.entry.appended data.sessionId");
     assertString(value.entryId, "session.entry.appended data.entryId");
     assertString(value.entryType, "session.entry.appended data.entryType");
@@ -533,29 +536,29 @@ export function sessionEntryAppendedEventDefinition() {
 }
 export function validateAgentEndEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("agent.end data must be a plain object");
+        throw new Error(t("agent.end data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "messageCount,sessionId,version") {
-        throw new Error("agent.end data has unsupported fields");
+        throw new Error(t("agent.end data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("agent.end data.version must be 1");
+        throw new Error(t("agent.end data.version must be 1"));
     assertString(value.sessionId, "agent.end data.sessionId");
     if (typeof value.messageCount !== "number" || !Number.isSafeInteger(value.messageCount) || value.messageCount < 0) {
-        throw new Error("agent.end data.messageCount must be a non-negative safe integer");
+        throw new Error(t("agent.end data.messageCount must be a non-negative safe integer"));
     }
     return value;
 }
 export function validateBeforeAgentStartEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("before.agent.start data must be a plain object");
+        throw new Error(t("before.agent.start data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "hasImages,sessionId,version") {
-        throw new Error("before.agent.start data has unsupported fields");
+        throw new Error(t("before.agent.start data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("before.agent.start data.version must be 1");
+        throw new Error(t("before.agent.start data.version must be 1"));
     assertString(value.sessionId, "before.agent.start data.sessionId");
     if (typeof value.hasImages !== "boolean")
-        throw new Error("before.agent.start data.hasImages must be a boolean");
+        throw new Error(t("before.agent.start data.hasImages must be a boolean"));
     return value;
 }
 export function agentEndEventDefinition() {
@@ -582,28 +585,28 @@ export function beforeAgentStartEventDefinition() {
 }
 export function validateBeforeAgentStartEventDataV2(value) {
     if (!isPlainRecord(value))
-        throw new Error("before.agent.start data must be a plain object");
+        throw new Error(t("before.agent.start data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "systemPrompt", "systemPromptOptions"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`before.agent.start data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("before.agent.start data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of ["version", "sessionId", "systemPrompt", "systemPromptOptions"]) {
         if (!(key in value))
-            throw new Error(`before.agent.start data is missing required field: ${key}`);
+            throw new Error(t("before.agent.start data is missing required field: {key}", { key }));
     }
     if (value.version !== 2)
-        throw new Error("before.agent.start data.version must be 2");
+        throw new Error(t("before.agent.start data.version must be 2"));
     assertString(value.sessionId, "before.agent.start data.sessionId");
     if (typeof value.systemPrompt !== "string") {
-        throw new Error("before.agent.start data.systemPrompt must be a string");
+        throw new Error(t("before.agent.start data.systemPrompt must be a string"));
     }
     // Only the shape is enforced here: JSON-safety (no functions, cycles, or
     // non-finite numbers) is already guaranteed because the dispatcher runs the
     // payload through a detached structured clone before validation, and the
     // build-options snapshot legitimately carries explicit `undefined` fields.
     if (!isPlainRecord(value.systemPromptOptions)) {
-        throw new Error("before.agent.start data.systemPromptOptions must be a plain object");
+        throw new Error(t("before.agent.start data.systemPromptOptions must be a plain object"));
     }
     return value;
 }
@@ -620,13 +623,13 @@ export function beforeAgentStartV2EventDefinition() {
 }
 export function validateUIPromptBoundaryEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("ui.prompt lifecycle data must be a plain object");
+        throw new Error(t("ui.prompt lifecycle data must be a plain object"));
     const keys = Object.keys(value).sort();
     if (keys.join(",") !== "kind,sessionId,version" && keys.join(",") !== "kind,sessionId,title,version") {
-        throw new Error("ui.prompt lifecycle data has unsupported fields");
+        throw new Error(t("ui.prompt lifecycle data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("ui.prompt lifecycle data.version must be 1");
+        throw new Error(t("ui.prompt lifecycle data.version must be 1"));
     assertString(value.sessionId, "ui.prompt lifecycle data.sessionId");
     assertString(value.kind, "ui.prompt lifecycle data.kind");
     if (value.title !== undefined)
@@ -635,16 +638,16 @@ export function validateUIPromptBoundaryEventDataV1(value) {
 }
 export function validateResourcesDiscoverEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("resources.discover data must be a plain object");
+        throw new Error(t("resources.discover data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "cwd,reason,sessionId,version") {
-        throw new Error("resources.discover data has unsupported fields");
+        throw new Error(t("resources.discover data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("resources.discover data.version must be 1");
+        throw new Error(t("resources.discover data.version must be 1"));
     assertString(value.sessionId, "resources.discover data.sessionId");
     assertString(value.cwd, "resources.discover data.cwd");
     if (value.reason !== "startup" && value.reason !== "reload") {
-        throw new Error("resources.discover data.reason is invalid");
+        throw new Error(t("resources.discover data.reason is invalid"));
     }
     return value;
 }
@@ -683,12 +686,12 @@ export function resourcesDiscoverEventDefinition() {
 }
 function validateResourcesDiscoverContributionV2(value, label) {
     if (!Array.isArray(value))
-        throw new Error(`${label} must be an array`);
+        throw new Error(t("{label} must be an array", { label }));
     for (const [index, entry] of value.entries()) {
         if (!isPlainRecord(entry))
-            throw new Error(`${label}[${index}] must be a plain object`);
+            throw new Error(t("{label}[{index}] must be a plain object", { label, index }));
         if (Object.keys(entry).sort().join(",") !== "extensionPath,path") {
-            throw new Error(`${label}[${index}] has unsupported fields`);
+            throw new Error(t("{label}[{index}] has unsupported fields", { label, index }));
         }
         assertString(entry.path, `${label}[${index}].path`);
         assertString(entry.extensionPath, `${label}[${index}].extensionPath`);
@@ -696,22 +699,22 @@ function validateResourcesDiscoverContributionV2(value, label) {
 }
 export function validateResourcesDiscoverEventDataV2(value) {
     if (!isPlainRecord(value))
-        throw new Error("resources.discover data must be a plain object");
+        throw new Error(t("resources.discover data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "cwd", "reason", "skillPaths", "promptPaths", "themePaths"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`resources.discover data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("resources.discover data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of ["version", "sessionId", "cwd", "reason"]) {
         if (!(key in value))
-            throw new Error(`resources.discover data is missing required field: ${key}`);
+            throw new Error(t("resources.discover data is missing required field: {key}", { key }));
     }
     if (value.version !== 2)
-        throw new Error("resources.discover data.version must be 2");
+        throw new Error(t("resources.discover data.version must be 2"));
     assertString(value.sessionId, "resources.discover data.sessionId");
     assertString(value.cwd, "resources.discover data.cwd");
     if (value.reason !== "startup" && value.reason !== "reload") {
-        throw new Error("resources.discover data.reason is invalid");
+        throw new Error(t("resources.discover data.reason is invalid"));
     }
     if (value.skillPaths !== undefined) {
         validateResourcesDiscoverContributionV2(value.skillPaths, "resources.discover data.skillPaths");
@@ -737,45 +740,45 @@ export function resourcesDiscoverV2EventDefinition() {
 }
 export function validateContextAssembledEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("context.assembled data must be a plain object");
+        throw new Error(t("context.assembled data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "messageCount,sessionId,version") {
-        throw new Error("context.assembled data has unsupported fields");
+        throw new Error(t("context.assembled data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("context.assembled data.version must be 1");
+        throw new Error(t("context.assembled data.version must be 1"));
     assertString(value.sessionId, "context.assembled data.sessionId");
     if (typeof value.messageCount !== "number" || !Number.isSafeInteger(value.messageCount) || value.messageCount < 0) {
-        throw new Error("context.assembled data.messageCount must be a non-negative safe integer");
+        throw new Error(t("context.assembled data.messageCount must be a non-negative safe integer"));
     }
     return value;
 }
 export function validateInputReceivedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("input.received data must be a plain object");
+        throw new Error(t("input.received data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "sessionId,textLength,version,source".split(",").sort().join(",")) {
-        throw new Error("input.received data has unsupported fields");
+        throw new Error(t("input.received data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("input.received data.version must be 1");
+        throw new Error(t("input.received data.version must be 1"));
     assertString(value.sessionId, "input.received data.sessionId");
     assertString(value.source, "input.received data.source");
     if (typeof value.textLength !== "number" || !Number.isSafeInteger(value.textLength) || value.textLength < 0) {
-        throw new Error("input.received data.textLength must be a non-negative safe integer");
+        throw new Error(t("input.received data.textLength must be a non-negative safe integer"));
     }
     return value;
 }
 export function validateUserBashEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("user.bash data must be a plain object");
+        throw new Error(t("user.bash data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "cwd,excludeFromContext,sessionId,version") {
-        throw new Error("user.bash data has unsupported fields");
+        throw new Error(t("user.bash data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("user.bash data.version must be 1");
+        throw new Error(t("user.bash data.version must be 1"));
     assertString(value.sessionId, "user.bash data.sessionId");
     assertString(value.cwd, "user.bash data.cwd");
     if (typeof value.excludeFromContext !== "boolean") {
-        throw new Error("user.bash data.excludeFromContext must be a boolean");
+        throw new Error(t("user.bash data.excludeFromContext must be a boolean"));
     }
     return value;
 }
@@ -814,21 +817,21 @@ export function userBashEventDefinition() {
 }
 export function validateSessionStartEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.start data must be a plain object");
+        throw new Error(t("session.start data must be a plain object"));
     const keys = Object.keys(value).sort();
     if (keys.join(",") !== "reason,sessionId,version" &&
         keys.join(",") !== "previousSessionFile,reason,sessionId,version") {
-        throw new Error("session.start data has unsupported fields");
+        throw new Error(t("session.start data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("session.start data.version must be 1");
+        throw new Error(t("session.start data.version must be 1"));
     assertString(value.sessionId, "session.start data.sessionId");
     if (value.reason !== "startup" &&
         value.reason !== "reload" &&
         value.reason !== "new" &&
         value.reason !== "resume" &&
         value.reason !== "fork") {
-        throw new Error("session.start data.reason is invalid");
+        throw new Error(t("session.start data.reason is invalid"));
     }
     if (value.previousSessionFile !== undefined)
         assertString(value.previousSessionFile, "session.start data.previousSessionFile");
@@ -850,7 +853,7 @@ export function validateModelResponseEventDataV1(value) {
         typeof value !== "object" ||
         Array.isArray(value) ||
         Object.getPrototypeOf(value) !== Object.prototype) {
-        throw new Error("model.response data must be a plain object");
+        throw new Error(t("model.response data must be a plain object"));
     }
     const record = value;
     const allowed = new Set([
@@ -866,13 +869,13 @@ export function validateModelResponseEventDataV1(value) {
     ]);
     const unsupported = Object.keys(record).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`model.response data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("model.response data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "entryId", "revision", "provider", "model", "stopReason", "message"]) {
         if (!(key in record))
-            throw new Error(`model.response data is missing required field: ${key}`);
+            throw new Error(t("model.response data is missing required field: {key}", { key }));
     }
     if (record.version !== 1)
-        throw new Error("model.response data.version must be 1");
+        throw new Error(t("model.response data.version must be 1"));
     assertString(record.sessionId, "model.response data.sessionId");
     assertString(record.entryId, "model.response data.entryId");
     assertString(record.provider, "model.response data.provider");
@@ -884,30 +887,30 @@ export function validateModelResponseEventDataV1(value) {
         record.stopReason !== "error" &&
         record.stopReason !== "aborted" &&
         record.stopReason !== "deferred") {
-        throw new Error("model.response data.stopReason is invalid");
+        throw new Error(t("model.response data.stopReason is invalid"));
     }
     if (!record.message || typeof record.message !== "object" || Array.isArray(record.message)) {
-        throw new Error("model.response data.message must be an assistant message object");
+        throw new Error(t("model.response data.message must be an assistant message object"));
     }
     const message = record.message;
     if (message.role !== "assistant")
-        throw new Error("model.response data.message.role must be assistant");
+        throw new Error(t("model.response data.message.role must be assistant"));
     if (!isPlainRecord(record.revision))
-        throw new Error("model.response data.revision must be a plain object");
+        throw new Error(t("model.response data.revision must be a plain object"));
     const revision = record.revision;
     if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
-        throw new Error("model.response data.revision has unsupported fields");
+        throw new Error(t("model.response data.revision has unsupported fields"));
     }
     if (revision.version !== 1)
-        throw new Error("model.response data.revision.version must be 1");
+        throw new Error(t("model.response data.revision.version must be 1"));
     assertString(revision.sessionId, "model.response data.revision.sessionId");
     if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
-        throw new Error("model.response data.revision.sequence must be a non-negative safe integer");
+        throw new Error(t("model.response data.revision.sequence must be a non-negative safe integer"));
     }
     if (revision.leafId !== null)
         assertString(revision.leafId, "model.response data.revision.leafId");
     if (revision.sessionId !== record.sessionId) {
-        throw new Error("model.response data.revision.sessionId must match sessionId");
+        throw new Error(t("model.response data.revision.sessionId must match sessionId"));
     }
     if (record.errorMessage !== undefined)
         assertString(record.errorMessage, "model.response data.errorMessage");
@@ -946,7 +949,7 @@ const modelStreamEvents = new Set([
 ]);
 export function validateModelStreamEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("model.stream data must be a plain object");
+        throw new Error(t("model.stream data must be a plain object"));
     const allowed = new Set([
         "version",
         "sessionId",
@@ -960,7 +963,7 @@ export function validateModelStreamEventDataV1(value) {
     ]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`model.stream data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("model.stream data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of [
         "version",
         "sessionId",
@@ -973,38 +976,38 @@ export function validateModelStreamEventDataV1(value) {
         "error",
     ]) {
         if (!(key in value))
-            throw new Error(`model.stream data is missing required field: ${key}`);
+            throw new Error(t("model.stream data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("model.stream data.version must be 1");
+        throw new Error(t("model.stream data.version must be 1"));
     assertString(value.sessionId, "model.stream data.sessionId");
     assertString(value.streamId, "model.stream data.streamId");
     if (typeof value.sequence !== "number" || !Number.isSafeInteger(value.sequence) || value.sequence < 1) {
-        throw new Error("model.stream data.sequence must be a positive safe integer");
+        throw new Error(t("model.stream data.sequence must be a positive safe integer"));
     }
     if (value.phase !== "raw" && value.phase !== "candidate" && value.phase !== "committed") {
-        throw new Error("model.stream data.phase is invalid");
+        throw new Error(t("model.stream data.phase is invalid"));
     }
     if (typeof value.event !== "string" || !modelStreamEvents.has(value.event)) {
-        throw new Error("model.stream data.event is invalid");
+        throw new Error(t("model.stream data.event is invalid"));
     }
     if (value.phase === "committed" && value.event !== "done" && value.event !== "error") {
-        throw new Error("model.stream committed phase only permits terminal events");
+        throw new Error(t("model.stream committed phase only permits terminal events"));
     }
     const terminal = value.event === "done" || value.event === "error";
     if (value.terminal !== terminal)
-        throw new Error("model.stream data.terminal does not match event");
+        throw new Error(t("model.stream data.terminal does not match event"));
     if (value.partial !== null)
         assertJsonSafe(value.partial, "model.stream data.partial");
     if (terminal && value.event === "done" && value.error !== null) {
-        throw new Error("model.stream done event cannot contain error");
+        throw new Error(t("model.stream done event cannot contain error"));
     }
     if (terminal && value.event === "error") {
         if (!isPlainRecord(value.error))
-            throw new Error("model.stream error event requires error object");
+            throw new Error(t("model.stream error event requires error object"));
         const errorKeys = Object.keys(value.error);
         if (errorKeys.some((key) => key !== "code" && key !== "message" && key !== "name")) {
-            throw new Error("model.stream error has unsupported fields");
+            throw new Error(t("model.stream error has unsupported fields"));
         }
         assertString(value.error.code, "model.stream data.error.code");
         assertString(value.error.message, "model.stream data.error.message");
@@ -1012,7 +1015,7 @@ export function validateModelStreamEventDataV1(value) {
             assertString(value.error.name, "model.stream data.error.name");
     }
     else if (value.error !== null) {
-        throw new Error("model.stream non-terminal event cannot contain error");
+        throw new Error(t("model.stream non-terminal event cannot contain error"));
     }
     return value;
 }
@@ -1029,7 +1032,7 @@ export function modelStreamEventDefinition() {
 }
 export function validateToolResultEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.result data must be a plain object");
+        throw new Error(t("tool.result data must be a plain object"));
     const allowed = new Set([
         "version",
         "sessionId",
@@ -1042,54 +1045,54 @@ export function validateToolResultEventDataV1(value) {
     ]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`tool.result data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.result data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "entryId", "revision", "toolCallId", "toolName", "isError", "message"]) {
         if (!(key in value))
-            throw new Error(`tool.result data is missing required field: ${key}`);
+            throw new Error(t("tool.result data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.result data.version must be 1");
+        throw new Error(t("tool.result data.version must be 1"));
     assertString(value.sessionId, "tool.result data.sessionId");
     assertString(value.entryId, "tool.result data.entryId");
     assertString(value.toolCallId, "tool.result data.toolCallId");
     assertString(value.toolName, "tool.result data.toolName");
     if (typeof value.isError !== "boolean")
-        throw new Error("tool.result data.isError must be boolean");
+        throw new Error(t("tool.result data.isError must be boolean"));
     if (!isPlainRecord(value.message))
-        throw new Error("tool.result data.message must be a tool result message object");
+        throw new Error(t("tool.result data.message must be a tool result message object"));
     if (value.message.role !== "toolResult")
-        throw new Error("tool.result data.message.role must be toolResult");
+        throw new Error(t("tool.result data.message.role must be toolResult"));
     assertString(value.message.toolCallId, "tool.result data.message.toolCallId");
     assertString(value.message.toolName, "tool.result data.message.toolName");
     if (!Array.isArray(value.message.content))
-        throw new Error("tool.result data.message.content must be an array");
+        throw new Error(t("tool.result data.message.content must be an array"));
     if (typeof value.message.isError !== "boolean")
-        throw new Error("tool.result data.message.isError must be boolean");
+        throw new Error(t("tool.result data.message.isError must be boolean"));
     if (value.message.toolCallId !== value.toolCallId) {
-        throw new Error("tool.result data.message.toolCallId must match toolCallId");
+        throw new Error(t("tool.result data.message.toolCallId must match toolCallId"));
     }
     if (value.message.toolName !== value.toolName) {
-        throw new Error("tool.result data.message.toolName must match toolName");
+        throw new Error(t("tool.result data.message.toolName must match toolName"));
     }
     if (value.message.isError !== value.isError) {
-        throw new Error("tool.result data.message.isError must match isError");
+        throw new Error(t("tool.result data.message.isError must match isError"));
     }
     if (!isPlainRecord(value.revision))
-        throw new Error("tool.result data.revision must be a plain object");
+        throw new Error(t("tool.result data.revision must be a plain object"));
     const revision = value.revision;
     if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
-        throw new Error("tool.result data.revision has unsupported fields");
+        throw new Error(t("tool.result data.revision has unsupported fields"));
     }
     if (revision.version !== 1)
-        throw new Error("tool.result data.revision.version must be 1");
+        throw new Error(t("tool.result data.revision.version must be 1"));
     assertString(revision.sessionId, "tool.result data.revision.sessionId");
     if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
-        throw new Error("tool.result data.revision.sequence must be a non-negative safe integer");
+        throw new Error(t("tool.result data.revision.sequence must be a non-negative safe integer"));
     }
     if (revision.leafId !== null)
         assertString(revision.leafId, "tool.result data.revision.leafId");
     if (revision.sessionId !== value.sessionId) {
-        throw new Error("tool.result data.revision.sessionId must match sessionId");
+        throw new Error(t("tool.result data.revision.sessionId must match sessionId"));
     }
     return value;
 }
@@ -1106,36 +1109,36 @@ export function toolResultEventDefinition() {
 }
 export function validateToolCallEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.call data must be a plain object");
+        throw new Error(t("tool.call data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "revision", "toolCallId", "toolName", "input"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`tool.call data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.call data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "input"]) {
         if (!(key in value))
-            throw new Error(`tool.call data is missing required field: ${key}`);
+            throw new Error(t("tool.call data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.call data.version must be 1");
+        throw new Error(t("tool.call data.version must be 1"));
     assertString(value.sessionId, "tool.call data.sessionId");
     assertString(value.toolCallId, "tool.call data.toolCallId");
     assertString(value.toolName, "tool.call data.toolName");
     if (!isPlainRecord(value.revision))
-        throw new Error("tool.call data.revision must be a plain object");
+        throw new Error(t("tool.call data.revision must be a plain object"));
     const revision = value.revision;
     if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
-        throw new Error("tool.call data.revision has unsupported fields");
+        throw new Error(t("tool.call data.revision has unsupported fields"));
     }
     if (revision.version !== 1)
-        throw new Error("tool.call data.revision.version must be 1");
+        throw new Error(t("tool.call data.revision.version must be 1"));
     assertString(revision.sessionId, "tool.call data.revision.sessionId");
     if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
-        throw new Error("tool.call data.revision.sequence must be a non-negative safe integer");
+        throw new Error(t("tool.call data.revision.sequence must be a non-negative safe integer"));
     }
     if (revision.leafId !== null)
         assertString(revision.leafId, "tool.call data.revision.leafId");
     if (revision.sessionId !== value.sessionId)
-        throw new Error("tool.call data.revision.sessionId must match sessionId");
+        throw new Error(t("tool.call data.revision.sessionId must match sessionId"));
     assertJsonSafe(value.input, "tool.call data.input");
     return value;
 }
@@ -1152,7 +1155,7 @@ export function toolCallEventDefinition() {
 }
 export function validateToolExecuteEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.execute data must be a plain object");
+        throw new Error(t("tool.execute data must be a plain object"));
     const allowed = new Set([
         "version",
         "sessionId",
@@ -1165,18 +1168,18 @@ export function validateToolExecuteEventDataV1(value) {
     ]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`tool.execute data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.execute data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "input", "isError", "content"]) {
         if (!(key in value))
-            throw new Error(`tool.execute data is missing required field: ${key}`);
+            throw new Error(t("tool.execute data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.execute data.version must be 1");
+        throw new Error(t("tool.execute data.version must be 1"));
     assertString(value.sessionId, "tool.execute data.sessionId");
     assertString(value.toolCallId, "tool.execute data.toolCallId");
     assertString(value.toolName, "tool.execute data.toolName");
     if (typeof value.isError !== "boolean")
-        throw new Error("tool.execute data.isError must be boolean");
+        throw new Error(t("tool.execute data.isError must be boolean"));
     assertJsonSafe(value.input, "tool.execute data.input");
     validateToolResultRawEventDataV1({
         version: 1,
@@ -1202,39 +1205,39 @@ export function toolExecuteEventDefinition() {
 }
 export function validateToolCommitEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.commit data must be a plain object");
+        throw new Error(t("tool.commit data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "entryId", "revision", "toolCallId", "toolName", "isError"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`tool.commit data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.commit data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "entryId", "revision", "toolCallId", "toolName", "isError"]) {
         if (!(key in value))
-            throw new Error(`tool.commit data is missing required field: ${key}`);
+            throw new Error(t("tool.commit data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.commit data.version must be 1");
+        throw new Error(t("tool.commit data.version must be 1"));
     assertString(value.sessionId, "tool.commit data.sessionId");
     assertString(value.entryId, "tool.commit data.entryId");
     assertString(value.toolCallId, "tool.commit data.toolCallId");
     assertString(value.toolName, "tool.commit data.toolName");
     if (typeof value.isError !== "boolean")
-        throw new Error("tool.commit data.isError must be boolean");
+        throw new Error(t("tool.commit data.isError must be boolean"));
     if (!isPlainRecord(value.revision))
-        throw new Error("tool.commit data.revision must be a plain object");
+        throw new Error(t("tool.commit data.revision must be a plain object"));
     const revision = value.revision;
     if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
-        throw new Error("tool.commit data.revision has unsupported fields");
+        throw new Error(t("tool.commit data.revision has unsupported fields"));
     }
     if (revision.version !== 1)
-        throw new Error("tool.commit data.revision.version must be 1");
+        throw new Error(t("tool.commit data.revision.version must be 1"));
     assertString(revision.sessionId, "tool.commit data.revision.sessionId");
     if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
-        throw new Error("tool.commit data.revision.sequence must be a non-negative safe integer");
+        throw new Error(t("tool.commit data.revision.sequence must be a non-negative safe integer"));
     }
     if (revision.leafId !== null)
         assertString(revision.leafId, "tool.commit data.revision.leafId");
     if (revision.sessionId !== value.sessionId)
-        throw new Error("tool.commit data.revision.sessionId must match sessionId");
+        throw new Error(t("tool.commit data.revision.sessionId must match sessionId"));
     return value;
 }
 export function toolCommitEventDefinition() {
@@ -1250,49 +1253,49 @@ export function toolCommitEventDefinition() {
 }
 export function validateToolResultRawEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.result.raw data must be a plain object");
+        throw new Error(t("tool.result.raw data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`tool.result.raw data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.result.raw data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]) {
         if (!(key in value))
-            throw new Error(`tool.result.raw data is missing required field: ${key}`);
+            throw new Error(t("tool.result.raw data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.result.raw data.version must be 1");
+        throw new Error(t("tool.result.raw data.version must be 1"));
     assertString(value.sessionId, "tool.result.raw data.sessionId");
     assertString(value.toolCallId, "tool.result.raw data.toolCallId");
     assertString(value.toolName, "tool.result.raw data.toolName");
     if (typeof value.isError !== "boolean")
-        throw new Error("tool.result.raw data.isError must be boolean");
+        throw new Error(t("tool.result.raw data.isError must be boolean"));
     if (!isPlainRecord(value.revision))
-        throw new Error("tool.result.raw data.revision must be a plain object");
+        throw new Error(t("tool.result.raw data.revision must be a plain object"));
     const revision = value.revision;
     if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
-        throw new Error("tool.result.raw data.revision has unsupported fields");
+        throw new Error(t("tool.result.raw data.revision has unsupported fields"));
     }
     if (revision.version !== 1)
-        throw new Error("tool.result.raw data.revision.version must be 1");
+        throw new Error(t("tool.result.raw data.revision.version must be 1"));
     assertString(revision.sessionId, "tool.result.raw data.revision.sessionId");
     if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
-        throw new Error("tool.result.raw data.revision.sequence must be a non-negative safe integer");
+        throw new Error(t("tool.result.raw data.revision.sequence must be a non-negative safe integer"));
     }
     if (revision.leafId !== null)
         assertString(revision.leafId, "tool.result.raw data.revision.leafId");
     if (revision.sessionId !== value.sessionId) {
-        throw new Error("tool.result.raw data.revision.sessionId must match sessionId");
+        throw new Error(t("tool.result.raw data.revision.sessionId must match sessionId"));
     }
     if (!Array.isArray(value.content))
-        throw new Error("tool.result.raw data.content must be an array");
+        throw new Error(t("tool.result.raw data.content must be an array"));
     for (const [index, content] of value.content.entries()) {
         if (!isPlainRecord(content))
-            throw new Error(`tool.result.raw data.content[${index}] must be a plain object`);
+            throw new Error(t("tool.result.raw data.content[{index}] must be a plain object", { index }));
         if (content.type === "text") {
             const keys = Object.keys(content).sort().join(",");
             if (keys !== "text,type" && keys !== "text,textSignature,type") {
-                throw new Error(`tool.result.raw data.content[${index}] has unsupported text fields`);
+                throw new Error(t("tool.result.raw data.content[{index}] has unsupported text fields", { index }));
             }
             assertString(content.text, `tool.result.raw data.content[${index}].text`);
             if (content.textSignature !== undefined) {
@@ -1302,13 +1305,13 @@ export function validateToolResultRawEventDataV1(value) {
         }
         if (content.type === "image") {
             if (Object.keys(content).sort().join(",") !== "data,mimeType,type") {
-                throw new Error(`tool.result.raw data.content[${index}] has unsupported image fields`);
+                throw new Error(t("tool.result.raw data.content[{index}] has unsupported image fields", { index }));
             }
             assertString(content.data, `tool.result.raw data.content[${index}].data`);
             assertString(content.mimeType, `tool.result.raw data.content[${index}].mimeType`);
             continue;
         }
-        throw new Error(`tool.result.raw data.content[${index}].type is invalid`);
+        throw new Error(t("tool.result.raw data.content[{index}].type is invalid", { index }));
     }
     return value;
 }
@@ -1327,50 +1330,50 @@ export const TOOL_RESULT_TRANSFORM_EVENT_ID = "tool.result.transform";
 export const TOOL_RESULT_TRANSFORM_EVENT_VERSION = 1;
 export function validateToolResultTransformEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.result.transform data must be a plain object");
+        throw new Error(t("tool.result.transform data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`tool.result.transform data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.result.transform data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of ["version", "sessionId", "revision", "toolCallId", "toolName", "isError", "content"]) {
         if (!(key in value))
-            throw new Error(`tool.result.transform data is missing required field: ${key}`);
+            throw new Error(t("tool.result.transform data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.result.transform data.version must be 1");
+        throw new Error(t("tool.result.transform data.version must be 1"));
     assertString(value.sessionId, "tool.result.transform data.sessionId");
     assertString(value.toolCallId, "tool.result.transform data.toolCallId");
     assertString(value.toolName, "tool.result.transform data.toolName");
     if (typeof value.isError !== "boolean")
-        throw new Error("tool.result.transform data.isError must be boolean");
+        throw new Error(t("tool.result.transform data.isError must be boolean"));
     if (!isPlainRecord(value.revision))
-        throw new Error("tool.result.transform data.revision must be a plain object");
+        throw new Error(t("tool.result.transform data.revision must be a plain object"));
     const revision = value.revision;
     if (Object.keys(revision).sort().join(",") !== "leafId,sequence,sessionId,version") {
-        throw new Error("tool.result.transform data.revision has unsupported fields");
+        throw new Error(t("tool.result.transform data.revision has unsupported fields"));
     }
     if (revision.version !== 1)
-        throw new Error("tool.result.transform data.revision.version must be 1");
+        throw new Error(t("tool.result.transform data.revision.version must be 1"));
     assertString(revision.sessionId, "tool.result.transform data.revision.sessionId");
     if (typeof revision.sequence !== "number" || !Number.isSafeInteger(revision.sequence) || revision.sequence < 0) {
-        throw new Error("tool.result.transform data.revision.sequence must be a non-negative safe integer");
+        throw new Error(t("tool.result.transform data.revision.sequence must be a non-negative safe integer"));
     }
     if (revision.leafId !== null)
         assertString(revision.leafId, "tool.result.transform data.revision.leafId");
     if (revision.sessionId !== value.sessionId) {
-        throw new Error("tool.result.transform data.revision.sessionId must match sessionId");
+        throw new Error(t("tool.result.transform data.revision.sessionId must match sessionId"));
     }
     if (!Array.isArray(value.content))
-        throw new Error("tool.result.transform data.content must be an array");
+        throw new Error(t("tool.result.transform data.content must be an array"));
     for (const [index, content] of value.content.entries()) {
         if (!isPlainRecord(content)) {
-            throw new Error(`tool.result.transform data.content[${index}] must be a plain object`);
+            throw new Error(t("tool.result.transform data.content[{index}] must be a plain object", { index }));
         }
         if (content.type === "text") {
             const keys = Object.keys(content).sort().join(",");
             if (keys !== "text,type" && keys !== "text,textSignature,type") {
-                throw new Error(`tool.result.transform data.content[${index}] has unsupported text fields`);
+                throw new Error(t("tool.result.transform data.content[{index}] has unsupported text fields", { index }));
             }
             assertString(content.text, `tool.result.transform data.content[${index}].text`);
             if (content.textSignature !== undefined) {
@@ -1380,13 +1383,13 @@ export function validateToolResultTransformEventDataV1(value) {
         }
         if (content.type === "image") {
             if (Object.keys(content).sort().join(",") !== "data,mimeType,type") {
-                throw new Error(`tool.result.transform data.content[${index}] has unsupported image fields`);
+                throw new Error(t("tool.result.transform data.content[{index}] has unsupported image fields", { index }));
             }
             assertString(content.data, `tool.result.transform data.content[${index}].data`);
             assertString(content.mimeType, `tool.result.transform data.content[${index}].mimeType`);
             continue;
         }
-        throw new Error(`tool.result.transform data.content[${index}].type is invalid`);
+        throw new Error(t("tool.result.transform data.content[{index}].type is invalid", { index }));
     }
     return value;
 }
@@ -1403,21 +1406,21 @@ export function toolResultTransformEventDefinition() {
 }
 export function validateOperationEndEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("operation.end data must be a plain object");
+        throw new Error(t("operation.end data must be a plain object"));
     const allowed = new Set(["version", "operationId", "operationKind", "status", "errorMessage", "reason"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`operation.end data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("operation.end data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "operationId", "operationKind", "status"]) {
         if (!(key in value))
-            throw new Error(`operation.end data is missing required field: ${key}`);
+            throw new Error(t("operation.end data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("operation.end data.version must be 1");
+        throw new Error(t("operation.end data.version must be 1"));
     assertString(value.operationId, "operation.end data.operationId");
     assertString(value.operationKind, "operation.end data.operationKind");
     if (value.status !== "succeeded" && value.status !== "failed" && value.status !== "cancelled") {
-        throw new Error("operation.end data.status is invalid");
+        throw new Error(t("operation.end data.status is invalid"));
     }
     if (value.errorMessage !== undefined)
         assertString(value.errorMessage, "operation.end data.errorMessage");
@@ -1442,7 +1445,7 @@ const capabilityCallEvents = new Set(["start", "cancel", "end"]);
 const capabilityCallStatuses = new Set(["succeeded", "failed", "cancelled"]);
 export function validateCapabilityCallEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("capability.call data must be a plain object");
+        throw new Error(t("capability.call data must be a plain object"));
     const allowed = new Set([
         "version",
         "operationId",
@@ -1457,7 +1460,7 @@ export function validateCapabilityCallEventDataV1(value) {
     ]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`capability.call data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("capability.call data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of [
         "version",
@@ -1470,59 +1473,59 @@ export function validateCapabilityCallEventDataV1(value) {
         "event",
     ]) {
         if (!(key in value))
-            throw new Error(`capability.call data is missing required field: ${key}`);
+            throw new Error(t("capability.call data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("capability.call data.version must be 1");
+        throw new Error(t("capability.call data.version must be 1"));
     assertString(value.operationId, "capability.call data.operationId");
     assertString(value.capabilityId, "capability.call data.capabilityId");
     if (typeof value.capabilityVersion !== "number" ||
         !Number.isSafeInteger(value.capabilityVersion) ||
         value.capabilityVersion < 1) {
-        throw new Error("capability.call data.capabilityVersion must be a positive safe integer");
+        throw new Error(t("capability.call data.capabilityVersion must be a positive safe integer"));
     }
     if (value.capabilityKind !== "service" &&
         value.capabilityKind !== "contribution" &&
         value.capabilityKind !== "transform") {
-        throw new Error("capability.call data.capabilityKind is invalid");
+        throw new Error(t("capability.call data.capabilityKind is invalid"));
     }
     assertString(value.callerPluginId, "capability.call data.callerPluginId");
     assertString(value.providerPluginId, "capability.call data.providerPluginId");
     if (typeof value.event !== "string" || !capabilityCallEvents.has(value.event)) {
-        throw new Error("capability.call data.event is invalid");
+        throw new Error(t("capability.call data.event is invalid"));
     }
     if ((value.event === "start" || value.event === "cancel") && value.status !== undefined) {
-        throw new Error("capability.call start/cancel must not include status");
+        throw new Error(t("capability.call start/cancel must not include status"));
     }
     if (value.event === "end" && value.status === undefined) {
-        throw new Error("capability.call end requires status");
+        throw new Error(t("capability.call end requires status"));
     }
     if (value.status !== undefined) {
         if (typeof value.status !== "string" || !capabilityCallStatuses.has(value.status)) {
-            throw new Error("capability.call data.status is invalid");
+            throw new Error(t("capability.call data.status is invalid"));
         }
     }
     if (value.error !== undefined) {
         if (!isPlainRecord(value.error))
-            throw new Error("capability.call data.error must be a plain object");
+            throw new Error(t("capability.call data.error must be a plain object"));
         const errorKeys = Object.keys(value.error);
         if (errorKeys.some((key) => key !== "code" && key !== "message" && key !== "name")) {
-            throw new Error("capability.call data.error has unsupported fields");
+            throw new Error(t("capability.call data.error has unsupported fields"));
         }
         if (!("code" in value.error))
-            throw new Error("capability.call data.error is missing required field: code");
+            throw new Error(t("capability.call data.error is missing required field: code"));
         if (!("message" in value.error))
-            throw new Error("capability.call data.error is missing required field: message");
+            throw new Error(t("capability.call data.error is missing required field: message"));
         assertString(value.error.code, "capability.call data.error.code");
         assertString(value.error.message, "capability.call data.error.message");
         if (value.error.name !== undefined)
             assertString(value.error.name, "capability.call data.error.name");
     }
     if (value.event !== "end" && value.error !== undefined) {
-        throw new Error("capability.call start/cancel must not include error");
+        throw new Error(t("capability.call start/cancel must not include error"));
     }
     if (value.event === "end" && value.status === "succeeded" && value.error !== undefined) {
-        throw new Error("capability.call succeeded end must not include error");
+        throw new Error(t("capability.call succeeded end must not include error"));
     }
     return value;
 }
@@ -1543,13 +1546,13 @@ export const OPERATION_STEP_EVENT_ID = "operation.step";
 export const OPERATION_STEP_EVENT_VERSION = 1;
 export function validateOperationStartEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("operation.start data must be a plain object");
+        throw new Error(t("operation.start data must be a plain object"));
     const keys = Object.keys(value).sort().join(",");
     if (keys !== "operationId,operationKind,version") {
-        throw new Error("operation.start data has unsupported fields");
+        throw new Error(t("operation.start data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("operation.start data.version must be 1");
+        throw new Error(t("operation.start data.version must be 1"));
     assertString(value.operationId, "operation.start data.operationId");
     assertString(value.operationKind, "operation.start data.operationKind");
     return value;
@@ -1567,17 +1570,17 @@ export function operationStartEventDefinition() {
 }
 export function validateOperationStepEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("operation.step data must be a plain object");
+        throw new Error(t("operation.step data must be a plain object"));
     const allowed = new Set(["version", "operationId", "operationKind", "step", "message", "data"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error("operation.step data has unsupported fields");
+        throw new Error(t("operation.step data has unsupported fields"));
     if (value.version !== 1)
-        throw new Error("operation.step data.version must be 1");
+        throw new Error(t("operation.step data.version must be 1"));
     assertString(value.operationId, "operation.step data.operationId");
     assertString(value.operationKind, "operation.step data.operationKind");
     if (typeof value.step !== "number" || !Number.isSafeInteger(value.step) || value.step < 1) {
-        throw new Error("operation.step data.step must be a positive safe integer");
+        throw new Error(t("operation.step data.step must be a positive safe integer"));
     }
     if (value.message !== undefined)
         assertString(value.message, "operation.step data.message");
@@ -1600,13 +1603,13 @@ export const OPERATION_CANCEL_EVENT_ID = "operation.cancel";
 export const OPERATION_CANCEL_EVENT_VERSION = 1;
 export function validateOperationCancelEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("operation.cancel data must be a plain object");
+        throw new Error(t("operation.cancel data must be a plain object"));
     const keys = Object.keys(value).sort().join(",");
     if (keys !== "operationId,operationKind,version") {
-        throw new Error("operation.cancel data has unsupported fields");
+        throw new Error(t("operation.cancel data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("operation.cancel data.version must be 1");
+        throw new Error(t("operation.cancel data.version must be 1"));
     assertString(value.operationId, "operation.cancel data.operationId");
     assertString(value.operationKind, "operation.cancel data.operationKind");
     return value;
@@ -1630,28 +1633,28 @@ export const SESSION_COMPACTION_FAILED_EVENT_ID = "session.compaction.failed";
 export const SESSION_COMPACTION_FAILED_EVENT_VERSION = 1;
 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 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 }));
     }
 }
 export function validateSessionAutoRetryEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.auto.retry data must be a plain object");
+        throw new Error(t("session.auto.retry data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "attempt", "maxAttempts", "delayMs", "errorMessage"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`session.auto.retry data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("session.auto.retry data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of ["version", "sessionId", "attempt", "maxAttempts", "delayMs", "errorMessage"]) {
         if (!(key in value))
-            throw new Error(`session.auto.retry data is missing required field: ${key}`);
+            throw new Error(t("session.auto.retry data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("session.auto.retry data.version must be 1");
+        throw new Error(t("session.auto.retry data.version must be 1"));
     assertString(value.sessionId, "session.auto.retry data.sessionId");
     assertPositiveSafeInteger(value.attempt, "session.auto.retry data.attempt");
     assertPositiveSafeInteger(value.maxAttempts, "session.auto.retry data.maxAttempts");
@@ -1678,7 +1681,7 @@ function assertOptionalPositiveSafeInteger(value, label) {
 }
 export function validateSessionCompactionDecisionEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.compaction.decision data must be a plain object");
+        throw new Error(t("session.compaction.decision data must be a plain object"));
     const allowed = new Set([
         "version",
         "sessionId",
@@ -1692,24 +1695,26 @@ export function validateSessionCompactionDecisionEventDataV1(value) {
     ]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`session.compaction.decision data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("session.compaction.decision data has unsupported fields: {unsupported}", {
+            unsupported: unsupported.join(", "),
+        }));
     }
     for (const key of ["version", "sessionId", "reason", "compact", "willRetry"]) {
         if (!(key in value))
-            throw new Error(`session.compaction.decision data is missing required field: ${key}`);
+            throw new Error(t("session.compaction.decision data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("session.compaction.decision data.version must be 1");
+        throw new Error(t("session.compaction.decision data.version must be 1"));
     assertString(value.sessionId, "session.compaction.decision data.sessionId");
     if (typeof value.reason !== "string" ||
         !sessionCompactionDecisionReasons.has(value.reason)) {
-        throw new Error("session.compaction.decision data.reason is invalid");
+        throw new Error(t("session.compaction.decision data.reason is invalid"));
     }
     if (typeof value.compact !== "boolean") {
-        throw new Error("session.compaction.decision data.compact must be a boolean");
+        throw new Error(t("session.compaction.decision data.compact must be a boolean"));
     }
     if (typeof value.willRetry !== "boolean") {
-        throw new Error("session.compaction.decision data.willRetry must be a boolean");
+        throw new Error(t("session.compaction.decision data.willRetry must be a boolean"));
     }
     assertOptionalPositiveSafeInteger(value.contextTokens, "session.compaction.decision data.contextTokens");
     assertOptionalPositiveSafeInteger(value.contextWindow, "session.compaction.decision data.contextWindow");
@@ -1733,22 +1738,24 @@ export function sessionCompactionDecisionEventDefinition() {
 const sessionCompactionFailedReasons = new Set(["manual", "overflow", "threshold"]);
 export function validateSessionCompactionFailedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.compaction.failed data must be a plain object");
+        throw new Error(t("session.compaction.failed data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "reason", "errorMessage"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`session.compaction.failed data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("session.compaction.failed data has unsupported fields: {unsupported}", {
+            unsupported: unsupported.join(", "),
+        }));
     }
     for (const key of ["version", "sessionId", "reason", "errorMessage"]) {
         if (!(key in value))
-            throw new Error(`session.compaction.failed data is missing required field: ${key}`);
+            throw new Error(t("session.compaction.failed data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("session.compaction.failed data.version must be 1");
+        throw new Error(t("session.compaction.failed data.version must be 1"));
     assertString(value.sessionId, "session.compaction.failed data.sessionId");
     if (typeof value.reason !== "string" ||
         !sessionCompactionFailedReasons.has(value.reason)) {
-        throw new Error("session.compaction.failed data.reason is invalid");
+        throw new Error(t("session.compaction.failed data.reason is invalid"));
     }
     assertString(value.errorMessage, "session.compaction.failed data.errorMessage");
     return value;
@@ -1768,12 +1775,12 @@ export const SESSION_END_EVENT_ID = "session.end";
 export const SESSION_END_EVENT_VERSION = 1;
 export function validateSessionEndEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("session.end data must be a plain object");
+        throw new Error(t("session.end data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "sessionId,version") {
-        throw new Error("session.end data has unsupported fields");
+        throw new Error(t("session.end data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("session.end data.version must be 1");
+        throw new Error(t("session.end data.version must be 1"));
     assertString(value.sessionId, "session.end data.sessionId");
     return value;
 }
@@ -1803,23 +1810,23 @@ const agentTaskSettledStatuses = new Set([
 ]);
 export function validateAgentTaskSettledEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("agent.task.settled data must be a plain object");
+        throw new Error(t("agent.task.settled data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "taskSessionId", "taskId", "status", "reasonCode"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`agent.task.settled data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("agent.task.settled data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     }
     for (const key of ["version", "sessionId", "taskSessionId", "taskId", "status"]) {
         if (!(key in value))
-            throw new Error(`agent.task.settled data is missing required field: ${key}`);
+            throw new Error(t("agent.task.settled data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("agent.task.settled data.version must be 1");
+        throw new Error(t("agent.task.settled data.version must be 1"));
     assertString(value.sessionId, "agent.task.settled data.sessionId");
     assertString(value.taskSessionId, "agent.task.settled data.taskSessionId");
     assertString(value.taskId, "agent.task.settled data.taskId");
     if (typeof value.status !== "string" || !agentTaskSettledStatuses.has(value.status)) {
-        throw new Error("agent.task.settled data.status is invalid");
+        throw new Error(t("agent.task.settled data.status is invalid"));
     }
     if (value.reasonCode !== undefined)
         assertString(value.reasonCode, "agent.task.settled data.reasonCode");
@@ -1838,17 +1845,17 @@ export function agentTaskSettledEventDefinition() {
 }
 export function validateToolGateBlockedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("tool.gate.blocked data must be a plain object");
+        throw new Error(t("tool.gate.blocked data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "toolCallId", "toolName", "reason"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`tool.gate.blocked data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("tool.gate.blocked data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "toolCallId", "toolName"]) {
         if (!(key in value))
-            throw new Error(`tool.gate.blocked data is missing required field: ${key}`);
+            throw new Error(t("tool.gate.blocked data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("tool.gate.blocked data.version must be 1");
+        throw new Error(t("tool.gate.blocked data.version must be 1"));
     assertString(value.sessionId, "tool.gate.blocked data.sessionId");
     assertString(value.toolCallId, "tool.gate.blocked data.toolCallId");
     assertString(value.toolName, "tool.gate.blocked data.toolName");
@@ -1869,21 +1876,21 @@ export function toolGateBlockedEventDefinition() {
 }
 export function validateInputGateBlockedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("input.gate.blocked data must be a plain object");
+        throw new Error(t("input.gate.blocked data must be a plain object"));
     const allowed = new Set(["version", "sessionId", "source", "textLength", "reason"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0)
-        throw new Error(`input.gate.blocked data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("input.gate.blocked data has unsupported fields: {unsupported}", { unsupported: unsupported.join(", ") }));
     for (const key of ["version", "sessionId", "source", "textLength"]) {
         if (!(key in value))
-            throw new Error(`input.gate.blocked data is missing required field: ${key}`);
+            throw new Error(t("input.gate.blocked data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("input.gate.blocked data.version must be 1");
+        throw new Error(t("input.gate.blocked data.version must be 1"));
     assertString(value.sessionId, "input.gate.blocked data.sessionId");
     assertString(value.source, "input.gate.blocked data.source");
     if (typeof value.textLength !== "number" || !Number.isInteger(value.textLength) || value.textLength < 0) {
-        throw new Error("input.gate.blocked data.textLength must be a non-negative integer");
+        throw new Error(t("input.gate.blocked data.textLength must be a non-negative integer"));
     }
     if (value.reason !== undefined)
         assertString(value.reason, "input.gate.blocked data.reason");
@@ -1913,22 +1920,24 @@ const isModelReference = (value) => {
 function validateFailoverModelReference(value, label) {
     assertString(value, label);
     if (!isModelReference(value))
-        throw new Error(`${label} must be a provider/modelId reference`);
+        throw new Error(t("{label} must be a provider/modelId reference", { label }));
 }
 export function validateProviderFailoverSwitchedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("provider.failover.switched data must be a plain object");
+        throw new Error(t("provider.failover.switched data must be a plain object"));
     const allowed = new Set(["version", "chainId", "from", "to", "attempt", "rawError"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`provider.failover.switched data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("provider.failover.switched data has unsupported fields: {unsupported}", {
+            unsupported: unsupported.join(", "),
+        }));
     }
     for (const key of ["version", "chainId", "from", "to", "attempt", "rawError"]) {
         if (!(key in value))
-            throw new Error(`provider.failover.switched data is missing required field: ${key}`);
+            throw new Error(t("provider.failover.switched data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("provider.failover.switched data.version must be 1");
+        throw new Error(t("provider.failover.switched data.version must be 1"));
     validateFailoverModelReference(value.chainId, "provider.failover.switched data.chainId");
     validateFailoverModelReference(value.from, "provider.failover.switched data.from");
     validateFailoverModelReference(value.to, "provider.failover.switched data.to");
@@ -1949,12 +1958,12 @@ export function providerFailoverSwitchedEventDefinition() {
 }
 export function validateProviderFailoverRecoveredEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("provider.failover.recovered data must be a plain object");
+        throw new Error(t("provider.failover.recovered data must be a plain object"));
     if (Object.keys(value).sort().join(",") !== "chainId,provider,version") {
-        throw new Error("provider.failover.recovered data has unsupported fields");
+        throw new Error(t("provider.failover.recovered data has unsupported fields"));
     }
     if (value.version !== 1)
-        throw new Error("provider.failover.recovered data.version must be 1");
+        throw new Error(t("provider.failover.recovered data.version must be 1"));
     validateFailoverModelReference(value.chainId, "provider.failover.recovered data.chainId");
     assertString(value.provider, "provider.failover.recovered data.provider");
     return value;
@@ -1972,18 +1981,20 @@ export function providerFailoverRecoveredEventDefinition() {
 }
 export function validateProviderFailoverProbeFailedEventDataV1(value) {
     if (!isPlainRecord(value))
-        throw new Error("provider.failover.probe.failed data must be a plain object");
+        throw new Error(t("provider.failover.probe.failed data must be a plain object"));
     const allowed = new Set(["version", "chainId", "provider", "rawError", "nextCooldownMs"]);
     const unsupported = Object.keys(value).filter((key) => !allowed.has(key));
     if (unsupported.length > 0) {
-        throw new Error(`provider.failover.probe.failed data has unsupported fields: ${unsupported.join(", ")}`);
+        throw new Error(t("provider.failover.probe.failed data has unsupported fields: {unsupported}", {
+            unsupported: unsupported.join(", "),
+        }));
     }
     for (const key of ["version", "chainId", "provider", "rawError", "nextCooldownMs"]) {
         if (!(key in value))
-            throw new Error(`provider.failover.probe.failed data is missing required field: ${key}`);
+            throw new Error(t("provider.failover.probe.failed data is missing required field: {key}", { key }));
     }
     if (value.version !== 1)
-        throw new Error("provider.failover.probe.failed data.version must be 1");
+        throw new Error(t("provider.failover.probe.failed data.version must be 1"));
     validateFailoverModelReference(value.chainId, "provider.failover.probe.failed data.chainId");
     assertString(value.provider, "provider.failover.probe.failed data.provider");
     assertString(value.rawError, "provider.failover.probe.failed data.rawError");