@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/openresponsescodeinterpretertool.js

@@ -0,0 +1,85 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8d6c57413f99
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ContainerType = {
+    Auto: "auto",
+};
+export const MemoryLimit = {
+    Oneg: "1g",
+    Fourg: "4g",
+    Sixteeng: "16g",
+    SixtyFourg: "64g",
+};
+/** @internal */
+export const ContainerType$inboundSchema = z
+    .enum(ContainerType);
+/** @internal */
+export const ContainerType$outboundSchema = ContainerType$inboundSchema;
+/** @internal */
+export const MemoryLimit$inboundSchema = openEnums.inboundSchema(MemoryLimit);
+/** @internal */
+export const MemoryLimit$outboundSchema = openEnums.outboundSchema(MemoryLimit);
+/** @internal */
+export const ContainerAuto$inboundSchema = z
+    .object({
+    type: ContainerType$inboundSchema,
+    file_ids: z.array(z.string()).optional(),
+    memory_limit: z.nullable(MemoryLimit$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "file_ids": "fileIds",
+        "memory_limit": "memoryLimit",
+    });
+});
+/** @internal */
+export const ContainerAuto$outboundSchema = z.object({
+    type: ContainerType$outboundSchema,
+    fileIds: z.array(z.string()).optional(),
+    memoryLimit: z.nullable(MemoryLimit$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        fileIds: "file_ids",
+        memoryLimit: "memory_limit",
+    });
+});
+export function containerAutoToJSON(containerAuto) {
+    return JSON.stringify(ContainerAuto$outboundSchema.parse(containerAuto));
+}
+export function containerAutoFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ContainerAuto$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ContainerAuto' from JSON`);
+}
+/** @internal */
+export const Container$inboundSchema = z.union([
+    z.lazy(() => ContainerAuto$inboundSchema),
+    z.string(),
+]);
+/** @internal */
+export const Container$outboundSchema = z.union([z.lazy(() => ContainerAuto$outboundSchema), z.string()]);
+export function containerToJSON(container) {
+    return JSON.stringify(Container$outboundSchema.parse(container));
+}
+export function containerFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Container$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Container' from JSON`);
+}
+/** @internal */
+export const OpenResponsesCodeInterpreterTool$inboundSchema = z.object({
+    type: z.literal("code_interpreter"),
+    container: z.union([z.lazy(() => ContainerAuto$inboundSchema), z.string()]),
+});
+/** @internal */
+export const OpenResponsesCodeInterpreterTool$outboundSchema = z.object({
+    type: z.literal("code_interpreter"),
+    container: z.union([z.lazy(() => ContainerAuto$outboundSchema), z.string()]),
+});
+export function openResponsesCodeInterpreterToolToJSON(openResponsesCodeInterpreterTool) {
+    return JSON.stringify(OpenResponsesCodeInterpreterTool$outboundSchema.parse(openResponsesCodeInterpreterTool));
+}
+export function openResponsesCodeInterpreterToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesCodeInterpreterTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesCodeInterpreterTool' from JSON`);
+}
+//# sourceMappingURL=openresponsescodeinterpretertool.js.map

package/esm/models/openresponsescomputertool.d.ts

@@ -0,0 +1,39 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Environment: {
+    readonly Windows: "windows";
+    readonly Mac: "mac";
+    readonly Linux: "linux";
+    readonly Ubuntu: "ubuntu";
+    readonly Browser: "browser";
+};
+export type Environment = OpenEnum<typeof Environment>;
+/**
+ * Computer use preview tool configuration
+ */
+export type OpenResponsesComputerTool = {
+    type: "computer_use_preview";
+    displayHeight: number;
+    displayWidth: number;
+    environment: Environment;
+};
+/** @internal */
+export declare const Environment$inboundSchema: z.ZodType<Environment, unknown>;
+/** @internal */
+export declare const Environment$outboundSchema: z.ZodType<string, Environment>;
+/** @internal */
+export declare const OpenResponsesComputerTool$inboundSchema: z.ZodType<OpenResponsesComputerTool, unknown>;
+/** @internal */
+export type OpenResponsesComputerTool$Outbound = {
+    type: "computer_use_preview";
+    display_height: number;
+    display_width: number;
+    environment: string;
+};
+/** @internal */
+export declare const OpenResponsesComputerTool$outboundSchema: z.ZodType<OpenResponsesComputerTool$Outbound, OpenResponsesComputerTool>;
+export declare function openResponsesComputerToolToJSON(openResponsesComputerTool: OpenResponsesComputerTool): string;
+export declare function openResponsesComputerToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesComputerTool, SDKValidationError>;
+//# sourceMappingURL=openresponsescomputertool.d.ts.map

package/esm/models/openresponsescomputertool.js

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4cd864e2c4f2
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Environment = {
+    Windows: "windows",
+    Mac: "mac",
+    Linux: "linux",
+    Ubuntu: "ubuntu",
+    Browser: "browser",
+};
+/** @internal */
+export const Environment$inboundSchema = openEnums.inboundSchema(Environment);
+/** @internal */
+export const Environment$outboundSchema = openEnums.outboundSchema(Environment);
+/** @internal */
+export const OpenResponsesComputerTool$inboundSchema = z.object({
+    type: z.literal("computer_use_preview"),
+    display_height: z.number(),
+    display_width: z.number(),
+    environment: Environment$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "display_height": "displayHeight",
+        "display_width": "displayWidth",
+    });
+});
+/** @internal */
+export const OpenResponsesComputerTool$outboundSchema = z.object({
+    type: z.literal("computer_use_preview"),
+    displayHeight: z.number(),
+    displayWidth: z.number(),
+    environment: Environment$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        displayHeight: "display_height",
+        displayWidth: "display_width",
+    });
+});
+export function openResponsesComputerToolToJSON(openResponsesComputerTool) {
+    return JSON.stringify(OpenResponsesComputerTool$outboundSchema.parse(openResponsesComputerTool));
+}
+export function openResponsesComputerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesComputerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesComputerTool' from JSON`);
+}
+//# sourceMappingURL=openresponsescomputertool.js.map

package/esm/models/openresponsescustomtool.d.ts

@@ -0,0 +1,75 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Syntax: {
+    readonly Lark: "lark";
+    readonly Regex: "regex";
+};
+export type Syntax = OpenEnum<typeof Syntax>;
+export type FormatGrammar = {
+    type: "grammar";
+    definition: string;
+    syntax: Syntax;
+};
+export type FormatText = {
+    type: "text";
+};
+export type Format = FormatText | FormatGrammar;
+/**
+ * Custom tool configuration
+ */
+export type OpenResponsesCustomTool = {
+    type: "custom";
+    name: string;
+    description?: string | undefined;
+    format?: FormatText | FormatGrammar | undefined;
+};
+/** @internal */
+export declare const Syntax$inboundSchema: z.ZodType<Syntax, unknown>;
+/** @internal */
+export declare const Syntax$outboundSchema: z.ZodType<string, Syntax>;
+/** @internal */
+export declare const FormatGrammar$inboundSchema: z.ZodType<FormatGrammar, unknown>;
+/** @internal */
+export type FormatGrammar$Outbound = {
+    type: "grammar";
+    definition: string;
+    syntax: string;
+};
+/** @internal */
+export declare const FormatGrammar$outboundSchema: z.ZodType<FormatGrammar$Outbound, FormatGrammar>;
+export declare function formatGrammarToJSON(formatGrammar: FormatGrammar): string;
+export declare function formatGrammarFromJSON(jsonString: string): SafeParseResult<FormatGrammar, SDKValidationError>;
+/** @internal */
+export declare const FormatText$inboundSchema: z.ZodType<FormatText, unknown>;
+/** @internal */
+export type FormatText$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const FormatText$outboundSchema: z.ZodType<FormatText$Outbound, FormatText>;
+export declare function formatTextToJSON(formatText: FormatText): string;
+export declare function formatTextFromJSON(jsonString: string): SafeParseResult<FormatText, SDKValidationError>;
+/** @internal */
+export declare const Format$inboundSchema: z.ZodType<Format, unknown>;
+/** @internal */
+export type Format$Outbound = FormatText$Outbound | FormatGrammar$Outbound;
+/** @internal */
+export declare const Format$outboundSchema: z.ZodType<Format$Outbound, Format>;
+export declare function formatToJSON(format: Format): string;
+export declare function formatFromJSON(jsonString: string): SafeParseResult<Format, SDKValidationError>;
+/** @internal */
+export declare const OpenResponsesCustomTool$inboundSchema: z.ZodType<OpenResponsesCustomTool, unknown>;
+/** @internal */
+export type OpenResponsesCustomTool$Outbound = {
+    type: "custom";
+    name: string;
+    description?: string | undefined;
+    format?: FormatText$Outbound | FormatGrammar$Outbound | undefined;
+};
+/** @internal */
+export declare const OpenResponsesCustomTool$outboundSchema: z.ZodType<OpenResponsesCustomTool$Outbound, OpenResponsesCustomTool>;
+export declare function openResponsesCustomToolToJSON(openResponsesCustomTool: OpenResponsesCustomTool): string;
+export declare function openResponsesCustomToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesCustomTool, SDKValidationError>;
+//# sourceMappingURL=openresponsescustomtool.d.ts.map

package/esm/models/openresponsescustomtool.js

@@ -0,0 +1,95 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9f957484e6a0
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Syntax = {
+    Lark: "lark",
+    Regex: "regex",
+};
+/** @internal */
+export const Syntax$inboundSchema = openEnums
+    .inboundSchema(Syntax);
+/** @internal */
+export const Syntax$outboundSchema = openEnums
+    .outboundSchema(Syntax);
+/** @internal */
+export const FormatGrammar$inboundSchema = z
+    .object({
+    type: z.literal("grammar"),
+    definition: z.string(),
+    syntax: Syntax$inboundSchema,
+});
+/** @internal */
+export const FormatGrammar$outboundSchema = z.object({
+    type: z.literal("grammar"),
+    definition: z.string(),
+    syntax: Syntax$outboundSchema,
+});
+export function formatGrammarToJSON(formatGrammar) {
+    return JSON.stringify(FormatGrammar$outboundSchema.parse(formatGrammar));
+}
+export function formatGrammarFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatGrammar$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatGrammar' from JSON`);
+}
+/** @internal */
+export const FormatText$inboundSchema = z
+    .object({
+    type: z.literal("text"),
+});
+/** @internal */
+export const FormatText$outboundSchema = z.object({
+    type: z.literal("text"),
+});
+export function formatTextToJSON(formatText) {
+    return JSON.stringify(FormatText$outboundSchema.parse(formatText));
+}
+export function formatTextFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatText' from JSON`);
+}
+/** @internal */
+export const Format$inboundSchema = z.union([
+    z.lazy(() => FormatText$inboundSchema),
+    z.lazy(() => FormatGrammar$inboundSchema),
+]);
+/** @internal */
+export const Format$outboundSchema = z
+    .union([
+    z.lazy(() => FormatText$outboundSchema),
+    z.lazy(() => FormatGrammar$outboundSchema),
+]);
+export function formatToJSON(format) {
+    return JSON.stringify(Format$outboundSchema.parse(format));
+}
+export function formatFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Format$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Format' from JSON`);
+}
+/** @internal */
+export const OpenResponsesCustomTool$inboundSchema = z.object({
+    type: z.literal("custom"),
+    name: z.string(),
+    description: z.string().optional(),
+    format: z.union([
+        z.lazy(() => FormatText$inboundSchema),
+        z.lazy(() => FormatGrammar$inboundSchema),
+    ]).optional(),
+});
+/** @internal */
+export const OpenResponsesCustomTool$outboundSchema = z.object({
+    type: z.literal("custom"),
+    name: z.string(),
+    description: z.string().optional(),
+    format: z.union([
+        z.lazy(() => FormatText$outboundSchema),
+        z.lazy(() => FormatGrammar$outboundSchema),
+    ]).optional(),
+});
+export function openResponsesCustomToolToJSON(openResponsesCustomTool) {
+    return JSON.stringify(OpenResponsesCustomTool$outboundSchema.parse(openResponsesCustomTool));
+}
+export function openResponsesCustomToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesCustomTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesCustomTool' from JSON`);
+}
+//# sourceMappingURL=openresponsescustomtool.js.map

package/esm/models/openresponseseasyinputmessage.d.ts

@@ -40,11 +40,27 @@ export type OpenResponsesEasyInputMessageContentInputImage = {
     imageUrl?: string | null | undefined;
 };
 export type OpenResponsesEasyInputMessageContentUnion1 = ResponseInputText | OpenResponsesEasyInputMessageContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo;
-export type OpenResponsesEasyInputMessageContentUnion2 = Array<ResponseInputText | OpenResponsesEasyInputMessageContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo> | string;
+export type OpenResponsesEasyInputMessageContentUnion2 = Array<ResponseInputText | OpenResponsesEasyInputMessageContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo> | string | any;
+export declare const OpenResponsesEasyInputMessagePhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OpenResponsesEasyInputMessagePhaseFinalAnswer = ClosedEnum<typeof OpenResponsesEasyInputMessagePhaseFinalAnswer>;
+export declare const OpenResponsesEasyInputMessagePhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OpenResponsesEasyInputMessagePhaseCommentary = ClosedEnum<typeof OpenResponsesEasyInputMessagePhaseCommentary>;
+/**
+ * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+ */
+export type OpenResponsesEasyInputMessagePhaseUnion = OpenResponsesEasyInputMessagePhaseCommentary | OpenResponsesEasyInputMessagePhaseFinalAnswer | any;
 export type OpenResponsesEasyInputMessage = {
     type?: OpenResponsesEasyInputMessageTypeMessage | undefined;
     role: OpenResponsesEasyInputMessageRoleUser | OpenResponsesEasyInputMessageRoleSystem | OpenResponsesEasyInputMessageRoleAssistant | OpenResponsesEasyInputMessageRoleDeveloper;
-    content: Array<ResponseInputText | OpenResponsesEasyInputMessageContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo> | string;
+    content?: Array<ResponseInputText | OpenResponsesEasyInputMessageContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo> | string | any | null | undefined;
+    /**
+     * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+     */
+    phase?: OpenResponsesEasyInputMessagePhaseCommentary | OpenResponsesEasyInputMessagePhaseFinalAnswer | any | null | undefined;
 };
 /** @internal */
 export declare const OpenResponsesEasyInputMessageTypeMessage$outboundSchema: z.ZodEnum<typeof OpenResponsesEasyInputMessageTypeMessage>;
@@ -78,15 +94,25 @@ export type OpenResponsesEasyInputMessageContentUnion1$Outbound = ResponseInputT
 export declare const OpenResponsesEasyInputMessageContentUnion1$outboundSchema: z.ZodType<OpenResponsesEasyInputMessageContentUnion1$Outbound, OpenResponsesEasyInputMessageContentUnion1>;
 export declare function openResponsesEasyInputMessageContentUnion1ToJSON(openResponsesEasyInputMessageContentUnion1: OpenResponsesEasyInputMessageContentUnion1): string;
 /** @internal */
-export type OpenResponsesEasyInputMessageContentUnion2$Outbound = Array<ResponseInputText$Outbound | OpenResponsesEasyInputMessageContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound> | string;
+export type OpenResponsesEasyInputMessageContentUnion2$Outbound = Array<ResponseInputText$Outbound | OpenResponsesEasyInputMessageContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound> | string | any;
 /** @internal */
 export declare const OpenResponsesEasyInputMessageContentUnion2$outboundSchema: z.ZodType<OpenResponsesEasyInputMessageContentUnion2$Outbound, OpenResponsesEasyInputMessageContentUnion2>;
 export declare function openResponsesEasyInputMessageContentUnion2ToJSON(openResponsesEasyInputMessageContentUnion2: OpenResponsesEasyInputMessageContentUnion2): string;
 /** @internal */
+export declare const OpenResponsesEasyInputMessagePhaseFinalAnswer$outboundSchema: z.ZodEnum<typeof OpenResponsesEasyInputMessagePhaseFinalAnswer>;
+/** @internal */
+export declare const OpenResponsesEasyInputMessagePhaseCommentary$outboundSchema: z.ZodEnum<typeof OpenResponsesEasyInputMessagePhaseCommentary>;
+/** @internal */
+export type OpenResponsesEasyInputMessagePhaseUnion$Outbound = string | string | any;
+/** @internal */
+export declare const OpenResponsesEasyInputMessagePhaseUnion$outboundSchema: z.ZodType<OpenResponsesEasyInputMessagePhaseUnion$Outbound, OpenResponsesEasyInputMessagePhaseUnion>;
+export declare function openResponsesEasyInputMessagePhaseUnionToJSON(openResponsesEasyInputMessagePhaseUnion: OpenResponsesEasyInputMessagePhaseUnion): string;
+/** @internal */
 export type OpenResponsesEasyInputMessage$Outbound = {
     type?: string | undefined;
     role: string | string | string | string;
-    content: Array<ResponseInputText$Outbound | OpenResponsesEasyInputMessageContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound> | string;
+    content?: Array<ResponseInputText$Outbound | OpenResponsesEasyInputMessageContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound> | string | any | null | undefined;
+    phase?: string | string | any | null | undefined;
 };
 /** @internal */
 export declare const OpenResponsesEasyInputMessage$outboundSchema: z.ZodType<OpenResponsesEasyInputMessage$Outbound, OpenResponsesEasyInputMessage>;

package/esm/models/openresponseseasyinputmessage.js

@@ -29,6 +29,12 @@ export const OpenResponsesEasyInputMessageDetail = {
     High: "high",
     Low: "low",
 };
+export const OpenResponsesEasyInputMessagePhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OpenResponsesEasyInputMessagePhaseCommentary = {
+    Commentary: "commentary",
+};
 /** @internal */
 export const OpenResponsesEasyInputMessageTypeMessage$outboundSchema = z.enum(OpenResponsesEasyInputMessageTypeMessage);
 /** @internal */
@@ -85,11 +91,25 @@ export const OpenResponsesEasyInputMessageContentUnion2$outboundSchema = z.union
         ResponseInputVideo$outboundSchema,
     ])),
     z.string(),
+    z.any(),
 ]);
 export function openResponsesEasyInputMessageContentUnion2ToJSON(openResponsesEasyInputMessageContentUnion2) {
     return JSON.stringify(OpenResponsesEasyInputMessageContentUnion2$outboundSchema.parse(openResponsesEasyInputMessageContentUnion2));
 }
 /** @internal */
+export const OpenResponsesEasyInputMessagePhaseFinalAnswer$outboundSchema = z.enum(OpenResponsesEasyInputMessagePhaseFinalAnswer);
+/** @internal */
+export const OpenResponsesEasyInputMessagePhaseCommentary$outboundSchema = z.enum(OpenResponsesEasyInputMessagePhaseCommentary);
+/** @internal */
+export const OpenResponsesEasyInputMessagePhaseUnion$outboundSchema = z.union([
+    OpenResponsesEasyInputMessagePhaseCommentary$outboundSchema,
+    OpenResponsesEasyInputMessagePhaseFinalAnswer$outboundSchema,
+    z.any(),
+]);
+export function openResponsesEasyInputMessagePhaseUnionToJSON(openResponsesEasyInputMessagePhaseUnion) {
+    return JSON.stringify(OpenResponsesEasyInputMessagePhaseUnion$outboundSchema.parse(openResponsesEasyInputMessagePhaseUnion));
+}
+/** @internal */
 export const OpenResponsesEasyInputMessage$outboundSchema = z.object({
     type: OpenResponsesEasyInputMessageTypeMessage$outboundSchema.optional(),
     role: z.union([
@@ -98,7 +118,7 @@ export const OpenResponsesEasyInputMessage$outboundSchema = z.object({
         OpenResponsesEasyInputMessageRoleAssistant$outboundSchema,
         OpenResponsesEasyInputMessageRoleDeveloper$outboundSchema,
     ]),
-    content: z.union([
+    content: z.nullable(z.union([
         z.array(z.union([
             ResponseInputText$outboundSchema,
             z.lazy(() => OpenResponsesEasyInputMessageContentInputImage$outboundSchema),
@@ -107,7 +127,13 @@ export const OpenResponsesEasyInputMessage$outboundSchema = z.object({
             ResponseInputVideo$outboundSchema,
         ])),
         z.string(),
-    ]),
+        z.any(),
+    ])).optional(),
+    phase: z.nullable(z.union([
+        OpenResponsesEasyInputMessagePhaseCommentary$outboundSchema,
+        OpenResponsesEasyInputMessagePhaseFinalAnswer$outboundSchema,
+        z.any(),
+    ])).optional(),
 });
 export function openResponsesEasyInputMessageToJSON(openResponsesEasyInputMessage) {
     return JSON.stringify(OpenResponsesEasyInputMessage$outboundSchema.parse(openResponsesEasyInputMessage));

package/esm/models/openresponsesfilesearchtool.d.ts

@@ -0,0 +1,111 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CompoundFilter, CompoundFilter$Outbound } from "./compoundfilter.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const FiltersType: {
+    readonly Eq: "eq";
+    readonly Ne: "ne";
+    readonly Gt: "gt";
+    readonly Gte: "gte";
+    readonly Lt: "lt";
+    readonly Lte: "lte";
+};
+export type FiltersType = OpenEnum<typeof FiltersType>;
+export type Value1 = string | number;
+export type Value2 = string | number | boolean | Array<string | number>;
+export type OpenResponsesFileSearchToolFilters = {
+    key: string;
+    type: FiltersType;
+    value: string | number | boolean | Array<string | number>;
+};
+export type Filters = OpenResponsesFileSearchToolFilters | CompoundFilter | any;
+export declare const Ranker: {
+    readonly Auto: "auto";
+    readonly Default20241115: "default-2024-11-15";
+};
+export type Ranker = OpenEnum<typeof Ranker>;
+export type RankingOptions = {
+    ranker?: Ranker | undefined;
+    scoreThreshold?: number | undefined;
+};
+/**
+ * File search tool configuration
+ */
+export type OpenResponsesFileSearchTool = {
+    type: "file_search";
+    vectorStoreIds: Array<string>;
+    filters?: OpenResponsesFileSearchToolFilters | CompoundFilter | any | null | undefined;
+    maxNumResults?: number | undefined;
+    rankingOptions?: RankingOptions | undefined;
+};
+/** @internal */
+export declare const FiltersType$inboundSchema: z.ZodType<FiltersType, unknown>;
+/** @internal */
+export declare const FiltersType$outboundSchema: z.ZodType<string, FiltersType>;
+/** @internal */
+export declare const Value1$inboundSchema: z.ZodType<Value1, unknown>;
+/** @internal */
+export type Value1$Outbound = string | number;
+/** @internal */
+export declare const Value1$outboundSchema: z.ZodType<Value1$Outbound, Value1>;
+export declare function value1ToJSON(value1: Value1): string;
+export declare function value1FromJSON(jsonString: string): SafeParseResult<Value1, SDKValidationError>;
+/** @internal */
+export declare const Value2$inboundSchema: z.ZodType<Value2, unknown>;
+/** @internal */
+export type Value2$Outbound = string | number | boolean | Array<string | number>;
+/** @internal */
+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>;
+/** @internal */
+export type OpenResponsesFileSearchToolFilters$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 Ranker$inboundSchema: z.ZodType<Ranker, unknown>;
+/** @internal */
+export declare const Ranker$outboundSchema: z.ZodType<string, Ranker>;
+/** @internal */
+export declare const RankingOptions$inboundSchema: z.ZodType<RankingOptions, unknown>;
+/** @internal */
+export type RankingOptions$Outbound = {
+    ranker?: string | undefined;
+    score_threshold?: number | undefined;
+};
+/** @internal */
+export declare const RankingOptions$outboundSchema: z.ZodType<RankingOptions$Outbound, RankingOptions>;
+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>;
+/** @internal */
+export type OpenResponsesFileSearchTool$Outbound = {
+    type: "file_search";
+    vector_store_ids: Array<string>;
+    filters?: OpenResponsesFileSearchToolFilters$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