@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/operations/updatekeys.js

@@ -18,15 +18,15 @@ export const UpdateKeysLimitReset = {
 export const UpdateKeysLimitReset$outboundSchema = openEnums.outboundSchema(UpdateKeysLimitReset);
 /** @internal */
 export const UpdateKeysRequestBody$outboundSchema = z.object({
-    name: z.string().optional(),
     disabled: z.boolean().optional(),
-    limit: z.nullable(z.number()).optional(),
-    limitReset: z.nullable(UpdateKeysLimitReset$outboundSchema).optional(),
     includeByokInLimit: z.boolean().optional(),
+    limit: z.number().optional(),
+    limitReset: z.nullable(UpdateKeysLimitReset$outboundSchema).optional(),
+    name: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        limitReset: "limit_reset",
         includeByokInLimit: "include_byok_in_limit",
+        limitReset: "limit_reset",
     });
 });
 export function updateKeysRequestBodyToJSON(updateKeysRequestBody) {
@@ -50,42 +50,42 @@ export function updateKeysRequestToJSON(updateKeysRequest) {
 }
 /** @internal */
 export const UpdateKeysData$inboundSchema = z.object({
+    byok_usage: z.number(),
+    byok_usage_daily: z.number(),
+    byok_usage_monthly: z.number(),
+    byok_usage_weekly: z.number(),
+    created_at: z.string(),
+    creator_user_id: z.nullable(z.string()),
+    disabled: z.boolean(),
+    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
     hash: z.string(),
-    name: z.string(),
+    include_byok_in_limit: z.boolean(),
     label: z.string(),
-    disabled: z.boolean(),
-    limit: z.nullable(z.number()),
-    limit_remaining: z.nullable(z.number()),
+    limit: z.number(),
+    limit_remaining: z.number(),
     limit_reset: z.nullable(z.string()),
-    include_byok_in_limit: z.boolean(),
+    name: z.string(),
+    updated_at: z.nullable(z.string()),
     usage: z.number(),
     usage_daily: z.number(),
-    usage_weekly: z.number(),
     usage_monthly: z.number(),
-    byok_usage: z.number(),
-    byok_usage_daily: z.number(),
-    byok_usage_weekly: z.number(),
-    byok_usage_monthly: z.number(),
-    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()),
+    usage_weekly: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "limit_remaining": "limitRemaining",
-        "limit_reset": "limitReset",
-        "include_byok_in_limit": "includeByokInLimit",
-        "usage_daily": "usageDaily",
-        "usage_weekly": "usageWeekly",
-        "usage_monthly": "usageMonthly",
         "byok_usage": "byokUsage",
         "byok_usage_daily": "byokUsageDaily",
-        "byok_usage_weekly": "byokUsageWeekly",
         "byok_usage_monthly": "byokUsageMonthly",
+        "byok_usage_weekly": "byokUsageWeekly",
         "created_at": "createdAt",
-        "updated_at": "updatedAt",
-        "expires_at": "expiresAt",
         "creator_user_id": "creatorUserId",
+        "expires_at": "expiresAt",
+        "include_byok_in_limit": "includeByokInLimit",
+        "limit_remaining": "limitRemaining",
+        "limit_reset": "limitReset",
+        "updated_at": "updatedAt",
+        "usage_daily": "usageDaily",
+        "usage_monthly": "usageMonthly",
+        "usage_weekly": "usageWeekly",
     });
 });
 export function updateKeysDataFromJSON(jsonString) {

package/esm/models/outputapplypatchservertoolitem.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 { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:apply_patch server tool output item
+ */
+export type OutputApplyPatchServerToolItem = {
+    filePath?: string | undefined;
+    id?: string | undefined;
+    patch?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:apply_patch";
+};
+/** @internal */
+export declare const OutputApplyPatchServerToolItem$inboundSchema: z.ZodType<OutputApplyPatchServerToolItem, unknown>;
+export declare function outputApplyPatchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputApplyPatchServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputapplypatchservertoolitem.d.ts.map

package/esm/models/outputapplypatchservertoolitem.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 761046712899
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputApplyPatchServerToolItem$inboundSchema = z.object({
+    filePath: z.string().optional(),
+    id: z.string().optional(),
+    patch: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:apply_patch"),
+});
+export function outputApplyPatchServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputApplyPatchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputApplyPatchServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputapplypatchservertoolitem.js.map

package/esm/models/outputbashservertoolitem.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:bash server tool output item
+ */
+export type OutputBashServerToolItem = {
+    command?: string | undefined;
+    exitCode?: number | undefined;
+    id?: string | undefined;
+    status: ToolCallStatus;
+    stderr?: string | undefined;
+    stdout?: string | undefined;
+    type: "openrouter:bash";
+};
+/** @internal */
+export declare const OutputBashServerToolItem$inboundSchema: z.ZodType<OutputBashServerToolItem, unknown>;
+export declare function outputBashServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputBashServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputbashservertoolitem.d.ts.map

package/esm/models/outputbashservertoolitem.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8eeee25f4818
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputBashServerToolItem$inboundSchema = z.object({
+    command: z.string().optional(),
+    exitCode: z.int().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    type: z.literal("openrouter:bash"),
+});
+export function outputBashServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputBashServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBashServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputbashservertoolitem.js.map

package/esm/models/outputbrowseruseservertoolitem.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 { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:browser_use server tool output item
+ */
+export type OutputBrowserUseServerToolItem = {
+    action?: string | undefined;
+    id?: string | undefined;
+    screenshotB64?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:browser_use";
+};
+/** @internal */
+export declare const OutputBrowserUseServerToolItem$inboundSchema: z.ZodType<OutputBrowserUseServerToolItem, unknown>;
+export declare function outputBrowserUseServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputBrowserUseServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputbrowseruseservertoolitem.d.ts.map

package/esm/models/outputbrowseruseservertoolitem.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5ad5586d0533
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputBrowserUseServerToolItem$inboundSchema = z.object({
+    action: z.string().optional(),
+    id: z.string().optional(),
+    screenshotB64: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:browser_use"),
+});
+export function outputBrowserUseServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputBrowserUseServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBrowserUseServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputbrowseruseservertoolitem.js.map

package/esm/models/outputcodeinterpretercallitem.d.ts

@@ -0,0 +1,38 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+export type OutputLogs = {
+    logs: string;
+    type: "logs";
+};
+export type OutputImage = {
+    type: "image";
+    url: string;
+};
+export type OutputCodeInterpreterCallItemOutputUnion = OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">;
+/**
+ * A code interpreter execution call with outputs
+ */
+export type OutputCodeInterpreterCallItem = {
+    code: string | null;
+    containerId: string;
+    id: string;
+    outputs: Array<OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">> | null;
+    status: ToolCallStatus;
+    type: "code_interpreter_call";
+};
+/** @internal */
+export declare const OutputLogs$inboundSchema: z.ZodType<OutputLogs, unknown>;
+export declare function outputLogsFromJSON(jsonString: string): SafeParseResult<OutputLogs, SDKValidationError>;
+/** @internal */
+export declare const OutputImage$inboundSchema: z.ZodType<OutputImage, unknown>;
+export declare function outputImageFromJSON(jsonString: string): SafeParseResult<OutputImage, SDKValidationError>;
+/** @internal */
+export declare const OutputCodeInterpreterCallItemOutputUnion$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion, unknown>;
+export declare function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItemOutputUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputCodeInterpreterCallItem$inboundSchema: z.ZodType<OutputCodeInterpreterCallItem, unknown>;
+export declare function outputCodeInterpreterCallItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItem, SDKValidationError>;
+//# sourceMappingURL=outputcodeinterpretercallitem.d.ts.map

package/esm/models/outputcodeinterpretercallitem.js

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ee080e2eccae
+ */
+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";
+/** @internal */
+export const OutputLogs$inboundSchema = z
+    .object({
+    logs: z.string(),
+    type: z.literal("logs"),
+});
+export function outputLogsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputLogs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputLogs' from JSON`);
+}
+/** @internal */
+export const OutputImage$inboundSchema = z
+    .object({
+    type: z.literal("image"),
+    url: z.string(),
+});
+export function outputImageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputImage' from JSON`);
+}
+/** @internal */
+export const OutputCodeInterpreterCallItemOutputUnion$inboundSchema = discriminatedUnion("type", {
+    image: z.lazy(() => OutputImage$inboundSchema),
+    logs: z.lazy(() => OutputLogs$inboundSchema),
+});
+export function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterCallItemOutputUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItemOutputUnion' from JSON`);
+}
+/** @internal */
+export const OutputCodeInterpreterCallItem$inboundSchema = z.object({
+    code: z.nullable(z.string()),
+    container_id: z.string(),
+    id: z.string(),
+    outputs: z.nullable(z.array(discriminatedUnion("type", {
+        image: z.lazy(() => OutputImage$inboundSchema),
+        logs: z.lazy(() => OutputLogs$inboundSchema),
+    }))),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("code_interpreter_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "container_id": "containerId",
+    });
+});
+export function outputCodeInterpreterCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItem' from JSON`);
+}
+//# sourceMappingURL=outputcodeinterpretercallitem.js.map

package/esm/models/outputcodeinterpreterservertoolitem.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:code_interpreter server tool output item
+ */
+export type OutputCodeInterpreterServerToolItem = {
+    code?: string | undefined;
+    exitCode?: number | undefined;
+    id?: string | undefined;
+    language?: string | undefined;
+    status: ToolCallStatus;
+    stderr?: string | undefined;
+    stdout?: string | undefined;
+    type: "openrouter:code_interpreter";
+};
+/** @internal */
+export declare const OutputCodeInterpreterServerToolItem$inboundSchema: z.ZodType<OutputCodeInterpreterServerToolItem, unknown>;
+export declare function outputCodeInterpreterServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputcodeinterpreterservertoolitem.d.ts.map

package/esm/models/outputcodeinterpreterservertoolitem.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 16f87f6046c4
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputCodeInterpreterServerToolItem$inboundSchema = z.object({
+    code: z.string().optional(),
+    exitCode: z.int().optional(),
+    id: z.string().optional(),
+    language: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    type: z.literal("openrouter:code_interpreter"),
+});
+export function outputCodeInterpreterServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputcodeinterpreterservertoolitem.js.map

package/esm/models/outputcomputercallitem.d.ts

@@ -0,0 +1,32 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type PendingSafetyCheck = {
+    code: string;
+    id: string;
+    message: string;
+};
+export declare const OutputComputerCallItemStatus: {
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+    readonly InProgress: "in_progress";
+};
+export type OutputComputerCallItemStatus = OpenEnum<typeof OutputComputerCallItemStatus>;
+export type OutputComputerCallItem = {
+    action?: any | null | undefined;
+    callId: string;
+    id?: string | undefined;
+    pendingSafetyChecks: Array<PendingSafetyCheck>;
+    status: OutputComputerCallItemStatus;
+    type: "computer_call";
+};
+/** @internal */
+export declare const PendingSafetyCheck$inboundSchema: z.ZodType<PendingSafetyCheck, unknown>;
+export declare function pendingSafetyCheckFromJSON(jsonString: string): SafeParseResult<PendingSafetyCheck, SDKValidationError>;
+/** @internal */
+export declare const OutputComputerCallItemStatus$inboundSchema: z.ZodType<OutputComputerCallItemStatus, unknown>;
+/** @internal */
+export declare const OutputComputerCallItem$inboundSchema: z.ZodType<OutputComputerCallItem, unknown>;
+export declare function outputComputerCallItemFromJSON(jsonString: string): SafeParseResult<OutputComputerCallItem, SDKValidationError>;
+//# sourceMappingURL=outputcomputercallitem.d.ts.map

package/esm/models/outputcomputercallitem.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fd4439fdf358
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const OutputComputerCallItemStatus = {
+    Completed: "completed",
+    Incomplete: "incomplete",
+    InProgress: "in_progress",
+};
+/** @internal */
+export const PendingSafetyCheck$inboundSchema = z.object({
+    code: z.string(),
+    id: z.string(),
+    message: z.string(),
+});
+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 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"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+        "pending_safety_checks": "pendingSafetyChecks",
+    });
+});
+export function outputComputerCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputComputerCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputComputerCallItem' from JSON`);
+}
+//# sourceMappingURL=outputcomputercallitem.js.map

package/esm/models/outputdatetimeitem.d.ts

@@ -1,44 +1,44 @@
 import * as z from "zod/v4";
-import { ClosedEnum, OpenEnum } from "../types/enums.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";
 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;
+    id?: string | undefined;
+    status: ToolCallStatus;
     /**
      * IANA timezone name
      */
     timezone: string;
+    type: OutputDatetimeItemType;
 };
 /** @internal */
+export declare const OutputDatetimeItemType$inboundSchema: z.ZodEnum<typeof OutputDatetimeItemType>;
+/** @internal */
 export declare const OutputDatetimeItemType$outboundSchema: z.ZodEnum<typeof OutputDatetimeItemType>;
 /** @internal */
-export declare const OutputDatetimeItemStatus$outboundSchema: z.ZodType<string, OutputDatetimeItemStatus>;
+export declare const OutputDatetimeItem$inboundSchema: z.ZodType<OutputDatetimeItem, unknown>;
 /** @internal */
 export type OutputDatetimeItem$Outbound = {
-    type: string;
+    datetime: string;
     id?: string | undefined;
     status: string;
-    datetime: string;
     timezone: string;
+    type: string;
 };
 /** @internal */
 export declare const OutputDatetimeItem$outboundSchema: z.ZodType<OutputDatetimeItem$Outbound, OutputDatetimeItem>;
 export declare function outputDatetimeItemToJSON(outputDatetimeItem: OutputDatetimeItem): string;
+export declare function outputDatetimeItemFromJSON(jsonString: string): SafeParseResult<OutputDatetimeItem, SDKValidationError>;
 //# sourceMappingURL=outputdatetimeitem.d.ts.map

package/esm/models/outputdatetimeitem.js

@@ -3,28 +3,35 @@
  * @generated-id: 0c1828e72f98
  */
 import * as z from "zod/v4";
-import * as openEnums from "../types/enums.js";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.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);
+export const OutputDatetimeItemType$inboundSchema = z.enum(OutputDatetimeItemType);
 /** @internal */
-export const OutputDatetimeItemStatus$outboundSchema = openEnums.outboundSchema(OutputDatetimeItemStatus);
+export const OutputDatetimeItemType$outboundSchema = OutputDatetimeItemType$inboundSchema;
 /** @internal */
-export const OutputDatetimeItem$outboundSchema = z.object({
-    type: OutputDatetimeItemType$outboundSchema,
+export const OutputDatetimeItem$inboundSchema = z.object({
+    datetime: z.string(),
     id: z.string().optional(),
-    status: OutputDatetimeItemStatus$outboundSchema,
+    status: ToolCallStatus$inboundSchema,
+    timezone: z.string(),
+    type: OutputDatetimeItemType$inboundSchema,
+});
+/** @internal */
+export const OutputDatetimeItem$outboundSchema = z.object({
     datetime: z.string(),
+    id: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
     timezone: z.string(),
+    type: OutputDatetimeItemType$outboundSchema,
 });
 export function outputDatetimeItemToJSON(outputDatetimeItem) {
     return JSON.stringify(OutputDatetimeItem$outboundSchema.parse(outputDatetimeItem));
 }
+export function outputDatetimeItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputDatetimeItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputDatetimeItem' from JSON`);
+}
 //# sourceMappingURL=outputdatetimeitem.js.map

package/esm/models/outputfilesearchcallitem.d.ts

@@ -8,10 +8,10 @@ export declare const OutputFileSearchCallItemType: {
 };
 export type OutputFileSearchCallItemType = ClosedEnum<typeof OutputFileSearchCallItemType>;
 export type OutputFileSearchCallItem = {
-    type: OutputFileSearchCallItemType;
     id: string;
     queries: Array<string>;
     status: WebSearchStatus;
+    type: OutputFileSearchCallItemType;
 };
 /** @internal */
 export declare const OutputFileSearchCallItemType$inboundSchema: z.ZodEnum<typeof OutputFileSearchCallItemType>;
@@ -21,10 +21,10 @@ export declare const OutputFileSearchCallItemType$outboundSchema: z.ZodEnum<type
 export declare const OutputFileSearchCallItem$inboundSchema: z.ZodType<OutputFileSearchCallItem, unknown>;
 /** @internal */
 export type OutputFileSearchCallItem$Outbound = {
-    type: string;
     id: string;
     queries: Array<string>;
     status: string;
+    type: string;
 };
 /** @internal */
 export declare const OutputFileSearchCallItem$outboundSchema: z.ZodType<OutputFileSearchCallItem$Outbound, OutputFileSearchCallItem>;

package/esm/models/outputfilesearchcallitem.js

@@ -14,17 +14,17 @@ export const OutputFileSearchCallItemType$inboundSchema = z.enum(OutputFileSearc
 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,
+    type: OutputFileSearchCallItemType$inboundSchema,
 });
 /** @internal */
 export const OutputFileSearchCallItem$outboundSchema = z.object({
-    type: OutputFileSearchCallItemType$outboundSchema,
     id: z.string(),
     queries: z.array(z.string()),
     status: WebSearchStatus$outboundSchema,
+    type: OutputFileSearchCallItemType$outboundSchema,
 });
 export function outputFileSearchCallItemToJSON(outputFileSearchCallItem) {
     return JSON.stringify(OutputFileSearchCallItem$outboundSchema.parse(outputFileSearchCallItem));

package/esm/models/outputfilesearchservertoolitem.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:file_search server tool output item
+ */
+export type OutputFileSearchServerToolItem = {
+    id?: string | undefined;
+    queries?: Array<string> | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:file_search";
+};
+/** @internal */
+export declare const OutputFileSearchServerToolItem$inboundSchema: z.ZodType<OutputFileSearchServerToolItem, unknown>;
+export declare function outputFileSearchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputFileSearchServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputfilesearchservertoolitem.d.ts.map

package/esm/models/outputfilesearchservertoolitem.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3e5afbd64572
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @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"),
+});
+export function outputFileSearchServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFileSearchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFileSearchServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputfilesearchservertoolitem.js.map