@anthropic-ai/sdk 0.126.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/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

@@ -295,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';
 

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/messages.ts

@@ -5000,7 +5000,7 @@ export interface BetaToolBash20250124 {
 }
 
 /**
- * Reference to a single MCP tool by its server and remote name — the same
+ * Reference to a single MCP tool by its server and remote name; the same
  * `server_name`/`name` pair `mcp_tool_use` carries.
  */
 export interface BetaToolChangeMCPToolReference {

package/src/resources/beta/organization/index.ts

@@ -50,7 +50,13 @@ export { Organization, type BetaOrganization, type BetaOrganizationRole } from '
 export {
   RateLimits,
   type BetaOrganizationRateLimit,
+  type BetaOrganizationRateLimitBatchGroup,
+  type BetaOrganizationRateLimitFilesGroup,
+  type BetaOrganizationRateLimitModelGroup,
+  type BetaOrganizationRateLimitSkillsGroup,
+  type BetaOrganizationRateLimitTokenCountGroup,
   type BetaOrganizationRateLimitValue,
+  type BetaOrganizationRateLimitWebSearchGroup,
   type RateLimitListParams,
   type BetaOrganizationRateLimitsPageCursor,
 } from './rate-limits';

package/src/resources/beta/organization/organization.ts

@@ -53,7 +53,13 @@ import {
 import * as RateLimitsAPI from './rate-limits';
 import {
   BetaOrganizationRateLimit,
+  BetaOrganizationRateLimitBatchGroup,
+  BetaOrganizationRateLimitFilesGroup,
+  BetaOrganizationRateLimitModelGroup,
+  BetaOrganizationRateLimitSkillsGroup,
+  BetaOrganizationRateLimitTokenCountGroup,
   BetaOrganizationRateLimitValue,
+  BetaOrganizationRateLimitWebSearchGroup,
   BetaOrganizationRateLimitsPageCursor,
   RateLimitListParams,
   RateLimits,
@@ -252,7 +258,13 @@ export declare namespace Organization {
   export {
     RateLimits as RateLimits,
     type BetaOrganizationRateLimit as BetaOrganizationRateLimit,
+    type BetaOrganizationRateLimitBatchGroup as BetaOrganizationRateLimitBatchGroup,
+    type BetaOrganizationRateLimitFilesGroup as BetaOrganizationRateLimitFilesGroup,
+    type BetaOrganizationRateLimitModelGroup as BetaOrganizationRateLimitModelGroup,
+    type BetaOrganizationRateLimitSkillsGroup as BetaOrganizationRateLimitSkillsGroup,
+    type BetaOrganizationRateLimitTokenCountGroup as BetaOrganizationRateLimitTokenCountGroup,
     type BetaOrganizationRateLimitValue as BetaOrganizationRateLimitValue,
+    type BetaOrganizationRateLimitWebSearchGroup as BetaOrganizationRateLimitWebSearchGroup,
     type BetaOrganizationRateLimitsPageCursor as BetaOrganizationRateLimitsPageCursor,
     type RateLimitListParams as RateLimitListParams,
   };

package/src/resources/beta/organization/rate-limits.ts

@@ -37,14 +37,26 @@ export type BetaOrganizationRateLimitsPageCursor = PageCursor<BetaOrganizationRa
 
 export interface BetaOrganizationRateLimit {
   /**
-   * Stable identifier for this rate-limit group within the organization.
+   * Identifier of this rate-limit entry. It is stable within the organization and
+   * differs between organizations; the group's own identifier is `group.id`.
    */
   id: string;
 
   /**
-   * The kind of rate-limit group this entry represents. `model_group` entries apply
-   * to a family of models (listed in `models`); other values apply to an API-surface
-   * category and have `models` set to `null`.
+   * The rate-limit group this entry's limits apply to. Its `type` equals
+   * `group_type`.
+   */
+  group:
+    | BetaOrganizationRateLimitModelGroup
+    | BetaOrganizationRateLimitBatchGroup
+    | BetaOrganizationRateLimitTokenCountGroup
+    | BetaOrganizationRateLimitFilesGroup
+    | BetaOrganizationRateLimitSkillsGroup
+    | BetaOrganizationRateLimitWebSearchGroup;
+
+  /**
+   * @deprecated Use `group.type` instead. `group_type` is still returned and always
+   * equals `group.type`.
    */
   group_type: 'batch' | 'files' | 'model_group' | 'skills' | 'token_count' | 'web_search';
 
@@ -65,6 +77,82 @@ export interface BetaOrganizationRateLimit {
   type: 'rate_limit';
 }
 
+export interface BetaOrganizationRateLimitBatchGroup {
+  /**
+   * Opaque identifier of the rate-limit group (for example,
+   * `rlg_01VPTCmyiu5ZLsWkcxYG2pY8`). It is the same in every organization and never
+   * changes, unlike the entry's own identifier, which differs per organization.
+   */
+  id: string;
+
+  /**
+   * Always `batch`: the Message Batches API.
+   */
+  type: 'batch';
+}
+
+export interface BetaOrganizationRateLimitFilesGroup {
+  /**
+   * Opaque identifier of the rate-limit group (for example,
+   * `rlg_01VPTCmyiu5ZLsWkcxYG2pY8`). It is the same in every organization and never
+   * changes, unlike the entry's own identifier, which differs per organization.
+   */
+  id: string;
+
+  /**
+   * Always `files`: the Files API.
+   */
+  type: 'files';
+}
+
+export interface BetaOrganizationRateLimitModelGroup {
+  /**
+   * Opaque identifier of the rate-limit group (for example,
+   * `rlg_01VPTCmyiu5ZLsWkcxYG2pY8`). It is the same in every organization and never
+   * changes, unlike the entry's own identifier, which differs per organization.
+   */
+  id: string;
+
+  /**
+   * Human-readable name of the model group (for example, `Claude Sonnet 4.x`). For
+   * display only; it may change.
+   */
+  display_name: string;
+
+  /**
+   * Always `model_group`: a family of models.
+   */
+  type: 'model_group';
+}
+
+export interface BetaOrganizationRateLimitSkillsGroup {
+  /**
+   * Opaque identifier of the rate-limit group (for example,
+   * `rlg_01VPTCmyiu5ZLsWkcxYG2pY8`). It is the same in every organization and never
+   * changes, unlike the entry's own identifier, which differs per organization.
+   */
+  id: string;
+
+  /**
+   * Always `skills`: the Skills API.
+   */
+  type: 'skills';
+}
+
+export interface BetaOrganizationRateLimitTokenCountGroup {
+  /**
+   * Opaque identifier of the rate-limit group (for example,
+   * `rlg_01VPTCmyiu5ZLsWkcxYG2pY8`). It is the same in every organization and never
+   * changes, unlike the entry's own identifier, which differs per organization.
+   */
+  id: string;
+
+  /**
+   * Always `token_count`: the Token Count API.
+   */
+  type: 'token_count';
+}
+
 export interface BetaOrganizationRateLimitValue {
   /**
    * The limiter type (for example, `requests_per_minute` or
@@ -78,6 +166,20 @@ export interface BetaOrganizationRateLimitValue {
   value: number;
 }
 
+export interface BetaOrganizationRateLimitWebSearchGroup {
+  /**
+   * Opaque identifier of the rate-limit group (for example,
+   * `rlg_01VPTCmyiu5ZLsWkcxYG2pY8`). It is the same in every organization and never
+   * changes, unlike the entry's own identifier, which differs per organization.
+   */
+  id: string;
+
+  /**
+   * Always `web_search`: the Messages API web search tool.
+   */
+  type: 'web_search';
+}
+
 export interface RateLimitListParams extends PageCursorParams {
   /**
    * Filter by group type.
@@ -95,7 +197,13 @@ export interface RateLimitListParams extends PageCursorParams {
 export declare namespace RateLimits {
   export {
     type BetaOrganizationRateLimit as BetaOrganizationRateLimit,
+    type BetaOrganizationRateLimitBatchGroup as BetaOrganizationRateLimitBatchGroup,
+    type BetaOrganizationRateLimitFilesGroup as BetaOrganizationRateLimitFilesGroup,
+    type BetaOrganizationRateLimitModelGroup as BetaOrganizationRateLimitModelGroup,
+    type BetaOrganizationRateLimitSkillsGroup as BetaOrganizationRateLimitSkillsGroup,
+    type BetaOrganizationRateLimitTokenCountGroup as BetaOrganizationRateLimitTokenCountGroup,
     type BetaOrganizationRateLimitValue as BetaOrganizationRateLimitValue,
+    type BetaOrganizationRateLimitWebSearchGroup as BetaOrganizationRateLimitWebSearchGroup,
     type BetaOrganizationRateLimitsPageCursor as BetaOrganizationRateLimitsPageCursor,
     type RateLimitListParams as RateLimitListParams,
   };

package/src/resources/beta/organization/workspaces/rate-limits.ts

@@ -1,4 +1,5 @@
 import { APIResource } from '../../../../core/resource';
+import * as RateLimitsAPI from '../rate-limits';
 import { PageCursor, type PageCursorParams, PagePromise } from '../../../../core/pagination';
 import { RequestOptions } from '../../../../internal/request-options';
 import { path } from '../../../../internal/utils/path';
@@ -41,9 +42,20 @@ export type BetaWorkspaceRateLimitsPageCursor = PageCursor<BetaWorkspaceRateLimi
 
 export interface BetaWorkspaceRateLimit {
   /**
-   * The kind of rate-limit group this entry represents. `model_group` entries apply
-   * to a family of models (listed in `models`); other values apply to an API-surface
-   * category and have `models` set to `null`.
+   * The rate-limit group this entry's limits apply to. Its `type` equals
+   * `group_type`.
+   */
+  group:
+    | RateLimitsAPI.BetaOrganizationRateLimitModelGroup
+    | RateLimitsAPI.BetaOrganizationRateLimitBatchGroup
+    | RateLimitsAPI.BetaOrganizationRateLimitTokenCountGroup
+    | RateLimitsAPI.BetaOrganizationRateLimitFilesGroup
+    | RateLimitsAPI.BetaOrganizationRateLimitSkillsGroup
+    | RateLimitsAPI.BetaOrganizationRateLimitWebSearchGroup;
+
+  /**
+   * @deprecated Use `group.type` instead. `group_type` is still returned and always
+   * equals `group.type`.
    */
   group_type: 'batch' | 'files' | 'model_group' | 'skills' | 'token_count' | 'web_search';
 
@@ -60,7 +72,7 @@ export interface BetaWorkspaceRateLimit {
   models: Array<string> | null;
 
   /**
-   * The `id` of the RateLimit group this override applies to.
+   * The `id` of the organization's RateLimit entry this override applies to.
    */
   rate_limit_id: string;
 

package/src/resources/beta/sessions/sessions.ts

@@ -741,6 +741,12 @@ export interface BetaManagedAgentsSession {
 
   /**
    * SessionStatus enum
+   *
+   * - `rescheduling` - Transient error occurred, retrying automatically.
+   * - `running` - Agent is actively executing.
+   * - `idle` - Agent is waiting for input, including user messages or tool
+   *   confirmations. Sessions start in idle.
+   * - `terminated` - Session has ended, either due to an error or completion.
    */
   status: 'rescheduling' | 'running' | 'idle' | 'terminated';