@anthropic-ai/sdk 0.122.0 → 0.124.0

package/src/internal/file-store.ts

@@ -7,14 +7,15 @@
  * scope.
  */
 
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
-import { constants as C } from 'node:fs';
 import type { BigIntStats, Dirent } from 'node:fs';
+import type { FileHandle } from 'node:fs/promises';
 import type * as util from 'node:util';
-import { createHash, randomBytes } from 'node:crypto';
+import { crypto, fs, path } from './node';
 import { encodeUTF8 } from './utils/bytes';
 
+const fsp = fs.promises;
+const C = fs.constants;
+
 // Owner-only regardless of umask: the store holds downloaded user/model content.
 const OWNER_ONLY_DIR_MODE = 0o700;
 const OWNER_ONLY_FILE_MODE = 0o600;
@@ -182,7 +183,7 @@ export class FileStore {
   /** The file's bytes; `null` when absent. */
   async get(relPath: string): Promise<Uint8Array | null> {
     const dest = this.resolveUnderRoot(relPath);
-    let handle: fsp.FileHandle;
+    let handle: FileHandle;
     try {
       handle = await openRegularFile(relPath, dest);
     } catch (e) {
@@ -388,8 +389,8 @@ async function makeDirsBelowRoot(root: string, dir: string): Promise<void> {
 
 async function replaceViaTemp(dest: string, data: Uint8Array, isExecutable: boolean): Promise<void> {
   const mode = isExecutable ? OWNER_ONLY_EXEC_MODE : OWNER_ONLY_FILE_MODE;
-  const tmp = path.join(path.dirname(dest), `.fs-${randomBytes(8).toString('hex')}.tmp`);
-  let handle: fsp.FileHandle | undefined;
+  const tmp = path.join(path.dirname(dest), `.fs-${crypto.randomBytes(8).toString('hex')}.tmp`);
+  let handle: FileHandle | undefined;
   try {
     handle = await fsp.open(tmp, C.O_WRONLY | C.O_CREAT | C.O_EXCL | O_NOFOLLOW, mode);
     await handle.writeFile(data);
@@ -404,9 +405,9 @@ async function replaceViaTemp(dest: string, data: Uint8Array, isExecutable: bool
   }
 }
 
-async function openRegularFile(relPath: string, dest: string): Promise<fsp.FileHandle> {
+async function openRegularFile(relPath: string, dest: string): Promise<FileHandle> {
   // O_NONBLOCK: a FIFO fails the fstat check below instead of blocking the open.
-  let handle: fsp.FileHandle;
+  let handle: FileHandle;
   try {
     handle = await fsp.open(dest, C.O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
   } catch (e) {
@@ -429,7 +430,7 @@ async function openRegularFile(relPath: string, dest: string): Promise<fsp.FileH
 
 /** sha256 of a file's contents, streamed — constant memory on any file size. */
 async function hashFile(full: string): Promise<string> {
-  const digest = createHash('sha256');
+  const digest = crypto.createHash('sha256');
   const handle = await openRegularFile(path.basename(full), full);
   const buf = new Uint8Array(1024 * 1024);
   try {

package/src/internal/node.browser.ts

@@ -0,0 +1,22 @@
+import { AnthropicError } from '../core/error';
+import type * as node from './node';
+
+/** Substituted for `./node` by the package.json `browser` field; every property access throws. */
+function unavailable<T extends object>(module: string): T {
+  return new Proxy({} as T, {
+    get(_target, property) {
+      if (typeof property === 'symbol') return undefined;
+      throw new AnthropicError(
+        `\`${module}.${property}\` is not available in this environment; it needs a Node.js-compatible runtime`,
+      );
+    },
+  });
+}
+
+export const child_process: typeof node.child_process = unavailable('child_process');
+export const crypto: typeof node.crypto = unavailable('crypto');
+export const fs: typeof node.fs = unavailable('fs');
+export const os: typeof node.os = unavailable('os');
+export const path: typeof node.path = unavailable('path');
+export const stream: typeof node.stream = unavailable('stream');
+export const util: typeof node.util = unavailable('util');

package/src/internal/node.ts

@@ -0,0 +1,14 @@
+/**
+ * The one module under `src/` that may import Node built-ins (eslint enforces this).
+ * The package.json `browser` field swaps it for `./node.browser`, so only touch its
+ * exports on code paths that run on Node-compatible runtimes.
+ */
+import * as child_process from 'node:child_process';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as stream from 'node:stream';
+import * as util from 'node:util';
+
+export { child_process, crypto, fs, os, path, stream, util };

package/src/lib/BetaMessageStream.ts

@@ -603,6 +603,10 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
           snapshot.context_management = event.context_management;
         }
 
+        if (event.input_transformations != null) {
+          snapshot.input_transformations = event.input_transformations;
+        }
+
         // The remaining usage counters are cumulative whole-message totals that are
         // omitted when they don't apply, so overwrite when present and never add.
         if (event.usage.input_tokens != null) {

package/src/lib/credentials/credential-chain.ts

@@ -240,7 +240,7 @@ function cachedExchangeProvider(
   onSafetyWarning: ((msg: string) => void) | undefined,
 ): AccessTokenProvider {
   return async (opts) => {
-    const fs = await import('node:fs');
+    const { fs } = await import('../../internal/node');
 
     await checkCredentialsFileSafety(credentialsPath, onSafetyWarning);
 

package/src/lib/credentials/identity-token.ts

@@ -11,7 +11,7 @@ export function identityTokenFromFile(path: string): IdentityTokenProvider {
   }
 
   return async () => {
-    const fs = await import('node:fs');
+    const { fs } = await import('../../internal/node');
     let content: string;
     try {
       content = await fs.promises.readFile(path, 'utf-8');

package/src/lib/credentials/types.ts

@@ -170,7 +170,7 @@ export async function checkCredentialsFileSafety(
   onWarn: (msg: string) => void = (m) => console.warn(`anthropic-sdk: ${m}`),
 ): Promise<void> {
   if (typeof process === 'undefined' || process.platform === 'win32') return;
-  const fs = await import('node:fs');
+  const { fs } = await import('../../internal/node');
   let resolved = path;
   let st;
   try {
@@ -208,8 +208,7 @@ export async function checkCredentialsFileSafety(
  * Creates the parent directory with mode 0700 and the file with mode 0600.
  */
 export async function writeCredentialsFileAtomic(targetPath: string, data: unknown): Promise<void> {
-  const fs = await import('node:fs');
-  const path = await import('node:path');
+  const { fs, path } = await import('../../internal/node');
   const dir = path.dirname(targetPath);
   await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
   // Unique temp name avoids two concurrent writers (different processes or

package/src/lib/credentials/user-oauth.ts

@@ -36,7 +36,7 @@ export type UserOAuthConfig = {
  */
 export function userOAuthProvider(config: UserOAuthConfig): AccessTokenProvider {
   return async (opts) => {
-    const fs = await import('node:fs');
+    const { fs } = await import('../../internal/node');
 
     await checkCredentialsFileSafety(config.credentialsPath, config.onSafetyWarning);
 

package/src/lib/middleware.ts

@@ -38,16 +38,17 @@ const DEFAULT_BETAS: readonly AnthropicBeta[] = ['fallback-credit-2026-07-01'];
  * Remove `fallback` blocks replayed in history. They only parse under the
  * server-side fallback beta, which belongs to the caller-owned server-side
  * `fallbacks` feature — this middleware never sends it, so a request
- * replaying them would 400. An assistant turn left empty is dropped whole.
+ * replaying them would 400. A turn the strip leaves empty is dropped whole;
+ * a turn that was already empty is kept — it may carry other payload (e.g. a
+ * directive-only system message's `output_config`).
  */
 function stripFallbackBlocks(body: MessageCreateParams): MessageCreateParams {
-  const messages = body.messages
-    .map((message) =>
-      Array.isArray(message.content) ?
-        { ...message, content: message.content.filter((block) => block.type !== 'fallback') }
-      : message,
-    )
-    .filter((message) => !Array.isArray(message.content) || message.content.length > 0);
+  const messages = body.messages.flatMap((message) => {
+    if (!Array.isArray(message.content)) return [message];
+    const content = message.content.filter((block) => block.type !== 'fallback');
+    if (content.length === message.content.length) return [message];
+    return content.length > 0 ? [{ ...message, content }] : [];
+  });
   return { ...body, messages };
 }
 
@@ -453,6 +454,9 @@ async function* splicedEvents(
   // The refusal whose token is currently in flight — surfaced verbatim (with a
   // recommended_model added) if every fallback request fails and we degrade.
   let refusalDetails = a.refused.stopDetails;
+  // That refused hop's suppressed message_start `input_transformations`, which
+  // ride on the surfaced refusal delta (none for A: its start reached the client).
+  let refusalInputTransformations = a.refused.inputTransformations;
 
   // One `message` entry per refused hop, in order — A first. Failed hops are
   // skipped (no usage came back); the serving hop is appended as
@@ -559,6 +563,9 @@ async function* splicedEvents(
           stop_details: stopDetails,
         },
         usage: (lastUsage ?? {}) as BetaMessageDeltaUsage,
+        ...(refusalInputTransformations !== undefined && {
+          input_transformations: refusalInputTransformations,
+        }),
       });
       yield emit<BetaRawMessageStopEvent>('message_stop', { type: 'message_stop' });
       return;
@@ -580,6 +587,7 @@ async function* splicedEvents(
     // continues.
     token = b.refused.token;
     refusalDetails = b.refused.stopDetails;
+    refusalInputTransformations = b.refused.inputTransformations;
     base = continuation;
     partial = b.refused.hasPrefillClaim ? toPrefillBlocks(b.blocks) : [];
     iterations.push(toIterationUsage('message', model, b.refused.usage));
@@ -598,6 +606,12 @@ interface HopOutcome {
     usage: BetaMessageDeltaUsage;
     /** The refusal's stop_details verbatim, surfaced if the whole chain degrades. */
     stopDetails: BetaRefusalStopDetails;
+    /**
+     * A spliced hop's suppressed message_start `input_transformations`, forwarded
+     * on the surfaced refusal delta if the whole chain degrades; `undefined` for
+     * stream A (its start reached the client) or when the start had none.
+     */
+    inputTransformations: BetaMessage['input_transformations'] | undefined;
   } | null;
   /** The hop's serving model, from its message_start. */
   model: string | undefined;
@@ -615,7 +629,8 @@ interface HopOutcome {
  * spliced hop (`splice` set) has its message_start suppressed (the client
  * already saw A's), its block indices shifted by `indexBase`, and its
  * terminal message_delta's usage rewritten to the `usage.iterations`
- * chain shape.
+ * chain shape, with the suppressed message_start's `input_transformations`
+ * forwarded onto it.
  *
  * A refusal that can be chained — it carries a `fallback_credit_token` and a
  * fallback entry remains — ends the hop early: open blocks are closed, the
@@ -638,6 +653,10 @@ async function* consumeHop(args: {
   const tracker = new BlockTracker(indexBase);
   let model: string | undefined;
   let startUsage: BetaUsage | null = null;
+  // A spliced hop's message_start is suppressed, so its `input_transformations`
+  // must ride on the re-emitted terminal message_delta — the way a server-side
+  // fallback reports the serving model's list.
+  let startInputTransformations: BetaMessage['input_transformations'];
 
   for await (const sse of Stream.rawEvents(response, controller)) {
     const p = safeJSON(sse.data) as BetaRawMessageStreamEvent | undefined;
@@ -645,6 +664,7 @@ async function* consumeHop(args: {
       case 'message_start': {
         model = p.message.model;
         startUsage = p.message.usage;
+        if ('input_transformations' in p.message) startInputTransformations = p.message.input_transformations;
         if (splice) continue;
         break;
       }
@@ -687,6 +707,7 @@ async function* consumeHop(args: {
                 hasPrefillClaim: details.fallback_has_prefill_claim === true,
                 usage,
                 stopDetails: details,
+                inputTransformations: splice ? startInputTransformations : undefined,
               },
               model,
               blocks: tracker.contentBlocks(),
@@ -721,6 +742,9 @@ async function* consumeHop(args: {
             toIterationUsage('fallback_message', splice.model, usage),
           ];
           p.usage = usage;
+          if (!('input_transformations' in p) && startInputTransformations !== undefined) {
+            p.input_transformations = startInputTransformations;
+          }
           yield emit('message_delta', p);
           continue;
         }

package/src/resources/beta/agents/agents.ts

@@ -27,12 +27,15 @@ export class Agents extends APIResource {
    * ```
    */
   create(params: AgentCreateParams, options?: RequestOptions): APIPromise<BetaManagedAgentsAgent> {
-    const { betas, ...body } = params;
+    const { betas, workspace_id, ...body } = params;
     return this._client.post('/v1/agents?beta=true', {
       body,
       ...options,
       headers: buildHeaders([
-        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        {
+          'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+          ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+        },
         options?.headers,
       ]),
     });
@@ -54,12 +57,15 @@ export class Agents extends APIResource {
     params: AgentRetrieveParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<BetaManagedAgentsAgent> {
-    const { betas, ...query } = params ?? {};
+    const { betas, workspace_id, ...query } = params ?? {};
     return this._client.get(path`/v1/agents/${agentID}?beta=true`, {
       query,
       ...options,
       headers: buildHeaders([
-        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        {
+          'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+          ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+        },
         options?.headers,
       ]),
     });
@@ -82,12 +88,15 @@ export class Agents extends APIResource {
     params: AgentUpdateParams,
     options?: RequestOptions,
   ): APIPromise<BetaManagedAgentsAgent> {
-    const { betas, ...body } = params;
+    const { betas, workspace_id, ...body } = params;
     return this._client.post(path`/v1/agents/${agentID}?beta=true`, {
       body,
       ...options,
       headers: buildHeaders([
-        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        {
+          'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+          ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+        },
         options?.headers,
       ]),
     });
@@ -108,12 +117,15 @@ export class Agents extends APIResource {
     params: AgentListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<BetaManagedAgentsAgentsPageCursor, BetaManagedAgentsAgent> {
-    const { betas, ...query } = params ?? {};
+    const { betas, workspace_id, ...query } = params ?? {};
     return this._client.getAPIList('/v1/agents?beta=true', PageCursor<BetaManagedAgentsAgent>, {
       query,
       ...options,
       headers: buildHeaders([
-        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        {
+          'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+          ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+        },
         options?.headers,
       ]),
     });
@@ -135,11 +147,14 @@ export class Agents extends APIResource {
     params: AgentArchiveParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<BetaManagedAgentsAgent> {
-    const { betas } = params ?? {};
+    const { betas, workspace_id } = params ?? {};
     return this._client.post(path`/v1/agents/${agentID}/archive?beta=true`, {
       ...options,
       headers: buildHeaders([
-        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        {
+          'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+          ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+        },
         options?.headers,
       ]),
     });
@@ -862,6 +877,7 @@ export interface BetaManagedAgentsMCPToolsetParams {
  * details and options.
  */
 export type BetaManagedAgentsModel =
+  | 'claude-fable-5-1'
   | 'claude-sonnet-5'
   | 'claude-fable-5'
   | 'claude-opus-5'
@@ -1363,6 +1379,16 @@ export interface AgentCreateParams {
    * Header param: Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Header param: Optional header to select the Workspace for this request. The
+   * value is a Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export interface AgentRetrieveParams {
@@ -1376,6 +1402,16 @@ export interface AgentRetrieveParams {
    * Header param: Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Header param: Optional header to select the Workspace for this request. The
+   * value is a Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export interface AgentUpdateParams {
@@ -1455,6 +1491,16 @@ export interface AgentUpdateParams {
    * Header param: Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Header param: Optional header to select the Workspace for this request. The
+   * value is a Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export interface AgentListParams extends PageCursorParams {
@@ -1477,6 +1523,16 @@ export interface AgentListParams extends PageCursorParams {
    * Header param: Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Header param: Optional header to select the Workspace for this request. The
+   * value is a Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export interface AgentArchiveParams {
@@ -1484,6 +1540,16 @@ export interface AgentArchiveParams {
    * Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Optional header to select the Workspace for this request. The value is a
+   * Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 Agents.Versions = Versions;

package/src/resources/beta/agents/versions.ts

@@ -28,7 +28,7 @@ export class Versions extends APIResource {
     params: VersionListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<BetaManagedAgentsAgentsPageCursor, AgentsAPI.BetaManagedAgentsAgent> {
-    const { betas, ...query } = params ?? {};
+    const { betas, workspace_id, ...query } = params ?? {};
     return this._client.getAPIList(
       path`/v1/agents/${agentID}/versions?beta=true`,
       PageCursor<AgentsAPI.BetaManagedAgentsAgent>,
@@ -36,7 +36,10 @@ export class Versions extends APIResource {
         query,
         ...options,
         headers: buildHeaders([
-          { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+          {
+            'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+            ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+          },
           options?.headers,
         ]),
       },
@@ -49,6 +52,16 @@ export interface VersionListParams extends PageCursorParams {
    * Header param: Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Header param: Optional header to select the Workspace for this request. The
+   * value is a Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export declare namespace Versions {

package/src/resources/beta/beta.ts

@@ -88,10 +88,12 @@ import {
   BetaDreamSessionsInput,
   BetaDreamStatus,
   BetaDreamUsage,
+  BetaDreamingError,
   BetaDreamsPageCursor,
   BetaOutputBehavior,
   BetaOutputBehaviorCreateNew,
   BetaOutputBehaviorUpdateExisting,
+  BetaTargetStoreHeldError,
   DreamArchiveParams,
   DreamCancelParams,
   DreamCreateParams,
@@ -510,6 +512,7 @@ import {
   BetaSignatureDelta,
   BetaSkillParams,
   BetaStopReason,
+  BetaSystemMessageOutputConfig,
   BetaTextBlock,
   BetaTextBlockParam,
   BetaTextCitation,
@@ -526,12 +529,15 @@ import {
   BetaTextEditorCodeExecutionViewResultBlock,
   BetaTextEditorCodeExecutionViewResultBlockParam,
   BetaThinkingBlock,
+  BetaThinkingBlockBinding,
   BetaThinkingBlockParam,
   BetaThinkingConfigAdaptive,
   BetaThinkingConfigDisabled,
   BetaThinkingConfigEnabled,
   BetaThinkingConfigParam,
   BetaThinkingDelta,
+  BetaThinkingDroppedInputTransformation,
+  BetaThinkingPrefixMismatchBehavior,
   BetaThinkingTurns,
   BetaTokenTaskBudget,
   BetaTool,
@@ -742,7 +748,10 @@ export type AnthropicBeta =
   | 'structured-outputs-2025-11-13'
   | 'task-budgets-2026-03-13'
   | 'thinking-display-updates-2026-08-18'
-  | 'ce-user-management-2026-07-13';
+  | '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';
 
 export interface BetaAPIError {
   message: string;
@@ -1101,6 +1110,7 @@ export declare namespace Beta {
     type BetaSignatureDelta as BetaSignatureDelta,
     type BetaSkillParams as BetaSkillParams,
     type BetaStopReason as BetaStopReason,
+    type BetaSystemMessageOutputConfig as BetaSystemMessageOutputConfig,
     type BetaTextBlock as BetaTextBlock,
     type BetaTextBlockParam as BetaTextBlockParam,
     type BetaTextCitation as BetaTextCitation,
@@ -1117,12 +1127,15 @@ export declare namespace Beta {
     type BetaTextEditorCodeExecutionViewResultBlock as BetaTextEditorCodeExecutionViewResultBlock,
     type BetaTextEditorCodeExecutionViewResultBlockParam as BetaTextEditorCodeExecutionViewResultBlockParam,
     type BetaThinkingBlock as BetaThinkingBlock,
+    type BetaThinkingBlockBinding as BetaThinkingBlockBinding,
     type BetaThinkingBlockParam as BetaThinkingBlockParam,
     type BetaThinkingConfigAdaptive as BetaThinkingConfigAdaptive,
     type BetaThinkingConfigDisabled as BetaThinkingConfigDisabled,
     type BetaThinkingConfigEnabled as BetaThinkingConfigEnabled,
     type BetaThinkingConfigParam as BetaThinkingConfigParam,
     type BetaThinkingDelta as BetaThinkingDelta,
+    type BetaThinkingDroppedInputTransformation as BetaThinkingDroppedInputTransformation,
+    type BetaThinkingPrefixMismatchBehavior as BetaThinkingPrefixMismatchBehavior,
     type BetaThinkingTurns as BetaThinkingTurns,
     type BetaTokenTaskBudget as BetaTokenTaskBudget,
     type BetaTool as BetaTool,
@@ -1526,9 +1539,11 @@ export declare namespace Beta {
     type BetaDreamSessionsInput as BetaDreamSessionsInput,
     type BetaDreamStatus as BetaDreamStatus,
     type BetaDreamUsage as BetaDreamUsage,
+    type BetaDreamingError as BetaDreamingError,
     type BetaOutputBehavior as BetaOutputBehavior,
     type BetaOutputBehaviorCreateNew as BetaOutputBehaviorCreateNew,
     type BetaOutputBehaviorUpdateExisting as BetaOutputBehaviorUpdateExisting,
+    type BetaTargetStoreHeldError as BetaTargetStoreHeldError,
     type BetaDreamsPageCursor as BetaDreamsPageCursor,
     type DreamCreateParams as DreamCreateParams,
     type DreamRetrieveParams as DreamRetrieveParams,

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

@@ -26,11 +26,14 @@ export class DeploymentRuns extends APIResource {
     params: DeploymentRunRetrieveParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<BetaManagedAgentsDeploymentRun> {
-    const { betas } = params ?? {};
+    const { betas, workspace_id } = params ?? {};
     return this._client.get(path`/v1/deployment_runs/${deploymentRunID}?beta=true`, {
       ...options,
       headers: buildHeaders([
-        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        {
+          'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+          ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+        },
         options?.headers,
       ]),
     });
@@ -51,7 +54,7 @@ export class DeploymentRuns extends APIResource {
     params: DeploymentRunListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<BetaManagedAgentsDeploymentRunsPageCursor, BetaManagedAgentsDeploymentRun> {
-    const { betas, ...query } = params ?? {};
+    const { betas, workspace_id, ...query } = params ?? {};
     return this._client.getAPIList(
       '/v1/deployment_runs?beta=true',
       PageCursor<BetaManagedAgentsDeploymentRun>,
@@ -59,7 +62,10 @@ export class DeploymentRuns extends APIResource {
         query,
         ...options,
         headers: buildHeaders([
-          { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+          {
+            'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString(),
+            ...(workspace_id != null ? { 'anthropic-workspace-id': workspace_id } : undefined),
+          },
           options?.headers,
         ]),
       },
@@ -130,8 +136,8 @@ export interface BetaManagedAgentsDeploymentRun {
     | null;
 
   /**
-   * Populated on success. Null on creation failure. Exactly one of session_id or
-   * error is non-null.
+   * Populated on success. Null on creation failure. Exactly one of `session_id` or
+   * `error` is non-null.
    */
   session_id: string | null;
 
@@ -364,6 +370,16 @@ export interface DeploymentRunRetrieveParams {
    * Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Optional header to select the Workspace for this request. The value is a
+   * Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export interface DeploymentRunListParams extends PageCursorParams {
@@ -389,14 +405,14 @@ export interface DeploymentRunListParams extends PageCursorParams {
 
   /**
    * Query param: Filter to a specific deployment. Omit to list across all
-   * deployments in the workspace. Filtering by a non-existent deployment_id returns
-   * 200 with empty data.
+   * deployments in the workspace. Filtering by a non-existent `deployment_id`
+   * returns 200 with empty data.
    */
   deployment_id?: string;
 
   /**
-   * Query param: Filter: true for runs with non-null error, false for runs with
-   * non-null session_id. Omit for all.
+   * Query param: Filter: true for runs with non-null `error`, false for runs with
+   * non-null `session_id`. Omit for all.
    */
   has_error?: boolean;
 
@@ -409,6 +425,16 @@ export interface DeploymentRunListParams extends PageCursorParams {
    * Header param: Optional header to specify the beta version(s) you want to use.
    */
   betas?: Array<BetaAPI.AnthropicBeta>;
+
+  /**
+   * Header param: Optional header to select the Workspace for this request. The
+   * value is a Workspace ID (for example, `wrkspc_011CZkZaBF1tNoB5wlCeusgy`).
+   *
+   * Only needed for credentials that can act on more than one Workspace. A
+   * credential that belongs to a specific Workspace may omit it; if sent, it must
+   * match that Workspace.
+   */
+  workspace_id?: string;
 }
 
 export declare namespace DeploymentRuns {