@openrouter/sdk 0.10.2 → 0.11.2

package/esm/models/outputfilesearchcallitem.d.ts

@@ -0,0 +1,33 @@
+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 { WebSearchStatus } from "./websearchstatus.js";
+export declare const OutputFileSearchCallItemType: {
+    readonly FileSearchCall: "file_search_call";
+};
+export type OutputFileSearchCallItemType = ClosedEnum<typeof OutputFileSearchCallItemType>;
+export type OutputFileSearchCallItem = {
+    type: OutputFileSearchCallItemType;
+    id: string;
+    queries: Array<string>;
+    status: WebSearchStatus;
+};
+/** @internal */
+export declare const OutputFileSearchCallItemType$inboundSchema: z.ZodEnum<typeof OutputFileSearchCallItemType>;
+/** @internal */
+export declare const OutputFileSearchCallItemType$outboundSchema: z.ZodEnum<typeof OutputFileSearchCallItemType>;
+/** @internal */
+export declare const OutputFileSearchCallItem$inboundSchema: z.ZodType<OutputFileSearchCallItem, unknown>;
+/** @internal */
+export type OutputFileSearchCallItem$Outbound = {
+    type: string;
+    id: string;
+    queries: Array<string>;
+    status: string;
+};
+/** @internal */
+export declare const OutputFileSearchCallItem$outboundSchema: z.ZodType<OutputFileSearchCallItem$Outbound, OutputFileSearchCallItem>;
+export declare function outputFileSearchCallItemToJSON(outputFileSearchCallItem: OutputFileSearchCallItem): string;
+export declare function outputFileSearchCallItemFromJSON(jsonString: string): SafeParseResult<OutputFileSearchCallItem, SDKValidationError>;
+//# sourceMappingURL=outputfilesearchcallitem.d.ts.map

package/esm/models/outputfilesearchcallitem.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: eafceec94b81
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { WebSearchStatus$inboundSchema, WebSearchStatus$outboundSchema, } from "./websearchstatus.js";
+export const OutputFileSearchCallItemType = {
+    FileSearchCall: "file_search_call",
+};
+/** @internal */
+export const OutputFileSearchCallItemType$inboundSchema = z.enum(OutputFileSearchCallItemType);
+/** @internal */
+export const OutputFileSearchCallItemType$outboundSchema = OutputFileSearchCallItemType$inboundSchema;
+/** @internal */
+export const OutputFileSearchCallItem$inboundSchema = z.object({
+    type: OutputFileSearchCallItemType$inboundSchema,
+    id: z.string(),
+    queries: z.array(z.string()),
+    status: WebSearchStatus$inboundSchema,
+});
+/** @internal */
+export const OutputFileSearchCallItem$outboundSchema = z.object({
+    type: OutputFileSearchCallItemType$outboundSchema,
+    id: z.string(),
+    queries: z.array(z.string()),
+    status: WebSearchStatus$outboundSchema,
+});
+export function outputFileSearchCallItemToJSON(outputFileSearchCallItem) {
+    return JSON.stringify(OutputFileSearchCallItem$outboundSchema.parse(outputFileSearchCallItem));
+}
+export function outputFileSearchCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFileSearchCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFileSearchCallItem' from JSON`);
+}
+//# sourceMappingURL=outputfilesearchcallitem.js.map

package/esm/models/outputfunctioncallitem.d.ts

@@ -0,0 +1,69 @@
+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 OutputFunctionCallItemType: {
+    readonly FunctionCall: "function_call";
+};
+export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
+export declare const OutputFunctionCallItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputFunctionCallItemStatusInProgress = ClosedEnum<typeof OutputFunctionCallItemStatusInProgress>;
+export declare const OutputFunctionCallItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputFunctionCallItemStatusIncomplete = ClosedEnum<typeof OutputFunctionCallItemStatusIncomplete>;
+export declare const OutputFunctionCallItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputFunctionCallItemStatusCompleted = ClosedEnum<typeof OutputFunctionCallItemStatusCompleted>;
+export type OutputFunctionCallItemStatusUnion = OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress;
+export type OutputFunctionCallItem = {
+    type: OutputFunctionCallItemType;
+    id?: string | undefined;
+    name: string;
+    arguments: string;
+    callId: string;
+    status?: OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress | undefined;
+};
+/** @internal */
+export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
+/** @internal */
+export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusInProgress$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusIncomplete$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusCompleted$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusUnion$inboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion, unknown>;
+/** @internal */
+export type OutputFunctionCallItemStatusUnion$Outbound = string | string | string;
+/** @internal */
+export declare const OutputFunctionCallItemStatusUnion$outboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion$Outbound, OutputFunctionCallItemStatusUnion>;
+export declare function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion: OutputFunctionCallItemStatusUnion): string;
+export declare function outputFunctionCallItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunctionCallItem, unknown>;
+/** @internal */
+export type OutputFunctionCallItem$Outbound = {
+    type: string;
+    id?: string | undefined;
+    name: string;
+    arguments: string;
+    call_id: string;
+    status?: string | string | string | undefined;
+};
+/** @internal */
+export declare const OutputFunctionCallItem$outboundSchema: z.ZodType<OutputFunctionCallItem$Outbound, OutputFunctionCallItem>;
+export declare function outputFunctionCallItemToJSON(outputFunctionCallItem: OutputFunctionCallItem): string;
+export declare function outputFunctionCallItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItem, SDKValidationError>;
+//# sourceMappingURL=outputfunctioncallitem.d.ts.map

package/esm/models/outputfunctioncallitem.js

@@ -0,0 +1,94 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9c462e9ff54b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OutputFunctionCallItemType = {
+    FunctionCall: "function_call",
+};
+export const OutputFunctionCallItemStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputFunctionCallItemStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputFunctionCallItemStatusCompleted = {
+    Completed: "completed",
+};
+/** @internal */
+export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCallItemType);
+/** @internal */
+export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusInProgress$inboundSchema = z.enum(OutputFunctionCallItemStatusInProgress);
+/** @internal */
+export const OutputFunctionCallItemStatusInProgress$outboundSchema = OutputFunctionCallItemStatusInProgress$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusIncomplete$inboundSchema = z.enum(OutputFunctionCallItemStatusIncomplete);
+/** @internal */
+export const OutputFunctionCallItemStatusIncomplete$outboundSchema = OutputFunctionCallItemStatusIncomplete$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusCompleted$inboundSchema = z.enum(OutputFunctionCallItemStatusCompleted);
+/** @internal */
+export const OutputFunctionCallItemStatusCompleted$outboundSchema = OutputFunctionCallItemStatusCompleted$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusUnion$inboundSchema = z.union([
+    OutputFunctionCallItemStatusCompleted$inboundSchema,
+    OutputFunctionCallItemStatusIncomplete$inboundSchema,
+    OutputFunctionCallItemStatusInProgress$inboundSchema,
+]);
+/** @internal */
+export const OutputFunctionCallItemStatusUnion$outboundSchema = z.union([
+    OutputFunctionCallItemStatusCompleted$outboundSchema,
+    OutputFunctionCallItemStatusIncomplete$outboundSchema,
+    OutputFunctionCallItemStatusInProgress$outboundSchema,
+]);
+export function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion) {
+    return JSON.stringify(OutputFunctionCallItemStatusUnion$outboundSchema.parse(outputFunctionCallItemStatusUnion));
+}
+export function outputFunctionCallItemStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFunctionCallItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputFunctionCallItem$inboundSchema = z.object({
+    type: OutputFunctionCallItemType$inboundSchema,
+    id: z.string().optional(),
+    name: z.string(),
+    arguments: z.string(),
+    call_id: z.string(),
+    status: z.union([
+        OutputFunctionCallItemStatusCompleted$inboundSchema,
+        OutputFunctionCallItemStatusIncomplete$inboundSchema,
+        OutputFunctionCallItemStatusInProgress$inboundSchema,
+    ]).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const OutputFunctionCallItem$outboundSchema = z.object({
+    type: OutputFunctionCallItemType$outboundSchema,
+    id: z.string().optional(),
+    name: z.string(),
+    arguments: z.string(),
+    callId: z.string(),
+    status: z.union([
+        OutputFunctionCallItemStatusCompleted$outboundSchema,
+        OutputFunctionCallItemStatusIncomplete$outboundSchema,
+        OutputFunctionCallItemStatusInProgress$outboundSchema,
+    ]).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function outputFunctionCallItemToJSON(outputFunctionCallItem) {
+    return JSON.stringify(OutputFunctionCallItem$outboundSchema.parse(outputFunctionCallItem));
+}
+export function outputFunctionCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFunctionCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItem' from JSON`);
+}
+//# sourceMappingURL=outputfunctioncallitem.js.map

package/esm/models/outputimagegenerationcallitem.d.ts

@@ -0,0 +1,33 @@
+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 OutputImageGenerationCallItemType: {
+    readonly ImageGenerationCall: "image_generation_call";
+};
+export type OutputImageGenerationCallItemType = ClosedEnum<typeof OutputImageGenerationCallItemType>;
+export type OutputImageGenerationCallItem = {
+    type: OutputImageGenerationCallItemType;
+    id: string;
+    result?: string | null | undefined;
+    status: ImageGenerationStatus;
+};
+/** @internal */
+export declare const OutputImageGenerationCallItemType$inboundSchema: z.ZodEnum<typeof OutputImageGenerationCallItemType>;
+/** @internal */
+export declare const OutputImageGenerationCallItemType$outboundSchema: z.ZodEnum<typeof OutputImageGenerationCallItemType>;
+/** @internal */
+export declare const OutputImageGenerationCallItem$inboundSchema: z.ZodType<OutputImageGenerationCallItem, unknown>;
+/** @internal */
+export type OutputImageGenerationCallItem$Outbound = {
+    type: string;
+    id: string;
+    result: string | null;
+    status: string;
+};
+/** @internal */
+export declare const OutputImageGenerationCallItem$outboundSchema: z.ZodType<OutputImageGenerationCallItem$Outbound, OutputImageGenerationCallItem>;
+export declare function outputImageGenerationCallItemToJSON(outputImageGenerationCallItem: OutputImageGenerationCallItem): string;
+export declare function outputImageGenerationCallItemFromJSON(jsonString: string): SafeParseResult<OutputImageGenerationCallItem, SDKValidationError>;
+//# sourceMappingURL=outputimagegenerationcallitem.d.ts.map

package/esm/models/outputimagegenerationcallitem.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 618bac10713d
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ImageGenerationStatus$inboundSchema, ImageGenerationStatus$outboundSchema, } from "./imagegenerationstatus.js";
+export const OutputImageGenerationCallItemType = {
+    ImageGenerationCall: "image_generation_call",
+};
+/** @internal */
+export const OutputImageGenerationCallItemType$inboundSchema = z.enum(OutputImageGenerationCallItemType);
+/** @internal */
+export const OutputImageGenerationCallItemType$outboundSchema = OutputImageGenerationCallItemType$inboundSchema;
+/** @internal */
+export const OutputImageGenerationCallItem$inboundSchema = z.object({
+    type: OutputImageGenerationCallItemType$inboundSchema,
+    id: z.string(),
+    result: z.nullable(z.string()).default(null),
+    status: ImageGenerationStatus$inboundSchema,
+});
+/** @internal */
+export const OutputImageGenerationCallItem$outboundSchema = z.object({
+    type: OutputImageGenerationCallItemType$outboundSchema,
+    id: z.string(),
+    result: z.nullable(z.string()).default(null),
+    status: ImageGenerationStatus$outboundSchema,
+});
+export function outputImageGenerationCallItemToJSON(outputImageGenerationCallItem) {
+    return JSON.stringify(OutputImageGenerationCallItem$outboundSchema.parse(outputImageGenerationCallItem));
+}
+export function outputImageGenerationCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputImageGenerationCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputImageGenerationCallItem' from JSON`);
+}
+//# sourceMappingURL=outputimagegenerationcallitem.js.map

package/esm/models/outputitems.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OutputFileSearchCallItem } from "./outputfilesearchcallitem.js";
+import { OutputFunctionCallItem } from "./outputfunctioncallitem.js";
+import { OutputImageGenerationCallItem } from "./outputimagegenerationcallitem.js";
+import { OutputMessageItem } from "./outputmessageitem.js";
+import { OutputReasoningItem } from "./outputreasoningitem.js";
+import { OutputServerToolItem } from "./outputservertoolitem.js";
+import { OutputWebSearchCallItem } from "./outputwebsearchcallitem.js";
+/**
+ * An output item from the response
+ */
+export type OutputItems = OutputMessageItem | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputReasoningItem | OutputImageGenerationCallItem | OutputServerToolItem;
+/** @internal */
+export declare const OutputItems$inboundSchema: z.ZodType<OutputItems, unknown>;
+export declare function outputItemsFromJSON(jsonString: string): SafeParseResult<OutputItems, SDKValidationError>;
+//# sourceMappingURL=outputitems.d.ts.map

package/esm/models/outputitems.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0d7161b3403e
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { OutputFileSearchCallItem$inboundSchema, } from "./outputfilesearchcallitem.js";
+import { OutputFunctionCallItem$inboundSchema, } from "./outputfunctioncallitem.js";
+import { OutputImageGenerationCallItem$inboundSchema, } from "./outputimagegenerationcallitem.js";
+import { OutputMessageItem$inboundSchema, } from "./outputmessageitem.js";
+import { OutputReasoningItem$inboundSchema, } from "./outputreasoningitem.js";
+import { OutputServerToolItem$inboundSchema, } from "./outputservertoolitem.js";
+import { OutputWebSearchCallItem$inboundSchema, } from "./outputwebsearchcallitem.js";
+/** @internal */
+export const OutputItems$inboundSchema = z
+    .union([
+    OutputMessageItem$inboundSchema,
+    OutputFunctionCallItem$inboundSchema,
+    OutputWebSearchCallItem$inboundSchema,
+    OutputFileSearchCallItem$inboundSchema,
+    OutputReasoningItem$inboundSchema,
+    OutputImageGenerationCallItem$inboundSchema,
+    OutputServerToolItem$inboundSchema,
+]);
+export function outputItemsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputItems$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputItems' from JSON`);
+}
+//# sourceMappingURL=outputitems.js.map

package/esm/models/outputmessageitem.d.ts

@@ -0,0 +1,81 @@
+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 { OpenAIResponsesRefusalContent } from "./openairesponsesrefusalcontent.js";
+import { ResponseOutputText } from "./responseoutputtext.js";
+export declare const OutputMessageItemRole: {
+    readonly Assistant: "assistant";
+};
+export type OutputMessageItemRole = ClosedEnum<typeof OutputMessageItemRole>;
+export declare const OutputMessageItemType: {
+    readonly Message: "message";
+};
+export type OutputMessageItemType = ClosedEnum<typeof OutputMessageItemType>;
+export declare const OutputMessageItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputMessageItemStatusInProgress = ClosedEnum<typeof OutputMessageItemStatusInProgress>;
+export declare const OutputMessageItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputMessageItemStatusIncomplete = ClosedEnum<typeof OutputMessageItemStatusIncomplete>;
+export declare const OutputMessageItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputMessageItemStatusCompleted = ClosedEnum<typeof OutputMessageItemStatusCompleted>;
+export type OutputMessageItemStatusUnion = OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress;
+export type OutputMessageItemContent = ResponseOutputText | OpenAIResponsesRefusalContent;
+export declare const OutputMessageItemPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OutputMessageItemPhaseFinalAnswer = ClosedEnum<typeof OutputMessageItemPhaseFinalAnswer>;
+export declare const OutputMessageItemPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OutputMessageItemPhaseCommentary = ClosedEnum<typeof OutputMessageItemPhaseCommentary>;
+/**
+ * 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 OutputMessageItemPhaseUnion = OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any;
+/**
+ * An output message item
+ */
+export type OutputMessageItem = {
+    id: string;
+    role: OutputMessageItemRole;
+    type: OutputMessageItemType;
+    status?: OutputMessageItemStatusCompleted | OutputMessageItemStatusIncomplete | OutputMessageItemStatusInProgress | undefined;
+    content: Array<ResponseOutputText | OpenAIResponsesRefusalContent>;
+    /**
+     * 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?: OutputMessageItemPhaseCommentary | OutputMessageItemPhaseFinalAnswer | any | null | undefined;
+};
+/** @internal */
+export declare const OutputMessageItemRole$inboundSchema: z.ZodEnum<typeof OutputMessageItemRole>;
+/** @internal */
+export declare const OutputMessageItemType$inboundSchema: z.ZodEnum<typeof OutputMessageItemType>;
+/** @internal */
+export declare const OutputMessageItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusInProgress>;
+/** @internal */
+export declare const OutputMessageItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusIncomplete>;
+/** @internal */
+export declare const OutputMessageItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputMessageItemStatusCompleted>;
+/** @internal */
+export declare const OutputMessageItemStatusUnion$inboundSchema: z.ZodType<OutputMessageItemStatusUnion, unknown>;
+export declare function outputMessageItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItemContent$inboundSchema: z.ZodType<OutputMessageItemContent, unknown>;
+export declare function outputMessageItemContentFromJSON(jsonString: string): SafeParseResult<OutputMessageItemContent, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItemPhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseFinalAnswer>;
+/** @internal */
+export declare const OutputMessageItemPhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessageItemPhaseCommentary>;
+/** @internal */
+export declare const OutputMessageItemPhaseUnion$inboundSchema: z.ZodType<OutputMessageItemPhaseUnion, unknown>;
+export declare function outputMessageItemPhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessageItemPhaseUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputMessageItem$inboundSchema: z.ZodType<OutputMessageItem, unknown>;
+export declare function outputMessageItemFromJSON(jsonString: string): SafeParseResult<OutputMessageItem, SDKValidationError>;
+//# sourceMappingURL=outputmessageitem.d.ts.map

package/esm/models/outputmessageitem.js

@@ -0,0 +1,93 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7eb39195329c
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesRefusalContent$inboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { ResponseOutputText$inboundSchema, } from "./responseoutputtext.js";
+export const OutputMessageItemRole = {
+    Assistant: "assistant",
+};
+export const OutputMessageItemType = {
+    Message: "message",
+};
+export const OutputMessageItemStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputMessageItemStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputMessageItemStatusCompleted = {
+    Completed: "completed",
+};
+export const OutputMessageItemPhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OutputMessageItemPhaseCommentary = {
+    Commentary: "commentary",
+};
+/** @internal */
+export const OutputMessageItemRole$inboundSchema = z.enum(OutputMessageItemRole);
+/** @internal */
+export const OutputMessageItemType$inboundSchema = z.enum(OutputMessageItemType);
+/** @internal */
+export const OutputMessageItemStatusInProgress$inboundSchema = z.enum(OutputMessageItemStatusInProgress);
+/** @internal */
+export const OutputMessageItemStatusIncomplete$inboundSchema = z.enum(OutputMessageItemStatusIncomplete);
+/** @internal */
+export const OutputMessageItemStatusCompleted$inboundSchema = z.enum(OutputMessageItemStatusCompleted);
+/** @internal */
+export const OutputMessageItemStatusUnion$inboundSchema = z.union([
+    OutputMessageItemStatusCompleted$inboundSchema,
+    OutputMessageItemStatusIncomplete$inboundSchema,
+    OutputMessageItemStatusInProgress$inboundSchema,
+]);
+export function outputMessageItemStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputMessageItemContent$inboundSchema = z.union([
+    ResponseOutputText$inboundSchema,
+    OpenAIResponsesRefusalContent$inboundSchema,
+]);
+export function outputMessageItemContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemContent' from JSON`);
+}
+/** @internal */
+export const OutputMessageItemPhaseFinalAnswer$inboundSchema = z.enum(OutputMessageItemPhaseFinalAnswer);
+/** @internal */
+export const OutputMessageItemPhaseCommentary$inboundSchema = z.enum(OutputMessageItemPhaseCommentary);
+/** @internal */
+export const OutputMessageItemPhaseUnion$inboundSchema = z.union([
+    OutputMessageItemPhaseCommentary$inboundSchema,
+    OutputMessageItemPhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function outputMessageItemPhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItemPhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItemPhaseUnion' from JSON`);
+}
+/** @internal */
+export const OutputMessageItem$inboundSchema = z.object({
+    id: z.string(),
+    role: OutputMessageItemRole$inboundSchema,
+    type: OutputMessageItemType$inboundSchema,
+    status: z.union([
+        OutputMessageItemStatusCompleted$inboundSchema,
+        OutputMessageItemStatusIncomplete$inboundSchema,
+        OutputMessageItemStatusInProgress$inboundSchema,
+    ]).optional(),
+    content: z.array(z.union([
+        ResponseOutputText$inboundSchema,
+        OpenAIResponsesRefusalContent$inboundSchema,
+    ])),
+    phase: z.nullable(z.union([
+        OutputMessageItemPhaseCommentary$inboundSchema,
+        OutputMessageItemPhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
+});
+export function outputMessageItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessageItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageItem' from JSON`);
+}
+//# sourceMappingURL=outputmessageitem.js.map

package/esm/models/outputmodalityenum.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const OutputModalityEnum: {
+    readonly Text: "text";
+    readonly Image: "image";
+};
+export type OutputModalityEnum = OpenEnum<typeof OutputModalityEnum>;
+/** @internal */
+export declare const OutputModalityEnum$outboundSchema: z.ZodType<string, OutputModalityEnum>;
+//# sourceMappingURL=outputmodalityenum.d.ts.map

package/esm/models/outputmodalityenum.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 732188d6b8fa
+ */
+import * as openEnums from "../types/enums.js";
+export const OutputModalityEnum = {
+    Text: "text",
+    Image: "image",
+};
+/** @internal */
+export const OutputModalityEnum$outboundSchema = openEnums.outboundSchema(OutputModalityEnum);
+//# sourceMappingURL=outputmodalityenum.js.map

package/esm/models/outputreasoningitem.d.ts

@@ -0,0 +1,74 @@
+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";
+import { ReasoningSummaryText } from "./reasoningsummarytext.js";
+import { ReasoningTextContent } from "./reasoningtextcontent.js";
+export declare const OutputReasoningItemType: {
+    readonly Reasoning: "reasoning";
+};
+export type OutputReasoningItemType = ClosedEnum<typeof OutputReasoningItemType>;
+export declare const OutputReasoningItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputReasoningItemStatusInProgress = ClosedEnum<typeof OutputReasoningItemStatusInProgress>;
+export declare const OutputReasoningItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputReasoningItemStatusIncomplete = ClosedEnum<typeof OutputReasoningItemStatusIncomplete>;
+export declare const OutputReasoningItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputReasoningItemStatusCompleted = ClosedEnum<typeof OutputReasoningItemStatusCompleted>;
+export type OutputReasoningItemStatusUnion = OutputReasoningItemStatusCompleted | OutputReasoningItemStatusIncomplete | OutputReasoningItemStatusInProgress;
+/**
+ * The format of the reasoning content
+ */
+export declare const OutputReasoningItemFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+/**
+ * The format of the reasoning content
+ */
+export type OutputReasoningItemFormat = OpenEnum<typeof OutputReasoningItemFormat>;
+/**
+ * An output item containing reasoning
+ */
+export type OutputReasoningItem = {
+    type: OutputReasoningItemType;
+    id: string;
+    content?: Array<ReasoningTextContent> | null | undefined;
+    summary: Array<ReasoningSummaryText>;
+    encryptedContent?: string | null | undefined;
+    status?: OutputReasoningItemStatusCompleted | OutputReasoningItemStatusIncomplete | OutputReasoningItemStatusInProgress | undefined;
+    /**
+     * A signature for the reasoning content, used for verification
+     */
+    signature?: string | null | undefined;
+    /**
+     * The format of the reasoning content
+     */
+    format?: OutputReasoningItemFormat | null | undefined;
+};
+/** @internal */
+export declare const OutputReasoningItemType$inboundSchema: z.ZodEnum<typeof OutputReasoningItemType>;
+/** @internal */
+export declare const OutputReasoningItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusInProgress>;
+/** @internal */
+export declare const OutputReasoningItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusIncomplete>;
+/** @internal */
+export declare const OutputReasoningItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputReasoningItemStatusCompleted>;
+/** @internal */
+export declare const OutputReasoningItemStatusUnion$inboundSchema: z.ZodType<OutputReasoningItemStatusUnion, unknown>;
+export declare function outputReasoningItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputReasoningItemStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputReasoningItemFormat$inboundSchema: z.ZodType<OutputReasoningItemFormat, unknown>;
+/** @internal */
+export declare const OutputReasoningItem$inboundSchema: z.ZodType<OutputReasoningItem, unknown>;
+export declare function outputReasoningItemFromJSON(jsonString: string): SafeParseResult<OutputReasoningItem, SDKValidationError>;
+//# sourceMappingURL=outputreasoningitem.d.ts.map