@code-yeongyu/senpi 2026.9.4 → 2026.9.5

package/node_modules/@anthropic-ai/sdk/src/internal/uploads.ts

@@ -137,14 +137,11 @@ export const createForm = async <T = Record<string, unknown>>(
   return form;
 };
 
-// We check for Blob not File because Bun.File doesn't inherit from File,
-// but they both inherit from Blob and have a `name` property at runtime.
-const isNamedBlob = (value: unknown): value is Blob => value instanceof Blob && 'name' in value;
-
+// Blob, not File: bare Blobs and Bun.file() results don't inherit from File.
 const isUploadable = (value: unknown) =>
   typeof value === 'object' &&
   value !== null &&
-  (value instanceof Response || isAsyncIterable(value) || isNamedBlob(value));
+  (value instanceof Response || isAsyncIterable(value) || value instanceof Blob);
 
 const hasUploadableValue = (value: unknown): boolean => {
   if (isUploadable(value)) return true;
@@ -186,10 +183,16 @@ const addFormValue = async (
       key,
       makeFile([await new Response(ReadableStreamFrom(value)).blob()], getName(value, stripFilenames)),
     );
-  } else if (isNamedBlob(value)) {
-    form.append(key, makeFile([value], getName(value, stripFilenames), { type: value.type }));
+  } else if (value instanceof Blob) {
+    form.append(key, makeFile([value], getName(value, stripFilenames) || undefined, { type: value.type }));
   } else if (Array.isArray(value)) {
     await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry, stripFilenames)));
+  } else if (typeof (value as any).then === 'function') {
+    throw new TypeError(`Received a Promise for "${key}"; await it first, e.g. \`await toFile(...)\``);
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    throw new TypeError(
+      `Received ${value.constructor.name} for "${key}"; to upload raw bytes, wrap them with \`await toFile(bytes, 'filename')\``,
+    );
   } else if (typeof value === 'object') {
     await Promise.all(
       Object.entries(value).map(([name, prop]) =>

package/node_modules/@anthropic-ai/sdk/src/internal/utils/values.ts

@@ -110,3 +110,10 @@ export const pop = <T extends Record<string, any>, K extends string>(obj: T, key
   delete obj[key];
   return value;
 };
+
+/**
+ * Compile-time exhaustiveness check: passing a value here only type-checks once every
+ * member of its union has been handled. Does nothing at runtime, so unknown values from a
+ * newer API version fall through instead of throwing.
+ */
+export function checkNever(_value: never): void {}

package/node_modules/@anthropic-ai/sdk/src/lib/BetaMessageStream.ts

@@ -2,6 +2,7 @@ import { STAINLESS_HELPER_METHOD_HEADER } from '../internal/stainless-helper-hea
 import type { Logger } from '../client';
 import { AnthropicError, APIUserAbortError } from '../error';
 import { isAbortError } from '../internal/errors';
+import { checkNever } from '../internal/utils/values';
 import { type RequestOptions } from '../internal/request-options';
 import {
   type BetaContentBlock,
@@ -602,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) {
@@ -798,6 +803,3 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     return stream.toReadableStream();
   }
 }
-
-// used to ensure exhaustive case matching without throwing a runtime error
-function checkNever(x: never) {}

package/node_modules/@anthropic-ai/sdk/src/lib/MessageStream.ts

@@ -1,5 +1,6 @@
 import { STAINLESS_HELPER_METHOD_HEADER } from '../internal/stainless-helper-header';
 import { isAbortError } from '../internal/errors';
+import { checkNever } from '../internal/utils/values';
 import { AnthropicError, APIUserAbortError } from '../error';
 import {
   type ContentBlock,
@@ -750,6 +751,3 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     return stream.toReadableStream();
   }
 }
-
-// used to ensure exhaustive case matching without throwing a runtime error
-function checkNever(x: never) {}

package/node_modules/@anthropic-ai/sdk/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/node_modules/@anthropic-ai/sdk/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/node_modules/@anthropic-ai/sdk/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/node_modules/@anthropic-ai/sdk/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/node_modules/@anthropic-ai/sdk/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/node_modules/@anthropic-ai/sdk/src/lib/sessions/accumulate.ts

@@ -18,10 +18,11 @@ export type AccumulatedEvent = BetaManagedAgentsAgentMessageEvent;
  *   fragment as a fresh content entry; an existing index returns a copy with
  *   that entry appended to. An unrecognised fragment type on an existing
  *   index passes the entry through unchanged — deltas are best-effort and the
- *   buffered final event is canonical — but is a compile-time error via the
- *   exhaustiveness guard, matching `MessageStream#accumulateMessage`.
+ *   buffered final event is canonical.
  * - `agent.message` is the buffered final event: a copy of it is returned,
  *   replacing whatever the preview had accumulated.
+ * - Every other event type returns `accumulated` unchanged, so new event types
+ *   added to the stream union need no change here.
  */
 export function accumulateManagedAgentsEvent<T extends AccumulatedEvent>(
   accumulated: AccumulatedEvent | undefined,
@@ -71,60 +72,17 @@ export function accumulateManagedAgentsEvent(
       }
 
       let updated = existing;
-      switch (fragment.type) {
-        case 'text':
-          if (existing.type === 'text') {
-            updated = { ...existing, text: existing.text + fragment.text };
-          }
-          break;
-        default:
-          checkNever(fragment.type);
+      if (fragment.type === 'text' && existing.type === 'text') {
+        updated = { ...existing, text: existing.text + fragment.text };
       }
 
       const content = accumulated.content.slice();
       content[idx] = updated;
       return { ...accumulated, content };
     }
-    case 'user.message':
-    case 'user.interrupt':
-    case 'user.tool_confirmation':
-    case 'user.tool_result':
-    case 'user.custom_tool_result':
-    case 'user.define_outcome':
-    case 'agent.thinking':
-    case 'agent.tool_use':
-    case 'agent.tool_result':
-    case 'agent.custom_tool_use':
-    case 'agent.mcp_tool_use':
-    case 'agent.mcp_tool_result':
-    case 'agent.thread_message_received':
-    case 'agent.thread_message_sent':
-    case 'agent.thread_context_compacted':
-    case 'session.error':
-    case 'session.updated':
-    case 'session.deleted':
-    case 'session.usage':
-    case 'session.status_running':
-    case 'session.status_idle':
-    case 'session.status_rescheduled':
-    case 'session.status_terminated':
-    case 'session.thread_created':
-    case 'session.thread_status_running':
-    case 'session.thread_status_idle':
-    case 'session.thread_status_rescheduled':
-    case 'session.thread_status_terminated':
-    case 'span.model_request_start':
-    case 'span.model_request_end':
-    case 'span.outcome_evaluation_start':
-    case 'span.outcome_evaluation_ongoing':
-    case 'span.outcome_evaluation_end':
-    case 'system.message':
-      return accumulated;
+
     default:
-      checkNever(event);
+      // Any other event, including types newer than this SDK, leaves the snapshot unchanged.
       return accumulated;
   }
 }
-
-// Compile-time exhaustiveness guard.
-function checkNever(_x: never): void {}

package/node_modules/@anthropic-ai/sdk/src/lib/standard-schema.ts

@@ -0,0 +1,209 @@
+import { AnthropicError } from '../core/error';
+
+// Standard Schema spec types, copied from `@standard-schema/spec@1.1.0` (MIT) as the spec
+// recommends. See https://standardschema.dev
+
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+
+export declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (
+      value: unknown,
+      options?: StandardSchemaV1.Options | undefined,
+    ) => Result<Output> | Promise<Result<Output>>;
+  }
+
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they
+   * are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should
+   * throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a
+   * superset of JSON Schema `"draft-04"`.
+   */
+  type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
+
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+/**
+ * Returns `jsonSchema` if given, otherwise the schema's Standard JSON Schema `input`
+ * representation (the model produces the value that the validator consumes).
+ */
+export function standardSchemaToJSONSchema(
+  schema: StandardSchemaV1,
+  jsonSchema?: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  if (jsonSchema) {
+    return jsonSchema;
+  }
+
+  const std: StandardSchemaV1.Props & Partial<StandardJSONSchemaV1.Props> = schema['~standard'];
+  if (std.jsonSchema) {
+    return std.jsonSchema.input({ target: 'draft-2020-12' });
+  }
+
+  throw new AnthropicError(
+    `Could not derive a JSON Schema from this ${std.vendor} schema as it does not implement Standard JSON Schema (\`~standard.jsonSchema\`). Pass the \`jsonSchema\` option, or use a library version that implements it (e.g. zod >= 4.2, or valibot via \`toStandardJsonSchema()\`).`,
+  );
+}
+
+/**
+ * Validates `value` with `~standard.validate` and returns the typed output, throwing an
+ * `AnthropicError` on issues. Validation must be synchronous because `parse` hooks are.
+ */
+export function parseWithStandardSchema<Schema extends StandardSchemaV1>(
+  schema: Schema,
+  value: unknown,
+): StandardSchemaV1.InferOutput<Schema> {
+  const result = schema['~standard'].validate(value);
+
+  if (result instanceof Promise) {
+    // avoid an unhandled rejection from the discarded result
+    result.catch(() => {});
+    throw new AnthropicError(
+      `Async validation is not supported: the ${schema['~standard'].vendor} schema's \`~standard.validate()\` returned a Promise.`,
+    );
+  }
+
+  if (result.issues) {
+    const formattedIssues = result.issues.slice(0, 5).map(formatIssue).join('\n');
+    const issueCount = result.issues.length;
+    const suffix = issueCount > 5 ? `\n  ... and ${issueCount - 5} more issue(s)` : '';
+
+    throw new AnthropicError(
+      `Schema validation failed with ${issueCount} issue(s):\n${formattedIssues}${suffix}`,
+    );
+  }
+
+  return result.value;
+}
+
+function formatIssue(issue: StandardSchemaV1.Issue): string {
+  const path = (issue.path ?? [])
+    .map((segment) => String(typeof segment === 'object' ? segment.key : segment))
+    .join('.');
+  return path ? `  - ${path}: ${issue.message}` : `  - ${issue.message}`;
+}

package/node_modules/@anthropic-ai/sdk/src/lib/tools/BetaToolRunner.ts

@@ -8,6 +8,7 @@ import {
   BetaMessageParam,
   BetaRequestToolAdditionBlock,
   BetaRequestToolRemovalBlock,
+  BetaStopReason,
   BetaToolChangeMCPToolReference,
   BetaToolChangeMCPToolsetReference,
   BetaToolChangeToolReference,
@@ -18,6 +19,7 @@ import { BetaMessageStream } from '../BetaMessageStream';
 import { RequestOptions } from '../../internal/request-options';
 import { buildHeaders } from '../../internal/headers';
 import { promiseWithResolvers } from '../../internal/utils/promise';
+import { checkNever } from '../../internal/utils/values';
 import { CompactionControl, DEFAULT_SUMMARY_PROMPT, DEFAULT_TOKEN_THRESHOLD } from './CompactionControl';
 import {
   collectStainlessHelpers,
@@ -220,6 +222,7 @@ export class BetaToolRunner<Stream extends boolean> {
           if (!isCompacted) {
             if (!this.#mutated) {
               const message = await this.#message;
+              const nextStep = determineNextStepFromStopReason(message.stop_reason);
               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
@@ -233,14 +236,12 @@ export class BetaToolRunner<Stream extends boolean> {
                 }
               }
 
-              // 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
-              // tool_results could never be replayed coherently. Surface the refusal as the
-              // final message instead.
-              if (message.stop_reason === 'refusal') {
+              if (nextStep === 'stop') {
                 break;
               }
+              if (nextStep === 'resume') {
+                continue;
+              }
             }
 
             const toolMessage = await this.#generateToolResponse(this.#state.params.messages.at(-1)!);
@@ -612,6 +613,37 @@ function referencedToolName(
   }
 }
 
+type NextStep = 'run_tools' | 'resume' | 'stop';
+
+/**
+ * Sorts every stop reason into one of three buckets: `run_tools` turns run their client tool
+ * calls and continue the loop; `resume` turns are sent back unchanged so the server continues
+ * them; `stop` turns end the loop without running any tool calls.
+ */
+function determineNextStepFromStopReason(stopReason: BetaStopReason | null): NextStep {
+  if (stopReason === null) return 'stop';
+  switch (stopReason) {
+    case 'tool_use':
+      return 'run_tools';
+    case 'pause_turn':
+    // pause_after_compaction hands the turn back before the model answers; sending it back
+    // unchanged continues it.
+    case 'compaction':
+      return 'resume';
+    case 'end_turn':
+    case 'stop_sequence':
+    case 'max_tokens':
+    case 'model_context_window_exceeded':
+    case 'refusal':
+      return 'stop';
+    default:
+      // The union is forward-compatible, so a stop reason this SDK doesn't know yet ends the
+      // loop rather than throwing; the `never` check makes tsc reject an unclassified member.
+      checkNever(stopReason);
+      return 'stop';
+  }
+}
+
 // vendored from typefest just to make things look a bit nicer on hover
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 

package/node_modules/@anthropic-ai/sdk/src/resources/beta/agents/agents.ts

@@ -862,6 +862,7 @@ export interface BetaManagedAgentsMCPToolsetParams {
  * details and options.
  */
 export type BetaManagedAgentsModel =
+  | 'claude-fable-5-1'
   | 'claude-sonnet-5'
   | 'claude-fable-5'
   | 'claude-opus-5'