@openrouter/sdk 0.13.38 → 0.13.40

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.40";
     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.40 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.40",
     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.40 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/agentmessageitem.d.ts

@@ -0,0 +1,99 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { InputText, InputText$Outbound } from "./inputtext.js";
+export type Agent = {
+    agentName: string;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+export type ContentEncryptedContent = {
+    encryptedContent: string;
+    type: "encrypted_content";
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+export declare const AgentMessageItemDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+    readonly Original: "original";
+};
+export type AgentMessageItemDetail = OpenEnum<typeof AgentMessageItemDetail>;
+/**
+ * Image input content item
+ */
+export type AgentMessageItemContentInputImage = {
+    detail: AgentMessageItemDetail;
+    imageUrl?: string | null | undefined;
+    type: "input_image";
+};
+export type AgentMessageItemContentUnion = InputText | AgentMessageItemContentInputImage | ContentEncryptedContent;
+export declare const TypeAgentMessage: {
+    readonly AgentMessage: "agent_message";
+};
+export type TypeAgentMessage = ClosedEnum<typeof TypeAgentMessage>;
+/**
+ * A message routed between agents in a multi-agent session
+ */
+export type AgentMessageItem = {
+    agent?: Agent | null | undefined;
+    author: string;
+    content: Array<InputText | AgentMessageItemContentInputImage | ContentEncryptedContent>;
+    id?: string | null | undefined;
+    recipient: string;
+    type: TypeAgentMessage;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/** @internal */
+export type Agent$Outbound = {
+    agent_name: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const Agent$outboundSchema: z.ZodType<Agent$Outbound, Agent>;
+export declare function agentToJSON(agent: Agent): string;
+/** @internal */
+export type ContentEncryptedContent$Outbound = {
+    encrypted_content: string;
+    type: "encrypted_content";
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const ContentEncryptedContent$outboundSchema: z.ZodType<ContentEncryptedContent$Outbound, ContentEncryptedContent>;
+export declare function contentEncryptedContentToJSON(contentEncryptedContent: ContentEncryptedContent): string;
+/** @internal */
+export declare const AgentMessageItemDetail$outboundSchema: z.ZodType<string, AgentMessageItemDetail>;
+/** @internal */
+export type AgentMessageItemContentInputImage$Outbound = {
+    detail: string;
+    image_url?: string | null | undefined;
+    type: "input_image";
+};
+/** @internal */
+export declare const AgentMessageItemContentInputImage$outboundSchema: z.ZodType<AgentMessageItemContentInputImage$Outbound, AgentMessageItemContentInputImage>;
+export declare function agentMessageItemContentInputImageToJSON(agentMessageItemContentInputImage: AgentMessageItemContentInputImage): string;
+/** @internal */
+export type AgentMessageItemContentUnion$Outbound = InputText$Outbound | AgentMessageItemContentInputImage$Outbound | ContentEncryptedContent$Outbound;
+/** @internal */
+export declare const AgentMessageItemContentUnion$outboundSchema: z.ZodType<AgentMessageItemContentUnion$Outbound, AgentMessageItemContentUnion>;
+export declare function agentMessageItemContentUnionToJSON(agentMessageItemContentUnion: AgentMessageItemContentUnion): string;
+/** @internal */
+export declare const TypeAgentMessage$outboundSchema: z.ZodEnum<typeof TypeAgentMessage>;
+/** @internal */
+export type AgentMessageItem$Outbound = {
+    agent?: Agent$Outbound | null | undefined;
+    author: string;
+    content: Array<InputText$Outbound | AgentMessageItemContentInputImage$Outbound | ContentEncryptedContent$Outbound>;
+    id?: string | null | undefined;
+    recipient: string;
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const AgentMessageItem$outboundSchema: z.ZodType<AgentMessageItem$Outbound, AgentMessageItem>;
+export declare function agentMessageItemToJSON(agentMessageItem: AgentMessageItem): string;
+//# sourceMappingURL=agentmessageitem.d.ts.map

package/esm/models/agentmessageitem.js

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fc9151085f62
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { InputText$outboundSchema, } from "./inputtext.js";
+export const AgentMessageItemDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+    Original: "original",
+};
+export const TypeAgentMessage = {
+    AgentMessage: "agent_message",
+};
+/** @internal */
+export const Agent$outboundSchema = z.object({
+    agentName: z.string(),
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            agentName: "agent_name",
+            additionalProperties: null,
+        }),
+    };
+});
+export function agentToJSON(agent) {
+    return JSON.stringify(Agent$outboundSchema.parse(agent));
+}
+/** @internal */
+export const ContentEncryptedContent$outboundSchema = z.object({
+    encryptedContent: z.string(),
+    type: z.literal("encrypted_content"),
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            encryptedContent: "encrypted_content",
+            additionalProperties: null,
+        }),
+    };
+});
+export function contentEncryptedContentToJSON(contentEncryptedContent) {
+    return JSON.stringify(ContentEncryptedContent$outboundSchema.parse(contentEncryptedContent));
+}
+/** @internal */
+export const AgentMessageItemDetail$outboundSchema = openEnums.outboundSchema(AgentMessageItemDetail);
+/** @internal */
+export const AgentMessageItemContentInputImage$outboundSchema = z.object({
+    detail: AgentMessageItemDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+    type: z.literal("input_image"),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function agentMessageItemContentInputImageToJSON(agentMessageItemContentInputImage) {
+    return JSON.stringify(AgentMessageItemContentInputImage$outboundSchema.parse(agentMessageItemContentInputImage));
+}
+/** @internal */
+export const AgentMessageItemContentUnion$outboundSchema = z.union([
+    InputText$outboundSchema,
+    z.lazy(() => AgentMessageItemContentInputImage$outboundSchema),
+    z.lazy(() => ContentEncryptedContent$outboundSchema),
+]);
+export function agentMessageItemContentUnionToJSON(agentMessageItemContentUnion) {
+    return JSON.stringify(AgentMessageItemContentUnion$outboundSchema.parse(agentMessageItemContentUnion));
+}
+/** @internal */
+export const TypeAgentMessage$outboundSchema = z.enum(TypeAgentMessage);
+/** @internal */
+export const AgentMessageItem$outboundSchema = z.object({
+    agent: z.nullable(z.lazy(() => Agent$outboundSchema)).optional(),
+    author: z.string(),
+    content: z.array(z.union([
+        InputText$outboundSchema,
+        z.lazy(() => AgentMessageItemContentInputImage$outboundSchema),
+        z.lazy(() => ContentEncryptedContent$outboundSchema),
+    ])),
+    id: z.nullable(z.string()).optional(),
+    recipient: z.string(),
+    type: TypeAgentMessage$outboundSchema,
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function agentMessageItemToJSON(agentMessageItem) {
+    return JSON.stringify(AgentMessageItem$outboundSchema.parse(agentMessageItem));
+}
+//# sourceMappingURL=agentmessageitem.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));