@openrouter/sdk 1.4.9 → 1.4.10

package/esm/models/outputitemcodeinterpretercall.js

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: accdd67e3d17
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import * as openEnums from "../types/enums.js";
+import { CodeInterpreterFileOutput$inboundSchema, } from "./codeinterpreterfileoutput.js";
+import { CodeInterpreterImageOutput$inboundSchema, } from "./codeinterpreterimageoutput.js";
+import { CodeInterpreterLogsOutput$inboundSchema, } from "./codeinterpreterlogsoutput.js";
+export const OutputItemCodeInterpreterCallStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+    Incomplete: "incomplete",
+    Interpreting: "interpreting",
+    Failed: "failed",
+};
+/** @internal */
+export const OutputItemCodeInterpreterCallOutput$inboundSchema = discriminatedUnion("type", {
+    file: CodeInterpreterFileOutput$inboundSchema,
+    image: CodeInterpreterImageOutput$inboundSchema,
+    logs: CodeInterpreterLogsOutput$inboundSchema,
+});
+export function outputItemCodeInterpreterCallOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemCodeInterpreterCallOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemCodeInterpreterCallOutput' from JSON`);
+}
+/** @internal */
+export const OutputItemCodeInterpreterCallStatus$inboundSchema = openEnums.inboundSchema(OutputItemCodeInterpreterCallStatus);
+/** @internal */
+export const OutputItemCodeInterpreterCall$inboundSchema = collectExtraKeys$(z.object({
+    code: z.nullable(z.string()).optional(),
+    container_id: z.string().optional(),
+    id: z.string(),
+    outputs: z.nullable(z.array(discriminatedUnion("type", {
+        file: CodeInterpreterFileOutput$inboundSchema,
+        image: CodeInterpreterImageOutput$inboundSchema,
+        logs: CodeInterpreterLogsOutput$inboundSchema,
+    }))).optional(),
+    status: OutputItemCodeInterpreterCallStatus$inboundSchema,
+    type: z.literal("code_interpreter_call"),
+}).catchall(z.any()), "additionalProperties", true).transform((v) => {
+    return remap$(v, {
+        "container_id": "containerId",
+    });
+});
+export function outputItemCodeInterpreterCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemCodeInterpreterCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemCodeInterpreterCall' from JSON`);
+}
+//# sourceMappingURL=outputitemcodeinterpretercall.js.map

package/esm/models/outputitemcustomtoolcall.d.ts

@@ -0,0 +1,32 @@
+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 OutputItemCustomToolCallStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+};
+export type OutputItemCustomToolCallStatus = OpenEnum<typeof OutputItemCustomToolCallStatus>;
+export type OutputItemCustomToolCall = {
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
+    callId: string;
+    id?: string | undefined;
+    input: string;
+    name: string;
+    /**
+     * Namespace qualifier for tools registered as part of a namespace tool group (e.g. an MCP server)
+     */
+    namespace?: string | undefined;
+    status?: OutputItemCustomToolCallStatus | undefined;
+    type: "custom_tool_call";
+};
+/** @internal */
+export declare const OutputItemCustomToolCallStatus$inboundSchema: z.ZodType<OutputItemCustomToolCallStatus, unknown>;
+/** @internal */
+export declare const OutputItemCustomToolCall$inboundSchema: z.ZodType<OutputItemCustomToolCall, unknown>;
+export declare function outputItemCustomToolCallFromJSON(jsonString: string): SafeParseResult<OutputItemCustomToolCall, SDKValidationError>;
+//# sourceMappingURL=outputitemcustomtoolcall.d.ts.map

package/esm/models/outputitemcustomtoolcall.js

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 753e2c0bcba2
+ */
+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 OutputItemCustomToolCallStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+    Incomplete: "incomplete",
+};
+/** @internal */
+export const OutputItemCustomToolCallStatus$inboundSchema = openEnums.inboundSchema(OutputItemCustomToolCallStatus);
+/** @internal */
+export const OutputItemCustomToolCall$inboundSchema = z.object({
+    async: z.boolean().optional(),
+    call_id: z.string(),
+    id: z.string().optional(),
+    input: z.string(),
+    name: z.string(),
+    namespace: z.string().optional(),
+    status: OutputItemCustomToolCallStatus$inboundSchema.optional(),
+    type: z.literal("custom_tool_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+export function outputItemCustomToolCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemCustomToolCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemCustomToolCall' from JSON`);
+}
+//# sourceMappingURL=outputitemcustomtoolcall.js.map

package/esm/models/outputitemfilesearchcall.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { WebSearchStatus } from "./websearchstatus.js";
+export type OutputItemFileSearchCall = {
+    id: string;
+    queries: Array<string>;
+    status: WebSearchStatus;
+    type: "file_search_call";
+};
+/** @internal */
+export declare const OutputItemFileSearchCall$inboundSchema: z.ZodType<OutputItemFileSearchCall, unknown>;
+export declare function outputItemFileSearchCallFromJSON(jsonString: string): SafeParseResult<OutputItemFileSearchCall, SDKValidationError>;
+//# sourceMappingURL=outputitemfilesearchcall.d.ts.map

package/esm/models/outputitemfilesearchcall.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e56ad67855a5
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { WebSearchStatus$inboundSchema, } from "./websearchstatus.js";
+/** @internal */
+export const OutputItemFileSearchCall$inboundSchema = z.object({
+    id: z.string(),
+    queries: z.array(z.string()),
+    status: WebSearchStatus$inboundSchema,
+    type: z.literal("file_search_call"),
+});
+export function outputItemFileSearchCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemFileSearchCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemFileSearchCall' from JSON`);
+}
+//# sourceMappingURL=outputitemfilesearchcall.js.map

package/esm/models/outputitemfunctioncall.d.ts

@@ -0,0 +1,46 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OutputItemFunctionCallStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputItemFunctionCallStatusInProgress = ClosedEnum<typeof OutputItemFunctionCallStatusInProgress>;
+export declare const OutputItemFunctionCallStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputItemFunctionCallStatusIncomplete = ClosedEnum<typeof OutputItemFunctionCallStatusIncomplete>;
+export declare const OutputItemFunctionCallStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputItemFunctionCallStatusCompleted = ClosedEnum<typeof OutputItemFunctionCallStatusCompleted>;
+export type OutputItemFunctionCallStatusUnion = OutputItemFunctionCallStatusCompleted | OutputItemFunctionCallStatusIncomplete | OutputItemFunctionCallStatusInProgress;
+export type OutputItemFunctionCall = {
+    arguments: string;
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
+    callId: string;
+    id?: string | undefined;
+    name: string;
+    /**
+     * Namespace qualifier for tools registered as part of a namespace tool group (e.g. an MCP server)
+     */
+    namespace?: string | undefined;
+    status?: OutputItemFunctionCallStatusCompleted | OutputItemFunctionCallStatusIncomplete | OutputItemFunctionCallStatusInProgress | undefined;
+    type: "function_call";
+};
+/** @internal */
+export declare const OutputItemFunctionCallStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputItemFunctionCallStatusInProgress>;
+/** @internal */
+export declare const OutputItemFunctionCallStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputItemFunctionCallStatusIncomplete>;
+/** @internal */
+export declare const OutputItemFunctionCallStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputItemFunctionCallStatusCompleted>;
+/** @internal */
+export declare const OutputItemFunctionCallStatusUnion$inboundSchema: z.ZodType<OutputItemFunctionCallStatusUnion, unknown>;
+export declare function outputItemFunctionCallStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputItemFunctionCallStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputItemFunctionCall$inboundSchema: z.ZodType<OutputItemFunctionCall, unknown>;
+export declare function outputItemFunctionCallFromJSON(jsonString: string): SafeParseResult<OutputItemFunctionCall, SDKValidationError>;
+//# sourceMappingURL=outputitemfunctioncall.d.ts.map

package/esm/models/outputitemfunctioncall.js

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 43cb10359f32
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OutputItemFunctionCallStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputItemFunctionCallStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputItemFunctionCallStatusCompleted = {
+    Completed: "completed",
+};
+/** @internal */
+export const OutputItemFunctionCallStatusInProgress$inboundSchema = z.enum(OutputItemFunctionCallStatusInProgress);
+/** @internal */
+export const OutputItemFunctionCallStatusIncomplete$inboundSchema = z.enum(OutputItemFunctionCallStatusIncomplete);
+/** @internal */
+export const OutputItemFunctionCallStatusCompleted$inboundSchema = z.enum(OutputItemFunctionCallStatusCompleted);
+/** @internal */
+export const OutputItemFunctionCallStatusUnion$inboundSchema = z.union([
+    OutputItemFunctionCallStatusCompleted$inboundSchema,
+    OutputItemFunctionCallStatusIncomplete$inboundSchema,
+    OutputItemFunctionCallStatusInProgress$inboundSchema,
+]);
+export function outputItemFunctionCallStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemFunctionCallStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemFunctionCallStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputItemFunctionCall$inboundSchema = z.object({
+    arguments: z.string(),
+    async: z.boolean().optional(),
+    call_id: z.string(),
+    id: z.string().optional(),
+    name: z.string(),
+    namespace: z.string().optional(),
+    status: z.union([
+        OutputItemFunctionCallStatusCompleted$inboundSchema,
+        OutputItemFunctionCallStatusIncomplete$inboundSchema,
+        OutputItemFunctionCallStatusInProgress$inboundSchema,
+    ]).optional(),
+    type: z.literal("function_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+export function outputItemFunctionCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemFunctionCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemFunctionCall' from JSON`);
+}
+//# sourceMappingURL=outputitemfunctioncall.js.map

package/esm/models/outputitemimagegenerationcall.d.ts

@@ -1,21 +1,14 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ImageGenerationStatus } from "./imagegenerationstatus.js";
-export declare const OutputItemImageGenerationCallType: {
-    readonly ImageGenerationCall: "image_generation_call";
-};
-export type OutputItemImageGenerationCallType = ClosedEnum<typeof OutputItemImageGenerationCallType>;
 export type OutputItemImageGenerationCall = {
     id: string;
     result: string | null;
     status: ImageGenerationStatus;
-    type: OutputItemImageGenerationCallType;
+    type: "image_generation_call";
 };
 /** @internal */
-export declare const OutputItemImageGenerationCallType$inboundSchema: z.ZodEnum<typeof OutputItemImageGenerationCallType>;
-/** @internal */
 export declare const OutputItemImageGenerationCall$inboundSchema: z.ZodType<OutputItemImageGenerationCall, unknown>;
 export declare function outputItemImageGenerationCallFromJSON(jsonString: string): SafeParseResult<OutputItemImageGenerationCall, SDKValidationError>;
 //# sourceMappingURL=outputitemimagegenerationcall.d.ts.map

package/esm/models/outputitemimagegenerationcall.js

@@ -5,17 +5,12 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { ImageGenerationStatus$inboundSchema, } from "./imagegenerationstatus.js";
-export const OutputItemImageGenerationCallType = {
-    ImageGenerationCall: "image_generation_call",
-};
-/** @internal */
-export const OutputItemImageGenerationCallType$inboundSchema = z.enum(OutputItemImageGenerationCallType);
 /** @internal */
 export const OutputItemImageGenerationCall$inboundSchema = z.object({
     id: z.string(),
     result: z.nullable(z.string()).default(null),
     status: ImageGenerationStatus$inboundSchema,
-    type: OutputItemImageGenerationCallType$inboundSchema,
+    type: z.literal("image_generation_call"),
 });
 export function outputItemImageGenerationCallFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputItemImageGenerationCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemImageGenerationCall' from JSON`);

package/esm/models/outputitemreasoning.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ReasoningSummaryText } from "./reasoningsummarytext.js";
+import { ReasoningTextContent } from "./reasoningtextcontent.js";
+export declare const OutputItemReasoningStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputItemReasoningStatusInProgress = ClosedEnum<typeof OutputItemReasoningStatusInProgress>;
+export declare const OutputItemReasoningStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputItemReasoningStatusIncomplete = ClosedEnum<typeof OutputItemReasoningStatusIncomplete>;
+export declare const OutputItemReasoningStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputItemReasoningStatusCompleted = ClosedEnum<typeof OutputItemReasoningStatusCompleted>;
+export type OutputItemReasoningStatusUnion = OutputItemReasoningStatusCompleted | OutputItemReasoningStatusIncomplete | OutputItemReasoningStatusInProgress;
+export type OutputItemReasoning = {
+    content?: Array<ReasoningTextContent> | undefined;
+    encryptedContent?: string | null | undefined;
+    id: string;
+    status?: OutputItemReasoningStatusCompleted | OutputItemReasoningStatusIncomplete | OutputItemReasoningStatusInProgress | undefined;
+    summary: Array<ReasoningSummaryText>;
+    type: "reasoning";
+};
+/** @internal */
+export declare const OutputItemReasoningStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputItemReasoningStatusInProgress>;
+/** @internal */
+export declare const OutputItemReasoningStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputItemReasoningStatusIncomplete>;
+/** @internal */
+export declare const OutputItemReasoningStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputItemReasoningStatusCompleted>;
+/** @internal */
+export declare const OutputItemReasoningStatusUnion$inboundSchema: z.ZodType<OutputItemReasoningStatusUnion, unknown>;
+export declare function outputItemReasoningStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputItemReasoningStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputItemReasoning$inboundSchema: z.ZodType<OutputItemReasoning, unknown>;
+export declare function outputItemReasoningFromJSON(jsonString: string): SafeParseResult<OutputItemReasoning, SDKValidationError>;
+//# sourceMappingURL=outputitemreasoning.d.ts.map

package/esm/models/outputitemreasoning.js

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a1c7dca97393
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
+import { ReasoningTextContent$inboundSchema, } from "./reasoningtextcontent.js";
+export const OutputItemReasoningStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputItemReasoningStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputItemReasoningStatusCompleted = {
+    Completed: "completed",
+};
+/** @internal */
+export const OutputItemReasoningStatusInProgress$inboundSchema = z.enum(OutputItemReasoningStatusInProgress);
+/** @internal */
+export const OutputItemReasoningStatusIncomplete$inboundSchema = z.enum(OutputItemReasoningStatusIncomplete);
+/** @internal */
+export const OutputItemReasoningStatusCompleted$inboundSchema = z.enum(OutputItemReasoningStatusCompleted);
+/** @internal */
+export const OutputItemReasoningStatusUnion$inboundSchema = z.union([
+    OutputItemReasoningStatusCompleted$inboundSchema,
+    OutputItemReasoningStatusIncomplete$inboundSchema,
+    OutputItemReasoningStatusInProgress$inboundSchema,
+]);
+export function outputItemReasoningStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemReasoningStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemReasoningStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputItemReasoning$inboundSchema = z.object({
+    content: z.array(ReasoningTextContent$inboundSchema).optional(),
+    encrypted_content: z.nullable(z.string()).optional(),
+    id: z.string(),
+    status: z.union([
+        OutputItemReasoningStatusCompleted$inboundSchema,
+        OutputItemReasoningStatusIncomplete$inboundSchema,
+        OutputItemReasoningStatusInProgress$inboundSchema,
+    ]).optional(),
+    summary: z.array(ReasoningSummaryText$inboundSchema),
+    type: z.literal("reasoning"),
+}).transform((v) => {
+    return remap$(v, {
+        "encrypted_content": "encryptedContent",
+    });
+});
+export function outputItemReasoningFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemReasoning$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemReasoning' from JSON`);
+}
+//# sourceMappingURL=outputitemreasoning.js.map

package/esm/models/outputitemwebsearchcall.d.ts

@@ -0,0 +1,47 @@
+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 { WebSearchSource } from "./websearchsource.js";
+import { WebSearchStatus } from "./websearchstatus.js";
+export type OutputItemWebSearchCallActionFindInPage = {
+    pattern: string;
+    type: "find_in_page";
+    url: string;
+};
+export type OutputItemWebSearchCallActionOpenPage = {
+    type: "open_page";
+    url?: string | null | undefined;
+};
+export type OutputItemWebSearchCallActionSearch = {
+    queries?: Array<string> | undefined;
+    query: string;
+    sources?: Array<WebSearchSource> | undefined;
+    type: "search";
+};
+export type OutputItemWebSearchCallActionUnion = OutputItemWebSearchCallActionSearch | OutputItemWebSearchCallActionOpenPage | OutputItemWebSearchCallActionFindInPage | discriminatedUnionTypes.Unknown<"type">;
+export type OutputItemWebSearchCall = {
+    action?: OutputItemWebSearchCallActionSearch | OutputItemWebSearchCallActionOpenPage | OutputItemWebSearchCallActionFindInPage | discriminatedUnionTypes.Unknown<"type"> | undefined;
+    id: string;
+    status: WebSearchStatus;
+    type: "web_search_call";
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const OutputItemWebSearchCallActionFindInPage$inboundSchema: z.ZodType<OutputItemWebSearchCallActionFindInPage, unknown>;
+export declare function outputItemWebSearchCallActionFindInPageFromJSON(jsonString: string): SafeParseResult<OutputItemWebSearchCallActionFindInPage, SDKValidationError>;
+/** @internal */
+export declare const OutputItemWebSearchCallActionOpenPage$inboundSchema: z.ZodType<OutputItemWebSearchCallActionOpenPage, unknown>;
+export declare function outputItemWebSearchCallActionOpenPageFromJSON(jsonString: string): SafeParseResult<OutputItemWebSearchCallActionOpenPage, SDKValidationError>;
+/** @internal */
+export declare const OutputItemWebSearchCallActionSearch$inboundSchema: z.ZodType<OutputItemWebSearchCallActionSearch, unknown>;
+export declare function outputItemWebSearchCallActionSearchFromJSON(jsonString: string): SafeParseResult<OutputItemWebSearchCallActionSearch, SDKValidationError>;
+/** @internal */
+export declare const OutputItemWebSearchCallActionUnion$inboundSchema: z.ZodType<OutputItemWebSearchCallActionUnion, unknown>;
+export declare function outputItemWebSearchCallActionUnionFromJSON(jsonString: string): SafeParseResult<OutputItemWebSearchCallActionUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputItemWebSearchCall$inboundSchema: z.ZodType<OutputItemWebSearchCall, unknown>;
+export declare function outputItemWebSearchCallFromJSON(jsonString: string): SafeParseResult<OutputItemWebSearchCall, SDKValidationError>;
+//# sourceMappingURL=outputitemwebsearchcall.d.ts.map

package/esm/models/outputitemwebsearchcall.js

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 759b367102df
+ */
+import * as z from "zod/v4";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { WebSearchSource$inboundSchema, } from "./websearchsource.js";
+import { WebSearchStatus$inboundSchema, } from "./websearchstatus.js";
+/** @internal */
+export const OutputItemWebSearchCallActionFindInPage$inboundSchema = z.object({
+    pattern: z.string(),
+    type: z.literal("find_in_page"),
+    url: z.string(),
+});
+export function outputItemWebSearchCallActionFindInPageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemWebSearchCallActionFindInPage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemWebSearchCallActionFindInPage' from JSON`);
+}
+/** @internal */
+export const OutputItemWebSearchCallActionOpenPage$inboundSchema = z.object({
+    type: z.literal("open_page"),
+    url: z.nullable(z.string()).optional(),
+});
+export function outputItemWebSearchCallActionOpenPageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemWebSearchCallActionOpenPage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemWebSearchCallActionOpenPage' from JSON`);
+}
+/** @internal */
+export const OutputItemWebSearchCallActionSearch$inboundSchema = z.object({
+    queries: z.array(z.string()).optional(),
+    query: z.string(),
+    sources: z.array(WebSearchSource$inboundSchema).optional(),
+    type: z.literal("search"),
+});
+export function outputItemWebSearchCallActionSearchFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemWebSearchCallActionSearch$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemWebSearchCallActionSearch' from JSON`);
+}
+/** @internal */
+export const OutputItemWebSearchCallActionUnion$inboundSchema = discriminatedUnion("type", {
+    search: z.lazy(() => OutputItemWebSearchCallActionSearch$inboundSchema),
+    open_page: z.lazy(() => OutputItemWebSearchCallActionOpenPage$inboundSchema),
+    find_in_page: z.lazy(() => OutputItemWebSearchCallActionFindInPage$inboundSchema),
+});
+export function outputItemWebSearchCallActionUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemWebSearchCallActionUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemWebSearchCallActionUnion' from JSON`);
+}
+/** @internal */
+export const OutputItemWebSearchCall$inboundSchema = collectExtraKeys$(z.object({
+    action: discriminatedUnion("type", {
+        search: z.lazy(() => OutputItemWebSearchCallActionSearch$inboundSchema),
+        open_page: z.lazy(() => OutputItemWebSearchCallActionOpenPage$inboundSchema),
+        find_in_page: z.lazy(() => OutputItemWebSearchCallActionFindInPage$inboundSchema),
+    }).optional(),
+    id: z.string(),
+    status: WebSearchStatus$inboundSchema,
+    type: z.literal("web_search_call"),
+}).catchall(z.any()), "additionalProperties", true);
+export function outputItemWebSearchCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemWebSearchCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemWebSearchCall' from JSON`);
+}
+//# sourceMappingURL=outputitemwebsearchcall.js.map

package/esm/models/outputmessage.d.ts

@@ -35,10 +35,6 @@ export declare const OutputMessageStatusCompleted: {
 };
 export type OutputMessageStatusCompleted = ClosedEnum<typeof OutputMessageStatusCompleted>;
 export type OutputMessageStatusUnion = OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress;
-export declare const OutputMessageType: {
-    readonly Message: "message";
-};
-export type OutputMessageType = ClosedEnum<typeof OutputMessageType>;
 export type OutputMessage = {
     content: Array<ResponseOutputText | OpenAIResponsesRefusalContent | discriminatedUnionTypes.Unknown<"type">>;
     id: string;
@@ -48,7 +44,7 @@ export type OutputMessage = {
     phase?: OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | null | undefined;
     role: OutputMessageRole;
     status?: OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress | undefined;
-    type: OutputMessageType;
+    type: "message";
 };
 /** @internal */
 export declare const OutputMessageContent$inboundSchema: z.ZodType<OutputMessageContent, unknown>;
@@ -72,8 +68,6 @@ export declare const OutputMessageStatusCompleted$inboundSchema: z.ZodEnum<typeo
 export declare const OutputMessageStatusUnion$inboundSchema: z.ZodType<OutputMessageStatusUnion, unknown>;
 export declare function outputMessageStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageStatusUnion, SDKValidationError>;
 /** @internal */
-export declare const OutputMessageType$inboundSchema: z.ZodEnum<typeof OutputMessageType>;
-/** @internal */
 export declare const OutputMessage$inboundSchema: z.ZodType<OutputMessage, unknown>;
 export declare function outputMessageFromJSON(jsonString: string): SafeParseResult<OutputMessage, SDKValidationError>;
 //# sourceMappingURL=outputmessage.d.ts.map

package/esm/models/outputmessage.js

@@ -25,9 +25,6 @@ export const OutputMessageStatusIncomplete = {
 export const OutputMessageStatusCompleted = {
     Completed: "completed",
 };
-export const OutputMessageType = {
-    Message: "message",
-};
 /** @internal */
 export const OutputMessageContent$inboundSchema = discriminatedUnion("type", {
     output_text: ResponseOutputText$inboundSchema,
@@ -66,8 +63,6 @@ export function outputMessageStatusUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageStatusUnion' from JSON`);
 }
 /** @internal */
-export const OutputMessageType$inboundSchema = z.enum(OutputMessageType);
-/** @internal */
 export const OutputMessage$inboundSchema = z
     .object({
     content: z.array(discriminatedUnion("type", {
@@ -85,7 +80,7 @@ export const OutputMessage$inboundSchema = z
         OutputMessageStatusIncomplete$inboundSchema,
         OutputMessageStatusInProgress$inboundSchema,
     ]).optional(),
-    type: OutputMessageType$inboundSchema,
+    type: z.literal("message"),
 });
 export function outputMessageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessage' from JSON`);