@openrouter/sdk 1.3.29 → 1.3.31

package/esm/models/anthropictexteditorcodeexecutionviewresult.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d22abd4b2e55
+ */
+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 FileType = {
+    Text: "text",
+    Image: "image",
+    Pdf: "pdf",
+};
+/** @internal */
+export const FileType$inboundSchema = openEnums
+    .inboundSchema(FileType);
+/** @internal */
+export const AnthropicTextEditorCodeExecutionViewResult$inboundSchema = z.object({
+    content: z.string(),
+    file_type: FileType$inboundSchema,
+    num_lines: z.nullable(z.int()),
+    start_line: z.nullable(z.int()),
+    total_lines: z.nullable(z.int()),
+    type: z.literal("text_editor_code_execution_view_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "file_type": "fileType",
+        "num_lines": "numLines",
+        "start_line": "startLine",
+        "total_lines": "totalLines",
+    });
+});
+export function anthropicTextEditorCodeExecutionViewResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextEditorCodeExecutionViewResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextEditorCodeExecutionViewResult' from JSON`);
+}
+//# sourceMappingURL=anthropictexteditorcodeexecutionviewresult.js.map

package/esm/models/anthropicthinkingblock.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 AnthropicThinkingBlock = {
+    signature: string;
+    thinking: string;
+    type: "thinking";
+};
+/** @internal */
+export declare const AnthropicThinkingBlock$inboundSchema: z.ZodType<AnthropicThinkingBlock, unknown>;
+export declare function anthropicThinkingBlockFromJSON(jsonString: string): SafeParseResult<AnthropicThinkingBlock, SDKValidationError>;
+//# sourceMappingURL=anthropicthinkingblock.d.ts.map

package/esm/models/anthropicthinkingblock.js

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

package/esm/models/anthropictoolreference.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 AnthropicToolReferenceType: {
+    readonly ToolReference: "tool_reference";
+};
+export type AnthropicToolReferenceType = ClosedEnum<typeof AnthropicToolReferenceType>;
+export type AnthropicToolReference = {
+    toolName: string;
+    type: AnthropicToolReferenceType;
+};
+/** @internal */
+export declare const AnthropicToolReferenceType$inboundSchema: z.ZodEnum<typeof AnthropicToolReferenceType>;
+/** @internal */
+export declare const AnthropicToolReference$inboundSchema: z.ZodType<AnthropicToolReference, unknown>;
+export declare function anthropicToolReferenceFromJSON(jsonString: string): SafeParseResult<AnthropicToolReference, SDKValidationError>;
+//# sourceMappingURL=anthropictoolreference.d.ts.map

package/esm/models/anthropictoolreference.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 106efa7085a7
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const AnthropicToolReferenceType = {
+    ToolReference: "tool_reference",
+};
+/** @internal */
+export const AnthropicToolReferenceType$inboundSchema = z.enum(AnthropicToolReferenceType);
+/** @internal */
+export const AnthropicToolReference$inboundSchema = z.object({
+    tool_name: z.string(),
+    type: AnthropicToolReferenceType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "tool_name": "toolName",
+    });
+});
+export function anthropicToolReferenceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicToolReference$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicToolReference' from JSON`);
+}
+//# sourceMappingURL=anthropictoolreference.js.map

package/esm/models/anthropictoolsearchcontent.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicToolSearchResult } from "./anthropictoolsearchresult.js";
+import { AnthropicToolSearchResultError } from "./anthropictoolsearchresulterror.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicToolSearchContent = AnthropicToolSearchResultError | AnthropicToolSearchResult | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const AnthropicToolSearchContent$inboundSchema: z.ZodType<AnthropicToolSearchContent, unknown>;
+export declare function anthropicToolSearchContentFromJSON(jsonString: string): SafeParseResult<AnthropicToolSearchContent, SDKValidationError>;
+//# sourceMappingURL=anthropictoolsearchcontent.d.ts.map

package/esm/models/anthropictoolsearchcontent.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3a2d3e60694f
+ */
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicToolSearchResult$inboundSchema, } from "./anthropictoolsearchresult.js";
+import { AnthropicToolSearchResultError$inboundSchema, } from "./anthropictoolsearchresulterror.js";
+/** @internal */
+export const AnthropicToolSearchContent$inboundSchema = discriminatedUnion("type", {
+    tool_search_tool_result_error: AnthropicToolSearchResultError$inboundSchema,
+    tool_search_tool_search_result: AnthropicToolSearchResult$inboundSchema,
+});
+export function anthropicToolSearchContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicToolSearchContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicToolSearchContent' from JSON`);
+}
+//# sourceMappingURL=anthropictoolsearchcontent.js.map

package/esm/models/anthropictoolsearchresult.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicToolReference } from "./anthropictoolreference.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicToolSearchResult = {
+    toolReferences: Array<AnthropicToolReference>;
+    type: "tool_search_tool_search_result";
+};
+/** @internal */
+export declare const AnthropicToolSearchResult$inboundSchema: z.ZodType<AnthropicToolSearchResult, unknown>;
+export declare function anthropicToolSearchResultFromJSON(jsonString: string): SafeParseResult<AnthropicToolSearchResult, SDKValidationError>;
+//# sourceMappingURL=anthropictoolsearchresult.d.ts.map

package/esm/models/anthropictoolsearchresult.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 465ebc45a91c
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicToolReference$inboundSchema, } from "./anthropictoolreference.js";
+/** @internal */
+export const AnthropicToolSearchResult$inboundSchema = z.object({
+    tool_references: z.array(AnthropicToolReference$inboundSchema),
+    type: z.literal("tool_search_tool_search_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_references": "toolReferences",
+    });
+});
+export function anthropicToolSearchResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicToolSearchResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicToolSearchResult' from JSON`);
+}
+//# sourceMappingURL=anthropictoolsearchresult.js.map

package/esm/models/anthropictoolsearchresulterror.d.ts

@@ -0,0 +1,13 @@
+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 AnthropicToolSearchResultError = {
+    errorCode: AnthropicServerToolErrorCode;
+    errorMessage: string | null;
+    type: "tool_search_tool_result_error";
+};
+/** @internal */
+export declare const AnthropicToolSearchResultError$inboundSchema: z.ZodType<AnthropicToolSearchResultError, unknown>;
+export declare function anthropicToolSearchResultErrorFromJSON(jsonString: string): SafeParseResult<AnthropicToolSearchResultError, SDKValidationError>;
+//# sourceMappingURL=anthropictoolsearchresulterror.d.ts.map

package/esm/models/anthropictoolsearchresulterror.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fdf5a0f6072b
+ */
+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 AnthropicToolSearchResultError$inboundSchema = z.object({
+    error_code: AnthropicServerToolErrorCode$inboundSchema,
+    error_message: z.nullable(z.string()),
+    type: z.literal("tool_search_tool_result_error"),
+}).transform((v) => {
+    return remap$(v, {
+        "error_code": "errorCode",
+        "error_message": "errorMessage",
+    });
+});
+export function anthropicToolSearchResultErrorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicToolSearchResultError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicToolSearchResultError' from JSON`);
+}
+//# sourceMappingURL=anthropictoolsearchresulterror.js.map

package/esm/models/anthropictoolsearchtoolresult.d.ts

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

package/esm/models/anthropictoolsearchtoolresult.js

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

package/esm/models/anthropictooluseblock.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCaller } from "./anthropiccaller.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicToolUseBlock = {
+    caller: AnthropicCaller;
+    id: string;
+    input?: any | undefined;
+    name: string;
+    type: "tool_use";
+};
+/** @internal */
+export declare const AnthropicToolUseBlock$inboundSchema: z.ZodType<AnthropicToolUseBlock, unknown>;
+export declare function anthropicToolUseBlockFromJSON(jsonString: string): SafeParseResult<AnthropicToolUseBlock, SDKValidationError>;
+//# sourceMappingURL=anthropictooluseblock.d.ts.map

package/esm/models/anthropictooluseblock.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6c9a5a6224a4
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicCaller$inboundSchema, } from "./anthropiccaller.js";
+/** @internal */
+export const AnthropicToolUseBlock$inboundSchema = z.object({
+    caller: AnthropicCaller$inboundSchema,
+    id: z.string(),
+    input: z.any().optional(),
+    name: z.string(),
+    type: z.literal("tool_use"),
+});
+export function anthropicToolUseBlockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicToolUseBlock$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicToolUseBlock' from JSON`);
+}
+//# sourceMappingURL=anthropictooluseblock.js.map

package/esm/models/anthropicwebfetchblock.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicDocumentBlock } from "./anthropicdocumentblock.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicWebFetchBlock = {
+    content: AnthropicDocumentBlock;
+    retrievedAt: string | null;
+    type: "web_fetch_result";
+    url: string;
+};
+/** @internal */
+export declare const AnthropicWebFetchBlock$inboundSchema: z.ZodType<AnthropicWebFetchBlock, unknown>;
+export declare function anthropicWebFetchBlockFromJSON(jsonString: string): SafeParseResult<AnthropicWebFetchBlock, SDKValidationError>;
+//# sourceMappingURL=anthropicwebfetchblock.d.ts.map

package/esm/models/anthropicwebfetchblock.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0e3236a6988b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicDocumentBlock$inboundSchema, } from "./anthropicdocumentblock.js";
+/** @internal */
+export const AnthropicWebFetchBlock$inboundSchema = z.object({
+    content: AnthropicDocumentBlock$inboundSchema,
+    retrieved_at: z.nullable(z.string()),
+    type: z.literal("web_fetch_result"),
+    url: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "retrieved_at": "retrievedAt",
+    });
+});
+export function anthropicWebFetchBlockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebFetchBlock$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebFetchBlock' from JSON`);
+}
+//# sourceMappingURL=anthropicwebfetchblock.js.map

package/esm/models/anthropicwebfetchcontent.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicWebFetchBlock } from "./anthropicwebfetchblock.js";
+import { AnthropicWebFetchToolResultError } from "./anthropicwebfetchtoolresulterror.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicWebFetchContent = AnthropicWebFetchBlock | AnthropicWebFetchToolResultError | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const AnthropicWebFetchContent$inboundSchema: z.ZodType<AnthropicWebFetchContent, unknown>;
+export declare function anthropicWebFetchContentFromJSON(jsonString: string): SafeParseResult<AnthropicWebFetchContent, SDKValidationError>;
+//# sourceMappingURL=anthropicwebfetchcontent.d.ts.map

package/esm/models/anthropicwebfetchcontent.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ef77960724b3
+ */
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicWebFetchBlock$inboundSchema, } from "./anthropicwebfetchblock.js";
+import { AnthropicWebFetchToolResultError$inboundSchema, } from "./anthropicwebfetchtoolresulterror.js";
+/** @internal */
+export const AnthropicWebFetchContent$inboundSchema = discriminatedUnion("type", {
+    web_fetch_result: AnthropicWebFetchBlock$inboundSchema,
+    web_fetch_tool_result_error: AnthropicWebFetchToolResultError$inboundSchema,
+});
+export function anthropicWebFetchContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebFetchContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebFetchContent' from JSON`);
+}
+//# sourceMappingURL=anthropicwebfetchcontent.js.map

package/esm/models/anthropicwebfetchtoolresult.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCaller } from "./anthropiccaller.js";
+import { AnthropicWebFetchContent } from "./anthropicwebfetchcontent.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicWebFetchToolResult = {
+    caller: AnthropicCaller;
+    content: AnthropicWebFetchContent;
+    toolUseId: string;
+    type: "web_fetch_tool_result";
+};
+/** @internal */
+export declare const AnthropicWebFetchToolResult$inboundSchema: z.ZodType<AnthropicWebFetchToolResult, unknown>;
+export declare function anthropicWebFetchToolResultFromJSON(jsonString: string): SafeParseResult<AnthropicWebFetchToolResult, SDKValidationError>;
+//# sourceMappingURL=anthropicwebfetchtoolresult.d.ts.map

package/esm/models/anthropicwebfetchtoolresult.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 12d2ff014a57
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicCaller$inboundSchema, } from "./anthropiccaller.js";
+import { AnthropicWebFetchContent$inboundSchema, } from "./anthropicwebfetchcontent.js";
+/** @internal */
+export const AnthropicWebFetchToolResult$inboundSchema = z.object({
+    caller: AnthropicCaller$inboundSchema,
+    content: AnthropicWebFetchContent$inboundSchema,
+    tool_use_id: z.string(),
+    type: z.literal("web_fetch_tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_use_id": "toolUseId",
+    });
+});
+export function anthropicWebFetchToolResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebFetchToolResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebFetchToolResult' from JSON`);
+}
+//# sourceMappingURL=anthropicwebfetchtoolresult.js.map

package/esm/models/anthropicwebfetchtoolresulterror.d.ts

@@ -0,0 +1,25 @@
+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 AnthropicWebFetchToolResultErrorErrorCode: {
+    readonly InvalidToolInput: "invalid_tool_input";
+    readonly UrlTooLong: "url_too_long";
+    readonly UrlNotAllowed: "url_not_allowed";
+    readonly UrlNotAccessible: "url_not_accessible";
+    readonly UnsupportedContentType: "unsupported_content_type";
+    readonly TooManyRequests: "too_many_requests";
+    readonly MaxUsesExceeded: "max_uses_exceeded";
+    readonly Unavailable: "unavailable";
+};
+export type AnthropicWebFetchToolResultErrorErrorCode = OpenEnum<typeof AnthropicWebFetchToolResultErrorErrorCode>;
+export type AnthropicWebFetchToolResultError = {
+    errorCode: AnthropicWebFetchToolResultErrorErrorCode;
+    type: "web_fetch_tool_result_error";
+};
+/** @internal */
+export declare const AnthropicWebFetchToolResultErrorErrorCode$inboundSchema: z.ZodType<AnthropicWebFetchToolResultErrorErrorCode, unknown>;
+/** @internal */
+export declare const AnthropicWebFetchToolResultError$inboundSchema: z.ZodType<AnthropicWebFetchToolResultError, unknown>;
+export declare function anthropicWebFetchToolResultErrorFromJSON(jsonString: string): SafeParseResult<AnthropicWebFetchToolResultError, SDKValidationError>;
+//# sourceMappingURL=anthropicwebfetchtoolresulterror.d.ts.map

package/esm/models/anthropicwebfetchtoolresulterror.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 51ade5a2476e
+ */
+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 AnthropicWebFetchToolResultErrorErrorCode = {
+    InvalidToolInput: "invalid_tool_input",
+    UrlTooLong: "url_too_long",
+    UrlNotAllowed: "url_not_allowed",
+    UrlNotAccessible: "url_not_accessible",
+    UnsupportedContentType: "unsupported_content_type",
+    TooManyRequests: "too_many_requests",
+    MaxUsesExceeded: "max_uses_exceeded",
+    Unavailable: "unavailable",
+};
+/** @internal */
+export const AnthropicWebFetchToolResultErrorErrorCode$inboundSchema = openEnums.inboundSchema(AnthropicWebFetchToolResultErrorErrorCode);
+/** @internal */
+export const AnthropicWebFetchToolResultError$inboundSchema = z.object({
+    error_code: AnthropicWebFetchToolResultErrorErrorCode$inboundSchema,
+    type: z.literal("web_fetch_tool_result_error"),
+}).transform((v) => {
+    return remap$(v, {
+        "error_code": "errorCode",
+    });
+});
+export function anthropicWebFetchToolResultErrorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebFetchToolResultError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebFetchToolResultError' from JSON`);
+}
+//# sourceMappingURL=anthropicwebfetchtoolresulterror.js.map

package/esm/models/anthropicwebsearchresult.d.ts

@@ -0,0 +1,21 @@
+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 AnthropicWebSearchResultType: {
+    readonly WebSearchResult: "web_search_result";
+};
+export type AnthropicWebSearchResultType = ClosedEnum<typeof AnthropicWebSearchResultType>;
+export type AnthropicWebSearchResult = {
+    encryptedContent: string;
+    pageAge: string | null;
+    title: string;
+    type: AnthropicWebSearchResultType;
+    url: string;
+};
+/** @internal */
+export declare const AnthropicWebSearchResultType$inboundSchema: z.ZodEnum<typeof AnthropicWebSearchResultType>;
+/** @internal */
+export declare const AnthropicWebSearchResult$inboundSchema: z.ZodType<AnthropicWebSearchResult, unknown>;
+export declare function anthropicWebSearchResultFromJSON(jsonString: string): SafeParseResult<AnthropicWebSearchResult, SDKValidationError>;
+//# sourceMappingURL=anthropicwebsearchresult.d.ts.map

package/esm/models/anthropicwebsearchresult.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8e1525a04bc3
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const AnthropicWebSearchResultType = {
+    WebSearchResult: "web_search_result",
+};
+/** @internal */
+export const AnthropicWebSearchResultType$inboundSchema = z.enum(AnthropicWebSearchResultType);
+/** @internal */
+export const AnthropicWebSearchResult$inboundSchema = z.object({
+    encrypted_content: z.string(),
+    page_age: z.nullable(z.string()),
+    title: z.string(),
+    type: AnthropicWebSearchResultType$inboundSchema,
+    url: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "encrypted_content": "encryptedContent",
+        "page_age": "pageAge",
+    });
+});
+export function anthropicWebSearchResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebSearchResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebSearchResult' from JSON`);
+}
+//# sourceMappingURL=anthropicwebsearchresult.js.map

package/esm/models/anthropicwebsearchtoolresult.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCaller } from "./anthropiccaller.js";
+import { AnthropicWebSearchResult } from "./anthropicwebsearchresult.js";
+import { AnthropicWebSearchToolResultError } from "./anthropicwebsearchtoolresulterror.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicWebSearchToolResultContent = AnthropicWebSearchToolResultError | Array<AnthropicWebSearchResult>;
+export type AnthropicWebSearchToolResult = {
+    caller: AnthropicCaller;
+    content: AnthropicWebSearchToolResultError | Array<AnthropicWebSearchResult>;
+    toolUseId: string;
+    type: "web_search_tool_result";
+};
+/** @internal */
+export declare const AnthropicWebSearchToolResultContent$inboundSchema: z.ZodType<AnthropicWebSearchToolResultContent, unknown>;
+export declare function anthropicWebSearchToolResultContentFromJSON(jsonString: string): SafeParseResult<AnthropicWebSearchToolResultContent, SDKValidationError>;
+/** @internal */
+export declare const AnthropicWebSearchToolResult$inboundSchema: z.ZodType<AnthropicWebSearchToolResult, unknown>;
+export declare function anthropicWebSearchToolResultFromJSON(jsonString: string): SafeParseResult<AnthropicWebSearchToolResult, SDKValidationError>;
+//# sourceMappingURL=anthropicwebsearchtoolresult.d.ts.map

package/esm/models/anthropicwebsearchtoolresult.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ba1707269043
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicCaller$inboundSchema, } from "./anthropiccaller.js";
+import { AnthropicWebSearchResult$inboundSchema, } from "./anthropicwebsearchresult.js";
+import { AnthropicWebSearchToolResultError$inboundSchema, } from "./anthropicwebsearchtoolresulterror.js";
+/** @internal */
+export const AnthropicWebSearchToolResultContent$inboundSchema = z.union([
+    AnthropicWebSearchToolResultError$inboundSchema,
+    z.array(AnthropicWebSearchResult$inboundSchema),
+]);
+export function anthropicWebSearchToolResultContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebSearchToolResultContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebSearchToolResultContent' from JSON`);
+}
+/** @internal */
+export const AnthropicWebSearchToolResult$inboundSchema = z.object({
+    caller: AnthropicCaller$inboundSchema,
+    content: z.union([
+        AnthropicWebSearchToolResultError$inboundSchema,
+        z.array(AnthropicWebSearchResult$inboundSchema),
+    ]),
+    tool_use_id: z.string(),
+    type: z.literal("web_search_tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_use_id": "toolUseId",
+    });
+});
+export function anthropicWebSearchToolResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicWebSearchToolResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicWebSearchToolResult' from JSON`);
+}
+//# sourceMappingURL=anthropicwebsearchtoolresult.js.map

package/esm/models/anthropicwebsearchtoolresulterror.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const AnthropicWebSearchToolResultErrorErrorCode: {
+    readonly InvalidToolInput: "invalid_tool_input";
+    readonly Unavailable: "unavailable";
+    readonly MaxUsesExceeded: "max_uses_exceeded";
+    readonly TooManyRequests: "too_many_requests";
+    readonly QueryTooLong: "query_too_long";
+    readonly RequestTooLarge: "request_too_large";
+};
+export type AnthropicWebSearchToolResultErrorErrorCode = OpenEnum<typeof AnthropicWebSearchToolResultErrorErrorCode>;
+export declare const AnthropicWebSearchToolResultErrorType: {
+    readonly WebSearchToolResultError: "web_search_tool_result_error";
+};
+export type AnthropicWebSearchToolResultErrorType = ClosedEnum<typeof AnthropicWebSearchToolResultErrorType>;
+export type AnthropicWebSearchToolResultError = {
+    errorCode: AnthropicWebSearchToolResultErrorErrorCode;
+    type: AnthropicWebSearchToolResultErrorType;
+};
+/** @internal */
+export declare const AnthropicWebSearchToolResultErrorErrorCode$inboundSchema: z.ZodType<AnthropicWebSearchToolResultErrorErrorCode, unknown>;
+/** @internal */
+export declare const AnthropicWebSearchToolResultErrorType$inboundSchema: z.ZodEnum<typeof AnthropicWebSearchToolResultErrorType>;
+/** @internal */
+export declare const AnthropicWebSearchToolResultError$inboundSchema: z.ZodType<AnthropicWebSearchToolResultError, unknown>;
+export declare function anthropicWebSearchToolResultErrorFromJSON(jsonString: string): SafeParseResult<AnthropicWebSearchToolResultError, SDKValidationError>;
+//# sourceMappingURL=anthropicwebsearchtoolresulterror.d.ts.map