@openrouter/sdk 0.12.34 → 0.12.79

package/esm/models/messagesmessageparam.d.ts

@@ -0,0 +1,228 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { AnthropicCacheControlDirective, AnthropicCacheControlDirective$Outbound } from "./anthropiccachecontroldirective.js";
+import { AnthropicDocumentBlockParam, AnthropicDocumentBlockParam$Outbound } from "./anthropicdocumentblockparam.js";
+import { AnthropicImageBlockParam, AnthropicImageBlockParam$Outbound } from "./anthropicimageblockparam.js";
+import { AnthropicSearchResultBlockParam, AnthropicSearchResultBlockParam$Outbound } from "./anthropicsearchresultblockparam.js";
+import { AnthropicTextBlockParam, AnthropicTextBlockParam$Outbound } from "./anthropictextblockparam.js";
+import { AnthropicWebSearchResultBlockParam, AnthropicWebSearchResultBlockParam$Outbound } from "./anthropicwebsearchresultblockparam.js";
+import { MessagesAdvisorToolResultBlock, MessagesAdvisorToolResultBlock$Outbound } from "./messagesadvisortoolresultblock.js";
+export type ContentCompaction = {
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    content: string | null;
+    type: "compaction";
+};
+export declare const ErrorCode: {
+    readonly InvalidToolInput: "invalid_tool_input";
+    readonly Unavailable: "unavailable";
+    readonly MaxUsesExceeded: "max_uses_exceeded";
+    readonly TooManyRequests: "too_many_requests";
+    readonly QueryTooLong: "query_too_long";
+};
+export type ErrorCode = OpenEnum<typeof ErrorCode>;
+export declare const TypeWebSearchToolResultError: {
+    readonly WebSearchToolResultError: "web_search_tool_result_error";
+};
+export type TypeWebSearchToolResultError = ClosedEnum<typeof TypeWebSearchToolResultError>;
+export type ContentWebSearchToolResultError = {
+    errorCode: ErrorCode;
+    type: TypeWebSearchToolResultError;
+};
+export type MessagesMessageParamContentUnion3 = ContentWebSearchToolResultError | Array<AnthropicWebSearchResultBlockParam>;
+export type ContentWebSearchToolResult = {
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    content: ContentWebSearchToolResultError | Array<AnthropicWebSearchResultBlockParam>;
+    toolUseId: string;
+    type: "web_search_tool_result";
+};
+export type ContentServerToolUse = {
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    id: string;
+    input?: any | null | undefined;
+    name: string;
+    type: "server_tool_use";
+};
+export type ContentRedactedThinking = {
+    data: string;
+    type: "redacted_thinking";
+};
+export type ContentThinking = {
+    signature: string;
+    thinking: string;
+    type: "thinking";
+};
+export type ContentToolReference = {
+    toolName: string;
+    type: "tool_reference";
+};
+export type MessagesMessageParamContentUnion1 = AnthropicTextBlockParam | AnthropicImageBlockParam | ContentToolReference | AnthropicSearchResultBlockParam | AnthropicDocumentBlockParam;
+export type MessagesMessageParamContentUnion2 = string | Array<AnthropicTextBlockParam | AnthropicImageBlockParam | ContentToolReference | AnthropicSearchResultBlockParam | AnthropicDocumentBlockParam>;
+export type ContentToolResult = {
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    content?: string | Array<AnthropicTextBlockParam | AnthropicImageBlockParam | ContentToolReference | AnthropicSearchResultBlockParam | AnthropicDocumentBlockParam> | undefined;
+    isError?: boolean | undefined;
+    toolUseId: string;
+    type: "tool_result";
+};
+export type ContentToolUse = {
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
+    id: string;
+    input?: any | null | undefined;
+    name: string;
+    type: "tool_use";
+};
+export type MessagesMessageParamContentUnion4 = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicDocumentBlockParam | ContentToolUse | ContentToolResult | ContentThinking | ContentRedactedThinking | ContentServerToolUse | ContentWebSearchToolResult | AnthropicSearchResultBlockParam | ContentCompaction | MessagesAdvisorToolResultBlock;
+export type MessagesMessageParamContentUnion5 = string | Array<AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicDocumentBlockParam | ContentToolUse | ContentToolResult | ContentThinking | ContentRedactedThinking | ContentServerToolUse | ContentWebSearchToolResult | AnthropicSearchResultBlockParam | ContentCompaction | MessagesAdvisorToolResultBlock>;
+export declare const MessagesMessageParamRole: {
+    readonly User: "user";
+    readonly Assistant: "assistant";
+    readonly System: "system";
+};
+export type MessagesMessageParamRole = OpenEnum<typeof MessagesMessageParamRole>;
+/**
+ * Anthropic message with OpenRouter extensions
+ */
+export type MessagesMessageParam = {
+    content: string | Array<AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicDocumentBlockParam | ContentToolUse | ContentToolResult | ContentThinking | ContentRedactedThinking | ContentServerToolUse | ContentWebSearchToolResult | AnthropicSearchResultBlockParam | ContentCompaction | MessagesAdvisorToolResultBlock>;
+    role: MessagesMessageParamRole;
+};
+/** @internal */
+export type ContentCompaction$Outbound = {
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    content: string | null;
+    type: "compaction";
+};
+/** @internal */
+export declare const ContentCompaction$outboundSchema: z.ZodType<ContentCompaction$Outbound, ContentCompaction>;
+export declare function contentCompactionToJSON(contentCompaction: ContentCompaction): string;
+/** @internal */
+export declare const ErrorCode$outboundSchema: z.ZodType<string, ErrorCode>;
+/** @internal */
+export declare const TypeWebSearchToolResultError$outboundSchema: z.ZodEnum<typeof TypeWebSearchToolResultError>;
+/** @internal */
+export type ContentWebSearchToolResultError$Outbound = {
+    error_code: string;
+    type: string;
+};
+/** @internal */
+export declare const ContentWebSearchToolResultError$outboundSchema: z.ZodType<ContentWebSearchToolResultError$Outbound, ContentWebSearchToolResultError>;
+export declare function contentWebSearchToolResultErrorToJSON(contentWebSearchToolResultError: ContentWebSearchToolResultError): string;
+/** @internal */
+export type MessagesMessageParamContentUnion3$Outbound = ContentWebSearchToolResultError$Outbound | Array<AnthropicWebSearchResultBlockParam$Outbound>;
+/** @internal */
+export declare const MessagesMessageParamContentUnion3$outboundSchema: z.ZodType<MessagesMessageParamContentUnion3$Outbound, MessagesMessageParamContentUnion3>;
+export declare function messagesMessageParamContentUnion3ToJSON(messagesMessageParamContentUnion3: MessagesMessageParamContentUnion3): string;
+/** @internal */
+export type ContentWebSearchToolResult$Outbound = {
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    content: ContentWebSearchToolResultError$Outbound | Array<AnthropicWebSearchResultBlockParam$Outbound>;
+    tool_use_id: string;
+    type: "web_search_tool_result";
+};
+/** @internal */
+export declare const ContentWebSearchToolResult$outboundSchema: z.ZodType<ContentWebSearchToolResult$Outbound, ContentWebSearchToolResult>;
+export declare function contentWebSearchToolResultToJSON(contentWebSearchToolResult: ContentWebSearchToolResult): string;
+/** @internal */
+export type ContentServerToolUse$Outbound = {
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    id: string;
+    input?: any | null | undefined;
+    name: string;
+    type: "server_tool_use";
+};
+/** @internal */
+export declare const ContentServerToolUse$outboundSchema: z.ZodType<ContentServerToolUse$Outbound, ContentServerToolUse>;
+export declare function contentServerToolUseToJSON(contentServerToolUse: ContentServerToolUse): string;
+/** @internal */
+export type ContentRedactedThinking$Outbound = {
+    data: string;
+    type: "redacted_thinking";
+};
+/** @internal */
+export declare const ContentRedactedThinking$outboundSchema: z.ZodType<ContentRedactedThinking$Outbound, ContentRedactedThinking>;
+export declare function contentRedactedThinkingToJSON(contentRedactedThinking: ContentRedactedThinking): string;
+/** @internal */
+export type ContentThinking$Outbound = {
+    signature: string;
+    thinking: string;
+    type: "thinking";
+};
+/** @internal */
+export declare const ContentThinking$outboundSchema: z.ZodType<ContentThinking$Outbound, ContentThinking>;
+export declare function contentThinkingToJSON(contentThinking: ContentThinking): string;
+/** @internal */
+export type ContentToolReference$Outbound = {
+    tool_name: string;
+    type: "tool_reference";
+};
+/** @internal */
+export declare const ContentToolReference$outboundSchema: z.ZodType<ContentToolReference$Outbound, ContentToolReference>;
+export declare function contentToolReferenceToJSON(contentToolReference: ContentToolReference): string;
+/** @internal */
+export type MessagesMessageParamContentUnion1$Outbound = AnthropicTextBlockParam$Outbound | AnthropicImageBlockParam$Outbound | ContentToolReference$Outbound | AnthropicSearchResultBlockParam$Outbound | AnthropicDocumentBlockParam$Outbound;
+/** @internal */
+export declare const MessagesMessageParamContentUnion1$outboundSchema: z.ZodType<MessagesMessageParamContentUnion1$Outbound, MessagesMessageParamContentUnion1>;
+export declare function messagesMessageParamContentUnion1ToJSON(messagesMessageParamContentUnion1: MessagesMessageParamContentUnion1): string;
+/** @internal */
+export type MessagesMessageParamContentUnion2$Outbound = string | Array<AnthropicTextBlockParam$Outbound | AnthropicImageBlockParam$Outbound | ContentToolReference$Outbound | AnthropicSearchResultBlockParam$Outbound | AnthropicDocumentBlockParam$Outbound>;
+/** @internal */
+export declare const MessagesMessageParamContentUnion2$outboundSchema: z.ZodType<MessagesMessageParamContentUnion2$Outbound, MessagesMessageParamContentUnion2>;
+export declare function messagesMessageParamContentUnion2ToJSON(messagesMessageParamContentUnion2: MessagesMessageParamContentUnion2): string;
+/** @internal */
+export type ContentToolResult$Outbound = {
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    content?: string | Array<AnthropicTextBlockParam$Outbound | AnthropicImageBlockParam$Outbound | ContentToolReference$Outbound | AnthropicSearchResultBlockParam$Outbound | AnthropicDocumentBlockParam$Outbound> | undefined;
+    is_error?: boolean | undefined;
+    tool_use_id: string;
+    type: "tool_result";
+};
+/** @internal */
+export declare const ContentToolResult$outboundSchema: z.ZodType<ContentToolResult$Outbound, ContentToolResult>;
+export declare function contentToolResultToJSON(contentToolResult: ContentToolResult): string;
+/** @internal */
+export type ContentToolUse$Outbound = {
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
+    id: string;
+    input?: any | null | undefined;
+    name: string;
+    type: "tool_use";
+};
+/** @internal */
+export declare const ContentToolUse$outboundSchema: z.ZodType<ContentToolUse$Outbound, ContentToolUse>;
+export declare function contentToolUseToJSON(contentToolUse: ContentToolUse): string;
+/** @internal */
+export type MessagesMessageParamContentUnion4$Outbound = AnthropicTextBlockParam$Outbound | AnthropicImageBlockParam$Outbound | AnthropicDocumentBlockParam$Outbound | ContentToolUse$Outbound | ContentToolResult$Outbound | ContentThinking$Outbound | ContentRedactedThinking$Outbound | ContentServerToolUse$Outbound | ContentWebSearchToolResult$Outbound | AnthropicSearchResultBlockParam$Outbound | ContentCompaction$Outbound | MessagesAdvisorToolResultBlock$Outbound;
+/** @internal */
+export declare const MessagesMessageParamContentUnion4$outboundSchema: z.ZodType<MessagesMessageParamContentUnion4$Outbound, MessagesMessageParamContentUnion4>;
+export declare function messagesMessageParamContentUnion4ToJSON(messagesMessageParamContentUnion4: MessagesMessageParamContentUnion4): string;
+/** @internal */
+export type MessagesMessageParamContentUnion5$Outbound = string | Array<AnthropicTextBlockParam$Outbound | AnthropicImageBlockParam$Outbound | AnthropicDocumentBlockParam$Outbound | ContentToolUse$Outbound | ContentToolResult$Outbound | ContentThinking$Outbound | ContentRedactedThinking$Outbound | ContentServerToolUse$Outbound | ContentWebSearchToolResult$Outbound | AnthropicSearchResultBlockParam$Outbound | ContentCompaction$Outbound | MessagesAdvisorToolResultBlock$Outbound>;
+/** @internal */
+export declare const MessagesMessageParamContentUnion5$outboundSchema: z.ZodType<MessagesMessageParamContentUnion5$Outbound, MessagesMessageParamContentUnion5>;
+export declare function messagesMessageParamContentUnion5ToJSON(messagesMessageParamContentUnion5: MessagesMessageParamContentUnion5): string;
+/** @internal */
+export declare const MessagesMessageParamRole$outboundSchema: z.ZodType<string, MessagesMessageParamRole>;
+/** @internal */
+export type MessagesMessageParam$Outbound = {
+    content: string | Array<AnthropicTextBlockParam$Outbound | AnthropicImageBlockParam$Outbound | AnthropicDocumentBlockParam$Outbound | ContentToolUse$Outbound | ContentToolResult$Outbound | ContentThinking$Outbound | ContentRedactedThinking$Outbound | ContentServerToolUse$Outbound | ContentWebSearchToolResult$Outbound | AnthropicSearchResultBlockParam$Outbound | ContentCompaction$Outbound | MessagesAdvisorToolResultBlock$Outbound>;
+    role: string;
+};
+/** @internal */
+export declare const MessagesMessageParam$outboundSchema: z.ZodType<MessagesMessageParam$Outbound, MessagesMessageParam>;
+export declare function messagesMessageParamToJSON(messagesMessageParam: MessagesMessageParam): string;
+//# sourceMappingURL=messagesmessageparam.d.ts.map

package/esm/models/messagesmessageparam.js

@@ -0,0 +1,261 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0a3ea5a7e049
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { AnthropicCacheControlDirective$outboundSchema, } from "./anthropiccachecontroldirective.js";
+import { AnthropicDocumentBlockParam$outboundSchema, } from "./anthropicdocumentblockparam.js";
+import { AnthropicImageBlockParam$outboundSchema, } from "./anthropicimageblockparam.js";
+import { AnthropicSearchResultBlockParam$outboundSchema, } from "./anthropicsearchresultblockparam.js";
+import { AnthropicTextBlockParam$outboundSchema, } from "./anthropictextblockparam.js";
+import { AnthropicWebSearchResultBlockParam$outboundSchema, } from "./anthropicwebsearchresultblockparam.js";
+import { MessagesAdvisorToolResultBlock$outboundSchema, } from "./messagesadvisortoolresultblock.js";
+export const ErrorCode = {
+    InvalidToolInput: "invalid_tool_input",
+    Unavailable: "unavailable",
+    MaxUsesExceeded: "max_uses_exceeded",
+    TooManyRequests: "too_many_requests",
+    QueryTooLong: "query_too_long",
+};
+export const TypeWebSearchToolResultError = {
+    WebSearchToolResultError: "web_search_tool_result_error",
+};
+export const MessagesMessageParamRole = {
+    User: "user",
+    Assistant: "assistant",
+    System: "system",
+};
+/** @internal */
+export const ContentCompaction$outboundSchema = z.object({
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    content: z.nullable(z.string()),
+    type: z.literal("compaction"),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function contentCompactionToJSON(contentCompaction) {
+    return JSON.stringify(ContentCompaction$outboundSchema.parse(contentCompaction));
+}
+/** @internal */
+export const ErrorCode$outboundSchema = openEnums
+    .outboundSchema(ErrorCode);
+/** @internal */
+export const TypeWebSearchToolResultError$outboundSchema = z.enum(TypeWebSearchToolResultError);
+/** @internal */
+export const ContentWebSearchToolResultError$outboundSchema = z.object({
+    errorCode: ErrorCode$outboundSchema,
+    type: TypeWebSearchToolResultError$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        errorCode: "error_code",
+    });
+});
+export function contentWebSearchToolResultErrorToJSON(contentWebSearchToolResultError) {
+    return JSON.stringify(ContentWebSearchToolResultError$outboundSchema.parse(contentWebSearchToolResultError));
+}
+/** @internal */
+export const MessagesMessageParamContentUnion3$outboundSchema = z.union([
+    z.lazy(() => ContentWebSearchToolResultError$outboundSchema),
+    z.array(AnthropicWebSearchResultBlockParam$outboundSchema),
+]);
+export function messagesMessageParamContentUnion3ToJSON(messagesMessageParamContentUnion3) {
+    return JSON.stringify(MessagesMessageParamContentUnion3$outboundSchema.parse(messagesMessageParamContentUnion3));
+}
+/** @internal */
+export const ContentWebSearchToolResult$outboundSchema = z.object({
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    content: z.union([
+        z.lazy(() => ContentWebSearchToolResultError$outboundSchema),
+        z.array(AnthropicWebSearchResultBlockParam$outboundSchema),
+    ]),
+    toolUseId: z.string(),
+    type: z.literal("web_search_tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+        toolUseId: "tool_use_id",
+    });
+});
+export function contentWebSearchToolResultToJSON(contentWebSearchToolResult) {
+    return JSON.stringify(ContentWebSearchToolResult$outboundSchema.parse(contentWebSearchToolResult));
+}
+/** @internal */
+export const ContentServerToolUse$outboundSchema = z.object({
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    id: z.string(),
+    input: z.nullable(z.any()).optional(),
+    name: z.string(),
+    type: z.literal("server_tool_use"),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function contentServerToolUseToJSON(contentServerToolUse) {
+    return JSON.stringify(ContentServerToolUse$outboundSchema.parse(contentServerToolUse));
+}
+/** @internal */
+export const ContentRedactedThinking$outboundSchema = z.object({
+    data: z.string(),
+    type: z.literal("redacted_thinking"),
+});
+export function contentRedactedThinkingToJSON(contentRedactedThinking) {
+    return JSON.stringify(ContentRedactedThinking$outboundSchema.parse(contentRedactedThinking));
+}
+/** @internal */
+export const ContentThinking$outboundSchema = z.object({
+    signature: z.string(),
+    thinking: z.string(),
+    type: z.literal("thinking"),
+});
+export function contentThinkingToJSON(contentThinking) {
+    return JSON.stringify(ContentThinking$outboundSchema.parse(contentThinking));
+}
+/** @internal */
+export const ContentToolReference$outboundSchema = z.object({
+    toolName: z.string(),
+    type: z.literal("tool_reference"),
+}).transform((v) => {
+    return remap$(v, {
+        toolName: "tool_name",
+    });
+});
+export function contentToolReferenceToJSON(contentToolReference) {
+    return JSON.stringify(ContentToolReference$outboundSchema.parse(contentToolReference));
+}
+/** @internal */
+export const MessagesMessageParamContentUnion1$outboundSchema = z.union([
+    AnthropicTextBlockParam$outboundSchema,
+    AnthropicImageBlockParam$outboundSchema,
+    z.lazy(() => ContentToolReference$outboundSchema),
+    AnthropicSearchResultBlockParam$outboundSchema,
+    AnthropicDocumentBlockParam$outboundSchema,
+]);
+export function messagesMessageParamContentUnion1ToJSON(messagesMessageParamContentUnion1) {
+    return JSON.stringify(MessagesMessageParamContentUnion1$outboundSchema.parse(messagesMessageParamContentUnion1));
+}
+/** @internal */
+export const MessagesMessageParamContentUnion2$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        AnthropicTextBlockParam$outboundSchema,
+        AnthropicImageBlockParam$outboundSchema,
+        z.lazy(() => ContentToolReference$outboundSchema),
+        AnthropicSearchResultBlockParam$outboundSchema,
+        AnthropicDocumentBlockParam$outboundSchema,
+    ])),
+]);
+export function messagesMessageParamContentUnion2ToJSON(messagesMessageParamContentUnion2) {
+    return JSON.stringify(MessagesMessageParamContentUnion2$outboundSchema.parse(messagesMessageParamContentUnion2));
+}
+/** @internal */
+export const ContentToolResult$outboundSchema = z.object({
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    content: z.union([
+        z.string(),
+        z.array(z.union([
+            AnthropicTextBlockParam$outboundSchema,
+            AnthropicImageBlockParam$outboundSchema,
+            z.lazy(() => ContentToolReference$outboundSchema),
+            AnthropicSearchResultBlockParam$outboundSchema,
+            AnthropicDocumentBlockParam$outboundSchema,
+        ])),
+    ]).optional(),
+    isError: z.boolean().optional(),
+    toolUseId: z.string(),
+    type: z.literal("tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+        isError: "is_error",
+        toolUseId: "tool_use_id",
+    });
+});
+export function contentToolResultToJSON(contentToolResult) {
+    return JSON.stringify(ContentToolResult$outboundSchema.parse(contentToolResult));
+}
+/** @internal */
+export const ContentToolUse$outboundSchema = z.object({
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
+    id: z.string(),
+    input: z.nullable(z.any()).optional(),
+    name: z.string(),
+    type: z.literal("tool_use"),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function contentToolUseToJSON(contentToolUse) {
+    return JSON.stringify(ContentToolUse$outboundSchema.parse(contentToolUse));
+}
+/** @internal */
+export const MessagesMessageParamContentUnion4$outboundSchema = z.union([
+    AnthropicTextBlockParam$outboundSchema,
+    AnthropicImageBlockParam$outboundSchema,
+    AnthropicDocumentBlockParam$outboundSchema,
+    z.lazy(() => ContentToolUse$outboundSchema),
+    z.lazy(() => ContentToolResult$outboundSchema),
+    z.lazy(() => ContentThinking$outboundSchema),
+    z.lazy(() => ContentRedactedThinking$outboundSchema),
+    z.lazy(() => ContentServerToolUse$outboundSchema),
+    z.lazy(() => ContentWebSearchToolResult$outboundSchema),
+    AnthropicSearchResultBlockParam$outboundSchema,
+    z.lazy(() => ContentCompaction$outboundSchema),
+    MessagesAdvisorToolResultBlock$outboundSchema,
+]);
+export function messagesMessageParamContentUnion4ToJSON(messagesMessageParamContentUnion4) {
+    return JSON.stringify(MessagesMessageParamContentUnion4$outboundSchema.parse(messagesMessageParamContentUnion4));
+}
+/** @internal */
+export const MessagesMessageParamContentUnion5$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        AnthropicTextBlockParam$outboundSchema,
+        AnthropicImageBlockParam$outboundSchema,
+        AnthropicDocumentBlockParam$outboundSchema,
+        z.lazy(() => ContentToolUse$outboundSchema),
+        z.lazy(() => ContentToolResult$outboundSchema),
+        z.lazy(() => ContentThinking$outboundSchema),
+        z.lazy(() => ContentRedactedThinking$outboundSchema),
+        z.lazy(() => ContentServerToolUse$outboundSchema),
+        z.lazy(() => ContentWebSearchToolResult$outboundSchema),
+        AnthropicSearchResultBlockParam$outboundSchema,
+        z.lazy(() => ContentCompaction$outboundSchema),
+        MessagesAdvisorToolResultBlock$outboundSchema,
+    ])),
+]);
+export function messagesMessageParamContentUnion5ToJSON(messagesMessageParamContentUnion5) {
+    return JSON.stringify(MessagesMessageParamContentUnion5$outboundSchema.parse(messagesMessageParamContentUnion5));
+}
+/** @internal */
+export const MessagesMessageParamRole$outboundSchema = openEnums.outboundSchema(MessagesMessageParamRole);
+/** @internal */
+export const MessagesMessageParam$outboundSchema = z.object({
+    content: z.union([
+        z.string(),
+        z.array(z.union([
+            AnthropicTextBlockParam$outboundSchema,
+            AnthropicImageBlockParam$outboundSchema,
+            AnthropicDocumentBlockParam$outboundSchema,
+            z.lazy(() => ContentToolUse$outboundSchema),
+            z.lazy(() => ContentToolResult$outboundSchema),
+            z.lazy(() => ContentThinking$outboundSchema),
+            z.lazy(() => ContentRedactedThinking$outboundSchema),
+            z.lazy(() => ContentServerToolUse$outboundSchema),
+            z.lazy(() => ContentWebSearchToolResult$outboundSchema),
+            AnthropicSearchResultBlockParam$outboundSchema,
+            z.lazy(() => ContentCompaction$outboundSchema),
+            MessagesAdvisorToolResultBlock$outboundSchema,
+        ])),
+    ]),
+    role: MessagesMessageParamRole$outboundSchema,
+});
+export function messagesMessageParamToJSON(messagesMessageParam) {
+    return JSON.stringify(MessagesMessageParam$outboundSchema.parse(messagesMessageParam));
+}
+//# sourceMappingURL=messagesmessageparam.js.map

package/esm/models/messagesoutputconfig.d.ts

@@ -0,0 +1,93 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+/**
+ * How much effort the model should put into its response. Higher effort levels may result in more thorough analysis but take longer. Valid values are `low`, `medium`, `high`, `xhigh`, or `max`.
+ */
+export declare const MessagesOutputConfigEffort: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Xhigh: "xhigh";
+    readonly Max: "max";
+};
+/**
+ * How much effort the model should put into its response. Higher effort levels may result in more thorough analysis but take longer. Valid values are `low`, `medium`, `high`, `xhigh`, or `max`.
+ */
+export type MessagesOutputConfigEffort = OpenEnum<typeof MessagesOutputConfigEffort>;
+export declare const MessagesOutputConfigTypeJSONSchema: {
+    readonly JsonSchema: "json_schema";
+};
+export type MessagesOutputConfigTypeJSONSchema = ClosedEnum<typeof MessagesOutputConfigTypeJSONSchema>;
+/**
+ * A schema to specify Claude's output format in responses. See [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs).
+ */
+export type MessagesOutputConfigFormat = {
+    schema: {
+        [k: string]: any | null;
+    };
+    type: MessagesOutputConfigTypeJSONSchema;
+};
+export declare const TypeTokens: {
+    readonly Tokens: "tokens";
+};
+export type TypeTokens = ClosedEnum<typeof TypeTokens>;
+/**
+ * Task budget for an agentic turn. The model sees a countdown of remaining tokens and uses it to prioritize work and wind down gracefully. Advisory — does not enforce a hard cap.
+ */
+export type TaskBudget = {
+    remaining?: number | null | undefined;
+    total: number;
+    type: TypeTokens;
+};
+/**
+ * Configuration for controlling output behavior. Supports the effort parameter and structured output format.
+ */
+export type MessagesOutputConfig = {
+    /**
+     * How much effort the model should put into its response. Higher effort levels may result in more thorough analysis but take longer. Valid values are `low`, `medium`, `high`, `xhigh`, or `max`.
+     */
+    effort?: MessagesOutputConfigEffort | null | undefined;
+    /**
+     * A schema to specify Claude's output format in responses. See [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs).
+     */
+    format?: MessagesOutputConfigFormat | null | undefined;
+    /**
+     * Task budget for an agentic turn. The model sees a countdown of remaining tokens and uses it to prioritize work and wind down gracefully. Advisory — does not enforce a hard cap.
+     */
+    taskBudget?: TaskBudget | null | undefined;
+};
+/** @internal */
+export declare const MessagesOutputConfigEffort$outboundSchema: z.ZodType<string, MessagesOutputConfigEffort>;
+/** @internal */
+export declare const MessagesOutputConfigTypeJSONSchema$outboundSchema: z.ZodEnum<typeof MessagesOutputConfigTypeJSONSchema>;
+/** @internal */
+export type MessagesOutputConfigFormat$Outbound = {
+    schema: {
+        [k: string]: any | null;
+    };
+    type: string;
+};
+/** @internal */
+export declare const MessagesOutputConfigFormat$outboundSchema: z.ZodType<MessagesOutputConfigFormat$Outbound, MessagesOutputConfigFormat>;
+export declare function messagesOutputConfigFormatToJSON(messagesOutputConfigFormat: MessagesOutputConfigFormat): string;
+/** @internal */
+export declare const TypeTokens$outboundSchema: z.ZodEnum<typeof TypeTokens>;
+/** @internal */
+export type TaskBudget$Outbound = {
+    remaining?: number | null | undefined;
+    total: number;
+    type: string;
+};
+/** @internal */
+export declare const TaskBudget$outboundSchema: z.ZodType<TaskBudget$Outbound, TaskBudget>;
+export declare function taskBudgetToJSON(taskBudget: TaskBudget): string;
+/** @internal */
+export type MessagesOutputConfig$Outbound = {
+    effort?: string | null | undefined;
+    format?: MessagesOutputConfigFormat$Outbound | null | undefined;
+    task_budget?: TaskBudget$Outbound | null | undefined;
+};
+/** @internal */
+export declare const MessagesOutputConfig$outboundSchema: z.ZodType<MessagesOutputConfig$Outbound, MessagesOutputConfig>;
+export declare function messagesOutputConfigToJSON(messagesOutputConfig: MessagesOutputConfig): string;
+//# sourceMappingURL=messagesoutputconfig.d.ts.map

package/esm/models/messagesoutputconfig.js

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: aad3082eb908
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+/**
+ * How much effort the model should put into its response. Higher effort levels may result in more thorough analysis but take longer. Valid values are `low`, `medium`, `high`, `xhigh`, or `max`.
+ */
+export const MessagesOutputConfigEffort = {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+    Xhigh: "xhigh",
+    Max: "max",
+};
+export const MessagesOutputConfigTypeJSONSchema = {
+    JsonSchema: "json_schema",
+};
+export const TypeTokens = {
+    Tokens: "tokens",
+};
+/** @internal */
+export const MessagesOutputConfigEffort$outboundSchema = openEnums.outboundSchema(MessagesOutputConfigEffort);
+/** @internal */
+export const MessagesOutputConfigTypeJSONSchema$outboundSchema = z.enum(MessagesOutputConfigTypeJSONSchema);
+/** @internal */
+export const MessagesOutputConfigFormat$outboundSchema = z.object({
+    schema: z.record(z.string(), z.nullable(z.any())),
+    type: MessagesOutputConfigTypeJSONSchema$outboundSchema,
+});
+export function messagesOutputConfigFormatToJSON(messagesOutputConfigFormat) {
+    return JSON.stringify(MessagesOutputConfigFormat$outboundSchema.parse(messagesOutputConfigFormat));
+}
+/** @internal */
+export const TypeTokens$outboundSchema = z.enum(TypeTokens);
+/** @internal */
+export const TaskBudget$outboundSchema = z.object({
+    remaining: z.nullable(z.int()).optional(),
+    total: z.int(),
+    type: TypeTokens$outboundSchema,
+});
+export function taskBudgetToJSON(taskBudget) {
+    return JSON.stringify(TaskBudget$outboundSchema.parse(taskBudget));
+}
+/** @internal */
+export const MessagesOutputConfig$outboundSchema = z.object({
+    effort: z.nullable(MessagesOutputConfigEffort$outboundSchema).optional(),
+    format: z.nullable(z.lazy(() => MessagesOutputConfigFormat$outboundSchema))
+        .optional(),
+    taskBudget: z.nullable(z.lazy(() => TaskBudget$outboundSchema)).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        taskBudget: "task_budget",
+    });
+});
+export function messagesOutputConfigToJSON(messagesOutputConfig) {
+    return JSON.stringify(MessagesOutputConfig$outboundSchema.parse(messagesOutputConfig));
+}
+//# sourceMappingURL=messagesoutputconfig.js.map