@effect/ai-anthropic 0.9.2 → 0.9.4

package/src/Generated.ts

@@ -19,9 +19,15 @@ export class Model extends S.Union(
   S.Literal("claude-3-7-sonnet-20250219"),
   S.Literal("claude-3-5-haiku-latest"),
   S.Literal("claude-3-5-haiku-20241022"),
+  S.Literal("claude-sonnet-4-20250514"),
+  S.Literal("claude-sonnet-4-0"),
+  S.Literal("claude-4-sonnet-20250514"),
   S.Literal("claude-3-5-sonnet-latest"),
   S.Literal("claude-3-5-sonnet-20241022"),
   S.Literal("claude-3-5-sonnet-20240620"),
+  S.Literal("claude-opus-4-0"),
+  S.Literal("claude-opus-4-20250514"),
+  S.Literal("claude-4-opus-20250514"),
   S.Literal("claude-3-opus-latest"),
   S.Literal("claude-3-opus-20240229"),
   S.Literal("claude-3-sonnet-20240229"),
@@ -30,45 +36,95 @@ export class Model extends S.Union(
   S.Literal("claude-2.0")
 ) {}
 
-export class InputMessageRole extends S.Literal("user", "assistant") {}
-
 export class CacheControlEphemeralType extends S.Literal("ephemeral") {}
 
 export class CacheControlEphemeral extends S.Struct({
   "type": CacheControlEphemeralType
 }) {}
 
+export class RequestServerToolUseBlockName extends S.Literal("web_search") {}
+
+export class RequestServerToolUseBlockType extends S.Literal("server_tool_use") {}
+
+export class RequestServerToolUseBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
+  "id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": RequestServerToolUseBlockName,
+  "type": RequestServerToolUseBlockType
+}) {}
+
+export class RequestWebSearchResultBlockType extends S.Literal("web_search_result") {}
+
+export class RequestWebSearchResultBlock extends S.Struct({
+  "encrypted_content": S.String,
+  "page_age": S.optionalWith(S.Union(S.String, S.Null), { nullable: true }),
+  "title": S.String,
+  "type": RequestWebSearchResultBlockType,
+  "url": S.String
+}) {}
+
+export class WebSearchToolResultErrorCode
+  extends S.Literal("invalid_tool_input", "unavailable", "max_uses_exceeded", "too_many_requests", "query_too_long")
+{}
+
+export class RequestWebSearchToolResultErrorType extends S.Literal("web_search_tool_result_error") {}
+
+export class RequestWebSearchToolResultError extends S.Struct({
+  "error_code": WebSearchToolResultErrorCode,
+  "type": RequestWebSearchToolResultErrorType
+}) {}
+
+export class RequestWebSearchToolResultBlockType extends S.Literal("web_search_tool_result") {}
+
+export class RequestWebSearchToolResultBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
+  "content": S.Union(S.Array(RequestWebSearchResultBlock), RequestWebSearchToolResultError),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "type": RequestWebSearchToolResultBlockType
+}) {}
+
 export class RequestCharLocationCitationType extends S.Literal("char_location") {}
 
 export class RequestCharLocationCitation extends S.Struct({
-  "type": RequestCharLocationCitationType,
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "end_char_index": S.Int,
   "start_char_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_char_index": S.Int
+  "type": RequestCharLocationCitationType
 }) {}
 
 export class RequestPageLocationCitationType extends S.Literal("page_location") {}
 
 export class RequestPageLocationCitation extends S.Struct({
-  "type": RequestPageLocationCitationType,
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "end_page_number": S.Int,
   "start_page_number": S.Int.pipe(S.greaterThanOrEqualTo(1)),
-  "end_page_number": S.Int
+  "type": RequestPageLocationCitationType
 }) {}
 
 export class RequestContentBlockLocationCitationType extends S.Literal("content_block_location") {}
 
 export class RequestContentBlockLocationCitation extends S.Struct({
-  "type": RequestContentBlockLocationCitationType,
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "end_block_index": S.Int,
   "start_block_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_block_index": S.Int
+  "type": RequestContentBlockLocationCitationType
+}) {}
+
+export class RequestWebSearchResultLocationCitationType extends S.Literal("web_search_result_location") {}
+
+export class RequestWebSearchResultLocationCitation extends S.Struct({
+  "cited_text": S.String,
+  "encrypted_index": S.String,
+  "title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "type": RequestWebSearchResultLocationCitationType,
+  "url": S.String.pipe(S.minLength(1), S.maxLength(2048))
 }) {}
 
 export class RequestTextBlockType extends S.Literal("text") {}
@@ -77,7 +133,14 @@ export class RequestTextBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
   "citations": S.optionalWith(
     S.Union(
-      S.Array(S.Union(RequestCharLocationCitation, RequestPageLocationCitation, RequestContentBlockLocationCitation)),
+      S.Array(
+        S.Union(
+          RequestCharLocationCitation,
+          RequestPageLocationCitation,
+          RequestContentBlockLocationCitation,
+          RequestWebSearchResultLocationCitation
+        )
+      ),
       S.Null
     ),
     { nullable: true }
@@ -86,16 +149,14 @@ export class RequestTextBlock extends S.Struct({
   "type": RequestTextBlockType
 }) {}
 
-export class RequestImageBlockType extends S.Literal("image") {}
+export class Base64ImageSourceMediaType extends S.Literal("image/jpeg", "image/png", "image/gif", "image/webp") {}
 
 export class Base64ImageSourceType extends S.Literal("base64") {}
 
-export class Base64ImageSourceMediaType extends S.Literal("image/jpeg", "image/png", "image/gif", "image/webp") {}
-
 export class Base64ImageSource extends S.Struct({
-  "type": Base64ImageSourceType,
+  "data": S.String,
   "media_type": Base64ImageSourceMediaType,
-  "data": S.String
+  "type": Base64ImageSourceType
 }) {}
 
 export class URLImageSourceType extends S.Literal("url") {}
@@ -105,61 +166,65 @@ export class URLImageSource extends S.Struct({
   "url": S.String
 }) {}
 
+export class RequestImageBlockType extends S.Literal("image") {}
+
 export class RequestImageBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
-  "type": RequestImageBlockType,
-  "source": S.Union(Base64ImageSource, URLImageSource)
+  "source": S.Union(Base64ImageSource, URLImageSource),
+  "type": RequestImageBlockType
 }) {}
 
 export class RequestToolUseBlockType extends S.Literal("tool_use") {}
 
 export class RequestToolUseBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
-  "type": RequestToolUseBlockType,
   "id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
-  "name": S.String.pipe(S.minLength(1), S.maxLength(64), S.pattern(new RegExp("^[a-zA-Z0-9_-]{1,64}$"))),
-  "input": S.Record({ key: S.String, value: S.Unknown })
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": S.String.pipe(S.minLength(1), S.maxLength(200)),
+  "type": RequestToolUseBlockType
 }) {}
 
 export class RequestToolResultBlockType extends S.Literal("tool_result") {}
 
 export class RequestToolResultBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
-  "type": RequestToolResultBlockType,
-  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
-  "is_error": S.optionalWith(S.Boolean, { nullable: true }),
   "content": S.optionalWith(S.Union(S.String, S.Array(S.Union(RequestTextBlock, RequestImageBlock))), {
     nullable: true
-  })
+  }),
+  "is_error": S.optionalWith(S.Boolean, { nullable: true }),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "type": RequestToolResultBlockType
 }) {}
 
-export class RequestDocumentBlockType extends S.Literal("document") {}
-
-export class Base64PDFSourceType extends S.Literal("base64") {}
+export class RequestCitationsConfig extends S.Struct({
+  "enabled": S.optionalWith(S.Boolean, { nullable: true })
+}) {}
 
 export class Base64PDFSourceMediaType extends S.Literal("application/pdf") {}
 
+export class Base64PDFSourceType extends S.Literal("base64") {}
+
 export class Base64PDFSource extends S.Struct({
-  "type": Base64PDFSourceType,
+  "data": S.String,
   "media_type": Base64PDFSourceMediaType,
-  "data": S.String
+  "type": Base64PDFSourceType
 }) {}
 
-export class PlainTextSourceType extends S.Literal("text") {}
-
 export class PlainTextSourceMediaType extends S.Literal("text/plain") {}
 
+export class PlainTextSourceType extends S.Literal("text") {}
+
 export class PlainTextSource extends S.Struct({
-  "type": PlainTextSourceType,
+  "data": S.String,
   "media_type": PlainTextSourceMediaType,
-  "data": S.String
+  "type": PlainTextSourceType
 }) {}
 
 export class ContentBlockSourceType extends S.Literal("content") {}
 
 export class ContentBlockSource extends S.Struct({
-  "type": ContentBlockSourceType,
-  "content": S.Union(S.String, S.Array(S.Union(RequestTextBlock, RequestImageBlock)))
+  "content": S.Union(S.String, S.Array(S.Union(RequestTextBlock, RequestImageBlock))),
+  "type": ContentBlockSourceType
 }) {}
 
 export class URLPDFSourceType extends S.Literal("url") {}
@@ -169,35 +234,35 @@ export class URLPDFSource extends S.Struct({
   "url": S.String
 }) {}
 
-export class RequestCitationsConfig extends S.Struct({
-  "enabled": S.optionalWith(S.Boolean, { nullable: true })
-}) {}
+export class RequestDocumentBlockType extends S.Literal("document") {}
 
 export class RequestDocumentBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
-  "type": RequestDocumentBlockType,
+  "citations": S.optionalWith(RequestCitationsConfig, { nullable: true }),
+  "context": S.optionalWith(S.Union(S.String.pipe(S.minLength(1)), S.Null), { nullable: true }),
   "source": S.Union(Base64PDFSource, PlainTextSource, ContentBlockSource, URLPDFSource),
   "title": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(500)), S.Null), { nullable: true }),
-  "context": S.optionalWith(S.Union(S.String.pipe(S.minLength(1)), S.Null), { nullable: true }),
-  "citations": S.optionalWith(RequestCitationsConfig, { nullable: true })
+  "type": RequestDocumentBlockType
 }) {}
 
 export class RequestThinkingBlockType extends S.Literal("thinking") {}
 
 export class RequestThinkingBlock extends S.Struct({
-  "type": RequestThinkingBlockType,
+  "signature": S.String,
   "thinking": S.String,
-  "signature": S.String
+  "type": RequestThinkingBlockType
 }) {}
 
 export class RequestRedactedThinkingBlockType extends S.Literal("redacted_thinking") {}
 
 export class RequestRedactedThinkingBlock extends S.Struct({
-  "type": RequestRedactedThinkingBlockType,
-  "data": S.String
+  "data": S.String,
+  "type": RequestRedactedThinkingBlockType
 }) {}
 
 export class InputContentBlock extends S.Union(
+  RequestServerToolUseBlock,
+  RequestWebSearchToolResultBlock,
   RequestTextBlock,
   RequestImageBlock,
   RequestToolUseBlock,
@@ -207,20 +272,24 @@ export class InputContentBlock extends S.Union(
   RequestRedactedThinkingBlock
 ) {}
 
+export class InputMessageRole extends S.Literal("user", "assistant") {}
+
 export class InputMessage extends S.Struct({
-  "role": InputMessageRole,
-  "content": S.Union(S.String, S.Array(InputContentBlock))
+  "content": S.Union(S.String, S.Array(InputContentBlock)),
+  "role": InputMessageRole
 }) {}
 
 export class Metadata extends S.Struct({
   "user_id": S.optionalWith(S.Union(S.String.pipe(S.maxLength(256)), S.Null), { nullable: true })
 }) {}
 
+export class CreateMessageParamsServiceTier extends S.Literal("auto", "standard_only") {}
+
 export class ThinkingConfigEnabledType extends S.Literal("enabled") {}
 
 export class ThinkingConfigEnabled extends S.Struct({
-  "type": ThinkingConfigEnabledType,
-  "budget_tokens": S.Int.pipe(S.greaterThanOrEqualTo(1024))
+  "budget_tokens": S.Int.pipe(S.greaterThanOrEqualTo(1024)),
+  "type": ThinkingConfigEnabledType
 }) {}
 
 export class ThinkingConfigDisabledType extends S.Literal("disabled") {}
@@ -234,23 +303,23 @@ export class ThinkingConfigParam extends S.Union(ThinkingConfigEnabled, Thinking
 export class ToolChoiceAutoType extends S.Literal("auto") {}
 
 export class ToolChoiceAuto extends S.Struct({
-  "type": ToolChoiceAutoType,
-  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true })
+  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true }),
+  "type": ToolChoiceAutoType
 }) {}
 
 export class ToolChoiceAnyType extends S.Literal("any") {}
 
 export class ToolChoiceAny extends S.Struct({
-  "type": ToolChoiceAnyType,
-  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true })
+  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true }),
+  "type": ToolChoiceAnyType
 }) {}
 
 export class ToolChoiceToolType extends S.Literal("tool") {}
 
 export class ToolChoiceTool extends S.Struct({
-  "type": ToolChoiceToolType,
+  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true }),
   "name": S.String,
-  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true })
+  "type": ToolChoiceToolType
 }) {}
 
 export class ToolChoiceNoneType extends S.Literal("none") {}
@@ -261,52 +330,94 @@ export class ToolChoiceNone extends S.Struct({
 
 export class ToolChoice extends S.Union(ToolChoiceAuto, ToolChoiceAny, ToolChoiceTool, ToolChoiceNone) {}
 
+export class ToolTypeEnum extends S.Literal("custom") {}
+
 export class InputSchemaType extends S.Literal("object") {}
 
 export class InputSchema extends S.Struct({
-  "type": InputSchemaType,
-  "properties": S.optionalWith(S.Union(S.Record({ key: S.String, value: S.Unknown }), S.Null), { nullable: true })
+  "properties": S.optionalWith(S.Union(S.Record({ key: S.String, value: S.Unknown }), S.Null), { nullable: true }),
+  "required": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "type": InputSchemaType
 }) {}
 
 export class Tool extends S.Struct({
+  "type": S.optionalWith(S.Union(S.Null, ToolTypeEnum), { nullable: true }),
   "description": S.optionalWith(S.String, { nullable: true }),
   "name": S.String.pipe(S.minLength(1), S.maxLength(64), S.pattern(new RegExp("^[a-zA-Z0-9_-]{1,64}$"))),
   "input_schema": InputSchema,
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true })
 }) {}
 
-export class BashTool20250124Type extends S.Literal("bash_20250124") {}
-
 export class BashTool20250124Name extends S.Literal("bash") {}
 
+export class BashTool20250124Type extends S.Literal("bash_20250124") {}
+
 export class BashTool20250124 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BashTool20250124Type,
-  "name": BashTool20250124Name
+  "name": BashTool20250124Name,
+  "type": BashTool20250124Type
 }) {}
 
-export class TextEditor20250124Type extends S.Literal("text_editor_20250124") {}
-
 export class TextEditor20250124Name extends S.Literal("str_replace_editor") {}
 
+export class TextEditor20250124Type extends S.Literal("text_editor_20250124") {}
+
 export class TextEditor20250124 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
-  "type": TextEditor20250124Type,
-  "name": TextEditor20250124Name
+  "name": TextEditor20250124Name,
+  "type": TextEditor20250124Type
+}) {}
+
+export class TextEditor20250429Name extends S.Literal("str_replace_based_edit_tool") {}
+
+export class TextEditor20250429Type extends S.Literal("text_editor_20250429") {}
+
+export class TextEditor20250429 extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
+  "name": TextEditor20250429Name,
+  "type": TextEditor20250429Type
+}) {}
+
+export class WebSearchTool20250305Name extends S.Literal("web_search") {}
+
+export class WebSearchTool20250305Type extends S.Literal("web_search_20250305") {}
+
+export class UserLocationType extends S.Literal("approximate") {}
+
+export class UserLocation extends S.Struct({
+  "city": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null), { nullable: true }),
+  "country": S.optionalWith(S.Union(S.String.pipe(S.minLength(2), S.maxLength(2)), S.Null), { nullable: true }),
+  "region": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null), { nullable: true }),
+  "timezone": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null), { nullable: true }),
+  "type": UserLocationType
+}) {}
+
+export class WebSearchTool20250305 extends S.Struct({
+  "allowed_domains": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "blocked_domains": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "cache_control": S.optionalWith(S.Union(CacheControlEphemeral, S.Null), { nullable: true }),
+  "max_uses": S.optionalWith(S.Union(S.Int.pipe(S.greaterThan(0)), S.Null), { nullable: true }),
+  "name": WebSearchTool20250305Name,
+  "type": WebSearchTool20250305Type,
+  "user_location": S.optionalWith(S.Union(UserLocation, S.Null), { nullable: true })
 }) {}
 
 export class CreateMessageParams extends S.Class<CreateMessageParams>("CreateMessageParams")({
-  "model": Model,
+  "model": S.Union(S.String, Model),
   "messages": S.Array(InputMessage),
   "max_tokens": S.Int.pipe(S.greaterThanOrEqualTo(1)),
   "metadata": S.optionalWith(Metadata, { nullable: true }),
+  "service_tier": S.optionalWith(CreateMessageParamsServiceTier, { nullable: true }),
   "stop_sequences": S.optionalWith(S.Array(S.String), { nullable: true }),
   "stream": S.optionalWith(S.Boolean, { nullable: true }),
   "system": S.optionalWith(S.Union(S.String, S.Array(RequestTextBlock)), { nullable: true }),
   "temperature": S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), { nullable: true }),
   "thinking": S.optionalWith(ThinkingConfigParam, { nullable: true }),
   "tool_choice": S.optionalWith(ToolChoice, { nullable: true }),
-  "tools": S.optionalWith(S.Array(S.Union(Tool, BashTool20250124, TextEditor20250124)), { nullable: true }),
+  "tools": S.optionalWith(
+    S.Array(S.Union(Tool, BashTool20250124, TextEditor20250124, TextEditor20250429, WebSearchTool20250305)),
+    { nullable: true }
+  ),
   "top_k": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(0)), { nullable: true }),
   "top_p": S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), { nullable: true })
 }) {}
@@ -315,194 +426,234 @@ export class MessageType extends S.Literal("message") {}
 
 export class MessageRole extends S.Literal("assistant") {}
 
-export class ResponseTextBlockType extends S.Literal("text") {}
-
 export class ResponseCharLocationCitationType extends S.Literal("char_location") {}
 
 export class ResponseCharLocationCitation extends S.Struct({
-  "type": ResponseCharLocationCitationType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "char_location" as const)
-  ),
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String, S.Null),
+  "end_char_index": S.Int,
   "start_char_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_char_index": S.Int
+  "type": ResponseCharLocationCitationType
 }) {}
 
 export class ResponsePageLocationCitationType extends S.Literal("page_location") {}
 
 export class ResponsePageLocationCitation extends S.Struct({
-  "type": ResponsePageLocationCitationType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "page_location" as const)
-  ),
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String, S.Null),
+  "end_page_number": S.Int,
   "start_page_number": S.Int.pipe(S.greaterThanOrEqualTo(1)),
-  "end_page_number": S.Int
+  "type": ResponsePageLocationCitationType
 }) {}
 
 export class ResponseContentBlockLocationCitationType extends S.Literal("content_block_location") {}
 
 export class ResponseContentBlockLocationCitation extends S.Struct({
-  "type": ResponseContentBlockLocationCitationType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "content_block_location" as const)
-  ),
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String, S.Null),
+  "end_block_index": S.Int,
   "start_block_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_block_index": S.Int
+  "type": ResponseContentBlockLocationCitationType
 }) {}
 
+export class ResponseWebSearchResultLocationCitationType extends S.Literal("web_search_result_location") {}
+
+export class ResponseWebSearchResultLocationCitation extends S.Struct({
+  "cited_text": S.String,
+  "encrypted_index": S.String,
+  "title": S.Union(S.String, S.Null),
+  "type": ResponseWebSearchResultLocationCitationType,
+  "url": S.String
+}) {}
+
+export class ResponseTextBlockType extends S.Literal("text") {}
+
 export class ResponseTextBlock extends S.Struct({
-  "type": ResponseTextBlockType.pipe(S.propertySignature, S.withConstructorDefault(() => "text" as const)),
+  "citations": S.NullOr(
+    S.Union(
+      S.Array(
+        S.Union(
+          ResponseCharLocationCitation,
+          ResponsePageLocationCitation,
+          ResponseContentBlockLocationCitation,
+          ResponseWebSearchResultLocationCitation
+        )
+      ),
+      S.Null
+    )
+  ),
   "text": S.String.pipe(S.minLength(0), S.maxLength(5000000)),
-  "citations": S.optionalWith(
-    S.NullOr(
-      S.Union(
-        S.Array(
-          S.Union(ResponseCharLocationCitation, ResponsePageLocationCitation, ResponseContentBlockLocationCitation)
-        ),
-        S.Null
-      )
-    ),
-    { default: () => null }
-  )
+  "type": ResponseTextBlockType
 }) {}
 
 export class ResponseToolUseBlockType extends S.Literal("tool_use") {}
 
 export class ResponseToolUseBlock extends S.Struct({
-  "type": ResponseToolUseBlockType.pipe(S.propertySignature, S.withConstructorDefault(() => "tool_use" as const)),
   "id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
   "name": S.String.pipe(S.minLength(1)),
-  "input": S.Record({ key: S.String, value: S.Unknown })
+  "type": ResponseToolUseBlockType
+}) {}
+
+export class ResponseServerToolUseBlockName extends S.Literal("web_search") {}
+
+export class ResponseServerToolUseBlockType extends S.Literal("server_tool_use") {}
+
+export class ResponseServerToolUseBlock extends S.Struct({
+  "id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": ResponseServerToolUseBlockName,
+  "type": ResponseServerToolUseBlockType
+}) {}
+
+export class ResponseWebSearchToolResultErrorType extends S.Literal("web_search_tool_result_error") {}
+
+export class ResponseWebSearchToolResultError extends S.Struct({
+  "error_code": WebSearchToolResultErrorCode,
+  "type": ResponseWebSearchToolResultErrorType
+}) {}
+
+export class ResponseWebSearchResultBlockType extends S.Literal("web_search_result") {}
+
+export class ResponseWebSearchResultBlock extends S.Struct({
+  "encrypted_content": S.String,
+  "page_age": S.NullOr(S.Union(S.String, S.Null)),
+  "title": S.String,
+  "type": ResponseWebSearchResultBlockType,
+  "url": S.String
+}) {}
+
+export class ResponseWebSearchToolResultBlockType extends S.Literal("web_search_tool_result") {}
+
+export class ResponseWebSearchToolResultBlock extends S.Struct({
+  "content": S.Union(ResponseWebSearchToolResultError, S.Array(ResponseWebSearchResultBlock)),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "type": ResponseWebSearchToolResultBlockType
 }) {}
 
 export class ResponseThinkingBlockType extends S.Literal("thinking") {}
 
 export class ResponseThinkingBlock extends S.Struct({
-  "type": ResponseThinkingBlockType.pipe(S.propertySignature, S.withConstructorDefault(() => "thinking" as const)),
+  "signature": S.String,
   "thinking": S.String,
-  "signature": S.String
+  "type": ResponseThinkingBlockType
 }) {}
 
 export class ResponseRedactedThinkingBlockType extends S.Literal("redacted_thinking") {}
 
 export class ResponseRedactedThinkingBlock extends S.Struct({
-  "type": ResponseRedactedThinkingBlockType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "redacted_thinking" as const)
-  ),
-  "data": S.String
+  "data": S.String,
+  "type": ResponseRedactedThinkingBlockType
 }) {}
 
-export class ContentBlock
-  extends S.Union(ResponseTextBlock, ResponseToolUseBlock, ResponseThinkingBlock, ResponseRedactedThinkingBlock)
+export class ContentBlock extends S.Union(
+  ResponseTextBlock,
+  ResponseToolUseBlock,
+  ResponseServerToolUseBlock,
+  ResponseWebSearchToolResultBlock,
+  ResponseThinkingBlock,
+  ResponseRedactedThinkingBlock
+) {}
+
+export class StopReason
+  extends S.Literal("end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal")
 {}
 
-export class MessageStopReasonEnum extends S.Literal("end_turn", "max_tokens", "stop_sequence", "tool_use") {}
+export class ServerToolUsage extends S.Struct({
+  "web_search_requests": S.Int.pipe(S.greaterThanOrEqualTo(0))
+}) {}
+
+export class UsageServiceTierEnum extends S.Literal("standard", "priority", "batch") {}
 
 export class Usage extends S.Struct({
+  "cache_creation_input_tokens": S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)),
+  "cache_read_input_tokens": S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)),
   "input_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "cache_creation_input_tokens": S.optionalWith(S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)), {
-    default: () => null
-  }),
-  "cache_read_input_tokens": S.optionalWith(S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)), {
-    default: () => null
-  }),
-  "output_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0))
+  "output_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0)),
+  "server_tool_use": S.NullOr(S.Union(ServerToolUsage, S.Null)),
+  "service_tier": S.NullOr(S.Union(UsageServiceTierEnum, S.Null))
 }) {}
 
 export class Message extends S.Class<Message>("Message")({
   "id": S.String,
-  "type": MessageType.pipe(S.propertySignature, S.withConstructorDefault(() => "message" as const)),
-  "role": MessageRole.pipe(S.propertySignature, S.withConstructorDefault(() => "assistant" as const)),
+  "type": MessageType,
+  "role": MessageRole,
   "content": S.Array(ContentBlock),
-  "model": Model,
-  "stop_reason": S.Union(MessageStopReasonEnum, S.Null),
-  "stop_sequence": S.optionalWith(S.NullOr(S.Union(S.String, S.Null)), { default: () => null }),
+  "model": S.Union(S.String, Model),
+  "stop_reason": S.Union(StopReason, S.Null),
+  "stop_sequence": S.NullOr(S.Union(S.String, S.Null)),
   "usage": Usage
 }) {}
 
-export class ErrorResponseType extends S.Literal("error") {}
-
 export class InvalidRequestErrorType extends S.Literal("invalid_request_error") {}
 
 export class InvalidRequestError extends S.Struct({
-  "type": InvalidRequestErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "invalid_request_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Invalid request" as const))
+  "message": S.String,
+  "type": InvalidRequestErrorType
 }) {}
 
 export class AuthenticationErrorType extends S.Literal("authentication_error") {}
 
 export class AuthenticationError extends S.Struct({
-  "type": AuthenticationErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "authentication_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Authentication error" as const))
+  "message": S.String,
+  "type": AuthenticationErrorType
 }) {}
 
 export class BillingErrorType extends S.Literal("billing_error") {}
 
 export class BillingError extends S.Struct({
-  "type": BillingErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "billing_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Billing error" as const))
+  "message": S.String,
+  "type": BillingErrorType
 }) {}
 
 export class PermissionErrorType extends S.Literal("permission_error") {}
 
 export class PermissionError extends S.Struct({
-  "type": PermissionErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "permission_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Permission denied" as const))
+  "message": S.String,
+  "type": PermissionErrorType
 }) {}
 
 export class NotFoundErrorType extends S.Literal("not_found_error") {}
 
 export class NotFoundError extends S.Struct({
-  "type": NotFoundErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "not_found_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Not found" as const))
+  "message": S.String,
+  "type": NotFoundErrorType
 }) {}
 
 export class RateLimitErrorType extends S.Literal("rate_limit_error") {}
 
 export class RateLimitError extends S.Struct({
-  "type": RateLimitErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "rate_limit_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Rate limited" as const))
+  "message": S.String,
+  "type": RateLimitErrorType
 }) {}
 
 export class GatewayTimeoutErrorType extends S.Literal("timeout_error") {}
 
 export class GatewayTimeoutError extends S.Struct({
-  "type": GatewayTimeoutErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "timeout_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Request timeout" as const))
+  "message": S.String,
+  "type": GatewayTimeoutErrorType
 }) {}
 
 export class APIErrorType extends S.Literal("api_error") {}
 
 export class APIError extends S.Struct({
-  "type": APIErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "api_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Internal server error" as const))
+  "message": S.String,
+  "type": APIErrorType
 }) {}
 
 export class OverloadedErrorType extends S.Literal("overloaded_error") {}
 
 export class OverloadedError extends S.Struct({
-  "type": OverloadedErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "overloaded_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Overloaded" as const))
+  "message": S.String,
+  "type": OverloadedErrorType
 }) {}
 
+export class ErrorResponseType extends S.Literal("error") {}
+
 export class ErrorResponse extends S.Class<ErrorResponse>("ErrorResponse")({
-  "type": ErrorResponseType.pipe(S.propertySignature, S.withConstructorDefault(() => "error" as const)),
   "error": S.Union(
     InvalidRequestError,
     AuthenticationError,
@@ -513,15 +664,17 @@ export class ErrorResponse extends S.Class<ErrorResponse>("ErrorResponse")({
     GatewayTimeoutError,
     APIError,
     OverloadedError
-  )
+  ),
+  "type": ErrorResponseType
 }) {}
 
 export class CompletePostParams extends S.Struct({
-  "anthropic-version": S.optionalWith(S.String, { nullable: true })
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class CompletionRequest extends S.Class<CompletionRequest>("CompletionRequest")({
-  "model": Model,
+  "model": S.Union(S.String, Model),
   "prompt": S.String.pipe(S.minLength(1)),
   "max_tokens_to_sample": S.Int.pipe(S.greaterThanOrEqualTo(1)),
   "stop_sequences": S.optionalWith(S.Array(S.String), { nullable: true }),
@@ -535,85 +688,81 @@ export class CompletionRequest extends S.Class<CompletionRequest>("CompletionReq
 export class CompletionResponseType extends S.Literal("completion") {}
 
 export class CompletionResponse extends S.Class<CompletionResponse>("CompletionResponse")({
-  "type": CompletionResponseType.pipe(S.propertySignature, S.withConstructorDefault(() => "completion" as const)),
-  "id": S.String,
   "completion": S.String,
+  "id": S.String,
+  "model": S.Union(S.String, Model),
   "stop_reason": S.Union(S.String, S.Null),
-  "model": Model
+  "type": CompletionResponseType
 }) {}
 
 export class ModelsListParams extends S.Struct({
   "before_id": S.optionalWith(S.String, { nullable: true }),
   "after_id": S.optionalWith(S.String, { nullable: true }),
-  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), {
-    nullable: true,
-    default: () => 20 as const
-  }),
+  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), { nullable: true }),
   "anthropic-version": S.optionalWith(S.String, { nullable: true }),
-  "x-api-key": S.optionalWith(S.String, { nullable: true })
+  "x-api-key": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class ModelInfoType extends S.Literal("model") {}
 
 export class ModelInfo extends S.Struct({
-  "type": ModelInfoType.pipe(S.propertySignature, S.withConstructorDefault(() => "model" as const)),
-  "id": S.String,
+  "created_at": S.String,
   "display_name": S.String,
-  "created_at": S.String
+  "id": S.String,
+  "type": ModelInfoType
 }) {}
 
 export class ListResponseModelInfo extends S.Class<ListResponseModelInfo>("ListResponseModelInfo")({
   "data": S.Array(ModelInfo),
-  "has_more": S.Boolean,
   "first_id": S.Union(S.String, S.Null),
+  "has_more": S.Boolean,
   "last_id": S.Union(S.String, S.Null)
 }) {}
 
 export class ModelsGetParams extends S.Struct({
   "anthropic-version": S.optionalWith(S.String, { nullable: true }),
-  "x-api-key": S.optionalWith(S.String, { nullable: true })
+  "x-api-key": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class MessageBatchesListParams extends S.Struct({
   "before_id": S.optionalWith(S.String, { nullable: true }),
   "after_id": S.optionalWith(S.String, { nullable: true }),
-  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), {
-    nullable: true,
-    default: () => 20 as const
-  }),
+  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), { nullable: true }),
   "anthropic-version": S.optionalWith(S.String, { nullable: true }),
   "x-api-key": S.optionalWith(S.String, { nullable: true })
 }) {}
 
-export class MessageBatchType extends S.Literal("message_batch") {}
-
 export class MessageBatchProcessingStatus extends S.Literal("in_progress", "canceling", "ended") {}
 
 export class RequestCounts extends S.Struct({
-  "processing": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "succeeded": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "errored": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "canceled": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "expired": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const))
+  "canceled": S.Int,
+  "errored": S.Int,
+  "expired": S.Int,
+  "processing": S.Int,
+  "succeeded": S.Int
 }) {}
 
+export class MessageBatchType extends S.Literal("message_batch") {}
+
 export class MessageBatch extends S.Struct({
+  "archived_at": S.Union(S.String, S.Null),
+  "cancel_initiated_at": S.Union(S.String, S.Null),
+  "created_at": S.String,
+  "ended_at": S.Union(S.String, S.Null),
+  "expires_at": S.String,
   "id": S.String,
-  "type": MessageBatchType.pipe(S.propertySignature, S.withConstructorDefault(() => "message_batch" as const)),
   "processing_status": MessageBatchProcessingStatus,
   "request_counts": RequestCounts,
-  "ended_at": S.Union(S.String, S.Null),
-  "created_at": S.String,
-  "expires_at": S.String,
-  "archived_at": S.Union(S.String, S.Null),
-  "cancel_initiated_at": S.Union(S.String, S.Null),
-  "results_url": S.Union(S.String, S.Null)
+  "results_url": S.Union(S.String, S.Null),
+  "type": MessageBatchType
 }) {}
 
 export class ListResponseMessageBatch extends S.Class<ListResponseMessageBatch>("ListResponseMessageBatch")({
   "data": S.Array(MessageBatch),
-  "has_more": S.Boolean,
   "first_id": S.Union(S.String, S.Null),
+  "has_more": S.Boolean,
   "last_id": S.Union(S.String, S.Null)
 }) {}
 
@@ -644,10 +793,7 @@ export class DeleteMessageBatchResponseType extends S.Literal("message_batch_del
 
 export class DeleteMessageBatchResponse extends S.Class<DeleteMessageBatchResponse>("DeleteMessageBatchResponse")({
   "id": S.String,
-  "type": DeleteMessageBatchResponseType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "message_batch_deleted" as const)
-  )
+  "type": DeleteMessageBatchResponseType
 }) {}
 
 export class MessageBatchesCancelParams extends S.Struct({
@@ -664,62 +810,224 @@ export class MessagesCountTokensPostParams extends S.Struct({
 }) {}
 
 export class CountMessageTokensParams extends S.Class<CountMessageTokensParams>("CountMessageTokensParams")({
-  "tool_choice": S.optionalWith(ToolChoice, { nullable: true }),
-  "tools": S.optionalWith(S.Array(S.Union(Tool, BashTool20250124, TextEditor20250124)), { nullable: true }),
   "messages": S.Array(InputMessage),
+  "model": S.Union(S.String, Model),
   "system": S.optionalWith(S.Union(S.String, S.Array(RequestTextBlock)), { nullable: true }),
   "thinking": S.optionalWith(ThinkingConfigParam, { nullable: true }),
-  "model": Model
+  "tool_choice": S.optionalWith(ToolChoice, { nullable: true }),
+  "tools": S.optionalWith(
+    S.Array(S.Union(Tool, BashTool20250124, TextEditor20250124, TextEditor20250429, WebSearchTool20250305)),
+    { nullable: true }
+  )
 }) {}
 
 export class CountMessageTokensResponse extends S.Class<CountMessageTokensResponse>("CountMessageTokensResponse")({
   "input_tokens": S.Int
 }) {}
 
+export class ListFilesV1FilesGetParams extends S.Struct({
+  "before_id": S.optionalWith(S.String, { nullable: true }),
+  "after_id": S.optionalWith(S.String, { nullable: true }),
+  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class FileMetadataSchemaType extends S.Literal("file") {}
+
+export class FileMetadataSchema extends S.Struct({
+  "created_at": S.String,
+  "downloadable": S.optionalWith(S.Boolean, { nullable: true }),
+  "filename": S.String.pipe(S.minLength(1), S.maxLength(500)),
+  "id": S.String,
+  "mime_type": S.String.pipe(S.minLength(1), S.maxLength(255)),
+  "size_bytes": S.Int.pipe(S.greaterThanOrEqualTo(0)),
+  "type": FileMetadataSchemaType
+}) {}
+
+export class FileListResponse extends S.Class<FileListResponse>("FileListResponse")({
+  "data": S.Array(FileMetadataSchema),
+  "first_id": S.optionalWith(S.Union(S.String, S.Null), { nullable: true }),
+  "has_more": S.optionalWith(S.Boolean, { nullable: true }),
+  "last_id": S.optionalWith(S.Union(S.String, S.Null), { nullable: true })
+}) {}
+
+export class UploadFileV1FilesPostParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class GetFileMetadataV1FilesFileIdGetParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class DeleteFileV1FilesFileIdDeleteParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class FileDeleteResponseType extends S.Literal("file_deleted") {}
+
+export class FileDeleteResponse extends S.Class<FileDeleteResponse>("FileDeleteResponse")({
+  "id": S.String,
+  "type": S.optionalWith(FileDeleteResponseType, { nullable: true })
+}) {}
+
+export class DownloadFileV1FilesFileIdContentGetParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
 export class BetaMessagesPostParams extends S.Struct({
   "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
   "anthropic-version": S.optionalWith(S.String, { nullable: true })
 }) {}
 
-export class BetaInputMessageRole extends S.Literal("user", "assistant") {}
+export class BetaCacheControlEphemeralTtl extends S.Literal("5m", "1h") {}
 
 export class BetaCacheControlEphemeralType extends S.Literal("ephemeral") {}
 
 export class BetaCacheControlEphemeral extends S.Struct({
+  "ttl": S.optionalWith(BetaCacheControlEphemeralTtl, { nullable: true }),
   "type": BetaCacheControlEphemeralType
 }) {}
 
+export class BetaRequestServerToolUseBlockName extends S.Literal("web_search", "code_execution") {}
+
+export class BetaRequestServerToolUseBlockType extends S.Literal("server_tool_use") {}
+
+export class BetaRequestServerToolUseBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": BetaRequestServerToolUseBlockName,
+  "type": BetaRequestServerToolUseBlockType
+}) {}
+
+export class BetaRequestWebSearchResultBlockType extends S.Literal("web_search_result") {}
+
+export class BetaRequestWebSearchResultBlock extends S.Struct({
+  "encrypted_content": S.String,
+  "page_age": S.optionalWith(S.Union(S.String, S.Null), { nullable: true }),
+  "title": S.String,
+  "type": BetaRequestWebSearchResultBlockType,
+  "url": S.String
+}) {}
+
+export class BetaWebSearchToolResultErrorCode
+  extends S.Literal("invalid_tool_input", "unavailable", "max_uses_exceeded", "too_many_requests", "query_too_long")
+{}
+
+export class BetaRequestWebSearchToolResultErrorType extends S.Literal("web_search_tool_result_error") {}
+
+export class BetaRequestWebSearchToolResultError extends S.Struct({
+  "error_code": BetaWebSearchToolResultErrorCode,
+  "type": BetaRequestWebSearchToolResultErrorType
+}) {}
+
+export class BetaRequestWebSearchToolResultBlockType extends S.Literal("web_search_tool_result") {}
+
+export class BetaRequestWebSearchToolResultBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "content": S.Union(S.Array(BetaRequestWebSearchResultBlock), BetaRequestWebSearchToolResultError),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "type": BetaRequestWebSearchToolResultBlockType
+}) {}
+
+export class BetaCodeExecutionToolResultErrorCode
+  extends S.Literal("invalid_tool_input", "unavailable", "too_many_requests", "execution_time_exceeded")
+{}
+
+export class BetaRequestCodeExecutionToolResultErrorType extends S.Literal("code_execution_tool_result_error") {}
+
+export class BetaRequestCodeExecutionToolResultError extends S.Struct({
+  "error_code": BetaCodeExecutionToolResultErrorCode,
+  "type": BetaRequestCodeExecutionToolResultErrorType
+}) {}
+
+export class BetaRequestCodeExecutionOutputBlockType extends S.Literal("code_execution_output") {}
+
+export class BetaRequestCodeExecutionOutputBlock extends S.Struct({
+  "file_id": S.String,
+  "type": BetaRequestCodeExecutionOutputBlockType
+}) {}
+
+export class BetaRequestCodeExecutionResultBlockType extends S.Literal("code_execution_result") {}
+
+export class BetaRequestCodeExecutionResultBlock extends S.Struct({
+  "content": S.Array(BetaRequestCodeExecutionOutputBlock),
+  "return_code": S.Int,
+  "stderr": S.String,
+  "stdout": S.String,
+  "type": BetaRequestCodeExecutionResultBlockType
+}) {}
+
+export class BetaRequestCodeExecutionToolResultBlockType extends S.Literal("code_execution_tool_result") {}
+
+export class BetaRequestCodeExecutionToolResultBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "content": S.Union(BetaRequestCodeExecutionToolResultError, BetaRequestCodeExecutionResultBlock),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "type": BetaRequestCodeExecutionToolResultBlockType
+}) {}
+
+export class BetaRequestMCPToolUseBlockType extends S.Literal("mcp_tool_use") {}
+
+export class BetaRequestMCPToolUseBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": S.String,
+  "server_name": S.String,
+  "type": BetaRequestMCPToolUseBlockType
+}) {}
+
 export class BetaRequestCharLocationCitationType extends S.Literal("char_location") {}
 
 export class BetaRequestCharLocationCitation extends S.Struct({
-  "type": BetaRequestCharLocationCitationType,
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "end_char_index": S.Int,
   "start_char_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_char_index": S.Int
+  "type": BetaRequestCharLocationCitationType
 }) {}
 
 export class BetaRequestPageLocationCitationType extends S.Literal("page_location") {}
 
 export class BetaRequestPageLocationCitation extends S.Struct({
-  "type": BetaRequestPageLocationCitationType,
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "end_page_number": S.Int,
   "start_page_number": S.Int.pipe(S.greaterThanOrEqualTo(1)),
-  "end_page_number": S.Int
+  "type": BetaRequestPageLocationCitationType
 }) {}
 
 export class BetaRequestContentBlockLocationCitationType extends S.Literal("content_block_location") {}
 
 export class BetaRequestContentBlockLocationCitation extends S.Struct({
-  "type": BetaRequestContentBlockLocationCitationType,
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "end_block_index": S.Int,
   "start_block_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_block_index": S.Int
+  "type": BetaRequestContentBlockLocationCitationType
+}) {}
+
+export class BetaRequestWebSearchResultLocationCitationType extends S.Literal("web_search_result_location") {}
+
+export class BetaRequestWebSearchResultLocationCitation extends S.Struct({
+  "cited_text": S.String,
+  "encrypted_index": S.String,
+  "title": S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null),
+  "type": BetaRequestWebSearchResultLocationCitationType,
+  "url": S.String.pipe(S.minLength(1), S.maxLength(2048))
 }) {}
 
 export class BetaRequestTextBlockType extends S.Literal("text") {}
@@ -732,7 +1040,8 @@ export class BetaRequestTextBlock extends S.Struct({
         S.Union(
           BetaRequestCharLocationCitation,
           BetaRequestPageLocationCitation,
-          BetaRequestContentBlockLocationCitation
+          BetaRequestContentBlockLocationCitation,
+          BetaRequestWebSearchResultLocationCitation
         )
       ),
       S.Null
@@ -743,16 +1052,24 @@ export class BetaRequestTextBlock extends S.Struct({
   "type": BetaRequestTextBlockType
 }) {}
 
-export class BetaRequestImageBlockType extends S.Literal("image") {}
+export class BetaRequestMCPToolResultBlockType extends S.Literal("mcp_tool_result") {}
 
-export class BetaBase64ImageSourceType extends S.Literal("base64") {}
+export class BetaRequestMCPToolResultBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "content": S.optionalWith(S.Union(S.String, S.Array(BetaRequestTextBlock)), { nullable: true }),
+  "is_error": S.optionalWith(S.Boolean, { nullable: true }),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "type": BetaRequestMCPToolResultBlockType
+}) {}
 
 export class BetaBase64ImageSourceMediaType extends S.Literal("image/jpeg", "image/png", "image/gif", "image/webp") {}
 
+export class BetaBase64ImageSourceType extends S.Literal("base64") {}
+
 export class BetaBase64ImageSource extends S.Struct({
-  "type": BetaBase64ImageSourceType,
+  "data": S.String,
   "media_type": BetaBase64ImageSourceMediaType,
-  "data": S.String
+  "type": BetaBase64ImageSourceType
 }) {}
 
 export class BetaURLImageSourceType extends S.Literal("url") {}
@@ -762,61 +1079,72 @@ export class BetaURLImageSource extends S.Struct({
   "url": S.String
 }) {}
 
+export class BetaFileImageSourceType extends S.Literal("file") {}
+
+export class BetaFileImageSource extends S.Struct({
+  "file_id": S.String,
+  "type": BetaFileImageSourceType
+}) {}
+
+export class BetaRequestImageBlockType extends S.Literal("image") {}
+
 export class BetaRequestImageBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaRequestImageBlockType,
-  "source": S.Union(BetaBase64ImageSource, BetaURLImageSource)
+  "source": S.Union(BetaBase64ImageSource, BetaURLImageSource, BetaFileImageSource),
+  "type": BetaRequestImageBlockType
 }) {}
 
 export class BetaRequestToolUseBlockType extends S.Literal("tool_use") {}
 
 export class BetaRequestToolUseBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaRequestToolUseBlockType,
   "id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
-  "name": S.String.pipe(S.minLength(1), S.maxLength(64), S.pattern(new RegExp("^[a-zA-Z0-9_-]{1,64}$"))),
-  "input": S.Record({ key: S.String, value: S.Unknown })
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": S.String.pipe(S.minLength(1), S.maxLength(200)),
+  "type": BetaRequestToolUseBlockType
 }) {}
 
 export class BetaRequestToolResultBlockType extends S.Literal("tool_result") {}
 
 export class BetaRequestToolResultBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaRequestToolResultBlockType,
-  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
-  "is_error": S.optionalWith(S.Boolean, { nullable: true }),
   "content": S.optionalWith(S.Union(S.String, S.Array(S.Union(BetaRequestTextBlock, BetaRequestImageBlock))), {
     nullable: true
-  })
+  }),
+  "is_error": S.optionalWith(S.Boolean, { nullable: true }),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "type": BetaRequestToolResultBlockType
 }) {}
 
-export class BetaRequestDocumentBlockType extends S.Literal("document") {}
-
-export class BetaBase64PDFSourceType extends S.Literal("base64") {}
+export class BetaRequestCitationsConfig extends S.Struct({
+  "enabled": S.optionalWith(S.Boolean, { nullable: true })
+}) {}
 
 export class BetaBase64PDFSourceMediaType extends S.Literal("application/pdf") {}
 
+export class BetaBase64PDFSourceType extends S.Literal("base64") {}
+
 export class BetaBase64PDFSource extends S.Struct({
-  "type": BetaBase64PDFSourceType,
+  "data": S.String,
   "media_type": BetaBase64PDFSourceMediaType,
-  "data": S.String
+  "type": BetaBase64PDFSourceType
 }) {}
 
-export class BetaPlainTextSourceType extends S.Literal("text") {}
-
 export class BetaPlainTextSourceMediaType extends S.Literal("text/plain") {}
 
+export class BetaPlainTextSourceType extends S.Literal("text") {}
+
 export class BetaPlainTextSource extends S.Struct({
-  "type": BetaPlainTextSourceType,
+  "data": S.String,
   "media_type": BetaPlainTextSourceMediaType,
-  "data": S.String
+  "type": BetaPlainTextSourceType
 }) {}
 
 export class BetaContentBlockSourceType extends S.Literal("content") {}
 
 export class BetaContentBlockSource extends S.Struct({
-  "type": BetaContentBlockSourceType,
-  "content": S.Union(S.String, S.Array(S.Union(BetaRequestTextBlock, BetaRequestImageBlock)))
+  "content": S.Union(S.String, S.Array(S.Union(BetaRequestTextBlock, BetaRequestImageBlock))),
+  "type": BetaContentBlockSourceType
 }) {}
 
 export class BetaURLPDFSourceType extends S.Literal("url") {}
@@ -826,58 +1154,102 @@ export class BetaURLPDFSource extends S.Struct({
   "url": S.String
 }) {}
 
-export class BetaRequestCitationsConfig extends S.Struct({
-  "enabled": S.optionalWith(S.Boolean, { nullable: true })
+export class BetaFileDocumentSourceType extends S.Literal("file") {}
+
+export class BetaFileDocumentSource extends S.Struct({
+  "file_id": S.String,
+  "type": BetaFileDocumentSourceType
 }) {}
 
+export class BetaRequestDocumentBlockType extends S.Literal("document") {}
+
 export class BetaRequestDocumentBlock extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaRequestDocumentBlockType,
-  "source": S.Union(BetaBase64PDFSource, BetaPlainTextSource, BetaContentBlockSource, BetaURLPDFSource),
-  "title": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(500)), S.Null), { nullable: true }),
+  "citations": S.optionalWith(BetaRequestCitationsConfig, { nullable: true }),
   "context": S.optionalWith(S.Union(S.String.pipe(S.minLength(1)), S.Null), { nullable: true }),
-  "citations": S.optionalWith(BetaRequestCitationsConfig, { nullable: true })
+  "source": S.Union(
+    BetaBase64PDFSource,
+    BetaPlainTextSource,
+    BetaContentBlockSource,
+    BetaURLPDFSource,
+    BetaFileDocumentSource
+  ),
+  "title": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(500)), S.Null), { nullable: true }),
+  "type": BetaRequestDocumentBlockType
 }) {}
 
 export class BetaRequestThinkingBlockType extends S.Literal("thinking") {}
 
 export class BetaRequestThinkingBlock extends S.Struct({
-  "type": BetaRequestThinkingBlockType,
+  "signature": S.String,
   "thinking": S.String,
-  "signature": S.String
+  "type": BetaRequestThinkingBlockType
 }) {}
 
 export class BetaRequestRedactedThinkingBlockType extends S.Literal("redacted_thinking") {}
 
 export class BetaRequestRedactedThinkingBlock extends S.Struct({
-  "type": BetaRequestRedactedThinkingBlockType,
-  "data": S.String
+  "data": S.String,
+  "type": BetaRequestRedactedThinkingBlockType
+}) {}
+
+export class BetaRequestContainerUploadBlockType extends S.Literal("container_upload") {}
+
+export class BetaRequestContainerUploadBlock extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "file_id": S.String,
+  "type": BetaRequestContainerUploadBlockType
 }) {}
 
 export class BetaInputContentBlock extends S.Union(
+  BetaRequestServerToolUseBlock,
+  BetaRequestWebSearchToolResultBlock,
+  BetaRequestCodeExecutionToolResultBlock,
+  BetaRequestMCPToolUseBlock,
+  BetaRequestMCPToolResultBlock,
   BetaRequestTextBlock,
   BetaRequestImageBlock,
   BetaRequestToolUseBlock,
   BetaRequestToolResultBlock,
   BetaRequestDocumentBlock,
   BetaRequestThinkingBlock,
-  BetaRequestRedactedThinkingBlock
+  BetaRequestRedactedThinkingBlock,
+  BetaRequestContainerUploadBlock
 ) {}
 
+export class BetaInputMessageRole extends S.Literal("user", "assistant") {}
+
 export class BetaInputMessage extends S.Struct({
-  "role": BetaInputMessageRole,
-  "content": S.Union(S.String, S.Array(BetaInputContentBlock))
+  "content": S.Union(S.String, S.Array(BetaInputContentBlock)),
+  "role": BetaInputMessageRole
+}) {}
+
+export class BetaRequestMCPServerToolConfiguration extends S.Struct({
+  "allowed_tools": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "enabled": S.optionalWith(S.Union(S.Boolean, S.Null), { nullable: true })
+}) {}
+
+export class BetaRequestMCPServerURLDefinitionType extends S.Literal("url") {}
+
+export class BetaRequestMCPServerURLDefinition extends S.Struct({
+  "authorization_token": S.optionalWith(S.Union(S.String, S.Null), { nullable: true }),
+  "name": S.String,
+  "tool_configuration": S.optionalWith(S.Union(BetaRequestMCPServerToolConfiguration, S.Null), { nullable: true }),
+  "type": BetaRequestMCPServerURLDefinitionType,
+  "url": S.String
 }) {}
 
 export class BetaMetadata extends S.Struct({
   "user_id": S.optionalWith(S.Union(S.String.pipe(S.maxLength(256)), S.Null), { nullable: true })
 }) {}
 
+export class BetaCreateMessageParamsServiceTier extends S.Literal("auto", "standard_only") {}
+
 export class BetaThinkingConfigEnabledType extends S.Literal("enabled") {}
 
 export class BetaThinkingConfigEnabled extends S.Struct({
-  "type": BetaThinkingConfigEnabledType,
-  "budget_tokens": S.Int.pipe(S.greaterThanOrEqualTo(1024))
+  "budget_tokens": S.Int.pipe(S.greaterThanOrEqualTo(1024)),
+  "type": BetaThinkingConfigEnabledType
 }) {}
 
 export class BetaThinkingConfigDisabledType extends S.Literal("disabled") {}
@@ -891,23 +1263,23 @@ export class BetaThinkingConfigParam extends S.Union(BetaThinkingConfigEnabled,
 export class BetaToolChoiceAutoType extends S.Literal("auto") {}
 
 export class BetaToolChoiceAuto extends S.Struct({
-  "type": BetaToolChoiceAutoType,
-  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true })
+  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true }),
+  "type": BetaToolChoiceAutoType
 }) {}
 
 export class BetaToolChoiceAnyType extends S.Literal("any") {}
 
 export class BetaToolChoiceAny extends S.Struct({
-  "type": BetaToolChoiceAnyType,
-  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true })
+  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true }),
+  "type": BetaToolChoiceAnyType
 }) {}
 
 export class BetaToolChoiceToolType extends S.Literal("tool") {}
 
 export class BetaToolChoiceTool extends S.Struct({
-  "type": BetaToolChoiceToolType,
+  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true }),
   "name": S.String,
-  "disable_parallel_tool_use": S.optionalWith(S.Boolean, { nullable: true })
+  "type": BetaToolChoiceToolType
 }) {}
 
 export class BetaToolChoiceNoneType extends S.Literal("none") {}
@@ -925,8 +1297,9 @@ export class BetaToolTypeEnum extends S.Literal("custom") {}
 export class BetaInputSchemaType extends S.Literal("object") {}
 
 export class BetaInputSchema extends S.Struct({
-  "type": BetaInputSchemaType,
-  "properties": S.optionalWith(S.Union(S.Record({ key: S.String, value: S.Unknown }), S.Null), { nullable: true })
+  "properties": S.optionalWith(S.Union(S.Record({ key: S.String, value: S.Unknown }), S.Null), { nullable: true }),
+  "required": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "type": BetaInputSchemaType
 }) {}
 
 export class BetaTool extends S.Struct({
@@ -937,77 +1310,124 @@ export class BetaTool extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true })
 }) {}
 
-export class BetaComputerUseTool20241022Type extends S.Literal("computer_20241022") {}
-
 export class BetaComputerUseTool20241022Name extends S.Literal("computer") {}
 
+export class BetaComputerUseTool20241022Type extends S.Literal("computer_20241022") {}
+
 export class BetaComputerUseTool20241022 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaComputerUseTool20241022Type,
-  "name": BetaComputerUseTool20241022Name,
   "display_height_px": S.Int.pipe(S.greaterThanOrEqualTo(1)),
+  "display_number": S.optionalWith(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null), { nullable: true }),
   "display_width_px": S.Int.pipe(S.greaterThanOrEqualTo(1)),
-  "display_number": S.optionalWith(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null), { nullable: true })
+  "name": BetaComputerUseTool20241022Name,
+  "type": BetaComputerUseTool20241022Type
 }) {}
 
-export class BetaBashTool20241022Type extends S.Literal("bash_20241022") {}
-
 export class BetaBashTool20241022Name extends S.Literal("bash") {}
 
+export class BetaBashTool20241022Type extends S.Literal("bash_20241022") {}
+
 export class BetaBashTool20241022 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaBashTool20241022Type,
-  "name": BetaBashTool20241022Name
+  "name": BetaBashTool20241022Name,
+  "type": BetaBashTool20241022Type
 }) {}
 
-export class BetaTextEditor20241022Type extends S.Literal("text_editor_20241022") {}
-
 export class BetaTextEditor20241022Name extends S.Literal("str_replace_editor") {}
 
+export class BetaTextEditor20241022Type extends S.Literal("text_editor_20241022") {}
+
 export class BetaTextEditor20241022 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaTextEditor20241022Type,
-  "name": BetaTextEditor20241022Name
+  "name": BetaTextEditor20241022Name,
+  "type": BetaTextEditor20241022Type
 }) {}
 
-export class BetaComputerUseTool20250124Type extends S.Literal("computer_20250124") {}
-
 export class BetaComputerUseTool20250124Name extends S.Literal("computer") {}
 
+export class BetaComputerUseTool20250124Type extends S.Literal("computer_20250124") {}
+
 export class BetaComputerUseTool20250124 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaComputerUseTool20250124Type,
-  "name": BetaComputerUseTool20250124Name,
   "display_height_px": S.Int.pipe(S.greaterThanOrEqualTo(1)),
+  "display_number": S.optionalWith(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null), { nullable: true }),
   "display_width_px": S.Int.pipe(S.greaterThanOrEqualTo(1)),
-  "display_number": S.optionalWith(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null), { nullable: true })
+  "name": BetaComputerUseTool20250124Name,
+  "type": BetaComputerUseTool20250124Type
 }) {}
 
-export class BetaBashTool20250124Type extends S.Literal("bash_20250124") {}
-
 export class BetaBashTool20250124Name extends S.Literal("bash") {}
 
+export class BetaBashTool20250124Type extends S.Literal("bash_20250124") {}
+
 export class BetaBashTool20250124 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaBashTool20250124Type,
-  "name": BetaBashTool20250124Name
+  "name": BetaBashTool20250124Name,
+  "type": BetaBashTool20250124Type
 }) {}
 
-export class BetaTextEditor20250124Type extends S.Literal("text_editor_20250124") {}
-
 export class BetaTextEditor20250124Name extends S.Literal("str_replace_editor") {}
 
+export class BetaTextEditor20250124Type extends S.Literal("text_editor_20250124") {}
+
 export class BetaTextEditor20250124 extends S.Struct({
   "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
-  "type": BetaTextEditor20250124Type,
-  "name": BetaTextEditor20250124Name
+  "name": BetaTextEditor20250124Name,
+  "type": BetaTextEditor20250124Type
+}) {}
+
+export class BetaTextEditor20250429Name extends S.Literal("str_replace_based_edit_tool") {}
+
+export class BetaTextEditor20250429Type extends S.Literal("text_editor_20250429") {}
+
+export class BetaTextEditor20250429 extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "name": BetaTextEditor20250429Name,
+  "type": BetaTextEditor20250429Type
+}) {}
+
+export class BetaWebSearchTool20250305Name extends S.Literal("web_search") {}
+
+export class BetaWebSearchTool20250305Type extends S.Literal("web_search_20250305") {}
+
+export class BetaUserLocationType extends S.Literal("approximate") {}
+
+export class BetaUserLocation extends S.Struct({
+  "city": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null), { nullable: true }),
+  "country": S.optionalWith(S.Union(S.String.pipe(S.minLength(2), S.maxLength(2)), S.Null), { nullable: true }),
+  "region": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null), { nullable: true }),
+  "timezone": S.optionalWith(S.Union(S.String.pipe(S.minLength(1), S.maxLength(255)), S.Null), { nullable: true }),
+  "type": BetaUserLocationType
+}) {}
+
+export class BetaWebSearchTool20250305 extends S.Struct({
+  "allowed_domains": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "blocked_domains": S.optionalWith(S.Union(S.Array(S.String), S.Null), { nullable: true }),
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "max_uses": S.optionalWith(S.Union(S.Int.pipe(S.greaterThan(0)), S.Null), { nullable: true }),
+  "name": BetaWebSearchTool20250305Name,
+  "type": BetaWebSearchTool20250305Type,
+  "user_location": S.optionalWith(S.Union(BetaUserLocation, S.Null), { nullable: true })
+}) {}
+
+export class BetaCodeExecutionTool20250522Name extends S.Literal("code_execution") {}
+
+export class BetaCodeExecutionTool20250522Type extends S.Literal("code_execution_20250522") {}
+
+export class BetaCodeExecutionTool20250522 extends S.Struct({
+  "cache_control": S.optionalWith(S.Union(BetaCacheControlEphemeral, S.Null), { nullable: true }),
+  "name": BetaCodeExecutionTool20250522Name,
+  "type": BetaCodeExecutionTool20250522Type
 }) {}
 
 export class BetaCreateMessageParams extends S.Class<BetaCreateMessageParams>("BetaCreateMessageParams")({
-  "model": Model,
+  "model": S.Union(S.String, Model),
   "messages": S.Array(BetaInputMessage),
+  "container": S.optionalWith(S.Union(S.String, S.Null), { nullable: true }),
   "max_tokens": S.Int.pipe(S.greaterThanOrEqualTo(1)),
+  "mcp_servers": S.optionalWith(S.Array(BetaRequestMCPServerURLDefinition).pipe(S.maxItems(20)), { nullable: true }),
   "metadata": S.optionalWith(BetaMetadata, { nullable: true }),
+  "service_tier": S.optionalWith(BetaCreateMessageParamsServiceTier, { nullable: true }),
   "stop_sequences": S.optionalWith(S.Array(S.String), { nullable: true }),
   "stream": S.optionalWith(S.Boolean, { nullable: true }),
   "system": S.optionalWith(S.Union(S.String, S.Array(BetaRequestTextBlock)), { nullable: true }),
@@ -1023,7 +1443,10 @@ export class BetaCreateMessageParams extends S.Class<BetaCreateMessageParams>("B
         BetaTextEditor20241022,
         BetaComputerUseTool20250124,
         BetaBashTool20250124,
-        BetaTextEditor20250124
+        BetaTextEditor20250124,
+        BetaTextEditor20250429,
+        BetaWebSearchTool20250305,
+        BetaCodeExecutionTool20250522
       )
     ),
     { nullable: true }
@@ -1036,210 +1459,308 @@ export class BetaMessageType extends S.Literal("message") {}
 
 export class BetaMessageRole extends S.Literal("assistant") {}
 
-export class BetaResponseTextBlockType extends S.Literal("text") {}
-
 export class BetaResponseCharLocationCitationType extends S.Literal("char_location") {}
 
 export class BetaResponseCharLocationCitation extends S.Struct({
-  "type": BetaResponseCharLocationCitationType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "char_location" as const)
-  ),
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String, S.Null),
+  "end_char_index": S.Int,
   "start_char_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_char_index": S.Int
+  "type": BetaResponseCharLocationCitationType
 }) {}
 
 export class BetaResponsePageLocationCitationType extends S.Literal("page_location") {}
 
 export class BetaResponsePageLocationCitation extends S.Struct({
-  "type": BetaResponsePageLocationCitationType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "page_location" as const)
-  ),
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String, S.Null),
+  "end_page_number": S.Int,
   "start_page_number": S.Int.pipe(S.greaterThanOrEqualTo(1)),
-  "end_page_number": S.Int
+  "type": BetaResponsePageLocationCitationType
 }) {}
 
 export class BetaResponseContentBlockLocationCitationType extends S.Literal("content_block_location") {}
 
 export class BetaResponseContentBlockLocationCitation extends S.Struct({
-  "type": BetaResponseContentBlockLocationCitationType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "content_block_location" as const)
-  ),
   "cited_text": S.String,
   "document_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
   "document_title": S.Union(S.String, S.Null),
+  "end_block_index": S.Int,
   "start_block_index": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "end_block_index": S.Int
+  "type": BetaResponseContentBlockLocationCitationType
 }) {}
 
+export class BetaResponseWebSearchResultLocationCitationType extends S.Literal("web_search_result_location") {}
+
+export class BetaResponseWebSearchResultLocationCitation extends S.Struct({
+  "cited_text": S.String,
+  "encrypted_index": S.String,
+  "title": S.Union(S.String, S.Null),
+  "type": BetaResponseWebSearchResultLocationCitationType,
+  "url": S.String
+}) {}
+
+export class BetaResponseTextBlockType extends S.Literal("text") {}
+
 export class BetaResponseTextBlock extends S.Struct({
-  "type": BetaResponseTextBlockType.pipe(S.propertySignature, S.withConstructorDefault(() => "text" as const)),
+  "citations": S.NullOr(
+    S.Union(
+      S.Array(
+        S.Union(
+          BetaResponseCharLocationCitation,
+          BetaResponsePageLocationCitation,
+          BetaResponseContentBlockLocationCitation,
+          BetaResponseWebSearchResultLocationCitation
+        )
+      ),
+      S.Null
+    )
+  ),
   "text": S.String.pipe(S.minLength(0), S.maxLength(5000000)),
-  "citations": S.optionalWith(
-    S.NullOr(
-      S.Union(
-        S.Array(
-          S.Union(
-            BetaResponseCharLocationCitation,
-            BetaResponsePageLocationCitation,
-            BetaResponseContentBlockLocationCitation
-          )
-        ),
-        S.Null
-      )
-    ),
-    { default: () => null }
-  )
+  "type": BetaResponseTextBlockType
 }) {}
 
 export class BetaResponseToolUseBlockType extends S.Literal("tool_use") {}
 
 export class BetaResponseToolUseBlock extends S.Struct({
-  "type": BetaResponseToolUseBlockType.pipe(S.propertySignature, S.withConstructorDefault(() => "tool_use" as const)),
   "id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
   "name": S.String.pipe(S.minLength(1)),
-  "input": S.Record({ key: S.String, value: S.Unknown })
+  "type": BetaResponseToolUseBlockType
+}) {}
+
+export class BetaResponseServerToolUseBlockName extends S.Literal("web_search", "code_execution") {}
+
+export class BetaResponseServerToolUseBlockType extends S.Literal("server_tool_use") {}
+
+export class BetaResponseServerToolUseBlock extends S.Struct({
+  "id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": BetaResponseServerToolUseBlockName,
+  "type": BetaResponseServerToolUseBlockType
+}) {}
+
+export class BetaResponseWebSearchToolResultErrorType extends S.Literal("web_search_tool_result_error") {}
+
+export class BetaResponseWebSearchToolResultError extends S.Struct({
+  "error_code": BetaWebSearchToolResultErrorCode,
+  "type": BetaResponseWebSearchToolResultErrorType
+}) {}
+
+export class BetaResponseWebSearchResultBlockType extends S.Literal("web_search_result") {}
+
+export class BetaResponseWebSearchResultBlock extends S.Struct({
+  "encrypted_content": S.String,
+  "page_age": S.NullOr(S.Union(S.String, S.Null)),
+  "title": S.String,
+  "type": BetaResponseWebSearchResultBlockType,
+  "url": S.String
+}) {}
+
+export class BetaResponseWebSearchToolResultBlockType extends S.Literal("web_search_tool_result") {}
+
+export class BetaResponseWebSearchToolResultBlock extends S.Struct({
+  "content": S.Union(BetaResponseWebSearchToolResultError, S.Array(BetaResponseWebSearchResultBlock)),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "type": BetaResponseWebSearchToolResultBlockType
+}) {}
+
+export class BetaResponseCodeExecutionToolResultErrorType extends S.Literal("code_execution_tool_result_error") {}
+
+export class BetaResponseCodeExecutionToolResultError extends S.Struct({
+  "error_code": BetaCodeExecutionToolResultErrorCode,
+  "type": BetaResponseCodeExecutionToolResultErrorType
+}) {}
+
+export class BetaResponseCodeExecutionOutputBlockType extends S.Literal("code_execution_output") {}
+
+export class BetaResponseCodeExecutionOutputBlock extends S.Struct({
+  "file_id": S.String,
+  "type": BetaResponseCodeExecutionOutputBlockType
+}) {}
+
+export class BetaResponseCodeExecutionResultBlockType extends S.Literal("code_execution_result") {}
+
+export class BetaResponseCodeExecutionResultBlock extends S.Struct({
+  "content": S.Array(BetaResponseCodeExecutionOutputBlock),
+  "return_code": S.Int,
+  "stderr": S.String,
+  "stdout": S.String,
+  "type": BetaResponseCodeExecutionResultBlockType
+}) {}
+
+export class BetaResponseCodeExecutionToolResultBlockType extends S.Literal("code_execution_tool_result") {}
+
+export class BetaResponseCodeExecutionToolResultBlock extends S.Struct({
+  "content": S.Union(BetaResponseCodeExecutionToolResultError, BetaResponseCodeExecutionResultBlock),
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^srvtoolu_[a-zA-Z0-9_]+$"))),
+  "type": BetaResponseCodeExecutionToolResultBlockType
+}) {}
+
+export class BetaResponseMCPToolUseBlockType extends S.Literal("mcp_tool_use") {}
+
+export class BetaResponseMCPToolUseBlock extends S.Struct({
+  "id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "input": S.Record({ key: S.String, value: S.Unknown }),
+  "name": S.String,
+  "server_name": S.String,
+  "type": BetaResponseMCPToolUseBlockType
+}) {}
+
+export class BetaResponseMCPToolResultBlockType extends S.Literal("mcp_tool_result") {}
+
+export class BetaResponseMCPToolResultBlock extends S.Struct({
+  "content": S.Union(S.String, S.Array(BetaResponseTextBlock)),
+  "is_error": S.Boolean,
+  "tool_use_id": S.String.pipe(S.pattern(new RegExp("^[a-zA-Z0-9_-]+$"))),
+  "type": BetaResponseMCPToolResultBlockType
+}) {}
+
+export class BetaResponseContainerUploadBlockType extends S.Literal("container_upload") {}
+
+export class BetaResponseContainerUploadBlock extends S.Struct({
+  "file_id": S.String,
+  "type": BetaResponseContainerUploadBlockType
 }) {}
 
 export class BetaResponseThinkingBlockType extends S.Literal("thinking") {}
 
 export class BetaResponseThinkingBlock extends S.Struct({
-  "type": BetaResponseThinkingBlockType.pipe(S.propertySignature, S.withConstructorDefault(() => "thinking" as const)),
+  "signature": S.String,
   "thinking": S.String,
-  "signature": S.String
+  "type": BetaResponseThinkingBlockType
 }) {}
 
 export class BetaResponseRedactedThinkingBlockType extends S.Literal("redacted_thinking") {}
 
 export class BetaResponseRedactedThinkingBlock extends S.Struct({
-  "type": BetaResponseRedactedThinkingBlockType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "redacted_thinking" as const)
-  ),
-  "data": S.String
+  "data": S.String,
+  "type": BetaResponseRedactedThinkingBlockType
 }) {}
 
 export class BetaContentBlock extends S.Union(
   BetaResponseTextBlock,
   BetaResponseToolUseBlock,
+  BetaResponseServerToolUseBlock,
+  BetaResponseWebSearchToolResultBlock,
+  BetaResponseCodeExecutionToolResultBlock,
+  BetaResponseMCPToolUseBlock,
+  BetaResponseMCPToolResultBlock,
+  BetaResponseContainerUploadBlock,
   BetaResponseThinkingBlock,
   BetaResponseRedactedThinkingBlock
 ) {}
 
-export class BetaMessageStopReasonEnum extends S.Literal("end_turn", "max_tokens", "stop_sequence", "tool_use") {}
+export class BetaStopReason
+  extends S.Literal("end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal")
+{}
+
+export class BetaCacheCreation extends S.Struct({
+  "ephemeral_1h_input_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0)),
+  "ephemeral_5m_input_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0))
+}) {}
+
+export class BetaServerToolUsage extends S.Struct({
+  "web_search_requests": S.Int.pipe(S.greaterThanOrEqualTo(0))
+}) {}
+
+export class BetaUsageServiceTierEnum extends S.Literal("standard", "priority", "batch") {}
 
 export class BetaUsage extends S.Struct({
+  "cache_creation": S.NullOr(S.Union(BetaCacheCreation, S.Null)),
+  "cache_creation_input_tokens": S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)),
+  "cache_read_input_tokens": S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)),
   "input_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0)),
-  "cache_creation_input_tokens": S.optionalWith(S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)), {
-    default: () => null
-  }),
-  "cache_read_input_tokens": S.optionalWith(S.NullOr(S.Union(S.Int.pipe(S.greaterThanOrEqualTo(0)), S.Null)), {
-    default: () => null
-  }),
-  "output_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0))
+  "output_tokens": S.Int.pipe(S.greaterThanOrEqualTo(0)),
+  "server_tool_use": S.NullOr(S.Union(BetaServerToolUsage, S.Null)),
+  "service_tier": S.NullOr(S.Union(BetaUsageServiceTierEnum, S.Null))
+}) {}
+
+export class BetaContainer extends S.Struct({
+  "expires_at": S.String,
+  "id": S.String
 }) {}
 
 export class BetaMessage extends S.Class<BetaMessage>("BetaMessage")({
   "id": S.String,
-  "type": BetaMessageType.pipe(S.propertySignature, S.withConstructorDefault(() => "message" as const)),
-  "role": BetaMessageRole.pipe(S.propertySignature, S.withConstructorDefault(() => "assistant" as const)),
+  "type": BetaMessageType,
+  "role": BetaMessageRole,
   "content": S.Array(BetaContentBlock),
-  "model": Model,
-  "stop_reason": S.Union(BetaMessageStopReasonEnum, S.Null),
-  "stop_sequence": S.optionalWith(S.NullOr(S.Union(S.String, S.Null)), { default: () => null }),
-  "usage": BetaUsage
+  "model": S.Union(S.String, Model),
+  "stop_reason": S.Union(BetaStopReason, S.Null),
+  "stop_sequence": S.NullOr(S.Union(S.String, S.Null)),
+  "usage": BetaUsage,
+  "container": S.NullOr(S.Union(BetaContainer, S.Null))
 }) {}
 
-export class BetaErrorResponseType extends S.Literal("error") {}
-
 export class BetaInvalidRequestErrorType extends S.Literal("invalid_request_error") {}
 
 export class BetaInvalidRequestError extends S.Struct({
-  "type": BetaInvalidRequestErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "invalid_request_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Invalid request" as const))
+  "message": S.String,
+  "type": BetaInvalidRequestErrorType
 }) {}
 
 export class BetaAuthenticationErrorType extends S.Literal("authentication_error") {}
 
 export class BetaAuthenticationError extends S.Struct({
-  "type": BetaAuthenticationErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "authentication_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Authentication error" as const))
+  "message": S.String,
+  "type": BetaAuthenticationErrorType
 }) {}
 
 export class BetaBillingErrorType extends S.Literal("billing_error") {}
 
 export class BetaBillingError extends S.Struct({
-  "type": BetaBillingErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "billing_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Billing error" as const))
+  "message": S.String,
+  "type": BetaBillingErrorType
 }) {}
 
 export class BetaPermissionErrorType extends S.Literal("permission_error") {}
 
 export class BetaPermissionError extends S.Struct({
-  "type": BetaPermissionErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "permission_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Permission denied" as const))
+  "message": S.String,
+  "type": BetaPermissionErrorType
 }) {}
 
 export class BetaNotFoundErrorType extends S.Literal("not_found_error") {}
 
 export class BetaNotFoundError extends S.Struct({
-  "type": BetaNotFoundErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "not_found_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Not found" as const))
+  "message": S.String,
+  "type": BetaNotFoundErrorType
 }) {}
 
 export class BetaRateLimitErrorType extends S.Literal("rate_limit_error") {}
 
 export class BetaRateLimitError extends S.Struct({
-  "type": BetaRateLimitErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "rate_limit_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Rate limited" as const))
+  "message": S.String,
+  "type": BetaRateLimitErrorType
 }) {}
 
 export class BetaGatewayTimeoutErrorType extends S.Literal("timeout_error") {}
 
 export class BetaGatewayTimeoutError extends S.Struct({
-  "type": BetaGatewayTimeoutErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "timeout_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Request timeout" as const))
+  "message": S.String,
+  "type": BetaGatewayTimeoutErrorType
 }) {}
 
 export class BetaAPIErrorType extends S.Literal("api_error") {}
 
 export class BetaAPIError extends S.Struct({
-  "type": BetaAPIErrorType.pipe(S.propertySignature, S.withConstructorDefault(() => "api_error" as const)),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Internal server error" as const))
+  "message": S.String,
+  "type": BetaAPIErrorType
 }) {}
 
 export class BetaOverloadedErrorType extends S.Literal("overloaded_error") {}
 
 export class BetaOverloadedError extends S.Struct({
-  "type": BetaOverloadedErrorType.pipe(
-    S.propertySignature,
-    S.withConstructorDefault(() => "overloaded_error" as const)
-  ),
-  "message": S.String.pipe(S.propertySignature, S.withConstructorDefault(() => "Overloaded" as const))
+  "message": S.String,
+  "type": BetaOverloadedErrorType
 }) {}
 
+export class BetaErrorResponseType extends S.Literal("error") {}
+
 export class BetaErrorResponse extends S.Class<BetaErrorResponse>("BetaErrorResponse")({
-  "type": BetaErrorResponseType.pipe(S.propertySignature, S.withConstructorDefault(() => "error" as const)),
   "error": S.Union(
     BetaInvalidRequestError,
     BetaAuthenticationError,
@@ -1250,83 +1771,80 @@ export class BetaErrorResponse extends S.Class<BetaErrorResponse>("BetaErrorResp
     BetaGatewayTimeoutError,
     BetaAPIError,
     BetaOverloadedError
-  )
+  ),
+  "type": BetaErrorResponseType
 }) {}
 
 export class BetaModelsListParams extends S.Struct({
   "before_id": S.optionalWith(S.String, { nullable: true }),
   "after_id": S.optionalWith(S.String, { nullable: true }),
-  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), {
-    nullable: true,
-    default: () => 20 as const
-  }),
+  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), { nullable: true }),
   "anthropic-version": S.optionalWith(S.String, { nullable: true }),
-  "x-api-key": S.optionalWith(S.String, { nullable: true })
+  "x-api-key": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class BetaModelInfoType extends S.Literal("model") {}
 
 export class BetaModelInfo extends S.Struct({
-  "type": BetaModelInfoType.pipe(S.propertySignature, S.withConstructorDefault(() => "model" as const)),
-  "id": S.String,
+  "created_at": S.String,
   "display_name": S.String,
-  "created_at": S.String
+  "id": S.String,
+  "type": BetaModelInfoType
 }) {}
 
 export class BetaListResponseModelInfo extends S.Class<BetaListResponseModelInfo>("BetaListResponseModelInfo")({
   "data": S.Array(BetaModelInfo),
-  "has_more": S.Boolean,
   "first_id": S.Union(S.String, S.Null),
+  "has_more": S.Boolean,
   "last_id": S.Union(S.String, S.Null)
 }) {}
 
 export class BetaModelsGetParams extends S.Struct({
   "anthropic-version": S.optionalWith(S.String, { nullable: true }),
-  "x-api-key": S.optionalWith(S.String, { nullable: true })
+  "x-api-key": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true })
 }) {}
 
 export class BetaMessageBatchesListParams extends S.Struct({
   "before_id": S.optionalWith(S.String, { nullable: true }),
   "after_id": S.optionalWith(S.String, { nullable: true }),
-  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), {
-    nullable: true,
-    default: () => 20 as const
-  }),
+  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), { nullable: true }),
   "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
   "anthropic-version": S.optionalWith(S.String, { nullable: true }),
   "x-api-key": S.optionalWith(S.String, { nullable: true })
 }) {}
 
-export class BetaMessageBatchType extends S.Literal("message_batch") {}
-
 export class BetaMessageBatchProcessingStatus extends S.Literal("in_progress", "canceling", "ended") {}
 
 export class BetaRequestCounts extends S.Struct({
-  "processing": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "succeeded": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "errored": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "canceled": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const)),
-  "expired": S.Int.pipe(S.propertySignature, S.withConstructorDefault(() => 0 as const))
+  "canceled": S.Int,
+  "errored": S.Int,
+  "expired": S.Int,
+  "processing": S.Int,
+  "succeeded": S.Int
 }) {}
 
+export class BetaMessageBatchType extends S.Literal("message_batch") {}
+
 export class BetaMessageBatch extends S.Struct({
+  "archived_at": S.Union(S.String, S.Null),
+  "cancel_initiated_at": S.Union(S.String, S.Null),
+  "created_at": S.String,
+  "ended_at": S.Union(S.String, S.Null),
+  "expires_at": S.String,
   "id": S.String,
-  "type": BetaMessageBatchType.pipe(S.propertySignature, S.withConstructorDefault(() => "message_batch" as const)),
   "processing_status": BetaMessageBatchProcessingStatus,
   "request_counts": BetaRequestCounts,
-  "ended_at": S.Union(S.String, S.Null),
-  "created_at": S.String,
-  "expires_at": S.String,
-  "archived_at": S.Union(S.String, S.Null),
-  "cancel_initiated_at": S.Union(S.String, S.Null),
-  "results_url": S.Union(S.String, S.Null)
+  "results_url": S.Union(S.String, S.Null),
+  "type": BetaMessageBatchType
 }) {}
 
 export class BetaListResponseMessageBatch
   extends S.Class<BetaListResponseMessageBatch>("BetaListResponseMessageBatch")({
     "data": S.Array(BetaMessageBatch),
-    "has_more": S.Boolean,
     "first_id": S.Union(S.String, S.Null),
+    "has_more": S.Boolean,
     "last_id": S.Union(S.String, S.Null)
   })
 {}
@@ -1364,10 +1882,7 @@ export class BetaDeleteMessageBatchResponseType extends S.Literal("message_batch
 export class BetaDeleteMessageBatchResponse
   extends S.Class<BetaDeleteMessageBatchResponse>("BetaDeleteMessageBatchResponse")({
     "id": S.String,
-    "type": BetaDeleteMessageBatchResponseType.pipe(
-      S.propertySignature,
-      S.withConstructorDefault(() => "message_batch_deleted" as const)
-    )
+    "type": BetaDeleteMessageBatchResponseType
   })
 {}
 
@@ -1389,6 +1904,11 @@ export class BetaMessagesCountTokensPostParams extends S.Struct({
 
 export class BetaCountMessageTokensParams
   extends S.Class<BetaCountMessageTokensParams>("BetaCountMessageTokensParams")({
+    "mcp_servers": S.optionalWith(S.Array(BetaRequestMCPServerURLDefinition).pipe(S.maxItems(20)), { nullable: true }),
+    "messages": S.Array(BetaInputMessage),
+    "model": S.Union(S.String, Model),
+    "system": S.optionalWith(S.Union(S.String, S.Array(BetaRequestTextBlock)), { nullable: true }),
+    "thinking": S.optionalWith(BetaThinkingConfigParam, { nullable: true }),
     "tool_choice": S.optionalWith(BetaToolChoice, { nullable: true }),
     "tools": S.optionalWith(
       S.Array(
@@ -1399,15 +1919,14 @@ export class BetaCountMessageTokensParams
           BetaTextEditor20241022,
           BetaComputerUseTool20250124,
           BetaBashTool20250124,
-          BetaTextEditor20250124
+          BetaTextEditor20250124,
+          BetaTextEditor20250429,
+          BetaWebSearchTool20250305,
+          BetaCodeExecutionTool20250522
         )
       ),
       { nullable: true }
-    ),
-    "messages": S.Array(BetaInputMessage),
-    "system": S.optionalWith(S.Union(S.String, S.Array(BetaRequestTextBlock)), { nullable: true }),
-    "thinking": S.optionalWith(BetaThinkingConfigParam, { nullable: true }),
-    "model": Model
+    )
   })
 {}
 
@@ -1417,6 +1936,64 @@ export class BetaCountMessageTokensResponse
   })
 {}
 
+export class BetaListFilesV1FilesGetParams extends S.Struct({
+  "before_id": S.optionalWith(S.String, { nullable: true }),
+  "after_id": S.optionalWith(S.String, { nullable: true }),
+  "limit": S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(1000)), { nullable: true }),
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class BetaFileMetadataSchemaType extends S.Literal("file") {}
+
+export class BetaFileMetadataSchema extends S.Struct({
+  "created_at": S.String,
+  "downloadable": S.optionalWith(S.Boolean, { nullable: true }),
+  "filename": S.String.pipe(S.minLength(1), S.maxLength(500)),
+  "id": S.String,
+  "mime_type": S.String.pipe(S.minLength(1), S.maxLength(255)),
+  "size_bytes": S.Int.pipe(S.greaterThanOrEqualTo(0)),
+  "type": BetaFileMetadataSchemaType
+}) {}
+
+export class BetaFileListResponse extends S.Class<BetaFileListResponse>("BetaFileListResponse")({
+  "data": S.Array(BetaFileMetadataSchema),
+  "first_id": S.optionalWith(S.Union(S.String, S.Null), { nullable: true }),
+  "has_more": S.optionalWith(S.Boolean, { nullable: true }),
+  "last_id": S.optionalWith(S.Union(S.String, S.Null), { nullable: true })
+}) {}
+
+export class BetaUploadFileV1FilesPostParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class BetaGetFileMetadataV1FilesFileIdGetParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class BetaDeleteFileV1FilesFileIdDeleteParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
+export class BetaFileDeleteResponseType extends S.Literal("file_deleted") {}
+
+export class BetaFileDeleteResponse extends S.Class<BetaFileDeleteResponse>("BetaFileDeleteResponse")({
+  "id": S.String,
+  "type": S.optionalWith(BetaFileDeleteResponseType, { nullable: true })
+}) {}
+
+export class BetaDownloadFileV1FilesFileIdContentGetParams extends S.Struct({
+  "anthropic-beta": S.optionalWith(S.String, { nullable: true }),
+  "anthropic-version": S.optionalWith(S.String, { nullable: true }),
+  "x-api-key": S.optionalWith(S.String, { nullable: true })
+}) {}
+
 export const make = (
   httpClient: HttpClient.HttpClient,
   options: {
@@ -1444,9 +2021,10 @@ export const make = (
   const decodeError = <A, I, R>(response: HttpClientResponse.HttpClientResponse, schema: S.Schema<A, I, R>) =>
     Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)(response), Effect.fail)
   return {
+    httpClient,
     "messagesPost": (options) =>
       HttpClientRequest.make("POST")(`/v1/messages`).pipe(
-        HttpClientRequest.setHeaders({ "anthropic-version": options.params["anthropic-version"] ?? undefined }),
+        HttpClientRequest.setHeaders({ "anthropic-version": options.params?.["anthropic-version"] ?? undefined }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
           Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
@@ -1462,7 +2040,10 @@ export const make = (
       ),
     "completePost": (options) =>
       HttpClientRequest.make("POST")(`/v1/complete`).pipe(
-        HttpClientRequest.setHeaders({ "anthropic-version": options.params["anthropic-version"] ?? undefined }),
+        HttpClientRequest.setHeaders({
+          "anthropic-version": options.params?.["anthropic-version"] ?? undefined,
+          "anthropic-beta": options.params?.["anthropic-beta"] ?? undefined
+        }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
           Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
@@ -1479,13 +2060,14 @@ export const make = (
     "modelsList": (options) =>
       HttpClientRequest.make("GET")(`/v1/models`).pipe(
         HttpClientRequest.setUrlParams({
-          "before_id": options["before_id"] as UrlParams.Coercible,
-          "after_id": options["after_id"] as UrlParams.Coercible,
-          "limit": options["limit"] as UrlParams.Coercible
+          "before_id": options?.["before_id"] as UrlParams.Coercible,
+          "after_id": options?.["after_id"] as UrlParams.Coercible,
+          "limit": options?.["limit"] as UrlParams.Coercible
         }),
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined,
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1503,8 +2085,9 @@ export const make = (
     "modelsGet": (modelId, options) =>
       HttpClientRequest.make("GET")(`/v1/models/${modelId}`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined,
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1522,13 +2105,13 @@ export const make = (
     "messageBatchesList": (options) =>
       HttpClientRequest.make("GET")(`/v1/messages/batches`).pipe(
         HttpClientRequest.setUrlParams({
-          "before_id": options["before_id"] as UrlParams.Coercible,
-          "after_id": options["after_id"] as UrlParams.Coercible,
-          "limit": options["limit"] as UrlParams.Coercible
+          "before_id": options?.["before_id"] as UrlParams.Coercible,
+          "after_id": options?.["after_id"] as UrlParams.Coercible,
+          "limit": options?.["limit"] as UrlParams.Coercible
         }),
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1545,7 +2128,7 @@ export const make = (
       ),
     "messageBatchesPost": (options) =>
       HttpClientRequest.make("POST")(`/v1/messages/batches`).pipe(
-        HttpClientRequest.setHeaders({ "anthropic-version": options.params["anthropic-version"] ?? undefined }),
+        HttpClientRequest.setHeaders({ "anthropic-version": options.params?.["anthropic-version"] ?? undefined }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
           Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
@@ -1562,8 +2145,8 @@ export const make = (
     "messageBatchesRetrieve": (messageBatchId, options) =>
       HttpClientRequest.make("GET")(`/v1/messages/batches/${messageBatchId}`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1584,8 +2167,8 @@ export const make = (
     "messageBatchesDelete": (messageBatchId, options) =>
       HttpClientRequest.make("DELETE")(`/v1/messages/batches/${messageBatchId}`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1605,7 +2188,7 @@ export const make = (
       ),
     "messageBatchesCancel": (messageBatchId, options) =>
       HttpClientRequest.make("POST")(`/v1/messages/batches/${messageBatchId}/cancel`).pipe(
-        HttpClientRequest.setHeaders({ "anthropic-version": options["anthropic-version"] ?? undefined }),
+        HttpClientRequest.setHeaders({ "anthropic-version": options?.["anthropic-version"] ?? undefined }),
         Effect.succeed,
         Effect.flatMap((request) =>
           Effect.flatMap(
@@ -1625,8 +2208,8 @@ export const make = (
     "messageBatchesResults": (messageBatchId, options) =>
       HttpClientRequest.make("GET")(`/v1/messages/batches/${messageBatchId}/results`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1645,7 +2228,7 @@ export const make = (
       ),
     "messagesCountTokensPost": (options) =>
       HttpClientRequest.make("POST")(`/v1/messages/count_tokens`).pipe(
-        HttpClientRequest.setHeaders({ "anthropic-version": options.params["anthropic-version"] ?? undefined }),
+        HttpClientRequest.setHeaders({ "anthropic-version": options.params?.["anthropic-version"] ?? undefined }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
           Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
@@ -1659,11 +2242,117 @@ export const make = (
             ))
         )
       ),
+    "listFilesV1FilesGet": (options) =>
+      HttpClientRequest.make("GET")(`/v1/files`).pipe(
+        HttpClientRequest.setUrlParams({
+          "before_id": options?.["before_id"] as UrlParams.Coercible,
+          "after_id": options?.["after_id"] as UrlParams.Coercible,
+          "limit": options?.["limit"] as UrlParams.Coercible
+        }),
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+            Effect.flatMap(
+              httpClient.execute(request),
+              HttpClientResponse.matchStatus({
+                "200": (r) => HttpClientResponse.schemaBodyJson(FileListResponse)(r),
+                "4xx": (r) => decodeError(r, ErrorResponse),
+                orElse: (response) => unexpectedStatus(request, response)
+              })
+            ))
+        )
+      ),
+    "uploadFileV1FilesPost": (options) =>
+      HttpClientRequest.make("POST")(`/v1/files`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options.params?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options.params?.["anthropic-version"] ?? undefined
+        }),
+        HttpClientRequest.bodyFormData(options.payload),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+            Effect.flatMap(
+              httpClient.execute(request),
+              HttpClientResponse.matchStatus({
+                "200": (r) => HttpClientResponse.schemaBodyJson(FileMetadataSchema)(r),
+                "4xx": (r) => decodeError(r, ErrorResponse),
+                orElse: (response) => unexpectedStatus(request, response)
+              })
+            ))
+        )
+      ),
+    "getFileMetadataV1FilesFileIdGet": (fileId, options) =>
+      HttpClientRequest.make("GET")(`/v1/files/${fileId}`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+            Effect.flatMap(
+              httpClient.execute(request),
+              HttpClientResponse.matchStatus({
+                "200": (r) => HttpClientResponse.schemaBodyJson(FileMetadataSchema)(r),
+                "4xx": (r) => decodeError(r, ErrorResponse),
+                orElse: (response) => unexpectedStatus(request, response)
+              })
+            ))
+        )
+      ),
+    "deleteFileV1FilesFileIdDelete": (fileId, options) =>
+      HttpClientRequest.make("DELETE")(`/v1/files/${fileId}`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+            Effect.flatMap(
+              httpClient.execute(request),
+              HttpClientResponse.matchStatus({
+                "200": (r) => HttpClientResponse.schemaBodyJson(FileDeleteResponse)(r),
+                "4xx": (r) => decodeError(r, ErrorResponse),
+                orElse: (response) => unexpectedStatus(request, response)
+              })
+            ))
+        )
+      ),
+    "downloadFileV1FilesFileIdContentGet": (fileId, options) =>
+      HttpClientRequest.make("GET")(`/v1/files/${fileId}/content`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            applyClientTransform(httpClient),
+            (httpClient) =>
+              Effect.flatMap(
+                httpClient.execute(request),
+                HttpClientResponse.matchStatus({
+                  orElse: (response) => unexpectedStatus(request, response)
+                })
+              )
+          )
+        )
+      ),
     "betaMessagesPost": (options) =>
       HttpClientRequest.make("POST")(`/v1/messages?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options.params["anthropic-beta"] ?? undefined,
-          "anthropic-version": options.params["anthropic-version"] ?? undefined
+          "anthropic-beta": options.params?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options.params?.["anthropic-version"] ?? undefined
         }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
@@ -1681,13 +2370,14 @@ export const make = (
     "betaModelsList": (options) =>
       HttpClientRequest.make("GET")(`/v1/models?beta=true`).pipe(
         HttpClientRequest.setUrlParams({
-          "before_id": options["before_id"] as UrlParams.Coercible,
-          "after_id": options["after_id"] as UrlParams.Coercible,
-          "limit": options["limit"] as UrlParams.Coercible
+          "before_id": options?.["before_id"] as UrlParams.Coercible,
+          "after_id": options?.["after_id"] as UrlParams.Coercible,
+          "limit": options?.["limit"] as UrlParams.Coercible
         }),
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined,
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1705,8 +2395,9 @@ export const make = (
     "betaModelsGet": (modelId, options) =>
       HttpClientRequest.make("GET")(`/v1/models/${modelId}?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined,
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1724,14 +2415,14 @@ export const make = (
     "betaMessageBatchesList": (options) =>
       HttpClientRequest.make("GET")(`/v1/messages/batches?beta=true`).pipe(
         HttpClientRequest.setUrlParams({
-          "before_id": options["before_id"] as UrlParams.Coercible,
-          "after_id": options["after_id"] as UrlParams.Coercible,
-          "limit": options["limit"] as UrlParams.Coercible
+          "before_id": options?.["before_id"] as UrlParams.Coercible,
+          "after_id": options?.["after_id"] as UrlParams.Coercible,
+          "limit": options?.["limit"] as UrlParams.Coercible
         }),
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options["anthropic-beta"] ?? undefined,
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1749,8 +2440,8 @@ export const make = (
     "betaMessageBatchesPost": (options) =>
       HttpClientRequest.make("POST")(`/v1/messages/batches?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options.params["anthropic-beta"] ?? undefined,
-          "anthropic-version": options.params["anthropic-version"] ?? undefined
+          "anthropic-beta": options.params?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options.params?.["anthropic-version"] ?? undefined
         }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
@@ -1768,9 +2459,9 @@ export const make = (
     "betaMessageBatchesRetrieve": (messageBatchId, options) =>
       HttpClientRequest.make("GET")(`/v1/messages/batches/${messageBatchId}?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options["anthropic-beta"] ?? undefined,
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1791,9 +2482,9 @@ export const make = (
     "betaMessageBatchesDelete": (messageBatchId, options) =>
       HttpClientRequest.make("DELETE")(`/v1/messages/batches/${messageBatchId}?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options["anthropic-beta"] ?? undefined,
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1814,8 +2505,8 @@ export const make = (
     "betaMessageBatchesCancel": (messageBatchId, options) =>
       HttpClientRequest.make("POST")(`/v1/messages/batches/${messageBatchId}/cancel?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options["anthropic-beta"] ?? undefined,
-          "anthropic-version": options["anthropic-version"] ?? undefined
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1836,9 +2527,9 @@ export const make = (
     "betaMessageBatchesResults": (messageBatchId, options) =>
       HttpClientRequest.make("GET")(`/v1/messages/batches/${messageBatchId}/results?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options["anthropic-beta"] ?? undefined,
-          "anthropic-version": options["anthropic-version"] ?? undefined,
-          "x-api-key": options["x-api-key"] ?? undefined
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
         }),
         Effect.succeed,
         Effect.flatMap((request) =>
@@ -1858,8 +2549,8 @@ export const make = (
     "betaMessagesCountTokensPost": (options) =>
       HttpClientRequest.make("POST")(`/v1/messages/count_tokens?beta=true`).pipe(
         HttpClientRequest.setHeaders({
-          "anthropic-beta": options.params["anthropic-beta"] ?? undefined,
-          "anthropic-version": options.params["anthropic-version"] ?? undefined
+          "anthropic-beta": options.params?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options.params?.["anthropic-version"] ?? undefined
         }),
         (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
         Effect.flatMap((request) =>
@@ -1876,76 +2567,225 @@ export const make = (
               )
           )
         )
+      ),
+    "betaListFilesV1FilesGet": (options) =>
+      HttpClientRequest.make("GET")(`/v1/files?beta=true`).pipe(
+        HttpClientRequest.setUrlParams({
+          "before_id": options?.["before_id"] as UrlParams.Coercible,
+          "after_id": options?.["after_id"] as UrlParams.Coercible,
+          "limit": options?.["limit"] as UrlParams.Coercible
+        }),
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+            Effect.flatMap(
+              httpClient.execute(request),
+              HttpClientResponse.matchStatus({
+                "200": (r) => HttpClientResponse.schemaBodyJson(BetaFileListResponse)(r),
+                "4xx": (r) => decodeError(r, BetaErrorResponse),
+                orElse: (response) => unexpectedStatus(request, response)
+              })
+            ))
+        )
+      ),
+    "betaUploadFileV1FilesPost": (options) =>
+      HttpClientRequest.make("POST")(`/v1/files?beta=true`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options.params?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options.params?.["anthropic-version"] ?? undefined
+        }),
+        HttpClientRequest.bodyFormData(options.payload),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+            Effect.flatMap(
+              httpClient.execute(request),
+              HttpClientResponse.matchStatus({
+                "200": (r) => HttpClientResponse.schemaBodyJson(BetaFileMetadataSchema)(r),
+                "4xx": (r) => decodeError(r, BetaErrorResponse),
+                orElse: (response) => unexpectedStatus(request, response)
+              })
+            ))
+        )
+      ),
+    "betaGetFileMetadataV1FilesFileIdGet": (fileId, options) =>
+      HttpClientRequest.make("GET")(`/v1/files/${fileId}?beta=true`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            applyClientTransform(httpClient),
+            (httpClient) =>
+              Effect.flatMap(
+                httpClient.execute(request),
+                HttpClientResponse.matchStatus({
+                  "200": (r) => HttpClientResponse.schemaBodyJson(BetaFileMetadataSchema)(r),
+                  "4xx": (r) => decodeError(r, BetaErrorResponse),
+                  orElse: (response) => unexpectedStatus(request, response)
+                })
+              )
+          )
+        )
+      ),
+    "betaDeleteFileV1FilesFileIdDelete": (fileId, options) =>
+      HttpClientRequest.make("DELETE")(`/v1/files/${fileId}?beta=true`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            applyClientTransform(httpClient),
+            (httpClient) =>
+              Effect.flatMap(
+                httpClient.execute(request),
+                HttpClientResponse.matchStatus({
+                  "200": (r) => HttpClientResponse.schemaBodyJson(BetaFileDeleteResponse)(r),
+                  "4xx": (r) => decodeError(r, BetaErrorResponse),
+                  orElse: (response) => unexpectedStatus(request, response)
+                })
+              )
+          )
+        )
+      ),
+    "betaDownloadFileV1FilesFileIdContentGet": (fileId, options) =>
+      HttpClientRequest.make("GET")(`/v1/files/${fileId}/content?beta=true`).pipe(
+        HttpClientRequest.setHeaders({
+          "anthropic-beta": options?.["anthropic-beta"] ?? undefined,
+          "anthropic-version": options?.["anthropic-version"] ?? undefined,
+          "x-api-key": options?.["x-api-key"] ?? undefined
+        }),
+        Effect.succeed,
+        Effect.flatMap((request) =>
+          Effect.flatMap(
+            applyClientTransform(httpClient),
+            (httpClient) =>
+              Effect.flatMap(
+                httpClient.execute(request),
+                HttpClientResponse.matchStatus({
+                  orElse: (response) => unexpectedStatus(request, response)
+                })
+              )
+          )
+        )
       )
   }
 }
 
 export interface Client {
+  readonly httpClient: HttpClient.HttpClient
   readonly "messagesPost": (
     options: {
-      readonly params: typeof MessagesPostParams.Encoded
+      readonly params?: typeof MessagesPostParams.Encoded | undefined
       readonly payload: typeof CreateMessageParams.Encoded
     }
   ) => Effect.Effect<typeof Message.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>
   readonly "completePost": (
-    options: { readonly params: typeof CompletePostParams.Encoded; readonly payload: typeof CompletionRequest.Encoded }
+    options: {
+      readonly params?: typeof CompletePostParams.Encoded | undefined
+      readonly payload: typeof CompletionRequest.Encoded
+    }
   ) => Effect.Effect<
     typeof CompletionResponse.Type,
     HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
   >
   readonly "modelsList": (
-    options: typeof ModelsListParams.Encoded
+    options?: typeof ModelsListParams.Encoded | undefined
   ) => Effect.Effect<
     typeof ListResponseModelInfo.Type,
     HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
   >
   readonly "modelsGet": (
     modelId: string,
-    options: typeof ModelsGetParams.Encoded
+    options?: typeof ModelsGetParams.Encoded | undefined
   ) => Effect.Effect<typeof ModelInfo.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>
   readonly "messageBatchesList": (
-    options: typeof MessageBatchesListParams.Encoded
+    options?: typeof MessageBatchesListParams.Encoded | undefined
   ) => Effect.Effect<
     typeof ListResponseMessageBatch.Type,
     HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
   >
   readonly "messageBatchesPost": (
     options: {
-      readonly params: typeof MessageBatchesPostParams.Encoded
+      readonly params?: typeof MessageBatchesPostParams.Encoded | undefined
       readonly payload: typeof CreateMessageBatchParams.Encoded
     }
   ) => Effect.Effect<typeof MessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>
   readonly "messageBatchesRetrieve": (
     messageBatchId: string,
-    options: typeof MessageBatchesRetrieveParams.Encoded
+    options?: typeof MessageBatchesRetrieveParams.Encoded | undefined
   ) => Effect.Effect<typeof MessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>
   readonly "messageBatchesDelete": (
     messageBatchId: string,
-    options: typeof MessageBatchesDeleteParams.Encoded
+    options?: typeof MessageBatchesDeleteParams.Encoded | undefined
   ) => Effect.Effect<
     typeof DeleteMessageBatchResponse.Type,
     HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
   >
   readonly "messageBatchesCancel": (
     messageBatchId: string,
-    options: typeof MessageBatchesCancelParams.Encoded
+    options?: typeof MessageBatchesCancelParams.Encoded | undefined
   ) => Effect.Effect<typeof MessageBatch.Type, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>
   readonly "messageBatchesResults": (
     messageBatchId: string,
-    options: typeof MessageBatchesResultsParams.Encoded
+    options?: typeof MessageBatchesResultsParams.Encoded | undefined
   ) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type>
   readonly "messagesCountTokensPost": (
     options: {
-      readonly params: typeof MessagesCountTokensPostParams.Encoded
+      readonly params?: typeof MessagesCountTokensPostParams.Encoded | undefined
       readonly payload: typeof CountMessageTokensParams.Encoded
     }
   ) => Effect.Effect<
     typeof CountMessageTokensResponse.Type,
     HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
   >
+  readonly "listFilesV1FilesGet": (
+    options?: typeof ListFilesV1FilesGetParams.Encoded | undefined
+  ) => Effect.Effect<
+    typeof FileListResponse.Type,
+    HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
+  >
+  readonly "uploadFileV1FilesPost": (
+    options: {
+      readonly params?: typeof UploadFileV1FilesPostParams.Encoded | undefined
+      readonly payload: globalThis.FormData
+    }
+  ) => Effect.Effect<
+    typeof FileMetadataSchema.Type,
+    HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
+  >
+  readonly "getFileMetadataV1FilesFileIdGet": (
+    fileId: string,
+    options?: typeof GetFileMetadataV1FilesFileIdGetParams.Encoded | undefined
+  ) => Effect.Effect<
+    typeof FileMetadataSchema.Type,
+    HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
+  >
+  readonly "deleteFileV1FilesFileIdDelete": (
+    fileId: string,
+    options?: typeof DeleteFileV1FilesFileIdDeleteParams.Encoded | undefined
+  ) => Effect.Effect<
+    typeof FileDeleteResponse.Type,
+    HttpClientError.HttpClientError | ParseError | typeof ErrorResponse.Type
+  >
+  readonly "downloadFileV1FilesFileIdContentGet": (
+    fileId: string,
+    options?: typeof DownloadFileV1FilesFileIdContentGetParams.Encoded | undefined
+  ) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError>
   readonly "betaMessagesPost": (
     options: {
-      readonly params: typeof BetaMessagesPostParams.Encoded
+      readonly params?: typeof BetaMessagesPostParams.Encoded | undefined
       readonly payload: typeof BetaCreateMessageParams.Encoded
     }
   ) => Effect.Effect<
@@ -1953,27 +2793,27 @@ export interface Client {
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaModelsList": (
-    options: typeof BetaModelsListParams.Encoded
+    options?: typeof BetaModelsListParams.Encoded | undefined
   ) => Effect.Effect<
     typeof BetaListResponseModelInfo.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaModelsGet": (
     modelId: string,
-    options: typeof BetaModelsGetParams.Encoded
+    options?: typeof BetaModelsGetParams.Encoded | undefined
   ) => Effect.Effect<
     typeof BetaModelInfo.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaMessageBatchesList": (
-    options: typeof BetaMessageBatchesListParams.Encoded
+    options?: typeof BetaMessageBatchesListParams.Encoded | undefined
   ) => Effect.Effect<
     typeof BetaListResponseMessageBatch.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaMessageBatchesPost": (
     options: {
-      readonly params: typeof BetaMessageBatchesPostParams.Encoded
+      readonly params?: typeof BetaMessageBatchesPostParams.Encoded | undefined
       readonly payload: typeof BetaCreateMessageBatchParams.Encoded
     }
   ) => Effect.Effect<
@@ -1982,36 +2822,69 @@ export interface Client {
   >
   readonly "betaMessageBatchesRetrieve": (
     messageBatchId: string,
-    options: typeof BetaMessageBatchesRetrieveParams.Encoded
+    options?: typeof BetaMessageBatchesRetrieveParams.Encoded | undefined
   ) => Effect.Effect<
     typeof BetaMessageBatch.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaMessageBatchesDelete": (
     messageBatchId: string,
-    options: typeof BetaMessageBatchesDeleteParams.Encoded
+    options?: typeof BetaMessageBatchesDeleteParams.Encoded | undefined
   ) => Effect.Effect<
     typeof BetaDeleteMessageBatchResponse.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaMessageBatchesCancel": (
     messageBatchId: string,
-    options: typeof BetaMessageBatchesCancelParams.Encoded
+    options?: typeof BetaMessageBatchesCancelParams.Encoded | undefined
   ) => Effect.Effect<
     typeof BetaMessageBatch.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
   readonly "betaMessageBatchesResults": (
     messageBatchId: string,
-    options: typeof BetaMessageBatchesResultsParams.Encoded
+    options?: typeof BetaMessageBatchesResultsParams.Encoded | undefined
   ) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type>
   readonly "betaMessagesCountTokensPost": (
     options: {
-      readonly params: typeof BetaMessagesCountTokensPostParams.Encoded
+      readonly params?: typeof BetaMessagesCountTokensPostParams.Encoded | undefined
       readonly payload: typeof BetaCountMessageTokensParams.Encoded
     }
   ) => Effect.Effect<
     typeof BetaCountMessageTokensResponse.Type,
     HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
   >
+  readonly "betaListFilesV1FilesGet": (
+    options?: typeof BetaListFilesV1FilesGetParams.Encoded | undefined
+  ) => Effect.Effect<
+    typeof BetaFileListResponse.Type,
+    HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
+  >
+  readonly "betaUploadFileV1FilesPost": (
+    options: {
+      readonly params?: typeof BetaUploadFileV1FilesPostParams.Encoded | undefined
+      readonly payload: globalThis.FormData
+    }
+  ) => Effect.Effect<
+    typeof BetaFileMetadataSchema.Type,
+    HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
+  >
+  readonly "betaGetFileMetadataV1FilesFileIdGet": (
+    fileId: string,
+    options?: typeof BetaGetFileMetadataV1FilesFileIdGetParams.Encoded | undefined
+  ) => Effect.Effect<
+    typeof BetaFileMetadataSchema.Type,
+    HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
+  >
+  readonly "betaDeleteFileV1FilesFileIdDelete": (
+    fileId: string,
+    options?: typeof BetaDeleteFileV1FilesFileIdDeleteParams.Encoded | undefined
+  ) => Effect.Effect<
+    typeof BetaFileDeleteResponse.Type,
+    HttpClientError.HttpClientError | ParseError | typeof BetaErrorResponse.Type
+  >
+  readonly "betaDownloadFileV1FilesFileIdContentGet": (
+    fileId: string,
+    options?: typeof BetaDownloadFileV1FilesFileIdContentGetParams.Encoded | undefined
+  ) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError>
 }