@anthropic-ai/sdk 0.125.0 → 0.127.0

package/src/lib/tools/BetaToolRunner.ts

@@ -3,6 +3,7 @@ import { ToolError } from './ToolError';
 import { Anthropic } from '../..';
 import { AnthropicError } from '../../core/error';
 import {
+  BetaCompactionConfig,
   BetaContentBlockParam,
   BetaMessage,
   BetaMessageParam,
@@ -20,12 +21,14 @@ import { RequestOptions } from '../../internal/request-options';
 import { buildHeaders } from '../../internal/headers';
 import { promiseWithResolvers } from '../../internal/utils/promise';
 import { checkNever } from '../../internal/utils/values';
+import { loggerFor } from '../../internal/utils/log';
 import { CompactionControl, DEFAULT_SUMMARY_PROMPT, DEFAULT_TOKEN_THRESHOLD } from './CompactionControl';
 import {
   collectStainlessHelpers,
   helperHeader,
   STAINLESS_HELPER_HEADER,
 } from '../../internal/stainless-helper-header';
+import type { Simplify } from '../internal/types';
 
 /**
  * A ToolRunner handles the automatic conversation loop between the assistant and tools.
@@ -43,6 +46,8 @@ export class BetaToolRunner<Stream extends boolean> {
   #options: BetaToolRunnerRequestOptions;
   /** Promise for the last message received from the assistant */
   #message?: Promise<BetaMessage> | undefined;
+  /** The stream of the request in progress, when streaming */
+  #stream?: BetaMessageStream | undefined;
   /** Cached tool response to avoid redundant executions */
   #toolResponse?: Promise<BetaMessageParam | null> | undefined;
   /** Promise resolvers for waiting on completion */
@@ -53,12 +58,17 @@ export class BetaToolRunner<Stream extends boolean> {
   };
   /** Number of iterations (API requests) made so far */
   #iterationCount = 0;
+  /** A compaction scheduled with `compactBeforeNextTurn()`, in flight until its response has been handled */
+  #compaction: Compaction = { status: 'idle' };
+  /** Whether the last turn was paused; a scheduled compaction waits for it to be resumed */
+  #turnPaused = false;
 
   constructor(
     private client: Anthropic,
     params: BetaToolRunnerParams,
     options?: BetaToolRunnerRequestOptions,
   ) {
+    rejectCompactionParam(params);
     this.#state = {
       params: {
         // You can't clone the entire params since there are functions as handlers.
@@ -190,7 +200,6 @@ export class BetaToolRunner<Stream extends boolean> {
 
     try {
       while (true) {
-        let stream;
         try {
           if (
             this.#state.params.max_iterations &&
@@ -199,6 +208,12 @@ export class BetaToolRunner<Stream extends boolean> {
             break;
           }
 
+          // The API can't compact a conversation that ends mid-turn, so a paused turn is resumed first.
+          if (this.#compaction.status === 'scheduled' && !this.#turnPaused) {
+            yield* this.#compact(this.#compaction.config);
+            continue;
+          }
+
           this.#mutated = false;
           this.#toolResponse = undefined;
           this.#iterationCount++;
@@ -206,23 +221,14 @@ export class BetaToolRunner<Stream extends boolean> {
 
           const { max_iterations, compactionControl, ...params } = this.#state.params;
 
-          if (params.stream) {
-            stream = this.client.beta.messages.stream({ ...params }, this.#options);
-            this.#message = stream.finalMessage();
-            // Make sure that this promise doesn't throw before we get the option to do something about it.
-            // Error will be caught when we call await this.#message ultimately
-            this.#message.catch(() => {});
-            yield stream as any;
-          } else {
-            this.#message = this.client.beta.messages.create({ ...params, stream: false }, this.#options);
-            yield this.#message as any;
-          }
+          yield* this.#send(params);
 
           const isCompacted = await this.#checkAndCompact();
           if (!isCompacted) {
             if (!this.#mutated) {
-              const message = await this.#message;
+              const message = await this.#message!;
               const nextStep = determineNextStepFromStopReason(message.stop_reason);
+              this.#turnPaused = nextStep === 'resume';
               this.#state.params.messages.push({ role: message.role, content: message.content });
 
               // Container-bound server tools reject a follow-up request that omits the container the
@@ -237,24 +243,28 @@ export class BetaToolRunner<Stream extends boolean> {
               }
 
               if (nextStep === 'stop') {
+                yield* this.#compactAfterFinalTurn();
                 break;
               }
               if (nextStep === 'resume') {
                 continue;
               }
+            } else {
+              // The caller has taken over the history, so the last response no longer says how it ends.
+              this.#turnPaused = false;
             }
 
             const toolMessage = await this.#generateToolResponse(this.#state.params.messages.at(-1)!);
             if (toolMessage) {
               this.#state.params.messages.push(toolMessage);
             } else if (!this.#mutated) {
+              yield* this.#compactAfterFinalTurn();
               break;
             }
           }
         } finally {
-          if (stream) {
-            stream.abort();
-          }
+          this.#stream?.abort();
+          this.#stream = undefined;
         }
       }
 
@@ -273,6 +283,69 @@ export class BetaToolRunner<Stream extends boolean> {
     }
   }
 
+  /**
+   * Sends one request and yields its message, or its stream when streaming. `#message` and `#stream` are set
+   * before the yield, so they are there while the caller handles the item; the loop aborts the stream at the
+   * end of the iteration.
+   */
+  async *#send(params: MessageCreateParams): AsyncGenerator<BetaToolRunnerItem<Stream>, void, undefined> {
+    if (params.stream) {
+      this.#stream = this.client.beta.messages.stream({ ...params }, this.#options);
+      this.#message = this.#stream.finalMessage();
+      // Make sure that this promise doesn't throw before we get the option to do something about it.
+      // Error will be caught when we call await this.#message ultimately
+      this.#message.catch(() => {});
+      yield this.#stream as any;
+    } else {
+      this.#message = this.client.beta.messages.create({ ...params, stream: false }, this.#options);
+      yield this.#message as any;
+    }
+  }
+
+  async *#compact(
+    compaction: BetaCompactionConfig,
+  ): AsyncGenerator<BetaToolRunnerItem<Stream>, void, undefined> {
+    rejectCompactionEdit(this.#state.params);
+    // The API refuses `compaction` alongside `context_management`; later requests keep it.
+    const { max_iterations, compactionControl, context_management, ...params } = this.#state.params;
+    this.#compaction = { status: 'in_flight' };
+    this.#toolResponse = undefined;
+    const lastMessage = this.#message;
+
+    try {
+      yield* this.#send({ ...params, compaction });
+      const message = await this.#message!;
+      if (message.content.some((block) => block.type === 'compaction' && block.content)) {
+        // The response has to be sent back as it came, first, replacing the messages it summarizes.
+        this.#state.params.messages = [{ role: message.role, content: message.content }];
+      } else {
+        loggerFor(this.client).warn('Compaction produced no summary; keeping the conversation as it is.');
+        // If the run ends here, `done()` resolves to the last real message rather than this response.
+        this.#message = lastMessage;
+      }
+    } finally {
+      this.#compaction = { status: 'idle' };
+    }
+  }
+
+  async *#compactAfterFinalTurn(): AsyncGenerator<BetaToolRunnerItem<Stream>, void, undefined> {
+    if (this.#compaction.status !== 'scheduled') {
+      return;
+    }
+    const lastContent = this.#state.params.messages.at(-1)?.content;
+    if (Array.isArray(lastContent) && lastContent.some((block) => block.type === 'tool_use')) {
+      // A turn that was cut short can end with tool calls that are never run, and the API can't
+      // compact a conversation whose last turn has an unanswered tool call.
+      loggerFor(this.client).warn(
+        'The pending compaction was skipped because the last turn ended with tool calls that were not run. ' +
+          'Call `compactBeforeNextTurn()` again if you continue the conversation.',
+      );
+      this.#compaction = { status: 'idle' };
+      return;
+    }
+    yield* this.#compact(this.#compaction.config);
+  }
+
   /**
    * Update the parameters for the next API call. This invalidates any cached tool responses.
    *
@@ -297,11 +370,19 @@ export class BetaToolRunner<Stream extends boolean> {
   setMessagesParams(
     paramsOrMutator: BetaToolRunnerParams | ((prevParams: BetaToolRunnerParams) => BetaToolRunnerParams),
   ) {
-    if (typeof paramsOrMutator === 'function') {
-      this.#state.params = paramsOrMutator(this.#state.params);
-    } else {
-      this.#state.params = paramsOrMutator;
+    const params =
+      typeof paramsOrMutator === 'function' ? paramsOrMutator(this.#state.params) : paramsOrMutator;
+    rejectCompactionParam(params);
+    if (this.#compaction.status !== 'idle') {
+      rejectCompactionEdit(params);
     }
+    if (this.#compaction.status === 'in_flight' && params.messages !== this.#state.params.messages) {
+      throw new AnthropicError(
+        "Message params can't be changed while the conversation is being compacted, because the compaction " +
+          'response is about to replace them. Change them after this iteration instead.',
+      );
+    }
+    this.#state.params = params;
     this.#mutated = true;
     // Invalidate cached tool response since parameters changed
     this.#toolResponse = undefined;
@@ -458,6 +539,28 @@ export class BetaToolRunner<Stream extends boolean> {
     }));
   }
 
+  /**
+   * Schedule a compaction of the conversation. Once the current turn has finished, including any tool
+   * calls, the runner requests a summary and replaces the message history with the compaction response,
+   * which is yielded like any other message. Requires the `compact-2026-09-04` beta.
+   *
+   * @param compaction - The config to send, as `messages.create()` takes it. Defaults to `{ type: 'summarize' }`
+   *
+   * @example
+   * for await (const message of runner) {
+   *   if (message.usage.input_tokens > 100_000) {
+   *     runner.compactBeforeNextTurn();
+   *   }
+   * }
+   */
+  compactBeforeNextTurn(compaction?: BetaCompactionConfig): void {
+    if (this.#compaction.status === 'in_flight') {
+      return;
+    }
+    rejectCompactionEdit(this.#state.params);
+    this.#compaction = { status: 'scheduled', config: compaction ?? { type: 'summarize' } };
+  }
+
   /**
    * Makes the ToolRunner directly awaitable, equivalent to calling .runUntilDone()
    * This allows using `await runner` instead of `await runner.runUntilDone()`
@@ -470,6 +573,26 @@ export class BetaToolRunner<Stream extends boolean> {
   }
 }
 
+function rejectCompactionParam(params: BetaToolRunnerParams): void {
+  if ('compaction' in params && params.compaction != null) {
+    throw new AnthropicError(
+      '`compaction` cannot be set on a tool runner: every request in the loop would compact again. ' +
+        'Call `runner.compactBeforeNextTurn()` when the conversation should be compacted instead.',
+    );
+  }
+}
+
+function rejectCompactionEdit(params: BetaToolRunnerParams): void {
+  // The compaction request is sent without `context_management`, so the API can't refuse the pair there:
+  // it would run and bill the compaction, then refuse the next request.
+  if (params.context_management?.edits?.some((edit) => edit.type.startsWith('compact_'))) {
+    throw new AnthropicError(
+      "`compactBeforeNextTurn()` can't be used while `context_management` has a compaction edit, " +
+        "because the API doesn't accept a compaction block together with one. Remove the edit first.",
+    );
+  }
+}
+
 async function generateToolResponse(
   params: BetaToolRunnerParams,
   lastMessage = params.messages.at(-1),
@@ -644,14 +767,14 @@ function determineNextStepFromStopReason(stopReason: BetaStopReason | null): Nex
   }
 }
 
-// vendored from typefest just to make things look a bit nicer on hover
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
-
 /**
  * Parameters for creating a ToolRunner, extending MessageCreateParams with runnable tools.
+ *
+ * `compaction` is left out because every request in the loop would compact again; call
+ * `BetaToolRunner.compactBeforeNextTurn()` instead.
  */
 export type BetaToolRunnerParams = Simplify<
-  Omit<MessageCreateParams, 'tools'> & {
+  Omit<MessageCreateParams, 'tools' | 'compaction'> & {
     tools: (BetaToolUnion | BetaRunnableTool<any>)[];
     /**
      * Maximum number of iterations (API requests) to make in the tool execution loop.
@@ -669,3 +792,13 @@ export type BetaToolRunnerParams = Simplify<
 >;
 
 export type BetaToolRunnerRequestOptions = Pick<RequestOptions, 'headers' | 'signal' | 'fallbackState'>;
+
+type Compaction =
+  | { status: 'idle' }
+  | { status: 'scheduled'; config: BetaCompactionConfig }
+  | { status: 'in_flight' };
+
+type BetaToolRunnerItem<Stream extends boolean> =
+  Stream extends true ? BetaMessageStream
+  : Stream extends false ? BetaMessage
+  : BetaMessage | BetaMessageStream;

package/src/lib/transform-json-schema.ts

@@ -28,12 +28,8 @@ export function transformJSONSchema(jsonSchema: JSONSchema): JSONSchema {
 function _transformJSONSchema(jsonSchema: JSONSchema): JSONSchema {
   const strictSchema: JSONSchema = {};
 
-  const ref = pop(jsonSchema, '$ref');
-  if (ref !== undefined) {
-    strictSchema['$ref'] = ref;
-    return strictSchema;
-  }
-
+  // `$defs` must be handled before the `$ref` early-return so that a root-level
+  // `$ref` with sibling `$defs` keeps its (transformed) definitions.
   const defs = pop(jsonSchema, '$defs');
   if (defs !== undefined) {
     const strictDefs: Record<string, any> = {};
@@ -43,6 +39,12 @@ function _transformJSONSchema(jsonSchema: JSONSchema): JSONSchema {
     }
   }
 
+  const ref = pop(jsonSchema, '$ref');
+  if (ref !== undefined) {
+    strictSchema['$ref'] = ref;
+    return strictSchema;
+  }
+
   const type = pop(jsonSchema, 'type');
   const anyOf = pop(jsonSchema, 'anyOf');
   const oneOf = pop(jsonSchema, 'oneOf');

package/src/resources/beta/beta.ts

@@ -115,6 +115,7 @@ import {
 import * as ModelsAPI from './models';
 import {
   BetaCapabilitySupport,
+  BetaCompactionCapability,
   BetaContextManagementCapability,
   BetaEffortCapability,
   BetaModelCapabilities,
@@ -407,6 +408,7 @@ import {
   BetaCompact20260112Edit,
   BetaCompactionBlock,
   BetaCompactionBlockParam,
+  BetaCompactionConfig,
   BetaCompactionContentBlockDelta,
   BetaCompactionIterationUsage,
   BetaComputerCursorPositionConfig,
@@ -466,6 +468,7 @@ import {
   BetaJSONOutputFormat,
   BetaInputTokensClearAtLeast,
   BetaInputTokensTrigger,
+  BetaInputTransformation,
   BetaMCPToolResultBlock,
   BetaMCPToolUseBlock,
   BetaMCPToolUseBlockParam,
@@ -513,6 +516,7 @@ import {
   BetaSignatureDelta,
   BetaSkillParams,
   BetaStopReason,
+  BetaSummarizeCompaction,
   BetaSystemMessageOutputConfig,
   BetaTextBlock,
   BetaTextBlockParam,
@@ -538,6 +542,7 @@ import {
   BetaThinkingConfigParam,
   BetaThinkingDelta,
   BetaThinkingDroppedInputTransformation,
+  BetaThinkingMismatchAllowedInputTransformation,
   BetaThinkingPrefixMismatchBehavior,
   BetaThinkingTurns,
   BetaTokenTaskBudget,
@@ -582,6 +587,12 @@ import {
   BetaWebFetchToolResultErrorBlock,
   BetaWebFetchToolResultErrorBlockParam,
   BetaWebFetchToolResultErrorCode,
+  BetaWebFetchURLSourceAll,
+  BetaWebFetchURLSourceExcept,
+  BetaWebFetchURLSourceNone,
+  BetaWebFetchURLSourceOnly,
+  BetaWebFetchURLSourceToolReference,
+  BetaWebFetchURLSources,
   BetaWebSearchResultBlock,
   BetaWebSearchResultBlockParam,
   BetaWebSearchTool20250305,
@@ -753,7 +764,8 @@ export type AnthropicBeta =
   | 'ce-user-management-2026-07-13'
   | 'mid-conversation-output-config-2026-07-01'
   | 'thinking-binding-controls-2026-08-01'
-  | 'mid-conversation-system-clear-at-2026-08-21';
+  | 'mid-conversation-system-clear-at-2026-08-21'
+  | 'compact-2026-09-04';
 
 export interface BetaAPIError {
   message: string;
@@ -887,6 +899,7 @@ export declare namespace Beta {
   export {
     Models as Models,
     type BetaCapabilitySupport as BetaCapabilitySupport,
+    type BetaCompactionCapability as BetaCompactionCapability,
     type BetaContextManagementCapability as BetaContextManagementCapability,
     type BetaEffortCapability as BetaEffortCapability,
     type BetaModelCapabilities as BetaModelCapabilities,
@@ -1004,6 +1017,7 @@ export declare namespace Beta {
     type BetaCompact20260112Edit as BetaCompact20260112Edit,
     type BetaCompactionBlock as BetaCompactionBlock,
     type BetaCompactionBlockParam as BetaCompactionBlockParam,
+    type BetaCompactionConfig as BetaCompactionConfig,
     type BetaCompactionContentBlockDelta as BetaCompactionContentBlockDelta,
     type BetaCompactionIterationUsage as BetaCompactionIterationUsage,
     type BetaComputerCursorPositionConfig as BetaComputerCursorPositionConfig,
@@ -1063,6 +1077,7 @@ export declare namespace Beta {
     type BetaJSONOutputFormat as BetaJSONOutputFormat,
     type BetaInputTokensClearAtLeast as BetaInputTokensClearAtLeast,
     type BetaInputTokensTrigger as BetaInputTokensTrigger,
+    type BetaInputTransformation as BetaInputTransformation,
     type BetaMCPToolConfig as BetaMCPToolConfig,
     type BetaMCPToolDefaultConfig as BetaMCPToolDefaultConfig,
     type BetaMCPToolResultBlock as BetaMCPToolResultBlock,
@@ -1112,6 +1127,7 @@ export declare namespace Beta {
     type BetaSignatureDelta as BetaSignatureDelta,
     type BetaSkillParams as BetaSkillParams,
     type BetaStopReason as BetaStopReason,
+    type BetaSummarizeCompaction as BetaSummarizeCompaction,
     type BetaSystemMessageOutputConfig as BetaSystemMessageOutputConfig,
     type BetaTextBlock as BetaTextBlock,
     type BetaTextBlockParam as BetaTextBlockParam,
@@ -1137,6 +1153,7 @@ export declare namespace Beta {
     type BetaThinkingConfigParam as BetaThinkingConfigParam,
     type BetaThinkingDelta as BetaThinkingDelta,
     type BetaThinkingDroppedInputTransformation as BetaThinkingDroppedInputTransformation,
+    type BetaThinkingMismatchAllowedInputTransformation as BetaThinkingMismatchAllowedInputTransformation,
     type BetaThinkingPrefixMismatchBehavior as BetaThinkingPrefixMismatchBehavior,
     type BetaThinkingTurns as BetaThinkingTurns,
     type BetaTokenTaskBudget as BetaTokenTaskBudget,
@@ -1181,6 +1198,12 @@ export declare namespace Beta {
     type BetaWebFetchToolResultErrorBlock as BetaWebFetchToolResultErrorBlock,
     type BetaWebFetchToolResultErrorBlockParam as BetaWebFetchToolResultErrorBlockParam,
     type BetaWebFetchToolResultErrorCode as BetaWebFetchToolResultErrorCode,
+    type BetaWebFetchURLSourceAll as BetaWebFetchURLSourceAll,
+    type BetaWebFetchURLSourceExcept as BetaWebFetchURLSourceExcept,
+    type BetaWebFetchURLSourceNone as BetaWebFetchURLSourceNone,
+    type BetaWebFetchURLSourceOnly as BetaWebFetchURLSourceOnly,
+    type BetaWebFetchURLSourceToolReference as BetaWebFetchURLSourceToolReference,
+    type BetaWebFetchURLSources as BetaWebFetchURLSources,
     type BetaWebSearchResultBlock as BetaWebSearchResultBlock,
     type BetaWebSearchResultBlockParam as BetaWebSearchResultBlockParam,
     type BetaWebSearchTool20250305 as BetaWebSearchTool20250305,

package/src/resources/beta/deployment-runs.ts

@@ -311,6 +311,10 @@ export type BetaManagedAgentsTriggerContext =
 
 /**
  * What triggered a deployment run.
+ *
+ * - `schedule` - The run was fired by the deployment's cron schedule.
+ * - `manual` - The run was started manually by creating a session directly against
+ *   the deployment.
  */
 export type BetaManagedAgentsTriggerType = 'schedule' | 'manual';
 

package/src/resources/beta/deployments.ts

@@ -460,6 +460,11 @@ export type BetaManagedAgentsDeploymentPausedReasonError =
 
 /**
  * Lifecycle status of a deployment.
+ *
+ * - `active` - The deployment is active and can run sessions. Archived deployments
+ *   also report this status; check `archived_at` to distinguish them.
+ * - `paused` - The deployment is paused. Autonomous triggers are suppressed;
+ *   manual runs are still permitted.
  */
 export type BetaManagedAgentsDeploymentStatus = 'active' | 'paused';
 

package/src/resources/beta/dreams.ts

@@ -190,11 +190,6 @@ export interface BetaDream {
    */
   model: BetaDreamModelConfig;
 
-  /**
-   * The default destination: the job creates a new output memory store as a clone of
-   * the memory_store input and writes the consolidated memories into it. The input
-   * store is never mutated.
-   */
   output_behavior: BetaOutputBehavior;
 
   outputs: Array<BetaDreamOutput>;
@@ -223,11 +218,6 @@ export interface BetaDreamError {
   type: string;
 }
 
-/**
- * An input memory store the dream reads from. The dream never mutates this store
- * unless it is also the destination: with output_behavior {type:
- * "update_existing"} the job consolidates this store in place.
- */
 export type BetaDreamInput = BetaDreamMemoryStoreInput | BetaDreamSessionsInput;
 
 /**
@@ -305,6 +295,23 @@ export interface BetaDreamSessionsInput {
 
 /**
  * Lifecycle status of a Dream.
+ *
+ * - `pending` - The dream is waiting to start and hasn't read its inputs yet.
+ *
+ *   `outputs` is empty and every `usage` count is zero.
+ *
+ * - `running` - The dream is reading its inputs and writing its result.
+ *
+ *   `usage` updates while the dream has this status.
+ *
+ * - `completed` - The dream finished and its output memory store holds the
+ *   complete result.
+ * - `failed` - The dream stopped with an error, which `error` describes.
+ *
+ *   If `outputs` references a memory store, that memory store keeps what the dream
+ *   wrote before it stopped.
+ *
+ * - `canceled` - The caller canceled the dream before it completed.
  */
 export type BetaDreamStatus = 'pending' | 'running' | 'completed' | 'failed' | 'canceled';
 
@@ -333,15 +340,6 @@ export interface BetaDreamUsage {
   output_tokens: number;
 }
 
-/**
- * The `output_behavior.memory_store_id` target is still held by a prior
- * `{type: "update_existing"}` dream — one that is `pending` or `running`, or was
- * canceled with its final writes still landing. Rarely the named dream has just
- * finished (`completed`/`failed`) and its execution is still closing; an immediate
- * retry then almost always succeeds. The message names the holding dream when the
- * server can identify it (rarely omitted); poll it to a terminal state or cancel
- * it, then retry. Carried with `x-should-retry: false`.
- */
 export type BetaDreamingError =
   | BetaAPI.BetaInvalidRequestError
   | BetaAPI.BetaAuthenticationError
@@ -354,11 +352,6 @@ export type BetaDreamingError =
   | BetaAPI.BetaOverloadedError
   | BetaTargetStoreHeldError;
 
-/**
- * The default destination: the job creates a new output memory store as a clone of
- * the memory_store input and writes the consolidated memories into it. The input
- * store is never mutated.
- */
 export type BetaOutputBehavior = BetaOutputBehaviorCreateNew | BetaOutputBehaviorUpdateExisting;
 
 /**
@@ -407,7 +400,7 @@ export interface DreamCreateParams {
   inputs: Array<BetaDreamInput>;
 
   /**
-   * Body param: Model identifier and configuration applied to every pipeline stage.
+   * Body param
    */
   model: string | BetaDreamModelConfigParam;
 
@@ -417,9 +410,7 @@ export interface DreamCreateParams {
   instructions?: string | null;
 
   /**
-   * Body param: The default destination: the job creates a new output memory store
-   * as a clone of the memory_store input and writes the consolidated memories into
-   * it. The input store is never mutated.
+   * Body param
    */
   output_behavior?: BetaOutputBehavior;
 

package/src/resources/beta/index.ts

@@ -335,6 +335,7 @@ export {
   type BetaCompact20260112Edit,
   type BetaCompactionBlock,
   type BetaCompactionBlockParam,
+  type BetaCompactionConfig,
   type BetaCompactionContentBlockDelta,
   type BetaCompactionIterationUsage,
   type BetaComputerCursorPositionConfig,
@@ -393,6 +394,7 @@ export {
   type BetaInputJSONDelta,
   type BetaInputTokensClearAtLeast,
   type BetaInputTokensTrigger,
+  type BetaInputTransformation,
   type BetaIterationsUsage,
   type BetaJSONOutputFormat,
   type BetaMCPToolConfig,
@@ -444,6 +446,7 @@ export {
   type BetaSignatureDelta,
   type BetaSkillParams,
   type BetaStopReason,
+  type BetaSummarizeCompaction,
   type BetaSystemMessageOutputConfig,
   type BetaTextBlock,
   type BetaTextBlockParam,
@@ -469,6 +472,7 @@ export {
   type BetaThinkingConfigParam,
   type BetaThinkingDelta,
   type BetaThinkingDroppedInputTransformation,
+  type BetaThinkingMismatchAllowedInputTransformation,
   type BetaThinkingPrefixMismatchBehavior,
   type BetaThinkingTurns,
   type BetaTokenTaskBudget,
@@ -521,6 +525,12 @@ export {
   type BetaWebFetchToolResultErrorBlock,
   type BetaWebFetchToolResultErrorBlockParam,
   type BetaWebFetchToolResultErrorCode,
+  type BetaWebFetchURLSourceAll,
+  type BetaWebFetchURLSourceExcept,
+  type BetaWebFetchURLSourceNone,
+  type BetaWebFetchURLSourceOnly,
+  type BetaWebFetchURLSourceToolReference,
+  type BetaWebFetchURLSources,
   type BetaWebSearchResultBlock,
   type BetaWebSearchResultBlockParam,
   type BetaWebSearchTool20250305,
@@ -543,6 +553,7 @@ export {
 export {
   Models,
   type BetaCapabilitySupport,
+  type BetaCompactionCapability,
   type BetaContextManagementCapability,
   type BetaEffortCapability,
   type BetaModelCapabilities,

package/src/resources/beta/memory-stores/memories.ts

@@ -346,6 +346,12 @@ export interface BetaManagedAgentsMemoryPrefix {
  * `content`. When omitted, the default is endpoint-specific: retrieve operations
  * default to `full`; list, create, and update operations default to `basic`.
  * Listing with `view=full` caps `limit` at 20.
+ *
+ * - `basic` - Return the object with `content` set to `null`. The
+ *   `content_size_bytes` and `content_sha256` fields remain populated, so sync
+ *   clients can diff without fetching content.
+ * - `full` - Return the object with `content` populated. On list endpoints,
+ *   `view=full` caps `limit` at 20.
  */
 export type BetaManagedAgentsMemoryView = 'basic' | 'full';
 

package/src/resources/beta/memory-stores/memory-versions.ts

@@ -236,6 +236,13 @@ export interface BetaManagedAgentsMemoryVersion {
 /**
  * The kind of mutation a `memory_version` records. Every non-no-op mutation to a
  * memory appends exactly one version row with one of these values.
+ *
+ * - `created` - The memory was created. The first version in any memory's lineage.
+ * - `modified` - The memory's `content`, `path`, or both were changed via update.
+ *   Writes the agent makes through the filesystem mount also appear as `modified`.
+ * - `deleted` - The memory was deleted. The `content`, `content_size_bytes`, and
+ *   `content_sha256` fields are `null` on this version. The preceding version,
+ *   while it is retained, records the deleted content's size and hash.
  */
 export type BetaManagedAgentsMemoryVersionOperation = 'created' | 'modified' | 'deleted';
 

package/src/resources/beta/messages/batches.ts

@@ -589,6 +589,18 @@ export namespace BatchCreateParams {
        */
       cache_control?: BetaMessagesAPI.BetaCacheControlEphemeral | null;
 
+      /**
+       * Compact the whole conversation and return a signed `compaction` block, alone,
+       * that a later request sends back first in `messages`, in place of the messages it
+       * summarizes. There is no trigger and no pause flag: sending the parameter
+       * compacts, and nothing is sampled after the block.
+       *
+       * The summarization prompt is the server's own unless `instructions` are given,
+       * which then replace it for this request; a value that is empty or only whitespace
+       * counts as absent.
+       */
+      compaction?: BetaMessagesAPI.BetaCompactionConfig | null;
+
       /**
        * Container identifier for reuse across requests.
        */
@@ -718,7 +730,7 @@ export namespace BatchCreateParams {
 
       /**
        * @deprecated Deprecated. Models released after Claude Opus 4.6 do not support
-       * setting temperature. A value of 1.0 of will be accepted for backwards
+       * setting temperature. A value of 1.0 will be accepted for backwards
        * compatibility, all other values will be rejected with a 400 error.
        */
       temperature?: number;