@openrouter/sdk 0.9.11 → 0.10.2

package/esm/models/openairesponsesinputunion.d.ts

@@ -25,11 +25,19 @@ export declare const OpenAIResponsesInputTypeFunctionCallOutput: {
     readonly FunctionCallOutput: "function_call_output";
 };
 export type OpenAIResponsesInputTypeFunctionCallOutput = ClosedEnum<typeof OpenAIResponsesInputTypeFunctionCallOutput>;
+export type OpenAIResponsesInputOutput1 = ResponseInputText | (ResponseInputImage & {
+    type: "input_image";
+}) | ResponseInputFile;
+export type OpenAIResponsesInputOutput2 = string | Array<ResponseInputText | (ResponseInputImage & {
+    type: "input_image";
+}) | ResponseInputFile>;
 export type OpenAIResponsesInputFunctionCallOutput = {
     type: OpenAIResponsesInputTypeFunctionCallOutput;
     id?: string | null | undefined;
     callId: string;
-    output: string;
+    output: string | Array<ResponseInputText | (ResponseInputImage & {
+        type: "input_image";
+    }) | ResponseInputFile>;
     status?: ToolCallStatus | null | undefined;
 };
 export declare const OpenAIResponsesInputTypeMessage2: {
@@ -87,12 +95,22 @@ export type OpenAIResponsesInputContent1 = ResponseInputText | (ResponseInputIma
 export type OpenAIResponsesInputContent2 = Array<ResponseInputText | (ResponseInputImage & {
     type: "input_image";
 }) | ResponseInputFile | ResponseInputAudio> | string;
+export declare const OpenAIResponsesInputPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OpenAIResponsesInputPhaseFinalAnswer = ClosedEnum<typeof OpenAIResponsesInputPhaseFinalAnswer>;
+export declare const OpenAIResponsesInputPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OpenAIResponsesInputPhaseCommentary = ClosedEnum<typeof OpenAIResponsesInputPhaseCommentary>;
+export type OpenAIResponsesInputPhaseUnion = OpenAIResponsesInputPhaseCommentary | OpenAIResponsesInputPhaseFinalAnswer | any;
 export type OpenAIResponsesInputMessage1 = {
     type?: OpenAIResponsesInputTypeMessage1 | undefined;
     role: OpenAIResponsesInputRoleUser1 | OpenAIResponsesInputRoleSystem1 | OpenAIResponsesInputRoleAssistant | OpenAIResponsesInputRoleDeveloper1;
     content: Array<ResponseInputText | (ResponseInputImage & {
         type: "input_image";
     }) | ResponseInputFile | ResponseInputAudio> | string;
+    phase?: OpenAIResponsesInputPhaseCommentary | OpenAIResponsesInputPhaseFinalAnswer | any | null | undefined;
 };
 export type OpenAIResponsesInputUnion1 = OpenAIResponsesInputFunctionCall | OutputMessage | OpenAIResponsesInputMessage2 | OpenAIResponsesInputFunctionCallOutput | OutputItemImageGenerationCall | OpenAIResponsesInputMessage1;
 export type OpenAIResponsesInputUnion = string | Array<OpenAIResponsesInputFunctionCall | OutputMessage | OpenAIResponsesInputMessage2 | OpenAIResponsesInputFunctionCallOutput | OutputItemImageGenerationCall | OpenAIResponsesInputMessage1> | any;
@@ -104,6 +122,12 @@ export declare function openAIResponsesInputFunctionCallFromJSON(jsonString: str
 /** @internal */
 export declare const OpenAIResponsesInputTypeFunctionCallOutput$inboundSchema: z.ZodEnum<typeof OpenAIResponsesInputTypeFunctionCallOutput>;
 /** @internal */
+export declare const OpenAIResponsesInputOutput1$inboundSchema: z.ZodType<OpenAIResponsesInputOutput1, unknown>;
+export declare function openAIResponsesInputOutput1FromJSON(jsonString: string): SafeParseResult<OpenAIResponsesInputOutput1, SDKValidationError>;
+/** @internal */
+export declare const OpenAIResponsesInputOutput2$inboundSchema: z.ZodType<OpenAIResponsesInputOutput2, unknown>;
+export declare function openAIResponsesInputOutput2FromJSON(jsonString: string): SafeParseResult<OpenAIResponsesInputOutput2, SDKValidationError>;
+/** @internal */
 export declare const OpenAIResponsesInputFunctionCallOutput$inboundSchema: z.ZodType<OpenAIResponsesInputFunctionCallOutput, unknown>;
 export declare function openAIResponsesInputFunctionCallOutputFromJSON(jsonString: string): SafeParseResult<OpenAIResponsesInputFunctionCallOutput, SDKValidationError>;
 /** @internal */
@@ -143,6 +167,13 @@ export declare function openAIResponsesInputContent1FromJSON(jsonString: string)
 export declare const OpenAIResponsesInputContent2$inboundSchema: z.ZodType<OpenAIResponsesInputContent2, unknown>;
 export declare function openAIResponsesInputContent2FromJSON(jsonString: string): SafeParseResult<OpenAIResponsesInputContent2, SDKValidationError>;
 /** @internal */
+export declare const OpenAIResponsesInputPhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OpenAIResponsesInputPhaseFinalAnswer>;
+/** @internal */
+export declare const OpenAIResponsesInputPhaseCommentary$inboundSchema: z.ZodEnum<typeof OpenAIResponsesInputPhaseCommentary>;
+/** @internal */
+export declare const OpenAIResponsesInputPhaseUnion$inboundSchema: z.ZodType<OpenAIResponsesInputPhaseUnion, unknown>;
+export declare function openAIResponsesInputPhaseUnionFromJSON(jsonString: string): SafeParseResult<OpenAIResponsesInputPhaseUnion, SDKValidationError>;
+/** @internal */
 export declare const OpenAIResponsesInputMessage1$inboundSchema: z.ZodType<OpenAIResponsesInputMessage1, unknown>;
 export declare function openAIResponsesInputMessage1FromJSON(jsonString: string): SafeParseResult<OpenAIResponsesInputMessage1, SDKValidationError>;
 /** @internal */

package/esm/models/openairesponsesinputunion.js

@@ -45,6 +45,12 @@ export const OpenAIResponsesInputRoleSystem1 = {
 export const OpenAIResponsesInputRoleUser1 = {
     User: "user",
 };
+export const OpenAIResponsesInputPhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OpenAIResponsesInputPhaseCommentary = {
+    Commentary: "commentary",
+};
 /** @internal */
 export const OpenAIResponsesInputTypeFunctionCall$inboundSchema = z.enum(OpenAIResponsesInputTypeFunctionCall);
 /** @internal */
@@ -66,11 +72,39 @@ export function openAIResponsesInputFunctionCallFromJSON(jsonString) {
 /** @internal */
 export const OpenAIResponsesInputTypeFunctionCallOutput$inboundSchema = z.enum(OpenAIResponsesInputTypeFunctionCallOutput);
 /** @internal */
+export const OpenAIResponsesInputOutput1$inboundSchema = z.union([
+    ResponseInputText$inboundSchema,
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+    ResponseInputFile$inboundSchema,
+]);
+export function openAIResponsesInputOutput1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenAIResponsesInputOutput1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputOutput1' from JSON`);
+}
+/** @internal */
+export const OpenAIResponsesInputOutput2$inboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        ResponseInputText$inboundSchema,
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+        ResponseInputFile$inboundSchema,
+    ])),
+]);
+export function openAIResponsesInputOutput2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenAIResponsesInputOutput2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputOutput2' from JSON`);
+}
+/** @internal */
 export const OpenAIResponsesInputFunctionCallOutput$inboundSchema = z.object({
     type: OpenAIResponsesInputTypeFunctionCallOutput$inboundSchema,
     id: z.nullable(z.string()).optional(),
     call_id: z.string(),
-    output: z.string(),
+    output: z.union([
+        z.string(),
+        z.array(z.union([
+            ResponseInputText$inboundSchema,
+            ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
+            ResponseInputFile$inboundSchema,
+        ])),
+    ]),
     status: z.nullable(ToolCallStatus$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -170,6 +204,19 @@ export function openAIResponsesInputContent2FromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenAIResponsesInputContent2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputContent2' from JSON`);
 }
 /** @internal */
+export const OpenAIResponsesInputPhaseFinalAnswer$inboundSchema = z.enum(OpenAIResponsesInputPhaseFinalAnswer);
+/** @internal */
+export const OpenAIResponsesInputPhaseCommentary$inboundSchema = z.enum(OpenAIResponsesInputPhaseCommentary);
+/** @internal */
+export const OpenAIResponsesInputPhaseUnion$inboundSchema = z.union([
+    OpenAIResponsesInputPhaseCommentary$inboundSchema,
+    OpenAIResponsesInputPhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function openAIResponsesInputPhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenAIResponsesInputPhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputPhaseUnion' from JSON`);
+}
+/** @internal */
 export const OpenAIResponsesInputMessage1$inboundSchema = z.object({
     type: OpenAIResponsesInputTypeMessage1$inboundSchema.optional(),
     role: z.union([
@@ -187,6 +234,11 @@ export const OpenAIResponsesInputMessage1$inboundSchema = z.object({
         ])),
         z.string(),
     ]),
+    phase: z.nullable(z.union([
+        OpenAIResponsesInputPhaseCommentary$inboundSchema,
+        OpenAIResponsesInputPhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
 });
 export function openAIResponsesInputMessage1FromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenAIResponsesInputMessage1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesInputMessage1' from JSON`);

package/esm/models/openresponsesapplypatchtool.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";
+/**
+ * Apply patch tool configuration
+ */
+export type OpenResponsesApplyPatchTool = {
+    type: "apply_patch";
+};
+/** @internal */
+export declare const OpenResponsesApplyPatchTool$inboundSchema: z.ZodType<OpenResponsesApplyPatchTool, unknown>;
+/** @internal */
+export type OpenResponsesApplyPatchTool$Outbound = {
+    type: "apply_patch";
+};
+/** @internal */
+export declare const OpenResponsesApplyPatchTool$outboundSchema: z.ZodType<OpenResponsesApplyPatchTool$Outbound, OpenResponsesApplyPatchTool>;
+export declare function openResponsesApplyPatchToolToJSON(openResponsesApplyPatchTool: OpenResponsesApplyPatchTool): string;
+export declare function openResponsesApplyPatchToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesApplyPatchTool, SDKValidationError>;
+//# sourceMappingURL=openresponsesapplypatchtool.d.ts.map

package/esm/models/openresponsesapplypatchtool.js

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

package/esm/models/openresponsescodeinterpretertool.d.ts

@@ -0,0 +1,68 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ContainerType: {
+    readonly Auto: "auto";
+};
+export type ContainerType = ClosedEnum<typeof ContainerType>;
+export declare const MemoryLimit: {
+    readonly Oneg: "1g";
+    readonly Fourg: "4g";
+    readonly Sixteeng: "16g";
+    readonly SixtyFourg: "64g";
+};
+export type MemoryLimit = OpenEnum<typeof MemoryLimit>;
+export type ContainerAuto = {
+    type: ContainerType;
+    fileIds?: Array<string> | undefined;
+    memoryLimit?: MemoryLimit | null | undefined;
+};
+export type Container = ContainerAuto | string;
+/**
+ * Code interpreter tool configuration
+ */
+export type OpenResponsesCodeInterpreterTool = {
+    type: "code_interpreter";
+    container: ContainerAuto | string;
+};
+/** @internal */
+export declare const ContainerType$inboundSchema: z.ZodEnum<typeof ContainerType>;
+/** @internal */
+export declare const ContainerType$outboundSchema: z.ZodEnum<typeof ContainerType>;
+/** @internal */
+export declare const MemoryLimit$inboundSchema: z.ZodType<MemoryLimit, unknown>;
+/** @internal */
+export declare const MemoryLimit$outboundSchema: z.ZodType<string, MemoryLimit>;
+/** @internal */
+export declare const ContainerAuto$inboundSchema: z.ZodType<ContainerAuto, unknown>;
+/** @internal */
+export type ContainerAuto$Outbound = {
+    type: string;
+    file_ids?: Array<string> | undefined;
+    memory_limit?: string | null | undefined;
+};
+/** @internal */
+export declare const ContainerAuto$outboundSchema: z.ZodType<ContainerAuto$Outbound, ContainerAuto>;
+export declare function containerAutoToJSON(containerAuto: ContainerAuto): string;
+export declare function containerAutoFromJSON(jsonString: string): SafeParseResult<ContainerAuto, SDKValidationError>;
+/** @internal */
+export declare const Container$inboundSchema: z.ZodType<Container, unknown>;
+/** @internal */
+export type Container$Outbound = ContainerAuto$Outbound | string;
+/** @internal */
+export declare const Container$outboundSchema: z.ZodType<Container$Outbound, Container>;
+export declare function containerToJSON(container: Container): string;
+export declare function containerFromJSON(jsonString: string): SafeParseResult<Container, SDKValidationError>;
+/** @internal */
+export declare const OpenResponsesCodeInterpreterTool$inboundSchema: z.ZodType<OpenResponsesCodeInterpreterTool, unknown>;
+/** @internal */
+export type OpenResponsesCodeInterpreterTool$Outbound = {
+    type: "code_interpreter";
+    container: ContainerAuto$Outbound | string;
+};
+/** @internal */
+export declare const OpenResponsesCodeInterpreterTool$outboundSchema: z.ZodType<OpenResponsesCodeInterpreterTool$Outbound, OpenResponsesCodeInterpreterTool>;
+export declare function openResponsesCodeInterpreterToolToJSON(openResponsesCodeInterpreterTool: OpenResponsesCodeInterpreterTool): string;
+export declare function openResponsesCodeInterpreterToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesCodeInterpreterTool, SDKValidationError>;
+//# sourceMappingURL=openresponsescodeinterpretertool.d.ts.map

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