@kaana.ai/contracts 0.0.0-stage → 4.4.0

package/dist/internal/decisions.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Kaana's typed decisions result and failure on the signed lane.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/decisions.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+export declare const decisionResultSchema: z.ZodObject<{
+    usage: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        requestId: z.ZodString;
+        generationId: z.ZodOptional<z.ZodString>;
+        attribution: z.ZodObject<{
+            principal: z.ZodObject<{
+                billing: z.ZodObject<{
+                    accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+                }, z.core.$strict>;
+                applicationId: z.ZodString;
+                credentialId: z.ZodString;
+                environment: z.ZodEnum<{
+                    development: "development";
+                    staging: "staging";
+                    production: "production";
+                }>;
+                inferenceScopes: z.ZodArray<z.ZodEnum<{
+                    "inference:invoke": "inference:invoke";
+                    "inference:models:read": "inference:models:read";
+                    "inference:usage:read": "inference:usage:read";
+                    "inference:routing:read": "inference:routing:read";
+                    "inference:routing:write": "inference:routing:write";
+                    "inference:providers:read": "inference:providers:read";
+                    "inference:providers:write": "inference:providers:write";
+                }>>;
+            }, z.core.$strip>;
+            userId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
+            requestId: z.ZodString;
+            generationId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            partial: "partial";
+            failed: "failed";
+        }>;
+        units: z.ZodArray<z.ZodObject<{
+            unit: z.ZodEnum<{
+                input_tokens: "input_tokens";
+                cached_input_tokens: "cached_input_tokens";
+                output_tokens: "output_tokens";
+                reasoning_tokens: "reasoning_tokens";
+                requests: "requests";
+                images: "images";
+                audio_input_milliseconds: "audio_input_milliseconds";
+                audio_output_milliseconds: "audio_output_milliseconds";
+                video_milliseconds: "video_milliseconds";
+                characters: "characters";
+                embeddings: "embeddings";
+                audio_input_tokens: "audio_input_tokens";
+                cached_audio_input_tokens: "cached_audio_input_tokens";
+                audio_output_tokens: "audio_output_tokens";
+                session_milliseconds: "session_milliseconds";
+                input_transcription_milliseconds: "input_transcription_milliseconds";
+            }>;
+            quantity: z.ZodNumber;
+        }, z.core.$strict>>;
+        usageSource: z.ZodEnum<{
+            provider_reported: "provider_reported";
+            oxy_measured: "oxy_measured";
+            estimated: "estimated";
+        }>;
+        resolvedModelReference: z.ZodString;
+        servingProvider: z.ZodString;
+        deploymentId: z.ZodString;
+        routeSwitches: z.ZodNumber;
+        fundingTier: z.ZodOptional<z.ZodEnum<{
+            free: "free";
+            credit: "credit";
+            paid: "paid";
+        }>>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        timeToFirstTokenMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    model: z.ZodString;
+    data: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"choice">;
+        reply: z.ZodString;
+        confidence: z.ZodNumber;
+        probabilities: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"score">;
+        reply: z.ZodNumber;
+        confidence: z.ZodNumber;
+        mean: z.ZodNumber;
+        distribution: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"noul">;
+        probability: z.ZodNumber;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+/**
+ * Kaana's typed decisions failure. `usage` is present only when the provider
+ * measured something before failing; its absence means nothing was measured,
+ * never that the cost was zero. A failure carrying usage did execute.
+ */
+export declare const decisionFailureSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    error: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        code: z.ZodEnum<{
+            invalid_request: "invalid_request";
+            authentication_failed: "authentication_failed";
+            permission_denied: "permission_denied";
+            insufficient_scope: "insufficient_scope";
+            model_not_found: "model_not_found";
+            unsupported_modality: "unsupported_modality";
+            context_length_exceeded: "context_length_exceeded";
+            request_too_large: "request_too_large";
+            output_limit_exceeded: "output_limit_exceeded";
+            idempotency_conflict: "idempotency_conflict";
+            insufficient_balance: "insufficient_balance";
+            spending_limit_exceeded: "spending_limit_exceeded";
+            quota_exceeded: "quota_exceeded";
+            byok_credential_invalid: "byok_credential_invalid";
+            policy_violation: "policy_violation";
+            commercial_permission_denied: "commercial_permission_denied";
+            no_route_available: "no_route_available";
+            upstream_content_filtered: "upstream_content_filtered";
+            cancelled: "cancelled";
+            rate_limited: "rate_limited";
+            provider_error: "provider_error";
+            provider_timeout: "provider_timeout";
+            provider_overloaded: "provider_overloaded";
+            service_unavailable: "service_unavailable";
+            internal_error: "internal_error";
+            deployment_unavailable: "deployment_unavailable";
+            provider_credential_invalid: "provider_credential_invalid";
+            provider_billing_refused: "provider_billing_refused";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        requestId: z.ZodString;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        param: z.ZodOptional<z.ZodString>;
+        upstreamCategory: z.ZodOptional<z.ZodEnum<{
+            rate_limit: "rate_limit";
+            quota: "quota";
+            timeout: "timeout";
+            overloaded: "overloaded";
+            server_error: "server_error";
+            content_filter: "content_filter";
+            invalid_request: "invalid_request";
+            authentication: "authentication";
+            unknown: "unknown";
+        }>>;
+        providerError: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            status: z.ZodOptional<z.ZodNumber>;
+            code: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+    usage: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        requestId: z.ZodString;
+        generationId: z.ZodOptional<z.ZodString>;
+        attribution: z.ZodObject<{
+            principal: z.ZodObject<{
+                billing: z.ZodObject<{
+                    accountId: z.core.$ZodBranded<z.ZodString, "OxyAccountId", "out">;
+                }, z.core.$strict>;
+                applicationId: z.ZodString;
+                credentialId: z.ZodString;
+                environment: z.ZodEnum<{
+                    development: "development";
+                    staging: "staging";
+                    production: "production";
+                }>;
+                inferenceScopes: z.ZodArray<z.ZodEnum<{
+                    "inference:invoke": "inference:invoke";
+                    "inference:models:read": "inference:models:read";
+                    "inference:usage:read": "inference:usage:read";
+                    "inference:routing:read": "inference:routing:read";
+                    "inference:routing:write": "inference:routing:write";
+                    "inference:providers:read": "inference:providers:read";
+                    "inference:providers:write": "inference:providers:write";
+                }>>;
+            }, z.core.$strip>;
+            userId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
+            requestId: z.ZodString;
+            generationId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            partial: "partial";
+            failed: "failed";
+        }>;
+        units: z.ZodArray<z.ZodObject<{
+            unit: z.ZodEnum<{
+                input_tokens: "input_tokens";
+                cached_input_tokens: "cached_input_tokens";
+                output_tokens: "output_tokens";
+                reasoning_tokens: "reasoning_tokens";
+                requests: "requests";
+                images: "images";
+                audio_input_milliseconds: "audio_input_milliseconds";
+                audio_output_milliseconds: "audio_output_milliseconds";
+                video_milliseconds: "video_milliseconds";
+                characters: "characters";
+                embeddings: "embeddings";
+                audio_input_tokens: "audio_input_tokens";
+                cached_audio_input_tokens: "cached_audio_input_tokens";
+                audio_output_tokens: "audio_output_tokens";
+                session_milliseconds: "session_milliseconds";
+                input_transcription_milliseconds: "input_transcription_milliseconds";
+            }>;
+            quantity: z.ZodNumber;
+        }, z.core.$strict>>;
+        usageSource: z.ZodEnum<{
+            provider_reported: "provider_reported";
+            oxy_measured: "oxy_measured";
+            estimated: "estimated";
+        }>;
+        resolvedModelReference: z.ZodString;
+        servingProvider: z.ZodString;
+        deploymentId: z.ZodString;
+        routeSwitches: z.ZodNumber;
+        fundingTier: z.ZodOptional<z.ZodEnum<{
+            free: "free";
+            credit: "credit";
+            paid: "paid";
+        }>>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        timeToFirstTokenMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type DecisionResult = z.infer<typeof decisionResultSchema>;
+export type DecisionFailure = z.infer<typeof decisionFailureSchema>;

package/dist/internal/decisions.js

@@ -0,0 +1,69 @@
+/**
+ * Kaana's typed decisions result and failure on the signed lane.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/decisions.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+import { decisionAnswerSchema } from '../public/decisions.js';
+import { modelReferenceSchema, requestIdSchema } from '../public/identifiers.js';
+import { inferenceErrorSchema } from './errors.js';
+import { normalizedUsageReportSchema } from './usage.js';
+const resultFields = {
+    schemaVersion: z.literal(1),
+    requestId: requestIdSchema,
+    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.',
+        });
+}
+export const decisionResultSchema = z
+    .object({ ...resultFields, usage: normalizedUsageReportSchema })
+    .strict()
+    .superRefine(uniqueAnswers)
+    .superRefine((result, ctx) => {
+    if (result.usage.requestId !== result.requestId ||
+        result.usage.resolvedModelReference !== result.model ||
+        result.usage.outcome !== 'completed') {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['usage'],
+            message: 'Decision usage must describe this completed request and immutable model.',
+        });
+    }
+});
+/**
+ * Kaana's typed decisions failure. `usage` is present only when the provider
+ * measured something before failing; its absence means nothing was measured,
+ * never that the cost was zero. A failure carrying usage did execute.
+ */
+export const decisionFailureSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    requestId: requestIdSchema,
+    error: inferenceErrorSchema,
+    usage: normalizedUsageReportSchema.optional(),
+})
+    .strict()
+    .superRefine((failure, ctx) => {
+    if (failure.error.requestId !== failure.requestId) {
+        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.',
+        });
+    }
+});

package/dist/internal/economics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * How a grant is treated economically.
+ *
+ * The treatment is decided by Oxy from the AUTHENTICATED application, its
+ * environment and lane, against a versioned policy; nothing a caller sends can
+ * select it, so it appears only on the signed grant, never on a public request.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/economics.ts`) by Kaana
+ * ADR 0002, which adds `platform_fee_only` (decision 4: a BYOK request, billed
+ * by the provider to the customer, on which Oxy charges only its fee; until now
+ * a receipt flag). Cost-centre usage and the metered generation read model stay
+ * in `@oxy.so/contracts`.
+ */
+import { z } from 'zod';
+/**
+ * - `commercial` — the default: reserve, settle, refund.
+ * - `internal_metered` — a product relationship Oxy configured (Alia on Kaana,
+ *   the Jev classifier): no hold and no receipt, usage still recorded.
+ * - `platform_fee_only` — BYOK: the provider bills the customer's own account.
+ */
+export declare const INFERENCE_ECONOMIC_TREATMENTS: readonly ["commercial", "internal_metered", "platform_fee_only"];
+export declare const inferenceEconomicTreatmentSchema: z.ZodEnum<{
+    commercial: "commercial";
+    internal_metered: "internal_metered";
+    platform_fee_only: "platform_fee_only";
+}>;
+export type InferenceEconomicTreatment = z.infer<typeof inferenceEconomicTreatmentSchema>;

package/dist/internal/economics.js

@@ -0,0 +1,26 @@
+/**
+ * How a grant is treated economically.
+ *
+ * The treatment is decided by Oxy from the AUTHENTICATED application, its
+ * environment and lane, against a versioned policy; nothing a caller sends can
+ * select it, so it appears only on the signed grant, never on a public request.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/economics.ts`) by Kaana
+ * ADR 0002, which adds `platform_fee_only` (decision 4: a BYOK request, billed
+ * by the provider to the customer, on which Oxy charges only its fee; until now
+ * a receipt flag). Cost-centre usage and the metered generation read model stay
+ * in `@oxy.so/contracts`.
+ */
+import { z } from 'zod';
+/**
+ * - `commercial` — the default: reserve, settle, refund.
+ * - `internal_metered` — a product relationship Oxy configured (Alia on Kaana,
+ *   the Jev classifier): no hold and no receipt, usage still recorded.
+ * - `platform_fee_only` — BYOK: the provider bills the customer's own account.
+ */
+export const INFERENCE_ECONOMIC_TREATMENTS = [
+    'commercial',
+    'internal_metered',
+    'platform_fee_only',
+];
+export const inferenceEconomicTreatmentSchema = z.enum(INFERENCE_ECONOMIC_TREATMENTS);

package/dist/internal/embeddings.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Kaana's embeddings result, as Oxy reads it from the signed lane.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/embeddings.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+export declare const embeddingVectorSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    embedding: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const embeddingUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+}, z.core.$strict>;
+export declare const embeddingSuccessSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    model: z.ZodString;
+    dimension: z.ZodNumber;
+    data: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        embedding: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const embeddingFailureSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    error: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        code: z.ZodEnum<{
+            invalid_request: "invalid_request";
+            authentication_failed: "authentication_failed";
+            permission_denied: "permission_denied";
+            insufficient_scope: "insufficient_scope";
+            model_not_found: "model_not_found";
+            unsupported_modality: "unsupported_modality";
+            context_length_exceeded: "context_length_exceeded";
+            request_too_large: "request_too_large";
+            output_limit_exceeded: "output_limit_exceeded";
+            idempotency_conflict: "idempotency_conflict";
+            insufficient_balance: "insufficient_balance";
+            spending_limit_exceeded: "spending_limit_exceeded";
+            quota_exceeded: "quota_exceeded";
+            byok_credential_invalid: "byok_credential_invalid";
+            policy_violation: "policy_violation";
+            commercial_permission_denied: "commercial_permission_denied";
+            no_route_available: "no_route_available";
+            upstream_content_filtered: "upstream_content_filtered";
+            cancelled: "cancelled";
+            rate_limited: "rate_limited";
+            provider_error: "provider_error";
+            provider_timeout: "provider_timeout";
+            provider_overloaded: "provider_overloaded";
+            service_unavailable: "service_unavailable";
+            internal_error: "internal_error";
+            deployment_unavailable: "deployment_unavailable";
+            provider_credential_invalid: "provider_credential_invalid";
+            provider_billing_refused: "provider_billing_refused";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        requestId: z.ZodString;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        param: z.ZodOptional<z.ZodString>;
+        upstreamCategory: z.ZodOptional<z.ZodEnum<{
+            rate_limit: "rate_limit";
+            quota: "quota";
+            timeout: "timeout";
+            overloaded: "overloaded";
+            server_error: "server_error";
+            content_filter: "content_filter";
+            invalid_request: "invalid_request";
+            authentication: "authentication";
+            unknown: "unknown";
+        }>>;
+        providerError: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            status: z.ZodOptional<z.ZodNumber>;
+            code: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export declare const embeddingResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    model: z.ZodString;
+    dimension: z.ZodNumber;
+    data: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        embedding: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    error: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        code: z.ZodEnum<{
+            invalid_request: "invalid_request";
+            authentication_failed: "authentication_failed";
+            permission_denied: "permission_denied";
+            insufficient_scope: "insufficient_scope";
+            model_not_found: "model_not_found";
+            unsupported_modality: "unsupported_modality";
+            context_length_exceeded: "context_length_exceeded";
+            request_too_large: "request_too_large";
+            output_limit_exceeded: "output_limit_exceeded";
+            idempotency_conflict: "idempotency_conflict";
+            insufficient_balance: "insufficient_balance";
+            spending_limit_exceeded: "spending_limit_exceeded";
+            quota_exceeded: "quota_exceeded";
+            byok_credential_invalid: "byok_credential_invalid";
+            policy_violation: "policy_violation";
+            commercial_permission_denied: "commercial_permission_denied";
+            no_route_available: "no_route_available";
+            upstream_content_filtered: "upstream_content_filtered";
+            cancelled: "cancelled";
+            rate_limited: "rate_limited";
+            provider_error: "provider_error";
+            provider_timeout: "provider_timeout";
+            provider_overloaded: "provider_overloaded";
+            service_unavailable: "service_unavailable";
+            internal_error: "internal_error";
+            deployment_unavailable: "deployment_unavailable";
+            provider_credential_invalid: "provider_credential_invalid";
+            provider_billing_refused: "provider_billing_refused";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        requestId: z.ZodString;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        param: z.ZodOptional<z.ZodString>;
+        upstreamCategory: z.ZodOptional<z.ZodEnum<{
+            rate_limit: "rate_limit";
+            quota: "quota";
+            timeout: "timeout";
+            overloaded: "overloaded";
+            server_error: "server_error";
+            content_filter: "content_filter";
+            invalid_request: "invalid_request";
+            authentication: "authentication";
+            unknown: "unknown";
+        }>>;
+        providerError: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            status: z.ZodOptional<z.ZodNumber>;
+            code: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+}, z.core.$strict>]>;
+export type EmbeddingVector = z.infer<typeof embeddingVectorSchema>;
+export type EmbeddingUsage = z.infer<typeof embeddingUsageSchema>;
+export type EmbeddingSuccess = z.infer<typeof embeddingSuccessSchema>;
+export type EmbeddingFailure = z.infer<typeof embeddingFailureSchema>;
+export type EmbeddingResponse = z.infer<typeof embeddingResponseSchema>;

package/dist/internal/embeddings.js

@@ -0,0 +1,59 @@
+/**
+ * Kaana's embeddings result, as Oxy reads it from the signed lane.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/embeddings.ts`) by Kaana ADR 0002.
+ */
+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) => {
+    const indexes = new Set();
+    for (const [position, vector] of result.data.entries()) {
+        if (vector.embedding.length !== result.dimension)
+            context.addIssue({
+                code: 'custom',
+                path: ['data', position, 'embedding'],
+                message: 'embedding length must equal dimension',
+            });
+        if (indexes.has(vector.index))
+            context.addIssue({
+                code: '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 embeddingResponseSchema = z.union([embeddingSuccessSchema, embeddingFailureSchema]);