@anthropic-ai/sdk 0.36.2 → 0.37.0

package/src/index.ts

@@ -53,6 +53,7 @@ import {
   InputJSONDelta,
   Message,
   MessageCountTokensParams,
+  MessageCountTokensTool,
   MessageCreateParams,
   MessageCreateParamsNonStreaming,
   MessageCreateParamsStreaming,
@@ -75,17 +76,29 @@ import {
   RawMessageStartEvent,
   RawMessageStopEvent,
   RawMessageStreamEvent,
+  RedactedThinkingBlock,
+  RedactedThinkingBlockParam,
+  SignatureDelta,
   TextBlock,
   TextBlockParam,
   TextCitation,
   TextCitationParam,
   TextDelta,
+  ThinkingBlock,
+  ThinkingBlockParam,
+  ThinkingConfigDisabled,
+  ThinkingConfigEnabled,
+  ThinkingConfigParam,
+  ThinkingDelta,
   Tool,
+  ToolBash20250124,
   ToolChoice,
   ToolChoiceAny,
   ToolChoiceAuto,
   ToolChoiceTool,
   ToolResultBlockParam,
+  ToolTextEditor20250124,
+  ToolUnion,
   ToolUseBlock,
   ToolUseBlockParam,
   Usage,
@@ -354,6 +367,7 @@ export declare namespace Anthropic {
     type ImageBlockParam as ImageBlockParam,
     type InputJSONDelta as InputJSONDelta,
     type Message as Message,
+    type MessageCountTokensTool as MessageCountTokensTool,
     type MessageDeltaEvent as MessageDeltaEvent,
     type MessageDeltaUsage as MessageDeltaUsage,
     type MessageParam as MessageParam,
@@ -371,17 +385,29 @@ export declare namespace Anthropic {
     type RawMessageStartEvent as RawMessageStartEvent,
     type RawMessageStopEvent as RawMessageStopEvent,
     type RawMessageStreamEvent as RawMessageStreamEvent,
+    type RedactedThinkingBlock as RedactedThinkingBlock,
+    type RedactedThinkingBlockParam as RedactedThinkingBlockParam,
+    type SignatureDelta as SignatureDelta,
     type TextBlock as TextBlock,
     type TextBlockParam as TextBlockParam,
     type TextCitation as TextCitation,
     type TextCitationParam as TextCitationParam,
     type TextDelta as TextDelta,
+    type ThinkingBlock as ThinkingBlock,
+    type ThinkingBlockParam as ThinkingBlockParam,
+    type ThinkingConfigDisabled as ThinkingConfigDisabled,
+    type ThinkingConfigEnabled as ThinkingConfigEnabled,
+    type ThinkingConfigParam as ThinkingConfigParam,
+    type ThinkingDelta as ThinkingDelta,
     type Tool as Tool,
+    type ToolBash20250124 as ToolBash20250124,
     type ToolChoice as ToolChoice,
     type ToolChoiceAny as ToolChoiceAny,
     type ToolChoiceAuto as ToolChoiceAuto,
     type ToolChoiceTool as ToolChoiceTool,
     type ToolResultBlockParam as ToolResultBlockParam,
+    type ToolTextEditor20250124 as ToolTextEditor20250124,
+    type ToolUnion as ToolUnion,
     type ToolUseBlock as ToolUseBlock,
     type ToolUseBlockParam as ToolUseBlockParam,
     type Usage as Usage,

package/src/internal/decoders/line.ts

@@ -13,52 +13,58 @@ export class LineDecoder {
   static NEWLINE_CHARS = new Set(['\n', '\r']);
   static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
 
-  buffer: string[];
-  trailingCR: boolean;
+  buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
   textDecoder: any; // TextDecoder found in browsers; not typed to avoid pulling in either "dom" or "node" types.
 
   constructor() {
-    this.buffer = [];
-    this.trailingCR = false;
+    this.buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
   }
 
   decode(chunk: Bytes): string[] {
-    let text = this.decodeText(chunk);
-
-    if (this.trailingCR) {
-      text = '\r' + text;
-      this.trailingCR = false;
-    }
-    if (text.endsWith('\r')) {
-      this.trailingCR = true;
-      text = text.slice(0, -1);
-    }
-
-    if (!text) {
+    if (chunk == null) {
       return [];
     }
 
-    const trailingNewline = LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || '');
-    let lines = text.split(LineDecoder.NEWLINE_REGEXP);
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? new TextEncoder().encode(chunk)
+      : chunk;
+
+    let newData = new Uint8Array(this.buffer.length + binaryChunk.length);
+    newData.set(this.buffer);
+    newData.set(binaryChunk, this.buffer.length);
+    this.buffer = newData;
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
 
-    // if there is a trailing new line then the last entry will be an empty
-    // string which we don't care about
-    if (trailingNewline) {
-      lines.pop();
-    }
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(this.decodeText(this.buffer.slice(0, this.#carriageReturnIndex - 1)));
+        this.buffer = this.buffer.slice(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
 
-    if (lines.length === 1 && !trailingNewline) {
-      this.buffer.push(lines[0]!);
-      return [];
-    }
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
 
-    if (this.buffer.length > 0) {
-      lines = [this.buffer.join('') + lines[0], ...lines.slice(1)];
-      this.buffer = [];
-    }
+      const line = this.decodeText(this.buffer.slice(0, endIndex));
+      lines.push(line);
 
-    if (!trailingNewline) {
-      this.buffer = [lines.pop() || ''];
+      this.buffer = this.buffer.slice(patternIndex.index);
+      this.#carriageReturnIndex = null;
     }
 
     return lines;
@@ -102,13 +108,69 @@ export class LineDecoder {
   }
 
   flush(): string[] {
-    if (!this.buffer.length && !this.trailingCR) {
+    if (!this.buffer.length) {
       return [];
     }
+    return this.decode('\n');
+  }
+}
 
-    const lines = [this.buffer.join('')];
-    this.buffer = [];
-    this.trailingCR = false;
-    return lines;
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
   }
+
+  return null;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
 }

package/src/lib/BetaMessageStream.ts

@@ -9,6 +9,7 @@ import {
   type MessageCreateParams as BetaMessageCreateParams,
   type MessageCreateParamsBase as BetaMessageCreateParamsBase,
   type BetaTextBlock,
+  type BetaTextCitation,
 } from "../resources/beta/messages/messages.js";
 import { type ReadableStream, type Response } from "../_shims/index.js";
 import { Stream } from "../streaming.js";
@@ -18,7 +19,10 @@ export interface MessageStreamEvents {
   connect: () => void;
   streamEvent: (event: BetaMessageStreamEvent, snapshot: BetaMessage) => void;
   text: (textDelta: string, textSnapshot: string) => void;
+  citation: (citation: BetaTextCitation, citationsSnapshot: BetaTextCitation[]) => void;
   inputJson: (partialJson: string, jsonSnapshot: unknown) => void;
+  thinking: (thinkingDelta: string, thinkingSnapshot: string) => void;
+  signature: (signature: string) => void;
   message: (message: BetaMessage) => void;
   contentBlock: (content: BetaContentBlock) => void;
   finalMessage: (message: BetaMessage) => void;
@@ -413,12 +417,39 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
     switch (event.type) {
       case 'content_block_delta': {
         const content = messageSnapshot.content.at(-1)!;
-        if (event.delta.type === 'text_delta' && content.type === 'text') {
-          this._emit('text', event.delta.text, content.text || '');
-        } else if (event.delta.type === 'input_json_delta' && content.type === 'tool_use') {
-          if (content.input) {
-            this._emit('inputJson', event.delta.partial_json, content.input);
+        switch (event.delta.type) {
+          case 'text_delta': {
+            if (content.type === 'text') {
+              this._emit('text', event.delta.text, content.text || '');
+            }
+            break;
           }
+          case 'citations_delta': {
+            if (content.type === 'text') {
+              this._emit('citation', event.delta.citation, content.citations ?? []);
+            }
+            break;
+          }
+          case 'input_json_delta': {
+            if (content.type === 'tool_use' && content.input) {
+              this._emit('inputJson', event.delta.partial_json, content.input);
+            }
+            break;
+          }
+          case 'thinking_delta': {
+            if (content.type === 'thinking') {
+              this._emit('thinking', event.delta.thinking, content.thinking);
+            }
+            break;
+          }
+          case 'signature_delta': {
+            if (content.type === 'thinking') {
+              this._emit('signature', content.signature);
+            }
+            break;
+          }
+          default:
+            checkNever(event.delta);
         }
         break;
       }
@@ -505,24 +536,55 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
         return snapshot;
       case 'content_block_delta': {
         const snapshotContent = snapshot.content.at(event.index);
-        if (snapshotContent?.type === 'text' && event.delta.type === 'text_delta') {
-          snapshotContent.text += event.delta.text;
-        } else if (snapshotContent?.type === 'tool_use' && event.delta.type === 'input_json_delta') {
-          // we need to keep track of the raw JSON string as well so that we can
-          // re-parse it for each delta, for now we just store it as an untyped
-          // non-enumerable property on the snapshot
-          let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || '';
-          jsonBuf += event.delta.partial_json;
-
-          Object.defineProperty(snapshotContent, JSON_BUF_PROPERTY, {
-            value: jsonBuf,
-            enumerable: false,
-            writable: true,
-          });
-
-          if (jsonBuf) {
-            snapshotContent.input = partialParse(jsonBuf);
+
+        switch (event.delta.type) {
+          case 'text_delta': {
+            if (snapshotContent?.type === 'text') {
+              snapshotContent.text += event.delta.text;
+            }
+            break;
           }
+          case 'citations_delta': {
+            if (snapshotContent?.type === 'text') {
+              snapshotContent.citations ??= [];
+              snapshotContent.citations.push(event.delta.citation);
+            }
+            break;
+          }
+          case 'input_json_delta': {
+            if (snapshotContent?.type === 'tool_use') {
+              // we need to keep track of the raw JSON string as well so that we can
+              // re-parse it for each delta, for now we just store it as an untyped
+              // non-enumerable property on the snapshot
+              let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || '';
+              jsonBuf += event.delta.partial_json;
+
+              Object.defineProperty(snapshotContent, JSON_BUF_PROPERTY, {
+                value: jsonBuf,
+                enumerable: false,
+                writable: true,
+              });
+
+              if (jsonBuf) {
+                snapshotContent.input = partialParse(jsonBuf);
+              }
+            }
+            break;
+          }
+          case 'thinking_delta': {
+            if (snapshotContent?.type === 'thinking') {
+              snapshotContent.thinking += event.delta.thinking;
+            }
+            break;
+          }
+          case 'signature_delta': {
+            if (snapshotContent?.type === 'thinking') {
+              snapshotContent.signature = event.delta.signature;
+            }
+            break;
+          }
+          default:
+            checkNever(event.delta);
         }
         return snapshot;
       }
@@ -597,3 +659,6 @@ export class BetaMessageStream implements AsyncIterable<BetaMessageStreamEvent>
     return stream.toReadableStream();
   }
 }
+
+// used to ensure exhaustive case matching without throwing a runtime error
+function checkNever(x: never) {}

package/src/lib/MessageStream.ts

@@ -9,6 +9,7 @@ import {
   type MessageCreateParams,
   type MessageCreateParamsBase,
   type TextBlock,
+  type TextCitation,
 } from "../resources/messages.js";
 import { type ReadableStream, type Response } from "../_shims/index.js";
 import { Stream } from "../streaming.js";
@@ -18,7 +19,10 @@ export interface MessageStreamEvents {
   connect: () => void;
   streamEvent: (event: MessageStreamEvent, snapshot: Message) => void;
   text: (textDelta: string, textSnapshot: string) => void;
+  citation: (citation: TextCitation, citationsSnapshot: TextCitation[]) => void;
   inputJson: (partialJson: string, jsonSnapshot: unknown) => void;
+  thinking: (thinkingDelta: string, thinkingSnapshot: string) => void;
+  signature: (signature: string) => void;
   message: (message: Message) => void;
   contentBlock: (content: ContentBlock) => void;
   finalMessage: (message: Message) => void;
@@ -413,12 +417,39 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
     switch (event.type) {
       case 'content_block_delta': {
         const content = messageSnapshot.content.at(-1)!;
-        if (event.delta.type === 'text_delta' && content.type === 'text') {
-          this._emit('text', event.delta.text, content.text || '');
-        } else if (event.delta.type === 'input_json_delta' && content.type === 'tool_use') {
-          if (content.input) {
-            this._emit('inputJson', event.delta.partial_json, content.input);
+        switch (event.delta.type) {
+          case 'text_delta': {
+            if (content.type === 'text') {
+              this._emit('text', event.delta.text, content.text || '');
+            }
+            break;
           }
+          case 'citations_delta': {
+            if (content.type === 'text') {
+              this._emit('citation', event.delta.citation, content.citations ?? []);
+            }
+            break;
+          }
+          case 'input_json_delta': {
+            if (content.type === 'tool_use' && content.input) {
+              this._emit('inputJson', event.delta.partial_json, content.input);
+            }
+            break;
+          }
+          case 'thinking_delta': {
+            if (content.type === 'thinking') {
+              this._emit('thinking', event.delta.thinking, content.thinking);
+            }
+            break;
+          }
+          case 'signature_delta': {
+            if (content.type === 'thinking') {
+              this._emit('signature', content.signature);
+            }
+            break;
+          }
+          default:
+            checkNever(event.delta);
         }
         break;
       }
@@ -505,25 +536,57 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
         return snapshot;
       case 'content_block_delta': {
         const snapshotContent = snapshot.content.at(event.index);
-        if (snapshotContent?.type === 'text' && event.delta.type === 'text_delta') {
-          snapshotContent.text += event.delta.text;
-        } else if (snapshotContent?.type === 'tool_use' && event.delta.type === 'input_json_delta') {
-          // we need to keep track of the raw JSON string as well so that we can
-          // re-parse it for each delta, for now we just store it as an untyped
-          // non-enumerable property on the snapshot
-          let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || '';
-          jsonBuf += event.delta.partial_json;
-
-          Object.defineProperty(snapshotContent, JSON_BUF_PROPERTY, {
-            value: jsonBuf,
-            enumerable: false,
-            writable: true,
-          });
-
-          if (jsonBuf) {
-            snapshotContent.input = partialParse(jsonBuf);
+
+        switch (event.delta.type) {
+          case 'text_delta': {
+            if (snapshotContent?.type === 'text') {
+              snapshotContent.text += event.delta.text;
+            }
+            break;
+          }
+          case 'citations_delta': {
+            if (snapshotContent?.type === 'text') {
+              snapshotContent.citations ??= [];
+              snapshotContent.citations.push(event.delta.citation);
+            }
+            break;
           }
+          case 'input_json_delta': {
+            if (snapshotContent?.type === 'tool_use') {
+              // we need to keep track of the raw JSON string as well so that we can
+              // re-parse it for each delta, for now we just store it as an untyped
+              // non-enumerable property on the snapshot
+              let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || '';
+              jsonBuf += event.delta.partial_json;
+
+              Object.defineProperty(snapshotContent, JSON_BUF_PROPERTY, {
+                value: jsonBuf,
+                enumerable: false,
+                writable: true,
+              });
+
+              if (jsonBuf) {
+                snapshotContent.input = partialParse(jsonBuf);
+              }
+            }
+            break;
+          }
+          case 'thinking_delta': {
+            if (snapshotContent?.type === 'thinking') {
+              snapshotContent.thinking += event.delta.thinking;
+            }
+            break;
+          }
+          case 'signature_delta': {
+            if (snapshotContent?.type === 'thinking') {
+              snapshotContent.signature = event.delta.signature;
+            }
+            break;
+          }
+          default:
+            checkNever(event.delta);
         }
+
         return snapshot;
       }
       case 'content_block_stop':
@@ -597,3 +660,6 @@ export class MessageStream implements AsyncIterable<MessageStreamEvent> {
     return stream.toReadableStream();
   }
 }
+
+// used to ensure exhaustive case matching without throwing a runtime error
+function checkNever(x: never) {}

package/src/pagination.ts

@@ -45,6 +45,14 @@ export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item>
     return this.data ?? [];
   }
 
+  override hasNextPage(): boolean {
+    if (this.has_more === false) {
+      return false;
+    }
+
+    return super.hasNextPage();
+  }
+
   // @deprecated Please use `nextPageInfo()` instead
   nextPageParams(): Partial<PageParams> | null {
     const info = this.nextPageInfo();

package/src/resources/beta/beta.ts

@@ -35,20 +35,32 @@ import {
   BetaRawMessageStartEvent,
   BetaRawMessageStopEvent,
   BetaRawMessageStreamEvent,
+  BetaRedactedThinkingBlock,
+  BetaRedactedThinkingBlockParam,
+  BetaSignatureDelta,
   BetaTextBlock,
   BetaTextBlockParam,
   BetaTextCitation,
   BetaTextCitationParam,
   BetaTextDelta,
+  BetaThinkingBlock,
+  BetaThinkingBlockParam,
+  BetaThinkingConfigDisabled,
+  BetaThinkingConfigEnabled,
+  BetaThinkingConfigParam,
+  BetaThinkingDelta,
   BetaTool,
   BetaToolBash20241022,
+  BetaToolBash20250124,
   BetaToolChoice,
   BetaToolChoiceAny,
   BetaToolChoiceAuto,
   BetaToolChoiceTool,
   BetaToolComputerUse20241022,
+  BetaToolComputerUse20250124,
   BetaToolResultBlockParam,
   BetaToolTextEditor20241022,
+  BetaToolTextEditor20250124,
   BetaToolUnion,
   BetaToolUseBlock,
   BetaToolUseBlockParam,
@@ -70,8 +82,11 @@ export type AnthropicBeta =
   | 'message-batches-2024-09-24'
   | 'prompt-caching-2024-07-31'
   | 'computer-use-2024-10-22'
+  | 'computer-use-2025-01-24'
   | 'pdfs-2024-09-25'
-  | 'token-counting-2024-11-01';
+  | 'token-counting-2024-11-01'
+  | 'token-efficient-tools-2025-02-19'
+  | 'output-128k-2025-02-19';
 
 export interface BetaAPIError {
   message: string;
@@ -203,20 +218,32 @@ export declare namespace Beta {
     type BetaRawMessageStartEvent as BetaRawMessageStartEvent,
     type BetaRawMessageStopEvent as BetaRawMessageStopEvent,
     type BetaRawMessageStreamEvent as BetaRawMessageStreamEvent,
+    type BetaRedactedThinkingBlock as BetaRedactedThinkingBlock,
+    type BetaRedactedThinkingBlockParam as BetaRedactedThinkingBlockParam,
+    type BetaSignatureDelta as BetaSignatureDelta,
     type BetaTextBlock as BetaTextBlock,
     type BetaTextBlockParam as BetaTextBlockParam,
     type BetaTextCitation as BetaTextCitation,
     type BetaTextCitationParam as BetaTextCitationParam,
     type BetaTextDelta as BetaTextDelta,
+    type BetaThinkingBlock as BetaThinkingBlock,
+    type BetaThinkingBlockParam as BetaThinkingBlockParam,
+    type BetaThinkingConfigDisabled as BetaThinkingConfigDisabled,
+    type BetaThinkingConfigEnabled as BetaThinkingConfigEnabled,
+    type BetaThinkingConfigParam as BetaThinkingConfigParam,
+    type BetaThinkingDelta as BetaThinkingDelta,
     type BetaTool as BetaTool,
     type BetaToolBash20241022 as BetaToolBash20241022,
+    type BetaToolBash20250124 as BetaToolBash20250124,
     type BetaToolChoice as BetaToolChoice,
     type BetaToolChoiceAny as BetaToolChoiceAny,
     type BetaToolChoiceAuto as BetaToolChoiceAuto,
     type BetaToolChoiceTool as BetaToolChoiceTool,
     type BetaToolComputerUse20241022 as BetaToolComputerUse20241022,
+    type BetaToolComputerUse20250124 as BetaToolComputerUse20250124,
     type BetaToolResultBlockParam as BetaToolResultBlockParam,
     type BetaToolTextEditor20241022 as BetaToolTextEditor20241022,
+    type BetaToolTextEditor20250124 as BetaToolTextEditor20250124,
     type BetaToolUnion as BetaToolUnion,
     type BetaToolUseBlock as BetaToolUseBlock,
     type BetaToolUseBlockParam as BetaToolUseBlockParam,

package/src/resources/beta/index.ts

@@ -48,20 +48,32 @@ export {
   type BetaRawMessageStartEvent,
   type BetaRawMessageStopEvent,
   type BetaRawMessageStreamEvent,
+  type BetaRedactedThinkingBlock,
+  type BetaRedactedThinkingBlockParam,
+  type BetaSignatureDelta,
   type BetaTextBlock,
   type BetaTextBlockParam,
   type BetaTextCitation,
   type BetaTextCitationParam,
   type BetaTextDelta,
+  type BetaThinkingBlock,
+  type BetaThinkingBlockParam,
+  type BetaThinkingConfigDisabled,
+  type BetaThinkingConfigEnabled,
+  type BetaThinkingConfigParam,
+  type BetaThinkingDelta,
   type BetaTool,
   type BetaToolBash20241022,
+  type BetaToolBash20250124,
   type BetaToolChoice,
   type BetaToolChoiceAny,
   type BetaToolChoiceAuto,
   type BetaToolChoiceTool,
   type BetaToolComputerUse20241022,
+  type BetaToolComputerUse20250124,
   type BetaToolResultBlockParam,
   type BetaToolTextEditor20241022,
+  type BetaToolTextEditor20250124,
   type BetaToolUnion,
   type BetaToolUseBlock,
   type BetaToolUseBlockParam,