@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/chatrequest.js

@@ -5,6 +5,8 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
+import { AnthropicCacheControlDirective$outboundSchema, } from "./anthropiccachecontroldirective.js";
+import { AutoRouterPlugin$outboundSchema, } from "./autorouterplugin.js";
 import { ChatDebugOptions$outboundSchema, } from "./chatdebugoptions.js";
 import { ChatFormatGrammarConfig$outboundSchema, } from "./chatformatgrammarconfig.js";
 import { ChatFormatJsonSchemaConfig$outboundSchema, } from "./chatformatjsonschemaconfig.js";
@@ -12,53 +14,21 @@ import { ChatFormatPythonConfig$outboundSchema, } from "./chatformatpythonconfig
 import { ChatFormatTextConfig$outboundSchema, } from "./chatformattextconfig.js";
 import { ChatFunctionTool$outboundSchema, } from "./chatfunctiontool.js";
 import { ChatMessages$outboundSchema, } from "./chatmessages.js";
+import { ChatReasoningSummaryVerbosityEnum$outboundSchema, } from "./chatreasoningsummaryverbosityenum.js";
 import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
 import { ChatToolChoice$outboundSchema, } from "./chattoolchoice.js";
-import { ContextCompressionEngine$outboundSchema, } from "./contextcompressionengine.js";
-import { DataCollection$outboundSchema, } from "./datacollection.js";
+import { ContextCompressionPlugin$outboundSchema, } from "./contextcompressionplugin.js";
+import { FileParserPlugin$outboundSchema, } from "./fileparserplugin.js";
 import { FormatJsonObjectConfig$outboundSchema, } from "./formatjsonobjectconfig.js";
-import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.js";
-import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
-import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
-import { ProviderName$outboundSchema } from "./providername.js";
-import { Quantization$outboundSchema } from "./quantization.js";
-import { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
-export const ChatRequestSortEnum = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-export const ChatRequestProviderSortConfigEnum = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * The provider sorting strategy (price, throughput, latency)
- */
-export const ChatRequestBy = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
- */
-export const ChatRequestPartition = {
-    Model: "model",
-    None: "none",
-};
-/**
- * The provider sorting strategy (price, throughput, latency)
- */
-export const ChatRequestProviderSort = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
+import { ModerationPlugin$outboundSchema, } from "./moderationplugin.js";
+import { ProviderPreferences$outboundSchema, } from "./providerpreferences.js";
+import { ResponseHealingPlugin$outboundSchema, } from "./responsehealingplugin.js";
+import { TraceConfig$outboundSchema, } from "./traceconfig.js";
+import { WebSearchPlugin$outboundSchema, } from "./websearchplugin.js";
+export const Modality = {
+    Text: "text",
+    Image: "image",
+    Audio: "audio",
 };
 /**
  * Constrains effort on reasoning for reasoning models
@@ -71,18 +41,6 @@ export const Effort = {
     Minimal: "minimal",
     None: "none",
 };
-export const Modality = {
-    Text: "text",
-    Image: "image",
-    Audio: "audio",
-};
-export const ChatRequestType = {
-    Ephemeral: "ephemeral",
-};
-export const ChatRequestTtl = {
-    Fivem: "5m",
-    Oneh: "1h",
-};
 /**
  * The service tier to use for processing this request.
  */
@@ -94,210 +52,24 @@ export const ChatRequestServiceTier = {
     Scale: "scale",
 };
 /** @internal */
-export const ChatRequestOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function chatRequestOrderToJSON(chatRequestOrder) {
-    return JSON.stringify(ChatRequestOrder$outboundSchema.parse(chatRequestOrder));
-}
-/** @internal */
-export const ChatRequestOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function chatRequestOnlyToJSON(chatRequestOnly) {
-    return JSON.stringify(ChatRequestOnly$outboundSchema.parse(chatRequestOnly));
-}
-/** @internal */
-export const ChatRequestIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function chatRequestIgnoreToJSON(chatRequestIgnore) {
-    return JSON.stringify(ChatRequestIgnore$outboundSchema.parse(chatRequestIgnore));
-}
-/** @internal */
-export const ChatRequestSortEnum$outboundSchema = openEnums.outboundSchema(ChatRequestSortEnum);
-/** @internal */
-export const ChatRequestProviderSortConfigEnum$outboundSchema = z.enum(ChatRequestProviderSortConfigEnum);
-/** @internal */
-export const ChatRequestBy$outboundSchema = openEnums.outboundSchema(ChatRequestBy);
-/** @internal */
-export const ChatRequestPartition$outboundSchema = openEnums.outboundSchema(ChatRequestPartition);
-/** @internal */
-export const ChatRequestProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ChatRequestBy$outboundSchema).optional(),
-    partition: z.nullable(ChatRequestPartition$outboundSchema).optional(),
-});
-export function chatRequestProviderSortConfigToJSON(chatRequestProviderSortConfig) {
-    return JSON.stringify(ChatRequestProviderSortConfig$outboundSchema.parse(chatRequestProviderSortConfig));
-}
-/** @internal */
-export const ChatRequestProviderSortConfigUnion$outboundSchema = z.union([
-    z.lazy(() => ChatRequestProviderSortConfig$outboundSchema),
-    ChatRequestProviderSortConfigEnum$outboundSchema,
-]);
-export function chatRequestProviderSortConfigUnionToJSON(chatRequestProviderSortConfigUnion) {
-    return JSON.stringify(ChatRequestProviderSortConfigUnion$outboundSchema.parse(chatRequestProviderSortConfigUnion));
-}
-/** @internal */
-export const ChatRequestProviderSort$outboundSchema = openEnums.outboundSchema(ChatRequestProviderSort);
-/** @internal */
-export const ChatRequestSortUnion$outboundSchema = z.union([
-    ChatRequestProviderSort$outboundSchema,
-    z.union([
-        z.lazy(() => ChatRequestProviderSortConfig$outboundSchema),
-        ChatRequestProviderSortConfigEnum$outboundSchema,
-    ]),
-    ChatRequestSortEnum$outboundSchema,
-]);
-export function chatRequestSortUnionToJSON(chatRequestSortUnion) {
-    return JSON.stringify(ChatRequestSortUnion$outboundSchema.parse(chatRequestSortUnion));
-}
-/** @internal */
-export const ChatRequestMaxPrice$outboundSchema = z.object({
-    prompt: z.string().optional(),
-    completion: z.string().optional(),
-    image: z.string().optional(),
-    audio: z.string().optional(),
-    request: z.string().optional(),
-});
-export function chatRequestMaxPriceToJSON(chatRequestMaxPrice) {
-    return JSON.stringify(ChatRequestMaxPrice$outboundSchema.parse(chatRequestMaxPrice));
-}
-/** @internal */
-export const ChatRequestProvider$outboundSchema = z.object({
-    allowFallbacks: z.nullable(z.boolean()).optional(),
-    requireParameters: z.nullable(z.boolean()).optional(),
-    dataCollection: z.nullable(DataCollection$outboundSchema).optional(),
-    zdr: z.nullable(z.boolean()).optional(),
-    enforceDistillableText: z.nullable(z.boolean()).optional(),
-    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
-        .optional(),
-    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
-        .optional(),
-    ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
-    quantizations: z.nullable(z.array(Quantization$outboundSchema)).optional(),
-    sort: z.nullable(z.union([
-        ChatRequestProviderSort$outboundSchema,
-        z.union([
-            z.lazy(() => ChatRequestProviderSortConfig$outboundSchema),
-            ChatRequestProviderSortConfigEnum$outboundSchema,
-        ]),
-        ChatRequestSortEnum$outboundSchema,
-    ])).optional(),
-    maxPrice: z.lazy(() => ChatRequestMaxPrice$outboundSchema).optional(),
-    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
-        .optional(),
-    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
-        .optional(),
-}).transform((v) => {
-    return remap$(v, {
-        allowFallbacks: "allow_fallbacks",
-        requireParameters: "require_parameters",
-        dataCollection: "data_collection",
-        enforceDistillableText: "enforce_distillable_text",
-        maxPrice: "max_price",
-        preferredMinThroughput: "preferred_min_throughput",
-        preferredMaxLatency: "preferred_max_latency",
-    });
-});
-export function chatRequestProviderToJSON(chatRequestProvider) {
-    return JSON.stringify(ChatRequestProvider$outboundSchema.parse(chatRequestProvider));
-}
-/** @internal */
-export const ChatRequestPluginContextCompression$outboundSchema = z.object({
-    id: z.literal("context-compression"),
-    enabled: z.boolean().optional(),
-    engine: ContextCompressionEngine$outboundSchema.optional(),
-});
-export function chatRequestPluginContextCompressionToJSON(chatRequestPluginContextCompression) {
-    return JSON.stringify(ChatRequestPluginContextCompression$outboundSchema.parse(chatRequestPluginContextCompression));
-}
-/** @internal */
-export const ChatRequestPluginResponseHealing$outboundSchema = z.object({
-    id: z.literal("response-healing"),
-    enabled: z.boolean().optional(),
-});
-export function chatRequestPluginResponseHealingToJSON(chatRequestPluginResponseHealing) {
-    return JSON.stringify(ChatRequestPluginResponseHealing$outboundSchema.parse(chatRequestPluginResponseHealing));
-}
-/** @internal */
-export const ChatRequestPluginFileParser$outboundSchema = z.object({
-    id: z.literal("file-parser"),
-    enabled: z.boolean().optional(),
-    pdf: PDFParserOptions$outboundSchema.optional(),
-});
-export function chatRequestPluginFileParserToJSON(chatRequestPluginFileParser) {
-    return JSON.stringify(ChatRequestPluginFileParser$outboundSchema.parse(chatRequestPluginFileParser));
-}
-/** @internal */
-export const ChatRequestPluginWeb$outboundSchema = z.object({
-    id: z.literal("web"),
-    enabled: z.boolean().optional(),
-    maxResults: z.number().optional(),
-    searchPrompt: z.string().optional(),
-    engine: WebSearchEngine$outboundSchema.optional(),
-    includeDomains: z.array(z.string()).optional(),
-    excludeDomains: z.array(z.string()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        maxResults: "max_results",
-        searchPrompt: "search_prompt",
-        includeDomains: "include_domains",
-        excludeDomains: "exclude_domains",
-    });
-});
-export function chatRequestPluginWebToJSON(chatRequestPluginWeb) {
-    return JSON.stringify(ChatRequestPluginWeb$outboundSchema.parse(chatRequestPluginWeb));
-}
-/** @internal */
-export const ChatRequestPluginModeration$outboundSchema = z.object({
-    id: z.literal("moderation"),
-});
-export function chatRequestPluginModerationToJSON(chatRequestPluginModeration) {
-    return JSON.stringify(ChatRequestPluginModeration$outboundSchema.parse(chatRequestPluginModeration));
+export const ChatRequestImageConfig$outboundSchema = z.union([z.string(), z.number(), z.array(z.nullable(z.any()))]);
+export function chatRequestImageConfigToJSON(chatRequestImageConfig) {
+    return JSON.stringify(ChatRequestImageConfig$outboundSchema.parse(chatRequestImageConfig));
 }
 /** @internal */
-export const ChatRequestPluginAutoRouter$outboundSchema = z.object({
-    id: z.literal("auto-router"),
-    enabled: z.boolean().optional(),
-    allowedModels: z.array(z.string()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        allowedModels: "allowed_models",
-    });
-});
-export function chatRequestPluginAutoRouterToJSON(chatRequestPluginAutoRouter) {
-    return JSON.stringify(ChatRequestPluginAutoRouter$outboundSchema.parse(chatRequestPluginAutoRouter));
-}
+export const Modality$outboundSchema = openEnums
+    .outboundSchema(Modality);
 /** @internal */
-export const ChatRequestPluginUnion$outboundSchema = z.union([
-    z.lazy(() => ChatRequestPluginAutoRouter$outboundSchema),
-    z.lazy(() => ChatRequestPluginModeration$outboundSchema),
-    z.lazy(() => ChatRequestPluginWeb$outboundSchema),
-    z.lazy(() => ChatRequestPluginFileParser$outboundSchema),
-    z.lazy(() => ChatRequestPluginResponseHealing$outboundSchema),
-    z.lazy(() => ChatRequestPluginContextCompression$outboundSchema),
+export const ChatRequestPlugin$outboundSchema = z.union([
+    AutoRouterPlugin$outboundSchema,
+    ContextCompressionPlugin$outboundSchema,
+    FileParserPlugin$outboundSchema,
+    ModerationPlugin$outboundSchema,
+    ResponseHealingPlugin$outboundSchema,
+    WebSearchPlugin$outboundSchema,
 ]);
-export function chatRequestPluginUnionToJSON(chatRequestPluginUnion) {
-    return JSON.stringify(ChatRequestPluginUnion$outboundSchema.parse(chatRequestPluginUnion));
-}
-/** @internal */
-export const ChatRequestTrace$outboundSchema = z.object({
-    traceId: z.string().optional(),
-    traceName: z.string().optional(),
-    spanName: z.string().optional(),
-    generationName: z.string().optional(),
-    parentSpanId: z.string().optional(),
-    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
-}).transform((v) => {
-    return {
-        ...v.additionalProperties,
-        ...remap$(v, {
-            traceId: "trace_id",
-            traceName: "trace_name",
-            spanName: "span_name",
-            generationName: "generation_name",
-            parentSpanId: "parent_span_id",
-            additionalProperties: null,
-        }),
-    };
-});
-export function chatRequestTraceToJSON(chatRequestTrace) {
-    return JSON.stringify(ChatRequestTrace$outboundSchema.parse(chatRequestTrace));
+export function chatRequestPluginToJSON(chatRequestPlugin) {
+    return JSON.stringify(ChatRequestPlugin$outboundSchema.parse(chatRequestPlugin));
 }
 /** @internal */
 export const Effort$outboundSchema = openEnums
@@ -305,23 +77,26 @@ export const Effort$outboundSchema = openEnums
 /** @internal */
 export const Reasoning$outboundSchema = z.object({
     effort: z.nullable(Effort$outboundSchema).optional(),
-    summary: z.nullable(z.any()).optional(),
+    summary: z.nullable(ChatReasoningSummaryVerbosityEnum$outboundSchema)
+        .optional(),
 });
 export function reasoningToJSON(reasoning) {
     return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
 }
 /** @internal */
 export const ResponseFormat$outboundSchema = z.union([
-    ChatFormatTextConfig$outboundSchema,
+    ChatFormatGrammarConfig$outboundSchema,
     FormatJsonObjectConfig$outboundSchema,
     ChatFormatJsonSchemaConfig$outboundSchema,
-    ChatFormatGrammarConfig$outboundSchema,
     ChatFormatPythonConfig$outboundSchema,
+    ChatFormatTextConfig$outboundSchema,
 ]);
 export function responseFormatToJSON(responseFormat) {
     return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
 }
 /** @internal */
+export const ChatRequestServiceTier$outboundSchema = openEnums.outboundSchema(ChatRequestServiceTier);
+/** @internal */
 export const Stop$outboundSchema = z.union([
     z.string(),
     z.array(z.string()),
@@ -331,93 +106,70 @@ export function stopToJSON(stop) {
     return JSON.stringify(Stop$outboundSchema.parse(stop));
 }
 /** @internal */
-export const ChatRequestImageConfig$outboundSchema = z.union([z.string(), z.number(), z.array(z.nullable(z.any()))]);
-export function chatRequestImageConfigToJSON(chatRequestImageConfig) {
-    return JSON.stringify(ChatRequestImageConfig$outboundSchema.parse(chatRequestImageConfig));
-}
-/** @internal */
-export const Modality$outboundSchema = openEnums
-    .outboundSchema(Modality);
-/** @internal */
-export const ChatRequestType$outboundSchema = z.enum(ChatRequestType);
-/** @internal */
-export const ChatRequestTtl$outboundSchema = openEnums.outboundSchema(ChatRequestTtl);
-/** @internal */
-export const CacheControl$outboundSchema = z.object({
-    type: ChatRequestType$outboundSchema,
-    ttl: ChatRequestTtl$outboundSchema.optional(),
-});
-export function cacheControlToJSON(cacheControl) {
-    return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
-}
-/** @internal */
-export const ChatRequestServiceTier$outboundSchema = openEnums.outboundSchema(ChatRequestServiceTier);
-/** @internal */
 export const ChatRequest$outboundSchema = z.object({
-    provider: z.nullable(z.lazy(() => ChatRequestProvider$outboundSchema))
-        .optional(),
-    plugins: z.array(z.union([
-        z.lazy(() => ChatRequestPluginAutoRouter$outboundSchema),
-        z.lazy(() => ChatRequestPluginModeration$outboundSchema),
-        z.lazy(() => ChatRequestPluginWeb$outboundSchema),
-        z.lazy(() => ChatRequestPluginFileParser$outboundSchema),
-        z.lazy(() => ChatRequestPluginResponseHealing$outboundSchema),
-        z.lazy(() => ChatRequestPluginContextCompression$outboundSchema),
-    ])).optional(),
-    user: z.string().optional(),
-    sessionId: z.string().optional(),
-    trace: z.lazy(() => ChatRequestTrace$outboundSchema).optional(),
-    messages: z.array(ChatMessages$outboundSchema),
-    model: z.string().optional(),
-    models: z.array(z.string()).optional(),
-    frequencyPenalty: z.nullable(z.number()).optional(),
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    debug: ChatDebugOptions$outboundSchema.optional(),
+    frequencyPenalty: z.number().optional(),
+    imageConfig: z.record(z.string(), z.union([z.string(), z.number(), z.array(z.nullable(z.any()))])).optional(),
     logitBias: z.nullable(z.record(z.string(), z.number())).optional(),
     logprobs: z.nullable(z.boolean()).optional(),
-    topLogprobs: z.nullable(z.number()).optional(),
-    maxCompletionTokens: z.nullable(z.number()).optional(),
-    maxTokens: z.nullable(z.number()).optional(),
+    maxCompletionTokens: z.int().optional(),
+    maxTokens: z.int().optional(),
+    messages: z.array(ChatMessages$outboundSchema),
     metadata: z.record(z.string(), z.string()).optional(),
-    presencePenalty: z.nullable(z.number()).optional(),
+    modalities: z.array(Modality$outboundSchema).optional(),
+    model: z.string().optional(),
+    models: z.array(z.string()).optional(),
+    parallelToolCalls: z.nullable(z.boolean()).optional(),
+    plugins: z.array(z.union([
+        AutoRouterPlugin$outboundSchema,
+        ContextCompressionPlugin$outboundSchema,
+        FileParserPlugin$outboundSchema,
+        ModerationPlugin$outboundSchema,
+        ResponseHealingPlugin$outboundSchema,
+        WebSearchPlugin$outboundSchema,
+    ])).optional(),
+    presencePenalty: z.number().optional(),
+    provider: z.nullable(ProviderPreferences$outboundSchema).optional(),
     reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
     responseFormat: z.union([
-        ChatFormatTextConfig$outboundSchema,
+        ChatFormatGrammarConfig$outboundSchema,
         FormatJsonObjectConfig$outboundSchema,
         ChatFormatJsonSchemaConfig$outboundSchema,
-        ChatFormatGrammarConfig$outboundSchema,
         ChatFormatPythonConfig$outboundSchema,
+        ChatFormatTextConfig$outboundSchema,
     ]).optional(),
-    seed: z.nullable(z.int()).optional(),
+    seed: z.int().optional(),
+    serviceTier: z.nullable(ChatRequestServiceTier$outboundSchema).optional(),
+    sessionId: z.string().optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string()), z.any()]))
         .optional(),
     stream: z.boolean().default(false),
     streamOptions: z.nullable(ChatStreamOptions$outboundSchema).optional(),
-    temperature: z.nullable(z.number().default(1)),
-    parallelToolCalls: z.nullable(z.boolean()).optional(),
+    temperature: z.number().optional(),
     toolChoice: ChatToolChoice$outboundSchema.optional(),
     tools: z.array(ChatFunctionTool$outboundSchema).optional(),
-    topP: z.nullable(z.number().default(1)),
-    debug: ChatDebugOptions$outboundSchema.optional(),
-    imageConfig: z.record(z.string(), z.union([z.string(), z.number(), z.array(z.nullable(z.any()))])).optional(),
-    modalities: z.array(Modality$outboundSchema).optional(),
-    cacheControl: z.lazy(() => CacheControl$outboundSchema).optional(),
-    serviceTier: z.nullable(ChatRequestServiceTier$outboundSchema).optional(),
+    topLogprobs: z.int().optional(),
+    topP: z.number().optional(),
+    trace: TraceConfig$outboundSchema.optional(),
+    user: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        sessionId: "session_id",
+        cacheControl: "cache_control",
         frequencyPenalty: "frequency_penalty",
+        imageConfig: "image_config",
         logitBias: "logit_bias",
-        topLogprobs: "top_logprobs",
         maxCompletionTokens: "max_completion_tokens",
         maxTokens: "max_tokens",
+        parallelToolCalls: "parallel_tool_calls",
         presencePenalty: "presence_penalty",
         responseFormat: "response_format",
+        serviceTier: "service_tier",
+        sessionId: "session_id",
         streamOptions: "stream_options",
-        parallelToolCalls: "parallel_tool_calls",
         toolChoice: "tool_choice",
+        topLogprobs: "top_logprobs",
         topP: "top_p",
-        imageConfig: "image_config",
-        cacheControl: "cache_control",
-        serviceTier: "service_tier",
     });
 });
 export function chatRequestToJSON(chatRequest) {

package/esm/models/chatresult.d.ts

@@ -12,10 +12,6 @@ export type ChatResultObject = ClosedEnum<typeof ChatResultObject>;
  * Chat completion response
  */
 export type ChatResult = {
-    /**
-     * Unique completion identifier
-     */
-    id: string;
     /**
      * List of completion choices
      */
@@ -24,19 +20,23 @@ export type ChatResult = {
      * Unix timestamp of creation
      */
     created: number;
+    /**
+     * Unique completion identifier
+     */
+    id: string;
     /**
      * Model used for completion
      */
     model: string;
     object: ChatResultObject;
-    /**
-     * System fingerprint
-     */
-    systemFingerprint: string | null;
     /**
      * The service tier used by the upstream provider for this request
      */
     serviceTier?: string | null | undefined;
+    /**
+     * System fingerprint
+     */
+    systemFingerprint: string | null;
     /**
      * Token usage statistics
      */

package/esm/models/chatresult.js

@@ -15,18 +15,18 @@ export const ChatResultObject$inboundSchema = z.enum(ChatResultObject);
 /** @internal */
 export const ChatResult$inboundSchema = z
     .object({
-    id: z.string(),
     choices: z.array(ChatChoice$inboundSchema),
-    created: z.number(),
+    created: z.int(),
+    id: z.string(),
     model: z.string(),
     object: ChatResultObject$inboundSchema,
-    system_fingerprint: z.nullable(z.string()),
     service_tier: z.nullable(z.string()).optional(),
+    system_fingerprint: z.nullable(z.string()),
     usage: ChatUsage$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
-        "system_fingerprint": "systemFingerprint",
         "service_tier": "serviceTier",
+        "system_fingerprint": "systemFingerprint",
     });
 });
 export function chatResultFromJSON(jsonString) {

package/esm/models/chatstreamchoice.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatFinishReasonEnum } from "./chatfinishreasonenum.js";
 import { ChatStreamDelta } from "./chatstreamdelta.js";
 import { ChatTokenLogprobs } from "./chattokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
@@ -11,7 +12,7 @@ export type ChatStreamChoice = {
      * Delta changes in streaming response
      */
     delta: ChatStreamDelta;
-    finishReason: any | null;
+    finishReason: ChatFinishReasonEnum | null;
     /**
      * Choice index
      */

package/esm/models/chatstreamchoice.js

@@ -5,13 +5,14 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ChatFinishReasonEnum$inboundSchema, } from "./chatfinishreasonenum.js";
 import { ChatStreamDelta$inboundSchema, } from "./chatstreamdelta.js";
 import { ChatTokenLogprobs$inboundSchema, } from "./chattokenlogprobs.js";
 /** @internal */
 export const ChatStreamChoice$inboundSchema = z.object({
     delta: ChatStreamDelta$inboundSchema,
-    finish_reason: z.nullable(z.any()),
-    index: z.number(),
+    finish_reason: z.nullable(ChatFinishReasonEnum$inboundSchema),
+    index: z.int(),
     logprobs: z.nullable(ChatTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatstreamchunk.d.ts

@@ -4,31 +4,27 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatStreamChoice } from "./chatstreamchoice.js";
 import { ChatUsage } from "./chatusage.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatStreamChunkObject: {
-    readonly ChatCompletionChunk: "chat.completion.chunk";
-};
-export type ChatStreamChunkObject = ClosedEnum<typeof ChatStreamChunkObject>;
 /**
  * Error information
  */
 export type ErrorT = {
-    /**
-     * Error message
-     */
-    message: string;
     /**
      * Error code
      */
     code: number;
+    /**
+     * Error message
+     */
+    message: string;
+};
+export declare const ChatStreamChunkObject: {
+    readonly ChatCompletionChunk: "chat.completion.chunk";
 };
+export type ChatStreamChunkObject = ClosedEnum<typeof ChatStreamChunkObject>;
 /**
  * Streaming chat completion chunk
  */
 export type ChatStreamChunk = {
-    /**
-     * Unique chunk identifier
-     */
-    id: string;
     /**
      * List of streaming chunk choices
      */
@@ -37,34 +33,38 @@ export type ChatStreamChunk = {
      * Unix timestamp of creation
      */
     created: number;
+    /**
+     * Error information
+     */
+    error?: ErrorT | undefined;
+    /**
+     * Unique chunk identifier
+     */
+    id: string;
     /**
      * Model used for completion
      */
     model: string;
     object: ChatStreamChunkObject;
-    /**
-     * System fingerprint
-     */
-    systemFingerprint?: string | undefined;
     /**
      * The service tier used by the upstream provider for this request
      */
     serviceTier?: string | null | undefined;
     /**
-     * Error information
+     * System fingerprint
      */
-    error?: ErrorT | undefined;
+    systemFingerprint?: string | undefined;
     /**
      * Token usage statistics
      */
     usage?: ChatUsage | undefined;
 };
 /** @internal */
-export declare const ChatStreamChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamChunkObject>;
-/** @internal */
 export declare const ErrorT$inboundSchema: z.ZodType<ErrorT, unknown>;
 export declare function errorFromJSON(jsonString: string): SafeParseResult<ErrorT, SDKValidationError>;
 /** @internal */
+export declare const ChatStreamChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamChunkObject>;
+/** @internal */
 export declare const ChatStreamChunk$inboundSchema: z.ZodType<ChatStreamChunk, unknown>;
 export declare function chatStreamChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamChunk, SDKValidationError>;
 //# sourceMappingURL=chatstreamchunk.d.ts.map