@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/operations/updateguardrail.js

@@ -32,6 +32,7 @@ export const UpdateGuardrailRequestBody$outboundSchema = z.object({
     resetInterval: z.nullable(UpdateGuardrailResetIntervalRequest$outboundSchema)
         .optional(),
     allowedProviders: z.nullable(z.array(z.string())).optional(),
+    ignoredProviders: z.nullable(z.array(z.string())).optional(),
     allowedModels: z.nullable(z.array(z.string())).optional(),
     enforceZdr: z.nullable(z.boolean()).optional(),
 }).transform((v) => {
@@ -39,6 +40,7 @@ export const UpdateGuardrailRequestBody$outboundSchema = z.object({
         limitUsd: "limit_usd",
         resetInterval: "reset_interval",
         allowedProviders: "allowed_providers",
+        ignoredProviders: "ignored_providers",
         allowedModels: "allowed_models",
         enforceZdr: "enforce_zdr",
     });
@@ -49,13 +51,13 @@ export function updateGuardrailRequestBodyToJSON(updateGuardrailRequestBody) {
 /** @internal */
 export const UpdateGuardrailRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
-    xTitle: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
     id: z.string(),
     requestBody: z.lazy(() => UpdateGuardrailRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        xTitle: "X-Title",
         requestBody: "RequestBody",
     });
 });
@@ -73,6 +75,7 @@ export const UpdateGuardrailData$inboundSchema = z.object({
     reset_interval: z.nullable(UpdateGuardrailResetIntervalResponse$inboundSchema)
         .optional(),
     allowed_providers: z.nullable(z.array(z.string())).optional(),
+    ignored_providers: z.nullable(z.array(z.string())).optional(),
     allowed_models: z.nullable(z.array(z.string())).optional(),
     enforce_zdr: z.nullable(z.boolean()).optional(),
     created_at: z.string(),
@@ -82,6 +85,7 @@ export const UpdateGuardrailData$inboundSchema = z.object({
         "limit_usd": "limitUsd",
         "reset_interval": "resetInterval",
         "allowed_providers": "allowedProviders",
+        "ignored_providers": "ignoredProviders",
         "allowed_models": "allowedModels",
         "enforce_zdr": "enforceZdr",
         "created_at": "createdAt",

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

@@ -15,7 +15,13 @@ export type UpdateKeysGlobals = {
      *
      * @remarks
      */
-    xTitle?: string | undefined;
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
 };
 /**
  * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
@@ -64,7 +70,13 @@ export type UpdateKeysRequest = {
      *
      * @remarks
      */
-    xTitle?: string | undefined;
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
     /**
      * The hash identifier of the API key to update
      */
@@ -151,6 +163,10 @@ export type UpdateKeysData = {
      * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
      */
     expiresAt?: Date | null | undefined;
+    /**
+     * The user ID of the key creator. For organization-owned keys, this is the member who created the key. For individual users, this is the user's own ID.
+     */
+    creatorUserId: string | null;
 };
 /**
  * API key updated successfully
@@ -177,7 +193,8 @@ export declare function updateKeysRequestBodyToJSON(updateKeysRequestBody: Updat
 /** @internal */
 export type UpdateKeysRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
-    "X-Title"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
     hash: string;
     RequestBody: UpdateKeysRequestBody$Outbound;
 };

package/esm/models/operations/updatekeys.js

@@ -35,13 +35,13 @@ export function updateKeysRequestBodyToJSON(updateKeysRequestBody) {
 /** @internal */
 export const UpdateKeysRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
-    xTitle: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
     hash: z.string(),
     requestBody: z.lazy(() => UpdateKeysRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        xTitle: "X-Title",
         requestBody: "RequestBody",
     });
 });
@@ -69,6 +69,7 @@ export const UpdateKeysData$inboundSchema = z.object({
     created_at: z.string(),
     updated_at: z.nullable(z.string()),
     expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
+    creator_user_id: z.nullable(z.string()),
 }).transform((v) => {
     return remap$(v, {
         "limit_remaining": "limitRemaining",
@@ -84,6 +85,7 @@ export const UpdateKeysData$inboundSchema = z.object({
         "created_at": "createdAt",
         "updated_at": "updatedAt",
         "expires_at": "expiresAt",
+        "creator_user_id": "creatorUserId",
     });
 });
 export function updateKeysDataFromJSON(jsonString) {

package/esm/models/outputdatetimeitem.d.ts

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+export declare const OutputDatetimeItemType: {
+    readonly OpenrouterDatetime: "openrouter:datetime";
+};
+export type OutputDatetimeItemType = ClosedEnum<typeof OutputDatetimeItemType>;
+export declare const OutputDatetimeItemStatus: {
+    readonly Completed: "completed";
+    readonly InProgress: "in_progress";
+    readonly Incomplete: "incomplete";
+};
+export type OutputDatetimeItemStatus = OpenEnum<typeof OutputDatetimeItemStatus>;
+/**
+ * An openrouter:datetime server tool output item
+ */
+export type OutputDatetimeItem = {
+    type: OutputDatetimeItemType;
+    id?: string | undefined;
+    status: OutputDatetimeItemStatus;
+    /**
+     * ISO 8601 datetime string
+     */
+    datetime: string;
+    /**
+     * IANA timezone name
+     */
+    timezone: string;
+};
+/** @internal */
+export declare const OutputDatetimeItemType$outboundSchema: z.ZodEnum<typeof OutputDatetimeItemType>;
+/** @internal */
+export declare const OutputDatetimeItemStatus$outboundSchema: z.ZodType<string, OutputDatetimeItemStatus>;
+/** @internal */
+export type OutputDatetimeItem$Outbound = {
+    type: string;
+    id?: string | undefined;
+    status: string;
+    datetime: string;
+    timezone: string;
+};
+/** @internal */
+export declare const OutputDatetimeItem$outboundSchema: z.ZodType<OutputDatetimeItem$Outbound, OutputDatetimeItem>;
+export declare function outputDatetimeItemToJSON(outputDatetimeItem: OutputDatetimeItem): string;
+//# sourceMappingURL=outputdatetimeitem.d.ts.map

package/esm/models/outputdatetimeitem.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0c1828e72f98
+ */
+import * as z from "zod/v4";
+import * as openEnums from "../types/enums.js";
+export const OutputDatetimeItemType = {
+    OpenrouterDatetime: "openrouter:datetime",
+};
+export const OutputDatetimeItemStatus = {
+    Completed: "completed",
+    InProgress: "in_progress",
+    Incomplete: "incomplete",
+};
+/** @internal */
+export const OutputDatetimeItemType$outboundSchema = z.enum(OutputDatetimeItemType);
+/** @internal */
+export const OutputDatetimeItemStatus$outboundSchema = openEnums.outboundSchema(OutputDatetimeItemStatus);
+/** @internal */
+export const OutputDatetimeItem$outboundSchema = z.object({
+    type: OutputDatetimeItemType$outboundSchema,
+    id: z.string().optional(),
+    status: OutputDatetimeItemStatus$outboundSchema,
+    datetime: z.string(),
+    timezone: z.string(),
+});
+export function outputDatetimeItemToJSON(outputDatetimeItem) {
+    return JSON.stringify(OutputDatetimeItem$outboundSchema.parse(outputDatetimeItem));
+}
+//# sourceMappingURL=outputdatetimeitem.js.map

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/outputmessage.d.ts

@@ -26,12 +26,28 @@ export declare const OutputMessageStatusCompleted: {
 export type OutputMessageStatusCompleted = ClosedEnum<typeof OutputMessageStatusCompleted>;
 export type OutputMessageStatusUnion = OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress;
 export type OutputMessageContent = ResponseOutputText | OpenAIResponsesRefusalContent;
+export declare const OutputMessagePhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OutputMessagePhaseFinalAnswer = ClosedEnum<typeof OutputMessagePhaseFinalAnswer>;
+export declare const OutputMessagePhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OutputMessagePhaseCommentary = ClosedEnum<typeof OutputMessagePhaseCommentary>;
+/**
+ * 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 OutputMessagePhaseUnion = OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any;
 export type OutputMessage = {
     id: string;
     role: OutputMessageRole;
     type: OutputMessageType;
     status?: OutputMessageStatusCompleted | OutputMessageStatusIncomplete | OutputMessageStatusInProgress | 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?: OutputMessagePhaseCommentary | OutputMessagePhaseFinalAnswer | any | null | undefined;
 };
 /** @internal */
 export declare const OutputMessageRole$inboundSchema: z.ZodEnum<typeof OutputMessageRole>;
@@ -50,6 +66,13 @@ export declare function outputMessageStatusUnionFromJSON(jsonString: string): Sa
 export declare const OutputMessageContent$inboundSchema: z.ZodType<OutputMessageContent, unknown>;
 export declare function outputMessageContentFromJSON(jsonString: string): SafeParseResult<OutputMessageContent, SDKValidationError>;
 /** @internal */
+export declare const OutputMessagePhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseFinalAnswer>;
+/** @internal */
+export declare const OutputMessagePhaseCommentary$inboundSchema: z.ZodEnum<typeof OutputMessagePhaseCommentary>;
+/** @internal */
+export declare const OutputMessagePhaseUnion$inboundSchema: z.ZodType<OutputMessagePhaseUnion, unknown>;
+export declare function outputMessagePhaseUnionFromJSON(jsonString: string): SafeParseResult<OutputMessagePhaseUnion, SDKValidationError>;
+/** @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

@@ -21,6 +21,12 @@ export const OutputMessageStatusIncomplete = {
 export const OutputMessageStatusCompleted = {
     Completed: "completed",
 };
+export const OutputMessagePhaseFinalAnswer = {
+    FinalAnswer: "final_answer",
+};
+export const OutputMessagePhaseCommentary = {
+    Commentary: "commentary",
+};
 /** @internal */
 export const OutputMessageRole$inboundSchema = z.enum(OutputMessageRole);
 /** @internal */
@@ -49,6 +55,19 @@ export function outputMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessageContent' from JSON`);
 }
 /** @internal */
+export const OutputMessagePhaseFinalAnswer$inboundSchema = z.enum(OutputMessagePhaseFinalAnswer);
+/** @internal */
+export const OutputMessagePhaseCommentary$inboundSchema = z.enum(OutputMessagePhaseCommentary);
+/** @internal */
+export const OutputMessagePhaseUnion$inboundSchema = z.union([
+    OutputMessagePhaseCommentary$inboundSchema,
+    OutputMessagePhaseFinalAnswer$inboundSchema,
+    z.any(),
+]);
+export function outputMessagePhaseUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputMessagePhaseUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessagePhaseUnion' from JSON`);
+}
+/** @internal */
 export const OutputMessage$inboundSchema = z
     .object({
     id: z.string(),
@@ -63,6 +82,11 @@ export const OutputMessage$inboundSchema = z
         ResponseOutputText$inboundSchema,
         OpenAIResponsesRefusalContent$inboundSchema,
     ])),
+    phase: z.nullable(z.union([
+        OutputMessagePhaseCommentary$inboundSchema,
+        OutputMessagePhaseFinalAnswer$inboundSchema,
+        z.any(),
+    ])).optional(),
 });
 export function outputMessageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputMessage' from JSON`);