@ai-agent-forge/agent-forge 0.86.3 → 0.86.5

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

@@ -1900,4 +1900,105 @@ export function inputGateBlockedEventDefinition() {
         validate: validateInputGateBlockedEventDataV1,
     };
 }
+export const PROVIDER_FAILOVER_SWITCHED_EVENT_ID = "provider.failover.switched";
+export const PROVIDER_FAILOVER_SWITCHED_EVENT_VERSION = 1;
+export const PROVIDER_FAILOVER_RECOVERED_EVENT_ID = "provider.failover.recovered";
+export const PROVIDER_FAILOVER_RECOVERED_EVENT_VERSION = 1;
+export const PROVIDER_FAILOVER_PROBE_FAILED_EVENT_ID = "provider.failover.probe.failed";
+export const PROVIDER_FAILOVER_PROBE_FAILED_EVENT_VERSION = 1;
+const isModelReference = (value) => {
+    const separator = value.indexOf("/");
+    return separator > 0 && separator < value.length - 1;
+};
+function validateFailoverModelReference(value, label) {
+    assertString(value, label);
+    if (!isModelReference(value))
+        throw new Error(`${label} must be a provider/modelId reference`);
+}
+export function validateProviderFailoverSwitchedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("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(", ")}`);
+    }
+    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}`);
+    }
+    if (value.version !== 1)
+        throw new Error("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");
+    assertPositiveSafeInteger(value.attempt, "provider.failover.switched data.attempt");
+    assertString(value.rawError, "provider.failover.switched data.rawError");
+    return value;
+}
+export function providerFailoverSwitchedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: PROVIDER_FAILOVER_SWITCHED_EVENT_ID,
+        version: PROVIDER_FAILOVER_SWITCHED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/provider.failover.switched@1",
+        allowedRegistrationKinds,
+        validate: validateProviderFailoverSwitchedEventDataV1,
+    };
+}
+export function validateProviderFailoverRecoveredEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("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");
+    }
+    if (value.version !== 1)
+        throw new Error("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;
+}
+export function providerFailoverRecoveredEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: PROVIDER_FAILOVER_RECOVERED_EVENT_ID,
+        version: PROVIDER_FAILOVER_RECOVERED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/provider.failover.recovered@1",
+        allowedRegistrationKinds,
+        validate: validateProviderFailoverRecoveredEventDataV1,
+    };
+}
+export function validateProviderFailoverProbeFailedEventDataV1(value) {
+    if (!isPlainRecord(value))
+        throw new Error("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(", ")}`);
+    }
+    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}`);
+    }
+    if (value.version !== 1)
+        throw new Error("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");
+    assertPositiveSafeInteger(value.nextCooldownMs, "provider.failover.probe.failed data.nextCooldownMs");
+    return value;
+}
+export function providerFailoverProbeFailedEventDefinition() {
+    const allowedRegistrationKinds = ["observe", "after-commit"];
+    return {
+        id: PROVIDER_FAILOVER_PROBE_FAILED_EVENT_ID,
+        version: PROVIDER_FAILOVER_PROBE_FAILED_EVENT_VERSION,
+        phase: "committed",
+        schema: "agent-forge/provider.failover.probe.failed@1",
+        allowedRegistrationKinds,
+        validate: validateProviderFailoverProbeFailedEventDataV1,
+    };
+}
 //# sourceMappingURL=lifecycle-catalog.js.map