@openrouter/sdk 0.9.11 → 0.10.2

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

package/esm/models/openresponsesfilesearchtool.js

@@ -0,0 +1,180 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0f461c2f2470
+ */
+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";
+import { CompoundFilter$inboundSchema, CompoundFilter$outboundSchema, } from "./compoundfilter.js";
+export const FiltersType = {
+    Eq: "eq",
+    Ne: "ne",
+    Gt: "gt",
+    Gte: "gte",
+    Lt: "lt",
+    Lte: "lte",
+};
+export const Ranker = {
+    Auto: "auto",
+    Default20241115: "default-2024-11-15",
+};
+/** @internal */
+export const FiltersType$inboundSchema = openEnums.inboundSchema(FiltersType);
+/** @internal */
+export const FiltersType$outboundSchema = openEnums.outboundSchema(FiltersType);
+/** @internal */
+export const Value1$inboundSchema = z.union([
+    z.string(),
+    z.number(),
+]);
+/** @internal */
+export const Value1$outboundSchema = z
+    .union([z.string(), z.number()]);
+export function value1ToJSON(value1) {
+    return JSON.stringify(Value1$outboundSchema.parse(value1));
+}
+export function value1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Value1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value1' from JSON`);
+}
+/** @internal */
+export const Value2$inboundSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+/** @internal */
+export const Value2$outboundSchema = z
+    .union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+export function value2ToJSON(value2) {
+    return JSON.stringify(Value2$outboundSchema.parse(value2));
+}
+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({
+    key: z.string(),
+    type: FiltersType$inboundSchema,
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.union([z.string(), z.number()])),
+    ]),
+});
+/** @internal */
+export const OpenResponsesFileSearchToolFilters$outboundSchema = z.object({
+    key: z.string(),
+    type: FiltersType$outboundSchema,
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.union([z.string(), z.number()])),
+    ]),
+});
+export function openResponsesFileSearchToolFiltersToJSON(openResponsesFileSearchToolFilters) {
+    return JSON.stringify(OpenResponsesFileSearchToolFilters$outboundSchema.parse(openResponsesFileSearchToolFilters));
+}
+export function openResponsesFileSearchToolFiltersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesFileSearchToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchToolFilters' from JSON`);
+}
+/** @internal */
+export const Filters$inboundSchema = z.union([
+    z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+    CompoundFilter$inboundSchema,
+    z.any(),
+]);
+/** @internal */
+export const Filters$outboundSchema = z
+    .union([
+    z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+    CompoundFilter$outboundSchema,
+    z.any(),
+]);
+export function filtersToJSON(filters) {
+    return JSON.stringify(Filters$outboundSchema.parse(filters));
+}
+export function filtersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Filters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Filters' from JSON`);
+}
+/** @internal */
+export const Ranker$inboundSchema = openEnums
+    .inboundSchema(Ranker);
+/** @internal */
+export const Ranker$outboundSchema = openEnums
+    .outboundSchema(Ranker);
+/** @internal */
+export const RankingOptions$inboundSchema = z.object({
+    ranker: Ranker$inboundSchema.optional(),
+    score_threshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "score_threshold": "scoreThreshold",
+    });
+});
+/** @internal */
+export const RankingOptions$outboundSchema = z.object({
+    ranker: Ranker$outboundSchema.optional(),
+    scoreThreshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        scoreThreshold: "score_threshold",
+    });
+});
+export function rankingOptionsToJSON(rankingOptions) {
+    return JSON.stringify(RankingOptions$outboundSchema.parse(rankingOptions));
+}
+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()),
+    filters: z.nullable(z.union([
+        z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+        CompoundFilter$inboundSchema,
+        z.any(),
+    ])).optional(),
+    max_num_results: z.int().optional(),
+    ranking_options: z.lazy(() => RankingOptions$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "vector_store_ids": "vectorStoreIds",
+        "max_num_results": "maxNumResults",
+        "ranking_options": "rankingOptions",
+    });
+});
+/** @internal */
+export const OpenResponsesFileSearchTool$outboundSchema = z.object({
+    type: z.literal("file_search"),
+    vectorStoreIds: z.array(z.string()),
+    filters: z.nullable(z.union([
+        z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+        CompoundFilter$outboundSchema,
+        z.any(),
+    ])).optional(),
+    maxNumResults: z.int().optional(),
+    rankingOptions: z.lazy(() => RankingOptions$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        vectorStoreIds: "vector_store_ids",
+        maxNumResults: "max_num_results",
+        rankingOptions: "ranking_options",
+    });
+});
+export function openResponsesFileSearchToolToJSON(openResponsesFileSearchTool) {
+    return JSON.stringify(OpenResponsesFileSearchTool$outboundSchema.parse(openResponsesFileSearchTool));
+}
+export function openResponsesFileSearchToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesFileSearchTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchTool' from JSON`);
+}
+//# sourceMappingURL=openresponsesfilesearchtool.js.map

package/esm/models/openresponsesfunctioncalloutput.d.ts

@@ -1,28 +1,67 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ResponseInputFile, ResponseInputFile$Outbound } from "./responseinputfile.js";
+import { ResponseInputText, ResponseInputText$Outbound } from "./responseinputtext.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
-export declare const OpenResponsesFunctionCallOutputType: {
+export declare const OpenResponsesFunctionCallOutputTypeFunctionCallOutput: {
     readonly FunctionCallOutput: "function_call_output";
 };
-export type OpenResponsesFunctionCallOutputType = ClosedEnum<typeof OpenResponsesFunctionCallOutputType>;
+export type OpenResponsesFunctionCallOutputTypeFunctionCallOutput = ClosedEnum<typeof OpenResponsesFunctionCallOutputTypeFunctionCallOutput>;
+export declare const OpenResponsesFunctionCallOutputDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type OpenResponsesFunctionCallOutputDetail = OpenEnum<typeof OpenResponsesFunctionCallOutputDetail>;
+/**
+ * Image input content item
+ */
+export type OutputInputImage = {
+    type: "input_image";
+    detail: OpenResponsesFunctionCallOutputDetail;
+    imageUrl?: string | null | undefined;
+};
+export type OpenResponsesFunctionCallOutputOutputUnion1 = ResponseInputText | OutputInputImage | ResponseInputFile;
+export type OpenResponsesFunctionCallOutputOutputUnion2 = string | Array<ResponseInputText | OutputInputImage | ResponseInputFile>;
 /**
  * The output from a function call execution
  */
 export type OpenResponsesFunctionCallOutput = {
-    type: OpenResponsesFunctionCallOutputType;
+    type: OpenResponsesFunctionCallOutputTypeFunctionCallOutput;
     id?: string | null | undefined;
     callId: string;
-    output: string;
+    output: string | Array<ResponseInputText | OutputInputImage | ResponseInputFile>;
     status?: ToolCallStatus | null | undefined;
 };
 /** @internal */
-export declare const OpenResponsesFunctionCallOutputType$outboundSchema: z.ZodEnum<typeof OpenResponsesFunctionCallOutputType>;
+export declare const OpenResponsesFunctionCallOutputTypeFunctionCallOutput$outboundSchema: z.ZodEnum<typeof OpenResponsesFunctionCallOutputTypeFunctionCallOutput>;
+/** @internal */
+export declare const OpenResponsesFunctionCallOutputDetail$outboundSchema: z.ZodType<string, OpenResponsesFunctionCallOutputDetail>;
+/** @internal */
+export type OutputInputImage$Outbound = {
+    type: "input_image";
+    detail: string;
+    image_url?: string | null | undefined;
+};
+/** @internal */
+export declare const OutputInputImage$outboundSchema: z.ZodType<OutputInputImage$Outbound, OutputInputImage>;
+export declare function outputInputImageToJSON(outputInputImage: OutputInputImage): string;
+/** @internal */
+export type OpenResponsesFunctionCallOutputOutputUnion1$Outbound = ResponseInputText$Outbound | OutputInputImage$Outbound | ResponseInputFile$Outbound;
+/** @internal */
+export declare const OpenResponsesFunctionCallOutputOutputUnion1$outboundSchema: z.ZodType<OpenResponsesFunctionCallOutputOutputUnion1$Outbound, OpenResponsesFunctionCallOutputOutputUnion1>;
+export declare function openResponsesFunctionCallOutputOutputUnion1ToJSON(openResponsesFunctionCallOutputOutputUnion1: OpenResponsesFunctionCallOutputOutputUnion1): string;
+/** @internal */
+export type OpenResponsesFunctionCallOutputOutputUnion2$Outbound = string | Array<ResponseInputText$Outbound | OutputInputImage$Outbound | ResponseInputFile$Outbound>;
+/** @internal */
+export declare const OpenResponsesFunctionCallOutputOutputUnion2$outboundSchema: z.ZodType<OpenResponsesFunctionCallOutputOutputUnion2$Outbound, OpenResponsesFunctionCallOutputOutputUnion2>;
+export declare function openResponsesFunctionCallOutputOutputUnion2ToJSON(openResponsesFunctionCallOutputOutputUnion2: OpenResponsesFunctionCallOutputOutputUnion2): string;
 /** @internal */
 export type OpenResponsesFunctionCallOutput$Outbound = {
     type: string;
     id?: string | null | undefined;
     call_id: string;
-    output: string;
+    output: string | Array<ResponseInputText$Outbound | OutputInputImage$Outbound | ResponseInputFile$Outbound>;
     status?: string | null | undefined;
 };
 /** @internal */

package/esm/models/openresponsesfunctioncalloutput.js

@@ -4,18 +4,70 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { ResponseInputFile$outboundSchema, } from "./responseinputfile.js";
+import { ResponseInputText$outboundSchema, } from "./responseinputtext.js";
 import { ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
-export const OpenResponsesFunctionCallOutputType = {
+export const OpenResponsesFunctionCallOutputTypeFunctionCallOutput = {
     FunctionCallOutput: "function_call_output",
 };
+export const OpenResponsesFunctionCallOutputDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+/** @internal */
+export const OpenResponsesFunctionCallOutputTypeFunctionCallOutput$outboundSchema = z
+    .enum(OpenResponsesFunctionCallOutputTypeFunctionCallOutput);
+/** @internal */
+export const OpenResponsesFunctionCallOutputDetail$outboundSchema = openEnums.outboundSchema(OpenResponsesFunctionCallOutputDetail);
+/** @internal */
+export const OutputInputImage$outboundSchema = z.object({
+    type: z.literal("input_image"),
+    detail: OpenResponsesFunctionCallOutputDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function outputInputImageToJSON(outputInputImage) {
+    return JSON.stringify(OutputInputImage$outboundSchema.parse(outputInputImage));
+}
 /** @internal */
-export const OpenResponsesFunctionCallOutputType$outboundSchema = z.enum(OpenResponsesFunctionCallOutputType);
+export const OpenResponsesFunctionCallOutputOutputUnion1$outboundSchema = z.union([
+    ResponseInputText$outboundSchema,
+    z.lazy(() => OutputInputImage$outboundSchema),
+    ResponseInputFile$outboundSchema,
+]);
+export function openResponsesFunctionCallOutputOutputUnion1ToJSON(openResponsesFunctionCallOutputOutputUnion1) {
+    return JSON.stringify(OpenResponsesFunctionCallOutputOutputUnion1$outboundSchema.parse(openResponsesFunctionCallOutputOutputUnion1));
+}
+/** @internal */
+export const OpenResponsesFunctionCallOutputOutputUnion2$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        ResponseInputText$outboundSchema,
+        z.lazy(() => OutputInputImage$outboundSchema),
+        ResponseInputFile$outboundSchema,
+    ])),
+]);
+export function openResponsesFunctionCallOutputOutputUnion2ToJSON(openResponsesFunctionCallOutputOutputUnion2) {
+    return JSON.stringify(OpenResponsesFunctionCallOutputOutputUnion2$outboundSchema.parse(openResponsesFunctionCallOutputOutputUnion2));
+}
 /** @internal */
 export const OpenResponsesFunctionCallOutput$outboundSchema = z.object({
-    type: OpenResponsesFunctionCallOutputType$outboundSchema,
+    type: OpenResponsesFunctionCallOutputTypeFunctionCallOutput$outboundSchema,
     id: z.nullable(z.string()).optional(),
     callId: z.string(),
-    output: z.string(),
+    output: z.union([
+        z.string(),
+        z.array(z.union([
+            ResponseInputText$outboundSchema,
+            z.lazy(() => OutputInputImage$outboundSchema),
+            ResponseInputFile$outboundSchema,
+        ])),
+    ]),
     status: z.nullable(ToolCallStatus$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/openresponsesfunctionshelltool.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";
+/**
+ * Shell tool configuration
+ */
+export type OpenResponsesFunctionShellTool = {
+    type: "shell";
+};
+/** @internal */
+export declare const OpenResponsesFunctionShellTool$inboundSchema: z.ZodType<OpenResponsesFunctionShellTool, unknown>;
+/** @internal */
+export type OpenResponsesFunctionShellTool$Outbound = {
+    type: "shell";
+};
+/** @internal */
+export declare const OpenResponsesFunctionShellTool$outboundSchema: z.ZodType<OpenResponsesFunctionShellTool$Outbound, OpenResponsesFunctionShellTool>;
+export declare function openResponsesFunctionShellToolToJSON(openResponsesFunctionShellTool: OpenResponsesFunctionShellTool): string;
+export declare function openResponsesFunctionShellToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesFunctionShellTool, SDKValidationError>;
+//# sourceMappingURL=openresponsesfunctionshelltool.d.ts.map

package/esm/models/openresponsesfunctionshelltool.js

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