@kaana.ai/contracts 8.2.0 → 8.3.0

package/dist/index.d.ts

@@ -10,6 +10,7 @@
  * Accounts, applications, `oxy_sk_…` keys, limits and billing are managed in
  * Oxy Console (`https://console.oxy.so`), never here.
  */
+export * from './public/anthropicMessages.js';
 export * from './public/audio.js';
 export * from './public/audioFormats.js';
 export * from './public/catalogue.js';

package/dist/index.js

@@ -10,6 +10,7 @@
  * Accounts, applications, `oxy_sk_…` keys, limits and billing are managed in
  * Oxy Console (`https://console.oxy.so`), never here.
  */
+export * from './public/anthropicMessages.js';
 export * from './public/audio.js';
 export * from './public/audioFormats.js';
 export * from './public/catalogue.js';

package/dist/internal/catalogue.d.ts

@@ -254,8 +254,8 @@ export declare const modelDeploymentSchema: z.ZodObject<{
     status: z.ZodEnum<{
         active: "active";
         retired: "retired";
-        degraded: "degraded";
         disabled: "disabled";
+        degraded: "degraded";
     }>;
     dedicatedCapacity: z.ZodBoolean;
     priceVersionId: z.ZodOptional<z.ZodString>;

package/dist/internal/realtime.d.ts

@@ -631,8 +631,8 @@ export declare const realtimeServerEventSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         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<{
@@ -682,8 +682,8 @@ export declare const realtimeServerEventSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         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/internal/request.d.ts

@@ -47,9 +47,9 @@ export declare const inferenceInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     format: z.ZodLiteral<"messages">;
     messages: z.ZodArray<z.ZodObject<{
         role: z.ZodEnum<{
-            user: "user";
             system: "system";
             developer: "developer";
+            user: "user";
             assistant: "assistant";
             tool: "tool";
         }>;
@@ -231,9 +231,9 @@ export declare const inferenceRequestSchema: z.ZodObject<{
         format: z.ZodLiteral<"messages">;
         messages: z.ZodArray<z.ZodObject<{
             role: z.ZodEnum<{
-                user: "user";
                 system: "system";
                 developer: "developer";
+                user: "user";
                 assistant: "assistant";
                 tool: "tool";
             }>;

package/dist/public/anthropicMessages.d.ts

@@ -0,0 +1,284 @@
+/**
+ * `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';
+export declare const anthropicMessagesRequestSchema: z.ZodObject<{
+    model: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        auto: "auto";
+        instant: "instant";
+        xhigh: "xhigh";
+        pro: "pro";
+        ultra: "ultra";
+    }>]>;
+    max_tokens: z.ZodNumber;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                media_type: z.ZodString;
+                data: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"base64">;
+                    media_type: z.ZodString;
+                    data: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"url">;
+                    url: z.ZodString;
+                }, z.core.$strict>], "type">;
+            }, z.core.$strict>]>>]>>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>]>>]>;
+    }, z.core.$strict>>;
+    system: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    top_k: z.ZodOptional<z.ZodNumber>;
+    stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<"custom">>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        strict: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    tool_choice: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"auto">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"any">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool">;
+        name: z.ZodString;
+    }, z.core.$strict>], "type">>;
+    thinking: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"disabled">;
+    }, z.core.$strict>>;
+    output_config: z.ZodOptional<z.ZodObject<{
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The non-streaming body. The request id rides in `Kaana-Request-Id` and `Request-Id`. */
+export declare const anthropicMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"message">;
+    role: z.ZodLiteral<"assistant">;
+    model: z.ZodString;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>], "type">>;
+    stop_reason: z.ZodEnum<{
+        refusal: "refusal";
+        tool_use: "tool_use";
+        max_tokens: "max_tokens";
+        end_turn: "end_turn";
+    }>;
+    stop_sequence: z.ZodLiteral<null>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** The error body, and the data of a stream's `event: error` frame. */
+export declare const anthropicErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        type: z.ZodEnum<{
+            request_too_large: "request_too_large";
+            invalid_request_error: "invalid_request_error";
+            authentication_error: "authentication_error";
+            billing_error: "billing_error";
+            permission_error: "permission_error";
+            not_found_error: "not_found_error";
+            rate_limit_error: "rate_limit_error";
+            timeout_error: "timeout_error";
+            overloaded_error: "overloaded_error";
+            api_error: "api_error";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    request_id: z.ZodOptional<z.ZodString>;
+}, z.core.$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 declare const anthropicStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"message_start">;
+    message: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"message">;
+        role: z.ZodLiteral<"assistant">;
+        model: z.ZodString;
+        content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>], "type">>;
+        stop_reason: z.ZodLiteral<null>;
+        stop_sequence: z.ZodLiteral<null>;
+        usage: z.ZodObject<{
+            input_tokens: z.ZodNumber;
+            output_tokens: z.ZodNumber;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_start">;
+    index: z.ZodNumber;
+    content_block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodLiteral<"">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodObject<{}, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_delta">;
+    index: z.ZodNumber;
+    delta: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text_delta">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"input_json_delta">;
+        partial_json: z.ZodString;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_stop">;
+    index: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"message_delta">;
+    delta: z.ZodObject<{
+        stop_reason: z.ZodEnum<{
+            refusal: "refusal";
+            tool_use: "tool_use";
+            max_tokens: "max_tokens";
+            end_turn: "end_turn";
+        }>;
+        stop_sequence: z.ZodLiteral<null>;
+    }, z.core.$strict>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"message_stop">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        type: z.ZodEnum<{
+            request_too_large: "request_too_large";
+            invalid_request_error: "invalid_request_error";
+            authentication_error: "authentication_error";
+            billing_error: "billing_error";
+            permission_error: "permission_error";
+            not_found_error: "not_found_error";
+            rate_limit_error: "rate_limit_error";
+            timeout_error: "timeout_error";
+            overloaded_error: "overloaded_error";
+            api_error: "api_error";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    request_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "type">;
+export type AnthropicMessagesRequest = z.infer<typeof anthropicMessagesRequestSchema>;
+export type AnthropicMessage = z.infer<typeof anthropicMessageSchema>;
+export type AnthropicError = z.infer<typeof anthropicErrorSchema>;
+export type AnthropicStreamEvent = z.infer<typeof anthropicStreamEventSchema>;

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

@@ -163,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";
 }>;
@@ -179,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

@@ -296,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(),