@anthropic-ai/sdk 0.116.0 → 0.118.0

package/src/core/api-promise.ts

@@ -7,7 +7,7 @@ import {
   type APIResponseProps,
   type WithRequestID,
   defaultParseResponse,
-  addRequestID,
+  addResponseIDs,
 } from '../internal/parse';
 
 /**
@@ -37,7 +37,7 @@ export class APIPromise<T> extends Promise<WithRequestID<T>> {
 
   _thenUnwrap<U>(transform: (data: T, props: APIResponseProps) => U): APIPromise<U> {
     return new APIPromise(this.#client, this.responsePromise, async (client, props) =>
-      addRequestID(transform(await this.parseResponse(client, props), props), props.response),
+      addResponseIDs(transform(await this.parseResponse(client, props), props), props.response),
     );
   }
 
@@ -68,9 +68,19 @@ export class APIPromise<T> extends Promise<WithRequestID<T>> {
    * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
    * to your `tsconfig.json`.
    */
-  async withResponse(): Promise<{ data: T; response: Response; request_id: string | null | undefined }> {
+  async withResponse(): Promise<{
+    data: T;
+    response: Response;
+    request_id: string | null | undefined;
+    workspace_id: string | null | undefined;
+  }> {
     const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
-    return { data, response, request_id: response.headers.get('request-id') };
+    return {
+      data,
+      response,
+      request_id: response.headers.get('request-id'),
+      workspace_id: response.headers.get('anthropic-workspace-id'),
+    };
   }
 
   private parse(): Promise<WithRequestID<T>> {

package/src/core/error.ts

@@ -18,6 +18,7 @@ export class APIError<
   readonly error: TError;
 
   readonly requestID: string | null | undefined;
+  readonly workspaceID: string | null | undefined;
 
   /** The `error.type` from the API response body, e.g. `"rate_limit_error"` */
   readonly type: ErrorType | null;
@@ -33,6 +34,7 @@ export class APIError<
     this.status = status;
     this.headers = headers;
     this.requestID = headers?.get('request-id');
+    this.workspaceID = headers?.get('anthropic-workspace-id');
     this.error = error;
     this.type = type ?? null;
   }

package/src/core/middleware.ts

@@ -1,7 +1,7 @@
 import type { BaseAnthropic } from '../client';
 import type { Fetch } from '../internal/builtin-types';
 import { castToError, isAbortError } from '../internal/errors';
-import { addRequestID } from '../internal/parse';
+import { addResponseIDs } from '../internal/parse';
 import type { FinalRequestOptions } from '../internal/request-options';
 import { defaultLogger, loggerFor, type Logger } from '../internal/utils/log';
 import type { APIRequest } from './api';
@@ -299,7 +299,7 @@ async function parseMiddlewareResponse(
       // if there is no content we can't do anything
       return undefined;
     }
-    return addRequestID(await response.clone().json(), response);
+    return addResponseIDs(await response.clone().json(), response);
   }
 
   return await response.clone().text();

package/src/helpers/beta/zod.ts

@@ -16,9 +16,7 @@ import { BetaToolResultContentBlockParam } from '../../resources/beta';
 export function betaZodOutputFormat<ZodInput extends z.ZodType>(
   zodObject: ZodInput,
 ): AutoParseableBetaOutputFormat<z.infer<ZodInput>> {
-  let jsonSchema = z.toJSONSchema(zodObject, { reused: 'ref' });
-
-  jsonSchema = transformJSONSchema(jsonSchema);
+  const jsonSchema = transformJSONSchema(z.toJSONSchema(zodObject, { reused: 'ref' }));
 
   return {
     type: 'json_schema',

package/src/helpers/zod.ts

@@ -15,9 +15,7 @@ import { AutoParseableOutputFormat } from '../lib/parser';
 export function zodOutputFormat<ZodInput extends z.ZodType>(
   zodObject: ZodInput,
 ): AutoParseableOutputFormat<z.infer<ZodInput>> {
-  let jsonSchema = z.toJSONSchema(zodObject, { reused: 'ref' });
-
-  jsonSchema = transformJSONSchema(jsonSchema);
+  const jsonSchema = transformJSONSchema(z.toJSONSchema(zodObject, { reused: 'ref' }));
 
   return {
     type: 'json_schema',

package/src/internal/parse.ts

@@ -51,7 +51,7 @@ export async function defaultParseResponse<T>(
       }
 
       const json = await response.json();
-      return addRequestID(json as T, response);
+      return addResponseIDs(json as T, response);
     }
 
     const text = await response.text();
@@ -80,16 +80,16 @@ export async function defaultParseResponse<T>(
 
 export type WithRequestID<T> =
   T extends Array<any> | Response | AbstractPage<any> ? T
-  : T extends Record<string, any> ? T & { _request_id?: string | null }
+  : T extends Record<string, any> ? T & { _request_id?: string | null; _workspace_id?: string | null }
   : T;
 
-export function addRequestID<T>(value: T, response: Response): WithRequestID<T> {
+export function addResponseIDs<T>(value: T, response: Response): WithRequestID<T> {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
     return value as WithRequestID<T>;
   }
 
-  return Object.defineProperty(value, '_request_id', {
-    value: response.headers.get('request-id'),
-    enumerable: false,
+  return Object.defineProperties(value, {
+    _request_id: { value: response.headers.get('request-id'), enumerable: false },
+    _workspace_id: { value: response.headers.get('anthropic-workspace-id'), enumerable: false },
   }) as WithRequestID<T>;
 }

package/src/lib/BetaMessageStream.ts

@@ -74,6 +74,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
   #catchingPromiseCreated = false;
   #response: Response | null | undefined;
   #request_id: string | null | undefined;
+  #workspace_id: string | null | undefined;
   #logger: Logger;
 
   constructor(params: MessageCreateParamsBase | null, opts?: { logger?: Logger | undefined }) {
@@ -106,6 +107,10 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     return this.#request_id;
   }
 
+  get workspace_id(): string | null | undefined {
+    return this.#workspace_id;
+  }
+
   /**
    * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request,
    * returned vie the `request-id` header which is useful for debugging requests and resporting
@@ -120,6 +125,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     data: BetaMessageStream<ParsedT>;
     response: Response;
     request_id: string | null | undefined;
+    workspace_id: string | null | undefined;
   }> {
     this.#catchingPromiseCreated = true;
 
@@ -132,6 +138,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
       data: this,
       response,
       request_id: response.headers.get('request-id'),
+      workspace_id: response.headers.get('anthropic-workspace-id'),
     };
   }
 
@@ -223,6 +230,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     if (this.ended) return;
     this.#response = response;
     this.#request_id = response?.headers.get('request-id');
+    this.#workspace_id = response?.headers.get('anthropic-workspace-id');
     this.#resolveConnectedPromise(response);
     this._emit('connect');
   }
@@ -581,15 +589,21 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
       case 'message_stop':
         return snapshot;
       case 'message_delta':
-        snapshot.container = event.delta.container;
         snapshot.stop_reason = event.delta.stop_reason;
         snapshot.stop_sequence = event.delta.stop_sequence;
-        if (event.delta.stop_details != null) {
-          snapshot.stop_details = event.delta.stop_details;
-        }
+        snapshot.stop_details = event.delta.stop_details;
         snapshot.usage.output_tokens = event.usage.output_tokens;
-        snapshot.context_management = event.context_management;
 
+        if (event.delta.container != null) {
+          snapshot.container = event.delta.container;
+        }
+
+        if (event.context_management != null) {
+          snapshot.context_management = event.context_management;
+        }
+
+        // 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) {
           snapshot.usage.input_tokens = event.usage.input_tokens;
         }
@@ -614,6 +628,10 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
           snapshot.usage.fallback_credit = event.usage.fallback_credit;
         }
 
+        if (event.usage.output_tokens_details != null) {
+          snapshot.usage.output_tokens_details = event.usage.output_tokens_details;
+        }
+
         return snapshot;
       case 'content_block_start':
         snapshot.content.push(event.content_block);

package/src/lib/MessageStream.ts

@@ -73,6 +73,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
   #catchingPromiseCreated = false;
   #response: Response | null | undefined;
   #request_id: string | null | undefined;
+  #workspace_id: string | null | undefined;
   #logger: Logger;
 
   constructor(params: MessageCreateParamsBase | null, opts?: { logger?: Logger | undefined }) {
@@ -105,6 +106,10 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     return this.#request_id;
   }
 
+  get workspace_id(): string | null | undefined {
+    return this.#workspace_id;
+  }
+
   /**
    * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request,
    * returned vie the `request-id` header which is useful for debugging requests and resporting
@@ -119,6 +124,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     data: MessageStream<ParsedT>;
     response: Response;
     request_id: string | null | undefined;
+    workspace_id: string | null | undefined;
   }> {
     this.#catchingPromiseCreated = true;
 
@@ -131,6 +137,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
       data: this,
       response,
       request_id: response.headers.get('request-id'),
+      workspace_id: response.headers.get('anthropic-workspace-id'),
     };
   }
 
@@ -222,6 +229,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     if (this.ended) return;
     this.#response = response;
     this.#request_id = response?.headers.get('request-id');
+    this.#workspace_id = response?.headers.get('anthropic-workspace-id');
     this.#resolveConnectedPromise(response);
     this._emit('connect');
   }
@@ -575,12 +583,15 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
       case 'message_delta':
         snapshot.stop_reason = event.delta.stop_reason;
         snapshot.stop_sequence = event.delta.stop_sequence;
-        if (event.delta.stop_details != null) {
-          snapshot.stop_details = event.delta.stop_details;
-        }
+        snapshot.stop_details = event.delta.stop_details;
         snapshot.usage.output_tokens = event.usage.output_tokens;
 
-        // Update other usage fields if they exist in the event
+        if (event.delta.container != null) {
+          snapshot.container = event.delta.container;
+        }
+
+        // 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) {
           snapshot.usage.input_tokens = event.usage.input_tokens;
         }
@@ -597,6 +608,10 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
           snapshot.usage.server_tool_use = event.usage.server_tool_use;
         }
 
+        if (event.usage.output_tokens_details != null) {
+          snapshot.usage.output_tokens_details = event.usage.output_tokens_details;
+        }
+
         return snapshot;
       case 'content_block_start':
         snapshot.content.push({ ...event.content_block });

package/src/lib/environments/worker.ts

@@ -21,6 +21,7 @@ import { copyClientForHelper } from '../helper-client';
 import type { AgentToolContext } from '../../tools/agent-toolset/node';
 
 const HEARTBEAT_DEFAULT_MS = 30_000;
+const HEARTBEAT_TTL_DEFAULT_MS = 90_000;
 const NO_HEARTBEAT_SENTINEL = 'NO_HEARTBEAT';
 
 /**
@@ -51,6 +52,10 @@ export interface EnvironmentWorkerOptions {
    * Tools to expose to each claimed session. Defaults to
    * `betaAgentToolset20260401(ctx)` (the standard `agent_toolset_20260401` set
    * bound to the per-session {@link AgentToolContext}).
+   *
+   * A `run` that blocks the event loop synchronously also stalls the lease
+   * heartbeat, and the worker can lose the lease; keep tools non-blocking (see
+   * {@link BetaRunnableTool.run}).
    */
   tools?: EnvironmentWorkerTools;
   /** Base directory for the per-session {@link AgentToolContext}. Defaults to `process.cwd()`. */
@@ -109,10 +114,10 @@ type ClaimedWork = Pick<BetaSelfHostedWork, 'id' | 'environment_id' | 'data'>;
  * For each claimed `session` work item it: builds the per-session
  * {@link AgentToolContext}, downloads the session agent's skills
  * (`setupSkills`), then runs a {@link SessionToolRunner} for the session
- * *while* heartbeating the work-item lease in parallel; on exit it force-stops
- * the work item, cleans up the downloaded skills, and loops to the next one. The
- * lease heartbeat reports `state === "stopping"` / a lost lease back into the run
- * by aborting the session runner.
+ * while heartbeating the work-item lease on the same event loop; on exit it
+ * force-stops the work item, cleans up the downloaded skills, and loops to the
+ * next one. The lease heartbeat reports `state === "stopping"` / a lost lease
+ * back into the run by aborting the session runner.
  *
  * Use {@link EnvironmentWorker.handleItem} if you already hold a claimed work
  * item (e.g. a `worker poll --on-work` script handed one to a fresh process) and
@@ -195,8 +200,8 @@ export class EnvironmentWorker {
    * per-session {@link AgentToolContext} (workdir from this worker's options),
    * download the session agent's skills (`setupSkills`), run a
    * {@link SessionToolRunner} for the session while heartbeating the work-item
-   * lease in parallel, and force-stop the work item on exit (whether the runner
-   * finishes normally, throws, or the heartbeat loop signals shutdown).
+   * lease, and force-stop the work item on exit (whether the runner finishes
+   * normally, throws, or the heartbeat loop signals shutdown).
    *
    * Use this when something else does the claiming — e.g. a `worker poll
    * --on-work` script that hands an already-claimed item to a fresh process. The
@@ -292,19 +297,26 @@ export class EnvironmentWorker {
     const ctrl = new AbortController();
     const detachExternal = linkAbort(externalSignal, ctrl);
 
-    const heartbeatPromise = heartbeatLoop(sessionClient, work, ctrl, log, this.requestOptions).catch((e) => {
+    // Inert until iterated below.
+    const runner = new SessionToolRunner(sessionId, {
+      client: sessionClient,
+      tools,
+      ...(this.maxIdleMs !== undefined ? { maxIdleMs: this.maxIdleMs } : {}),
+      ...(this.requestOptions !== undefined ? { requestOptions: this.requestOptions } : {}),
+      signal: ctrl.signal,
+    });
+
+    // Each heartbeat reports the lease TTL the server is enforcing; it becomes
+    // the runner's tool-result send retry window so a send keeps retrying
+    // exactly as long as the lease could still be live.
+    const heartbeatPromise = heartbeatLoop(sessionClient, work, ctrl, log, this.requestOptions, (ttlMs) =>
+      runner._setSendRetryWindow(ttlMs),
+    ).catch((e) => {
       if (!ctrl.signal.aborted) log.error('heartbeat loop failed', { work_id: work.id, error: String(e) });
       ctrl.abort();
     });
 
     try {
-      const runner = new SessionToolRunner(sessionId, {
-        client: sessionClient,
-        tools,
-        ...(this.maxIdleMs !== undefined ? { maxIdleMs: this.maxIdleMs } : {}),
-        ...(this.requestOptions !== undefined ? { requestOptions: this.requestOptions } : {}),
-        signal: ctrl.signal,
-      });
       for await (const _ of runner) {
         // Drive the runner to completion; per-call observability is not part
         // of this composition's surface — use `SessionToolRunner` directly
@@ -348,7 +360,10 @@ async function forceStop(
 /**
  * Keep the work-item lease alive while a session is being served. Aborts `ctrl`
  * when the control plane reports the work is `stopping`/`stopped`, when the
- * lease is no longer extended, or on a permanent heartbeat failure.
+ * lease is no longer extended, on a permanent heartbeat failure, or when no
+ * heartbeat has succeeded for longer than the lease ttl (the lease is assumed
+ * lost). Each heartbeat call is cut off after the current beat interval so a
+ * hung request cannot outlive the lease it is meant to renew.
  */
 async function heartbeatLoop(
   client: Anthropic,
@@ -356,19 +371,31 @@ async function heartbeatLoop(
   ctrl: AbortController,
   logger: Logger,
   requestOptions?: BetaToolRunnerRequestOptions,
+  /** Called with the server-reported lease TTL after every successful beat. */
+  onLeaseTtl?: (ttlMs: number) => void,
 ): Promise<void> {
   let intervalMs = HEARTBEAT_DEFAULT_MS;
+  let ttlMs = HEARTBEAT_TTL_DEFAULT_MS;
+  let lastSuccessMs = Date.now();
   let last = NO_HEARTBEAT_SENTINEL;
   const beat = async (): Promise<void> => {
+    // Not the request `timeout` option: the core client retries timeouts, so
+    // it would not bound the call as a whole.
+    const beatCtrl = new AbortController();
+    const detach = linkAbort(ctrl.signal, beatCtrl);
+    const cutoff = setTimeout(() => beatCtrl.abort(), intervalMs);
     try {
       const resp = await client.beta.environments.work.heartbeat(
         work.id,
         { environment_id: work.environment_id, expected_last_heartbeat: last },
-        { ...requestOptions, headers: buildHeaders([requestOptions?.headers]), signal: ctrl.signal },
+        { ...requestOptions, headers: buildHeaders([requestOptions?.headers]), signal: beatCtrl.signal },
       );
+      lastSuccessMs = Date.now();
       last = resp.last_heartbeat;
       if (resp.ttl_seconds > 0) {
-        intervalMs = Math.max(1_000, Math.min((resp.ttl_seconds * 1000) / 2, HEARTBEAT_DEFAULT_MS));
+        ttlMs = resp.ttl_seconds * 1000;
+        intervalMs = Math.max(1_000, Math.min(ttlMs / 2, HEARTBEAT_DEFAULT_MS));
+        onLeaseTtl?.(ttlMs);
       }
       if (resp.state === 'stopping' || resp.state === 'stopped') {
         logger.info('heartbeat signals shutdown', { work_id: work.id, state: resp.state });
@@ -387,7 +414,19 @@ async function heartbeatLoop(
         ctrl.abort();
         throw e;
       }
+      if (Date.now() - lastSuccessMs > ttlMs) {
+        logger.error('lease assumed lost: no successful heartbeat in ttl', {
+          work_id: work.id,
+          ttl_ms: ttlMs,
+          error: String(e),
+        });
+        ctrl.abort();
+        return;
+      }
       logger.warn('transient heartbeat failure', { work_id: work.id, error: String(e) });
+    } finally {
+      clearTimeout(cutoff);
+      detach();
     }
   };
 

package/src/lib/tools/BetaRunnableTool.ts

@@ -22,10 +22,7 @@ import { ToolError } from './ToolError';
 
 export type Promisable<T> = T | Promise<T>;
 
-/**
- * Tool types that can be implemented on the client.
- * Excludes server-side tools like code execution, web search, and MCP toolsets.
- */
+/** Tools that run on the client. Server-side tools (code execution, web search, MCP toolsets) are not included. */
 export type BetaClientRunnableToolType =
   | BetaTool
   | BetaMemoryTool20250818
@@ -40,15 +37,9 @@ export type BetaClientRunnableToolType =
   | BetaToolTextEditor20250728;
 
 /**
- * The tool-use that triggered a {@link BetaRunnableTool.run}:
- *
- * - from `client.beta.messages.toolRunner`, a Messages `tool_use` content block;
- * - from `client.beta.sessions.events.toolRunner`, the `agent.tool_use` /
- *   `agent.custom_tool_use` session event.
- *
- * The shapes overlap on the common fields (`id`, `name`, `input`), so code that
- * only reads those works without narrowing; narrow on the shape (e.g. `'type' in
- * x`) when you need surface-specific properties.
+ * The tool call being served: a Messages `tool_use` block, or a session
+ * `agent.tool_use` / `agent.custom_tool_use` event. All three carry `id`,
+ * `name` and `input`.
  */
 export type BetaToolUse =
   | BetaToolUseBlock
@@ -56,65 +47,50 @@ export type BetaToolUse =
   | BetaManagedAgentsAgentCustomToolUseEvent;
 
 export type BetaToolRunContext = {
-  /** The tool-use that triggered this run. See {@link BetaToolUse}. */
   toolUse: BetaToolUse;
+  /** @deprecated Use `toolUse`. */
+  toolUseBlock: BetaToolUse;
   /**
-   * @deprecated Renamed to `toolUse`. Also note that for
-   * `client.beta.sessions.events.toolRunner` this is the `agent.tool_use` /
-   * `agent.custom_tool_use` *event*, not a Messages content block, despite the
-   * name — which is why it was renamed.
+   * Aborted when the runner is aborted or, in the session runner, when the
+   * per-tool timeout fires. The runner still waits for `run` to return, so
+   * check it in long-running work.
    */
-  toolUseBlock: BetaToolUse;
   signal?: AbortSignal | null | undefined;
 };
 
-// this type is just an extension of BetaTool with a run and parse method
-// that will be called by `toolRunner()` helpers
+/** A tool definition plus the `run` and `parse` the tool runners call. */
 export type BetaRunnableTool<Input = any> = BetaClientRunnableToolType & {
+  /**
+   * Runs on the event loop: a body that blocks synchronously stalls the runner
+   * and, in an `EnvironmentWorker`, the lease heartbeat. Await async work or
+   * move it to a worker thread.
+   */
   run: (
     args: Input,
     context?: BetaToolRunContext,
   ) => Promisable<string | Array<BetaToolResultContentBlockParam>>;
   parse: (content: unknown) => Input;
-  /**
-   * Optional cleanup hook for tools that hold process-level resources (e.g. a
-   * persistent shell). `SessionToolRunner` (`client.beta.sessions.events.toolRunner`)
-   * calls it once when iteration ends.
-   */
+  /** Called once by the session runner when it stops. Release held resources here (e.g. a shell). */
   close?: () => Promisable<void>;
 };
 
-/**
- * Resolve the registry key for a tool — the name the model addresses it by.
- * MCP toolsets are keyed on `mcp_server_name`; every other tool on `name`.
- * Shared so the tool-name lookup is identical across `toolRunner()` surfaces.
- */
+/** The name the model calls a tool by: `mcp_server_name` for MCP toolsets, `name` for everything else. */
 export function toolName(tool: BetaToolUnion | BetaRunnableTool): string {
   return 'name' in tool ? tool.name : tool.mcp_server_name;
 }
 
-/**
- * Format a thrown value into tool-result content: a {@link ToolError} carries
- * its own structured content, anything else becomes an `Error: <message>`
- * string. Shared so every `toolRunner()` surface reports tool failures the
- * same way to the model.
- */
+/** Tool-result content for a thrown value: a {@link ToolError}'s own content, otherwise `Error: <message>`. */
 export function toolErrorContent(e: unknown): string | Array<BetaToolResultContentBlockParam> {
   return e instanceof ToolError ? e.content : `Error: ${e instanceof Error ? e.message : String(e)}`;
 }
 
-/** Outcome of {@link runRunnableTool}: the content to post back and whether it is an error. */
+/** What a tool run produced, and whether it failed. */
 export interface RunnableToolOutcome {
   content: string | Array<BetaToolResultContentBlockParam>;
   isError: boolean;
 }
 
-/**
- * Run a {@link BetaRunnableTool} end-to-end: parse the raw input, invoke `run`,
- * and format any thrown value via {@link toolErrorContent}. Shared so the
- * parse → run → catch → format pipeline is identical across `toolRunner()`
- * surfaces.
- */
+/** Parse the input, run the tool, and turn anything thrown into an error result. */
 export async function runRunnableTool(
   tool: BetaRunnableTool,
   rawInput: unknown,

package/src/lib/tools/BetaToolRunner.ts

@@ -222,6 +222,17 @@ export class BetaToolRunner<Stream extends boolean> {
               const message = await this.#message;
               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
+              // previous turn ran in, so carry its id forward unless the caller pinned one themselves.
+              const { container } = this.#state.params;
+              if (message.container) {
+                if (container == null) {
+                  this.#state.params.container = message.container.id;
+                } else if (typeof container === 'object' && container.id == null) {
+                  this.#state.params.container = { ...container, id: message.container.id };
+                }
+              }
+
               // Refusal-terminated turns are terminal: the refusal may have cut a tool_use off
               // with partial input, so executing this turn's tools would fire side effects the
               // model never confirmed — and once middleware strips the refusal turn, their
@@ -567,18 +578,6 @@ function applyToolChange(block: BetaContentBlockParam, available: Set<string>):
     case 'tool_addition':
       applyToolReference(block, available);
       break;
-    case 'mid_conv_system':
-      // A `mid_conv_system` block's content is limited by the API schema to
-      // text / tool_addition / tool_removal, so we walk exactly one level — no recursion.
-      for (const inner of block.content) {
-        if (inner.type === 'tool_removal' || inner.type === 'tool_addition') {
-          applyToolReference(inner, available);
-        }
-      }
-      break;
-    default:
-      // Other and unknown/newer block types leave the set untouched (forward compatibility).
-      break;
   }
 }