@kaana.ai/contracts 8.1.0 → 8.3.0

package/dist/public/anthropicMessages.js

@@ -0,0 +1,274 @@
+/**
+ * `POST /v1/messages` — the Anthropic-Messages-compatible surface.
+ *
+ * It speaks the flat Anthropic request, response and stream shapes so an
+ * unmodified Anthropic SDK or Claude Code works with
+ * `ANTHROPIC_BASE_URL=https://kaana.ai` and an `oxy_sk_…` key (sent as
+ * `x-api-key` or as `Authorization: Bearer`). Like `/v1/chat/completions` it
+ * gains NO Kaana-specific request field, and it is `.strict()` everywhere: a
+ * stock SDK sending a parameter Kaana does not implement is told so rather than
+ * having it silently dropped.
+ *
+ * ## What is refused, and why
+ *
+ *  - **`cache_control`, anywhere** (on a block, a tool, `system` or the
+ *    request). Kaana's usage units have no unit for a cache WRITE (see the
+ *    Anthropic adapter's usage meter): a cache write is billed at a premium
+ *    over input, so honouring the marker while folding the write into
+ *    `input_tokens` would report less than the request cost. The marker is
+ *    refused, by name and path, instead of being dropped.
+ *  - **`thinking` other than `{ type: 'disabled' }`.** The contract's reasoning
+ *    control is an effort (`low`, `medium`, `high`), not a token budget, and a
+ *    thinking block has no part in a message: reasoning is private and is never
+ *    returned. Reasoning effort is asked with `output_config.effort`, which
+ *    maps one to one. A `thinking` or `redacted_thinking` block in a message is
+ *    refused for the same reason.
+ *  - **Server tools** (`web_search`, `bash`, `text_editor`, …), `mcp_servers`,
+ *    `container`, `service_tier`, `disable_parallel_tool_use`, `document`
+ *    blocks and any other member this file does not name.
+ *  - **An image `url` source**: nothing fetches an image URL (ADR 0007); a
+ *    `base64` source is carried inline under the image rules.
+ *
+ * `stop_reason: 'stop_sequence'` is never produced: the finish reason Kaana
+ * measures does not say WHICH stop sequence ended the turn, and `stop_sequence`
+ * would then have to name one. A turn that ended on a stop sequence reports
+ * `end_turn`.
+ *
+ * `metadata.user_id` is accepted and neither forwarded nor stored: it is an
+ * end-user identifier, and Kaana persists none.
+ *
+ * `usage` is derived from the measured units: `input_tokens`, `output_tokens`
+ * (reasoning included, as Anthropic counts it) and, only when the route
+ * measured it, `cache_read_input_tokens`. There is no `cache_creation_*`.
+ */
+import { z } from 'zod';
+import { maxUtf16Length, minUtf16Length } from '../stringBounds.js';
+import { reasoningEffortSchema } from './catalogue.js';
+import { modelTargetSchema } from './responses.js';
+const nonEmpty = (max) => z.string().check(minUtf16Length(1)).check(maxUtf16Length(max));
+const textBlockSchema = z.object({ type: z.literal('text'), text: z.string() }).strict();
+const imageBlockSchema = z
+    .object({
+    type: z.literal('image'),
+    source: z.discriminatedUnion('type', [
+        z
+            .object({
+            type: z.literal('base64'),
+            media_type: nonEmpty(255),
+            data: z.string().check(minUtf16Length(1)),
+        })
+            .strict(),
+        /** Parses so the refusal can name it; Kaana fetches no image URL. */
+        z.object({ type: z.literal('url'), url: nonEmpty(4096) }).strict(),
+    ]),
+})
+    .strict();
+const toolUseBlockSchema = z
+    .object({
+    type: z.literal('tool_use'),
+    id: nonEmpty(128),
+    name: nonEmpty(128),
+    input: z.record(z.string(), z.unknown()),
+})
+    .strict();
+const toolResultBlockSchema = z
+    .object({
+    type: z.literal('tool_result'),
+    tool_use_id: nonEmpty(128),
+    content: z
+        .union([z.string(), z.array(z.union([textBlockSchema, imageBlockSchema]))])
+        .optional(),
+    /**
+     * Accepted. The contract's tool message has no error flag, so the result's
+     * own content is what the model reads; the flag is not forwarded.
+     */
+    is_error: z.boolean().optional(),
+})
+    .strict();
+const messageSchema = z
+    .object({
+    role: z.enum(['user', 'assistant']),
+    content: z.union([
+        z.string(),
+        z
+            .array(z.union([textBlockSchema, imageBlockSchema, toolUseBlockSchema, toolResultBlockSchema]))
+            .min(1),
+    ]),
+})
+    .strict()
+    .superRefine((message, ctx) => {
+    if (typeof message.content === 'string')
+        return;
+    for (const [index, block] of message.content.entries()) {
+        const allowed = message.role === 'assistant'
+            ? block.type === 'text' || block.type === 'tool_use'
+            : block.type !== 'tool_use';
+        if (!allowed) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['content', index, 'type'],
+                message: `a ${message.role} message does not carry a ${block.type} block`,
+            });
+        }
+    }
+});
+const toolSchema = z
+    .object({
+    type: z.literal('custom').optional(),
+    name: nonEmpty(128),
+    description: z.string().check(maxUtf16Length(32768)).optional(),
+    input_schema: z.record(z.string(), z.unknown()),
+    strict: z.boolean().optional(),
+})
+    .strict();
+const toolChoiceSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('auto') }).strict(),
+    z.object({ type: z.literal('any') }).strict(),
+    z.object({ type: z.literal('none') }).strict(),
+    z.object({ type: z.literal('tool'), name: nonEmpty(128) }).strict(),
+]);
+export const anthropicMessagesRequestSchema = z
+    .object({
+    /** A model reference (`publisher/model[@revision]`) or a power level. */
+    model: modelTargetSchema,
+    /** Required, as Anthropic requires it. */
+    max_tokens: z.number().int().positive().safe(),
+    messages: z.array(messageSchema).min(1),
+    system: z.union([z.string(), z.array(textBlockSchema)]).optional(),
+    temperature: z.number().min(0).max(1).optional(),
+    top_p: z.number().min(0).max(1).optional(),
+    top_k: z.number().int().positive().safe().optional(),
+    stop_sequences: z.array(nonEmpty(256)).max(8).optional(),
+    stream: z.boolean().optional(),
+    tools: z.array(toolSchema).max(128).optional(),
+    tool_choice: toolChoiceSchema.optional(),
+    /** Only "off" is accepted: see the file comment. */
+    thinking: z
+        .object({ type: z.literal('disabled') })
+        .strict()
+        .optional(),
+    /** `effort` is the contract's reasoning effort; no other member is carried. */
+    output_config: z.object({ effort: reasoningEffortSchema.optional() }).strict().optional(),
+    /** Accepted and not forwarded or stored. */
+    metadata: z
+        .object({ user_id: z.string().check(maxUtf16Length(512)).nullable().optional() })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .superRefine((request, ctx) => {
+    if (request.tool_choice !== undefined && (request.tools ?? []).length === 0) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['tool_choice'],
+            message: 'a tool choice requires at least one tool definition',
+        });
+    }
+});
+const usageSchema = z
+    .object({
+    input_tokens: z.number().int().nonnegative(),
+    output_tokens: z.number().int().nonnegative(),
+    /** Present only when the route measured a cache read. */
+    cache_read_input_tokens: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const stopReasonSchema = z.enum(['end_turn', 'max_tokens', 'tool_use', 'refusal']);
+const outputBlockSchema = z.discriminatedUnion('type', [
+    textBlockSchema,
+    toolUseBlockSchema.extend({ input: z.record(z.string(), z.unknown()) }),
+]);
+const messageBodySchema = z.object({
+    id: nonEmpty(256),
+    type: z.literal('message'),
+    role: z.literal('assistant'),
+    /** The revision that served the request. */
+    model: nonEmpty(256),
+});
+/** The non-streaming body. The request id rides in `Kaana-Request-Id` and `Request-Id`. */
+export const anthropicMessageSchema = messageBodySchema
+    .extend({
+    content: z.array(outputBlockSchema),
+    stop_reason: stopReasonSchema,
+    stop_sequence: z.literal(null),
+    usage: usageSchema,
+})
+    .strict();
+/** The error body, and the data of a stream's `event: error` frame. */
+export const anthropicErrorSchema = z
+    .object({
+    type: z.literal('error'),
+    error: z
+        .object({
+        type: z.enum([
+            'invalid_request_error',
+            'authentication_error',
+            'billing_error',
+            'permission_error',
+            'not_found_error',
+            'request_too_large',
+            'rate_limit_error',
+            'timeout_error',
+            'overloaded_error',
+            'api_error',
+        ]),
+        message: nonEmpty(4096),
+    })
+        .strict(),
+    request_id: nonEmpty(256).optional(),
+})
+    .strict();
+/**
+ * One frame of a streamed message: `event: <type>` and this as its data. The
+ * input tokens are known only when the route reports usage, so `message_start`
+ * carries zeros and the final `message_delta` the measured totals. A stream that
+ * fails after its first frame ends with an `error` frame and no `message_stop`.
+ */
+export const anthropicStreamEventSchema = z.discriminatedUnion('type', [
+    z
+        .object({
+        type: z.literal('message_start'),
+        message: messageBodySchema
+            .extend({
+            content: z.array(outputBlockSchema).length(0),
+            stop_reason: z.literal(null),
+            stop_sequence: z.literal(null),
+            usage: usageSchema,
+        })
+            .strict(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal('content_block_start'),
+        index: z.number().int().nonnegative(),
+        content_block: z.discriminatedUnion('type', [
+            z.object({ type: z.literal('text'), text: z.literal('') }).strict(),
+            toolUseBlockSchema.extend({ input: z.object({}).strict() }),
+        ]),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal('content_block_delta'),
+        index: z.number().int().nonnegative(),
+        delta: z.discriminatedUnion('type', [
+            z.object({ type: z.literal('text_delta'), text: z.string() }).strict(),
+            z.object({ type: z.literal('input_json_delta'), partial_json: z.string() }).strict(),
+        ]),
+    })
+        .strict(),
+    z
+        .object({ type: z.literal('content_block_stop'), index: z.number().int().nonnegative() })
+        .strict(),
+    z
+        .object({
+        type: z.literal('message_delta'),
+        delta: z.object({ stop_reason: stopReasonSchema, stop_sequence: z.literal(null) }).strict(),
+        usage: usageSchema,
+    })
+        .strict(),
+    z.object({ type: z.literal('message_stop') }).strict(),
+    z.object({ type: z.literal('ping') }).strict(),
+    anthropicErrorSchema,
+]);

package/dist/public/chatCompletions.d.ts

@@ -21,9 +21,9 @@ import { z } from 'zod';
  */
 export declare const chatCompletionMessageSchema: z.ZodObject<{
     role: z.ZodEnum<{
-        user: "user";
         system: "system";
         developer: "developer";
+        user: "user";
         assistant: "assistant";
         tool: "tool";
     }>;
@@ -93,9 +93,9 @@ export declare const chatCompletionsRequestSchema: z.ZodObject<{
     }>]>;
     messages: z.ZodArray<z.ZodObject<{
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
             developer: "developer";
+            user: "user";
             assistant: "assistant";
             tool: "tool";
         }>;

package/dist/public/messages.d.ts

@@ -95,6 +95,61 @@ export declare const inferenceContentPartSchema: z.ZodDiscriminatedUnion<[z.ZodO
     type: z.ZodLiteral<"refusal">;
     text: z.ZodString;
 }, z.core.$strict>], "type">;
+/**
+ * The image formats a request may carry. Every provider that serves image input
+ * on a Kaana route reads these four: Anthropic (`image/jpeg`, `image/png`,
+ * `image/gif`, `image/webp`) and OpenAI (PNG, JPEG, WEBP, non-animated GIF).
+ */
+export declare const INPUT_IMAGE_MEDIA_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+/**
+ * The most image parts one request may carry, across every message. Above 20
+ * images Anthropic applies a stricter per-image dimension limit to EVERY image
+ * of the request, so 20 is the most a request can carry and keep one rule per
+ * image on every route.
+ */
+export declare const MAX_INPUT_IMAGES = 20;
+/**
+ * The most decoded bytes one image may carry: 3,750,000, whose base64 is
+ * 5,000,000 characters, the smallest per-image limit a provider serving these
+ * routes documents (Anthropic on Amazon Bedrock: 5 MB base64-encoded).
+ */
+export declare const MAX_INPUT_IMAGE_BYTES = 3750000;
+/** Why one image part cannot be carried, before anything is held. Never the image itself. */
+export interface ImageInputIssue {
+    /** The message, as its index in the request's message list. */
+    readonly messageIndex: number;
+    /** The part, as its index in that message's content; absent for the request-wide count. */
+    readonly partIndex?: number;
+    /** The field at fault, relative to the part. */
+    readonly field: 'role' | 'source' | 'source.mediaType' | 'source.data' | 'count';
+    readonly message: string;
+}
+/**
+ * Check the image parts of a conversation against the contract's image rules
+ * (Kaana ADR 0007). Kaana refuses a request with `invalid_request` and the first
+ * issue BEFORE it asks Oxy for a grant; Oxy applies the same rules on its own
+ * edge; a client may run it first.
+ *
+ *  - an image is `inline`: no component fetches an image URL, and a `url`
+ *    source is never forwarded to a provider to fetch either;
+ *  - its media type is one of {@link INPUT_IMAGE_MEDIA_TYPES};
+ *  - its data is canonical base64 of at most {@link MAX_INPUT_IMAGE_BYTES} bytes;
+ *  - it rides on a `user` or `tool` message;
+ *  - the request carries at most {@link MAX_INPUT_IMAGES} of them.
+ *
+ * Returns the number of image parts and every issue, in message order. An issue
+ * names where and why, never the bytes: an image is payload and is never echoed
+ * into an error, a log line or a record.
+ */
+export declare function checkImageInput(messages: readonly InferenceMessage[]): {
+    readonly images: number;
+    readonly issues: ImageInputIssue[];
+};
+/**
+ * The decoded length of canonical base64 (RFC 4648 section 4, padded, no line
+ * breaks), or `undefined` when the text is not that. Counted, never decoded.
+ */
+export declare function base64DecodedLength(data: string): number | undefined;
 /**
  * A tool call an assistant made, in the normalized form.
  *
@@ -108,9 +163,9 @@ export declare const inferenceToolCallSchema: z.ZodObject<{
     arguments: z.ZodString;
 }, z.core.$strict>;
 export declare const inferenceMessageRoleSchema: z.ZodEnum<{
-    user: "user";
     system: "system";
     developer: "developer";
+    user: "user";
     assistant: "assistant";
     tool: "tool";
 }>;
@@ -124,9 +179,9 @@ export declare const inferenceMessageRoleSchema: z.ZodEnum<{
  */
 export declare const inferenceMessageSchema: z.ZodObject<{
     role: z.ZodEnum<{
-        user: "user";
         system: "system";
         developer: "developer";
+        user: "user";
         assistant: "assistant";
         tool: "tool";
     }>;

package/dist/public/messages.js

@@ -86,6 +86,113 @@ export const inferenceContentPartSchema = z.discriminatedUnion('type', [
      */
     z.object({ type: z.literal('refusal'), text: z.string() }).strict(),
 ]);
+/* -------------------------------------------------------------------------- */
+/*  Image input (contract set 8.2.0, Kaana ADR 0007)                           */
+/* -------------------------------------------------------------------------- */
+/**
+ * The image formats a request may carry. Every provider that serves image input
+ * on a Kaana route reads these four: Anthropic (`image/jpeg`, `image/png`,
+ * `image/gif`, `image/webp`) and OpenAI (PNG, JPEG, WEBP, non-animated GIF).
+ */
+export const INPUT_IMAGE_MEDIA_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/gif',
+];
+/**
+ * The most image parts one request may carry, across every message. Above 20
+ * images Anthropic applies a stricter per-image dimension limit to EVERY image
+ * of the request, so 20 is the most a request can carry and keep one rule per
+ * image on every route.
+ */
+export const MAX_INPUT_IMAGES = 20;
+/**
+ * The most decoded bytes one image may carry: 3,750,000, whose base64 is
+ * 5,000,000 characters, the smallest per-image limit a provider serving these
+ * routes documents (Anthropic on Amazon Bedrock: 5 MB base64-encoded).
+ */
+export const MAX_INPUT_IMAGE_BYTES = 3_750_000;
+/**
+ * Check the image parts of a conversation against the contract's image rules
+ * (Kaana ADR 0007). Kaana refuses a request with `invalid_request` and the first
+ * issue BEFORE it asks Oxy for a grant; Oxy applies the same rules on its own
+ * edge; a client may run it first.
+ *
+ *  - an image is `inline`: no component fetches an image URL, and a `url`
+ *    source is never forwarded to a provider to fetch either;
+ *  - its media type is one of {@link INPUT_IMAGE_MEDIA_TYPES};
+ *  - its data is canonical base64 of at most {@link MAX_INPUT_IMAGE_BYTES} bytes;
+ *  - it rides on a `user` or `tool` message;
+ *  - the request carries at most {@link MAX_INPUT_IMAGES} of them.
+ *
+ * Returns the number of image parts and every issue, in message order. An issue
+ * names where and why, never the bytes: an image is payload and is never echoed
+ * into an error, a log line or a record.
+ */
+export function checkImageInput(messages) {
+    const issues = [];
+    let images = 0;
+    for (const [messageIndex, message] of messages.entries()) {
+        for (const [partIndex, part] of message.content.entries()) {
+            if (part.type !== 'image')
+                continue;
+            images += 1;
+            const at = { messageIndex, partIndex };
+            if (message.role !== 'user' && message.role !== 'tool') {
+                issues.push({ ...at, field: 'role', message: 'an image rides on a user or tool message' });
+            }
+            const source = part.source;
+            if (source.kind !== 'inline') {
+                issues.push({
+                    ...at,
+                    field: 'source',
+                    message: 'an image is sent inline as base64; no image URL is fetched',
+                });
+                continue;
+            }
+            if (!INPUT_IMAGE_MEDIA_TYPES.includes(source.mediaType)) {
+                issues.push({
+                    ...at,
+                    field: 'source.mediaType',
+                    message: `an image is one of ${INPUT_IMAGE_MEDIA_TYPES.join(', ')}`,
+                });
+            }
+            const bytes = base64DecodedLength(source.data);
+            if (bytes === undefined) {
+                issues.push({ ...at, field: 'source.data', message: 'image data is canonical base64' });
+            }
+            else if (bytes > MAX_INPUT_IMAGE_BYTES) {
+                issues.push({
+                    ...at,
+                    field: 'source.data',
+                    message: `an image is at most ${MAX_INPUT_IMAGE_BYTES} bytes`,
+                });
+            }
+        }
+    }
+    if (images > MAX_INPUT_IMAGES) {
+        issues.push({
+            messageIndex: messages.length - 1,
+            field: 'count',
+            message: `a request carries at most ${MAX_INPUT_IMAGES} images`,
+        });
+    }
+    return { images, issues };
+}
+const BASE64_BODY = /^[A-Za-z0-9+/]*$/;
+/**
+ * The decoded length of canonical base64 (RFC 4648 section 4, padded, no line
+ * breaks), or `undefined` when the text is not that. Counted, never decoded.
+ */
+export function base64DecodedLength(data) {
+    if (data.length === 0 || data.length % 4 !== 0)
+        return undefined;
+    const padding = data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0;
+    if (!BASE64_BODY.test(data.slice(0, data.length - padding)))
+        return undefined;
+    return (data.length / 4) * 3 - padding;
+}
 /**
  * A tool call an assistant made, in the normalized form.
  *
@@ -189,7 +296,7 @@ export const toolDefinitionSchema = z
     .object({
     type: z.literal('function'),
     name: z.string().check(minUtf16Length(1)).check(maxUtf16Length(128)),
-    description: z.string().check(maxUtf16Length(2000)).optional(),
+    description: z.string().check(maxUtf16Length(32768)).optional(),
     parameters: z.record(z.string(), z.unknown()),
     /** Ask the provider to enforce the schema, where it supports enforcement. */
     strict: z.boolean().optional(),

package/dist/public/realtime.d.ts

@@ -284,8 +284,8 @@ export declare const realtimeConversationItemSchema: z.ZodDiscriminatedUnion<[z.
     type: z.ZodLiteral<"message">;
     itemId: z.ZodOptional<z.ZodString>;
     role: z.ZodEnum<{
-        user: "user";
         system: "system";
+        user: "user";
         assistant: "assistant";
     }>;
     content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -401,8 +401,8 @@ export declare const realtimeItemCreateCommandSchema: z.ZodObject<{
         type: z.ZodLiteral<"message">;
         itemId: z.ZodOptional<z.ZodString>;
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
+            user: "user";
             assistant: "assistant";
         }>;
         content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -591,8 +591,8 @@ export declare const realtimeClientCommandSchema: z.ZodDiscriminatedUnion<[z.Zod
         type: z.ZodLiteral<"message">;
         itemId: z.ZodOptional<z.ZodString>;
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
+            user: "user";
             assistant: "assistant";
         }>;
         content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -796,8 +796,8 @@ export declare const realtimeItemAddedEventSchema: z.ZodObject<{
         type: z.ZodLiteral<"message">;
         itemId: z.ZodOptional<z.ZodString>;
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
+            user: "user";
             assistant: "assistant";
         }>;
         content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -848,8 +848,8 @@ export declare const realtimeItemDoneEventSchema: z.ZodObject<{
         type: z.ZodLiteral<"message">;
         itemId: z.ZodOptional<z.ZodString>;
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
+            user: "user";
             assistant: "assistant";
         }>;
         content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1655,8 +1655,8 @@ export declare const realtimePublicServerEventSchema: z.ZodDiscriminatedUnion<[z
         type: z.ZodLiteral<"message">;
         itemId: z.ZodOptional<z.ZodString>;
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
+            user: "user";
             assistant: "assistant";
         }>;
         content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1706,8 +1706,8 @@ export declare const realtimePublicServerEventSchema: z.ZodDiscriminatedUnion<[z
         type: z.ZodLiteral<"message">;
         itemId: z.ZodOptional<z.ZodString>;
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
+            user: "user";
             assistant: "assistant";
         }>;
         content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/public/responses.d.ts

@@ -44,9 +44,9 @@ export declare const responsesRequestSchema: z.ZodObject<{
     }>]>>;
     input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
             developer: "developer";
+            user: "user";
             assistant: "assistant";
             tool: "tool";
         }>;
@@ -164,9 +164,9 @@ export declare const responseSchema: z.ZodObject<{
     }>;
     output: z.ZodArray<z.ZodObject<{
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
             developer: "developer";
+            user: "user";
             assistant: "assistant";
             tool: "tool";
         }>;

package/dist/public/version.d.ts

@@ -100,7 +100,7 @@
  * change to, say, the catalogue reject every in-flight inference request; the
  * per-shape `schemaVersion` is what a message is validated against.
  */
-export declare const INFERENCE_CONTRACT_VERSION = "8.1.0";
+export declare const INFERENCE_CONTRACT_VERSION = "8.3.0";
 /**
  * Contract set 4.0.0 (Kaana ADR 0002) is the first published as
  * `@kaana.ai/contracts`. MAJOR because the set changed hands and split in two:
@@ -187,6 +187,20 @@ export declare const INFERENCE_CONTRACT_VERSION = "8.1.0";
  * `transcript.interim` event it asks for, the provisional text of an input
  * item that the item's deltas and its `transcript.done` supersede. Any other
  * kind asking for interim text is refused. Nothing in 8.0.0 changes.
+ *
+ * Contract set 8.2.0 (Kaana ADR 0007) is additive: image input. The rules an
+ * image part answers to (`checkImageInput`, `INPUT_IMAGE_MEDIA_TYPES`,
+ * `MAX_INPUT_IMAGES`, `MAX_INPUT_IMAGE_BYTES`), the internal declared model's
+ * `imageInput` (the most input tokens one image costs on the line) and the
+ * grant fact `inputImages`. Every 8.1.0 message parses the same; a consumer on
+ * 8.1.0 or earlier refuses a declared catalogue or an authorization carrying
+ * what is new, so Oxy reads them before Kaana publishes them.
+ *
+ * Contract set 8.3.0 is additive: the Anthropic-Messages-compatible
+ * `POST /v1/messages` (`anthropicMessagesRequestSchema`,
+ * `anthropicMessageSchema`, `anthropicStreamEventSchema`,
+ * `anthropicErrorSchema`). Nothing in 8.2.0 changes, and the signed grant and
+ * envelope are untouched: the endpoint is served as the `responses` operation.
  */
 /** The public API's one origin and version. */
 export declare const KAANA_API_BASE_URL = "https://kaana.ai/v1";

package/dist/public/version.js

@@ -100,7 +100,7 @@
  * change to, say, the catalogue reject every in-flight inference request; the
  * per-shape `schemaVersion` is what a message is validated against.
  */
-export const INFERENCE_CONTRACT_VERSION = '8.1.0';
+export const INFERENCE_CONTRACT_VERSION = '8.3.0';
 /**
  * Contract set 4.0.0 (Kaana ADR 0002) is the first published as
  * `@kaana.ai/contracts`. MAJOR because the set changed hands and split in two:
@@ -187,6 +187,20 @@ export const INFERENCE_CONTRACT_VERSION = '8.1.0';
  * `transcript.interim` event it asks for, the provisional text of an input
  * item that the item's deltas and its `transcript.done` supersede. Any other
  * kind asking for interim text is refused. Nothing in 8.0.0 changes.
+ *
+ * Contract set 8.2.0 (Kaana ADR 0007) is additive: image input. The rules an
+ * image part answers to (`checkImageInput`, `INPUT_IMAGE_MEDIA_TYPES`,
+ * `MAX_INPUT_IMAGES`, `MAX_INPUT_IMAGE_BYTES`), the internal declared model's
+ * `imageInput` (the most input tokens one image costs on the line) and the
+ * grant fact `inputImages`. Every 8.1.0 message parses the same; a consumer on
+ * 8.1.0 or earlier refuses a declared catalogue or an authorization carrying
+ * what is new, so Oxy reads them before Kaana publishes them.
+ *
+ * Contract set 8.3.0 is additive: the Anthropic-Messages-compatible
+ * `POST /v1/messages` (`anthropicMessagesRequestSchema`,
+ * `anthropicMessageSchema`, `anthropicStreamEventSchema`,
+ * `anthropicErrorSchema`). Nothing in 8.2.0 changes, and the signed grant and
+ * envelope are untouched: the endpoint is served as the `responses` operation.
  */
 /** The public API's one origin and version. */
 export const KAANA_API_BASE_URL = 'https://kaana.ai/v1';