@openrouter/sdk 0.12.20 → 0.12.22

package/esm/models/outputcodeinterpretercallitem.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
@@ -12,6 +13,10 @@ export type OutputImage = {
     url: string;
 };
 export type OutputCodeInterpreterCallItemOutputUnion = OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">;
+export declare const TypeCodeInterpreterCall: {
+    readonly CodeInterpreterCall: "code_interpreter_call";
+};
+export type TypeCodeInterpreterCall = ClosedEnum<typeof TypeCodeInterpreterCall>;
 /**
  * A code interpreter execution call with outputs
  */
@@ -21,18 +26,55 @@ export type OutputCodeInterpreterCallItem = {
     id: string;
     outputs: Array<OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">> | null;
     status: ToolCallStatus;
-    type: "code_interpreter_call";
+    type: TypeCodeInterpreterCall;
 };
 /** @internal */
 export declare const OutputLogs$inboundSchema: z.ZodType<OutputLogs, unknown>;
+/** @internal */
+export type OutputLogs$Outbound = {
+    logs: string;
+    type: "logs";
+};
+/** @internal */
+export declare const OutputLogs$outboundSchema: z.ZodType<OutputLogs$Outbound, OutputLogs>;
+export declare function outputLogsToJSON(outputLogs: OutputLogs): string;
 export declare function outputLogsFromJSON(jsonString: string): SafeParseResult<OutputLogs, SDKValidationError>;
 /** @internal */
 export declare const OutputImage$inboundSchema: z.ZodType<OutputImage, unknown>;
+/** @internal */
+export type OutputImage$Outbound = {
+    type: "image";
+    url: string;
+};
+/** @internal */
+export declare const OutputImage$outboundSchema: z.ZodType<OutputImage$Outbound, OutputImage>;
+export declare function outputImageToJSON(outputImage: OutputImage): string;
 export declare function outputImageFromJSON(jsonString: string): SafeParseResult<OutputImage, SDKValidationError>;
 /** @internal */
 export declare const OutputCodeInterpreterCallItemOutputUnion$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion, unknown>;
+/** @internal */
+export type OutputCodeInterpreterCallItemOutputUnion$Outbound = OutputImage$Outbound | OutputLogs$Outbound;
+/** @internal */
+export declare const OutputCodeInterpreterCallItemOutputUnion$outboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion$Outbound, OutputCodeInterpreterCallItemOutputUnion>;
+export declare function outputCodeInterpreterCallItemOutputUnionToJSON(outputCodeInterpreterCallItemOutputUnion: OutputCodeInterpreterCallItemOutputUnion): string;
 export declare function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItemOutputUnion, SDKValidationError>;
 /** @internal */
+export declare const TypeCodeInterpreterCall$inboundSchema: z.ZodEnum<typeof TypeCodeInterpreterCall>;
+/** @internal */
+export declare const TypeCodeInterpreterCall$outboundSchema: z.ZodEnum<typeof TypeCodeInterpreterCall>;
+/** @internal */
 export declare const OutputCodeInterpreterCallItem$inboundSchema: z.ZodType<OutputCodeInterpreterCallItem, unknown>;
+/** @internal */
+export type OutputCodeInterpreterCallItem$Outbound = {
+    code: string | null;
+    container_id: string;
+    id: string;
+    outputs: Array<OutputImage$Outbound | OutputLogs$Outbound> | null;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputCodeInterpreterCallItem$outboundSchema: z.ZodType<OutputCodeInterpreterCallItem$Outbound, OutputCodeInterpreterCallItem>;
+export declare function outputCodeInterpreterCallItemToJSON(outputCodeInterpreterCallItem: OutputCodeInterpreterCallItem): string;
 export declare function outputCodeInterpreterCallItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItem, SDKValidationError>;
 //# sourceMappingURL=outputcodeinterpretercallitem.d.ts.map

package/esm/models/outputcodeinterpretercallitem.js

@@ -6,13 +6,24 @@ 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 { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const TypeCodeInterpreterCall = {
+    CodeInterpreterCall: "code_interpreter_call",
+};
 /** @internal */
 export const OutputLogs$inboundSchema = z
     .object({
     logs: z.string(),
     type: z.literal("logs"),
 });
+/** @internal */
+export const OutputLogs$outboundSchema = z.object({
+    logs: z.string(),
+    type: z.literal("logs"),
+});
+export function outputLogsToJSON(outputLogs) {
+    return JSON.stringify(OutputLogs$outboundSchema.parse(outputLogs));
+}
 export function outputLogsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputLogs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputLogs' from JSON`);
 }
@@ -22,6 +33,14 @@ export const OutputImage$inboundSchema = z
     type: z.literal("image"),
     url: z.string(),
 });
+/** @internal */
+export const OutputImage$outboundSchema = z.object({
+    type: z.literal("image"),
+    url: z.string(),
+});
+export function outputImageToJSON(outputImage) {
+    return JSON.stringify(OutputImage$outboundSchema.parse(outputImage));
+}
 export function outputImageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputImage' from JSON`);
 }
@@ -30,10 +49,22 @@ export const OutputCodeInterpreterCallItemOutputUnion$inboundSchema = discrimina
     image: z.lazy(() => OutputImage$inboundSchema),
     logs: z.lazy(() => OutputLogs$inboundSchema),
 });
+/** @internal */
+export const OutputCodeInterpreterCallItemOutputUnion$outboundSchema = z.union([
+    z.lazy(() => OutputImage$outboundSchema),
+    z.lazy(() => OutputLogs$outboundSchema),
+]);
+export function outputCodeInterpreterCallItemOutputUnionToJSON(outputCodeInterpreterCallItemOutputUnion) {
+    return JSON.stringify(OutputCodeInterpreterCallItemOutputUnion$outboundSchema.parse(outputCodeInterpreterCallItemOutputUnion));
+}
 export function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputCodeInterpreterCallItemOutputUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItemOutputUnion' from JSON`);
 }
 /** @internal */
+export const TypeCodeInterpreterCall$inboundSchema = z.enum(TypeCodeInterpreterCall);
+/** @internal */
+export const TypeCodeInterpreterCall$outboundSchema = TypeCodeInterpreterCall$inboundSchema;
+/** @internal */
 export const OutputCodeInterpreterCallItem$inboundSchema = z.object({
     code: z.nullable(z.string()),
     container_id: z.string(),
@@ -43,12 +74,31 @@ export const OutputCodeInterpreterCallItem$inboundSchema = z.object({
         logs: z.lazy(() => OutputLogs$inboundSchema),
     }))),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("code_interpreter_call"),
+    type: TypeCodeInterpreterCall$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "container_id": "containerId",
     });
 });
+/** @internal */
+export const OutputCodeInterpreterCallItem$outboundSchema = z.object({
+    code: z.nullable(z.string()),
+    containerId: z.string(),
+    id: z.string(),
+    outputs: z.nullable(z.array(z.union([
+        z.lazy(() => OutputImage$outboundSchema),
+        z.lazy(() => OutputLogs$outboundSchema),
+    ]))),
+    status: ToolCallStatus$outboundSchema,
+    type: TypeCodeInterpreterCall$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        containerId: "container_id",
+    });
+});
+export function outputCodeInterpreterCallItemToJSON(outputCodeInterpreterCallItem) {
+    return JSON.stringify(OutputCodeInterpreterCallItem$outboundSchema.parse(outputCodeInterpreterCallItem));
+}
 export function outputCodeInterpreterCallItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputCodeInterpreterCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItem' from JSON`);
 }

package/esm/models/outputcodeinterpreterservertoolitem.d.ts

@@ -1,7 +1,12 @@
 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 { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputCodeInterpreterServerToolItemType: {
+    readonly OpenrouterCodeInterpreter: "openrouter:code_interpreter";
+};
+export type OutputCodeInterpreterServerToolItemType = ClosedEnum<typeof OutputCodeInterpreterServerToolItemType>;
 /**
  * An openrouter:code_interpreter server tool output item
  */
@@ -13,9 +18,27 @@ export type OutputCodeInterpreterServerToolItem = {
     status: ToolCallStatus;
     stderr?: string | undefined;
     stdout?: string | undefined;
-    type: "openrouter:code_interpreter";
+    type: OutputCodeInterpreterServerToolItemType;
 };
 /** @internal */
+export declare const OutputCodeInterpreterServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputCodeInterpreterServerToolItemType>;
+/** @internal */
+export declare const OutputCodeInterpreterServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputCodeInterpreterServerToolItemType>;
+/** @internal */
 export declare const OutputCodeInterpreterServerToolItem$inboundSchema: z.ZodType<OutputCodeInterpreterServerToolItem, unknown>;
+/** @internal */
+export type OutputCodeInterpreterServerToolItem$Outbound = {
+    code?: string | undefined;
+    exitCode?: number | undefined;
+    id?: string | undefined;
+    language?: string | undefined;
+    status: string;
+    stderr?: string | undefined;
+    stdout?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OutputCodeInterpreterServerToolItem$outboundSchema: z.ZodType<OutputCodeInterpreterServerToolItem$Outbound, OutputCodeInterpreterServerToolItem>;
+export declare function outputCodeInterpreterServerToolItemToJSON(outputCodeInterpreterServerToolItem: OutputCodeInterpreterServerToolItem): string;
 export declare function outputCodeInterpreterServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputcodeinterpreterservertoolitem.d.ts.map

package/esm/models/outputcodeinterpreterservertoolitem.js

@@ -4,7 +4,14 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputCodeInterpreterServerToolItemType = {
+    OpenrouterCodeInterpreter: "openrouter:code_interpreter",
+};
+/** @internal */
+export const OutputCodeInterpreterServerToolItemType$inboundSchema = z.enum(OutputCodeInterpreterServerToolItemType);
+/** @internal */
+export const OutputCodeInterpreterServerToolItemType$outboundSchema = OutputCodeInterpreterServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputCodeInterpreterServerToolItem$inboundSchema = z.object({
     code: z.string().optional(),
@@ -14,8 +21,22 @@ export const OutputCodeInterpreterServerToolItem$inboundSchema = z.object({
     status: ToolCallStatus$inboundSchema,
     stderr: z.string().optional(),
     stdout: z.string().optional(),
-    type: z.literal("openrouter:code_interpreter"),
+    type: OutputCodeInterpreterServerToolItemType$inboundSchema,
 });
+/** @internal */
+export const OutputCodeInterpreterServerToolItem$outboundSchema = z.object({
+    code: z.string().optional(),
+    exitCode: z.int().optional(),
+    id: z.string().optional(),
+    language: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    type: OutputCodeInterpreterServerToolItemType$outboundSchema,
+});
+export function outputCodeInterpreterServerToolItemToJSON(outputCodeInterpreterServerToolItem) {
+    return JSON.stringify(OutputCodeInterpreterServerToolItem$outboundSchema.parse(outputCodeInterpreterServerToolItem));
+}
 export function outputCodeInterpreterServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputCodeInterpreterServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterServerToolItem' from JSON`);
 }

package/esm/models/outputcomputercallitem.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type PendingSafetyCheck = {
@@ -13,20 +13,51 @@ export declare const OutputComputerCallItemStatus: {
     readonly InProgress: "in_progress";
 };
 export type OutputComputerCallItemStatus = OpenEnum<typeof OutputComputerCallItemStatus>;
+export declare const OutputComputerCallItemType: {
+    readonly ComputerCall: "computer_call";
+};
+export type OutputComputerCallItemType = ClosedEnum<typeof OutputComputerCallItemType>;
 export type OutputComputerCallItem = {
     action?: any | null | undefined;
     callId: string;
     id?: string | undefined;
     pendingSafetyChecks: Array<PendingSafetyCheck>;
     status: OutputComputerCallItemStatus;
-    type: "computer_call";
+    type: OutputComputerCallItemType;
 };
 /** @internal */
 export declare const PendingSafetyCheck$inboundSchema: z.ZodType<PendingSafetyCheck, unknown>;
+/** @internal */
+export type PendingSafetyCheck$Outbound = {
+    code: string;
+    id: string;
+    message: string;
+};
+/** @internal */
+export declare const PendingSafetyCheck$outboundSchema: z.ZodType<PendingSafetyCheck$Outbound, PendingSafetyCheck>;
+export declare function pendingSafetyCheckToJSON(pendingSafetyCheck: PendingSafetyCheck): string;
 export declare function pendingSafetyCheckFromJSON(jsonString: string): SafeParseResult<PendingSafetyCheck, SDKValidationError>;
 /** @internal */
 export declare const OutputComputerCallItemStatus$inboundSchema: z.ZodType<OutputComputerCallItemStatus, unknown>;
 /** @internal */
+export declare const OutputComputerCallItemStatus$outboundSchema: z.ZodType<string, OutputComputerCallItemStatus>;
+/** @internal */
+export declare const OutputComputerCallItemType$inboundSchema: z.ZodEnum<typeof OutputComputerCallItemType>;
+/** @internal */
+export declare const OutputComputerCallItemType$outboundSchema: z.ZodEnum<typeof OutputComputerCallItemType>;
+/** @internal */
 export declare const OutputComputerCallItem$inboundSchema: z.ZodType<OutputComputerCallItem, unknown>;
+/** @internal */
+export type OutputComputerCallItem$Outbound = {
+    action?: any | null | undefined;
+    call_id: string;
+    id?: string | undefined;
+    pending_safety_checks: Array<PendingSafetyCheck$Outbound>;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputComputerCallItem$outboundSchema: z.ZodType<OutputComputerCallItem$Outbound, OutputComputerCallItem>;
+export declare function outputComputerCallItemToJSON(outputComputerCallItem: OutputComputerCallItem): string;
 export declare function outputComputerCallItemFromJSON(jsonString: string): SafeParseResult<OutputComputerCallItem, SDKValidationError>;
 //# sourceMappingURL=outputcomputercallitem.d.ts.map

package/esm/models/outputcomputercallitem.js

@@ -11,31 +11,66 @@ export const OutputComputerCallItemStatus = {
     Incomplete: "incomplete",
     InProgress: "in_progress",
 };
+export const OutputComputerCallItemType = {
+    ComputerCall: "computer_call",
+};
 /** @internal */
 export const PendingSafetyCheck$inboundSchema = z.object({
     code: z.string(),
     id: z.string(),
     message: z.string(),
 });
+/** @internal */
+export const PendingSafetyCheck$outboundSchema = z.object({
+    code: z.string(),
+    id: z.string(),
+    message: z.string(),
+});
+export function pendingSafetyCheckToJSON(pendingSafetyCheck) {
+    return JSON.stringify(PendingSafetyCheck$outboundSchema.parse(pendingSafetyCheck));
+}
 export function pendingSafetyCheckFromJSON(jsonString) {
     return safeParse(jsonString, (x) => PendingSafetyCheck$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PendingSafetyCheck' from JSON`);
 }
 /** @internal */
 export const OutputComputerCallItemStatus$inboundSchema = openEnums.inboundSchema(OutputComputerCallItemStatus);
 /** @internal */
+export const OutputComputerCallItemStatus$outboundSchema = openEnums.outboundSchema(OutputComputerCallItemStatus);
+/** @internal */
+export const OutputComputerCallItemType$inboundSchema = z.enum(OutputComputerCallItemType);
+/** @internal */
+export const OutputComputerCallItemType$outboundSchema = OutputComputerCallItemType$inboundSchema;
+/** @internal */
 export const OutputComputerCallItem$inboundSchema = z.object({
     action: z.nullable(z.any()).optional(),
     call_id: z.string(),
     id: z.string().optional(),
     pending_safety_checks: z.array(z.lazy(() => PendingSafetyCheck$inboundSchema)),
     status: OutputComputerCallItemStatus$inboundSchema,
-    type: z.literal("computer_call"),
+    type: OutputComputerCallItemType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
         "pending_safety_checks": "pendingSafetyChecks",
     });
 });
+/** @internal */
+export const OutputComputerCallItem$outboundSchema = z.object({
+    action: z.nullable(z.any()).optional(),
+    callId: z.string(),
+    id: z.string().optional(),
+    pendingSafetyChecks: z.array(z.lazy(() => PendingSafetyCheck$outboundSchema)),
+    status: OutputComputerCallItemStatus$outboundSchema,
+    type: OutputComputerCallItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+        pendingSafetyChecks: "pending_safety_checks",
+    });
+});
+export function outputComputerCallItemToJSON(outputComputerCallItem) {
+    return JSON.stringify(OutputComputerCallItem$outboundSchema.parse(outputComputerCallItem));
+}
 export function outputComputerCallItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputComputerCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputComputerCallItem' from JSON`);
 }

package/esm/models/outputfilesearchservertoolitem.d.ts

@@ -1,7 +1,12 @@
 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 { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputFileSearchServerToolItemType: {
+    readonly OpenrouterFileSearch: "openrouter:file_search";
+};
+export type OutputFileSearchServerToolItemType = ClosedEnum<typeof OutputFileSearchServerToolItemType>;
 /**
  * An openrouter:file_search server tool output item
  */
@@ -9,9 +14,23 @@ export type OutputFileSearchServerToolItem = {
     id?: string | undefined;
     queries?: Array<string> | undefined;
     status: ToolCallStatus;
-    type: "openrouter:file_search";
+    type: OutputFileSearchServerToolItemType;
 };
 /** @internal */
+export declare const OutputFileSearchServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputFileSearchServerToolItemType>;
+/** @internal */
+export declare const OutputFileSearchServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputFileSearchServerToolItemType>;
+/** @internal */
 export declare const OutputFileSearchServerToolItem$inboundSchema: z.ZodType<OutputFileSearchServerToolItem, unknown>;
+/** @internal */
+export type OutputFileSearchServerToolItem$Outbound = {
+    id?: string | undefined;
+    queries?: Array<string> | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputFileSearchServerToolItem$outboundSchema: z.ZodType<OutputFileSearchServerToolItem$Outbound, OutputFileSearchServerToolItem>;
+export declare function outputFileSearchServerToolItemToJSON(outputFileSearchServerToolItem: OutputFileSearchServerToolItem): string;
 export declare function outputFileSearchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputFileSearchServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputfilesearchservertoolitem.d.ts.map

package/esm/models/outputfilesearchservertoolitem.js

@@ -4,14 +4,31 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputFileSearchServerToolItemType = {
+    OpenrouterFileSearch: "openrouter:file_search",
+};
+/** @internal */
+export const OutputFileSearchServerToolItemType$inboundSchema = z.enum(OutputFileSearchServerToolItemType);
+/** @internal */
+export const OutputFileSearchServerToolItemType$outboundSchema = OutputFileSearchServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputFileSearchServerToolItem$inboundSchema = z.object({
     id: z.string().optional(),
     queries: z.array(z.string()).optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:file_search"),
+    type: OutputFileSearchServerToolItemType$inboundSchema,
 });
+/** @internal */
+export const OutputFileSearchServerToolItem$outboundSchema = z.object({
+    id: z.string().optional(),
+    queries: z.array(z.string()).optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputFileSearchServerToolItemType$outboundSchema,
+});
+export function outputFileSearchServerToolItemToJSON(outputFileSearchServerToolItem) {
+    return JSON.stringify(OutputFileSearchServerToolItem$outboundSchema.parse(outputFileSearchServerToolItem));
+}
 export function outputFileSearchServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputFileSearchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFileSearchServerToolItem' from JSON`);
 }

package/esm/models/outputimagegenerationservertoolitem.d.ts

@@ -1,7 +1,12 @@
 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 { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputImageGenerationServerToolItemType: {
+    readonly OpenrouterImageGeneration: "openrouter:image_generation";
+};
+export type OutputImageGenerationServerToolItemType = ClosedEnum<typeof OutputImageGenerationServerToolItemType>;
 /**
  * An openrouter:image_generation server tool output item
  */
@@ -15,9 +20,26 @@ export type OutputImageGenerationServerToolItem = {
     result?: string | null | undefined;
     revisedPrompt?: string | undefined;
     status: ToolCallStatus;
-    type: "openrouter:image_generation";
+    type: OutputImageGenerationServerToolItemType;
 };
 /** @internal */
+export declare const OutputImageGenerationServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputImageGenerationServerToolItemType>;
+/** @internal */
+export declare const OutputImageGenerationServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputImageGenerationServerToolItemType>;
+/** @internal */
 export declare const OutputImageGenerationServerToolItem$inboundSchema: z.ZodType<OutputImageGenerationServerToolItem, unknown>;
+/** @internal */
+export type OutputImageGenerationServerToolItem$Outbound = {
+    id?: string | undefined;
+    imageB64?: string | undefined;
+    imageUrl?: string | undefined;
+    result?: string | null | undefined;
+    revisedPrompt?: string | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputImageGenerationServerToolItem$outboundSchema: z.ZodType<OutputImageGenerationServerToolItem$Outbound, OutputImageGenerationServerToolItem>;
+export declare function outputImageGenerationServerToolItemToJSON(outputImageGenerationServerToolItem: OutputImageGenerationServerToolItem): string;
 export declare function outputImageGenerationServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputImageGenerationServerToolItem, SDKValidationError>;
 //# sourceMappingURL=outputimagegenerationservertoolitem.d.ts.map

package/esm/models/outputimagegenerationservertoolitem.js

@@ -4,7 +4,14 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputImageGenerationServerToolItemType = {
+    OpenrouterImageGeneration: "openrouter:image_generation",
+};
+/** @internal */
+export const OutputImageGenerationServerToolItemType$inboundSchema = z.enum(OutputImageGenerationServerToolItemType);
+/** @internal */
+export const OutputImageGenerationServerToolItemType$outboundSchema = OutputImageGenerationServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputImageGenerationServerToolItem$inboundSchema = z.object({
     id: z.string().optional(),
@@ -13,8 +20,21 @@ export const OutputImageGenerationServerToolItem$inboundSchema = z.object({
     result: z.nullable(z.string()).optional(),
     revisedPrompt: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
-    type: z.literal("openrouter:image_generation"),
+    type: OutputImageGenerationServerToolItemType$inboundSchema,
+});
+/** @internal */
+export const OutputImageGenerationServerToolItem$outboundSchema = z.object({
+    id: z.string().optional(),
+    imageB64: z.string().optional(),
+    imageUrl: z.string().optional(),
+    result: z.nullable(z.string()).optional(),
+    revisedPrompt: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputImageGenerationServerToolItemType$outboundSchema,
 });
+export function outputImageGenerationServerToolItemToJSON(outputImageGenerationServerToolItem) {
+    return JSON.stringify(OutputImageGenerationServerToolItem$outboundSchema.parse(outputImageGenerationServerToolItem));
+}
 export function outputImageGenerationServerToolItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputImageGenerationServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputImageGenerationServerToolItem' from JSON`);
 }

package/esm/models/outputitems.d.ts

@@ -27,15 +27,43 @@ import { OutputWebSearchServerToolItem } from "./outputwebsearchservertoolitem.j
 /**
  * An output item from the response
  */
-export type OutputItems = OutputCodeInterpreterCallItem | OutputComputerCallItem | (OutputFileSearchCallItem & {
+export type OutputItems = (OutputCodeInterpreterCallItem & {
+    type: "code_interpreter_call";
+}) | (OutputComputerCallItem & {
+    type: "computer_call";
+}) | (OutputFileSearchCallItem & {
     type: "file_search_call";
 }) | (OutputFunctionCallItem & {
     type: "function_call";
 }) | (OutputImageGenerationCallItem & {
     type: "image_generation_call";
-}) | OutputMessageItem | OutputApplyPatchServerToolItem | OutputBashServerToolItem | OutputBrowserUseServerToolItem | OutputCodeInterpreterServerToolItem | (OutputDatetimeItem & {
+}) | OutputMessageItem | (OutputApplyPatchServerToolItem & {
+    type: "openrouter:apply_patch";
+}) | (OutputBashServerToolItem & {
+    type: "openrouter:bash";
+}) | (OutputBrowserUseServerToolItem & {
+    type: "openrouter:browser_use";
+}) | (OutputCodeInterpreterServerToolItem & {
+    type: "openrouter:code_interpreter";
+}) | (OutputDatetimeItem & {
     type: "openrouter:datetime";
-}) | OutputSearchModelsServerToolItem | OutputFileSearchServerToolItem | OutputImageGenerationServerToolItem | OutputMcpServerToolItem | OutputMemoryServerToolItem | OutputTextEditorServerToolItem | OutputToolSearchServerToolItem | OutputWebFetchServerToolItem | (OutputWebSearchServerToolItem & {
+}) | (OutputSearchModelsServerToolItem & {
+    type: "openrouter:experimental__search_models";
+}) | (OutputFileSearchServerToolItem & {
+    type: "openrouter:file_search";
+}) | (OutputImageGenerationServerToolItem & {
+    type: "openrouter:image_generation";
+}) | (OutputMcpServerToolItem & {
+    type: "openrouter:mcp";
+}) | (OutputMemoryServerToolItem & {
+    type: "openrouter:memory";
+}) | (OutputTextEditorServerToolItem & {
+    type: "openrouter:text_editor";
+}) | (OutputToolSearchServerToolItem & {
+    type: "openrouter:tool_search";
+}) | (OutputWebFetchServerToolItem & {
+    type: "openrouter:web_fetch";
+}) | (OutputWebSearchServerToolItem & {
     type: "openrouter:web_search";
 }) | OutputReasoningItem | (OutputWebSearchCallItem & {
     type: "web_search_call";

package/esm/models/outputitems.js

@@ -29,25 +29,30 @@ import { OutputWebSearchCallItem$inboundSchema, } from "./outputwebsearchcallite
 import { OutputWebSearchServerToolItem$inboundSchema, } from "./outputwebsearchservertoolitem.js";
 /** @internal */
 export const OutputItems$inboundSchema = discriminatedUnion("type", {
-    code_interpreter_call: OutputCodeInterpreterCallItem$inboundSchema,
-    computer_call: OutputComputerCallItem$inboundSchema,
+    code_interpreter_call: OutputCodeInterpreterCallItem$inboundSchema.and(z.object({ type: z.literal("code_interpreter_call") })),
+    computer_call: OutputComputerCallItem$inboundSchema.and(z.object({ type: z.literal("computer_call") })),
     file_search_call: OutputFileSearchCallItem$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
     function_call: OutputFunctionCallItem$inboundSchema.and(z.object({ type: z.literal("function_call") })),
     image_generation_call: OutputImageGenerationCallItem$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
     message: OutputMessageItem$inboundSchema,
-    ["openrouter:apply_patch"]: OutputApplyPatchServerToolItem$inboundSchema,
-    ["openrouter:bash"]: OutputBashServerToolItem$inboundSchema,
-    ["openrouter:browser_use"]: OutputBrowserUseServerToolItem$inboundSchema,
-    ["openrouter:code_interpreter"]: OutputCodeInterpreterServerToolItem$inboundSchema,
+    ["openrouter:apply_patch"]: OutputApplyPatchServerToolItem$inboundSchema
+        .and(z.object({ type: z.literal("openrouter:apply_patch") })),
+    ["openrouter:bash"]: OutputBashServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:bash") })),
+    ["openrouter:browser_use"]: OutputBrowserUseServerToolItem$inboundSchema
+        .and(z.object({ type: z.literal("openrouter:browser_use") })),
+    ["openrouter:code_interpreter"]: OutputCodeInterpreterServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:code_interpreter") })),
     ["openrouter:datetime"]: OutputDatetimeItem$inboundSchema.and(z.object({ type: z.literal("openrouter:datetime") })),
-    ["openrouter:experimental__search_models"]: OutputSearchModelsServerToolItem$inboundSchema,
-    ["openrouter:file_search"]: OutputFileSearchServerToolItem$inboundSchema,
-    ["openrouter:image_generation"]: OutputImageGenerationServerToolItem$inboundSchema,
-    ["openrouter:mcp"]: OutputMcpServerToolItem$inboundSchema,
-    ["openrouter:memory"]: OutputMemoryServerToolItem$inboundSchema,
-    ["openrouter:text_editor"]: OutputTextEditorServerToolItem$inboundSchema,
-    ["openrouter:tool_search"]: OutputToolSearchServerToolItem$inboundSchema,
-    ["openrouter:web_fetch"]: OutputWebFetchServerToolItem$inboundSchema,
+    ["openrouter:experimental__search_models"]: OutputSearchModelsServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:experimental__search_models") })),
+    ["openrouter:file_search"]: OutputFileSearchServerToolItem$inboundSchema
+        .and(z.object({ type: z.literal("openrouter:file_search") })),
+    ["openrouter:image_generation"]: OutputImageGenerationServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:image_generation") })),
+    ["openrouter:mcp"]: OutputMcpServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:mcp") })),
+    ["openrouter:memory"]: OutputMemoryServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:memory") })),
+    ["openrouter:text_editor"]: OutputTextEditorServerToolItem$inboundSchema
+        .and(z.object({ type: z.literal("openrouter:text_editor") })),
+    ["openrouter:tool_search"]: OutputToolSearchServerToolItem$inboundSchema
+        .and(z.object({ type: z.literal("openrouter:tool_search") })),
+    ["openrouter:web_fetch"]: OutputWebFetchServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:web_fetch") })),
     ["openrouter:web_search"]: OutputWebSearchServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:web_search") })),
     reasoning: OutputReasoningItem$inboundSchema,
     web_search_call: OutputWebSearchCallItem$inboundSchema.and(z.object({ type: z.literal("web_search_call") })),