@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/fileparserplugin.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 04e61b333ea7
+ */
+import * as z from "zod/v4";
+import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.js";
+/** @internal */
+export const FileParserPlugin$outboundSchema = z.object({
+    enabled: z.boolean().optional(),
+    id: z.literal("file-parser"),
+    pdf: PDFParserOptions$outboundSchema.optional(),
+});
+export function fileParserPluginToJSON(fileParserPlugin) {
+    return JSON.stringify(FileParserPlugin$outboundSchema.parse(fileParserPlugin));
+}
+//# sourceMappingURL=fileparserplugin.js.map

package/esm/models/filepath.d.ts

@@ -2,17 +2,17 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type FilePath = {
-    type: "file_path";
     fileId: string;
     index: number;
+    type: "file_path";
 };
 /** @internal */
 export declare const FilePath$inboundSchema: z.ZodType<FilePath, unknown>;
 /** @internal */
 export type FilePath$Outbound = {
-    type: "file_path";
     file_id: string;
     index: number;
+    type: "file_path";
 };
 /** @internal */
 export declare const FilePath$outboundSchema: z.ZodType<FilePath$Outbound, FilePath>;

package/esm/models/filepath.js

@@ -7,9 +7,9 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const FilePath$inboundSchema = z.object({
-    type: z.literal("file_path"),
     file_id: z.string(),
-    index: z.number(),
+    index: z.int(),
+    type: z.literal("file_path"),
 }).transform((v) => {
     return remap$(v, {
         "file_id": "fileId",
@@ -18,9 +18,9 @@ export const FilePath$inboundSchema = z.object({
 /** @internal */
 export const FilePath$outboundSchema = z
     .object({
-    type: z.literal("file_path"),
     fileId: z.string(),
-    index: z.number(),
+    index: z.int(),
+    type: z.literal("file_path"),
 }).transform((v) => {
     return remap$(v, {
         fileId: "file_id",

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 Filters = {
     key: string;
     type: FiltersType;
     value: string | number | boolean | Array<string | number>;
 };
-export type Filters = OpenResponsesFileSearchToolFilters | CompoundFilter | any;
+export type FiltersUnion = Filters | CompoundFilter | any;
 export declare const Ranker: {
     readonly Auto: "auto";
     readonly Default20241115: "default-2024-11-15";
@@ -32,12 +32,12 @@ export type RankingOptions = {
 /**
  * File search tool configuration
  */
-export type OpenResponsesFileSearchTool = {
-    type: "file_search";
-    vectorStoreIds: Array<string>;
-    filters?: OpenResponsesFileSearchToolFilters | CompoundFilter | any | null | undefined;
+export type FileSearchServerTool = {
+    filters?: Filters | CompoundFilter | any | null | undefined;
     maxNumResults?: number | undefined;
     rankingOptions?: RankingOptions | undefined;
+    type: "file_search";
+    vectorStoreIds: Array<string>;
 };
 /** @internal */
 export declare const FiltersType$inboundSchema: z.ZodType<FiltersType, unknown>;
@@ -60,26 +60,26 @@ 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 Filters$inboundSchema: z.ZodType<Filters, unknown>;
 /** @internal */
-export type OpenResponsesFileSearchToolFilters$Outbound = {
+export type Filters$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>;
-/** @internal */
-export declare const Filters$inboundSchema: z.ZodType<Filters, unknown>;
-/** @internal */
-export type Filters$Outbound = OpenResponsesFileSearchToolFilters$Outbound | CompoundFilter$Outbound | any;
-/** @internal */
 export declare const Filters$outboundSchema: z.ZodType<Filters$Outbound, Filters>;
 export declare function filtersToJSON(filters: Filters): string;
 export declare function filtersFromJSON(jsonString: string): SafeParseResult<Filters, SDKValidationError>;
 /** @internal */
+export declare const FiltersUnion$inboundSchema: z.ZodType<FiltersUnion, unknown>;
+/** @internal */
+export type FiltersUnion$Outbound = Filters$Outbound | CompoundFilter$Outbound | any;
+/** @internal */
+export declare const FiltersUnion$outboundSchema: z.ZodType<FiltersUnion$Outbound, FiltersUnion>;
+export declare function filtersUnionToJSON(filtersUnion: FiltersUnion): string;
+export declare function filtersUnionFromJSON(jsonString: string): SafeParseResult<FiltersUnion, SDKValidationError>;
+/** @internal */
 export declare const Ranker$inboundSchema: z.ZodType<Ranker, unknown>;
 /** @internal */
 export declare const Ranker$outboundSchema: z.ZodType<string, Ranker>;
@@ -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 = {
-    type: "file_search";
-    vector_store_ids: Array<string>;
-    filters?: OpenResponsesFileSearchToolFilters$Outbound | CompoundFilter$Outbound | any | null | undefined;
+export type FileSearchServerTool$Outbound = {
+    filters?: Filters$Outbound | CompoundFilter$Outbound | any | null | undefined;
     max_num_results?: number | undefined;
     ranking_options?: RankingOptions$Outbound | undefined;
+    type: "file_search";
+    vector_store_ids: Array<string>;
 };
 /** @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 Filters$inboundSchema = z.object({
     key: z.string(),
     type: FiltersType$inboundSchema,
     value: z.union([
@@ -70,7 +70,8 @@ export const OpenResponsesFileSearchToolFilters$inboundSchema = z.object({
     ]),
 });
 /** @internal */
-export const OpenResponsesFileSearchToolFilters$outboundSchema = z.object({
+export const Filters$outboundSchema = z
+    .object({
     key: z.string(),
     type: FiltersType$outboundSchema,
     value: z.union([
@@ -80,30 +81,30 @@ 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 filtersToJSON(filters) {
+    return JSON.stringify(Filters$outboundSchema.parse(filters));
 }
-export function openResponsesFileSearchToolFiltersFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesFileSearchToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchToolFilters' from JSON`);
+export function filtersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Filters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Filters' from JSON`);
 }
 /** @internal */
-export const Filters$inboundSchema = z.union([
-    z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+export const FiltersUnion$inboundSchema = z
+    .union([
+    z.lazy(() => Filters$inboundSchema),
     CompoundFilter$inboundSchema,
     z.any(),
 ]);
 /** @internal */
-export const Filters$outboundSchema = z
-    .union([
-    z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+export const FiltersUnion$outboundSchema = z.union([
+    z.lazy(() => Filters$outboundSchema),
     CompoundFilter$outboundSchema,
     z.any(),
 ]);
-export function filtersToJSON(filters) {
-    return JSON.stringify(Filters$outboundSchema.parse(filters));
+export function filtersUnionToJSON(filtersUnion) {
+    return JSON.stringify(FiltersUnion$outboundSchema.parse(filtersUnion));
 }
-export function filtersFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Filters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Filters' from JSON`);
+export function filtersUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FiltersUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FiltersUnion' from JSON`);
 }
 /** @internal */
 export const Ranker$inboundSchema = openEnums
@@ -136,45 +137,45 @@ 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({
-    type: z.literal("file_search"),
-    vector_store_ids: z.array(z.string()),
+export const FileSearchServerTool$inboundSchema = z.object({
     filters: z.nullable(z.union([
-        z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+        z.lazy(() => Filters$inboundSchema),
         CompoundFilter$inboundSchema,
         z.any(),
     ])).optional(),
     max_num_results: z.int().optional(),
     ranking_options: z.lazy(() => RankingOptions$inboundSchema).optional(),
+    type: z.literal("file_search"),
+    vector_store_ids: z.array(z.string()),
 }).transform((v) => {
     return remap$(v, {
-        "vector_store_ids": "vectorStoreIds",
         "max_num_results": "maxNumResults",
         "ranking_options": "rankingOptions",
+        "vector_store_ids": "vectorStoreIds",
     });
 });
 /** @internal */
-export const OpenResponsesFileSearchTool$outboundSchema = z.object({
-    type: z.literal("file_search"),
-    vectorStoreIds: z.array(z.string()),
+export const FileSearchServerTool$outboundSchema = z.object({
     filters: z.nullable(z.union([
-        z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+        z.lazy(() => Filters$outboundSchema),
         CompoundFilter$outboundSchema,
         z.any(),
     ])).optional(),
     maxNumResults: z.int().optional(),
     rankingOptions: z.lazy(() => RankingOptions$outboundSchema).optional(),
+    type: z.literal("file_search"),
+    vectorStoreIds: z.array(z.string()),
 }).transform((v) => {
     return remap$(v, {
-        vectorStoreIds: "vector_store_ids",
         maxNumResults: "max_num_results",
         rankingOptions: "ranking_options",
+        vectorStoreIds: "vector_store_ids",
     });
 });
-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 = {
+    description?: string | undefined;
+    name: string;
+    schema: {
+        [k: string]: any | null;
+    };
+    strict?: boolean | null | undefined;
+    type: "json_schema";
+};
+/** @internal */
+export declare const FormatJsonSchemaConfig$inboundSchema: z.ZodType<FormatJsonSchemaConfig, unknown>;
+/** @internal */
+export type FormatJsonSchemaConfig$Outbound = {
+    description?: string | undefined;
+    name: string;
+    schema: {
+        [k: string]: any | null;
+    };
+    strict?: boolean | null | undefined;
+    type: "json_schema";
+};
+/** @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({
+    description: z.string().optional(),
+    name: z.string(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+    strict: z.nullable(z.boolean()).optional(),
+    type: z.literal("json_schema"),
+});
+/** @internal */
+export const FormatJsonSchemaConfig$outboundSchema = z.object({
+    description: z.string().optional(),
+    name: z.string(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+    strict: z.nullable(z.boolean()).optional(),
+    type: z.literal("json_schema"),
+});
+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,20 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+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 | discriminatedUnionTypes.Unknown<"type">;
+/** @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,30 @@
+/*
+ * 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 { discriminatedUnion } from "../types/discriminatedUnion.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 = discriminatedUnion("type", {
+    text: FormatTextConfig$inboundSchema,
+    json_object: FormatJsonObjectConfig$inboundSchema,
+    json_schema: 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/frameimage.d.ts

@@ -0,0 +1,49 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+export type FrameImageImageUrl = {
+    url: string;
+};
+export declare const FrameImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type FrameImageType = ClosedEnum<typeof FrameImageType>;
+/**
+ * Whether this image represents the first or last frame of the video
+ */
+export declare const FrameType: {
+    readonly FirstFrame: "first_frame";
+    readonly LastFrame: "last_frame";
+};
+/**
+ * Whether this image represents the first or last frame of the video
+ */
+export type FrameType = OpenEnum<typeof FrameType>;
+export type FrameImage = {
+    imageUrl: FrameImageImageUrl;
+    type: FrameImageType;
+    /**
+     * Whether this image represents the first or last frame of the video
+     */
+    frameType: FrameType;
+};
+/** @internal */
+export type FrameImageImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const FrameImageImageUrl$outboundSchema: z.ZodType<FrameImageImageUrl$Outbound, FrameImageImageUrl>;
+export declare function frameImageImageUrlToJSON(frameImageImageUrl: FrameImageImageUrl): string;
+/** @internal */
+export declare const FrameImageType$outboundSchema: z.ZodEnum<typeof FrameImageType>;
+/** @internal */
+export declare const FrameType$outboundSchema: z.ZodType<string, FrameType>;
+/** @internal */
+export type FrameImage$Outbound = {
+    image_url: FrameImageImageUrl$Outbound;
+    type: string;
+    frame_type: string;
+};
+/** @internal */
+export declare const FrameImage$outboundSchema: z.ZodType<FrameImage$Outbound, FrameImage>;
+export declare function frameImageToJSON(frameImage: FrameImage): string;
+//# sourceMappingURL=frameimage.d.ts.map

package/esm/models/frameimage.js

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 97fccf1b68ca
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+export const FrameImageType = {
+    ImageUrl: "image_url",
+};
+/**
+ * Whether this image represents the first or last frame of the video
+ */
+export const FrameType = {
+    FirstFrame: "first_frame",
+    LastFrame: "last_frame",
+};
+/** @internal */
+export const FrameImageImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function frameImageImageUrlToJSON(frameImageImageUrl) {
+    return JSON.stringify(FrameImageImageUrl$outboundSchema.parse(frameImageImageUrl));
+}
+/** @internal */
+export const FrameImageType$outboundSchema = z
+    .enum(FrameImageType);
+/** @internal */
+export const FrameType$outboundSchema = openEnums
+    .outboundSchema(FrameType);
+/** @internal */
+export const FrameImage$outboundSchema = z.object({
+    imageUrl: z.lazy(() => FrameImageImageUrl$outboundSchema),
+    type: FrameImageType$outboundSchema,
+    frameType: FrameType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+        frameType: "frame_type",
+    });
+});
+export function frameImageToJSON(frameImage) {
+    return JSON.stringify(FrameImage$outboundSchema.parse(frameImage));
+}
+//# sourceMappingURL=frameimage.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 = {
+    delta: string;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.function_call_arguments.delta";
+};
+/** @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({
+    delta: z.string(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.function_call_arguments.delta"),
+}).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 = {
+    arguments: string;
+    itemId: string;
+    name: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.function_call_arguments.done";
+};
+/** @internal */
+export declare const FunctionCallArgsDoneEvent$inboundSchema: z.ZodType<FunctionCallArgsDoneEvent, unknown>;
+export declare function functionCallArgsDoneEventFromJSON(jsonString: string): SafeParseResult<FunctionCallArgsDoneEvent, SDKValidationError>;
+//# sourceMappingURL=functioncallargsdoneevent.d.ts.map