@oxy.so/contracts 4.11.0-oxy-one.0 → 4.12.0

package/dist/esm/inference/decisions.js

@@ -1,37 +1,31 @@
-import { z } from "zod";
-import { inferenceErrorSchema } from "./errors.js";
-import { modelReferenceSchema, requestIdSchema } from "./identifiers.js";
-import { usageQuantitySchema } from "./money.js";
-import { routingPolicyReferenceSchema } from "./routingPolicy.js";
-import { normalizedUsageReportSchema } from "./usage.js";
+import { z } from 'zod';
+import { inferenceErrorSchema } from './errors.js';
+import { modelReferenceSchema, requestIdSchema } from './identifiers.js';
+import { usageQuantitySchema } from './money.js';
+import { routingPolicyReferenceSchema } from './routingPolicy.js';
+import { normalizedUsageReportSchema } from './usage.js';
 const probability = z.number().finite().min(0).max(1);
 const text = z.string().min(1).max(65536);
 const id = z.string().min(1).max(128);
 const tolerance = 1e-6;
-export const decisionEffortSchema = z.enum([
-    "instant",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-]);
+export const decisionEffortSchema = z.enum(['instant', 'low', 'medium', 'high', 'xhigh']);
 const common = { id, question: text, criteria: text.optional() };
-export const decisionQuestionSchema = z.discriminatedUnion("kind", [
+export const decisionQuestionSchema = z.discriminatedUnion('kind', [
     z
         .object({
         ...common,
-        kind: z.literal("choice"),
+        kind: z.literal('choice'),
         options: z.array(text).min(2).max(255),
     })
         .strict(),
     z
         .object({
         ...common,
-        kind: z.literal("score"),
+        kind: z.literal('score'),
         levels: z.array(text).min(2).max(10),
     })
         .strict(),
-    z.object({ ...common, kind: z.literal("noul") }).strict(),
+    z.object({ ...common, kind: z.literal('noul') }).strict(),
 ]);
 const payloadFields = {
     state: z.string().max(65536),
@@ -47,23 +41,38 @@ const payloadFields = {
  * Kaana must also check its final serialized body before sending it.
  */
 export function decisionInputBudget(payload) {
-    const bytes = (value) => new TextEncoder().encode(JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`)).length;
-    const model = "x".repeat(255);
+    const bytes = (value) => new TextEncoder().encode(JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)).length;
+    const model = 'x'.repeat(255);
     const measure = (questions) => {
-        const wireQuestions = Object.fromEntries(questions.map((q) => [q.id, {
+        const wireQuestions = Object.fromEntries(questions.map((q) => [
+            q.id,
+            {
                 type: q.kind,
                 instructions: {
                     question: q.question,
                     ...(payload.instructions === undefined ? {} : { instructions: payload.instructions }),
                     ...(q.criteria === undefined ? {} : { criteria: q.criteria }),
                 },
-                ...(q.kind === "choice" ? { criteria: Object.fromEntries(q.options.map((label) => [label, null])) } :
-                    q.kind === "score" ? { criteria: q.levels } : {}),
-            }]));
-        return Math.max(bytes({ ...payload, model, questions }), bytes({ model, state: payload.state, questions: wireQuestions, ...(payload.effort === undefined ? {} : { effort: payload.effort }) }));
+                ...(q.kind === 'choice'
+                    ? { criteria: Object.fromEntries(q.options.map((label) => [label, null])) }
+                    : q.kind === 'score'
+                        ? { criteria: q.levels }
+                        : {}),
+            },
+        ]));
+        return Math.max(bytes({ ...payload, model, questions }), bytes({
+            model,
+            state: payload.state,
+            questions: wireQuestions,
+            ...(payload.effort === undefined ? {} : { effort: payload.effort }),
+        }));
     };
     const total = measure(payload.questions);
-    return { total, context: Math.max(...payload.questions.map((q) => measure([q]))), gateway: total + 4096 };
+    return {
+        total,
+        context: Math.max(...payload.questions.map((q) => measure([q]))),
+        gateway: total + 4096,
+    };
 }
 /** OpenRouter's TOTAL limit is separate from direct state-plus-longest context. */
 export function decisionFitsGateway(payload) {
@@ -86,18 +95,18 @@ function hasUnpairedSurrogate(value) {
 }
 function validateInput(payload, ctx) {
     const fields = [
-        { value: payload.state, path: ["state"] },
-        { value: payload.instructions, path: ["instructions"] },
+        { value: payload.state, path: ['state'] },
+        { value: payload.instructions, path: ['instructions'] },
     ];
     for (const [index, question] of payload.questions.entries()) {
-        for (const field of ["id", "question", "criteria"]) {
-            fields.push({ value: question[field], path: ["questions", index, field] });
+        for (const field of ['id', 'question', 'criteria']) {
+            fields.push({ value: question[field], path: ['questions', index, field] });
         }
-        if (question.kind === "choice" || question.kind === "score") {
-            const field = question.kind === "choice" ? "options" : "levels";
-            const labels = question.kind === "choice" ? question.options : question.levels;
+        if (question.kind === 'choice' || question.kind === 'score') {
+            const field = question.kind === 'choice' ? 'options' : 'levels';
+            const labels = question.kind === 'choice' ? question.options : question.levels;
             for (const [labelIndex, value] of labels.entries()) {
-                fields.push({ value, path: ["questions", index, field, labelIndex] });
+                fields.push({ value, path: ['questions', index, field, labelIndex] });
             }
         }
     }
@@ -105,57 +114,57 @@ function validateInput(payload, ctx) {
     for (const { value, path } of fields) {
         if (value !== undefined && hasUnpairedSurrogate(value)) {
             invalidUnicode = true;
-            ctx.addIssue({ code: "custom", path, message: "Decisions require paired UTF-16 surrogates." });
+            ctx.addIssue({
+                code: 'custom',
+                path,
+                message: 'Decisions require paired UTF-16 surrogates.',
+            });
         }
     }
     // Reject before measuring/reserving text that the execution runtime would change.
     if (invalidUnicode)
         return;
-    if (new Set(payload.questions.map((q) => q.id)).size !==
-        payload.questions.length)
+    if (new Set(payload.questions.map((q) => q.id)).size !== payload.questions.length)
         ctx.addIssue({
-            code: "custom",
-            path: ["questions"],
-            message: "Question IDs must be unique.",
+            code: 'custom',
+            path: ['questions'],
+            message: 'Question IDs must be unique.',
         });
     for (const [index, question] of payload.questions.entries()) {
-        const labels = question.kind === "choice"
+        const labels = question.kind === 'choice'
             ? question.options
-            : question.kind === "score"
+            : question.kind === 'score'
                 ? question.levels
                 : [];
         if (new Set(labels).size !== labels.length)
             ctx.addIssue({
-                code: "custom",
-                path: ["questions", index],
-                message: "Options and levels must be unique.",
+                code: 'custom',
+                path: ['questions', index],
+                message: 'Options and levels must be unique.',
             });
     }
     const budget = decisionInputBudget(payload);
     if (budget.total > 64000 || budget.context > 32000)
         ctx.addIssue({
-            code: "custom",
-            path: ["state"],
-            message: "Decisions exceed the serialized 64000-byte total or 32000-byte per-question context budget.",
+            code: 'custom',
+            path: ['state'],
+            message: 'Decisions exceed the serialized 64000-byte total or 32000-byte per-question context budget.',
         });
 }
-export const decisionInputSchema = z
-    .object(payloadFields)
-    .strict()
-    .superRefine(validateInput);
+export const decisionInputSchema = z.object(payloadFields).strict().superRefine(validateInput);
 export const decisionRequestSchema = z
     .object({
-    model: modelReferenceSchema.refine((model) => model.includes("@"), "Decisions require a revision-pinned model."),
+    model: modelReferenceSchema.refine((model) => model.includes('@'), 'Decisions require a revision-pinned model.'),
     ...payloadFields,
 })
     .strict()
     .superRefine(validateInput);
 export const decisionAnswerSchema = z
-    .discriminatedUnion("kind", [
+    .discriminatedUnion('kind', [
     z
         .object({
         id,
-        kind: z.literal("choice"),
+        kind: z.literal('choice'),
         /** Actual provider-selected option. Never reconstructed from probabilities. */
         reply: text,
         /** Provider-returned confidence, not a correctness probability. */
@@ -166,7 +175,7 @@ export const decisionAnswerSchema = z
     z
         .object({
         id,
-        kind: z.literal("score"),
+        kind: z.literal('score'),
         /** Actual provider score. Kept separate from the validated expected index. */
         reply: z.number().finite().min(0).max(9),
         confidence: probability,
@@ -174,42 +183,45 @@ export const decisionAnswerSchema = z
         distribution: z.array(probability).min(2).max(10),
     })
         .strict(),
-    z.object({ id, kind: z.literal("noul"), probability }).strict(),
+    z.object({ id, kind: z.literal('noul'), probability }).strict(),
 ])
     .superRefine((answer, ctx) => {
-    if (answer.kind === "noul")
+    if (answer.kind === 'noul')
         return;
-    if (answer.kind === "score" && Math.abs(answer.reply - answer.mean) > tolerance) {
-        ctx.addIssue({ code: "custom", path: ["reply"], message: "Provider score must match the expected level index." });
+    if (answer.kind === 'score' && Math.abs(answer.reply - answer.mean) > tolerance) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['reply'],
+            message: 'Provider score must match the expected level index.',
+        });
     }
-    const distribution = answer.kind === "choice" ? answer.probabilities : answer.distribution;
-    if (Math.abs(distribution.reduce((sum, value) => sum + value, 0) - 1) >
-        tolerance)
+    const distribution = answer.kind === 'choice' ? answer.probabilities : answer.distribution;
+    if (Math.abs(distribution.reduce((sum, value) => sum + value, 0) - 1) > tolerance)
         ctx.addIssue({
-            code: "custom",
-            message: "Probabilities must sum to one.",
+            code: 'custom',
+            message: 'Probabilities must sum to one.',
         });
-    if (answer.kind === "score" &&
-        Math.abs(distribution.reduce((sum, value, index) => sum + index * value, 0) -
-            answer.mean) > tolerance)
+    if (answer.kind === 'score' &&
+        Math.abs(distribution.reduce((sum, value, index) => sum + index * value, 0) - answer.mean) >
+            tolerance)
         ctx.addIssue({
-            code: "custom",
-            path: ["mean"],
-            message: "Mean must equal the expected zero-based level index.",
+            code: 'custom',
+            path: ['mean'],
+            message: 'Mean must equal the expected zero-based level index.',
         });
 });
 const resultFields = {
     schemaVersion: z.literal(1),
     requestId: requestIdSchema,
-    model: modelReferenceSchema.refine((model) => model.includes("@"), "Decisions require an immutable model revision."),
+    model: modelReferenceSchema.refine((model) => model.includes('@'), 'Decisions require an immutable model revision.'),
     data: z.array(decisionAnswerSchema).min(1).max(255),
 };
 function uniqueAnswers(result, ctx) {
     if (new Set(result.data.map((answer) => answer.id)).size !== result.data.length)
         ctx.addIssue({
-            code: "custom",
-            path: ["data"],
-            message: "Answer IDs must be unique.",
+            code: 'custom',
+            path: ['data'],
+            message: 'Answer IDs must be unique.',
         });
 }
 export const decisionResultSchema = z
@@ -219,11 +231,11 @@ export const decisionResultSchema = z
     .superRefine((result, ctx) => {
     if (result.usage.requestId !== result.requestId ||
         result.usage.resolvedModelReference !== result.model ||
-        result.usage.outcome !== "completed") {
+        result.usage.outcome !== 'completed') {
         ctx.addIssue({
-            code: "custom",
-            path: ["usage"],
-            message: "Decision usage must describe this completed request and immutable model.",
+            code: 'custom',
+            path: ['usage'],
+            message: 'Decision usage must describe this completed request and immutable model.',
         });
     }
 });
@@ -242,11 +254,19 @@ export const decisionFailureSchema = z
     .strict()
     .superRefine((failure, ctx) => {
     if (failure.error.requestId !== failure.requestId) {
-        ctx.addIssue({ code: "custom", path: ["error", "requestId"], message: "The error must answer this request." });
+        ctx.addIssue({
+            code: 'custom',
+            path: ['error', 'requestId'],
+            message: 'The error must answer this request.',
+        });
     }
     if (failure.usage !== undefined &&
-        (failure.usage.requestId !== failure.requestId || failure.usage.outcome === "completed")) {
-        ctx.addIssue({ code: "custom", path: ["usage"], message: "Failure usage must describe this request and an incomplete outcome." });
+        (failure.usage.requestId !== failure.requestId || failure.usage.outcome === 'completed')) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['usage'],
+            message: 'Failure usage must describe this request and an incomplete outcome.',
+        });
     }
 });
 export const decisionSuccessSchema = z
@@ -264,17 +284,16 @@ export function decisionAnswersMatch(input, answers) {
         return false;
     return input.questions.every((question) => {
         const answer = answers.find((candidate) => candidate.id === question.id);
-        if (!answer ||
-            !decisionAnswerSchema.safeParse(answer).success ||
-            answer.kind !== question.kind)
+        if (!answer || !decisionAnswerSchema.safeParse(answer).success || answer.kind !== question.kind)
             return false;
-        if (question.kind === "choice" && answer.kind === "choice") {
+        if (question.kind === 'choice' && answer.kind === 'choice') {
             const index = question.options.indexOf(answer.reply);
-            return question.options.length === answer.probabilities.length && index >= 0 &&
-                answer.probabilities[index] + tolerance >= Math.max(...answer.probabilities);
+            return (question.options.length === answer.probabilities.length &&
+                index >= 0 &&
+                answer.probabilities[index] + tolerance >= Math.max(...answer.probabilities));
         }
-        if (question.kind === "score" && answer.kind === "score")
+        if (question.kind === 'score' && answer.kind === 'score')
             return question.levels.length === answer.distribution.length;
-        return question.kind === "noul";
+        return question.kind === 'noul';
     });
 }

package/dist/esm/inference/economics.js

@@ -28,7 +28,7 @@
  */
 import { z } from 'zod';
 import { costCenterSchema } from './entitlement.js';
-import { currencyCodeSchema, exactDecimalSchema, usageSourceSchema, usageQuantitySchema } from './money.js';
+import { currencyCodeSchema, exactDecimalSchema, usageSourceSchema, usageQuantitySchema, } from './money.js';
 import { inferenceEnvironmentSchema, modelReferenceSchema } from './identifiers.js';
 import { inferenceRequestOutcomeSchema } from './usage.js';
 /** How a request is treated economically. The first entry is the default. */
@@ -104,7 +104,8 @@ export const costCenterUsageSchema = z
 })
     .strict();
 /** A technical generation record for an internal request, never a financial receipt. */
-export const meteredGenerationSchema = z.object({
+export const meteredGenerationSchema = z
+    .object({
     schemaVersion: z.literal(2),
     kind: z.literal('metered_usage'),
     meteredUsageId: z.string().min(1),
@@ -123,10 +124,19 @@ export const meteredGenerationSchema = z.object({
     resolvedModelReference: modelReferenceSchema,
     servingProvider: z.string().min(1),
     tariff: z.discriminatedUnion('status', [
-        z.object({ status: z.literal('quoted'), amount: exactDecimalSchema, currency: currencyCodeSchema,
-            priceVersionId: z.string().min(1) }).strict(),
-        z.object({ status: z.literal('unpriced'), priceVersionId: z.string().min(1).nullable() }).strict(),
+        z
+            .object({
+            status: z.literal('quoted'),
+            amount: exactDecimalSchema,
+            currency: currencyCodeSchema,
+            priceVersionId: z.string().min(1),
+        })
+            .strict(),
+        z
+            .object({ status: z.literal('unpriced'), priceVersionId: z.string().min(1).nullable() })
+            .strict(),
     ]),
     customerCharge: z.object({ status: z.literal('not_charged') }).strict(),
     settledAt: z.string().datetime(),
-}).strict();
+})
+    .strict();

package/dist/esm/inference/embeddings.js

@@ -1,16 +1,54 @@
 import { z } from 'zod';
 import { inferenceErrorSchema } from './errors.js';
-export const embeddingVectorSchema = z.object({ index: z.number().int().nonnegative(), embedding: z.array(z.number().finite()).min(1).max(1024) }).strict();
-export const embeddingUsageSchema = z.object({ inputTokens: z.number().int().nonnegative(), totalTokens: z.number().int().nonnegative() }).strict().refine((usage) => usage.totalTokens >= usage.inputTokens, { message: 'totalTokens must be greater than or equal to inputTokens', path: ['totalTokens'] });
-export const embeddingSuccessSchema = z.object({ schemaVersion: z.literal(1), requestId: z.string().min(1).max(128), model: z.string().min(1).max(255), dimension: z.number().int().positive().max(1024), data: z.array(embeddingVectorSchema).min(1).max(2048), usage: embeddingUsageSchema }).strict().superRefine((result, context) => {
+export const embeddingVectorSchema = z
+    .object({
+    index: z.number().int().nonnegative(),
+    embedding: z.array(z.number().finite()).min(1).max(1024),
+})
+    .strict();
+export const embeddingUsageSchema = z
+    .object({
+    inputTokens: z.number().int().nonnegative(),
+    totalTokens: z.number().int().nonnegative(),
+})
+    .strict()
+    .refine((usage) => usage.totalTokens >= usage.inputTokens, {
+    message: 'totalTokens must be greater than or equal to inputTokens',
+    path: ['totalTokens'],
+});
+export const embeddingSuccessSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    requestId: z.string().min(1).max(128),
+    model: z.string().min(1).max(255),
+    dimension: z.number().int().positive().max(1024),
+    data: z.array(embeddingVectorSchema).min(1).max(2048),
+    usage: embeddingUsageSchema,
+})
+    .strict()
+    .superRefine((result, context) => {
     const indexes = new Set();
     for (const [position, vector] of result.data.entries()) {
         if (vector.embedding.length !== result.dimension)
-            context.addIssue({ code: z.ZodIssueCode.custom, path: ['data', position, 'embedding'], message: 'embedding length must equal dimension' });
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['data', position, 'embedding'],
+                message: 'embedding length must equal dimension',
+            });
         if (indexes.has(vector.index))
-            context.addIssue({ code: z.ZodIssueCode.custom, path: ['data', position, 'index'], message: 'embedding indexes must be unique' });
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['data', position, 'index'],
+                message: 'embedding indexes must be unique',
+            });
         indexes.add(vector.index);
     }
 });
-export const embeddingFailureSchema = z.object({ schemaVersion: z.literal(1), requestId: z.string().min(1).max(128), error: inferenceErrorSchema }).strict();
+export const embeddingFailureSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    requestId: z.string().min(1).max(128),
+    error: inferenceErrorSchema,
+})
+    .strict();
 export const embeddingResponseSchema = z.union([embeddingSuccessSchema, embeddingFailureSchema]);

package/dist/esm/inference/identifiers.js

@@ -221,3 +221,16 @@ export const inferenceRegionSchema = z
  * this constant exists to be checked against.
  */
 export const RESERVED_ALIA_PUBLISHER = 'alia';
+/**
+ * The economic tier of the provider capacity that funds a request, in the
+ * order Kaana spends it: `free` (costs nothing), `credit` (a promotional or
+ * trial grant, or a prepaid balance), `paid` (ordinary metered spend).
+ *
+ * Kaana owns provider keys, their economics and which key serves (Oxy ADR
+ * 0038, Kaana ADR 0001); Oxy owns what a customer may spend. The tier is the
+ * one economic fact the two exchange: Oxy BOUNDS a route by it
+ * (`maxFundingTier`), and Kaana REPORTS the tier that served
+ * (`normalizedUsageReportSchema.fundingTier`). No key id, label or price
+ * travels with it.
+ */
+export const inferenceFundingTierSchema = z.enum(['free', 'credit', 'paid']);

package/dist/esm/inference/inbox.js

@@ -37,7 +37,8 @@ export const inboxComposeRequestSchema = z.discriminatedUnion('operation', [
 export const inboxDailyBriefRequestSchema = z.object({
     startAt: inboxUtcTimestampSchema,
     endAt: inboxUtcTimestampSchema,
-    stream: z.boolean().optional(),
+    /** BCP 47 tag of the language the brief is written in; English when absent. */
+    locale: z.string().regex(/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/).max(35).optional(),
 }).strict().superRefine((value, context) => {
     const durationMs = Date.parse(value.endAt) - Date.parse(value.startAt);
     if (!Number.isFinite(durationMs) || durationMs <= 0) {
@@ -79,6 +80,36 @@ export const inboxNaturalSearchResponseSchema = z.object({
     }).strict(),
     interpretation: z.string().max(1000),
 }).strict();
+/** Where the brief puts a message: it asks something of the owner, it is today's news, or it is still unread from before. */
+export const INBOX_DAILY_BRIEF_SECTIONS = ['needs_you', 'today', 'earlier'];
+/**
+ * The Daily Brief as data, so a client draws it rather than printing a wall of
+ * text: a short summary, then the messages it mentions — each with the
+ * server's own copy of its sender, subject, time and unread state, so a client
+ * can show and open it, and a one-line note of why it matters.
+ */
+export const inboxDailyBriefResponseSchema = z.object({
+    schemaVersion: z.literal(1),
+    requestId: z.string().min(1).max(128),
+    generationId: z.string().min(1).max(128).optional(),
+    summary: z.string().max(400),
+    counts: z.object({
+        received: z.number().int().nonnegative(),
+        unread: z.number().int().nonnegative(),
+        starred: z.number().int().nonnegative(),
+        earlierUnread: z.number().int().nonnegative(),
+    }).strict(),
+    items: z.array(z.object({
+        messageId: inboxMessageIdSchema,
+        section: z.enum(INBOX_DAILY_BRIEF_SECTIONS),
+        note: z.string().max(200),
+        from: z.object({ name: z.string().max(998).nullable(), address: z.string().max(320) }).strict(),
+        subject: z.string().max(998),
+        receivedAt: z.string().datetime(),
+        unread: z.boolean(),
+        hasAttachments: z.boolean(),
+    }).strict()).max(20),
+}).strict();
 export const inboxSmartRepliesResponseSchema = z.object({
     replies: z.array(z.string().trim().min(1).max(500)).max(3),
 }).strict();

package/dist/esm/inference/providerConnection.js

@@ -92,8 +92,7 @@ function isVisibleASCIIProviderCredential(value) {
             return false;
         const finalQuartet = offset + 4 === value.length;
         if (finalQuartet &&
-            ((padding === 2 && (second & 0x0f) !== 0) ||
-                (padding === 1 && (third & 0x03) !== 0))) {
+            ((padding === 2 && (second & 0x0f) !== 0) || (padding === 1 && (third & 0x03) !== 0))) {
             return false;
         }
         const packed = (first << 18) | (second << 12) | (third << 6) | fourth;
@@ -131,7 +130,11 @@ export const kaanaCredentialRotateMutationSchema = kaanaCredentialIdentitySchema
     operationId: kaanaCredentialOperationIdSchema,
     operationActor: kaanaCredentialOperationActorSchema,
     credentialHandle: kaanaCredentialHandleSchema,
-    expectedRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER - 1),
+    expectedRevision: z
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER - 1),
     secretBase64: kaanaCredentialSecretBase64Schema,
 })
     .strict();
@@ -142,7 +145,11 @@ export const kaanaCredentialRevokeMutationSchema = kaanaCredentialIdentitySchema
     operationId: kaanaCredentialOperationIdSchema,
     operationActor: kaanaCredentialOperationActorSchema,
     credentialHandle: kaanaCredentialHandleSchema,
-    expectedRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER - 1),
+    expectedRevision: z
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER - 1),
 })
     .strict();
 export const kaanaCredentialMutationSchema = z.discriminatedUnion('action', [
@@ -163,7 +170,11 @@ export const kaanaCredentialRotateOutcomeRequestSchema = kaanaCredentialIdentity
     action: z.literal('rotate'),
     operationId: kaanaCredentialOperationIdSchema,
     credentialHandle: kaanaCredentialHandleSchema,
-    expectedRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER - 1),
+    expectedRevision: z
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER - 1),
 })
     .strict();
 export const kaanaCredentialRevokeOutcomeRequestSchema = kaanaCredentialIdentitySchema
@@ -172,7 +183,11 @@ export const kaanaCredentialRevokeOutcomeRequestSchema = kaanaCredentialIdentity
     action: z.literal('revoke'),
     operationId: kaanaCredentialOperationIdSchema,
     credentialHandle: kaanaCredentialHandleSchema,
-    expectedRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER - 1),
+    expectedRevision: z
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER - 1),
 })
     .strict();
 export const kaanaCredentialOutcomeRequestSchema = z.discriminatedUnion('action', [