@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/providerresponse.d.ts

@@ -0,0 +1,156 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Name of the provider
+ */
+export declare const ProviderResponseProviderName: {
+    readonly AnyScale: "AnyScale";
+    readonly Atoma: "Atoma";
+    readonly CentML: "Cent-ML";
+    readonly CrofAI: "CrofAI";
+    readonly Enfer: "Enfer";
+    readonly GoPomelo: "GoPomelo";
+    readonly HuggingFace: "HuggingFace";
+    readonly Hyperbolic2: "Hyperbolic 2";
+    readonly InoCloud: "InoCloud";
+    readonly Kluster: "Kluster";
+    readonly Lambda: "Lambda";
+    readonly Lepton: "Lepton";
+    readonly Lynn2: "Lynn 2";
+    readonly Lynn: "Lynn";
+    readonly Mancer: "Mancer";
+    readonly Meta: "Meta";
+    readonly Modal: "Modal";
+    readonly Nineteen: "Nineteen";
+    readonly OctoAI: "OctoAI";
+    readonly Recursal: "Recursal";
+    readonly Reflection: "Reflection";
+    readonly Replicate: "Replicate";
+    readonly SambaNova2: "SambaNova 2";
+    readonly SFCompute: "SF Compute";
+    readonly Targon: "Targon";
+    readonly Together2: "Together 2";
+    readonly Ubicloud: "Ubicloud";
+    readonly OneDotAI: "01.AI";
+    readonly AkashML: "AkashML";
+    readonly Ai21: "AI21";
+    readonly AionLabs: "AionLabs";
+    readonly Alibaba: "Alibaba";
+    readonly Ambient: "Ambient";
+    readonly AmazonBedrock: "Amazon Bedrock";
+    readonly AmazonNova: "Amazon Nova";
+    readonly Anthropic: "Anthropic";
+    readonly ArceeAI: "Arcee AI";
+    readonly AtlasCloud: "AtlasCloud";
+    readonly Avian: "Avian";
+    readonly Azure: "Azure";
+    readonly BaseTen: "BaseTen";
+    readonly BytePlus: "BytePlus";
+    readonly BlackForestLabs: "Black Forest Labs";
+    readonly Cerebras: "Cerebras";
+    readonly Chutes: "Chutes";
+    readonly Cirrascale: "Cirrascale";
+    readonly Clarifai: "Clarifai";
+    readonly Cloudflare: "Cloudflare";
+    readonly Cohere: "Cohere";
+    readonly Crusoe: "Crusoe";
+    readonly DeepInfra: "DeepInfra";
+    readonly DeepSeek: "DeepSeek";
+    readonly Featherless: "Featherless";
+    readonly Fireworks: "Fireworks";
+    readonly Friendli: "Friendli";
+    readonly GMICloud: "GMICloud";
+    readonly Google: "Google";
+    readonly GoogleAIStudio: "Google AI Studio";
+    readonly Groq: "Groq";
+    readonly Hyperbolic: "Hyperbolic";
+    readonly Inception: "Inception";
+    readonly Inceptron: "Inceptron";
+    readonly InferenceNet: "InferenceNet";
+    readonly Ionstream: "Ionstream";
+    readonly Infermatic: "Infermatic";
+    readonly IoNet: "Io Net";
+    readonly Inflection: "Inflection";
+    readonly Liquid: "Liquid";
+    readonly Mara: "Mara";
+    readonly Mancer2: "Mancer 2";
+    readonly Minimax: "Minimax";
+    readonly ModelRun: "ModelRun";
+    readonly Mistral: "Mistral";
+    readonly Modular: "Modular";
+    readonly MoonshotAI: "Moonshot AI";
+    readonly Morph: "Morph";
+    readonly NCompass: "NCompass";
+    readonly Nebius: "Nebius";
+    readonly NextBit: "NextBit";
+    readonly Novita: "Novita";
+    readonly Nvidia: "Nvidia";
+    readonly OpenAI: "OpenAI";
+    readonly OpenInference: "OpenInference";
+    readonly Parasail: "Parasail";
+    readonly Perplexity: "Perplexity";
+    readonly Phala: "Phala";
+    readonly Reka: "Reka";
+    readonly Relace: "Relace";
+    readonly SambaNova: "SambaNova";
+    readonly Seed: "Seed";
+    readonly SiliconFlow: "SiliconFlow";
+    readonly Sourceful: "Sourceful";
+    readonly StepFun: "StepFun";
+    readonly Stealth: "Stealth";
+    readonly StreamLake: "StreamLake";
+    readonly Switchpoint: "Switchpoint";
+    readonly Together: "Together";
+    readonly Upstage: "Upstage";
+    readonly Venice: "Venice";
+    readonly WandB: "WandB";
+    readonly Xiaomi: "Xiaomi";
+    readonly XAI: "xAI";
+    readonly ZAi: "Z.AI";
+    readonly FakeProvider: "FakeProvider";
+};
+/**
+ * Name of the provider
+ */
+export type ProviderResponseProviderName = OpenEnum<typeof ProviderResponseProviderName>;
+/**
+ * Details of a provider response for a generation attempt
+ */
+export type ProviderResponse = {
+    /**
+     * Internal endpoint identifier
+     */
+    endpointId?: string | undefined;
+    /**
+     * Upstream provider response identifier
+     */
+    id?: string | undefined;
+    /**
+     * Whether the request used a bring-your-own-key
+     */
+    isByok?: boolean | undefined;
+    /**
+     * Response latency in milliseconds
+     */
+    latency?: number | undefined;
+    /**
+     * Canonical model slug
+     */
+    modelPermaslug?: string | undefined;
+    /**
+     * Name of the provider
+     */
+    providerName?: ProviderResponseProviderName | undefined;
+    /**
+     * HTTP status code from the provider
+     */
+    status: number | null;
+};
+/** @internal */
+export declare const ProviderResponseProviderName$inboundSchema: z.ZodType<ProviderResponseProviderName, unknown>;
+/** @internal */
+export declare const ProviderResponse$inboundSchema: z.ZodType<ProviderResponse, unknown>;
+export declare function providerResponseFromJSON(jsonString: string): SafeParseResult<ProviderResponse, SDKValidationError>;
+//# sourceMappingURL=providerresponse.d.ts.map

package/esm/models/providerresponse.js

@@ -0,0 +1,140 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7427d17a27bc
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+/**
+ * Name of the provider
+ */
+export const ProviderResponseProviderName = {
+    AnyScale: "AnyScale",
+    Atoma: "Atoma",
+    CentML: "Cent-ML",
+    CrofAI: "CrofAI",
+    Enfer: "Enfer",
+    GoPomelo: "GoPomelo",
+    HuggingFace: "HuggingFace",
+    Hyperbolic2: "Hyperbolic 2",
+    InoCloud: "InoCloud",
+    Kluster: "Kluster",
+    Lambda: "Lambda",
+    Lepton: "Lepton",
+    Lynn2: "Lynn 2",
+    Lynn: "Lynn",
+    Mancer: "Mancer",
+    Meta: "Meta",
+    Modal: "Modal",
+    Nineteen: "Nineteen",
+    OctoAI: "OctoAI",
+    Recursal: "Recursal",
+    Reflection: "Reflection",
+    Replicate: "Replicate",
+    SambaNova2: "SambaNova 2",
+    SFCompute: "SF Compute",
+    Targon: "Targon",
+    Together2: "Together 2",
+    Ubicloud: "Ubicloud",
+    OneDotAI: "01.AI",
+    AkashML: "AkashML",
+    Ai21: "AI21",
+    AionLabs: "AionLabs",
+    Alibaba: "Alibaba",
+    Ambient: "Ambient",
+    AmazonBedrock: "Amazon Bedrock",
+    AmazonNova: "Amazon Nova",
+    Anthropic: "Anthropic",
+    ArceeAI: "Arcee AI",
+    AtlasCloud: "AtlasCloud",
+    Avian: "Avian",
+    Azure: "Azure",
+    BaseTen: "BaseTen",
+    BytePlus: "BytePlus",
+    BlackForestLabs: "Black Forest Labs",
+    Cerebras: "Cerebras",
+    Chutes: "Chutes",
+    Cirrascale: "Cirrascale",
+    Clarifai: "Clarifai",
+    Cloudflare: "Cloudflare",
+    Cohere: "Cohere",
+    Crusoe: "Crusoe",
+    DeepInfra: "DeepInfra",
+    DeepSeek: "DeepSeek",
+    Featherless: "Featherless",
+    Fireworks: "Fireworks",
+    Friendli: "Friendli",
+    GMICloud: "GMICloud",
+    Google: "Google",
+    GoogleAIStudio: "Google AI Studio",
+    Groq: "Groq",
+    Hyperbolic: "Hyperbolic",
+    Inception: "Inception",
+    Inceptron: "Inceptron",
+    InferenceNet: "InferenceNet",
+    Ionstream: "Ionstream",
+    Infermatic: "Infermatic",
+    IoNet: "Io Net",
+    Inflection: "Inflection",
+    Liquid: "Liquid",
+    Mara: "Mara",
+    Mancer2: "Mancer 2",
+    Minimax: "Minimax",
+    ModelRun: "ModelRun",
+    Mistral: "Mistral",
+    Modular: "Modular",
+    MoonshotAI: "Moonshot AI",
+    Morph: "Morph",
+    NCompass: "NCompass",
+    Nebius: "Nebius",
+    NextBit: "NextBit",
+    Novita: "Novita",
+    Nvidia: "Nvidia",
+    OpenAI: "OpenAI",
+    OpenInference: "OpenInference",
+    Parasail: "Parasail",
+    Perplexity: "Perplexity",
+    Phala: "Phala",
+    Reka: "Reka",
+    Relace: "Relace",
+    SambaNova: "SambaNova",
+    Seed: "Seed",
+    SiliconFlow: "SiliconFlow",
+    Sourceful: "Sourceful",
+    StepFun: "StepFun",
+    Stealth: "Stealth",
+    StreamLake: "StreamLake",
+    Switchpoint: "Switchpoint",
+    Together: "Together",
+    Upstage: "Upstage",
+    Venice: "Venice",
+    WandB: "WandB",
+    Xiaomi: "Xiaomi",
+    XAI: "xAI",
+    ZAi: "Z.AI",
+    FakeProvider: "FakeProvider",
+};
+/** @internal */
+export const ProviderResponseProviderName$inboundSchema = openEnums.inboundSchema(ProviderResponseProviderName);
+/** @internal */
+export const ProviderResponse$inboundSchema = z.object({
+    endpoint_id: z.string().optional(),
+    id: z.string().optional(),
+    is_byok: z.boolean().optional(),
+    latency: z.number().optional(),
+    model_permaslug: z.string().optional(),
+    provider_name: ProviderResponseProviderName$inboundSchema.optional(),
+    status: z.nullable(z.number()),
+}).transform((v) => {
+    return remap$(v, {
+        "endpoint_id": "endpointId",
+        "is_byok": "isByok",
+        "model_permaslug": "modelPermaslug",
+        "provider_name": "providerName",
+    });
+});
+export function providerResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ProviderResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ProviderResponse' from JSON`);
+}
+//# sourceMappingURL=providerresponse.js.map

package/esm/models/publicendpoint.d.ts

@@ -7,20 +7,20 @@ import { Parameter } from "./parameter.js";
 import { PercentileStats } from "./percentilestats.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
-    prompt: string;
+    audio?: string | undefined;
+    audioOutput?: string | undefined;
     completion: string;
-    request?: string | undefined;
+    discount?: number | undefined;
     image?: string | undefined;
-    imageToken?: string | undefined;
     imageOutput?: string | undefined;
-    audio?: string | undefined;
-    audioOutput?: string | undefined;
+    imageToken?: string | undefined;
     inputAudioCache?: string | undefined;
-    webSearch?: string | undefined;
-    internalReasoning?: string | undefined;
     inputCacheRead?: string | undefined;
     inputCacheWrite?: string | undefined;
-    discount?: number | undefined;
+    internalReasoning?: string | undefined;
+    prompt: string;
+    request?: string | undefined;
+    webSearch?: string | undefined;
 };
 export declare const PublicEndpointQuantization: {
     readonly Int4: "int4";
@@ -38,28 +38,36 @@ export type PublicEndpointQuantization = OpenEnum<typeof PublicEndpointQuantizat
  * Information about a specific model endpoint
  */
 export type PublicEndpoint = {
-    name: string;
+    contextLength: number;
+    /**
+     * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+     */
+    latencyLast30m: PercentileStats | null;
+    maxCompletionTokens: number;
+    maxPromptTokens: number;
     /**
      * The unique identifier for the model (permaslug)
      */
     modelId: string;
     modelName: string;
-    contextLength: number;
+    name: string;
     pricing: Pricing;
     providerName: ProviderName;
-    tag: string;
     quantization: PublicEndpointQuantization | null;
-    maxCompletionTokens: number | null;
-    maxPromptTokens: number | null;
-    supportedParameters: Array<Parameter>;
     status?: EndpointStatus | undefined;
-    uptimeLast30m: number | null;
+    supportedParameters: Array<Parameter>;
     supportsImplicitCaching: boolean;
+    tag: string;
+    throughputLast30m: PercentileStats | null;
     /**
-     * Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests.
+     * Uptime percentage over the last 1 day, calculated as successful requests / (successful + error requests) * 100. Rate-limited requests are excluded. Returns null if insufficient data.
      */
-    latencyLast30m: PercentileStats | null;
-    throughputLast30m: PercentileStats | null;
+    uptimeLast1d: number;
+    uptimeLast30m: number;
+    /**
+     * Uptime percentage over the last 5 minutes, calculated as successful requests / (successful + error requests) * 100. Rate-limited requests are excluded. Returns null if insufficient data.
+     */
+    uptimeLast5m: number;
 };
 /** @internal */
 export declare const Pricing$inboundSchema: z.ZodType<Pricing, unknown>;

package/esm/models/publicendpoint.js

@@ -23,30 +23,30 @@ export const PublicEndpointQuantization = {
 };
 /** @internal */
 export const Pricing$inboundSchema = z.object({
-    prompt: z.string(),
+    audio: z.string().optional(),
+    audio_output: z.string().optional(),
     completion: z.string(),
-    request: z.string().optional(),
+    discount: z.number().optional(),
     image: z.string().optional(),
-    image_token: z.string().optional(),
     image_output: z.string().optional(),
-    audio: z.string().optional(),
-    audio_output: z.string().optional(),
+    image_token: z.string().optional(),
     input_audio_cache: z.string().optional(),
-    web_search: z.string().optional(),
-    internal_reasoning: z.string().optional(),
     input_cache_read: z.string().optional(),
     input_cache_write: z.string().optional(),
-    discount: z.number().optional(),
+    internal_reasoning: z.string().optional(),
+    prompt: z.string(),
+    request: z.string().optional(),
+    web_search: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "image_token": "imageToken",
-        "image_output": "imageOutput",
         "audio_output": "audioOutput",
+        "image_output": "imageOutput",
+        "image_token": "imageToken",
         "input_audio_cache": "inputAudioCache",
-        "web_search": "webSearch",
-        "internal_reasoning": "internalReasoning",
         "input_cache_read": "inputCacheRead",
         "input_cache_write": "inputCacheWrite",
+        "internal_reasoning": "internalReasoning",
+        "web_search": "webSearch",
     });
 });
 export function pricingFromJSON(jsonString) {
@@ -56,35 +56,39 @@ export function pricingFromJSON(jsonString) {
 export const PublicEndpointQuantization$inboundSchema = openEnums.inboundSchema(PublicEndpointQuantization);
 /** @internal */
 export const PublicEndpoint$inboundSchema = z.object({
-    name: z.string(),
+    context_length: z.int(),
+    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    max_completion_tokens: z.int(),
+    max_prompt_tokens: z.int(),
     model_id: z.string(),
     model_name: z.string(),
-    context_length: z.number(),
+    name: z.string(),
     pricing: z.lazy(() => Pricing$inboundSchema),
     provider_name: ProviderName$inboundSchema,
-    tag: z.string(),
     quantization: z.nullable(PublicEndpointQuantization$inboundSchema),
-    max_completion_tokens: z.nullable(z.number()),
-    max_prompt_tokens: z.nullable(z.number()),
-    supported_parameters: z.array(Parameter$inboundSchema),
     status: EndpointStatus$inboundSchema.optional(),
-    uptime_last_30m: z.nullable(z.number()),
+    supported_parameters: z.array(Parameter$inboundSchema),
     supports_implicit_caching: z.boolean(),
-    latency_last_30m: z.nullable(PercentileStats$inboundSchema),
+    tag: z.string(),
     throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
+    uptime_last_1d: z.number(),
+    uptime_last_30m: z.number(),
+    uptime_last_5m: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "model_id": "modelId",
-        "model_name": "modelName",
         "context_length": "contextLength",
-        "provider_name": "providerName",
+        "latency_last_30m": "latencyLast30m",
         "max_completion_tokens": "maxCompletionTokens",
         "max_prompt_tokens": "maxPromptTokens",
+        "model_id": "modelId",
+        "model_name": "modelName",
+        "provider_name": "providerName",
         "supported_parameters": "supportedParameters",
-        "uptime_last_30m": "uptimeLast30m",
         "supports_implicit_caching": "supportsImplicitCaching",
-        "latency_last_30m": "latencyLast30m",
         "throughput_last_30m": "throughputLast30m",
+        "uptime_last_1d": "uptimeLast1d",
+        "uptime_last_30m": "uptimeLast30m",
+        "uptime_last_5m": "uptimeLast5m",
     });
 });
 export function publicEndpointFromJSON(jsonString) {

package/esm/models/publicpricing.d.ts

@@ -5,20 +5,20 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Pricing information for the model
  */
 export type PublicPricing = {
-    prompt: string;
+    audio?: string | undefined;
+    audioOutput?: string | undefined;
     completion: string;
-    request?: string | undefined;
+    discount?: number | undefined;
     image?: string | undefined;
-    imageToken?: string | undefined;
     imageOutput?: string | undefined;
-    audio?: string | undefined;
-    audioOutput?: string | undefined;
+    imageToken?: string | undefined;
     inputAudioCache?: string | undefined;
-    webSearch?: string | undefined;
-    internalReasoning?: string | undefined;
     inputCacheRead?: string | undefined;
     inputCacheWrite?: string | undefined;
-    discount?: number | undefined;
+    internalReasoning?: string | undefined;
+    prompt: string;
+    request?: string | undefined;
+    webSearch?: string | undefined;
 };
 /** @internal */
 export declare const PublicPricing$inboundSchema: z.ZodType<PublicPricing, unknown>;

package/esm/models/publicpricing.js

@@ -8,30 +8,30 @@ import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const PublicPricing$inboundSchema = z
     .object({
-    prompt: z.string(),
+    audio: z.string().optional(),
+    audio_output: z.string().optional(),
     completion: z.string(),
-    request: z.string().optional(),
+    discount: z.number().optional(),
     image: z.string().optional(),
-    image_token: z.string().optional(),
     image_output: z.string().optional(),
-    audio: z.string().optional(),
-    audio_output: z.string().optional(),
+    image_token: z.string().optional(),
     input_audio_cache: z.string().optional(),
-    web_search: z.string().optional(),
-    internal_reasoning: z.string().optional(),
     input_cache_read: z.string().optional(),
     input_cache_write: z.string().optional(),
-    discount: z.number().optional(),
+    internal_reasoning: z.string().optional(),
+    prompt: z.string(),
+    request: z.string().optional(),
+    web_search: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "image_token": "imageToken",
-        "image_output": "imageOutput",
         "audio_output": "audioOutput",
+        "image_output": "imageOutput",
+        "image_token": "imageToken",
         "input_audio_cache": "inputAudioCache",
-        "web_search": "webSearch",
-        "internal_reasoning": "internalReasoning",
         "input_cache_read": "inputCacheRead",
         "input_cache_write": "inputCacheWrite",
+        "internal_reasoning": "internalReasoning",
+        "web_search": "webSearch",
     });
 });
 export function publicPricingFromJSON(jsonString) {

package/esm/models/reasoningconfig.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { ReasoningEffort } from "./reasoningeffort.js";
+import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
+/**
+ * Configuration for reasoning mode in the response
+ */
+export type ReasoningConfig = {
+    effort?: ReasoningEffort | null | undefined;
+    summary?: ReasoningSummaryVerbosity | null | undefined;
+    enabled?: boolean | null | undefined;
+    maxTokens?: number | undefined;
+};
+/** @internal */
+export type ReasoningConfig$Outbound = {
+    effort?: string | null | undefined;
+    summary?: string | null | undefined;
+    enabled?: boolean | null | undefined;
+    max_tokens?: number | undefined;
+};
+/** @internal */
+export declare const ReasoningConfig$outboundSchema: z.ZodType<ReasoningConfig$Outbound, ReasoningConfig>;
+export declare function reasoningConfigToJSON(reasoningConfig: ReasoningConfig): string;
+//# sourceMappingURL=reasoningconfig.d.ts.map

package/esm/models/reasoningconfig.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 809170859136
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ReasoningEffort$outboundSchema, } from "./reasoningeffort.js";
+import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
+/** @internal */
+export const ReasoningConfig$outboundSchema = z.object({
+    effort: z.nullable(ReasoningEffort$outboundSchema).optional(),
+    summary: z.nullable(ReasoningSummaryVerbosity$outboundSchema).optional(),
+    enabled: z.nullable(z.boolean()).optional(),
+    maxTokens: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxTokens: "max_tokens",
+    });
+});
+export function reasoningConfigToJSON(reasoningConfig) {
+    return JSON.stringify(ReasoningConfig$outboundSchema.parse(reasoningConfig));
+}
+//# sourceMappingURL=reasoningconfig.js.map

package/esm/models/{openresponsesreasoningdeltaevent.d.ts → reasoningdeltaevent.d.ts}

@@ -4,15 +4,15 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Event emitted when reasoning text delta is streamed
  */
-export type OpenResponsesReasoningDeltaEvent = {
-    type: "response.reasoning_text.delta";
-    outputIndex: number;
-    itemId: string;
+export type ReasoningDeltaEvent = {
     contentIndex: number;
     delta: string;
+    itemId: string;
+    outputIndex: number;
     sequenceNumber: number;
+    type: "response.reasoning_text.delta";
 };
 /** @internal */
-export declare const OpenResponsesReasoningDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown>;
-export declare function openResponsesReasoningDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDeltaEvent, SDKValidationError>;
-//# sourceMappingURL=openresponsesreasoningdeltaevent.d.ts.map
+export declare const ReasoningDeltaEvent$inboundSchema: z.ZodType<ReasoningDeltaEvent, unknown>;
+export declare function reasoningDeltaEventFromJSON(jsonString: string): SafeParseResult<ReasoningDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=reasoningdeltaevent.d.ts.map

package/esm/models/{openresponsesreasoningdeltaevent.js → reasoningdeltaevent.js}

@@ -1,27 +1,27 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 32b751d1d3d7
+ * @generated-id: 0e129c34b701
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesReasoningDeltaEvent$inboundSchema = z.object({
-    type: z.literal("response.reasoning_text.delta"),
-    output_index: z.number(),
-    item_id: z.string(),
-    content_index: z.number(),
+export const ReasoningDeltaEvent$inboundSchema = z.object({
+    content_index: z.int(),
     delta: z.string(),
-    sequence_number: z.number(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.reasoning_text.delta"),
 }).transform((v) => {
     return remap$(v, {
-        "output_index": "outputIndex",
-        "item_id": "itemId",
         "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesReasoningDeltaEventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesReasoningDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningDeltaEvent' from JSON`);
+export function reasoningDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDeltaEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesreasoningdeltaevent.js.map
+//# sourceMappingURL=reasoningdeltaevent.js.map