@kaana.ai/contracts 8.1.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>;
@@ -562,6 +562,26 @@ export declare const modelCatalogueEntrySchema: z.ZodObject<{
         ultra: "ultra";
     }>>;
 }, z.core.$strip>;
+/**
+ * What a model line's image input costs at most, as the line's own documented
+ * rule states it (contract set 8.2.0, Kaana ADR 0007). Internal: Oxy reads it
+ * from the declared catalogue to bound the input of a request carrying images;
+ * `GET /v1/models` does not serve it.
+ *
+ * `maxInputTokensPerImage` is the most input tokens the line's provider bills
+ * for ONE image the contract admits (`checkImageInput`), at any `detail` the
+ * contract offers, from the publisher's documented resize and tokenization
+ * rule. Images are billed as input tokens at the line's `input_tokens` price;
+ * this figure only sizes a hold and qualifies a route, the settlement is the
+ * provider's own count.
+ *
+ * ABSENT means undeclared, even on a model whose `inputModalities` lists
+ * `image`: nobody has stated what one image costs on it, so no request carrying
+ * an image is authorized on it.
+ */
+export declare const declaredImageInputSchema: z.ZodObject<{
+    maxInputTokensPerImage: z.ZodNumber;
+}, z.core.$strict>;
 /**
  * One model as Kaana DECLARES it in `configs/public-catalogue.json` (Kaana ADR
  * 0002, amendment 2026-10-15): the public `modelSchema` without the three
@@ -791,6 +811,9 @@ export declare const declaredModelSchema: z.ZodObject<{
         platform_internal: "platform_internal";
         public: "public";
     }>;
+    imageInput: z.ZodOptional<z.ZodObject<{
+        maxInputTokensPerImage: z.ZodNumber;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 /**
  * The declared catalogue: identity, publisher, licence, provenance, data
@@ -1019,9 +1042,13 @@ export declare const declaredCatalogueSchema: z.ZodObject<{
             platform_internal: "platform_internal";
             public: "public";
         }>;
+        imageInput: z.ZodOptional<z.ZodObject<{
+            maxInputTokensPerImage: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type DeclaredModel = z.infer<typeof declaredModelSchema>;
+export type DeclaredImageInput = z.infer<typeof declaredImageInputSchema>;
 export type DeclaredCatalogue = z.infer<typeof declaredCatalogueSchema>;
 export type AvailabilityScope = z.infer<typeof availabilityScopeSchema>;
 export type CommercialPermission = z.infer<typeof commercialPermissionSchema>;

package/dist/internal/catalogue.js

@@ -354,6 +354,28 @@ export const modelCatalogueEntrySchema = z.object({
      */
     powerClass: modelPowerClassSchema.optional(),
 });
+/**
+ * What a model line's image input costs at most, as the line's own documented
+ * rule states it (contract set 8.2.0, Kaana ADR 0007). Internal: Oxy reads it
+ * from the declared catalogue to bound the input of a request carrying images;
+ * `GET /v1/models` does not serve it.
+ *
+ * `maxInputTokensPerImage` is the most input tokens the line's provider bills
+ * for ONE image the contract admits (`checkImageInput`), at any `detail` the
+ * contract offers, from the publisher's documented resize and tokenization
+ * rule. Images are billed as input tokens at the line's `input_tokens` price;
+ * this figure only sizes a hold and qualifies a route, the settlement is the
+ * provider's own count.
+ *
+ * ABSENT means undeclared, even on a model whose `inputModalities` lists
+ * `image`: nobody has stated what one image costs on it, so no request carrying
+ * an image is authorized on it.
+ */
+export const declaredImageInputSchema = z
+    .object({
+    maxInputTokensPerImage: z.number().int().positive().safe(),
+})
+    .strict();
 /**
  * One model as Kaana DECLARES it in `configs/public-catalogue.json` (Kaana ADR
  * 0002, amendment 2026-10-15): the public `modelSchema` without the three
@@ -368,8 +390,20 @@ export const modelCatalogueEntrySchema = z.object({
  */
 export const declaredModelSchema = modelSchema
     .omit({ schemaVersion: true, currentRevision: true, availableRevisions: true })
-    .extend({ audience: z.enum(['public', 'platform_internal']) })
-    .strict();
+    .extend({
+    audience: z.enum(['public', 'platform_internal']),
+    imageInput: declaredImageInputSchema.optional(),
+})
+    .strict()
+    .superRefine((model, ctx) => {
+    if (model.imageInput !== undefined && !model.capabilities.inputModalities.includes('image')) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['imageInput'],
+            message: 'a model that bounds its image input takes image input',
+        });
+    }
+});
 /**
  * The declared catalogue: identity, publisher, licence, provenance, data
  * policy, capabilities, voices and the LIST PRICE per unit of every model

package/dist/internal/grant.d.ts

@@ -74,6 +74,7 @@ export declare const grantRequestFactsSchema: z.ZodObject<{
     audioInputMilliseconds: z.ZodOptional<z.ZodNumber>;
     embeddingInputs: z.ZodOptional<z.ZodNumber>;
     images: z.ZodOptional<z.ZodNumber>;
+    inputImages: z.ZodOptional<z.ZodNumber>;
     declaredTools: z.ZodNumber;
     stream: z.ZodBoolean;
     realtimeSessionKind: z.ZodOptional<z.ZodEnum<{
@@ -125,6 +126,7 @@ export declare const inferenceAuthorizationRequestSchema: z.ZodObject<{
         audioInputMilliseconds: z.ZodOptional<z.ZodNumber>;
         embeddingInputs: z.ZodOptional<z.ZodNumber>;
         images: z.ZodOptional<z.ZodNumber>;
+        inputImages: z.ZodOptional<z.ZodNumber>;
         declaredTools: z.ZodNumber;
         stream: z.ZodBoolean;
         realtimeSessionKind: z.ZodOptional<z.ZodEnum<{
@@ -204,6 +206,7 @@ export declare const authorizationRequestSchema: z.ZodDiscriminatedUnion<[z.ZodO
         audioInputMilliseconds: z.ZodOptional<z.ZodNumber>;
         embeddingInputs: z.ZodOptional<z.ZodNumber>;
         images: z.ZodOptional<z.ZodNumber>;
+        inputImages: z.ZodOptional<z.ZodNumber>;
         declaredTools: z.ZodNumber;
         stream: z.ZodBoolean;
         realtimeSessionKind: z.ZodOptional<z.ZodEnum<{

package/dist/internal/grant.js

@@ -22,7 +22,7 @@ import { maxUtf16Length, minUtf16Length } from '../stringBounds.js';
 import { powerLevelSchema, realtimeSessionKindSchema } from '../public/catalogue.js';
 import { generationRecordSchema } from '../public/generations.js';
 import { delegatedUserIdSchema, generationIdSchema, idempotencyKeySchema, inferenceEnvironmentSchema, inferenceRegionSchema, inferenceTimestampSchema, modelIdSchema, modelRevisionLabelSchema, oxyApplicationIdSchema, oxyCredentialIdSchema, requestIdSchema, } from '../public/identifiers.js';
-import { requestLabelsSchema } from '../public/messages.js';
+import { MAX_INPUT_IMAGES, requestLabelsSchema } from '../public/messages.js';
 import { moneySchema } from '../public/money.js';
 import { routingPolicyReferenceSchema } from '../public/policy.js';
 import { inferenceScopeSchema } from './attribution.js';
@@ -107,6 +107,13 @@ export const grantRequestFactsSchema = z
     /** Embeddings: how many inputs. Images: how many images. */
     embeddingInputs: z.number().int().positive().max(2048).optional(),
     images: z.number().int().positive().max(10).optional(),
+    /**
+     * Completions: how many image parts the input carries (contract set 8.2.0,
+     * Kaana ADR 0007), present exactly when it carries one. Their bytes are not
+     * in `estimatedInputTokens`: Oxy bounds each image by the line's declared
+     * `imageInput.maxInputTokensPerImage` and admits only lines that declare it.
+     */
+    inputImages: z.number().int().positive().max(MAX_INPUT_IMAGES).optional(),
     /** How many tools the request declares; their definitions stay in Kaana. */
     declaredTools: z.number().int().nonnegative().max(128),
     stream: z.boolean(),

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>;