@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/chatrequest.d.ts

@@ -0,0 +1,292 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { AnthropicCacheControlDirective, AnthropicCacheControlDirective$Outbound } from "./anthropiccachecontroldirective.js";
+import { AutoRouterPlugin, AutoRouterPlugin$Outbound } from "./autorouterplugin.js";
+import { ChatDebugOptions, ChatDebugOptions$Outbound } from "./chatdebugoptions.js";
+import { ChatFormatGrammarConfig, ChatFormatGrammarConfig$Outbound } from "./chatformatgrammarconfig.js";
+import { ChatFormatJsonSchemaConfig, ChatFormatJsonSchemaConfig$Outbound } from "./chatformatjsonschemaconfig.js";
+import { ChatFormatPythonConfig, ChatFormatPythonConfig$Outbound } from "./chatformatpythonconfig.js";
+import { ChatFormatTextConfig, ChatFormatTextConfig$Outbound } from "./chatformattextconfig.js";
+import { ChatFunctionTool, ChatFunctionTool$Outbound } from "./chatfunctiontool.js";
+import { ChatMessages, ChatMessages$Outbound } from "./chatmessages.js";
+import { ChatReasoningSummaryVerbosityEnum } from "./chatreasoningsummaryverbosityenum.js";
+import { ChatStreamOptions, ChatStreamOptions$Outbound } from "./chatstreamoptions.js";
+import { ChatToolChoice, ChatToolChoice$Outbound } from "./chattoolchoice.js";
+import { ContextCompressionPlugin, ContextCompressionPlugin$Outbound } from "./contextcompressionplugin.js";
+import { FileParserPlugin, FileParserPlugin$Outbound } from "./fileparserplugin.js";
+import { FormatJsonObjectConfig, FormatJsonObjectConfig$Outbound } from "./formatjsonobjectconfig.js";
+import { ModerationPlugin, ModerationPlugin$Outbound } from "./moderationplugin.js";
+import { ProviderPreferences, ProviderPreferences$Outbound } from "./providerpreferences.js";
+import { ResponseHealingPlugin, ResponseHealingPlugin$Outbound } from "./responsehealingplugin.js";
+import { TraceConfig, TraceConfig$Outbound } from "./traceconfig.js";
+import { WebSearchPlugin, WebSearchPlugin$Outbound } from "./websearchplugin.js";
+export type ChatRequestImageConfig = string | number | Array<any | null>;
+export declare const Modality: {
+    readonly Text: "text";
+    readonly Image: "image";
+    readonly Audio: "audio";
+};
+export type Modality = OpenEnum<typeof Modality>;
+export type ChatRequestPlugin = AutoRouterPlugin | ContextCompressionPlugin | FileParserPlugin | ModerationPlugin | ResponseHealingPlugin | WebSearchPlugin;
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
+export declare const Effort: {
+    readonly Xhigh: "xhigh";
+    readonly High: "high";
+    readonly Medium: "medium";
+    readonly Low: "low";
+    readonly Minimal: "minimal";
+    readonly None: "none";
+};
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
+export type Effort = OpenEnum<typeof Effort>;
+/**
+ * Configuration options for reasoning models
+ */
+export type Reasoning = {
+    /**
+     * Constrains effort on reasoning for reasoning models
+     */
+    effort?: Effort | null | undefined;
+    summary?: ChatReasoningSummaryVerbosityEnum | null | undefined;
+};
+/**
+ * Response format configuration
+ */
+export type ResponseFormat = ChatFormatGrammarConfig | FormatJsonObjectConfig | ChatFormatJsonSchemaConfig | ChatFormatPythonConfig | ChatFormatTextConfig;
+/**
+ * The service tier to use for processing this request.
+ */
+export declare const ChatRequestServiceTier: {
+    readonly Auto: "auto";
+    readonly Default: "default";
+    readonly Flex: "flex";
+    readonly Priority: "priority";
+    readonly Scale: "scale";
+};
+/**
+ * The service tier to use for processing this request.
+ */
+export type ChatRequestServiceTier = OpenEnum<typeof ChatRequestServiceTier>;
+/**
+ * Stop sequences (up to 4)
+ */
+export type Stop = string | Array<string> | any;
+/**
+ * Chat completion request parameters
+ */
+export type ChatRequest = {
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    /**
+     * Debug options for inspecting request transformations (streaming only)
+     */
+    debug?: ChatDebugOptions | undefined;
+    /**
+     * Frequency penalty (-2.0 to 2.0)
+     */
+    frequencyPenalty?: number | undefined;
+    /**
+     * Provider-specific image configuration options. Keys and values vary by model/provider. See https://openrouter.ai/docs/guides/overview/multimodal/image-generation for more details.
+     */
+    imageConfig?: {
+        [k: string]: string | number | Array<any | null>;
+    } | undefined;
+    /**
+     * Token logit bias adjustments
+     */
+    logitBias?: {
+        [k: string]: number;
+    } | null | undefined;
+    /**
+     * Return log probabilities
+     */
+    logprobs?: boolean | null | undefined;
+    /**
+     * Maximum tokens in completion
+     */
+    maxCompletionTokens?: number | undefined;
+    /**
+     * Maximum tokens (deprecated, use max_completion_tokens). Note: some providers enforce a minimum of 16.
+     */
+    maxTokens?: number | undefined;
+    /**
+     * List of messages for the conversation
+     */
+    messages: Array<ChatMessages>;
+    /**
+     * Key-value pairs for additional object information (max 16 pairs, 64 char keys, 512 char values)
+     */
+    metadata?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Output modalities for the response. Supported values are "text", "image", and "audio".
+     */
+    modalities?: Array<Modality> | undefined;
+    /**
+     * Model to use for completion
+     */
+    model?: string | undefined;
+    /**
+     * Models to use for completion
+     */
+    models?: Array<string> | undefined;
+    /**
+     * Whether to enable parallel function calling during tool use. When true, the model may generate multiple tool calls in a single response.
+     */
+    parallelToolCalls?: boolean | null | undefined;
+    /**
+     * Plugins you want to enable for this request, including their settings.
+     */
+    plugins?: Array<AutoRouterPlugin | ContextCompressionPlugin | FileParserPlugin | ModerationPlugin | ResponseHealingPlugin | WebSearchPlugin> | undefined;
+    /**
+     * Presence penalty (-2.0 to 2.0)
+     */
+    presencePenalty?: number | undefined;
+    /**
+     * When multiple model providers are available, optionally indicate your routing preference.
+     */
+    provider?: ProviderPreferences | null | undefined;
+    /**
+     * Configuration options for reasoning models
+     */
+    reasoning?: Reasoning | undefined;
+    /**
+     * Response format configuration
+     */
+    responseFormat?: ChatFormatGrammarConfig | FormatJsonObjectConfig | ChatFormatJsonSchemaConfig | ChatFormatPythonConfig | ChatFormatTextConfig | undefined;
+    /**
+     * Random seed for deterministic outputs
+     */
+    seed?: number | undefined;
+    /**
+     * The service tier to use for processing this request.
+     */
+    serviceTier?: ChatRequestServiceTier | null | undefined;
+    /**
+     * A unique identifier for grouping related requests (e.g., a conversation or agent workflow) for observability. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 256 characters.
+     */
+    sessionId?: string | undefined;
+    /**
+     * Stop sequences (up to 4)
+     */
+    stop?: string | Array<string> | any | null | undefined;
+    /**
+     * Enable streaming response
+     */
+    stream?: boolean | undefined;
+    /**
+     * Streaming configuration options
+     */
+    streamOptions?: ChatStreamOptions | null | undefined;
+    /**
+     * Sampling temperature (0-2)
+     */
+    temperature?: number | undefined;
+    /**
+     * Tool choice configuration
+     */
+    toolChoice?: ChatToolChoice | undefined;
+    /**
+     * Available tools for function calling
+     */
+    tools?: Array<ChatFunctionTool> | undefined;
+    /**
+     * Number of top log probabilities to return (0-20)
+     */
+    topLogprobs?: number | undefined;
+    /**
+     * Nucleus sampling parameter (0-1)
+     */
+    topP?: number | undefined;
+    /**
+     * Metadata for observability and tracing. Known keys (trace_id, trace_name, span_name, generation_name, parent_span_id) have special handling. Additional keys are passed through as custom metadata to configured broadcast destinations.
+     */
+    trace?: TraceConfig | undefined;
+    /**
+     * Unique user identifier
+     */
+    user?: string | undefined;
+};
+/** @internal */
+export type ChatRequestImageConfig$Outbound = string | number | Array<any | null>;
+/** @internal */
+export declare const ChatRequestImageConfig$outboundSchema: z.ZodType<ChatRequestImageConfig$Outbound, ChatRequestImageConfig>;
+export declare function chatRequestImageConfigToJSON(chatRequestImageConfig: ChatRequestImageConfig): string;
+/** @internal */
+export declare const Modality$outboundSchema: z.ZodType<string, Modality>;
+/** @internal */
+export type ChatRequestPlugin$Outbound = AutoRouterPlugin$Outbound | ContextCompressionPlugin$Outbound | FileParserPlugin$Outbound | ModerationPlugin$Outbound | ResponseHealingPlugin$Outbound | WebSearchPlugin$Outbound;
+/** @internal */
+export declare const ChatRequestPlugin$outboundSchema: z.ZodType<ChatRequestPlugin$Outbound, ChatRequestPlugin>;
+export declare function chatRequestPluginToJSON(chatRequestPlugin: ChatRequestPlugin): string;
+/** @internal */
+export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
+/** @internal */
+export type Reasoning$Outbound = {
+    effort?: string | null | undefined;
+    summary?: string | null | undefined;
+};
+/** @internal */
+export declare const Reasoning$outboundSchema: z.ZodType<Reasoning$Outbound, Reasoning>;
+export declare function reasoningToJSON(reasoning: Reasoning): string;
+/** @internal */
+export type ResponseFormat$Outbound = ChatFormatGrammarConfig$Outbound | FormatJsonObjectConfig$Outbound | ChatFormatJsonSchemaConfig$Outbound | ChatFormatPythonConfig$Outbound | ChatFormatTextConfig$Outbound;
+/** @internal */
+export declare const ResponseFormat$outboundSchema: z.ZodType<ResponseFormat$Outbound, ResponseFormat>;
+export declare function responseFormatToJSON(responseFormat: ResponseFormat): string;
+/** @internal */
+export declare const ChatRequestServiceTier$outboundSchema: z.ZodType<string, ChatRequestServiceTier>;
+/** @internal */
+export type Stop$Outbound = string | Array<string> | any;
+/** @internal */
+export declare const Stop$outboundSchema: z.ZodType<Stop$Outbound, Stop>;
+export declare function stopToJSON(stop: Stop): string;
+/** @internal */
+export type ChatRequest$Outbound = {
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    debug?: ChatDebugOptions$Outbound | undefined;
+    frequency_penalty?: number | undefined;
+    image_config?: {
+        [k: string]: string | number | Array<any | null>;
+    } | undefined;
+    logit_bias?: {
+        [k: string]: number;
+    } | null | undefined;
+    logprobs?: boolean | null | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    messages: Array<ChatMessages$Outbound>;
+    metadata?: {
+        [k: string]: string;
+    } | undefined;
+    modalities?: Array<string> | undefined;
+    model?: string | undefined;
+    models?: Array<string> | undefined;
+    parallel_tool_calls?: boolean | null | undefined;
+    plugins?: Array<AutoRouterPlugin$Outbound | ContextCompressionPlugin$Outbound | FileParserPlugin$Outbound | ModerationPlugin$Outbound | ResponseHealingPlugin$Outbound | WebSearchPlugin$Outbound> | undefined;
+    presence_penalty?: number | undefined;
+    provider?: ProviderPreferences$Outbound | null | undefined;
+    reasoning?: Reasoning$Outbound | undefined;
+    response_format?: ChatFormatGrammarConfig$Outbound | FormatJsonObjectConfig$Outbound | ChatFormatJsonSchemaConfig$Outbound | ChatFormatPythonConfig$Outbound | ChatFormatTextConfig$Outbound | undefined;
+    seed?: number | undefined;
+    service_tier?: string | null | undefined;
+    session_id?: string | undefined;
+    stop?: string | Array<string> | any | null | undefined;
+    stream: boolean;
+    stream_options?: ChatStreamOptions$Outbound | null | undefined;
+    temperature?: number | undefined;
+    tool_choice?: ChatToolChoice$Outbound | undefined;
+    tools?: Array<ChatFunctionTool$Outbound> | undefined;
+    top_logprobs?: number | undefined;
+    top_p?: number | undefined;
+    trace?: TraceConfig$Outbound | undefined;
+    user?: string | undefined;
+};
+/** @internal */
+export declare const ChatRequest$outboundSchema: z.ZodType<ChatRequest$Outbound, ChatRequest>;
+export declare function chatRequestToJSON(chatRequest: ChatRequest): string;
+//# sourceMappingURL=chatrequest.d.ts.map

package/esm/models/chatrequest.js

@@ -0,0 +1,178 @@
+/*
+ * 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 { 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";
+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 { ChatReasoningSummaryVerbosityEnum$outboundSchema, } from "./chatreasoningsummaryverbosityenum.js";
+import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
+import { ChatToolChoice$outboundSchema, } from "./chattoolchoice.js";
+import { ContextCompressionPlugin$outboundSchema, } from "./contextcompressionplugin.js";
+import { FileParserPlugin$outboundSchema, } from "./fileparserplugin.js";
+import { FormatJsonObjectConfig$outboundSchema, } from "./formatjsonobjectconfig.js";
+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
+ */
+export const Effort = {
+    Xhigh: "xhigh",
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+    Minimal: "minimal",
+    None: "none",
+};
+/**
+ * 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 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 ChatRequestPlugin$outboundSchema = z.union([
+    AutoRouterPlugin$outboundSchema,
+    ContextCompressionPlugin$outboundSchema,
+    FileParserPlugin$outboundSchema,
+    ModerationPlugin$outboundSchema,
+    ResponseHealingPlugin$outboundSchema,
+    WebSearchPlugin$outboundSchema,
+]);
+export function chatRequestPluginToJSON(chatRequestPlugin) {
+    return JSON.stringify(ChatRequestPlugin$outboundSchema.parse(chatRequestPlugin));
+}
+/** @internal */
+export const Effort$outboundSchema = openEnums
+    .outboundSchema(Effort);
+/** @internal */
+export const Reasoning$outboundSchema = z.object({
+    effort: z.nullable(Effort$outboundSchema).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([
+    ChatFormatGrammarConfig$outboundSchema,
+    FormatJsonObjectConfig$outboundSchema,
+    ChatFormatJsonSchemaConfig$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()),
+    z.any(),
+]);
+export function stopToJSON(stop) {
+    return JSON.stringify(Stop$outboundSchema.parse(stop));
+}
+/** @internal */
+export const ChatRequest$outboundSchema = z.object({
+    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(),
+    maxCompletionTokens: z.int().optional(),
+    maxTokens: z.int().optional(),
+    messages: z.array(ChatMessages$outboundSchema),
+    metadata: z.record(z.string(), z.string()).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([
+        ChatFormatGrammarConfig$outboundSchema,
+        FormatJsonObjectConfig$outboundSchema,
+        ChatFormatJsonSchemaConfig$outboundSchema,
+        ChatFormatPythonConfig$outboundSchema,
+        ChatFormatTextConfig$outboundSchema,
+    ]).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.number().optional(),
+    toolChoice: ChatToolChoice$outboundSchema.optional(),
+    tools: z.array(ChatFunctionTool$outboundSchema).optional(),
+    topLogprobs: z.int().optional(),
+    topP: z.number().optional(),
+    trace: TraceConfig$outboundSchema.optional(),
+    user: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+        frequencyPenalty: "frequency_penalty",
+        imageConfig: "image_config",
+        logitBias: "logit_bias",
+        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",
+        toolChoice: "tool_choice",
+        topLogprobs: "top_logprobs",
+        topP: "top_p",
+    });
+});
+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 = {
+    /**
+     * List of completion choices
+     */
+    choices: Array<ChatChoice>;
+    /**
+     * Unix timestamp of creation
+     */
+    created: number;
+    /**
+     * Unique completion identifier
+     */
+    id: string;
+    /**
+     * Model used for completion
+     */
+    model: string;
+    object: ChatResultObject;
+    /**
+     * The service tier used by the upstream provider for this request
+     */
+    serviceTier?: string | null | undefined;
+    /**
+     * System fingerprint
+     */
+    systemFingerprint: string | null;
+    /**
+     * 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({
+    choices: z.array(ChatChoice$inboundSchema),
+    created: z.int(),
+    id: z.string(),
+    model: z.string(),
+    object: ChatResultObject$inboundSchema,
+    service_tier: z.nullable(z.string()).optional(),
+    system_fingerprint: z.nullable(z.string()),
+    usage: ChatUsage$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "service_tier": "serviceTier",
+        "system_fingerprint": "systemFingerprint",
+    });
+});
+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,28 @@
+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";
+/**
+ * Streaming completion choice chunk
+ */
+export type ChatStreamChoice = {
+    /**
+     * Delta changes in streaming response
+     */
+    delta: ChatStreamDelta;
+    finishReason: ChatFinishReasonEnum | 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,25 @@
+/*
+ * 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 { 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(ChatFinishReasonEnum$inboundSchema),
+    index: z.int(),
+    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