@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/chatrequest.js

@@ -0,0 +1,426 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5d2646ed8dcf
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { ChatDebugOptions$outboundSchema, } from "./chatdebugoptions.js";
+import { ChatFormatGrammarConfig$outboundSchema, } from "./chatformatgrammarconfig.js";
+import { ChatFormatJsonSchemaConfig$outboundSchema, } from "./chatformatjsonschemaconfig.js";
+import { ChatFormatPythonConfig$outboundSchema, } from "./chatformatpythonconfig.js";
+import { ChatFormatTextConfig$outboundSchema, } from "./chatformattextconfig.js";
+import { ChatFunctionTool$outboundSchema, } from "./chatfunctiontool.js";
+import { ChatMessages$outboundSchema, } from "./chatmessages.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 { 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",
+};
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
+export const Effort = {
+    Xhigh: "xhigh",
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+    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.
+ */
+export const ChatRequestServiceTier = {
+    Auto: "auto",
+    Default: "default",
+    Flex: "flex",
+    Priority: "priority",
+    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));
+}
+/** @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));
+}
+/** @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 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));
+}
+/** @internal */
+export const Effort$outboundSchema = openEnums
+    .outboundSchema(Effort);
+/** @internal */
+export const Reasoning$outboundSchema = z.object({
+    effort: z.nullable(Effort$outboundSchema).optional(),
+    summary: z.nullable(z.any()).optional(),
+});
+export function reasoningToJSON(reasoning) {
+    return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
+}
+/** @internal */
+export const ResponseFormat$outboundSchema = z.union([
+    ChatFormatTextConfig$outboundSchema,
+    FormatJsonObjectConfig$outboundSchema,
+    ChatFormatJsonSchemaConfig$outboundSchema,
+    ChatFormatGrammarConfig$outboundSchema,
+    ChatFormatPythonConfig$outboundSchema,
+]);
+export function responseFormatToJSON(responseFormat) {
+    return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
+}
+/** @internal */
+export const Stop$outboundSchema = z.union([
+    z.string(),
+    z.array(z.string()),
+    z.any(),
+]);
+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(),
+    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(),
+    metadata: z.record(z.string(), z.string()).optional(),
+    presencePenalty: z.nullable(z.number()).optional(),
+    reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
+    responseFormat: z.union([
+        ChatFormatTextConfig$outboundSchema,
+        FormatJsonObjectConfig$outboundSchema,
+        ChatFormatJsonSchemaConfig$outboundSchema,
+        ChatFormatGrammarConfig$outboundSchema,
+        ChatFormatPythonConfig$outboundSchema,
+    ]).optional(),
+    seed: z.nullable(z.int()).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(),
+    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(),
+}).transform((v) => {
+    return remap$(v, {
+        sessionId: "session_id",
+        frequencyPenalty: "frequency_penalty",
+        logitBias: "logit_bias",
+        topLogprobs: "top_logprobs",
+        maxCompletionTokens: "max_completion_tokens",
+        maxTokens: "max_tokens",
+        presencePenalty: "presence_penalty",
+        responseFormat: "response_format",
+        streamOptions: "stream_options",
+        parallelToolCalls: "parallel_tool_calls",
+        toolChoice: "tool_choice",
+        topP: "top_p",
+        imageConfig: "image_config",
+        cacheControl: "cache_control",
+        serviceTier: "service_tier",
+    });
+});
+export function chatRequestToJSON(chatRequest) {
+    return JSON.stringify(ChatRequest$outboundSchema.parse(chatRequest));
+}
+//# sourceMappingURL=chatrequest.js.map

package/esm/models/chatresult.d.ts

@@ -0,0 +1,50 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatChoice } from "./chatchoice.js";
+import { ChatUsage } from "./chatusage.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatResultObject: {
+    readonly ChatCompletion: "chat.completion";
+};
+export type ChatResultObject = ClosedEnum<typeof ChatResultObject>;
+/**
+ * Chat completion response
+ */
+export type ChatResult = {
+    /**
+     * Unique completion identifier
+     */
+    id: string;
+    /**
+     * List of completion choices
+     */
+    choices: Array<ChatChoice>;
+    /**
+     * Unix timestamp of creation
+     */
+    created: number;
+    /**
+     * 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;
+    /**
+     * Token usage statistics
+     */
+    usage?: ChatUsage | undefined;
+};
+/** @internal */
+export declare const ChatResultObject$inboundSchema: z.ZodEnum<typeof ChatResultObject>;
+/** @internal */
+export declare const ChatResult$inboundSchema: z.ZodType<ChatResult, unknown>;
+export declare function chatResultFromJSON(jsonString: string): SafeParseResult<ChatResult, SDKValidationError>;
+//# sourceMappingURL=chatresult.d.ts.map

package/esm/models/chatresult.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: afefd8aadd09
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatChoice$inboundSchema } from "./chatchoice.js";
+import { ChatUsage$inboundSchema } from "./chatusage.js";
+export const ChatResultObject = {
+    ChatCompletion: "chat.completion",
+};
+/** @internal */
+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(),
+    model: z.string(),
+    object: ChatResultObject$inboundSchema,
+    system_fingerprint: z.nullable(z.string()),
+    service_tier: z.nullable(z.string()).optional(),
+    usage: ChatUsage$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "system_fingerprint": "systemFingerprint",
+        "service_tier": "serviceTier",
+    });
+});
+export function chatResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatResult' from JSON`);
+}
+//# sourceMappingURL=chatresult.js.map

package/esm/models/chatstreamchoice.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatStreamDelta } from "./chatstreamdelta.js";
+import { ChatTokenLogprobs } from "./chattokenlogprobs.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Streaming completion choice chunk
+ */
+export type ChatStreamChoice = {
+    /**
+     * Delta changes in streaming response
+     */
+    delta: ChatStreamDelta;
+    finishReason: any | null;
+    /**
+     * Choice index
+     */
+    index: number;
+    /**
+     * Log probabilities for the completion
+     */
+    logprobs?: ChatTokenLogprobs | null | undefined;
+};
+/** @internal */
+export declare const ChatStreamChoice$inboundSchema: z.ZodType<ChatStreamChoice, unknown>;
+export declare function chatStreamChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamChoice, SDKValidationError>;
+//# sourceMappingURL=chatstreamchoice.d.ts.map

package/esm/models/chatstreamchoice.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3747d92a0ba4
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.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(),
+    logprobs: z.nullable(ChatTokenLogprobs$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "finish_reason": "finishReason",
+    });
+});
+export function chatStreamChoiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamChoice' from JSON`);
+}
+//# sourceMappingURL=chatstreamchoice.js.map

package/esm/models/{chatstreamingresponsechunk.d.ts → chatstreamchunk.d.ts}

@@ -1,13 +1,13 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
-import { ChatStreamingChoice } from "./chatstreamingchoice.js";
+import { ChatStreamChoice } from "./chatstreamchoice.js";
+import { ChatUsage } from "./chatusage.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatStreamingResponseChunkObject: {
+export declare const ChatStreamChunkObject: {
     readonly ChatCompletionChunk: "chat.completion.chunk";
 };
-export type ChatStreamingResponseChunkObject = ClosedEnum<typeof ChatStreamingResponseChunkObject>;
+export type ChatStreamChunkObject = ClosedEnum<typeof ChatStreamChunkObject>;
 /**
  * Error information
  */
@@ -24,7 +24,7 @@ export type ErrorT = {
 /**
  * Streaming chat completion chunk
  */
-export type ChatStreamingResponseChunk = {
+export type ChatStreamChunk = {
     /**
      * Unique chunk identifier
      */
@@ -32,7 +32,7 @@ export type ChatStreamingResponseChunk = {
     /**
      * List of streaming chunk choices
      */
-    choices: Array<ChatStreamingChoice>;
+    choices: Array<ChatStreamChoice>;
     /**
      * Unix timestamp of creation
      */
@@ -41,11 +41,15 @@ export type ChatStreamingResponseChunk = {
      * Model used for completion
      */
     model: string;
-    object: ChatStreamingResponseChunkObject;
+    object: ChatStreamChunkObject;
     /**
      * System fingerprint
      */
-    systemFingerprint?: string | null | undefined;
+    systemFingerprint?: string | undefined;
+    /**
+     * The service tier used by the upstream provider for this request
+     */
+    serviceTier?: string | null | undefined;
     /**
      * Error information
      */
@@ -53,14 +57,14 @@ export type ChatStreamingResponseChunk = {
     /**
      * Token usage statistics
      */
-    usage?: ChatGenerationTokenUsage | undefined;
+    usage?: ChatUsage | undefined;
 };
 /** @internal */
-export declare const ChatStreamingResponseChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamingResponseChunkObject>;
+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 ChatStreamingResponseChunk$inboundSchema: z.ZodType<ChatStreamingResponseChunk, unknown>;
-export declare function chatStreamingResponseChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunk, SDKValidationError>;
-//# sourceMappingURL=chatstreamingresponsechunk.d.ts.map
+export declare const ChatStreamChunk$inboundSchema: z.ZodType<ChatStreamChunk, unknown>;
+export declare function chatStreamChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamChunk, SDKValidationError>;
+//# sourceMappingURL=chatstreamchunk.d.ts.map

package/esm/models/chatstreamchunk.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 361f940e91e4
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatStreamChoice$inboundSchema, } from "./chatstreamchoice.js";
+import { ChatUsage$inboundSchema } from "./chatusage.js";
+export const ChatStreamChunkObject = {
+    ChatCompletionChunk: "chat.completion.chunk",
+};
+/** @internal */
+export const ChatStreamChunkObject$inboundSchema = z.enum(ChatStreamChunkObject);
+/** @internal */
+export const ErrorT$inboundSchema = z.object({
+    message: z.string(),
+    code: z.number(),
+});
+export function errorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ErrorT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ErrorT' from JSON`);
+}
+/** @internal */
+export const ChatStreamChunk$inboundSchema = z.object({
+    id: z.string(),
+    choices: z.array(ChatStreamChoice$inboundSchema),
+    created: z.number(),
+    model: z.string(),
+    object: ChatStreamChunkObject$inboundSchema,
+    system_fingerprint: z.string().optional(),
+    service_tier: z.nullable(z.string()).optional(),
+    error: z.lazy(() => ErrorT$inboundSchema).optional(),
+    usage: ChatUsage$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "system_fingerprint": "systemFingerprint",
+        "service_tier": "serviceTier",
+    });
+});
+export function chatStreamChunkFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamChunk$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamChunk' from JSON`);
+}
+//# sourceMappingURL=chatstreamchunk.js.map