@openrouter/sdk 0.10.2 → 0.11.2

package/esm/models/easyinputmessage.js

@@ -0,0 +1,141 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0e3bca037a2a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { InputAudio$outboundSchema, } from "./inputaudio.js";
+import { InputFile$outboundSchema, } from "./inputfile.js";
+import { InputText$outboundSchema, } from "./inputtext.js";
+import { InputVideo$outboundSchema, } from "./inputvideo.js";
+export const EasyInputMessageTypeMessage = {
+    Message: "message",
+};
+export const EasyInputMessageRoleDeveloper = {
+    Developer: "developer",
+};
+export const EasyInputMessageRoleAssistant = {
+    Assistant: "assistant",
+};
+export const EasyInputMessageRoleSystem = {
+    System: "system",
+};
+export const EasyInputMessageRoleUser = {
+    User: "user",
+};
+export const EasyInputMessageDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+export const EasyInputMessagePhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const EasyInputMessagePhaseCommentary = {
+    Commentary: "commentary",
+};
+/** @internal */
+export const EasyInputMessageTypeMessage$outboundSchema = z.enum(EasyInputMessageTypeMessage);
+/** @internal */
+export const EasyInputMessageRoleDeveloper$outboundSchema = z.enum(EasyInputMessageRoleDeveloper);
+/** @internal */
+export const EasyInputMessageRoleAssistant$outboundSchema = z.enum(EasyInputMessageRoleAssistant);
+/** @internal */
+export const EasyInputMessageRoleSystem$outboundSchema = z.enum(EasyInputMessageRoleSystem);
+/** @internal */
+export const EasyInputMessageRoleUser$outboundSchema = z.enum(EasyInputMessageRoleUser);
+/** @internal */
+export const EasyInputMessageRoleUnion$outboundSchema = z.union([
+    EasyInputMessageRoleUser$outboundSchema,
+    EasyInputMessageRoleSystem$outboundSchema,
+    EasyInputMessageRoleAssistant$outboundSchema,
+    EasyInputMessageRoleDeveloper$outboundSchema,
+]);
+export function easyInputMessageRoleUnionToJSON(easyInputMessageRoleUnion) {
+    return JSON.stringify(EasyInputMessageRoleUnion$outboundSchema.parse(easyInputMessageRoleUnion));
+}
+/** @internal */
+export const EasyInputMessageDetail$outboundSchema = openEnums.outboundSchema(EasyInputMessageDetail);
+/** @internal */
+export const EasyInputMessageContentInputImage$outboundSchema = z.object({
+    type: z.literal("input_image"),
+    detail: EasyInputMessageDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function easyInputMessageContentInputImageToJSON(easyInputMessageContentInputImage) {
+    return JSON.stringify(EasyInputMessageContentInputImage$outboundSchema.parse(easyInputMessageContentInputImage));
+}
+/** @internal */
+export const EasyInputMessageContentUnion1$outboundSchema = z.union([
+    InputText$outboundSchema,
+    z.lazy(() => EasyInputMessageContentInputImage$outboundSchema),
+    InputFile$outboundSchema,
+    InputAudio$outboundSchema,
+    InputVideo$outboundSchema,
+]);
+export function easyInputMessageContentUnion1ToJSON(easyInputMessageContentUnion1) {
+    return JSON.stringify(EasyInputMessageContentUnion1$outboundSchema.parse(easyInputMessageContentUnion1));
+}
+/** @internal */
+export const EasyInputMessageContentUnion2$outboundSchema = z.union([
+    z.array(z.union([
+        InputText$outboundSchema,
+        z.lazy(() => EasyInputMessageContentInputImage$outboundSchema),
+        InputFile$outboundSchema,
+        InputAudio$outboundSchema,
+        InputVideo$outboundSchema,
+    ])),
+    z.string(),
+    z.any(),
+]);
+export function easyInputMessageContentUnion2ToJSON(easyInputMessageContentUnion2) {
+    return JSON.stringify(EasyInputMessageContentUnion2$outboundSchema.parse(easyInputMessageContentUnion2));
+}
+/** @internal */
+export const EasyInputMessagePhaseFinalAnswer$outboundSchema = z.enum(EasyInputMessagePhaseFinalAnswer);
+/** @internal */
+export const EasyInputMessagePhaseCommentary$outboundSchema = z.enum(EasyInputMessagePhaseCommentary);
+/** @internal */
+export const EasyInputMessagePhaseUnion$outboundSchema = z.union([
+    EasyInputMessagePhaseCommentary$outboundSchema,
+    EasyInputMessagePhaseFinalAnswer$outboundSchema,
+    z.any(),
+]);
+export function easyInputMessagePhaseUnionToJSON(easyInputMessagePhaseUnion) {
+    return JSON.stringify(EasyInputMessagePhaseUnion$outboundSchema.parse(easyInputMessagePhaseUnion));
+}
+/** @internal */
+export const EasyInputMessage$outboundSchema = z.object({
+    type: EasyInputMessageTypeMessage$outboundSchema.optional(),
+    role: z.union([
+        EasyInputMessageRoleUser$outboundSchema,
+        EasyInputMessageRoleSystem$outboundSchema,
+        EasyInputMessageRoleAssistant$outboundSchema,
+        EasyInputMessageRoleDeveloper$outboundSchema,
+    ]),
+    content: z.nullable(z.union([
+        z.array(z.union([
+            InputText$outboundSchema,
+            z.lazy(() => EasyInputMessageContentInputImage$outboundSchema),
+            InputFile$outboundSchema,
+            InputAudio$outboundSchema,
+            InputVideo$outboundSchema,
+        ])),
+        z.string(),
+        z.any(),
+    ])).optional(),
+    phase: z.nullable(z.union([
+        EasyInputMessagePhaseCommentary$outboundSchema,
+        EasyInputMessagePhaseFinalAnswer$outboundSchema,
+        z.any(),
+    ])).optional(),
+});
+export function easyInputMessageToJSON(easyInputMessage) {
+    return JSON.stringify(EasyInputMessage$outboundSchema.parse(easyInputMessage));
+}
+//# sourceMappingURL=easyinputmessage.js.map

package/esm/models/{openresponseserrorevent.d.ts → errorevent.d.ts}

@@ -4,7 +4,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Event emitted when an error occurs during streaming
  */
-export type OpenResponsesErrorEvent = {
+export type ErrorEvent = {
     type: "error";
     code: string | null;
     message: string;
@@ -12,6 +12,6 @@ export type OpenResponsesErrorEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesErrorEvent$inboundSchema: z.ZodType<OpenResponsesErrorEvent, unknown>;
-export declare function openResponsesErrorEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesErrorEvent, SDKValidationError>;
-//# sourceMappingURL=openresponseserrorevent.d.ts.map
+export declare const ErrorEvent$inboundSchema: z.ZodType<ErrorEvent, unknown>;
+export declare function errorEventFromJSON(jsonString: string): SafeParseResult<ErrorEvent, SDKValidationError>;
+//# sourceMappingURL=errorevent.d.ts.map

package/esm/models/{openresponseserrorevent.js → errorevent.js}

@@ -1,12 +1,13 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 508880501ed2
+ * @generated-id: a4e22766585b
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesErrorEvent$inboundSchema = z.object({
+export const ErrorEvent$inboundSchema = z
+    .object({
     type: z.literal("error"),
     code: z.nullable(z.string()),
     message: z.string(),
@@ -17,7 +18,7 @@ export const OpenResponsesErrorEvent$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesErrorEventFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesErrorEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesErrorEvent' from JSON`);
+export function errorEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ErrorEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ErrorEvent' from JSON`);
 }
-//# sourceMappingURL=openresponseserrorevent.js.map
+//# sourceMappingURL=errorevent.js.map

package/esm/models/{openresponsesfilesearchtool.d.ts → filesearchservertool.d.ts}

@@ -14,12 +14,12 @@ export declare const FiltersType: {
 export type FiltersType = OpenEnum<typeof FiltersType>;
 export type Value1 = string | number;
 export type Value2 = string | number | boolean | Array<string | number>;
-export type OpenResponsesFileSearchToolFilters = {
+export type FileSearchServerToolFilters = {
     key: string;
     type: FiltersType;
     value: string | number | boolean | Array<string | number>;
 };
-export type Filters = OpenResponsesFileSearchToolFilters | CompoundFilter | any;
+export type Filters = FileSearchServerToolFilters | CompoundFilter | any;
 export declare const Ranker: {
     readonly Auto: "auto";
     readonly Default20241115: "default-2024-11-15";
@@ -32,10 +32,10 @@ export type RankingOptions = {
 /**
  * File search tool configuration
  */
-export type OpenResponsesFileSearchTool = {
+export type FileSearchServerTool = {
     type: "file_search";
     vectorStoreIds: Array<string>;
-    filters?: OpenResponsesFileSearchToolFilters | CompoundFilter | any | null | undefined;
+    filters?: FileSearchServerToolFilters | CompoundFilter | any | null | undefined;
     maxNumResults?: number | undefined;
     rankingOptions?: RankingOptions | undefined;
 };
@@ -60,21 +60,21 @@ export declare const Value2$outboundSchema: z.ZodType<Value2$Outbound, Value2>;
 export declare function value2ToJSON(value2: Value2): string;
 export declare function value2FromJSON(jsonString: string): SafeParseResult<Value2, SDKValidationError>;
 /** @internal */
-export declare const OpenResponsesFileSearchToolFilters$inboundSchema: z.ZodType<OpenResponsesFileSearchToolFilters, unknown>;
+export declare const FileSearchServerToolFilters$inboundSchema: z.ZodType<FileSearchServerToolFilters, unknown>;
 /** @internal */
-export type OpenResponsesFileSearchToolFilters$Outbound = {
+export type FileSearchServerToolFilters$Outbound = {
     key: string;
     type: string;
     value: string | number | boolean | Array<string | number>;
 };
 /** @internal */
-export declare const OpenResponsesFileSearchToolFilters$outboundSchema: z.ZodType<OpenResponsesFileSearchToolFilters$Outbound, OpenResponsesFileSearchToolFilters>;
-export declare function openResponsesFileSearchToolFiltersToJSON(openResponsesFileSearchToolFilters: OpenResponsesFileSearchToolFilters): string;
-export declare function openResponsesFileSearchToolFiltersFromJSON(jsonString: string): SafeParseResult<OpenResponsesFileSearchToolFilters, SDKValidationError>;
+export declare const FileSearchServerToolFilters$outboundSchema: z.ZodType<FileSearchServerToolFilters$Outbound, FileSearchServerToolFilters>;
+export declare function fileSearchServerToolFiltersToJSON(fileSearchServerToolFilters: FileSearchServerToolFilters): string;
+export declare function fileSearchServerToolFiltersFromJSON(jsonString: string): SafeParseResult<FileSearchServerToolFilters, SDKValidationError>;
 /** @internal */
 export declare const Filters$inboundSchema: z.ZodType<Filters, unknown>;
 /** @internal */
-export type Filters$Outbound = OpenResponsesFileSearchToolFilters$Outbound | CompoundFilter$Outbound | any;
+export type Filters$Outbound = FileSearchServerToolFilters$Outbound | CompoundFilter$Outbound | any;
 /** @internal */
 export declare const Filters$outboundSchema: z.ZodType<Filters$Outbound, Filters>;
 export declare function filtersToJSON(filters: Filters): string;
@@ -95,17 +95,17 @@ export declare const RankingOptions$outboundSchema: z.ZodType<RankingOptions$Out
 export declare function rankingOptionsToJSON(rankingOptions: RankingOptions): string;
 export declare function rankingOptionsFromJSON(jsonString: string): SafeParseResult<RankingOptions, SDKValidationError>;
 /** @internal */
-export declare const OpenResponsesFileSearchTool$inboundSchema: z.ZodType<OpenResponsesFileSearchTool, unknown>;
+export declare const FileSearchServerTool$inboundSchema: z.ZodType<FileSearchServerTool, unknown>;
 /** @internal */
-export type OpenResponsesFileSearchTool$Outbound = {
+export type FileSearchServerTool$Outbound = {
     type: "file_search";
     vector_store_ids: Array<string>;
-    filters?: OpenResponsesFileSearchToolFilters$Outbound | CompoundFilter$Outbound | any | null | undefined;
+    filters?: FileSearchServerToolFilters$Outbound | CompoundFilter$Outbound | any | null | undefined;
     max_num_results?: number | undefined;
     ranking_options?: RankingOptions$Outbound | undefined;
 };
 /** @internal */
-export declare const OpenResponsesFileSearchTool$outboundSchema: z.ZodType<OpenResponsesFileSearchTool$Outbound, OpenResponsesFileSearchTool>;
-export declare function openResponsesFileSearchToolToJSON(openResponsesFileSearchTool: OpenResponsesFileSearchTool): string;
-export declare function openResponsesFileSearchToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesFileSearchTool, SDKValidationError>;
-//# sourceMappingURL=openresponsesfilesearchtool.d.ts.map
+export declare const FileSearchServerTool$outboundSchema: z.ZodType<FileSearchServerTool$Outbound, FileSearchServerTool>;
+export declare function fileSearchServerToolToJSON(fileSearchServerTool: FileSearchServerTool): string;
+export declare function fileSearchServerToolFromJSON(jsonString: string): SafeParseResult<FileSearchServerTool, SDKValidationError>;
+//# sourceMappingURL=filesearchservertool.d.ts.map

package/esm/models/{openresponsesfilesearchtool.js → filesearchservertool.js}

@@ -1,6 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 0f461c2f2470
+ * @generated-id: e9b1dc2a101e
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
@@ -59,7 +59,7 @@ export function value2FromJSON(jsonString) {
     return safeParse(jsonString, (x) => Value2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value2' from JSON`);
 }
 /** @internal */
-export const OpenResponsesFileSearchToolFilters$inboundSchema = z.object({
+export const FileSearchServerToolFilters$inboundSchema = z.object({
     key: z.string(),
     type: FiltersType$inboundSchema,
     value: z.union([
@@ -70,7 +70,7 @@ export const OpenResponsesFileSearchToolFilters$inboundSchema = z.object({
     ]),
 });
 /** @internal */
-export const OpenResponsesFileSearchToolFilters$outboundSchema = z.object({
+export const FileSearchServerToolFilters$outboundSchema = z.object({
     key: z.string(),
     type: FiltersType$outboundSchema,
     value: z.union([
@@ -80,22 +80,22 @@ export const OpenResponsesFileSearchToolFilters$outboundSchema = z.object({
         z.array(z.union([z.string(), z.number()])),
     ]),
 });
-export function openResponsesFileSearchToolFiltersToJSON(openResponsesFileSearchToolFilters) {
-    return JSON.stringify(OpenResponsesFileSearchToolFilters$outboundSchema.parse(openResponsesFileSearchToolFilters));
+export function fileSearchServerToolFiltersToJSON(fileSearchServerToolFilters) {
+    return JSON.stringify(FileSearchServerToolFilters$outboundSchema.parse(fileSearchServerToolFilters));
 }
-export function openResponsesFileSearchToolFiltersFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesFileSearchToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchToolFilters' from JSON`);
+export function fileSearchServerToolFiltersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileSearchServerToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileSearchServerToolFilters' from JSON`);
 }
 /** @internal */
 export const Filters$inboundSchema = z.union([
-    z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+    z.lazy(() => FileSearchServerToolFilters$inboundSchema),
     CompoundFilter$inboundSchema,
     z.any(),
 ]);
 /** @internal */
 export const Filters$outboundSchema = z
     .union([
-    z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+    z.lazy(() => FileSearchServerToolFilters$outboundSchema),
     CompoundFilter$outboundSchema,
     z.any(),
 ]);
@@ -136,11 +136,11 @@ export function rankingOptionsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => RankingOptions$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RankingOptions' from JSON`);
 }
 /** @internal */
-export const OpenResponsesFileSearchTool$inboundSchema = z.object({
+export const FileSearchServerTool$inboundSchema = z.object({
     type: z.literal("file_search"),
     vector_store_ids: z.array(z.string()),
     filters: z.nullable(z.union([
-        z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+        z.lazy(() => FileSearchServerToolFilters$inboundSchema),
         CompoundFilter$inboundSchema,
         z.any(),
     ])).optional(),
@@ -154,11 +154,11 @@ export const OpenResponsesFileSearchTool$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const OpenResponsesFileSearchTool$outboundSchema = z.object({
+export const FileSearchServerTool$outboundSchema = z.object({
     type: z.literal("file_search"),
     vectorStoreIds: z.array(z.string()),
     filters: z.nullable(z.union([
-        z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+        z.lazy(() => FileSearchServerToolFilters$outboundSchema),
         CompoundFilter$outboundSchema,
         z.any(),
     ])).optional(),
@@ -171,10 +171,10 @@ export const OpenResponsesFileSearchTool$outboundSchema = z.object({
         rankingOptions: "ranking_options",
     });
 });
-export function openResponsesFileSearchToolToJSON(openResponsesFileSearchTool) {
-    return JSON.stringify(OpenResponsesFileSearchTool$outboundSchema.parse(openResponsesFileSearchTool));
+export function fileSearchServerToolToJSON(fileSearchServerTool) {
+    return JSON.stringify(FileSearchServerTool$outboundSchema.parse(fileSearchServerTool));
 }
-export function openResponsesFileSearchToolFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesFileSearchTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchTool' from JSON`);
+export function fileSearchServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileSearchServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileSearchServerTool' from JSON`);
 }
-//# sourceMappingURL=openresponsesfilesearchtool.js.map
+//# sourceMappingURL=filesearchservertool.js.map

package/esm/models/formatjsonobjectconfig.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * JSON object response format
+ */
+export type FormatJsonObjectConfig = {
+    type: "json_object";
+};
+/** @internal */
+export declare const FormatJsonObjectConfig$inboundSchema: z.ZodType<FormatJsonObjectConfig, unknown>;
+/** @internal */
+export type FormatJsonObjectConfig$Outbound = {
+    type: "json_object";
+};
+/** @internal */
+export declare const FormatJsonObjectConfig$outboundSchema: z.ZodType<FormatJsonObjectConfig$Outbound, FormatJsonObjectConfig>;
+export declare function formatJsonObjectConfigToJSON(formatJsonObjectConfig: FormatJsonObjectConfig): string;
+export declare function formatJsonObjectConfigFromJSON(jsonString: string): SafeParseResult<FormatJsonObjectConfig, SDKValidationError>;
+//# sourceMappingURL=formatjsonobjectconfig.d.ts.map

package/esm/models/formatjsonobjectconfig.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 18c9f55ddf22
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FormatJsonObjectConfig$inboundSchema = z.object({
+    type: z.literal("json_object"),
+});
+/** @internal */
+export const FormatJsonObjectConfig$outboundSchema = z.object({
+    type: z.literal("json_object"),
+});
+export function formatJsonObjectConfigToJSON(formatJsonObjectConfig) {
+    return JSON.stringify(FormatJsonObjectConfig$outboundSchema.parse(formatJsonObjectConfig));
+}
+export function formatJsonObjectConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatJsonObjectConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatJsonObjectConfig' from JSON`);
+}
+//# sourceMappingURL=formatjsonobjectconfig.js.map

package/esm/models/formatjsonschemaconfig.d.ts

@@ -0,0 +1,32 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * JSON schema constrained response format
+ */
+export type FormatJsonSchemaConfig = {
+    type: "json_schema";
+    name: string;
+    description?: string | undefined;
+    strict?: boolean | null | undefined;
+    schema: {
+        [k: string]: any | null;
+    };
+};
+/** @internal */
+export declare const FormatJsonSchemaConfig$inboundSchema: z.ZodType<FormatJsonSchemaConfig, unknown>;
+/** @internal */
+export type FormatJsonSchemaConfig$Outbound = {
+    type: "json_schema";
+    name: string;
+    description?: string | undefined;
+    strict?: boolean | null | undefined;
+    schema: {
+        [k: string]: any | null;
+    };
+};
+/** @internal */
+export declare const FormatJsonSchemaConfig$outboundSchema: z.ZodType<FormatJsonSchemaConfig$Outbound, FormatJsonSchemaConfig>;
+export declare function formatJsonSchemaConfigToJSON(formatJsonSchemaConfig: FormatJsonSchemaConfig): string;
+export declare function formatJsonSchemaConfigFromJSON(jsonString: string): SafeParseResult<FormatJsonSchemaConfig, SDKValidationError>;
+//# sourceMappingURL=formatjsonschemaconfig.d.ts.map

package/esm/models/formatjsonschemaconfig.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: dbec4c78c132
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FormatJsonSchemaConfig$inboundSchema = z.object({
+    type: z.literal("json_schema"),
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+});
+/** @internal */
+export const FormatJsonSchemaConfig$outboundSchema = z.object({
+    type: z.literal("json_schema"),
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+});
+export function formatJsonSchemaConfigToJSON(formatJsonSchemaConfig) {
+    return JSON.stringify(FormatJsonSchemaConfig$outboundSchema.parse(formatJsonSchemaConfig));
+}
+export function formatJsonSchemaConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatJsonSchemaConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatJsonSchemaConfig' from JSON`);
+}
+//# sourceMappingURL=formatjsonschemaconfig.js.map

package/esm/models/formats.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 { FormatJsonObjectConfig, FormatJsonObjectConfig$Outbound } from "./formatjsonobjectconfig.js";
+import { FormatJsonSchemaConfig, FormatJsonSchemaConfig$Outbound } from "./formatjsonschemaconfig.js";
+import { FormatTextConfig, FormatTextConfig$Outbound } from "./formattextconfig.js";
+/**
+ * Text response format configuration
+ */
+export type Formats = FormatTextConfig | FormatJsonObjectConfig | FormatJsonSchemaConfig;
+/** @internal */
+export declare const Formats$inboundSchema: z.ZodType<Formats, unknown>;
+/** @internal */
+export type Formats$Outbound = FormatTextConfig$Outbound | FormatJsonObjectConfig$Outbound | FormatJsonSchemaConfig$Outbound;
+/** @internal */
+export declare const Formats$outboundSchema: z.ZodType<Formats$Outbound, Formats>;
+export declare function formatsToJSON(formats: Formats): string;
+export declare function formatsFromJSON(jsonString: string): SafeParseResult<Formats, SDKValidationError>;
+//# sourceMappingURL=formats.d.ts.map

package/esm/models/formats.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6e4608e1920c
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { FormatJsonObjectConfig$inboundSchema, FormatJsonObjectConfig$outboundSchema, } from "./formatjsonobjectconfig.js";
+import { FormatJsonSchemaConfig$inboundSchema, FormatJsonSchemaConfig$outboundSchema, } from "./formatjsonschemaconfig.js";
+import { FormatTextConfig$inboundSchema, FormatTextConfig$outboundSchema, } from "./formattextconfig.js";
+/** @internal */
+export const Formats$inboundSchema = z.union([
+    FormatTextConfig$inboundSchema,
+    FormatJsonObjectConfig$inboundSchema,
+    FormatJsonSchemaConfig$inboundSchema,
+]);
+/** @internal */
+export const Formats$outboundSchema = z
+    .union([
+    FormatTextConfig$outboundSchema,
+    FormatJsonObjectConfig$outboundSchema,
+    FormatJsonSchemaConfig$outboundSchema,
+]);
+export function formatsToJSON(formats) {
+    return JSON.stringify(Formats$outboundSchema.parse(formats));
+}
+export function formatsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Formats$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Formats' from JSON`);
+}
+//# sourceMappingURL=formats.js.map

package/esm/models/formattextconfig.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Plain text response format
+ */
+export type FormatTextConfig = {
+    type: "text";
+};
+/** @internal */
+export declare const FormatTextConfig$inboundSchema: z.ZodType<FormatTextConfig, unknown>;
+/** @internal */
+export type FormatTextConfig$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const FormatTextConfig$outboundSchema: z.ZodType<FormatTextConfig$Outbound, FormatTextConfig>;
+export declare function formatTextConfigToJSON(formatTextConfig: FormatTextConfig): string;
+export declare function formatTextConfigFromJSON(jsonString: string): SafeParseResult<FormatTextConfig, SDKValidationError>;
+//# sourceMappingURL=formattextconfig.d.ts.map

package/esm/models/formattextconfig.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 06c312c9c674
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FormatTextConfig$inboundSchema = z.object({
+    type: z.literal("text"),
+});
+/** @internal */
+export const FormatTextConfig$outboundSchema = z.object({
+    type: z.literal("text"),
+});
+export function formatTextConfigToJSON(formatTextConfig) {
+    return JSON.stringify(FormatTextConfig$outboundSchema.parse(formatTextConfig));
+}
+export function formatTextConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatTextConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatTextConfig' from JSON`);
+}
+//# sourceMappingURL=formattextconfig.js.map

package/esm/models/functioncallargsdeltaevent.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Event emitted when function call arguments are being streamed
+ */
+export type FunctionCallArgsDeltaEvent = {
+    type: "response.function_call_arguments.delta";
+    itemId: string;
+    outputIndex: number;
+    delta: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const FunctionCallArgsDeltaEvent$inboundSchema: z.ZodType<FunctionCallArgsDeltaEvent, unknown>;
+export declare function functionCallArgsDeltaEventFromJSON(jsonString: string): SafeParseResult<FunctionCallArgsDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=functioncallargsdeltaevent.d.ts.map

package/esm/models/functioncallargsdeltaevent.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2f23b040fdad
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FunctionCallArgsDeltaEvent$inboundSchema = z.object({
+    type: z.literal("response.function_call_arguments.delta"),
+    item_id: z.string(),
+    output_index: z.number(),
+    delta: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function functionCallArgsDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FunctionCallArgsDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FunctionCallArgsDeltaEvent' from JSON`);
+}
+//# sourceMappingURL=functioncallargsdeltaevent.js.map

package/esm/models/functioncallargsdoneevent.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 function call arguments streaming is complete
+ */
+export type FunctionCallArgsDoneEvent = {
+    type: "response.function_call_arguments.done";
+    itemId: string;
+    outputIndex: number;
+    name: string;
+    arguments: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const FunctionCallArgsDoneEvent$inboundSchema: z.ZodType<FunctionCallArgsDoneEvent, unknown>;
+export declare function functionCallArgsDoneEventFromJSON(jsonString: string): SafeParseResult<FunctionCallArgsDoneEvent, SDKValidationError>;
+//# sourceMappingURL=functioncallargsdoneevent.d.ts.map