@openrouter/sdk 0.0.1-beta.8 → 0.0.1

package/esm/models/openresponsesreasoningconfig.js

@@ -4,40 +4,11 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, } from "../types/enums.js";
+import { OpenAIResponsesReasoningEffort$inboundSchema, OpenAIResponsesReasoningEffort$outboundSchema, } from "./openairesponsesreasoningeffort.js";
 import { ReasoningSummaryVerbosity$inboundSchema, ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
-export const OpenResponsesReasoningConfigEffort = {
-    High: "high",
-    Medium: "medium",
-    Low: "low",
-    Minimal: "minimal",
-};
-/** @internal */
-export const OpenResponsesReasoningConfigEffort$inboundSchema = z
-    .union([
-    z.enum(OpenResponsesReasoningConfigEffort),
-    z.string().transform(catchUnrecognizedEnum),
-]);
-/** @internal */
-export const OpenResponsesReasoningConfigEffort$outboundSchema = z.union([
-    z.enum(OpenResponsesReasoningConfigEffort),
-    z.string().and(z.custom()),
-]);
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var OpenResponsesReasoningConfigEffort$;
-(function (OpenResponsesReasoningConfigEffort$) {
-    /** @deprecated use `OpenResponsesReasoningConfigEffort$inboundSchema` instead. */
-    OpenResponsesReasoningConfigEffort$.inboundSchema = OpenResponsesReasoningConfigEffort$inboundSchema;
-    /** @deprecated use `OpenResponsesReasoningConfigEffort$outboundSchema` instead. */
-    OpenResponsesReasoningConfigEffort$.outboundSchema = OpenResponsesReasoningConfigEffort$outboundSchema;
-})(OpenResponsesReasoningConfigEffort$ || (OpenResponsesReasoningConfigEffort$ = {}));
 /** @internal */
 export const OpenResponsesReasoningConfig$inboundSchema = z.object({
-    effort: z.nullable(OpenResponsesReasoningConfigEffort$inboundSchema)
-        .optional(),
+    effort: z.nullable(OpenAIResponsesReasoningEffort$inboundSchema).optional(),
     summary: ReasoningSummaryVerbosity$inboundSchema.optional(),
     max_tokens: z.nullable(z.number()).optional(),
     enabled: z.nullable(z.boolean()).optional(),
@@ -48,8 +19,7 @@ export const OpenResponsesReasoningConfig$inboundSchema = z.object({
 });
 /** @internal */
 export const OpenResponsesReasoningConfig$outboundSchema = z.object({
-    effort: z.nullable(OpenResponsesReasoningConfigEffort$outboundSchema)
-        .optional(),
+    effort: z.nullable(OpenAIResponsesReasoningEffort$outboundSchema).optional(),
     summary: ReasoningSummaryVerbosity$outboundSchema.optional(),
     maxTokens: z.nullable(z.number()).optional(),
     enabled: z.nullable(z.boolean()).optional(),

package/esm/models/openresponsesreasoningdeltaevent.d.ts

@@ -0,0 +1,65 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesReasoningDeltaEventType: {
+    readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
+};
+export type OpenResponsesReasoningDeltaEventType = ClosedEnum<typeof OpenResponsesReasoningDeltaEventType>;
+/**
+ * Event emitted when reasoning text delta is streamed
+ */
+export type OpenResponsesReasoningDeltaEvent = {
+    type: OpenResponsesReasoningDeltaEventType;
+    outputIndex: number;
+    itemId: string;
+    contentIndex: number;
+    delta: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDeltaEventType>;
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEventType$outboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDeltaEventType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningDeltaEventType$ {
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
+    }>;
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown>;
+/** @internal */
+export type OpenResponsesReasoningDeltaEvent$Outbound = {
+    type: string;
+    output_index: number;
+    item_id: string;
+    content_index: number;
+    delta: string;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEvent$outboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent$Outbound, OpenResponsesReasoningDeltaEvent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningDeltaEvent$ {
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown, z.core.$ZodTypeInternals<OpenResponsesReasoningDeltaEvent, unknown>>;
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent$Outbound, OpenResponsesReasoningDeltaEvent, z.core.$ZodTypeInternals<OpenResponsesReasoningDeltaEvent$Outbound, OpenResponsesReasoningDeltaEvent>>;
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$Outbound` instead. */
+    type Outbound = OpenResponsesReasoningDeltaEvent$Outbound;
+}
+export declare function openResponsesReasoningDeltaEventToJSON(openResponsesReasoningDeltaEvent: OpenResponsesReasoningDeltaEvent): string;
+export declare function openResponsesReasoningDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=openresponsesreasoningdeltaevent.d.ts.map

package/esm/models/openresponsesreasoningdeltaevent.js

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesReasoningDeltaEventType = {
+    ResponseReasoningTextDelta: "response.reasoning_text.delta",
+};
+/** @internal */
+export const OpenResponsesReasoningDeltaEventType$inboundSchema = z.enum(OpenResponsesReasoningDeltaEventType);
+/** @internal */
+export const OpenResponsesReasoningDeltaEventType$outboundSchema = OpenResponsesReasoningDeltaEventType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningDeltaEventType$;
+(function (OpenResponsesReasoningDeltaEventType$) {
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$inboundSchema` instead. */
+    OpenResponsesReasoningDeltaEventType$.inboundSchema = OpenResponsesReasoningDeltaEventType$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$outboundSchema` instead. */
+    OpenResponsesReasoningDeltaEventType$.outboundSchema = OpenResponsesReasoningDeltaEventType$outboundSchema;
+})(OpenResponsesReasoningDeltaEventType$ || (OpenResponsesReasoningDeltaEventType$ = {}));
+/** @internal */
+export const OpenResponsesReasoningDeltaEvent$inboundSchema = z.object({
+    type: OpenResponsesReasoningDeltaEventType$inboundSchema,
+    output_index: z.number(),
+    item_id: z.string(),
+    content_index: z.number(),
+    delta: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "content_index": "contentIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesReasoningDeltaEvent$outboundSchema = z.object({
+    type: OpenResponsesReasoningDeltaEventType$outboundSchema,
+    outputIndex: z.number(),
+    itemId: z.string(),
+    contentIndex: z.number(),
+    delta: z.string(),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        outputIndex: "output_index",
+        itemId: "item_id",
+        contentIndex: "content_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningDeltaEvent$;
+(function (OpenResponsesReasoningDeltaEvent$) {
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$inboundSchema` instead. */
+    OpenResponsesReasoningDeltaEvent$.inboundSchema = OpenResponsesReasoningDeltaEvent$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$outboundSchema` instead. */
+    OpenResponsesReasoningDeltaEvent$.outboundSchema = OpenResponsesReasoningDeltaEvent$outboundSchema;
+})(OpenResponsesReasoningDeltaEvent$ || (OpenResponsesReasoningDeltaEvent$ = {}));
+export function openResponsesReasoningDeltaEventToJSON(openResponsesReasoningDeltaEvent) {
+    return JSON.stringify(OpenResponsesReasoningDeltaEvent$outboundSchema.parse(openResponsesReasoningDeltaEvent));
+}
+export function openResponsesReasoningDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesReasoningDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningDeltaEvent' from JSON`);
+}
+//# sourceMappingURL=openresponsesreasoningdeltaevent.js.map

package/esm/models/openresponsesreasoningdoneevent.d.ts

@@ -0,0 +1,65 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesReasoningDoneEventType: {
+    readonly ResponseReasoningTextDone: "response.reasoning_text.done";
+};
+export type OpenResponsesReasoningDoneEventType = ClosedEnum<typeof OpenResponsesReasoningDoneEventType>;
+/**
+ * Event emitted when reasoning text streaming is complete
+ */
+export type OpenResponsesReasoningDoneEvent = {
+    type: OpenResponsesReasoningDoneEventType;
+    outputIndex: number;
+    itemId: string;
+    contentIndex: number;
+    text: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningDoneEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDoneEventType>;
+/** @internal */
+export declare const OpenResponsesReasoningDoneEventType$outboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDoneEventType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningDoneEventType$ {
+    /** @deprecated use `OpenResponsesReasoningDoneEventType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningTextDone: "response.reasoning_text.done";
+    }>;
+    /** @deprecated use `OpenResponsesReasoningDoneEventType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningTextDone: "response.reasoning_text.done";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesReasoningDoneEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent, unknown>;
+/** @internal */
+export type OpenResponsesReasoningDoneEvent$Outbound = {
+    type: string;
+    output_index: number;
+    item_id: string;
+    content_index: number;
+    text: string;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningDoneEvent$outboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent$Outbound, OpenResponsesReasoningDoneEvent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningDoneEvent$ {
+    /** @deprecated use `OpenResponsesReasoningDoneEvent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent, unknown, z.core.$ZodTypeInternals<OpenResponsesReasoningDoneEvent, unknown>>;
+    /** @deprecated use `OpenResponsesReasoningDoneEvent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent$Outbound, OpenResponsesReasoningDoneEvent, z.core.$ZodTypeInternals<OpenResponsesReasoningDoneEvent$Outbound, OpenResponsesReasoningDoneEvent>>;
+    /** @deprecated use `OpenResponsesReasoningDoneEvent$Outbound` instead. */
+    type Outbound = OpenResponsesReasoningDoneEvent$Outbound;
+}
+export declare function openResponsesReasoningDoneEventToJSON(openResponsesReasoningDoneEvent: OpenResponsesReasoningDoneEvent): string;
+export declare function openResponsesReasoningDoneEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDoneEvent, SDKValidationError>;
+//# sourceMappingURL=openresponsesreasoningdoneevent.d.ts.map

package/esm/models/openresponsesreasoningdoneevent.js

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesReasoningDoneEventType = {
+    ResponseReasoningTextDone: "response.reasoning_text.done",
+};
+/** @internal */
+export const OpenResponsesReasoningDoneEventType$inboundSchema = z.enum(OpenResponsesReasoningDoneEventType);
+/** @internal */
+export const OpenResponsesReasoningDoneEventType$outboundSchema = OpenResponsesReasoningDoneEventType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningDoneEventType$;
+(function (OpenResponsesReasoningDoneEventType$) {
+    /** @deprecated use `OpenResponsesReasoningDoneEventType$inboundSchema` instead. */
+    OpenResponsesReasoningDoneEventType$.inboundSchema = OpenResponsesReasoningDoneEventType$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningDoneEventType$outboundSchema` instead. */
+    OpenResponsesReasoningDoneEventType$.outboundSchema = OpenResponsesReasoningDoneEventType$outboundSchema;
+})(OpenResponsesReasoningDoneEventType$ || (OpenResponsesReasoningDoneEventType$ = {}));
+/** @internal */
+export const OpenResponsesReasoningDoneEvent$inboundSchema = z.object({
+    type: OpenResponsesReasoningDoneEventType$inboundSchema,
+    output_index: z.number(),
+    item_id: z.string(),
+    content_index: z.number(),
+    text: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "content_index": "contentIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesReasoningDoneEvent$outboundSchema = z.object({
+    type: OpenResponsesReasoningDoneEventType$outboundSchema,
+    outputIndex: z.number(),
+    itemId: z.string(),
+    contentIndex: z.number(),
+    text: z.string(),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        outputIndex: "output_index",
+        itemId: "item_id",
+        contentIndex: "content_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningDoneEvent$;
+(function (OpenResponsesReasoningDoneEvent$) {
+    /** @deprecated use `OpenResponsesReasoningDoneEvent$inboundSchema` instead. */
+    OpenResponsesReasoningDoneEvent$.inboundSchema = OpenResponsesReasoningDoneEvent$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningDoneEvent$outboundSchema` instead. */
+    OpenResponsesReasoningDoneEvent$.outboundSchema = OpenResponsesReasoningDoneEvent$outboundSchema;
+})(OpenResponsesReasoningDoneEvent$ || (OpenResponsesReasoningDoneEvent$ = {}));
+export function openResponsesReasoningDoneEventToJSON(openResponsesReasoningDoneEvent) {
+    return JSON.stringify(OpenResponsesReasoningDoneEvent$outboundSchema.parse(openResponsesReasoningDoneEvent));
+}
+export function openResponsesReasoningDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesReasoningDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningDoneEvent' from JSON`);
+}
+//# sourceMappingURL=openresponsesreasoningdoneevent.js.map

package/esm/models/openresponsesreasoningsummarypartaddedevent.d.ts

@@ -0,0 +1,66 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
+export declare const OpenResponsesReasoningSummaryPartAddedEventType: {
+    readonly ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added";
+};
+export type OpenResponsesReasoningSummaryPartAddedEventType = ClosedEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
+/**
+ * Event emitted when a reasoning summary part is added
+ */
+export type OpenResponsesReasoningSummaryPartAddedEvent = {
+    type: OpenResponsesReasoningSummaryPartAddedEventType;
+    outputIndex: number;
+    itemId: string;
+    summaryIndex: number;
+    part: ReasoningSummaryText;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
+/** @internal */
+export declare const OpenResponsesReasoningSummaryPartAddedEventType$outboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningSummaryPartAddedEventType$ {
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added";
+    }>;
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEventType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent, unknown>;
+/** @internal */
+export type OpenResponsesReasoningSummaryPartAddedEvent$Outbound = {
+    type: string;
+    output_index: number;
+    item_id: string;
+    summary_index: number;
+    part: ReasoningSummaryText$Outbound;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningSummaryPartAddedEvent$outboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent$Outbound, OpenResponsesReasoningSummaryPartAddedEvent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningSummaryPartAddedEvent$ {
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent, unknown, z.core.$ZodTypeInternals<OpenResponsesReasoningSummaryPartAddedEvent, unknown>>;
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEvent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent$Outbound, OpenResponsesReasoningSummaryPartAddedEvent, z.core.$ZodTypeInternals<OpenResponsesReasoningSummaryPartAddedEvent$Outbound, OpenResponsesReasoningSummaryPartAddedEvent>>;
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEvent$Outbound` instead. */
+    type Outbound = OpenResponsesReasoningSummaryPartAddedEvent$Outbound;
+}
+export declare function openResponsesReasoningSummaryPartAddedEventToJSON(openResponsesReasoningSummaryPartAddedEvent: OpenResponsesReasoningSummaryPartAddedEvent): string;
+export declare function openResponsesReasoningSummaryPartAddedEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryPartAddedEvent, SDKValidationError>;
+//# sourceMappingURL=openresponsesreasoningsummarypartaddedevent.d.ts.map

package/esm/models/openresponsesreasoningsummarypartaddedevent.js

@@ -0,0 +1,75 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ReasoningSummaryText$inboundSchema, ReasoningSummaryText$outboundSchema, } from "./reasoningsummarytext.js";
+export const OpenResponsesReasoningSummaryPartAddedEventType = {
+    ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added",
+};
+/** @internal */
+export const OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema = z.enum(OpenResponsesReasoningSummaryPartAddedEventType);
+/** @internal */
+export const OpenResponsesReasoningSummaryPartAddedEventType$outboundSchema = OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningSummaryPartAddedEventType$;
+(function (OpenResponsesReasoningSummaryPartAddedEventType$) {
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema` instead. */
+    OpenResponsesReasoningSummaryPartAddedEventType$.inboundSchema = OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEventType$outboundSchema` instead. */
+    OpenResponsesReasoningSummaryPartAddedEventType$.outboundSchema = OpenResponsesReasoningSummaryPartAddedEventType$outboundSchema;
+})(OpenResponsesReasoningSummaryPartAddedEventType$ || (OpenResponsesReasoningSummaryPartAddedEventType$ = {}));
+/** @internal */
+export const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema = z.object({
+    type: OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema,
+    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",
+    });
+});
+/** @internal */
+export const OpenResponsesReasoningSummaryPartAddedEvent$outboundSchema = z.object({
+    type: OpenResponsesReasoningSummaryPartAddedEventType$outboundSchema,
+    outputIndex: z.number(),
+    itemId: z.string(),
+    summaryIndex: z.number(),
+    part: ReasoningSummaryText$outboundSchema,
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        outputIndex: "output_index",
+        itemId: "item_id",
+        summaryIndex: "summary_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningSummaryPartAddedEvent$;
+(function (OpenResponsesReasoningSummaryPartAddedEvent$) {
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema` instead. */
+    OpenResponsesReasoningSummaryPartAddedEvent$.inboundSchema = OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningSummaryPartAddedEvent$outboundSchema` instead. */
+    OpenResponsesReasoningSummaryPartAddedEvent$.outboundSchema = OpenResponsesReasoningSummaryPartAddedEvent$outboundSchema;
+})(OpenResponsesReasoningSummaryPartAddedEvent$ || (OpenResponsesReasoningSummaryPartAddedEvent$ = {}));
+export function openResponsesReasoningSummaryPartAddedEventToJSON(openResponsesReasoningSummaryPartAddedEvent) {
+    return JSON.stringify(OpenResponsesReasoningSummaryPartAddedEvent$outboundSchema.parse(openResponsesReasoningSummaryPartAddedEvent));
+}
+export function openResponsesReasoningSummaryPartAddedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningSummaryPartAddedEvent' from JSON`);
+}
+//# sourceMappingURL=openresponsesreasoningsummarypartaddedevent.js.map

package/esm/models/openresponsesreasoningsummarytextdeltaevent.d.ts

@@ -0,0 +1,65 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesReasoningSummaryTextDeltaEventType: {
+    readonly ResponseReasoningSummaryTextDelta: "response.reasoning_summary_text.delta";
+};
+export type OpenResponsesReasoningSummaryTextDeltaEventType = ClosedEnum<typeof OpenResponsesReasoningSummaryTextDeltaEventType>;
+/**
+ * Event emitted when reasoning summary text delta is streamed
+ */
+export type OpenResponsesReasoningSummaryTextDeltaEvent = {
+    type: OpenResponsesReasoningSummaryTextDeltaEventType;
+    itemId: string;
+    outputIndex: number;
+    summaryIndex: number;
+    delta: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryTextDeltaEventType>;
+/** @internal */
+export declare const OpenResponsesReasoningSummaryTextDeltaEventType$outboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryTextDeltaEventType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningSummaryTextDeltaEventType$ {
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningSummaryTextDelta: "response.reasoning_summary_text.delta";
+    }>;
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEventType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningSummaryTextDelta: "response.reasoning_summary_text.delta";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryTextDeltaEvent, unknown>;
+/** @internal */
+export type OpenResponsesReasoningSummaryTextDeltaEvent$Outbound = {
+    type: string;
+    item_id: string;
+    output_index: number;
+    summary_index: number;
+    delta: string;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningSummaryTextDeltaEvent$outboundSchema: z.ZodType<OpenResponsesReasoningSummaryTextDeltaEvent$Outbound, OpenResponsesReasoningSummaryTextDeltaEvent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningSummaryTextDeltaEvent$ {
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesReasoningSummaryTextDeltaEvent, unknown, z.core.$ZodTypeInternals<OpenResponsesReasoningSummaryTextDeltaEvent, unknown>>;
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEvent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesReasoningSummaryTextDeltaEvent$Outbound, OpenResponsesReasoningSummaryTextDeltaEvent, z.core.$ZodTypeInternals<OpenResponsesReasoningSummaryTextDeltaEvent$Outbound, OpenResponsesReasoningSummaryTextDeltaEvent>>;
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEvent$Outbound` instead. */
+    type Outbound = OpenResponsesReasoningSummaryTextDeltaEvent$Outbound;
+}
+export declare function openResponsesReasoningSummaryTextDeltaEventToJSON(openResponsesReasoningSummaryTextDeltaEvent: OpenResponsesReasoningSummaryTextDeltaEvent): string;
+export declare function openResponsesReasoningSummaryTextDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryTextDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=openresponsesreasoningsummarytextdeltaevent.d.ts.map

package/esm/models/openresponsesreasoningsummarytextdeltaevent.js

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesReasoningSummaryTextDeltaEventType = {
+    ResponseReasoningSummaryTextDelta: "response.reasoning_summary_text.delta",
+};
+/** @internal */
+export const OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema = z.enum(OpenResponsesReasoningSummaryTextDeltaEventType);
+/** @internal */
+export const OpenResponsesReasoningSummaryTextDeltaEventType$outboundSchema = OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningSummaryTextDeltaEventType$;
+(function (OpenResponsesReasoningSummaryTextDeltaEventType$) {
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema` instead. */
+    OpenResponsesReasoningSummaryTextDeltaEventType$.inboundSchema = OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEventType$outboundSchema` instead. */
+    OpenResponsesReasoningSummaryTextDeltaEventType$.outboundSchema = OpenResponsesReasoningSummaryTextDeltaEventType$outboundSchema;
+})(OpenResponsesReasoningSummaryTextDeltaEventType$ || (OpenResponsesReasoningSummaryTextDeltaEventType$ = {}));
+/** @internal */
+export const OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema = z.object({
+    type: OpenResponsesReasoningSummaryTextDeltaEventType$inboundSchema,
+    item_id: z.string(),
+    output_index: z.number(),
+    summary_index: z.number(),
+    delta: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "summary_index": "summaryIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesReasoningSummaryTextDeltaEvent$outboundSchema = z.object({
+    type: OpenResponsesReasoningSummaryTextDeltaEventType$outboundSchema,
+    itemId: z.string(),
+    outputIndex: z.number(),
+    summaryIndex: z.number(),
+    delta: z.string(),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        itemId: "item_id",
+        outputIndex: "output_index",
+        summaryIndex: "summary_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningSummaryTextDeltaEvent$;
+(function (OpenResponsesReasoningSummaryTextDeltaEvent$) {
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema` instead. */
+    OpenResponsesReasoningSummaryTextDeltaEvent$.inboundSchema = OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningSummaryTextDeltaEvent$outboundSchema` instead. */
+    OpenResponsesReasoningSummaryTextDeltaEvent$.outboundSchema = OpenResponsesReasoningSummaryTextDeltaEvent$outboundSchema;
+})(OpenResponsesReasoningSummaryTextDeltaEvent$ || (OpenResponsesReasoningSummaryTextDeltaEvent$ = {}));
+export function openResponsesReasoningSummaryTextDeltaEventToJSON(openResponsesReasoningSummaryTextDeltaEvent) {
+    return JSON.stringify(OpenResponsesReasoningSummaryTextDeltaEvent$outboundSchema.parse(openResponsesReasoningSummaryTextDeltaEvent));
+}
+export function openResponsesReasoningSummaryTextDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesReasoningSummaryTextDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningSummaryTextDeltaEvent' from JSON`);
+}
+//# sourceMappingURL=openresponsesreasoningsummarytextdeltaevent.js.map