@openrouter/sdk 1.3.29 → 1.3.31

package/esm/models/anthropiccodeexecutioncontent.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f4f46d300ed2
+ */
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicCodeExecutionResult$inboundSchema, } from "./anthropiccodeexecutionresult.js";
+import { AnthropicCodeExecutionToolResultError$inboundSchema, } from "./anthropiccodeexecutiontoolresulterror.js";
+import { AnthropicEncryptedCodeExecutionResult$inboundSchema, } from "./anthropicencryptedcodeexecutionresult.js";
+/** @internal */
+export const AnthropicCodeExecutionContent$inboundSchema = discriminatedUnion("type", {
+    code_execution_result: AnthropicCodeExecutionResult$inboundSchema,
+    code_execution_tool_result_error: AnthropicCodeExecutionToolResultError$inboundSchema,
+    encrypted_code_execution_result: AnthropicEncryptedCodeExecutionResult$inboundSchema,
+});
+export function anthropicCodeExecutionContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicCodeExecutionContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicCodeExecutionContent' from JSON`);
+}
+//# sourceMappingURL=anthropiccodeexecutioncontent.js.map

package/esm/models/anthropiccodeexecutionoutput.d.ts

@@ -0,0 +1,18 @@
+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 AnthropicCodeExecutionOutputType: {
+    readonly CodeExecutionOutput: "code_execution_output";
+};
+export type AnthropicCodeExecutionOutputType = ClosedEnum<typeof AnthropicCodeExecutionOutputType>;
+export type AnthropicCodeExecutionOutput = {
+    fileId: string;
+    type: AnthropicCodeExecutionOutputType;
+};
+/** @internal */
+export declare const AnthropicCodeExecutionOutputType$inboundSchema: z.ZodEnum<typeof AnthropicCodeExecutionOutputType>;
+/** @internal */
+export declare const AnthropicCodeExecutionOutput$inboundSchema: z.ZodType<AnthropicCodeExecutionOutput, unknown>;
+export declare function anthropicCodeExecutionOutputFromJSON(jsonString: string): SafeParseResult<AnthropicCodeExecutionOutput, SDKValidationError>;
+//# sourceMappingURL=anthropiccodeexecutionoutput.d.ts.map

package/esm/models/anthropiccodeexecutionoutput.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b7d015976558
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const AnthropicCodeExecutionOutputType = {
+    CodeExecutionOutput: "code_execution_output",
+};
+/** @internal */
+export const AnthropicCodeExecutionOutputType$inboundSchema = z.enum(AnthropicCodeExecutionOutputType);
+/** @internal */
+export const AnthropicCodeExecutionOutput$inboundSchema = z.object({
+    file_id: z.string(),
+    type: AnthropicCodeExecutionOutputType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "file_id": "fileId",
+    });
+});
+export function anthropicCodeExecutionOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicCodeExecutionOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicCodeExecutionOutput' from JSON`);
+}
+//# sourceMappingURL=anthropiccodeexecutionoutput.js.map

package/esm/models/anthropiccodeexecutionresult.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCodeExecutionOutput } from "./anthropiccodeexecutionoutput.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicCodeExecutionResult = {
+    content: Array<AnthropicCodeExecutionOutput>;
+    returnCode: number;
+    stderr: string;
+    stdout: string;
+    type: "code_execution_result";
+};
+/** @internal */
+export declare const AnthropicCodeExecutionResult$inboundSchema: z.ZodType<AnthropicCodeExecutionResult, unknown>;
+export declare function anthropicCodeExecutionResultFromJSON(jsonString: string): SafeParseResult<AnthropicCodeExecutionResult, SDKValidationError>;
+//# sourceMappingURL=anthropiccodeexecutionresult.d.ts.map

package/esm/models/anthropiccodeexecutionresult.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a35c5b19103f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicCodeExecutionOutput$inboundSchema, } from "./anthropiccodeexecutionoutput.js";
+/** @internal */
+export const AnthropicCodeExecutionResult$inboundSchema = z.object({
+    content: z.array(AnthropicCodeExecutionOutput$inboundSchema),
+    return_code: z.int(),
+    stderr: z.string(),
+    stdout: z.string(),
+    type: z.literal("code_execution_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "return_code": "returnCode",
+    });
+});
+export function anthropicCodeExecutionResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicCodeExecutionResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicCodeExecutionResult' from JSON`);
+}
+//# sourceMappingURL=anthropiccodeexecutionresult.js.map

package/esm/models/anthropiccodeexecutiontoolresult.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCodeExecutionContent } from "./anthropiccodeexecutioncontent.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicCodeExecutionToolResult = {
+    content: AnthropicCodeExecutionContent;
+    toolUseId: string;
+    type: "code_execution_tool_result";
+};
+/** @internal */
+export declare const AnthropicCodeExecutionToolResult$inboundSchema: z.ZodType<AnthropicCodeExecutionToolResult, unknown>;
+export declare function anthropicCodeExecutionToolResultFromJSON(jsonString: string): SafeParseResult<AnthropicCodeExecutionToolResult, SDKValidationError>;
+//# sourceMappingURL=anthropiccodeexecutiontoolresult.d.ts.map

package/esm/models/anthropiccodeexecutiontoolresult.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b65091190ef2
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicCodeExecutionContent$inboundSchema, } from "./anthropiccodeexecutioncontent.js";
+/** @internal */
+export const AnthropicCodeExecutionToolResult$inboundSchema = z.object({
+    content: AnthropicCodeExecutionContent$inboundSchema,
+    tool_use_id: z.string(),
+    type: z.literal("code_execution_tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_use_id": "toolUseId",
+    });
+});
+export function anthropicCodeExecutionToolResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicCodeExecutionToolResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicCodeExecutionToolResult' from JSON`);
+}
+//# sourceMappingURL=anthropiccodeexecutiontoolresult.js.map

package/esm/models/anthropiccodeexecutiontoolresulterror.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicServerToolErrorCode } from "./anthropicservertoolerrorcode.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicCodeExecutionToolResultError = {
+    errorCode: AnthropicServerToolErrorCode;
+    type: "code_execution_tool_result_error";
+};
+/** @internal */
+export declare const AnthropicCodeExecutionToolResultError$inboundSchema: z.ZodType<AnthropicCodeExecutionToolResultError, unknown>;
+export declare function anthropicCodeExecutionToolResultErrorFromJSON(jsonString: string): SafeParseResult<AnthropicCodeExecutionToolResultError, SDKValidationError>;
+//# sourceMappingURL=anthropiccodeexecutiontoolresulterror.d.ts.map

package/esm/models/anthropiccodeexecutiontoolresulterror.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bf9694582afc
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicServerToolErrorCode$inboundSchema, } from "./anthropicservertoolerrorcode.js";
+/** @internal */
+export const AnthropicCodeExecutionToolResultError$inboundSchema = z.object({
+    error_code: AnthropicServerToolErrorCode$inboundSchema,
+    type: z.literal("code_execution_tool_result_error"),
+}).transform((v) => {
+    return remap$(v, {
+        "error_code": "errorCode",
+    });
+});
+export function anthropicCodeExecutionToolResultErrorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicCodeExecutionToolResultError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicCodeExecutionToolResultError' from JSON`);
+}
+//# sourceMappingURL=anthropiccodeexecutiontoolresulterror.js.map

package/esm/models/anthropiccompactionblock.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicCompactionBlock = {
+    content: string | null;
+    encryptedContent?: string | null | undefined;
+    type: "compaction";
+};
+/** @internal */
+export declare const AnthropicCompactionBlock$inboundSchema: z.ZodType<AnthropicCompactionBlock, unknown>;
+export declare function anthropicCompactionBlockFromJSON(jsonString: string): SafeParseResult<AnthropicCompactionBlock, SDKValidationError>;
+//# sourceMappingURL=anthropiccompactionblock.d.ts.map

package/esm/models/anthropiccompactionblock.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2e8c7492d352
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicCompactionBlock$inboundSchema = z.object({
+    content: z.nullable(z.string()),
+    encrypted_content: z.nullable(z.string()).optional(),
+    type: z.literal("compaction"),
+}).transform((v) => {
+    return remap$(v, {
+        "encrypted_content": "encryptedContent",
+    });
+});
+export function anthropicCompactionBlockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicCompactionBlock$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicCompactionBlock' from JSON`);
+}
+//# sourceMappingURL=anthropiccompactionblock.js.map

package/esm/models/anthropiccontainer.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicContainerSkill } from "./anthropiccontainerskill.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicContainer = {
+    expiresAt: string;
+    id: string;
+    skills?: Array<AnthropicContainerSkill> | null | undefined;
+};
+/** @internal */
+export declare const AnthropicContainer$inboundSchema: z.ZodType<AnthropicContainer, unknown>;
+export declare function anthropicContainerFromJSON(jsonString: string): SafeParseResult<AnthropicContainer, SDKValidationError>;
+//# sourceMappingURL=anthropiccontainer.d.ts.map

package/esm/models/anthropiccontainer.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e824c8443a90
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicContainerSkill$inboundSchema, } from "./anthropiccontainerskill.js";
+/** @internal */
+export const AnthropicContainer$inboundSchema = z.object({
+    expires_at: z.string(),
+    id: z.string(),
+    skills: z.nullable(z.array(AnthropicContainerSkill$inboundSchema)).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "expires_at": "expiresAt",
+    });
+});
+export function anthropicContainerFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicContainer$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicContainer' from JSON`);
+}
+//# sourceMappingURL=anthropiccontainer.js.map

package/esm/models/anthropiccontainerskill.d.ts

@@ -0,0 +1,20 @@
+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 declare const AnthropicContainerSkillType: {
+    readonly Anthropic: "anthropic";
+    readonly Custom: "custom";
+};
+export type AnthropicContainerSkillType = OpenEnum<typeof AnthropicContainerSkillType>;
+export type AnthropicContainerSkill = {
+    skillId: string;
+    type: AnthropicContainerSkillType;
+    version: string;
+};
+/** @internal */
+export declare const AnthropicContainerSkillType$inboundSchema: z.ZodType<AnthropicContainerSkillType, unknown>;
+/** @internal */
+export declare const AnthropicContainerSkill$inboundSchema: z.ZodType<AnthropicContainerSkill, unknown>;
+export declare function anthropicContainerSkillFromJSON(jsonString: string): SafeParseResult<AnthropicContainerSkill, SDKValidationError>;
+//# sourceMappingURL=anthropiccontainerskill.d.ts.map

package/esm/models/anthropiccontainerskill.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5235f5b38850
+ */
+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 AnthropicContainerSkillType = {
+    Anthropic: "anthropic",
+    Custom: "custom",
+};
+/** @internal */
+export const AnthropicContainerSkillType$inboundSchema = openEnums.inboundSchema(AnthropicContainerSkillType);
+/** @internal */
+export const AnthropicContainerSkill$inboundSchema = z.object({
+    skill_id: z.string(),
+    type: AnthropicContainerSkillType$inboundSchema,
+    version: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "skill_id": "skillId",
+    });
+});
+export function anthropicContainerSkillFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicContainerSkill$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicContainerSkill' from JSON`);
+}
+//# sourceMappingURL=anthropiccontainerskill.js.map

package/esm/models/anthropiccontainerupload.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicContainerUpload = {
+    fileId: string;
+    type: "container_upload";
+};
+/** @internal */
+export declare const AnthropicContainerUpload$inboundSchema: z.ZodType<AnthropicContainerUpload, unknown>;
+export declare function anthropicContainerUploadFromJSON(jsonString: string): SafeParseResult<AnthropicContainerUpload, SDKValidationError>;
+//# sourceMappingURL=anthropiccontainerupload.d.ts.map

package/esm/models/anthropiccontainerupload.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7c9967fcbcec
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicContainerUpload$inboundSchema = z.object({
+    file_id: z.string(),
+    type: z.literal("container_upload"),
+}).transform((v) => {
+    return remap$(v, {
+        "file_id": "fileId",
+    });
+});
+export function anthropicContainerUploadFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicContainerUpload$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicContainerUpload' from JSON`);
+}
+//# sourceMappingURL=anthropiccontainerupload.js.map

package/esm/models/anthropicdirectcaller.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicDirectCaller = {
+    type: "direct";
+};
+/** @internal */
+export declare const AnthropicDirectCaller$inboundSchema: z.ZodType<AnthropicDirectCaller, unknown>;
+export declare function anthropicDirectCallerFromJSON(jsonString: string): SafeParseResult<AnthropicDirectCaller, SDKValidationError>;
+//# sourceMappingURL=anthropicdirectcaller.d.ts.map

package/esm/models/anthropicdirectcaller.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c1dba2541585
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicDirectCaller$inboundSchema = z.object({
+    type: z.literal("direct"),
+});
+export function anthropicDirectCallerFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicDirectCaller$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicDirectCaller' from JSON`);
+}
+//# sourceMappingURL=anthropicdirectcaller.js.map

package/esm/models/anthropicdocumentblock.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicBase64PdfSource } from "./anthropicbase64pdfsource.js";
+import { AnthropicCitationsConfig } from "./anthropiccitationsconfig.js";
+import { AnthropicPlainTextSource } from "./anthropicplaintextsource.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicDocumentBlockSource = (AnthropicBase64PdfSource & {
+    mediaType: "application/pdf";
+}) | (AnthropicPlainTextSource & {
+    mediaType: "text/plain";
+}) | discriminatedUnionTypes.Unknown<"mediaType">;
+export declare const AnthropicDocumentBlockType: {
+    readonly Document: "document";
+};
+export type AnthropicDocumentBlockType = ClosedEnum<typeof AnthropicDocumentBlockType>;
+export type AnthropicDocumentBlock = {
+    citations?: AnthropicCitationsConfig | null | undefined;
+    source: (AnthropicBase64PdfSource & {
+        mediaType: "application/pdf";
+    }) | (AnthropicPlainTextSource & {
+        mediaType: "text/plain";
+    }) | discriminatedUnionTypes.Unknown<"mediaType">;
+    title: string | null;
+    type: AnthropicDocumentBlockType;
+};
+/** @internal */
+export declare const AnthropicDocumentBlockSource$inboundSchema: z.ZodType<AnthropicDocumentBlockSource, unknown>;
+export declare function anthropicDocumentBlockSourceFromJSON(jsonString: string): SafeParseResult<AnthropicDocumentBlockSource, SDKValidationError>;
+/** @internal */
+export declare const AnthropicDocumentBlockType$inboundSchema: z.ZodEnum<typeof AnthropicDocumentBlockType>;
+/** @internal */
+export declare const AnthropicDocumentBlock$inboundSchema: z.ZodType<AnthropicDocumentBlock, unknown>;
+export declare function anthropicDocumentBlockFromJSON(jsonString: string): SafeParseResult<AnthropicDocumentBlock, SDKValidationError>;
+//# sourceMappingURL=anthropicdocumentblock.d.ts.map

package/esm/models/anthropicdocumentblock.js

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6aec49691162
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicBase64PdfSource$inboundSchema, } from "./anthropicbase64pdfsource.js";
+import { AnthropicCitationsConfig$inboundSchema, } from "./anthropiccitationsconfig.js";
+import { AnthropicPlainTextSource$inboundSchema, } from "./anthropicplaintextsource.js";
+export const AnthropicDocumentBlockType = {
+    Document: "document",
+};
+/** @internal */
+export const AnthropicDocumentBlockSource$inboundSchema = discriminatedUnion("media_type", {
+    ["application/pdf"]: AnthropicBase64PdfSource$inboundSchema.and(z.object({ media_type: z.literal("application/pdf") }).transform((v) => ({
+        mediaType: v.media_type,
+    }))),
+    ["text/plain"]: AnthropicPlainTextSource$inboundSchema.and(z.object({ media_type: z.literal("text/plain") }).transform((v) => ({
+        mediaType: v.media_type,
+    }))),
+}, { outputPropertyName: "mediaType" });
+export function anthropicDocumentBlockSourceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicDocumentBlockSource$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicDocumentBlockSource' from JSON`);
+}
+/** @internal */
+export const AnthropicDocumentBlockType$inboundSchema = z.enum(AnthropicDocumentBlockType);
+/** @internal */
+export const AnthropicDocumentBlock$inboundSchema = z.object({
+    citations: z.nullable(AnthropicCitationsConfig$inboundSchema).optional(),
+    source: discriminatedUnion("media_type", {
+        ["application/pdf"]: AnthropicBase64PdfSource$inboundSchema.and(z.object({ media_type: z.literal("application/pdf") }).transform((v) => ({
+            mediaType: v.media_type,
+        }))),
+        ["text/plain"]: AnthropicPlainTextSource$inboundSchema.and(z.object({ media_type: z.literal("text/plain") }).transform((v) => ({
+            mediaType: v.media_type,
+        }))),
+    }, { outputPropertyName: "mediaType" }),
+    title: z.nullable(z.string()),
+    type: AnthropicDocumentBlockType$inboundSchema,
+});
+export function anthropicDocumentBlockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicDocumentBlock$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicDocumentBlock' from JSON`);
+}
+//# sourceMappingURL=anthropicdocumentblock.js.map

package/esm/models/anthropicdocumentblockparam.d.ts

@@ -15,7 +15,11 @@ export type SourceContent = {
     content: string | Array<AnthropicImageBlockParam | AnthropicTextBlockParam>;
     type: "content";
 };
-export type AnthropicDocumentBlockParamSourceUnion = AnthropicBase64PdfSource | AnthropicPlainTextSource | SourceContent | AnthropicUrlPdfSource | AnthropicFileDocumentSource;
+export type AnthropicDocumentBlockParamSourceUnion = (AnthropicBase64PdfSource & {
+    type: "base64";
+}) | (AnthropicPlainTextSource & {
+    type: "text";
+}) | SourceContent | AnthropicUrlPdfSource | AnthropicFileDocumentSource;
 export type AnthropicDocumentBlockParam = {
     /**
      * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. When set on an individual content block, it marks an explicit cache breakpoint; block-level markers also work on OpenAI models that support explicit prompt caching — OpenRouter converts them to the provider's native format.
@@ -23,7 +27,11 @@ export type AnthropicDocumentBlockParam = {
     cacheControl?: AnthropicCacheControlDirective | undefined;
     citations?: AnthropicDocumentBlockParamCitations | null | undefined;
     context?: string | null | undefined;
-    source: AnthropicBase64PdfSource | AnthropicPlainTextSource | SourceContent | AnthropicUrlPdfSource | AnthropicFileDocumentSource;
+    source: (AnthropicBase64PdfSource & {
+        type: "base64";
+    }) | (AnthropicPlainTextSource & {
+        type: "text";
+    }) | SourceContent | AnthropicUrlPdfSource | AnthropicFileDocumentSource;
     title?: string | null | undefined;
     type: "document";
 };
@@ -53,7 +61,11 @@ export type SourceContent$Outbound = {
 export declare const SourceContent$outboundSchema: z.ZodType<SourceContent$Outbound, SourceContent>;
 export declare function sourceContentToJSON(sourceContent: SourceContent): string;
 /** @internal */
-export type AnthropicDocumentBlockParamSourceUnion$Outbound = AnthropicBase64PdfSource$Outbound | AnthropicPlainTextSource$Outbound | SourceContent$Outbound | AnthropicUrlPdfSource$Outbound | AnthropicFileDocumentSource$Outbound;
+export type AnthropicDocumentBlockParamSourceUnion$Outbound = (AnthropicBase64PdfSource$Outbound & {
+    type: "base64";
+}) | (AnthropicPlainTextSource$Outbound & {
+    type: "text";
+}) | SourceContent$Outbound | AnthropicUrlPdfSource$Outbound | AnthropicFileDocumentSource$Outbound;
 /** @internal */
 export declare const AnthropicDocumentBlockParamSourceUnion$outboundSchema: z.ZodType<AnthropicDocumentBlockParamSourceUnion$Outbound, AnthropicDocumentBlockParamSourceUnion>;
 export declare function anthropicDocumentBlockParamSourceUnionToJSON(anthropicDocumentBlockParamSourceUnion: AnthropicDocumentBlockParamSourceUnion): string;
@@ -62,7 +74,11 @@ export type AnthropicDocumentBlockParam$Outbound = {
     cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
     citations?: AnthropicDocumentBlockParamCitations$Outbound | null | undefined;
     context?: string | null | undefined;
-    source: AnthropicBase64PdfSource$Outbound | AnthropicPlainTextSource$Outbound | SourceContent$Outbound | AnthropicUrlPdfSource$Outbound | AnthropicFileDocumentSource$Outbound;
+    source: (AnthropicBase64PdfSource$Outbound & {
+        type: "base64";
+    }) | (AnthropicPlainTextSource$Outbound & {
+        type: "text";
+    }) | SourceContent$Outbound | AnthropicUrlPdfSource$Outbound | AnthropicFileDocumentSource$Outbound;
     title?: string | null | undefined;
     type: "document";
 };

package/esm/models/anthropicdocumentblockparam.js

@@ -53,8 +53,8 @@ export function sourceContentToJSON(sourceContent) {
 }
 /** @internal */
 export const AnthropicDocumentBlockParamSourceUnion$outboundSchema = z.union([
-    AnthropicBase64PdfSource$outboundSchema,
-    AnthropicPlainTextSource$outboundSchema,
+    AnthropicBase64PdfSource$outboundSchema.and(z.object({ type: z.literal("base64") })),
+    AnthropicPlainTextSource$outboundSchema.and(z.object({ type: z.literal("text") })),
     z.lazy(() => SourceContent$outboundSchema),
     AnthropicUrlPdfSource$outboundSchema,
     AnthropicFileDocumentSource$outboundSchema,
@@ -68,8 +68,8 @@ export const AnthropicDocumentBlockParam$outboundSchema = z.object({
     citations: z.nullable(z.lazy(() => AnthropicDocumentBlockParamCitations$outboundSchema)).optional(),
     context: z.nullable(z.string()).optional(),
     source: z.union([
-        AnthropicBase64PdfSource$outboundSchema,
-        AnthropicPlainTextSource$outboundSchema,
+        AnthropicBase64PdfSource$outboundSchema.and(z.object({ type: z.literal("base64") })),
+        AnthropicPlainTextSource$outboundSchema.and(z.object({ type: z.literal("text") })),
         z.lazy(() => SourceContent$outboundSchema),
         AnthropicUrlPdfSource$outboundSchema,
         AnthropicFileDocumentSource$outboundSchema,

package/esm/models/anthropicencryptedcodeexecutionresult.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCodeExecutionOutput } from "./anthropiccodeexecutionoutput.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicEncryptedCodeExecutionResult = {
+    content: Array<AnthropicCodeExecutionOutput>;
+    encryptedStdout: string;
+    returnCode: number;
+    stderr: string;
+    type: "encrypted_code_execution_result";
+};
+/** @internal */
+export declare const AnthropicEncryptedCodeExecutionResult$inboundSchema: z.ZodType<AnthropicEncryptedCodeExecutionResult, unknown>;
+export declare function anthropicEncryptedCodeExecutionResultFromJSON(jsonString: string): SafeParseResult<AnthropicEncryptedCodeExecutionResult, SDKValidationError>;
+//# sourceMappingURL=anthropicencryptedcodeexecutionresult.d.ts.map

package/esm/models/anthropicencryptedcodeexecutionresult.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1e1762f68df1
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicCodeExecutionOutput$inboundSchema, } from "./anthropiccodeexecutionoutput.js";
+/** @internal */
+export const AnthropicEncryptedCodeExecutionResult$inboundSchema = z.object({
+    content: z.array(AnthropicCodeExecutionOutput$inboundSchema),
+    encrypted_stdout: z.string(),
+    return_code: z.int(),
+    stderr: z.string(),
+    type: z.literal("encrypted_code_execution_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "encrypted_stdout": "encryptedStdout",
+        "return_code": "returnCode",
+    });
+});
+export function anthropicEncryptedCodeExecutionResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicEncryptedCodeExecutionResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicEncryptedCodeExecutionResult' from JSON`);
+}
+//# sourceMappingURL=anthropicencryptedcodeexecutionresult.js.map

package/esm/models/anthropicinputtransformation.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";
+/**
+ * A server-side transformation Anthropic applied to the request input
+ */
+export type AnthropicInputTransformation = {
+    path?: string | null | undefined;
+    reason?: string | null | undefined;
+    type: string;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const AnthropicInputTransformation$inboundSchema: z.ZodType<AnthropicInputTransformation, unknown>;
+export declare function anthropicInputTransformationFromJSON(jsonString: string): SafeParseResult<AnthropicInputTransformation, SDKValidationError>;
+//# sourceMappingURL=anthropicinputtransformation.d.ts.map

package/esm/models/anthropicinputtransformation.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 02d29ed9a0c4
+ */
+import * as z from "zod/v4";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicInputTransformation$inboundSchema = collectExtraKeys$(z.object({
+    path: z.nullable(z.string()).optional(),
+    reason: z.nullable(z.string()).optional(),
+    type: z.string(),
+}).catchall(z.any()), "additionalProperties", true);
+export function anthropicInputTransformationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicInputTransformation$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicInputTransformation' from JSON`);
+}
+//# sourceMappingURL=anthropicinputtransformation.js.map

package/esm/models/anthropicoutputtokensdetails.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicOutputTokensDetails = {
+    thinkingTokens: number;
+};
+/** @internal */
+export declare const AnthropicOutputTokensDetails$inboundSchema: z.ZodType<AnthropicOutputTokensDetails, unknown>;
+export declare function anthropicOutputTokensDetailsFromJSON(jsonString: string): SafeParseResult<AnthropicOutputTokensDetails, SDKValidationError>;
+//# sourceMappingURL=anthropicoutputtokensdetails.d.ts.map