@openrouter/sdk 0.13.38 → 0.13.39

package/esm/lib/config.d.ts

@@ -49,8 +49,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.13.38";
+    readonly sdkVersion: "0.13.39";
     readonly genVersion: "2.884.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.13.38 2.884.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.13.39 2.884.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.13.38",
+    sdkVersion: "0.13.39",
     genVersion: "2.884.4",
-    userAgent: "speakeasy-sdk/typescript 0.13.38 2.884.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.13.39 2.884.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/additionaltoolsitem.d.ts

@@ -0,0 +1,117 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { AdvisorServerToolOpenRouter, AdvisorServerToolOpenRouter$Outbound } from "./advisorservertoolopenrouter.js";
+import { ApplyPatchServerTool, ApplyPatchServerTool$Outbound } from "./applypatchservertool.js";
+import { ApplyPatchServerToolOpenRouter, ApplyPatchServerToolOpenRouter$Outbound } from "./applypatchservertoolopenrouter.js";
+import { BashServerTool, BashServerTool$Outbound } from "./bashservertool.js";
+import { ChatSearchModelsServerTool, ChatSearchModelsServerTool$Outbound } from "./chatsearchmodelsservertool.js";
+import { CodeInterpreterServerTool, CodeInterpreterServerTool$Outbound } from "./codeinterpreterservertool.js";
+import { CodexLocalShellTool, CodexLocalShellTool$Outbound } from "./codexlocalshelltool.js";
+import { ComputerUseServerTool, ComputerUseServerTool$Outbound } from "./computeruseservertool.js";
+import { CustomTool, CustomTool$Outbound } from "./customtool.js";
+import { DatetimeServerTool, DatetimeServerTool$Outbound } from "./datetimeservertool.js";
+import { FileSearchServerTool, FileSearchServerTool$Outbound } from "./filesearchservertool.js";
+import { FilesServerTool, FilesServerTool$Outbound } from "./filesservertool.js";
+import { FusionServerToolOpenRouter, FusionServerToolOpenRouter$Outbound } from "./fusionservertoolopenrouter.js";
+import { ImageGenerationServerTool, ImageGenerationServerTool$Outbound } from "./imagegenerationservertool.js";
+import { ImageGenerationServerToolOpenRouter, ImageGenerationServerToolOpenRouter$Outbound } from "./imagegenerationservertoolopenrouter.js";
+import { LegacyWebSearchServerTool, LegacyWebSearchServerTool$Outbound } from "./legacywebsearchservertool.js";
+import { McpServerTool, McpServerTool$Outbound } from "./mcpservertool.js";
+import { Preview20250311WebSearchServerTool, Preview20250311WebSearchServerTool$Outbound } from "./preview20250311websearchservertool.js";
+import { PreviewWebSearchServerTool, PreviewWebSearchServerTool$Outbound } from "./previewwebsearchservertool.js";
+import { ShellServerTool, ShellServerTool$Outbound } from "./shellservertool.js";
+import { ShellServerToolOpenRouter, ShellServerToolOpenRouter$Outbound } from "./shellservertoolopenrouter.js";
+import { SubagentServerToolOpenRouter, SubagentServerToolOpenRouter$Outbound } from "./subagentservertoolopenrouter.js";
+import { WebFetchServerTool, WebFetchServerTool$Outbound } from "./webfetchservertool.js";
+import { WebSearchServerTool, WebSearchServerTool$Outbound } from "./websearchservertool.js";
+import { WebSearchServerToolOpenRouter, WebSearchServerToolOpenRouter$Outbound } from "./websearchservertoolopenrouter.js";
+export declare const AdditionalToolsItemRole: {
+    readonly Unknown: "unknown";
+    readonly User: "user";
+    readonly Assistant: "assistant";
+    readonly System: "system";
+    readonly Critic: "critic";
+    readonly Discriminator: "discriminator";
+    readonly Developer: "developer";
+    readonly Tool: "tool";
+};
+export type AdditionalToolsItemRole = OpenEnum<typeof AdditionalToolsItemRole>;
+export type AdditionalToolsItemTool = {
+    type: string;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+export declare const AdditionalToolsItemTypeFunction: {
+    readonly Function: "function";
+};
+export type AdditionalToolsItemTypeFunction = ClosedEnum<typeof AdditionalToolsItemTypeFunction>;
+/**
+ * Function tool definition
+ */
+export type AdditionalToolsItemToolFunction = {
+    description?: string | null | undefined;
+    name: string;
+    parameters: {
+        [k: string]: any | null;
+    } | null;
+    strict?: boolean | null | undefined;
+    type: AdditionalToolsItemTypeFunction;
+};
+export type AdditionalToolsItemToolUnion = ComputerUseServerTool | AdditionalToolsItemToolFunction | FileSearchServerTool | CodeInterpreterServerTool | McpServerTool | CustomTool | PreviewWebSearchServerTool | Preview20250311WebSearchServerTool | LegacyWebSearchServerTool | WebSearchServerTool | ImageGenerationServerTool | CodexLocalShellTool | ShellServerTool | ApplyPatchServerTool | AdvisorServerToolOpenRouter | SubagentServerToolOpenRouter | DatetimeServerTool | FilesServerTool | FusionServerToolOpenRouter | ImageGenerationServerToolOpenRouter | ChatSearchModelsServerTool | WebFetchServerTool | WebSearchServerToolOpenRouter | ApplyPatchServerToolOpenRouter | BashServerTool | ShellServerToolOpenRouter | AdditionalToolsItemTool;
+export declare const TypeAdditionalTools: {
+    readonly AdditionalTools: "additional_tools";
+};
+export type TypeAdditionalTools = ClosedEnum<typeof TypeAdditionalTools>;
+/**
+ * Additional tools made available to the model at this point in the input
+ */
+export type AdditionalToolsItem = {
+    id?: string | null | undefined;
+    role: AdditionalToolsItemRole;
+    tools: Array<ComputerUseServerTool | AdditionalToolsItemToolFunction | FileSearchServerTool | CodeInterpreterServerTool | McpServerTool | CustomTool | PreviewWebSearchServerTool | Preview20250311WebSearchServerTool | LegacyWebSearchServerTool | WebSearchServerTool | ImageGenerationServerTool | CodexLocalShellTool | ShellServerTool | ApplyPatchServerTool | AdvisorServerToolOpenRouter | SubagentServerToolOpenRouter | DatetimeServerTool | FilesServerTool | FusionServerToolOpenRouter | ImageGenerationServerToolOpenRouter | ChatSearchModelsServerTool | WebFetchServerTool | WebSearchServerToolOpenRouter | ApplyPatchServerToolOpenRouter | BashServerTool | ShellServerToolOpenRouter | AdditionalToolsItemTool>;
+    type: TypeAdditionalTools;
+};
+/** @internal */
+export declare const AdditionalToolsItemRole$outboundSchema: z.ZodType<string, AdditionalToolsItemRole>;
+/** @internal */
+export type AdditionalToolsItemTool$Outbound = {
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const AdditionalToolsItemTool$outboundSchema: z.ZodType<AdditionalToolsItemTool$Outbound, AdditionalToolsItemTool>;
+export declare function additionalToolsItemToolToJSON(additionalToolsItemTool: AdditionalToolsItemTool): string;
+/** @internal */
+export declare const AdditionalToolsItemTypeFunction$outboundSchema: z.ZodEnum<typeof AdditionalToolsItemTypeFunction>;
+/** @internal */
+export type AdditionalToolsItemToolFunction$Outbound = {
+    description?: string | null | undefined;
+    name: string;
+    parameters: {
+        [k: string]: any | null;
+    } | null;
+    strict?: boolean | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const AdditionalToolsItemToolFunction$outboundSchema: z.ZodType<AdditionalToolsItemToolFunction$Outbound, AdditionalToolsItemToolFunction>;
+export declare function additionalToolsItemToolFunctionToJSON(additionalToolsItemToolFunction: AdditionalToolsItemToolFunction): string;
+/** @internal */
+export type AdditionalToolsItemToolUnion$Outbound = ComputerUseServerTool$Outbound | AdditionalToolsItemToolFunction$Outbound | FileSearchServerTool$Outbound | CodeInterpreterServerTool$Outbound | McpServerTool$Outbound | CustomTool$Outbound | PreviewWebSearchServerTool$Outbound | Preview20250311WebSearchServerTool$Outbound | LegacyWebSearchServerTool$Outbound | WebSearchServerTool$Outbound | ImageGenerationServerTool$Outbound | CodexLocalShellTool$Outbound | ShellServerTool$Outbound | ApplyPatchServerTool$Outbound | AdvisorServerToolOpenRouter$Outbound | SubagentServerToolOpenRouter$Outbound | DatetimeServerTool$Outbound | FilesServerTool$Outbound | FusionServerToolOpenRouter$Outbound | ImageGenerationServerToolOpenRouter$Outbound | ChatSearchModelsServerTool$Outbound | WebFetchServerTool$Outbound | WebSearchServerToolOpenRouter$Outbound | ApplyPatchServerToolOpenRouter$Outbound | BashServerTool$Outbound | ShellServerToolOpenRouter$Outbound | AdditionalToolsItemTool$Outbound;
+/** @internal */
+export declare const AdditionalToolsItemToolUnion$outboundSchema: z.ZodType<AdditionalToolsItemToolUnion$Outbound, AdditionalToolsItemToolUnion>;
+export declare function additionalToolsItemToolUnionToJSON(additionalToolsItemToolUnion: AdditionalToolsItemToolUnion): string;
+/** @internal */
+export declare const TypeAdditionalTools$outboundSchema: z.ZodEnum<typeof TypeAdditionalTools>;
+/** @internal */
+export type AdditionalToolsItem$Outbound = {
+    id?: string | null | undefined;
+    role: string;
+    tools: Array<ComputerUseServerTool$Outbound | AdditionalToolsItemToolFunction$Outbound | FileSearchServerTool$Outbound | CodeInterpreterServerTool$Outbound | McpServerTool$Outbound | CustomTool$Outbound | PreviewWebSearchServerTool$Outbound | Preview20250311WebSearchServerTool$Outbound | LegacyWebSearchServerTool$Outbound | WebSearchServerTool$Outbound | ImageGenerationServerTool$Outbound | CodexLocalShellTool$Outbound | ShellServerTool$Outbound | ApplyPatchServerTool$Outbound | AdvisorServerToolOpenRouter$Outbound | SubagentServerToolOpenRouter$Outbound | DatetimeServerTool$Outbound | FilesServerTool$Outbound | FusionServerToolOpenRouter$Outbound | ImageGenerationServerToolOpenRouter$Outbound | ChatSearchModelsServerTool$Outbound | WebFetchServerTool$Outbound | WebSearchServerToolOpenRouter$Outbound | ApplyPatchServerToolOpenRouter$Outbound | BashServerTool$Outbound | ShellServerToolOpenRouter$Outbound | AdditionalToolsItemTool$Outbound>;
+    type: string;
+};
+/** @internal */
+export declare const AdditionalToolsItem$outboundSchema: z.ZodType<AdditionalToolsItem$Outbound, AdditionalToolsItem>;
+export declare function additionalToolsItemToJSON(additionalToolsItem: AdditionalToolsItem): string;
+//# sourceMappingURL=additionaltoolsitem.d.ts.map

package/esm/models/additionaltoolsitem.js

@@ -0,0 +1,152 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d33059f81c21
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { AdvisorServerToolOpenRouter$outboundSchema, } from "./advisorservertoolopenrouter.js";
+import { ApplyPatchServerTool$outboundSchema, } from "./applypatchservertool.js";
+import { ApplyPatchServerToolOpenRouter$outboundSchema, } from "./applypatchservertoolopenrouter.js";
+import { BashServerTool$outboundSchema, } from "./bashservertool.js";
+import { ChatSearchModelsServerTool$outboundSchema, } from "./chatsearchmodelsservertool.js";
+import { CodeInterpreterServerTool$outboundSchema, } from "./codeinterpreterservertool.js";
+import { CodexLocalShellTool$outboundSchema, } from "./codexlocalshelltool.js";
+import { ComputerUseServerTool$outboundSchema, } from "./computeruseservertool.js";
+import { CustomTool$outboundSchema, } from "./customtool.js";
+import { DatetimeServerTool$outboundSchema, } from "./datetimeservertool.js";
+import { FileSearchServerTool$outboundSchema, } from "./filesearchservertool.js";
+import { FilesServerTool$outboundSchema, } from "./filesservertool.js";
+import { FusionServerToolOpenRouter$outboundSchema, } from "./fusionservertoolopenrouter.js";
+import { ImageGenerationServerTool$outboundSchema, } from "./imagegenerationservertool.js";
+import { ImageGenerationServerToolOpenRouter$outboundSchema, } from "./imagegenerationservertoolopenrouter.js";
+import { LegacyWebSearchServerTool$outboundSchema, } from "./legacywebsearchservertool.js";
+import { McpServerTool$outboundSchema, } from "./mcpservertool.js";
+import { Preview20250311WebSearchServerTool$outboundSchema, } from "./preview20250311websearchservertool.js";
+import { PreviewWebSearchServerTool$outboundSchema, } from "./previewwebsearchservertool.js";
+import { ShellServerTool$outboundSchema, } from "./shellservertool.js";
+import { ShellServerToolOpenRouter$outboundSchema, } from "./shellservertoolopenrouter.js";
+import { SubagentServerToolOpenRouter$outboundSchema, } from "./subagentservertoolopenrouter.js";
+import { WebFetchServerTool$outboundSchema, } from "./webfetchservertool.js";
+import { WebSearchServerTool$outboundSchema, } from "./websearchservertool.js";
+import { WebSearchServerToolOpenRouter$outboundSchema, } from "./websearchservertoolopenrouter.js";
+export const AdditionalToolsItemRole = {
+    Unknown: "unknown",
+    User: "user",
+    Assistant: "assistant",
+    System: "system",
+    Critic: "critic",
+    Discriminator: "discriminator",
+    Developer: "developer",
+    Tool: "tool",
+};
+export const AdditionalToolsItemTypeFunction = {
+    Function: "function",
+};
+export const TypeAdditionalTools = {
+    AdditionalTools: "additional_tools",
+};
+/** @internal */
+export const AdditionalToolsItemRole$outboundSchema = openEnums.outboundSchema(AdditionalToolsItemRole);
+/** @internal */
+export const AdditionalToolsItemTool$outboundSchema = z.object({
+    type: z.string(),
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function additionalToolsItemToolToJSON(additionalToolsItemTool) {
+    return JSON.stringify(AdditionalToolsItemTool$outboundSchema.parse(additionalToolsItemTool));
+}
+/** @internal */
+export const AdditionalToolsItemTypeFunction$outboundSchema = z.enum(AdditionalToolsItemTypeFunction);
+/** @internal */
+export const AdditionalToolsItemToolFunction$outboundSchema = z.object({
+    description: z.nullable(z.string()).optional(),
+    name: z.string(),
+    parameters: z.nullable(z.record(z.string(), z.nullable(z.any()))),
+    strict: z.nullable(z.boolean()).optional(),
+    type: AdditionalToolsItemTypeFunction$outboundSchema,
+});
+export function additionalToolsItemToolFunctionToJSON(additionalToolsItemToolFunction) {
+    return JSON.stringify(AdditionalToolsItemToolFunction$outboundSchema.parse(additionalToolsItemToolFunction));
+}
+/** @internal */
+export const AdditionalToolsItemToolUnion$outboundSchema = z.union([
+    ComputerUseServerTool$outboundSchema,
+    z.lazy(() => AdditionalToolsItemToolFunction$outboundSchema),
+    FileSearchServerTool$outboundSchema,
+    CodeInterpreterServerTool$outboundSchema,
+    McpServerTool$outboundSchema,
+    CustomTool$outboundSchema,
+    PreviewWebSearchServerTool$outboundSchema,
+    Preview20250311WebSearchServerTool$outboundSchema,
+    LegacyWebSearchServerTool$outboundSchema,
+    WebSearchServerTool$outboundSchema,
+    ImageGenerationServerTool$outboundSchema,
+    CodexLocalShellTool$outboundSchema,
+    ShellServerTool$outboundSchema,
+    ApplyPatchServerTool$outboundSchema,
+    AdvisorServerToolOpenRouter$outboundSchema,
+    SubagentServerToolOpenRouter$outboundSchema,
+    DatetimeServerTool$outboundSchema,
+    FilesServerTool$outboundSchema,
+    FusionServerToolOpenRouter$outboundSchema,
+    ImageGenerationServerToolOpenRouter$outboundSchema,
+    ChatSearchModelsServerTool$outboundSchema,
+    WebFetchServerTool$outboundSchema,
+    WebSearchServerToolOpenRouter$outboundSchema,
+    ApplyPatchServerToolOpenRouter$outboundSchema,
+    BashServerTool$outboundSchema,
+    ShellServerToolOpenRouter$outboundSchema,
+    z.lazy(() => AdditionalToolsItemTool$outboundSchema),
+]);
+export function additionalToolsItemToolUnionToJSON(additionalToolsItemToolUnion) {
+    return JSON.stringify(AdditionalToolsItemToolUnion$outboundSchema.parse(additionalToolsItemToolUnion));
+}
+/** @internal */
+export const TypeAdditionalTools$outboundSchema = z.enum(TypeAdditionalTools);
+/** @internal */
+export const AdditionalToolsItem$outboundSchema = z.object({
+    id: z.nullable(z.string()).optional(),
+    role: AdditionalToolsItemRole$outboundSchema,
+    tools: z.array(z.union([
+        ComputerUseServerTool$outboundSchema,
+        z.lazy(() => AdditionalToolsItemToolFunction$outboundSchema),
+        FileSearchServerTool$outboundSchema,
+        CodeInterpreterServerTool$outboundSchema,
+        McpServerTool$outboundSchema,
+        CustomTool$outboundSchema,
+        PreviewWebSearchServerTool$outboundSchema,
+        Preview20250311WebSearchServerTool$outboundSchema,
+        LegacyWebSearchServerTool$outboundSchema,
+        WebSearchServerTool$outboundSchema,
+        ImageGenerationServerTool$outboundSchema,
+        CodexLocalShellTool$outboundSchema,
+        ShellServerTool$outboundSchema,
+        ApplyPatchServerTool$outboundSchema,
+        AdvisorServerToolOpenRouter$outboundSchema,
+        SubagentServerToolOpenRouter$outboundSchema,
+        DatetimeServerTool$outboundSchema,
+        FilesServerTool$outboundSchema,
+        FusionServerToolOpenRouter$outboundSchema,
+        ImageGenerationServerToolOpenRouter$outboundSchema,
+        ChatSearchModelsServerTool$outboundSchema,
+        WebFetchServerTool$outboundSchema,
+        WebSearchServerToolOpenRouter$outboundSchema,
+        ApplyPatchServerToolOpenRouter$outboundSchema,
+        BashServerTool$outboundSchema,
+        ShellServerToolOpenRouter$outboundSchema,
+        z.lazy(() => AdditionalToolsItemTool$outboundSchema),
+    ])),
+    type: TypeAdditionalTools$outboundSchema,
+});
+export function additionalToolsItemToJSON(additionalToolsItem) {
+    return JSON.stringify(AdditionalToolsItem$outboundSchema.parse(additionalToolsItem));
+}
+//# sourceMappingURL=additionaltoolsitem.js.map

package/esm/models/applypatchservertool.d.ts

@@ -1,17 +1,26 @@
 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 ApplyPatchServerToolType: {
+    readonly ApplyPatch: "apply_patch";
+};
+export type ApplyPatchServerToolType = ClosedEnum<typeof ApplyPatchServerToolType>;
 /**
  * Apply patch tool configuration
  */
 export type ApplyPatchServerTool = {
-    type: "apply_patch";
+    type: ApplyPatchServerToolType;
 };
 /** @internal */
+export declare const ApplyPatchServerToolType$inboundSchema: z.ZodEnum<typeof ApplyPatchServerToolType>;
+/** @internal */
+export declare const ApplyPatchServerToolType$outboundSchema: z.ZodEnum<typeof ApplyPatchServerToolType>;
+/** @internal */
 export declare const ApplyPatchServerTool$inboundSchema: z.ZodType<ApplyPatchServerTool, unknown>;
 /** @internal */
 export type ApplyPatchServerTool$Outbound = {
-    type: "apply_patch";
+    type: string;
 };
 /** @internal */
 export declare const ApplyPatchServerTool$outboundSchema: z.ZodType<ApplyPatchServerTool$Outbound, ApplyPatchServerTool>;

package/esm/models/applypatchservertool.js

@@ -4,13 +4,20 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+export const ApplyPatchServerToolType = {
+    ApplyPatch: "apply_patch",
+};
+/** @internal */
+export const ApplyPatchServerToolType$inboundSchema = z.enum(ApplyPatchServerToolType);
+/** @internal */
+export const ApplyPatchServerToolType$outboundSchema = ApplyPatchServerToolType$inboundSchema;
 /** @internal */
 export const ApplyPatchServerTool$inboundSchema = z.object({
-    type: z.literal("apply_patch"),
+    type: ApplyPatchServerToolType$inboundSchema,
 });
 /** @internal */
 export const ApplyPatchServerTool$outboundSchema = z.object({
-    type: z.literal("apply_patch"),
+    type: ApplyPatchServerToolType$outboundSchema,
 });
 export function applyPatchServerToolToJSON(applyPatchServerTool) {
     return JSON.stringify(ApplyPatchServerTool$outboundSchema.parse(applyPatchServerTool));

package/esm/models/applypatchservertoolopenrouter.d.ts

@@ -1,5 +1,10 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { ApplyPatchServerToolConfig, ApplyPatchServerToolConfig$Outbound } from "./applypatchservertoolconfig.js";
+export declare const ApplyPatchServerToolOpenRouterType: {
+    readonly OpenrouterApplyPatch: "openrouter:apply_patch";
+};
+export type ApplyPatchServerToolOpenRouterType = ClosedEnum<typeof ApplyPatchServerToolOpenRouterType>;
 /**
  * OpenRouter built-in server tool: validates V4A diff patches for file operations (create, update, delete). Restricted to the Responses API.
  */
@@ -8,12 +13,14 @@ export type ApplyPatchServerToolOpenRouter = {
      * Configuration for the openrouter:apply_patch server tool
      */
     parameters?: ApplyPatchServerToolConfig | undefined;
-    type: "openrouter:apply_patch";
+    type: ApplyPatchServerToolOpenRouterType;
 };
 /** @internal */
+export declare const ApplyPatchServerToolOpenRouterType$outboundSchema: z.ZodEnum<typeof ApplyPatchServerToolOpenRouterType>;
+/** @internal */
 export type ApplyPatchServerToolOpenRouter$Outbound = {
     parameters?: ApplyPatchServerToolConfig$Outbound | undefined;
-    type: "openrouter:apply_patch";
+    type: string;
 };
 /** @internal */
 export declare const ApplyPatchServerToolOpenRouter$outboundSchema: z.ZodType<ApplyPatchServerToolOpenRouter$Outbound, ApplyPatchServerToolOpenRouter>;

package/esm/models/applypatchservertoolopenrouter.js

@@ -4,10 +4,15 @@
  */
 import * as z from "zod/v4";
 import { ApplyPatchServerToolConfig$outboundSchema, } from "./applypatchservertoolconfig.js";
+export const ApplyPatchServerToolOpenRouterType = {
+    OpenrouterApplyPatch: "openrouter:apply_patch",
+};
+/** @internal */
+export const ApplyPatchServerToolOpenRouterType$outboundSchema = z.enum(ApplyPatchServerToolOpenRouterType);
 /** @internal */
 export const ApplyPatchServerToolOpenRouter$outboundSchema = z.object({
     parameters: ApplyPatchServerToolConfig$outboundSchema.optional(),
-    type: z.literal("openrouter:apply_patch"),
+    type: ApplyPatchServerToolOpenRouterType$outboundSchema,
 });
 export function applyPatchServerToolOpenRouterToJSON(applyPatchServerToolOpenRouter) {
     return JSON.stringify(ApplyPatchServerToolOpenRouter$outboundSchema.parse(applyPatchServerToolOpenRouter));

package/esm/models/codeinterpreterservertool.d.ts

@@ -19,12 +19,16 @@ export type ContainerAuto = {
     type: ContainerType;
 };
 export type Container = ContainerAuto | string;
+export declare const TypeCodeInterpreter: {
+    readonly CodeInterpreter: "code_interpreter";
+};
+export type TypeCodeInterpreter = ClosedEnum<typeof TypeCodeInterpreter>;
 /**
  * Code interpreter tool configuration
  */
 export type CodeInterpreterServerTool = {
     container: ContainerAuto | string;
-    type: "code_interpreter";
+    type: TypeCodeInterpreter;
 };
 /** @internal */
 export declare const MemoryLimit$inboundSchema: z.ZodType<MemoryLimit, unknown>;
@@ -55,11 +59,15 @@ export declare const Container$outboundSchema: z.ZodType<Container$Outbound, Con
 export declare function containerToJSON(container: Container): string;
 export declare function containerFromJSON(jsonString: string): SafeParseResult<Container, SDKValidationError>;
 /** @internal */
+export declare const TypeCodeInterpreter$inboundSchema: z.ZodEnum<typeof TypeCodeInterpreter>;
+/** @internal */
+export declare const TypeCodeInterpreter$outboundSchema: z.ZodEnum<typeof TypeCodeInterpreter>;
+/** @internal */
 export declare const CodeInterpreterServerTool$inboundSchema: z.ZodType<CodeInterpreterServerTool, unknown>;
 /** @internal */
 export type CodeInterpreterServerTool$Outbound = {
     container: ContainerAuto$Outbound | string;
-    type: "code_interpreter";
+    type: string;
 };
 /** @internal */
 export declare const CodeInterpreterServerTool$outboundSchema: z.ZodType<CodeInterpreterServerTool$Outbound, CodeInterpreterServerTool>;

package/esm/models/codeinterpreterservertool.js

@@ -15,6 +15,9 @@ export const MemoryLimit = {
 export const ContainerType = {
     Auto: "auto",
 };
+export const TypeCodeInterpreter = {
+    CodeInterpreter: "code_interpreter",
+};
 /** @internal */
 export const MemoryLimit$inboundSchema = openEnums.inboundSchema(MemoryLimit);
 /** @internal */
@@ -67,14 +70,18 @@ export function containerFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Container$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Container' from JSON`);
 }
 /** @internal */
+export const TypeCodeInterpreter$inboundSchema = z.enum(TypeCodeInterpreter);
+/** @internal */
+export const TypeCodeInterpreter$outboundSchema = TypeCodeInterpreter$inboundSchema;
+/** @internal */
 export const CodeInterpreterServerTool$inboundSchema = z.object({
     container: z.union([z.lazy(() => ContainerAuto$inboundSchema), z.string()]),
-    type: z.literal("code_interpreter"),
+    type: TypeCodeInterpreter$inboundSchema,
 });
 /** @internal */
 export const CodeInterpreterServerTool$outboundSchema = z.object({
     container: z.union([z.lazy(() => ContainerAuto$outboundSchema), z.string()]),
-    type: z.literal("code_interpreter"),
+    type: TypeCodeInterpreter$outboundSchema,
 });
 export function codeInterpreterServerToolToJSON(codeInterpreterServerTool) {
     return JSON.stringify(CodeInterpreterServerTool$outboundSchema.parse(codeInterpreterServerTool));

package/esm/models/codexlocalshelltool.d.ts

@@ -1,17 +1,26 @@
 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 CodexLocalShellToolType: {
+    readonly LocalShell: "local_shell";
+};
+export type CodexLocalShellToolType = ClosedEnum<typeof CodexLocalShellToolType>;
 /**
  * Local shell tool configuration
  */
 export type CodexLocalShellTool = {
-    type: "local_shell";
+    type: CodexLocalShellToolType;
 };
 /** @internal */
+export declare const CodexLocalShellToolType$inboundSchema: z.ZodEnum<typeof CodexLocalShellToolType>;
+/** @internal */
+export declare const CodexLocalShellToolType$outboundSchema: z.ZodEnum<typeof CodexLocalShellToolType>;
+/** @internal */
 export declare const CodexLocalShellTool$inboundSchema: z.ZodType<CodexLocalShellTool, unknown>;
 /** @internal */
 export type CodexLocalShellTool$Outbound = {
-    type: "local_shell";
+    type: string;
 };
 /** @internal */
 export declare const CodexLocalShellTool$outboundSchema: z.ZodType<CodexLocalShellTool$Outbound, CodexLocalShellTool>;

package/esm/models/codexlocalshelltool.js

@@ -4,13 +4,20 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+export const CodexLocalShellToolType = {
+    LocalShell: "local_shell",
+};
+/** @internal */
+export const CodexLocalShellToolType$inboundSchema = z.enum(CodexLocalShellToolType);
+/** @internal */
+export const CodexLocalShellToolType$outboundSchema = CodexLocalShellToolType$inboundSchema;
 /** @internal */
 export const CodexLocalShellTool$inboundSchema = z.object({
-    type: z.literal("local_shell"),
+    type: CodexLocalShellToolType$inboundSchema,
 });
 /** @internal */
 export const CodexLocalShellTool$outboundSchema = z.object({
-    type: z.literal("local_shell"),
+    type: CodexLocalShellToolType$outboundSchema,
 });
 export function codexLocalShellToolToJSON(codexLocalShellTool) {
     return JSON.stringify(CodexLocalShellTool$outboundSchema.parse(codexLocalShellTool));

package/esm/models/computeruseservertool.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 declare const Environment: {
@@ -10,6 +10,10 @@ export declare const Environment: {
     readonly Browser: "browser";
 };
 export type Environment = OpenEnum<typeof Environment>;
+export declare const ComputerUseServerToolType: {
+    readonly ComputerUsePreview: "computer_use_preview";
+};
+export type ComputerUseServerToolType = ClosedEnum<typeof ComputerUseServerToolType>;
 /**
  * Computer use preview tool configuration
  */
@@ -17,20 +21,24 @@ export type ComputerUseServerTool = {
     displayHeight: number;
     displayWidth: number;
     environment: Environment;
-    type: "computer_use_preview";
+    type: ComputerUseServerToolType;
 };
 /** @internal */
 export declare const Environment$inboundSchema: z.ZodType<Environment, unknown>;
 /** @internal */
 export declare const Environment$outboundSchema: z.ZodType<string, Environment>;
 /** @internal */
+export declare const ComputerUseServerToolType$inboundSchema: z.ZodEnum<typeof ComputerUseServerToolType>;
+/** @internal */
+export declare const ComputerUseServerToolType$outboundSchema: z.ZodEnum<typeof ComputerUseServerToolType>;
+/** @internal */
 export declare const ComputerUseServerTool$inboundSchema: z.ZodType<ComputerUseServerTool, unknown>;
 /** @internal */
 export type ComputerUseServerTool$Outbound = {
     display_height: number;
     display_width: number;
     environment: string;
-    type: "computer_use_preview";
+    type: string;
 };
 /** @internal */
 export declare const ComputerUseServerTool$outboundSchema: z.ZodType<ComputerUseServerTool$Outbound, ComputerUseServerTool>;

package/esm/models/computeruseservertool.js

@@ -13,16 +13,23 @@ export const Environment = {
     Ubuntu: "ubuntu",
     Browser: "browser",
 };
+export const ComputerUseServerToolType = {
+    ComputerUsePreview: "computer_use_preview",
+};
 /** @internal */
 export const Environment$inboundSchema = openEnums.inboundSchema(Environment);
 /** @internal */
 export const Environment$outboundSchema = openEnums.outboundSchema(Environment);
 /** @internal */
+export const ComputerUseServerToolType$inboundSchema = z.enum(ComputerUseServerToolType);
+/** @internal */
+export const ComputerUseServerToolType$outboundSchema = ComputerUseServerToolType$inboundSchema;
+/** @internal */
 export const ComputerUseServerTool$inboundSchema = z.object({
     display_height: z.int(),
     display_width: z.int(),
     environment: Environment$inboundSchema,
-    type: z.literal("computer_use_preview"),
+    type: ComputerUseServerToolType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "display_height": "displayHeight",
@@ -34,7 +41,7 @@ export const ComputerUseServerTool$outboundSchema = z.object({
     displayHeight: z.int(),
     displayWidth: z.int(),
     environment: Environment$outboundSchema,
-    type: z.literal("computer_use_preview"),
+    type: ComputerUseServerToolType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         displayHeight: "display_height",

package/esm/models/customtool.d.ts

@@ -1,6 +1,6 @@
 import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
-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 declare const Syntax: {
@@ -17,6 +17,10 @@ export type FormatText = {
     type: "text";
 };
 export type Format = FormatText | FormatGrammar | discriminatedUnionTypes.Unknown<"type">;
+export declare const CustomToolTypeCustom: {
+    readonly Custom: "custom";
+};
+export type CustomToolTypeCustom = ClosedEnum<typeof CustomToolTypeCustom>;
 /**
  * Custom tool configuration
  */
@@ -24,7 +28,7 @@ export type CustomTool = {
     description?: string | undefined;
     format?: FormatText | FormatGrammar | discriminatedUnionTypes.Unknown<"type"> | undefined;
     name: string;
-    type: "custom";
+    type: CustomToolTypeCustom;
 };
 /** @internal */
 export declare const Syntax$inboundSchema: z.ZodType<Syntax, unknown>;
@@ -61,13 +65,17 @@ export declare const Format$outboundSchema: z.ZodType<Format$Outbound, Format>;
 export declare function formatToJSON(format: Format): string;
 export declare function formatFromJSON(jsonString: string): SafeParseResult<Format, SDKValidationError>;
 /** @internal */
+export declare const CustomToolTypeCustom$inboundSchema: z.ZodEnum<typeof CustomToolTypeCustom>;
+/** @internal */
+export declare const CustomToolTypeCustom$outboundSchema: z.ZodEnum<typeof CustomToolTypeCustom>;
+/** @internal */
 export declare const CustomTool$inboundSchema: z.ZodType<CustomTool, unknown>;
 /** @internal */
 export type CustomTool$Outbound = {
     description?: string | undefined;
     format?: FormatText$Outbound | FormatGrammar$Outbound | undefined;
     name: string;
-    type: "custom";
+    type: string;
 };
 /** @internal */
 export declare const CustomTool$outboundSchema: z.ZodType<CustomTool$Outbound, CustomTool>;