@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/providername.js

@@ -4,6 +4,7 @@
  */
 import * as openEnums from "../types/enums.js";
 export const ProviderName = {
+    AkashML: "AkashML",
     Ai21: "AI21",
     AionLabs: "AionLabs",
     Alibaba: "Alibaba",
@@ -61,6 +62,7 @@ export const ProviderName = {
     Parasail: "Parasail",
     Perplexity: "Perplexity",
     Phala: "Phala",
+    Reka: "Reka",
     Relace: "Relace",
     SambaNova: "SambaNova",
     Seed: "Seed",

package/esm/models/providerpreferences.d.ts

@@ -12,12 +12,14 @@ export declare const ProviderPreferencesSortEnum: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
+    readonly Exacto: "exacto";
 };
 export type ProviderPreferencesSortEnum = OpenEnum<typeof ProviderPreferencesSortEnum>;
 export declare const ProviderPreferencesProviderSortConfigEnum: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
+    readonly Exacto: "exacto";
 };
 export type ProviderPreferencesProviderSortConfigEnum = ClosedEnum<typeof ProviderPreferencesProviderSortConfigEnum>;
 /**
@@ -27,6 +29,7 @@ export declare const ProviderPreferencesBy: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
+    readonly Exacto: "exacto";
 };
 /**
  * The provider sorting strategy (price, throughput, latency)
@@ -53,6 +56,9 @@ export type ProviderPreferencesProviderSortConfig = {
      */
     partition?: ProviderPreferencesPartition | null | undefined;
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export type ProviderPreferencesProviderSortConfigUnion = ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum;
 /**
  * The provider sorting strategy (price, throughput, latency)
@@ -61,6 +67,7 @@ export declare const ProviderPreferencesProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
+    readonly Exacto: "exacto";
 };
 /**
  * The provider sorting strategy (price, throughput, latency)

package/esm/models/providerpreferences.js

@@ -14,11 +14,13 @@ export const ProviderPreferencesSortEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
+    Exacto: "exacto",
 };
 export const ProviderPreferencesProviderSortConfigEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
+    Exacto: "exacto",
 };
 /**
  * The provider sorting strategy (price, throughput, latency)
@@ -27,6 +29,7 @@ export const ProviderPreferencesBy = {
     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.
@@ -42,6 +45,7 @@ export const ProviderPreferencesProviderSort = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
+    Exacto: "exacto",
 };
 /** @internal */
 export const ProviderPreferencesOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);

package/esm/models/providersort.d.ts

@@ -7,6 +7,7 @@ export declare const ProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
+    readonly Exacto: "exacto";
 };
 /**
  * The provider sorting strategy (price, throughput, latency)

package/esm/models/providersort.js

@@ -10,6 +10,7 @@ export const ProviderSort = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
+    Exacto: "exacto",
 };
 /** @internal */
 export const ProviderSort$outboundSchema = openEnums.outboundSchema(ProviderSort);

package/esm/models/providersortconfig.d.ts

@@ -7,6 +7,7 @@ export declare const By: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
+    readonly Exacto: "exacto";
 };
 /**
  * The provider sorting strategy (price, throughput, latency)

package/esm/models/providersortconfig.js

@@ -11,6 +11,7 @@ export const By = {
     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.

package/esm/models/reasoningconfig.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { ReasoningEffortEnum } from "./reasoningeffortenum.js";
+import { ReasoningSummaryVerbosityEnum } from "./reasoningsummaryverbosityenum.js";
+/**
+ * Configuration for reasoning mode in the response
+ */
+export type ReasoningConfig = {
+    effort?: ReasoningEffortEnum | null | undefined;
+    summary?: ReasoningSummaryVerbosityEnum | null | undefined;
+    maxTokens?: number | null | undefined;
+    enabled?: boolean | null | undefined;
+};
+/** @internal */
+export type ReasoningConfig$Outbound = {
+    effort?: string | null | undefined;
+    summary?: string | null | undefined;
+    max_tokens?: number | null | undefined;
+    enabled?: boolean | null | 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 { ReasoningEffortEnum$outboundSchema, } from "./reasoningeffortenum.js";
+import { ReasoningSummaryVerbosityEnum$outboundSchema, } from "./reasoningsummaryverbosityenum.js";
+/** @internal */
+export const ReasoningConfig$outboundSchema = z.object({
+    effort: z.nullable(ReasoningEffortEnum$outboundSchema).optional(),
+    summary: z.nullable(ReasoningSummaryVerbosityEnum$outboundSchema).optional(),
+    maxTokens: z.nullable(z.number()).optional(),
+    enabled: z.nullable(z.boolean()).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,7 +4,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Event emitted when reasoning text delta is streamed
  */
-export type OpenResponsesReasoningDeltaEvent = {
+export type ReasoningDeltaEvent = {
     type: "response.reasoning_text.delta";
     outputIndex: number;
     itemId: string;
@@ -13,6 +13,6 @@ export type OpenResponsesReasoningDeltaEvent = {
     sequenceNumber: number;
 };
 /** @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,12 +1,12 @@
 /*
  * 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({
+export const ReasoningDeltaEvent$inboundSchema = z.object({
     type: z.literal("response.reasoning_text.delta"),
     output_index: z.number(),
     item_id: z.string(),
@@ -21,7 +21,7 @@ export const OpenResponsesReasoningDeltaEvent$inboundSchema = z.object({
         "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

package/esm/models/{openresponsesreasoningdoneevent.d.ts → reasoningdoneevent.d.ts}

@@ -4,7 +4,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Event emitted when reasoning text streaming is complete
  */
-export type OpenResponsesReasoningDoneEvent = {
+export type ReasoningDoneEvent = {
     type: "response.reasoning_text.done";
     outputIndex: number;
     itemId: string;
@@ -13,6 +13,6 @@ export type OpenResponsesReasoningDoneEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningDoneEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent, unknown>;
-export declare function openResponsesReasoningDoneEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDoneEvent, SDKValidationError>;
-//# sourceMappingURL=openresponsesreasoningdoneevent.d.ts.map
+export declare const ReasoningDoneEvent$inboundSchema: z.ZodType<ReasoningDoneEvent, unknown>;
+export declare function reasoningDoneEventFromJSON(jsonString: string): SafeParseResult<ReasoningDoneEvent, SDKValidationError>;
+//# sourceMappingURL=reasoningdoneevent.d.ts.map

package/esm/models/{openresponsesreasoningdoneevent.js → reasoningdoneevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: f76803b0bdd0
+ * @generated-id: 3af93f83e103
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesReasoningDoneEvent$inboundSchema = z.object({
+export const ReasoningDoneEvent$inboundSchema = z.object({
     type: z.literal("response.reasoning_text.done"),
     output_index: z.number(),
     item_id: z.string(),
@@ -21,7 +21,7 @@ export const OpenResponsesReasoningDoneEvent$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesReasoningDoneEventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesReasoningDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningDoneEvent' from JSON`);
+export function reasoningDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningDoneEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesreasoningdoneevent.js.map
+//# sourceMappingURL=reasoningdoneevent.js.map

package/esm/models/reasoningeffortenum.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ReasoningEffortEnum: {
+    readonly Xhigh: "xhigh";
+    readonly High: "high";
+    readonly Medium: "medium";
+    readonly Low: "low";
+    readonly Minimal: "minimal";
+    readonly None: "none";
+};
+export type ReasoningEffortEnum = OpenEnum<typeof ReasoningEffortEnum>;
+/** @internal */
+export declare const ReasoningEffortEnum$inboundSchema: z.ZodType<ReasoningEffortEnum, unknown>;
+/** @internal */
+export declare const ReasoningEffortEnum$outboundSchema: z.ZodType<string, ReasoningEffortEnum>;
+//# sourceMappingURL=reasoningeffortenum.d.ts.map

package/esm/models/reasoningeffortenum.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9559eb443bab
+ */
+import * as openEnums from "../types/enums.js";
+export const ReasoningEffortEnum = {
+    Xhigh: "xhigh",
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+    Minimal: "minimal",
+    None: "none",
+};
+/** @internal */
+export const ReasoningEffortEnum$inboundSchema = openEnums.inboundSchema(ReasoningEffortEnum);
+/** @internal */
+export const ReasoningEffortEnum$outboundSchema = openEnums.outboundSchema(ReasoningEffortEnum);
+//# sourceMappingURL=reasoningeffortenum.js.map

package/esm/models/reasoningitem.d.ts

@@ -0,0 +1,73 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
+import { ReasoningTextContent, ReasoningTextContent$Outbound } from "./reasoningtextcontent.js";
+export declare const ReasoningItemType: {
+    readonly Reasoning: "reasoning";
+};
+export type ReasoningItemType = ClosedEnum<typeof ReasoningItemType>;
+export declare const ReasoningItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type ReasoningItemStatusInProgress = ClosedEnum<typeof ReasoningItemStatusInProgress>;
+export declare const ReasoningItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type ReasoningItemStatusIncomplete = ClosedEnum<typeof ReasoningItemStatusIncomplete>;
+export declare const ReasoningItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type ReasoningItemStatusCompleted = ClosedEnum<typeof ReasoningItemStatusCompleted>;
+export type ReasoningItemStatusUnion = ReasoningItemStatusCompleted | ReasoningItemStatusIncomplete | ReasoningItemStatusInProgress;
+export declare const ReasoningItemFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+export type ReasoningItemFormat = OpenEnum<typeof ReasoningItemFormat>;
+/**
+ * Reasoning output item with signature and format extensions
+ */
+export type ReasoningItem = {
+    type: ReasoningItemType;
+    id: string;
+    content?: Array<ReasoningTextContent> | null | undefined;
+    summary: Array<ReasoningSummaryText>;
+    encryptedContent?: string | null | undefined;
+    status?: ReasoningItemStatusCompleted | ReasoningItemStatusIncomplete | ReasoningItemStatusInProgress | undefined;
+    signature?: string | null | undefined;
+    format?: ReasoningItemFormat | null | undefined;
+};
+/** @internal */
+export declare const ReasoningItemType$outboundSchema: z.ZodEnum<typeof ReasoningItemType>;
+/** @internal */
+export declare const ReasoningItemStatusInProgress$outboundSchema: z.ZodEnum<typeof ReasoningItemStatusInProgress>;
+/** @internal */
+export declare const ReasoningItemStatusIncomplete$outboundSchema: z.ZodEnum<typeof ReasoningItemStatusIncomplete>;
+/** @internal */
+export declare const ReasoningItemStatusCompleted$outboundSchema: z.ZodEnum<typeof ReasoningItemStatusCompleted>;
+/** @internal */
+export type ReasoningItemStatusUnion$Outbound = string | string | string;
+/** @internal */
+export declare const ReasoningItemStatusUnion$outboundSchema: z.ZodType<ReasoningItemStatusUnion$Outbound, ReasoningItemStatusUnion>;
+export declare function reasoningItemStatusUnionToJSON(reasoningItemStatusUnion: ReasoningItemStatusUnion): string;
+/** @internal */
+export declare const ReasoningItemFormat$outboundSchema: z.ZodType<string, ReasoningItemFormat>;
+/** @internal */
+export type ReasoningItem$Outbound = {
+    type: string;
+    id: string;
+    content?: Array<ReasoningTextContent$Outbound> | null | undefined;
+    summary: Array<ReasoningSummaryText$Outbound>;
+    encrypted_content?: string | null | undefined;
+    status?: string | string | string | undefined;
+    signature?: string | null | undefined;
+    format?: string | null | undefined;
+};
+/** @internal */
+export declare const ReasoningItem$outboundSchema: z.ZodType<ReasoningItem$Outbound, ReasoningItem>;
+export declare function reasoningItemToJSON(reasoningItem: ReasoningItem): string;
+//# sourceMappingURL=reasoningitem.d.ts.map

package/esm/models/reasoningitem.js

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 347a000c48b1
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { ReasoningSummaryText$outboundSchema, } from "./reasoningsummarytext.js";
+import { ReasoningTextContent$outboundSchema, } from "./reasoningtextcontent.js";
+export const ReasoningItemType = {
+    Reasoning: "reasoning",
+};
+export const ReasoningItemStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const ReasoningItemStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const ReasoningItemStatusCompleted = {
+    Completed: "completed",
+};
+export const ReasoningItemFormat = {
+    Unknown: "unknown",
+    OpenaiResponsesV1: "openai-responses-v1",
+    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
+    XaiResponsesV1: "xai-responses-v1",
+    AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
+};
+/** @internal */
+export const ReasoningItemType$outboundSchema = z.enum(ReasoningItemType);
+/** @internal */
+export const ReasoningItemStatusInProgress$outboundSchema = z.enum(ReasoningItemStatusInProgress);
+/** @internal */
+export const ReasoningItemStatusIncomplete$outboundSchema = z.enum(ReasoningItemStatusIncomplete);
+/** @internal */
+export const ReasoningItemStatusCompleted$outboundSchema = z.enum(ReasoningItemStatusCompleted);
+/** @internal */
+export const ReasoningItemStatusUnion$outboundSchema = z.union([
+    ReasoningItemStatusCompleted$outboundSchema,
+    ReasoningItemStatusIncomplete$outboundSchema,
+    ReasoningItemStatusInProgress$outboundSchema,
+]);
+export function reasoningItemStatusUnionToJSON(reasoningItemStatusUnion) {
+    return JSON.stringify(ReasoningItemStatusUnion$outboundSchema.parse(reasoningItemStatusUnion));
+}
+/** @internal */
+export const ReasoningItemFormat$outboundSchema = openEnums.outboundSchema(ReasoningItemFormat);
+/** @internal */
+export const ReasoningItem$outboundSchema = z.object({
+    type: ReasoningItemType$outboundSchema,
+    id: z.string(),
+    content: z.nullable(z.array(ReasoningTextContent$outboundSchema)).optional(),
+    summary: z.array(ReasoningSummaryText$outboundSchema),
+    encryptedContent: z.nullable(z.string()).optional(),
+    status: z.union([
+        ReasoningItemStatusCompleted$outboundSchema,
+        ReasoningItemStatusIncomplete$outboundSchema,
+        ReasoningItemStatusInProgress$outboundSchema,
+    ]).optional(),
+    signature: z.nullable(z.string()).optional(),
+    format: z.nullable(ReasoningItemFormat$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        encryptedContent: "encrypted_content",
+    });
+});
+export function reasoningItemToJSON(reasoningItem) {
+    return JSON.stringify(ReasoningItem$outboundSchema.parse(reasoningItem));
+}
+//# sourceMappingURL=reasoningitem.js.map

package/esm/models/{openresponsesreasoningsummarypartaddedevent.d.ts → reasoningsummarypartaddedevent.d.ts}

@@ -5,7 +5,7 @@ import { ReasoningSummaryText } from "./reasoningsummarytext.js";
 /**
  * Event emitted when a reasoning summary part is added
  */
-export type OpenResponsesReasoningSummaryPartAddedEvent = {
+export type ReasoningSummaryPartAddedEvent = {
     type: "response.reasoning_summary_part.added";
     outputIndex: number;
     itemId: string;
@@ -14,6 +14,6 @@ export type OpenResponsesReasoningSummaryPartAddedEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent, unknown>;
-export declare function openResponsesReasoningSummaryPartAddedEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryPartAddedEvent, SDKValidationError>;
-//# sourceMappingURL=openresponsesreasoningsummarypartaddedevent.d.ts.map
+export declare const ReasoningSummaryPartAddedEvent$inboundSchema: z.ZodType<ReasoningSummaryPartAddedEvent, unknown>;
+export declare function reasoningSummaryPartAddedEventFromJSON(jsonString: string): SafeParseResult<ReasoningSummaryPartAddedEvent, SDKValidationError>;
+//# sourceMappingURL=reasoningsummarypartaddedevent.d.ts.map

package/esm/models/{openresponsesreasoningsummarypartaddedevent.js → reasoningsummarypartaddedevent.js}

@@ -1,13 +1,13 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: e83b9ca2ee64
+ * @generated-id: aca3bffec6c2
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
 /** @internal */
-export const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema = z.object({
+export const ReasoningSummaryPartAddedEvent$inboundSchema = z.object({
     type: z.literal("response.reasoning_summary_part.added"),
     output_index: z.number(),
     item_id: z.string(),
@@ -22,7 +22,7 @@ export const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema = z.objec
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesReasoningSummaryPartAddedEventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningSummaryPartAddedEvent' from JSON`);
+export function reasoningSummaryPartAddedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningSummaryPartAddedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningSummaryPartAddedEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesreasoningsummarypartaddedevent.js.map
+//# sourceMappingURL=reasoningsummarypartaddedevent.js.map

package/esm/models/reasoningsummarypartdoneevent.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ReasoningSummaryText } from "./reasoningsummarytext.js";
+/**
+ * Event emitted when a reasoning summary part is complete
+ */
+export type ReasoningSummaryPartDoneEvent = {
+    type: "response.reasoning_summary_part.done";
+    outputIndex: number;
+    itemId: string;
+    summaryIndex: number;
+    part: ReasoningSummaryText;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ReasoningSummaryPartDoneEvent$inboundSchema: z.ZodType<ReasoningSummaryPartDoneEvent, unknown>;
+export declare function reasoningSummaryPartDoneEventFromJSON(jsonString: string): SafeParseResult<ReasoningSummaryPartDoneEvent, SDKValidationError>;
+//# sourceMappingURL=reasoningsummarypartdoneevent.d.ts.map

package/esm/models/reasoningsummarypartdoneevent.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5917fb728157
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
+/** @internal */
+export const ReasoningSummaryPartDoneEvent$inboundSchema = z.object({
+    type: z.literal("response.reasoning_summary_part.done"),
+    output_index: z.number(),
+    item_id: z.string(),
+    summary_index: z.number(),
+    part: ReasoningSummaryText$inboundSchema,
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "summary_index": "summaryIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function reasoningSummaryPartDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningSummaryPartDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningSummaryPartDoneEvent' from JSON`);
+}
+//# sourceMappingURL=reasoningsummarypartdoneevent.js.map

package/esm/models/reasoningsummarytextdeltaevent.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Event emitted when reasoning summary text delta is streamed
+ */
+export type ReasoningSummaryTextDeltaEvent = {
+    type: "response.reasoning_summary_text.delta";
+    itemId: string;
+    outputIndex: number;
+    summaryIndex: number;
+    delta: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ReasoningSummaryTextDeltaEvent$inboundSchema: z.ZodType<ReasoningSummaryTextDeltaEvent, unknown>;
+export declare function reasoningSummaryTextDeltaEventFromJSON(jsonString: string): SafeParseResult<ReasoningSummaryTextDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=reasoningsummarytextdeltaevent.d.ts.map

package/esm/models/{openresponsesreasoningsummarytextdeltaevent.js → reasoningsummarytextdeltaevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 61ee69f0a41f
+ * @generated-id: 888dc7b3074b
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema = z.object({
+export const ReasoningSummaryTextDeltaEvent$inboundSchema = z.object({
     type: z.literal("response.reasoning_summary_text.delta"),
     item_id: z.string(),
     output_index: z.number(),
@@ -21,7 +21,7 @@ export const OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema = z.objec
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesReasoningSummaryTextDeltaEventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningSummaryTextDeltaEvent' from JSON`);
+export function reasoningSummaryTextDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningSummaryTextDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningSummaryTextDeltaEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesreasoningsummarytextdeltaevent.js.map
+//# sourceMappingURL=reasoningsummarytextdeltaevent.js.map

package/esm/models/reasoningsummarytextdoneevent.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Event emitted when reasoning summary text streaming is complete
+ */
+export type ReasoningSummaryTextDoneEvent = {
+    type: "response.reasoning_summary_text.done";
+    itemId: string;
+    outputIndex: number;
+    summaryIndex: number;
+    text: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ReasoningSummaryTextDoneEvent$inboundSchema: z.ZodType<ReasoningSummaryTextDoneEvent, unknown>;
+export declare function reasoningSummaryTextDoneEventFromJSON(jsonString: string): SafeParseResult<ReasoningSummaryTextDoneEvent, SDKValidationError>;
+//# sourceMappingURL=reasoningsummarytextdoneevent.d.ts.map

package/esm/models/{openresponsesreasoningsummarytextdoneevent.js → reasoningsummarytextdoneevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 0519f084cea8
+ * @generated-id: 4945c757d284
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesReasoningSummaryTextDoneEvent$inboundSchema = z.object({
+export const ReasoningSummaryTextDoneEvent$inboundSchema = z.object({
     type: z.literal("response.reasoning_summary_text.done"),
     item_id: z.string(),
     output_index: z.number(),
@@ -21,7 +21,7 @@ export const OpenResponsesReasoningSummaryTextDoneEvent$inboundSchema = z.object
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesReasoningSummaryTextDoneEventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesReasoningSummaryTextDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningSummaryTextDoneEvent' from JSON`);
+export function reasoningSummaryTextDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReasoningSummaryTextDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReasoningSummaryTextDoneEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesreasoningsummarytextdoneevent.js.map
+//# sourceMappingURL=reasoningsummarytextdoneevent.js.map