@openrouter/sdk 1.4.9 → 1.4.11

package/esm/models/operations/updateenduser.d.ts

@@ -0,0 +1,61 @@
+import * as z from "zod/v4";
+import * as models from "../index.js";
+export type UpdateEndUserGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+};
+export type UpdateEndUserRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+    /**
+     * Immutable case-sensitive tracking string supplied as user on inference requests. URL-encode it in resource paths.
+     */
+    user: string;
+    updateEndUserRequest: models.UpdateEndUserRequest;
+};
+/** @internal */
+export type UpdateEndUserRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
+    user: string;
+    UpdateEndUserRequest: models.UpdateEndUserRequest$Outbound;
+};
+/** @internal */
+export declare const UpdateEndUserRequest$outboundSchema: z.ZodType<UpdateEndUserRequest$Outbound, UpdateEndUserRequest>;
+export declare function updateEndUserRequestToJSON(updateEndUserRequest: UpdateEndUserRequest): string;
+//# sourceMappingURL=updateenduser.d.ts.map

package/esm/models/operations/updateenduser.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 15ed3e7fa116
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { UpdateEndUserRequest$outboundSchema as models_UpdateEndUserRequest$outboundSchema } from "../updateenduserrequest.js";
+/** @internal */
+export const UpdateEndUserRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
+    user: z.string(),
+    updateEndUserRequest: models_UpdateEndUserRequest$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        updateEndUserRequest: "UpdateEndUserRequest",
+    });
+});
+export function updateEndUserRequestToJSON(updateEndUserRequest) {
+    return JSON.stringify(UpdateEndUserRequest$outboundSchema.parse(updateEndUserRequest));
+}
+//# sourceMappingURL=updateenduser.js.map

package/esm/models/outputitemapplypatchcall.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ApplyPatchCreateFileOperation } from "./applypatchcreatefileoperation.js";
+import { ApplyPatchDeleteFileOperation } from "./applypatchdeletefileoperation.js";
+import { ApplyPatchUpdateFileOperation } from "./applypatchupdatefileoperation.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type Operation = ApplyPatchCreateFileOperation | ApplyPatchDeleteFileOperation | ApplyPatchUpdateFileOperation | discriminatedUnionTypes.Unknown<"type">;
+export declare const OutputItemApplyPatchCallStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+};
+export type OutputItemApplyPatchCallStatus = OpenEnum<typeof OutputItemApplyPatchCallStatus>;
+export type OutputItemApplyPatchCall = {
+    callId: string;
+    createdBy?: string | undefined;
+    id: string;
+    operation: ApplyPatchCreateFileOperation | ApplyPatchDeleteFileOperation | ApplyPatchUpdateFileOperation | discriminatedUnionTypes.Unknown<"type">;
+    status: OutputItemApplyPatchCallStatus;
+    type: "apply_patch_call";
+};
+/** @internal */
+export declare const Operation$inboundSchema: z.ZodType<Operation, unknown>;
+export declare function operationFromJSON(jsonString: string): SafeParseResult<Operation, SDKValidationError>;
+/** @internal */
+export declare const OutputItemApplyPatchCallStatus$inboundSchema: z.ZodType<OutputItemApplyPatchCallStatus, unknown>;
+/** @internal */
+export declare const OutputItemApplyPatchCall$inboundSchema: z.ZodType<OutputItemApplyPatchCall, unknown>;
+export declare function outputItemApplyPatchCallFromJSON(jsonString: string): SafeParseResult<OutputItemApplyPatchCall, SDKValidationError>;
+//# sourceMappingURL=outputitemapplypatchcall.d.ts.map

package/esm/models/outputitemapplypatchcall.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e89e86568a78
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import * as openEnums from "../types/enums.js";
+import { ApplyPatchCreateFileOperation$inboundSchema, } from "./applypatchcreatefileoperation.js";
+import { ApplyPatchDeleteFileOperation$inboundSchema, } from "./applypatchdeletefileoperation.js";
+import { ApplyPatchUpdateFileOperation$inboundSchema, } from "./applypatchupdatefileoperation.js";
+export const OutputItemApplyPatchCallStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+};
+/** @internal */
+export const Operation$inboundSchema = discriminatedUnion("type", {
+    create_file: ApplyPatchCreateFileOperation$inboundSchema,
+    delete_file: ApplyPatchDeleteFileOperation$inboundSchema,
+    update_file: ApplyPatchUpdateFileOperation$inboundSchema,
+});
+export function operationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Operation$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Operation' from JSON`);
+}
+/** @internal */
+export const OutputItemApplyPatchCallStatus$inboundSchema = openEnums.inboundSchema(OutputItemApplyPatchCallStatus);
+/** @internal */
+export const OutputItemApplyPatchCall$inboundSchema = z.object({
+    call_id: z.string(),
+    created_by: z.string().optional(),
+    id: z.string(),
+    operation: discriminatedUnion("type", {
+        create_file: ApplyPatchCreateFileOperation$inboundSchema,
+        delete_file: ApplyPatchDeleteFileOperation$inboundSchema,
+        update_file: ApplyPatchUpdateFileOperation$inboundSchema,
+    }),
+    status: OutputItemApplyPatchCallStatus$inboundSchema,
+    type: z.literal("apply_patch_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+        "created_by": "createdBy",
+    });
+});
+export function outputItemApplyPatchCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItemApplyPatchCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItemApplyPatchCall' from JSON`);
+}
+//# sourceMappingURL=outputitemapplypatchcall.js.map

package/esm/models/outputitemcodeinterpretercall.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CodeInterpreterFileOutput } from "./codeinterpreterfileoutput.js";
+import { CodeInterpreterImageOutput } from "./codeinterpreterimageoutput.js";
+import { CodeInterpreterLogsOutput } from "./codeinterpreterlogsoutput.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type OutputItemCodeInterpreterCallOutput = CodeInterpreterFileOutput | CodeInterpreterImageOutput | CodeInterpreterLogsOutput | discriminatedUnionTypes.Unknown<"type">;
+export declare const OutputItemCodeInterpreterCallStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+    readonly Interpreting: "interpreting";
+    readonly Failed: "failed";
+};
+export type OutputItemCodeInterpreterCallStatus = OpenEnum<typeof OutputItemCodeInterpreterCallStatus>;
+export type OutputItemCodeInterpreterCall = {
+    code?: string | null | undefined;
+    containerId?: string | undefined;
+    id: string;
+    outputs?: Array<CodeInterpreterFileOutput | CodeInterpreterImageOutput | CodeInterpreterLogsOutput | discriminatedUnionTypes.Unknown<"type">> | null | undefined;
+    status: OutputItemCodeInterpreterCallStatus;
+    type: "code_interpreter_call";
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const OutputItemCodeInterpreterCallOutput$inboundSchema: z.ZodType<OutputItemCodeInterpreterCallOutput, unknown>;
+export declare function outputItemCodeInterpreterCallOutputFromJSON(jsonString: string): SafeParseResult<OutputItemCodeInterpreterCallOutput, SDKValidationError>;
+/** @internal */
+export declare const OutputItemCodeInterpreterCallStatus$inboundSchema: z.ZodType<OutputItemCodeInterpreterCallStatus, unknown>;
+/** @internal */
+export declare const OutputItemCodeInterpreterCall$inboundSchema: z.ZodType<OutputItemCodeInterpreterCall, unknown>;
+export declare function outputItemCodeInterpreterCallFromJSON(jsonString: string): SafeParseResult<OutputItemCodeInterpreterCall, SDKValidationError>;
+//# sourceMappingURL=outputitemcodeinterpretercall.d.ts.map

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