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

package/dist/esm/inference/realtime.js

@@ -83,15 +83,15 @@
  *
  * Decided in: OxyHQ/Kaana#90.
  */
-import { z } from "zod";
-import { inferenceAttributionSchema } from "./attribution.js";
-import { realtimeSessionKindSchema, realtimeSessionTransportSchema, } from "./catalogue.js";
-import { inferenceErrorSchema } from "./errors.js";
-import { deploymentIdSchema, inferenceProviderSlugSchema, inferenceTimestampSchema, modelReferenceSchema, PADDED_BASE64_PATTERN, requestIdSchema, } from "./identifiers.js";
-import { usageQuantitySchema, usageSourceSchema } from "./money.js";
-import { toolChoiceSchema, toolDefinitionSchema } from "./request.js";
-import { authorizedRouteSchema, routingPolicyReferenceSchema, } from "./routingPolicy.js";
-import { inferenceFinishReasonSchema } from "./streamEvents.js";
+import { z } from 'zod';
+import { inferenceAttributionSchema } from './attribution.js';
+import { realtimeSessionKindSchema, realtimeSessionTransportSchema } from './catalogue.js';
+import { inferenceErrorSchema } from './errors.js';
+import { deploymentIdSchema, inferenceProviderSlugSchema, inferenceTimestampSchema, modelReferenceSchema, PADDED_BASE64_PATTERN, requestIdSchema, } from './identifiers.js';
+import { usageQuantitySchema, usageSourceSchema } from './money.js';
+import { toolChoiceSchema, toolDefinitionSchema } from './request.js';
+import { authorizedRouteSchema, routingPolicyReferenceSchema } from './routingPolicy.js';
+import { inferenceFinishReasonSchema } from './streamEvents.js';
 /* -------------------------------------------------------------------------- */
 /*  Bounds                                                                    */
 /* -------------------------------------------------------------------------- */
@@ -125,13 +125,9 @@ export const realtimeResponseIdSchema = z.string().min(1).max(128);
  * The audio encodings a session carries, in both directions. Named by what they
  * ARE (sample format, rate) because a realtime stream has no container to say so.
  */
-export const realtimeAudioFormatSchema = z.enum([
-    "pcm16_24khz",
-    "g711_ulaw",
-    "g711_alaw",
-]);
+export const realtimeAudioFormatSchema = z.enum(['pcm16_24khz', 'g711_ulaw', 'g711_alaw']);
 /** What a session's responses produce. */
-export const realtimeOutputModalitySchema = z.enum(["text", "audio"]);
+export const realtimeOutputModalitySchema = z.enum(['text', 'audio']);
 const audioFrameSchema = z
     .string()
     .min(4)
@@ -151,11 +147,11 @@ const milliseconds = z.number().int().nonnegative().safe();
  * off, are the two behaviours a caller most needs to have chosen, and a default
  * would choose them silently — and differently per provider.
  */
-export const realtimeTurnDetectionSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("none") }).strict(),
+export const realtimeTurnDetectionSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('none') }).strict(),
     z
         .object({
-        type: z.literal("server_vad"),
+        type: z.literal('server_vad'),
         threshold: z.number().min(0).max(1).optional(),
         prefixPaddingMs: z.number().int().min(0).max(5000).optional(),
         silenceDurationMs: z.number().int().min(0).max(10000).optional(),
@@ -165,8 +161,8 @@ export const realtimeTurnDetectionSchema = z.discriminatedUnion("type", [
         .strict(),
     z
         .object({
-        type: z.literal("semantic_vad"),
-        eagerness: z.enum(["low", "medium", "high", "auto"]),
+        type: z.literal('semantic_vad'),
+        eagerness: z.enum(['low', 'medium', 'high', 'auto']),
         createResponse: z.boolean(),
         interruptResponse: z.boolean(),
     })
@@ -241,7 +237,7 @@ export const realtimeSessionConfigUpdateSchema = z
     if (Object.keys(update).length === 0) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: "a session update changes at least one field",
+            message: 'a session update changes at least one field',
         });
     }
 });
@@ -277,7 +273,7 @@ export const realtimeClientMetadataSchema = z
 /*  The session request                                                       */
 /* -------------------------------------------------------------------------- */
 const modelLineOf = (reference) => {
-    const at = reference.indexOf("@");
+    const at = reference.indexOf('@');
     return at === -1 ? reference : reference.slice(0, at);
 };
 /**
@@ -302,72 +298,83 @@ export const realtimeSessionRequestSchema = z
     const { config } = request;
     const issue = (path, message) => ctx.addIssue({ code: z.ZodIssueCode.custom, path, message });
     if (request.limits.idleTimeoutMs > request.limits.maxDurationMs) {
-        issue(["limits", "idleTimeoutMs"], "an idle timeout cannot outlast the session");
+        issue(['limits', 'idleTimeoutMs'], 'an idle timeout cannot outlast the session');
     }
-    const producesAudio = config.outputModalities?.includes("audio") === true;
+    const producesAudio = config.outputModalities?.includes('audio') === true;
     const hasTools = config.tools !== undefined && config.tools.length > 0;
     switch (request.kind) {
-        case "conversation":
+        case 'conversation':
             if (config.outputModalities === undefined) {
-                issue(["config", "outputModalities"], "a conversation names what its responses produce");
+                issue(['config', 'outputModalities'], 'a conversation names what its responses produce');
             }
-            if (producesAudio && (config.voice === undefined || config.outputAudioFormat === undefined)) {
-                issue(["config"], "spoken responses need a voice and an output audio format");
+            if (producesAudio &&
+                (config.voice === undefined || config.outputAudioFormat === undefined)) {
+                issue(['config'], 'spoken responses need a voice and an output audio format');
             }
             if (config.translation !== undefined) {
-                issue(["config", "translation"], "only a translation session translates");
+                issue(['config', 'translation'], 'only a translation session translates');
             }
             break;
-        case "transcription":
+        case 'transcription':
             if (config.inputAudioTranscription === undefined) {
-                issue(["config", "inputAudioTranscription"], "a transcription session transcribes its input");
+                issue(['config', 'inputAudioTranscription'], 'a transcription session transcribes its input');
             }
-            for (const field of ["outputModalities", "voice", "outputAudioFormat", "translation", "tools", "toolChoice", "maxOutputTokens"]) {
+            for (const field of [
+                'outputModalities',
+                'voice',
+                'outputAudioFormat',
+                'translation',
+                'tools',
+                'toolChoice',
+                'maxOutputTokens',
+            ]) {
                 if (config[field] !== undefined) {
-                    issue(["config", field], "a transcription session never responds");
+                    issue(['config', field], 'a transcription session never responds');
                 }
             }
-            if (config.turnDetection.type !== "none" && (config.turnDetection.createResponse || config.turnDetection.interruptResponse)) {
-                issue(["config", "turnDetection"], "a transcription session has no response to create or interrupt");
+            if (config.turnDetection.type !== 'none' &&
+                (config.turnDetection.createResponse || config.turnDetection.interruptResponse)) {
+                issue(['config', 'turnDetection'], 'a transcription session has no response to create or interrupt');
             }
             break;
-        case "translation":
+        case 'translation':
             if (config.translation === undefined || config.outputAudioFormat === undefined) {
-                issue(["config"], "a translation session names its target language and output audio format");
+                issue(['config'], 'a translation session names its target language and output audio format');
             }
             if (config.tools !== undefined || config.toolChoice !== undefined) {
-                issue(["config", "tools"], "a translation session calls no tools");
+                issue(['config', 'tools'], 'a translation session calls no tools');
             }
             break;
     }
     if (config.toolChoice !== undefined && !hasTools) {
-        issue(["config", "toolChoice"], "a tool choice requires at least one tool definition");
+        issue(['config', 'toolChoice'], 'a tool choice requires at least one tool definition');
     }
     if (config.tools !== undefined) {
         const names = config.tools.map((tool) => tool.name);
         if (new Set(names).size !== names.length) {
-            issue(["config", "tools"], "tool names must be unique within one session");
+            issue(['config', 'tools'], 'tool names must be unique within one session');
         }
     }
-    if (config.outputModalities !== undefined && new Set(config.outputModalities).size !== config.outputModalities.length) {
-        issue(["config", "outputModalities"], "each output modality is named at most once");
+    if (config.outputModalities !== undefined &&
+        new Set(config.outputModalities).size !== config.outputModalities.length) {
+        issue(['config', 'outputModalities'], 'each output modality is named at most once');
     }
     // A session is never substituted: the conversation it holds belongs to one
     // model, so every route serves the line the caller named, and a pinned
     // request is served on exactly the revision it pinned.
     const line = modelLineOf(request.modelReference);
-    const pinned = request.modelReference.includes("@");
+    const pinned = request.modelReference.includes('@');
     for (const [index, route] of request.authorizedRoutes.entries()) {
-        if (route.substitution !== "same_model" || modelLineOf(route.modelReference) !== line) {
-            issue(["authorizedRoutes", index], "every route of a session serves the model it named");
+        if (route.substitution !== 'same_model' || modelLineOf(route.modelReference) !== line) {
+            issue(['authorizedRoutes', index], 'every route of a session serves the model it named');
         }
         if (pinned && route.modelReference !== request.modelReference) {
-            issue(["authorizedRoutes", index, "modelReference"], "a pinned session is served on exactly the revision it pinned");
+            issue(['authorizedRoutes', index, 'modelReference'], 'a pinned session is served on exactly the revision it pinned');
         }
     }
     const deployments = request.authorizedRoutes.map((route) => route.deploymentId);
     if (new Set(deployments).size !== deployments.length) {
-        issue(["authorizedRoutes"], "each deployment appears at most once in the authorized route list");
+        issue(['authorizedRoutes'], 'each deployment appears at most once in the authorized route list');
     }
 });
 /* -------------------------------------------------------------------------- */
@@ -380,26 +387,26 @@ export const realtimeSessionRequestSchema = z
  * never does — spoken output arrives as `output_audio.delta` events, and an
  * item echoing it carries only the format and, once known, the transcript.
  */
-export const realtimeContentPartSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("input_text"), text: z.string().max(1048576) }).strict(),
+export const realtimeContentPartSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('input_text'), text: z.string().max(1048576) }).strict(),
     z
         .object({
-        type: z.literal("input_audio"),
+        type: z.literal('input_audio'),
         format: realtimeAudioFormatSchema,
         data: audioFrameSchema.optional(),
         transcript: z.string().optional(),
     })
         .strict(),
-    z.object({ type: z.literal("output_text"), text: z.string() }).strict(),
+    z.object({ type: z.literal('output_text'), text: z.string() }).strict(),
     z
         .object({
-        type: z.literal("output_audio"),
+        type: z.literal('output_audio'),
         format: realtimeAudioFormatSchema,
         transcript: z.string().optional(),
     })
         .strict(),
 ]);
-const INPUT_PARTS = new Set(["input_text", "input_audio"]);
+const INPUT_PARTS = new Set(['input_text', 'input_audio']);
 /**
  * One item of the conversation a session holds.
  *
@@ -407,18 +414,18 @@ const INPUT_PARTS = new Set(["input_text", "input_audio"]);
  * is always stated by the server on the events that carry an item.
  */
 export const realtimeConversationItemSchema = z
-    .discriminatedUnion("type", [
+    .discriminatedUnion('type', [
     z
         .object({
-        type: z.literal("message"),
+        type: z.literal('message'),
         itemId: realtimeItemIdSchema.optional(),
-        role: z.enum(["system", "user", "assistant"]),
+        role: z.enum(['system', 'user', 'assistant']),
         content: z.array(realtimeContentPartSchema).min(1).max(64),
     })
         .strict(),
     z
         .object({
-        type: z.literal("function_call"),
+        type: z.literal('function_call'),
         itemId: realtimeItemIdSchema.optional(),
         callId: z.string().min(1).max(128),
         name: z.string().min(1).max(128),
@@ -427,7 +434,7 @@ export const realtimeConversationItemSchema = z
         .strict(),
     z
         .object({
-        type: z.literal("function_call_output"),
+        type: z.literal('function_call_output'),
         itemId: realtimeItemIdSchema.optional(),
         callId: z.string().min(1).max(128),
         output: z.string().max(1048576),
@@ -435,24 +442,24 @@ export const realtimeConversationItemSchema = z
         .strict(),
 ])
     .superRefine((item, ctx) => {
-    if (item.type !== "message")
+    if (item.type !== 'message')
         return;
     for (const [index, part] of item.content.entries()) {
         const isInput = INPUT_PARTS.has(part.type);
         // A user or system turn is input; an assistant turn is output. A part on
         // the wrong side is one every provider would silently ignore.
-        if (item.role === "assistant" ? isInput : !isInput) {
+        if (item.role === 'assistant' ? isInput : !isInput) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                path: ["content", index, "type"],
+                path: ['content', index, 'type'],
                 message: `a ${item.role} message cannot carry ${part.type}`,
             });
         }
-        if (item.role === "system" && part.type !== "input_text") {
+        if (item.role === 'system' && part.type !== 'input_text') {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                path: ["content", index, "type"],
-                message: "a system message is text",
+                path: ['content', index, 'type'],
+                message: 'a system message is text',
             });
         }
     }
@@ -477,19 +484,19 @@ const commandBase = {
 };
 export const realtimeSessionUpdateCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("session.update"),
+    type: z.literal('session.update'),
     config: realtimeSessionConfigUpdateSchema,
 });
 export const realtimeItemCreateCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("conversation.item.create"),
+    type: z.literal('conversation.item.create'),
     /** Insert after this item; absent appends. */
     previousItemId: realtimeItemIdSchema.optional(),
     item: realtimeConversationItemSchema,
 });
 export const realtimeItemDeleteCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("conversation.item.delete"),
+    type: z.literal('conversation.item.delete'),
     itemId: realtimeItemIdSchema,
 });
 /**
@@ -499,33 +506,33 @@ export const realtimeItemDeleteCommandSchema = z.object({
  */
 export const realtimeItemTruncateCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("conversation.item.truncate"),
+    type: z.literal('conversation.item.truncate'),
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
     audioEndMs: milliseconds,
 });
 export const realtimeInputAudioAppendCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("input_audio.append"),
+    type: z.literal('input_audio.append'),
     /** One bounded frame in the session's `inputAudioFormat`. */
     data: audioFrameSchema,
 });
 export const realtimeInputAudioCommitCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("input_audio.commit"),
+    type: z.literal('input_audio.commit'),
 });
 export const realtimeInputAudioClearCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("input_audio.clear"),
+    type: z.literal('input_audio.clear'),
 });
 export const realtimeResponseCreateCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("response.create"),
+    type: z.literal('response.create'),
     response: realtimeResponseParametersSchema.optional(),
 });
 export const realtimeResponseCancelCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("response.cancel"),
+    type: z.literal('response.cancel'),
     /** Absent cancels the response in progress, if any. */
     responseId: realtimeResponseIdSchema.optional(),
 });
@@ -535,15 +542,15 @@ export const realtimeResponseCancelCommandSchema = z.object({
  */
 export const realtimeSessionResumeCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("session.resume"),
+    type: z.literal('session.resume'),
     afterSequence: z.number().int().min(-1).safe(),
 });
 export const realtimeSessionCloseCommandSchema = z.object({
     ...commandBase,
-    type: z.literal("session.close"),
+    type: z.literal('session.close'),
 });
 /** Every command a client can send. */
-export const realtimeClientCommandSchema = z.discriminatedUnion("type", [
+export const realtimeClientCommandSchema = z.discriminatedUnion('type', [
     realtimeSessionUpdateCommandSchema,
     realtimeItemCreateCommandSchema,
     realtimeItemDeleteCommandSchema,
@@ -576,7 +583,7 @@ const eventBase = {
  */
 export const realtimeSessionCreatedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("session.created"),
+    type: z.literal('session.created'),
     resolvedModelReference: modelReferenceSchema,
     servingProvider: inferenceProviderSlugSchema,
     deploymentId: deploymentIdSchema,
@@ -589,42 +596,42 @@ export const realtimeSessionCreatedEventSchema = z.object({
 });
 export const realtimeSessionUpdatedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("session.updated"),
+    type: z.literal('session.updated'),
     config: realtimeSessionConfigSchema,
 });
 export const realtimeSessionResumedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("session.resumed"),
+    type: z.literal('session.resumed'),
     afterSequence: z.number().int().min(-1).safe(),
 });
 /** Sent before a command is applied. `duplicate` means it was not applied again. */
 export const realtimeCommandAcceptedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("command.accepted"),
+    type: z.literal('command.accepted'),
     commandId: realtimeCommandIdSchema,
     duplicate: z.boolean(),
 });
 export const realtimeItemAddedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("conversation.item.added"),
+    type: z.literal('conversation.item.added'),
     itemId: realtimeItemIdSchema,
     previousItemId: realtimeItemIdSchema.optional(),
     item: realtimeConversationItemSchema,
 });
 export const realtimeItemDoneEventSchema = z.object({
     ...eventBase,
-    type: z.literal("conversation.item.done"),
+    type: z.literal('conversation.item.done'),
     itemId: realtimeItemIdSchema,
     item: realtimeConversationItemSchema,
 });
 export const realtimeItemDeletedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("conversation.item.deleted"),
+    type: z.literal('conversation.item.deleted'),
     itemId: realtimeItemIdSchema,
 });
 export const realtimeItemTruncatedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("conversation.item.truncated"),
+    type: z.literal('conversation.item.truncated'),
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
     audioEndMs: milliseconds,
@@ -636,35 +643,35 @@ export const realtimeItemTruncatedEventSchema = z.object({
  */
 export const realtimeSpeechStartedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("input_audio.speech_started"),
+    type: z.literal('input_audio.speech_started'),
     itemId: realtimeItemIdSchema,
     audioStartMs: milliseconds,
 });
 export const realtimeSpeechStoppedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("input_audio.speech_stopped"),
+    type: z.literal('input_audio.speech_stopped'),
     itemId: realtimeItemIdSchema,
     audioEndMs: milliseconds,
 });
 export const realtimeInputAudioCommittedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("input_audio.committed"),
+    type: z.literal('input_audio.committed'),
     itemId: realtimeItemIdSchema,
     previousItemId: realtimeItemIdSchema.optional(),
 });
 export const realtimeInputAudioClearedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("input_audio.cleared"),
+    type: z.literal('input_audio.cleared'),
 });
 export const realtimeResponseCreatedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("response.created"),
+    type: z.literal('response.created'),
     responseId: realtimeResponseIdSchema,
 });
 /** One bounded frame of spoken output, in the session's `outputAudioFormat`. */
 export const realtimeOutputAudioDeltaEventSchema = z.object({
     ...eventBase,
-    type: z.literal("output_audio.delta"),
+    type: z.literal('output_audio.delta'),
     responseId: realtimeResponseIdSchema,
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
@@ -673,7 +680,7 @@ export const realtimeOutputAudioDeltaEventSchema = z.object({
 });
 export const realtimeOutputAudioDoneEventSchema = z.object({
     ...eventBase,
-    type: z.literal("output_audio.done"),
+    type: z.literal('output_audio.done'),
     responseId: realtimeResponseIdSchema,
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
@@ -682,10 +689,10 @@ export const realtimeOutputAudioDoneEventSchema = z.object({
  * Which audio a transcript describes: the caller's (`input_audio`) or the
  * model's own speech (`output_audio`). Neither is answer text.
  */
-export const realtimeTranscriptSourceSchema = z.enum(["input_audio", "output_audio"]);
+export const realtimeTranscriptSourceSchema = z.enum(['input_audio', 'output_audio']);
 export const realtimeTranscriptDeltaEventSchema = z.object({
     ...eventBase,
-    type: z.literal("transcript.delta"),
+    type: z.literal('transcript.delta'),
     source: realtimeTranscriptSourceSchema,
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
@@ -695,7 +702,7 @@ export const realtimeTranscriptDeltaEventSchema = z.object({
 });
 export const realtimeTranscriptDoneEventSchema = z.object({
     ...eventBase,
-    type: z.literal("transcript.done"),
+    type: z.literal('transcript.done'),
     source: realtimeTranscriptSourceSchema,
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
@@ -705,7 +712,7 @@ export const realtimeTranscriptDoneEventSchema = z.object({
 /** Written output of a response (`outputModalities` including `text`). */
 export const realtimeTextDeltaEventSchema = z.object({
     ...eventBase,
-    type: z.literal("text.delta"),
+    type: z.literal('text.delta'),
     responseId: realtimeResponseIdSchema,
     itemId: realtimeItemIdSchema,
     contentIndex: z.number().int().nonnegative().safe(),
@@ -714,7 +721,7 @@ export const realtimeTextDeltaEventSchema = z.object({
 /** A tool call being streamed; same accumulation rules as the one-shot event. */
 export const realtimeToolCallEventSchema = z.object({
     ...eventBase,
-    type: z.literal("tool_call"),
+    type: z.literal('tool_call'),
     responseId: realtimeResponseIdSchema,
     itemId: realtimeItemIdSchema,
     toolCallId: z.string().min(1).max(128),
@@ -724,10 +731,10 @@ export const realtimeToolCallEventSchema = z.object({
 });
 /** How a response ended. */
 export const realtimeResponseStatusSchema = z.enum([
-    "completed",
-    "cancelled",
-    "incomplete",
-    "failed",
+    'completed',
+    'cancelled',
+    'incomplete',
+    'failed',
 ]);
 /**
  * A response ended, with the units it consumed — measurement evidence, as on
@@ -736,7 +743,7 @@ export const realtimeResponseStatusSchema = z.enum([
  */
 export const realtimeResponseDoneEventSchema = z.object({
     ...eventBase,
-    type: z.literal("response.done"),
+    type: z.literal('response.done'),
     responseId: realtimeResponseIdSchema,
     status: realtimeResponseStatusSchema,
     finishReason: inferenceFinishReasonSchema.optional(),
@@ -750,21 +757,21 @@ export const realtimeResponseDoneEventSchema = z.object({
  */
 export const realtimeErrorEventSchema = z.object({
     ...eventBase,
-    type: z.literal("error"),
+    type: z.literal('error'),
     fatal: z.boolean(),
     error: inferenceErrorSchema,
 });
 /** Why a session ended. */
 export const realtimeSessionCloseReasonSchema = z.enum([
-    "client_closed",
-    "max_duration",
-    "idle_timeout",
-    "limit_exceeded",
-    "resume_expired",
-    "upstream_closed",
-    "upstream_error",
-    "no_route_available",
-    "server_shutdown",
+    'client_closed',
+    'max_duration',
+    'idle_timeout',
+    'limit_exceeded',
+    'resume_expired',
+    'upstream_closed',
+    'upstream_error',
+    'no_route_available',
+    'server_shutdown',
 ]);
 /**
  * The terminal event. Carries the session's total units; `deploymentId` is
@@ -772,7 +779,7 @@ export const realtimeSessionCloseReasonSchema = z.enum([
  */
 export const realtimeSessionClosedEventSchema = z.object({
     ...eventBase,
-    type: z.literal("session.closed"),
+    type: z.literal('session.closed'),
     reason: realtimeSessionCloseReasonSchema,
     deploymentId: deploymentIdSchema.optional(),
     units: z.array(usageQuantitySchema),
@@ -781,7 +788,7 @@ export const realtimeSessionClosedEventSchema = z.object({
 });
 /** Every event a session can emit. */
 export const realtimeServerEventSchema = z
-    .discriminatedUnion("type", [
+    .discriminatedUnion('type', [
     realtimeSessionCreatedEventSchema,
     realtimeSessionUpdatedEventSchema,
     realtimeSessionResumedEventSchema,
@@ -809,14 +816,14 @@ export const realtimeServerEventSchema = z
     // Each unit is reported once, as a total — the rule every usage record in
     // this contract holds. Checked on the union because a discriminated union's
     // options must stay plain objects.
-    if (event.type !== "response.done" && event.type !== "session.closed")
+    if (event.type !== 'response.done' && event.type !== 'session.closed')
         return;
     const units = event.units.map((quantity) => quantity.unit);
     if (new Set(units).size !== units.length) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            path: ["units"],
-            message: "each unit is reported at most once",
+            path: ['units'],
+            message: 'each unit is reported at most once',
         });
     }
 });

package/dist/esm/inference/routingPolicy.js

@@ -32,7 +32,7 @@
  * docs/adr/0017-authorized-routes-in-the-envelope.md, issue #972 workstream 6.
  */
 import { z } from "zod";
-import { deploymentIdSchema, inferenceProviderSlugSchema, inferenceRegionSchema, inferenceTimestampSchema, modelReferenceSchema, oxyAccountIdSchema, oxyApplicationIdSchema, routingProfileIdSchema, } from "./identifiers.js";
+import { deploymentIdSchema, inferenceProviderSlugSchema, inferenceFundingTierSchema, inferenceRegionSchema, inferenceTimestampSchema, modelReferenceSchema, oxyAccountIdSchema, oxyApplicationIdSchema, routingProfileIdSchema, } from "./identifiers.js";
 import { kaanaCredentialHandleSchema } from "./providerConnection.js";
 import { exactDecimalSchema, currencyCodeSchema, unitPriceSchema, } from "./money.js";
 /**
@@ -291,6 +291,16 @@ const authorizedRouteFields = {
     modelReference: modelReferenceSchema,
     provider: inferenceProviderSlugSchema,
     regions: z.array(inferenceRegionSchema),
+    /**
+     * The dearest funding tier the data plane may spend on this route. Absent
+     * means no ceiling. Present, the data plane walks only provider keys whose
+     * STATED tier is at or below it — a key whose economics nobody stated is
+     * never admitted — and refuses the route rather than fall through to a
+     * dearer key. It is how Oxy authorizes a route only while credit funds it
+     * (Alia Pro and Ultra spend credits only, ADR 0038). Meaningless with a
+     * customer credential, which the provider bills to the customer.
+     */
+    maxFundingTier: inferenceFundingTierSchema.optional(),
     /**
      * Exact customer credential binding. Absence means a platform credential;
      * presence names the immutable Kaana generation this route may use.
@@ -345,6 +355,13 @@ export const authorizedRouteSchema = z
         .strict(),
 ])
     .superRefine((route, ctx) => {
+    if (route.maxFundingTier !== undefined && route.customerProviderCredential !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['maxFundingTier'],
+            message: 'a funding ceiling bounds platform keys; a customer credential is billed to the customer',
+        });
+    }
     // Same rule as `modelDeploymentSchema`: a route serves specific weights. An
     // unpinned entry would leave the data plane choosing a revision, which is
     // the one substitution the customer never authorized by naming a model.