@code-yeongyu/senpi 2026.8.24 → 2026.8.26

package/node_modules/@anthropic-ai/sdk/src/client.ts

@@ -9,13 +9,33 @@ export type { Logger, LogLevel } from './internal/utils/log';
 import { castToError, isAbortError } from './internal/errors';
 import type { APIResponseProps } from './internal/parse';
 import { getPlatformHeaders } from './internal/detect-platform';
+import {
+  armAbandonmentBackstop,
+  registerRequestSignalCleanup,
+  releaseRequestSignal,
+} from './internal/request-signal';
 import * as Shims from './internal/shims';
 import * as Opts from './internal/request-options';
 import { stringifyQuery } from './internal/utils/query';
 import { VERSION } from './version';
 import * as Errors from './core/error';
+import type { AccessTokenProvider } from './lib/credentials/types';
+import { OAUTH_API_BETA_HEADER } from './lib/credentials/types';
+import { TokenCache } from './lib/credentials/token-cache';
+import { defaultCredentials, resolveCredentialsFromConfig } from './lib/credentials/credential-chain';
+import type { AnthropicConfig } from './core/credentials';
+import {
+  type Middleware,
+  isFetchOriginError,
+  isRetryableError,
+  wrapFetchWithMiddleware,
+} from './core/middleware';
+export type { Middleware, MiddlewareContext, MiddlewareNext } from './core/middleware';
+export type { APIRequest } from './core/api';
 import * as Pagination from './core/pagination';
 import {
+  type BidirectionalPageCursorParams,
+  BidirectionalPageCursorResponse,
   type PageCursorParams,
   PageCursorResponse,
   type PageParams,
@@ -33,6 +53,14 @@ import {
   CompletionCreateParamsStreaming,
   Completions,
 } from './resources/completions';
+import {
+  DeletedFile,
+  FileListParams,
+  FileMetadata,
+  FileMetadataPageCursor,
+  FileUploadParams,
+  Files,
+} from './resources/files';
 import {
   CapabilitySupport,
   ContextManagementCapability,
@@ -52,10 +80,12 @@ import {
   BetaAPIError,
   BetaAuthenticationError,
   BetaBillingError,
+  BetaCurrency,
   BetaError,
   BetaErrorResponse,
   BetaGatewayTimeoutError,
   BetaInvalidRequestError,
+  BetaMonetaryAmount,
   BetaNotFoundError,
   BetaOverloadedError,
   BetaPermissionError,
@@ -73,6 +103,46 @@ import {
   BashCodeExecutionToolResultError,
   BashCodeExecutionToolResultErrorCode,
   BashCodeExecutionToolResultErrorParam,
+  BrowserCloseTabConfig,
+  BrowserDoubleClickConfig,
+  BrowserFileUploadConfig,
+  BrowserFindConfig,
+  BrowserFormInputConfig,
+  BrowserGetPageTextConfig,
+  BrowserHoldKeyConfig,
+  BrowserHoverConfig,
+  BrowserJavascriptExecConfig,
+  BrowserKeyConfig,
+  BrowserLeftClickConfig,
+  BrowserLeftClickDragConfig,
+  BrowserLeftMouseDownConfig,
+  BrowserLeftMouseUpConfig,
+  BrowserListTabsConfig,
+  BrowserMiddleClickConfig,
+  BrowserMouseMoveConfig,
+  BrowserNavigateConfig,
+  BrowserNewTabConfig,
+  BrowserReadConsoleConfig,
+  BrowserReadNetworkConfig,
+  BrowserReadPageConfig,
+  BrowserRightClickConfig,
+  BrowserScreenshotConfig,
+  BrowserScrollConfig,
+  BrowserScrollToConfig,
+  BrowserStateBlockParam,
+  BrowserStateChange,
+  BrowserStateChangeDownloadCompleted,
+  BrowserStateChangeDownloadFailed,
+  BrowserStateChangeDownloadStarted,
+  BrowserStateChangeTabOpened,
+  BrowserStateTabEntry,
+  BrowserSwitchTabConfig,
+  BrowserToolset20260801,
+  BrowserToolsetConfigs,
+  BrowserTripleClickConfig,
+  BrowserTypeConfig,
+  BrowserWaitConfig,
+  BrowserZoomConfig,
   CacheControlEphemeral,
   CacheCreation,
   CitationCharLocation,
@@ -95,6 +165,7 @@ import {
   CodeExecutionTool20250522,
   CodeExecutionTool20250825,
   CodeExecutionTool20260120,
+  CodeExecutionTool20260521,
   CodeExecutionToolResultBlock,
   CodeExecutionToolResultBlockContent,
   CodeExecutionToolResultBlockParam,
@@ -102,7 +173,28 @@ import {
   CodeExecutionToolResultError,
   CodeExecutionToolResultErrorCode,
   CodeExecutionToolResultErrorParam,
+  ComputerCursorPositionConfig,
+  ComputerDoubleClickConfig,
+  ComputerHoldKeyConfig,
+  ComputerKeyConfig,
+  ComputerLeftClickConfig,
+  ComputerLeftClickDragConfig,
+  ComputerLeftMouseDownConfig,
+  ComputerLeftMouseUpConfig,
+  ComputerMiddleClickConfig,
+  ComputerMouseMoveConfig,
+  ComputerRightClickConfig,
+  ComputerScreenshotConfig,
+  ComputerScrollConfig,
+  ComputerToolset20260801,
+  ComputerToolsetConfigs,
+  ComputerTripleClickConfig,
+  ComputerTypeConfig,
+  ComputerWaitConfig,
+  ComputerZoomConfig,
   Container,
+  ContainerParams,
+  ContainerSkill,
   ContainerUploadBlock,
   ContainerUploadBlockParam,
   ContentBlock,
@@ -117,7 +209,10 @@ import {
   DocumentBlockParam,
   EncryptedCodeExecutionResultBlock,
   EncryptedCodeExecutionResultBlockParam,
+  FileDocumentSource,
+  FileImageSource,
   ImageBlockParam,
+  ImageTransformationsParam,
   InputJSONDelta,
   JSONOutputFormat,
   MemoryTool20250818,
@@ -126,6 +221,7 @@ import {
   MessageCountTokensParams,
   MessageCountTokensTool,
   MessageCreateParams,
+  MessageCreateParamsContainer,
   MessageCreateParamsNonStreaming,
   MessageCreateParamsStreaming,
   MessageDeltaEvent,
@@ -139,6 +235,7 @@ import {
   Metadata,
   Model,
   OutputConfig,
+  OutputTokensDetails,
   PlainTextSource,
   RawContentBlockDelta,
   RawContentBlockDeltaEvent,
@@ -158,6 +255,7 @@ import {
   ServerToolUseBlock,
   ServerToolUseBlockParam,
   SignatureDelta,
+  SkillParams,
   StopReason,
   TextBlock,
   TextBlockParam,
@@ -216,6 +314,7 @@ import {
   WebFetchTool20250910,
   WebFetchTool20260209,
   WebFetchTool20260309,
+  WebFetchTool20260318,
   WebFetchToolResultBlock,
   WebFetchToolResultBlockParam,
   WebFetchToolResultErrorBlock,
@@ -225,6 +324,7 @@ import {
   WebSearchResultBlockParam,
   WebSearchTool20250305,
   WebSearchTool20260209,
+  WebSearchTool20260318,
   WebSearchToolRequestError,
   WebSearchToolResultBlock,
   WebSearchToolResultBlockContent,
@@ -233,6 +333,15 @@ import {
   WebSearchToolResultError,
   WebSearchToolResultErrorCode,
 } from './resources/messages/messages';
+import {
+  DeletedSkill,
+  Skill,
+  SkillCreateParams,
+  SkillListParams,
+  SkillSource,
+  Skills,
+  SkillsPageCursor,
+} from './resources/skills/skills';
 import { type Fetch } from './internal/builtin-types';
 import { isRunningInBrowser } from './internal/detect-platform';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
@@ -241,12 +350,47 @@ import { readEnv } from './internal/utils/env';
 import {
   type LogLevel,
   type Logger,
+  defaultLogLevel,
   formatRequestDetails,
   loggerFor,
   parseLogLevel,
 } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
 
+/**
+ * Shared auth state. A `withOptions()` clone receives the parent's instance
+ * (unless the caller overrides auth options) so a clone created before lazy
+ * resolution settles observes the same provider/tokenCache/error/extraHeaders
+ * as the parent rather than starting an independent resolution.
+ */
+type AuthState = {
+  provider: AccessTokenProvider | null;
+  tokenCache: TokenCache | null;
+  resolution: Promise<void> | null;
+  error: unknown;
+  extraHeaders: Record<string, string>;
+  /**
+   * `base_url` from the resolved profile/config, normalized (no trailing
+   * slash). Stored on the shared auth state so `withOptions()` clones created
+   * before lazy resolution settles can still adopt it on their first request.
+   */
+  baseURL?: string | undefined;
+};
+
+/**
+ * Per-request auth flags, keyed by the FinalRequestOptions object so
+ * caller-owned options aren't mutated.
+ */
+type RequestAuthFlags = {
+  usedTokenCache: boolean;
+  didRefreshFor401: boolean;
+};
+
+type InternalClientOptions = ClientOptions & {
+  __auth?: AuthState | undefined;
+  __baseURLIsExplicit?: boolean | undefined;
+};
+
 export type ApiKeySetter = () => Promise<string>;
 
 export interface ClientOptions {
@@ -268,6 +412,45 @@ export interface ClientOptions {
    */
   authToken?: string | null | undefined;
 
+  /**
+   * An {@link AccessTokenProvider} for OAuth/workload-identity authentication.
+   *
+   * When set, the provider is wrapped in a {@link TokenCache} and used for
+   * Bearer token auth on every request. Takes precedence over `authToken`
+   * but not `apiKey`.
+   *
+   * If omitted (and no `apiKey` or `authToken` is provided), the client
+   * automatically resolves credentials from config files or environment
+   * variables on the first request.
+   */
+  credentials?: AccessTokenProvider | null | undefined;
+
+  /**
+   * An {@link AnthropicConfig} object to resolve credentials from directly,
+   * bypassing config-file and environment-variable lookup. This is the
+   * TypeScript equivalent of Go's `option.WithConfig(cfg)`.
+   *
+   * Ignored when `credentials` is set. For `oidc_federation`, the SDK
+   * performs the jwt-bearer exchange in-process; for `user_oauth`,
+   * `authentication.credentials_path` must point at the credentials file.
+   */
+  config?: AnthropicConfig | null | undefined;
+
+  /**
+   * Name of a profile to load from `<config_dir>/configs/<profile>.json`.
+   *
+   * Equivalent to setting the `ANTHROPIC_PROFILE` environment variable, but
+   * scoped to this client instance. As an explicit constructor argument it
+   * takes precedence over `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` in the
+   * environment. Mutually exclusive with `credentials` and `config`.
+   */
+  profile?: string | null | undefined;
+
+  /**
+   * Defaults to process.env['ANTHROPIC_WEBHOOK_SIGNING_KEY'].
+   */
+  webhookKey?: string | null | undefined;
+
   /**
    * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
    *
@@ -298,6 +481,18 @@ export interface ClientOptions {
    */
   fetch?: Fetch | undefined;
 
+  /**
+   * {@link Middleware} functions that wrap every HTTP request made by the
+   * client.
+   *
+   * Middleware runs per HTTP attempt, including retries. It observes the
+   * canonical Anthropic-shaped request and response on every backend: on
+   * clients for third-party backends (Bedrock, Vertex, Foundry), the
+   * backend's URL/body rewriting, request signing, and response
+   * normalization happen inside `next`.
+   */
+  middleware?: ReadonlyArray<Middleware> | undefined;
+
   /**
    * The maximum number of times that the client will retry a request in case of a
    * temporary failure, like a network error or a 5XX error from the server.
@@ -352,6 +547,31 @@ export const AI_PROMPT = '\\n\\nAssistant:';
 export class BaseAnthropic {
   apiKey: string | null;
   authToken: string | null;
+  webhookKey: string | null;
+
+  /**
+   * The active credential provider. Default credential resolution runs once
+   * at construction time. If it fails, the error is surfaced on every
+   * request and the client must be reconstructed — there is no retry path.
+   *
+   * Clones returned by {@link withOptions} share the parent's auth state
+   * (provider, token cache, pending resolution, and any resolution error)
+   * unless the caller passes an explicit `apiKey`, `authToken`,
+   * `credentials`, `config`, or `profile` override.
+   */
+  get credentials(): AccessTokenProvider | null {
+    return this._authState.provider;
+  }
+  private _authState: AuthState;
+  /**
+   * Whether `baseURL` was chosen by the caller (constructor arg or env var)
+   * rather than derived. Non-explicit base URLs may be replaced — by a
+   * profile-supplied host, or by re-derivation in `withOptions()` clones.
+   * Subclasses that derive their own base URL should correct this after
+   * `super()`, since the base constructor can't tell a derived value apart.
+   */
+  protected _baseURLIsExplicit: boolean;
+  private _requestAuthFlags = new WeakMap<FinalRequestOptions, RequestAuthFlags>();
 
   baseURL: string;
   maxRetries: number;
@@ -359,6 +579,7 @@ export class BaseAnthropic {
   logger: Logger;
   logLevel: LogLevel | undefined;
   fetchOptions: MergedRequestInit | undefined;
+  middleware: ReadonlyArray<Middleware>;
 
   private fetch: Fetch;
   #encoder: Opts.RequestEncoder;
@@ -370,6 +591,7 @@ export class BaseAnthropic {
    *
    * @param {string | null | undefined} [opts.apiKey=process.env['ANTHROPIC_API_KEY'] ?? null]
    * @param {string | null | undefined} [opts.authToken=process.env['ANTHROPIC_AUTH_TOKEN'] ?? null]
+   * @param {string | null | undefined} [opts.webhookKey=process.env['ANTHROPIC_WEBHOOK_SIGNING_KEY'] ?? null]
    * @param {string} [opts.baseURL=process.env['ANTHROPIC_BASE_URL'] ?? https://api.anthropic.com] - Override the default base URL for the API.
    * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
@@ -381,13 +603,26 @@ export class BaseAnthropic {
    */
   constructor({
     baseURL = readEnv('ANTHROPIC_BASE_URL'),
-    apiKey = readEnv('ANTHROPIC_API_KEY') ?? null,
-    authToken = readEnv('ANTHROPIC_AUTH_TOKEN') ?? null,
+    apiKey,
+    authToken,
+    webhookKey = readEnv('ANTHROPIC_WEBHOOK_SIGNING_KEY') ?? null,
     ...opts
   }: ClientOptions = {}) {
+    // An explicit `profile` is a constructor-level credential choice; when set,
+    // do not let env ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN shadow it.
+    if (apiKey === undefined) {
+      apiKey = opts.profile != null ? null : readEnv('ANTHROPIC_API_KEY') ?? null;
+    }
+    if (authToken === undefined) {
+      authToken = opts.profile != null ? null : readEnv('ANTHROPIC_AUTH_TOKEN') ?? null;
+    }
+    if (opts.profile != null && (opts.credentials != null || opts.config != null)) {
+      throw new TypeError('Pass at most one of `profile`, `credentials`, or `config`.');
+    }
     const options: ClientOptions = {
       apiKey,
       authToken,
+      webhookKey,
       ...opts,
       baseURL: baseURL || `https://api.anthropic.com`,
     };
@@ -399,48 +634,238 @@ export class BaseAnthropic {
     }
 
     this.baseURL = options.baseURL!;
+    // After destructuring, `baseURL` is the constructor arg or
+    // ANTHROPIC_BASE_URL — both count as an explicit choice that a profile
+    // base_url must not override. A falsy value means we fell through to the
+    // hardcoded default above and a profile may supply the host. withOptions()
+    // propagates the parent's flag via __baseURLIsExplicit so a non-overriding
+    // clone doesn't mistake the inherited baseURL for a caller-supplied one.
+    this._baseURLIsExplicit = (opts as InternalClientOptions).__baseURLIsExplicit ?? !!baseURL;
     this.timeout = options.timeout ?? BaseAnthropic.DEFAULT_TIMEOUT /* 10 minutes */;
     this.logger = options.logger ?? console;
-    const defaultLogLevel = 'warn';
     // Set default logLevel early so that we can log a warning in parseLogLevel.
     this.logLevel = defaultLogLevel;
     this.logLevel =
-      parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this) ??
-      parseLogLevel(readEnv('ANTHROPIC_LOG'), "process.env['ANTHROPIC_LOG']", this) ??
+      parseLogLevel(options.logLevel, 'ClientOptions.logLevel', loggerFor(this)) ??
+      parseLogLevel(readEnv('ANTHROPIC_LOG'), "process.env['ANTHROPIC_LOG']", loggerFor(this)) ??
       defaultLogLevel;
     this.fetchOptions = options.fetchOptions;
     this.maxRetries = options.maxRetries ?? 2;
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
     this.#encoder = Opts.FallbackEncoder;
 
+    this.middleware = [...(options.middleware ?? [])];
+
+    const customHeadersEnv = readEnv('ANTHROPIC_CUSTOM_HEADERS');
+    if (customHeadersEnv) {
+      const parsed: Record<string, string> = {};
+      for (const line of customHeadersEnv.split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon >= 0) {
+          parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+        }
+      }
+      options.defaultHeaders = { ...parsed, ...options.defaultHeaders };
+    }
+
+    const inherited = (opts as InternalClientOptions).__auth;
+    // Never persist the internal __auth handle on _options — it's a
+    // one-shot constructor signal, and leaking it through _options would
+    // cause withOptions() to spread a stale value into clones.
+    delete (options as InternalClientOptions).__auth;
+    delete (options as InternalClientOptions).__baseURLIsExplicit;
     this._options = options;
 
     this.apiKey = typeof apiKey === 'string' ? apiKey : null;
     this.authToken = authToken;
+    this.webhookKey = webhookKey;
+
+    if (inherited) {
+      this._authState = inherited;
+      if (!this._baseURLIsExplicit && inherited.baseURL) {
+        this.baseURL = inherited.baseURL;
+      }
+    } else {
+      this._authState = { provider: null, tokenCache: null, resolution: null, error: null, extraHeaders: {} };
+
+      // apiKey/authToken win over credentials/config/profile; don't build a
+      // token cache or resolve a config that the request path will then ignore.
+      if (this.apiKey == null && this.authToken == null) {
+        const credentials = options.credentials ?? null;
+        if (credentials) {
+          this._authState.provider = credentials;
+          this._authState.tokenCache = this._makeTokenCache(credentials);
+        } else if (options.config != null) {
+          const result = resolveCredentialsFromConfig(options.config, this._credentialResolverOptions());
+          this._authState.provider = result.provider;
+          this._authState.tokenCache = this._makeTokenCache(result.provider);
+          this._authState.extraHeaders = result.extraHeaders;
+          this._applyCredentialBaseURL(result.baseURL);
+        } else if (options.profile != null) {
+          this._authState.resolution = this._resolveDefaultCredentials(options.profile);
+        } else if (this._shouldResolveDefaultCredentials()) {
+          // No explicit auth provided — lazily resolve from the credential
+          // chain on first request. Errors are captured into _auth.error and
+          // surfaced on first use rather than as an unhandled rejection.
+          this._authState.resolution = this._resolveDefaultCredentials();
+        }
+      }
+    }
+  }
+
+  /**
+   * Whether to lazily resolve auth from the default credential chain when no
+   * explicit auth is configured. Called once from the constructor, so
+   * overrides must not depend on subclass instance state. Subclasses that
+   * bring their own auth scheme return false so unrelated local credentials
+   * are never resolved or allowed to supply a base URL.
+   */
+  protected _shouldResolveDefaultCredentials(): boolean {
+    return true;
+  }
+
+  /**
+   * Stores a profile/config-supplied base URL on the shared auth state and, if
+   * the caller did not pin `baseURL` via constructor option or env, adopts it
+   * as this client's outbound API host. Precedence: ctor opt > env > profile >
+   * hardcoded default.
+   */
+  private _applyCredentialBaseURL(baseURL: string | undefined): void {
+    if (!baseURL) return;
+    const normalized = baseURL.replace(/\/+$/, '');
+    this._authState.baseURL = normalized;
+    if (!this._baseURLIsExplicit) {
+      this.baseURL = normalized;
+    }
+  }
+
+  /**
+   * Options bag passed into the credential chain. `baseURL` here is only the
+   * fallback host for the token-exchange POST when the config itself omits
+   * `base_url`; the chain returns the config's own `base_url` (if any) on
+   * {@link CredentialResult.baseURL}, which {@link _applyCredentialBaseURL}
+   * then adopts for outbound API requests. The two are deliberately decoupled
+   * so this fallback never round-trips into precedence.
+   */
+  private _credentialResolverOptions() {
+    return {
+      baseURL: this.baseURL,
+      fetch: this._credentialsFetch(),
+      userAgent: this.getUserAgent(),
+      onCacheWriteError: (err: unknown) => {
+        loggerFor(this).debug('credential cache write failed (best-effort)', err);
+      },
+      onSafetyWarning: (msg: string) => {
+        loggerFor(this).warn(msg);
+      },
+    };
+  }
+
+  /**
+   * A `Fetch` for first-party credential token-exchange requests (OIDC
+   * federation jwt-bearer grants, user-OAuth refresh grants) that routes
+   * through this client's middleware chain, so middleware observes token
+   * traffic like any other request. Only client-level middleware applies:
+   * a minted token is shared across requests, so attributing the exchange
+   * to any one request's per-request middleware would be arbitrary. For the
+   * same reason, `ctx.options` is undefined for these requests.
+   */
+  private _credentialsFetch(): Fetch {
+    return wrapFetchWithMiddleware(this.fetch, this.middleware, undefined, this);
+  }
+
+  private _makeTokenCache(provider: AccessTokenProvider): TokenCache {
+    return new TokenCache(provider, (err) => {
+      loggerFor(this).debug('advisory token refresh failed; serving cached token', err);
+    });
   }
 
   /**
    * Create a new client instance re-using the same options given to the current client with optional overriding.
    */
   withOptions(options: Partial<ClientOptions>): this {
-    const client = new (this.constructor as any as new (props: ClientOptions) => typeof this)({
+    // Share the auth state object unless the caller passes any auth-related
+    // key. The `in` check is intentional: even `apiKey: undefined` opts the
+    // clone out of sharing (it gets its own _auth and TokenCache, though it
+    // may still wrap the parent's provider via the credentials spread below).
+    const overridesStructuredAuth = 'credentials' in options || 'config' in options || 'profile' in options;
+    const overridesAuth = 'apiKey' in options || 'authToken' in options || overridesStructuredAuth;
+    const internal: InternalClientOptions = {
       ...this._options,
-      baseURL: this.baseURL,
+      // Only forward baseURL when the caller (or env) explicitly chose it.
+      // For a non-explicit parent, this.baseURL may have been mutated to the
+      // profile-resolved host; pinning that as the clone's options.baseURL
+      // would make _options on the clone misreport caller intent and would
+      // leave the clone stuck on the parent's host across an auth override.
+      // The clone instead receives the construction-time value via
+      // ...this._options above and re-adopts the profile host through the
+      // shared _authState.baseURL + __baseURLIsExplicit=false path.
+      ...(this._baseURLIsExplicit ? { baseURL: this.baseURL } : {}),
       maxRetries: this.maxRetries,
       timeout: this.timeout,
       logger: this.logger,
       logLevel: this.logLevel,
       fetch: this.fetch,
       fetchOptions: this.fetchOptions,
+      middleware: this.middleware,
       apiKey: this.apiKey,
       authToken: this.authToken,
+      webhookKey: this.webhookKey,
+      // credentials: this.credentials is a no-op when __auth is shared (the
+      // ctor takes the inherited path and ignores options.credentials); when
+      // overridesAuth is true via apiKey/authToken only, it lets the clone
+      // build a fresh TokenCache around the parent's provider.
+      credentials: this.credentials,
+      // When the caller passes a structured-credential override, drop inherited
+      // structured-credential options so only `...options` supplies them —
+      // otherwise an inherited `credentials`/`config`/`profile` would trip the
+      // mutual-exclusion check or precedence over the override.
+      ...(overridesStructuredAuth ? { credentials: undefined, config: undefined, profile: undefined } : {}),
       ...options,
-    });
-    return client;
+      // Always set __auth so any stale value from ...this._options is
+      // overwritten. undefined means "build fresh auth from these options".
+      __auth: overridesAuth ? undefined : this._authState,
+      __baseURLIsExplicit: 'baseURL' in options ? true : this._baseURLIsExplicit,
+    };
+    return new (this.constructor as any as new (props: ClientOptions) => typeof this)(internal);
+  }
+
+  /**
+   * Lazily resolves credentials from config files or environment variables.
+   * Called once from the constructor when no explicit auth is provided, or
+   * when an explicit `profile` was passed (in which case a missing/unresolved
+   * profile is surfaced as an error instead of falling through to "no auth").
+   * The returned promise is stored and awaited on the first request.
+   */
+  private async _resolveDefaultCredentials(profile?: string): Promise<void> {
+    try {
+      const result = await defaultCredentials(this._credentialResolverOptions(), profile);
+      if (result) {
+        this._authState.provider = result.provider;
+        this._authState.tokenCache = this._makeTokenCache(result.provider);
+        this._authState.extraHeaders = result.extraHeaders;
+        this._applyCredentialBaseURL(result.baseURL);
+      } else if (profile != null) {
+        throw new Errors.AnthropicError(
+          `Profile "${profile}" could not be resolved (no <config_dir>/configs/${profile}.json found).`,
+        );
+      }
+    } catch (err) {
+      this._authState.error = err;
+    } finally {
+      this._authState.resolution = null;
+    }
   }
 
   /**
    * Check whether the base URL is set to its default.
+   *
+   * A profile-supplied `base_url` counts as an override here: a profile that
+   * pins a non-default host is declaring "this whole client targets deployment
+   * X", so per-endpoint {@link RequestOptions.defaultBaseURL} hints must not
+   * silently route individual calls back to production. No generated resource
+   * currently sets `defaultBaseURL`, so this is documenting intent for when
+   * one does.
    */
   #baseURLOverridden(): boolean {
     return this.baseURL !== 'https://api.anthropic.com';
@@ -454,6 +879,12 @@ export class BaseAnthropic {
     if (values.get('x-api-key') || values.get('authorization')) {
       return;
     }
+    if (this._authState.error) {
+      throw this._authState.error;
+    }
+    if (this._authState.tokenCache || this._authState.resolution) {
+      return; // auth will be injected per-request via authHeaders
+    }
 
     if (this.apiKey && values.get('x-api-key')) {
       return;
@@ -470,11 +901,35 @@ export class BaseAnthropic {
     }
 
     throw new Error(
-      'Could not resolve authentication method. Expected either apiKey or authToken to be set. Or for one of the "X-Api-Key" or "Authorization" headers to be explicitly omitted',
+      'Could not resolve authentication method. Expected one of apiKey, authToken, credentials, config, or profile to be set. Or for one of the "X-Api-Key" or "Authorization" headers to be explicitly omitted',
     );
   }
 
+  private _authFlags(opts: FinalRequestOptions): RequestAuthFlags {
+    let flags = this._requestAuthFlags.get(opts);
+    if (!flags) {
+      flags = { usedTokenCache: false, didRefreshFor401: false };
+      this._requestAuthFlags.set(opts, flags);
+    }
+    return flags;
+  }
+
   protected async authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
+    // Wait for lazy credential resolution if it's in progress. If it failed,
+    // return no auth headers — validateHeaders surfaces the stored error
+    // after the explicit-header escape hatch has had a chance to apply.
+    if (this._authState.resolution) {
+      await this._authState.resolution;
+    }
+    if (this._authState.error) {
+      return undefined;
+    }
+    // If we have a token cache and no API key is set, use token auth
+    if (this._authState.tokenCache && this.apiKey == null) {
+      const token = await this._authState.tokenCache.getToken();
+      this._authFlags(opts).usedTokenCache = true;
+      return buildHeaders([{ Authorization: `Bearer ${token}` }]);
+    }
     return buildHeaders([await this.apiKeyAuth(opts), await this.bearerAuth(opts)]);
   }
 
@@ -492,15 +947,12 @@ export class BaseAnthropic {
     return buildHeaders([{ Authorization: `Bearer ${this.authToken}` }]);
   }
 
-  /**
-   * Basic re-implementation of `qs.stringify` for primitive types.
-   */
   protected stringifyQuery(query: object | Record<string, unknown>): string {
     return stringifyQuery(query);
   }
 
-  private getUserAgent(): string {
-    return `${this.constructor.name}/JS ${VERSION}`;
+  protected getUserAgent(): string {
+    return `Anthropic/JS ${VERSION}`;
   }
 
   protected defaultIdempotencyKey(): string {
@@ -562,11 +1014,61 @@ export class BaseAnthropic {
    *
    * This is useful for cases where you want to add certain headers based off of
    * the request properties, e.g. `method` or `url`.
+   *
+   * Runs after all middleware (including {@link backendMiddleware}),
+   * immediately before each underlying fetch call, so it sees exactly what
+   * goes over the wire. Middleware may replay a request by calling `next()`
+   * more than once, so this hook can run multiple times per attempt:
+   * overrides must be idempotent and overwrite headers from a previous
+   * invocation rather than append to them.
    */
   protected async prepareRequest(
     request: RequestInit,
     { url, options }: { url: string; options: FinalRequestOptions },
-  ): Promise<void> {}
+  ): Promise<void> {
+    // Append auth-derived headers when using token auth. Done here (after all
+    // header merging) rather than in authHeaders() so we append to any existing
+    // anthropic-beta values instead of being overwritten by later header sources.
+    if (this._authState.tokenCache && this.apiKey == null) {
+      // Normalize to a Headers instance — custom fetch impls or polyfills can
+      // hand back arrays / plain objects, and silently dropping the beta
+      // header in that case would surface as a confusing server-side 4xx.
+      const headers = request.headers instanceof Headers ? request.headers : new Headers(request.headers);
+      for (const [k, v] of Object.entries(this._authState.extraHeaders)) {
+        if (!headers.has(k)) headers.set(k, v);
+      }
+      const existing = headers
+        .get('anthropic-beta')
+        ?.split(',')
+        .map((s) => s.trim());
+      if (!existing?.includes(OAUTH_API_BETA_HEADER)) {
+        headers.append('anthropic-beta', OAUTH_API_BETA_HEADER);
+      }
+      request.headers = headers;
+    }
+  }
+
+  /**
+   * Internal {@link Middleware} composed innermost in the chain — inside both
+   * client-level and per-request middleware, immediately around the underlying
+   * `fetch`. Subclasses for third-party backends override this to adapt the
+   * canonical Anthropic-shaped request to the backend's wire shape (URL/body
+   * rewriting, request signing) and to normalize the wire response back to the
+   * canonical shape (e.g. AWS EventStream to SSE).
+   *
+   * Running inside the user's middleware means user middleware always observes
+   * canonical Anthropic-shaped traffic, and the adaptation re-runs (e.g.
+   * re-signs) on every `next()` invocation, covering whatever the middleware
+   * mutated.
+   *
+   * Errors thrown here follow the middleware error policy: they propagate to
+   * the caller as-is — no retries, no `APIConnectionError` wrapping — unless
+   * retryable (see {@link Middleware}); throw a `RetryableError` to opt into
+   * the retry path.
+   */
+  protected backendMiddleware(): ReadonlyArray<Middleware> {
+    return [];
+  }
 
   get<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp> {
     return this.methodRequest('get', path, opts);
@@ -616,6 +1118,9 @@ export class BaseAnthropic {
     const maxRetries = options.maxRetries ?? this.maxRetries;
     if (retriesRemaining == null) {
       retriesRemaining = maxRetries;
+      // Top-level call: reset per-request auth flags so a reused options object
+      // (via client.request(opts)) doesn't carry stale 401-refresh state.
+      this._requestAuthFlags.delete(options);
     }
 
     await this.prepareOptions(options);
@@ -624,33 +1129,24 @@ export class BaseAnthropic {
       retryCount: maxRetries - retriesRemaining,
     });
 
-    await this.prepareRequest(req, { url, options });
-
     /** Not an API request ID, just for correlating local log entries. */
     const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0');
     const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`;
     const startTime = Date.now();
 
-    loggerFor(this).debug(
-      `[${requestLogID}] sending request`,
-      formatRequestDetails({
-        retryOfRequestLogID,
-        method: options.method,
-        url,
-        options,
-        headers: req.headers,
-      }),
-    );
-
     if (options.signal?.aborted) {
       throw new Errors.APIUserAbortError();
     }
 
     const controller = new AbortController();
-    const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+    const response = await this.fetchWithTimeout(url, req, timeout, controller, options, {
+      requestLogID,
+      retryOfRequestLogID,
+    }).catch(castToError);
     const headersTime = Date.now();
 
     if (response instanceof globalThis.Error) {
+      releaseRequestSignal(controller);
       const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
       if (options.signal?.aborted) {
         throw new Errors.APIUserAbortError();
@@ -662,6 +1158,27 @@ export class BaseAnthropic {
       const isTimeout =
         isAbortError(response) ||
         /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
+
+      // Errors thrown by middleware (user middleware and the backend adaptation
+      // alike) propagate to the caller as-is — no retries, no APIConnectionError
+      // wrapping — except retryable errors (timeouts/aborts, APIConnectionErrors,
+      // and RetryableErrors, directly or in the `cause` chain), which stay on the
+      // retry path.
+      const hasMiddleware =
+        this.middleware.length > 0 || !!options.middleware?.length || this.backendMiddleware().length > 0;
+      if (hasMiddleware && !isTimeout && !isRetryableError(response)) {
+        loggerFor(this).info(`[${requestLogID}] middleware error (not retryable)`);
+        loggerFor(this).debug(
+          `[${requestLogID}] middleware error (not retryable)`,
+          formatRequestDetails({
+            retryOfRequestLogID,
+            url,
+            durationMs: headersTime - startTime,
+            message: response.message,
+          }),
+        );
+        throw response;
+      }
       if (retriesRemaining) {
         loggerFor(this).info(
           `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`,
@@ -692,11 +1209,16 @@ export class BaseAnthropic {
       if (isTimeout) {
         throw new Errors.APIConnectionTimeoutError();
       }
+      // a retryable middleware-origin error is still the caller's error: once retries are
+      // exhausted it propagates as-is rather than wrapped in APIConnectionError
+      if (hasMiddleware && !isFetchOriginError(response)) {
+        throw response;
+      }
       throw new Errors.APIConnectionError({ cause: response });
     }
 
     const specialHeaders = [...response.headers.entries()]
-      .filter(([name]) => name === 'request-id')
+      .filter(([name]) => name === 'request-id' || name === 'anthropic-workspace-id')
       .map(([name, value]) => ', ' + name + ': ' + JSON.stringify(value))
       .join('');
     const responseInfo = `[${requestLogID}${retryLogStr}${specialHeaders}] ${req.method} ${url} ${
@@ -704,12 +1226,13 @@ export class BaseAnthropic {
     } with status ${response.status} in ${headersTime - startTime}ms`;
 
     if (!response.ok) {
-      const shouldRetry = await this.shouldRetry(response);
+      const shouldRetry = await this.shouldRetry(response, options);
       if (retriesRemaining && shouldRetry) {
         const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
 
         // We don't need the body of this response.
         await Shims.CancelReadableStream(response.body);
+        releaseRequestSignal(controller);
         loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
         loggerFor(this).debug(
           `[${requestLogID}] response error (${retryMessage})`,
@@ -749,6 +1272,7 @@ export class BaseAnthropic {
         }),
       );
 
+      releaseRequestSignal(controller);
       const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
       throw err;
     }
@@ -765,6 +1289,7 @@ export class BaseAnthropic {
       }),
     );
 
+    armAbandonmentBackstop(response.body ?? response, controller);
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
 
@@ -797,6 +1322,8 @@ export class BaseAnthropic {
     init: RequestInit | undefined,
     ms: number,
     controller: AbortController,
+    requestOptions?: FinalRequestOptions | undefined,
+    logCtx?: { requestLogID: string; retryOfRequestLogID?: string | undefined } | undefined,
   ): Promise<Response> {
     const { signal, method, ...options } = init || {};
     // Avoid creating a closure over `this`, `init`, or `options` to prevent memory leaks.
@@ -806,9 +1333,10 @@ export class BaseAnthropic {
     // the lifetime of the signal. Using `.bind()` only retains a reference to the
     // controller itself.
     const abort = this._makeAbort(controller);
-    if (signal) signal.addEventListener('abort', abort, { once: true });
-
-    const timeout = setTimeout(abort, ms);
+    if (signal) {
+      signal.addEventListener('abort', abort, { once: true });
+      registerRequestSignalCleanup(controller, signal, abort);
+    }
 
     const isReadableBody =
       ((globalThis as any).ReadableStream && options.body instanceof (globalThis as any).ReadableStream) ||
@@ -826,15 +1354,81 @@ export class BaseAnthropic {
       fetchOptions.method = method.toUpperCase();
     }
 
-    try {
-      // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-      return await this.fetch.call(undefined, url, fetchOptions);
-    } finally {
-      clearTimeout(timeout);
-    }
+    // Arm the timeout around the underlying fetch only, not the middleware
+    // chain — middleware can take arbitrarily long (or call `next` more than
+    // once), and each inner-fetch invocation gets its own `ms` timer.
+    const baseFetch = this.fetch;
+    const timedFetch: Fetch = async (innerUrl, innerInit) => {
+      const timeout = setTimeout(abort, ms);
+      try {
+        return await baseFetch.call(undefined, innerUrl, innerInit);
+      } finally {
+        clearTimeout(timeout);
+      }
+    };
+
+    // Prepare the request (auth signing and other `prepareRequest` hooks) as
+    // the innermost step, after any middleware — including the backend
+    // middleware, so it sees exactly what goes over the wire. Runs per
+    // inner-fetch invocation, so a request middleware rewrote — or replayed
+    // via a second `next()` call — is prepared fresh each time. Preparation is
+    // outside the timeout timer, matching its pre-middleware behavior.
+    const innerFetch: Fetch =
+      requestOptions === undefined ? timedFetch : (
+        async (innerUrl, innerInit = {}) => {
+          const innerUrlStr =
+            typeof innerUrl === 'string' ? innerUrl
+            : innerUrl instanceof URL ? innerUrl.href
+            : innerUrl.url;
+          innerInit.headers =
+            innerInit.headers instanceof Headers ? innerInit.headers : new Headers(innerInit.headers);
+
+          await this.prepareRequest(innerInit, { url: innerUrlStr, options: requestOptions });
+
+          if (logCtx) {
+            loggerFor(this).debug(
+              `[${logCtx.requestLogID}] sending request`,
+              formatRequestDetails({
+                retryOfRequestLogID: logCtx.retryOfRequestLogID,
+                method: innerInit.method,
+                url: innerUrlStr,
+                options: requestOptions,
+                headers: innerInit.headers,
+              }),
+            );
+          }
+
+          return timedFetch(innerUrl, innerInit);
+        }
+      );
+
+    const requestMiddleware = requestOptions?.middleware;
+    const backendMiddleware = this.backendMiddleware();
+    const allMiddleware =
+      requestMiddleware?.length || backendMiddleware.length ?
+        [...this.middleware, ...(requestMiddleware ?? []), ...backendMiddleware]
+      : this.middleware;
+    return await wrapFetchWithMiddleware(innerFetch, allMiddleware, requestOptions, this)(url, fetchOptions);
   }
 
-  private async shouldRetry(response: Response): Promise<boolean> {
+  private async shouldRetry(response: Response, options: FinalRequestOptions): Promise<boolean> {
+    // Reactive refresh: on a 401 from a request that used the token cache,
+    // invalidate and retry once. Only fires when this specific request was
+    // bearer-authenticated (not when an apiKey was used) and only once per
+    // request — a second 401 after refresh falls through to the normal
+    // retry policy below (which treats 4xx as non-retryable).
+    const flags = this._authFlags(options);
+    if (
+      response.status === 401 &&
+      this._authState.tokenCache &&
+      flags.usedTokenCache &&
+      !flags.didRefreshFor401
+    ) {
+      flags.didRefreshFor401 = true;
+      this._authState.tokenCache.invalidate();
+      return true;
+    }
+
     // Note this is not a standard header.
     const shouldRetryHeader = response.headers.get('x-should-retry');
 
@@ -932,6 +1526,17 @@ export class BaseAnthropic {
     const options = { ...inputOptions };
     const { method, path, query, defaultBaseURL } = options;
 
+    // Lazy credential resolution may carry a profile-supplied baseURL. Await
+    // it before building the request URL so the very first request — and
+    // requests on withOptions() clones created before resolution settled —
+    // hit the profile's host rather than the hardcoded default.
+    if (this._authState.resolution) {
+      await this._authState.resolution;
+    }
+    if (!this._baseURLIsExplicit && this._authState.baseURL && this.baseURL !== this._authState.baseURL) {
+      this.baseURL = this._authState.baseURL;
+    }
+
     const url = this.buildURL(path!, query as Record<string, unknown>, defaultBaseURL);
     if ('timeout' in options) validatePositiveInteger('timeout', options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -1073,16 +1678,21 @@ export class Anthropic extends BaseAnthropic {
   completions: API.Completions = new API.Completions(this);
   messages: API.Messages = new API.Messages(this);
   models: API.Models = new API.Models(this);
+  files: API.Files = new API.Files(this);
+  skills: API.Skills = new API.Skills(this);
   beta: API.Beta = new API.Beta(this);
 }
 
 Anthropic.Completions = Completions;
 Anthropic.Messages = Messages;
 Anthropic.Models = Models;
+Anthropic.Files = Files;
+Anthropic.Skills = Skills;
 Anthropic.Beta = Beta;
 
 export declare namespace Anthropic {
   export type RequestOptions = Opts.RequestOptions;
+  export type FinalRequestOptions = Opts.FinalRequestOptions;
 
   export type { ApiKeySetter };
 
@@ -1095,6 +1705,12 @@ export declare namespace Anthropic {
   export import PageCursor = Pagination.PageCursor;
   export { type PageCursorParams as PageCursorParams, type PageCursorResponse as PageCursorResponse };
 
+  export import BidirectionalPageCursor = Pagination.BidirectionalPageCursor;
+  export {
+    type BidirectionalPageCursorParams as BidirectionalPageCursorParams,
+    type BidirectionalPageCursorResponse as BidirectionalPageCursorResponse,
+  };
+
   export {
     Completions as Completions,
     type Completion as Completion,
@@ -1116,6 +1732,46 @@ export declare namespace Anthropic {
     type BashCodeExecutionToolResultError as BashCodeExecutionToolResultError,
     type BashCodeExecutionToolResultErrorCode as BashCodeExecutionToolResultErrorCode,
     type BashCodeExecutionToolResultErrorParam as BashCodeExecutionToolResultErrorParam,
+    type BrowserCloseTabConfig as BrowserCloseTabConfig,
+    type BrowserDoubleClickConfig as BrowserDoubleClickConfig,
+    type BrowserFileUploadConfig as BrowserFileUploadConfig,
+    type BrowserFindConfig as BrowserFindConfig,
+    type BrowserFormInputConfig as BrowserFormInputConfig,
+    type BrowserGetPageTextConfig as BrowserGetPageTextConfig,
+    type BrowserHoldKeyConfig as BrowserHoldKeyConfig,
+    type BrowserHoverConfig as BrowserHoverConfig,
+    type BrowserJavascriptExecConfig as BrowserJavascriptExecConfig,
+    type BrowserKeyConfig as BrowserKeyConfig,
+    type BrowserLeftClickConfig as BrowserLeftClickConfig,
+    type BrowserLeftClickDragConfig as BrowserLeftClickDragConfig,
+    type BrowserLeftMouseDownConfig as BrowserLeftMouseDownConfig,
+    type BrowserLeftMouseUpConfig as BrowserLeftMouseUpConfig,
+    type BrowserListTabsConfig as BrowserListTabsConfig,
+    type BrowserMiddleClickConfig as BrowserMiddleClickConfig,
+    type BrowserMouseMoveConfig as BrowserMouseMoveConfig,
+    type BrowserNavigateConfig as BrowserNavigateConfig,
+    type BrowserNewTabConfig as BrowserNewTabConfig,
+    type BrowserReadConsoleConfig as BrowserReadConsoleConfig,
+    type BrowserReadNetworkConfig as BrowserReadNetworkConfig,
+    type BrowserReadPageConfig as BrowserReadPageConfig,
+    type BrowserRightClickConfig as BrowserRightClickConfig,
+    type BrowserScreenshotConfig as BrowserScreenshotConfig,
+    type BrowserScrollConfig as BrowserScrollConfig,
+    type BrowserScrollToConfig as BrowserScrollToConfig,
+    type BrowserStateBlockParam as BrowserStateBlockParam,
+    type BrowserStateChange as BrowserStateChange,
+    type BrowserStateChangeDownloadCompleted as BrowserStateChangeDownloadCompleted,
+    type BrowserStateChangeDownloadFailed as BrowserStateChangeDownloadFailed,
+    type BrowserStateChangeDownloadStarted as BrowserStateChangeDownloadStarted,
+    type BrowserStateChangeTabOpened as BrowserStateChangeTabOpened,
+    type BrowserStateTabEntry as BrowserStateTabEntry,
+    type BrowserSwitchTabConfig as BrowserSwitchTabConfig,
+    type BrowserToolset20260801 as BrowserToolset20260801,
+    type BrowserToolsetConfigs as BrowserToolsetConfigs,
+    type BrowserTripleClickConfig as BrowserTripleClickConfig,
+    type BrowserTypeConfig as BrowserTypeConfig,
+    type BrowserWaitConfig as BrowserWaitConfig,
+    type BrowserZoomConfig as BrowserZoomConfig,
     type CacheControlEphemeral as CacheControlEphemeral,
     type CacheCreation as CacheCreation,
     type CitationCharLocation as CitationCharLocation,
@@ -1138,6 +1794,7 @@ export declare namespace Anthropic {
     type CodeExecutionTool20250522 as CodeExecutionTool20250522,
     type CodeExecutionTool20250825 as CodeExecutionTool20250825,
     type CodeExecutionTool20260120 as CodeExecutionTool20260120,
+    type CodeExecutionTool20260521 as CodeExecutionTool20260521,
     type CodeExecutionToolResultBlock as CodeExecutionToolResultBlock,
     type CodeExecutionToolResultBlockContent as CodeExecutionToolResultBlockContent,
     type CodeExecutionToolResultBlockParam as CodeExecutionToolResultBlockParam,
@@ -1145,7 +1802,28 @@ export declare namespace Anthropic {
     type CodeExecutionToolResultError as CodeExecutionToolResultError,
     type CodeExecutionToolResultErrorCode as CodeExecutionToolResultErrorCode,
     type CodeExecutionToolResultErrorParam as CodeExecutionToolResultErrorParam,
+    type ComputerCursorPositionConfig as ComputerCursorPositionConfig,
+    type ComputerDoubleClickConfig as ComputerDoubleClickConfig,
+    type ComputerHoldKeyConfig as ComputerHoldKeyConfig,
+    type ComputerKeyConfig as ComputerKeyConfig,
+    type ComputerLeftClickConfig as ComputerLeftClickConfig,
+    type ComputerLeftClickDragConfig as ComputerLeftClickDragConfig,
+    type ComputerLeftMouseDownConfig as ComputerLeftMouseDownConfig,
+    type ComputerLeftMouseUpConfig as ComputerLeftMouseUpConfig,
+    type ComputerMiddleClickConfig as ComputerMiddleClickConfig,
+    type ComputerMouseMoveConfig as ComputerMouseMoveConfig,
+    type ComputerRightClickConfig as ComputerRightClickConfig,
+    type ComputerScreenshotConfig as ComputerScreenshotConfig,
+    type ComputerScrollConfig as ComputerScrollConfig,
+    type ComputerToolset20260801 as ComputerToolset20260801,
+    type ComputerToolsetConfigs as ComputerToolsetConfigs,
+    type ComputerTripleClickConfig as ComputerTripleClickConfig,
+    type ComputerTypeConfig as ComputerTypeConfig,
+    type ComputerWaitConfig as ComputerWaitConfig,
+    type ComputerZoomConfig as ComputerZoomConfig,
     type Container as Container,
+    type ContainerParams as ContainerParams,
+    type ContainerSkill as ContainerSkill,
     type ContainerUploadBlock as ContainerUploadBlock,
     type ContainerUploadBlockParam as ContainerUploadBlockParam,
     type ContentBlock as ContentBlock,
@@ -1160,12 +1838,16 @@ export declare namespace Anthropic {
     type DocumentBlockParam as DocumentBlockParam,
     type EncryptedCodeExecutionResultBlock as EncryptedCodeExecutionResultBlock,
     type EncryptedCodeExecutionResultBlockParam as EncryptedCodeExecutionResultBlockParam,
+    type FileDocumentSource as FileDocumentSource,
+    type FileImageSource as FileImageSource,
     type ImageBlockParam as ImageBlockParam,
+    type ImageTransformationsParam as ImageTransformationsParam,
     type InputJSONDelta as InputJSONDelta,
     type JSONOutputFormat as JSONOutputFormat,
     type MemoryTool20250818 as MemoryTool20250818,
     type Message as Message,
     type MessageCountTokensTool as MessageCountTokensTool,
+    type MessageCreateParamsContainer as MessageCreateParamsContainer,
     type MessageDeltaEvent as MessageDeltaEvent,
     type MessageDeltaUsage as MessageDeltaUsage,
     type MessageParam as MessageParam,
@@ -1176,6 +1858,7 @@ export declare namespace Anthropic {
     type Metadata as Metadata,
     type Model as Model,
     type OutputConfig as OutputConfig,
+    type OutputTokensDetails as OutputTokensDetails,
     type PlainTextSource as PlainTextSource,
     type RawContentBlockDelta as RawContentBlockDelta,
     type RawContentBlockDeltaEvent as RawContentBlockDeltaEvent,
@@ -1195,6 +1878,7 @@ export declare namespace Anthropic {
     type ServerToolUseBlock as ServerToolUseBlock,
     type ServerToolUseBlockParam as ServerToolUseBlockParam,
     type SignatureDelta as SignatureDelta,
+    type SkillParams as SkillParams,
     type StopReason as StopReason,
     type TextBlock as TextBlock,
     type TextBlockParam as TextBlockParam,
@@ -1253,6 +1937,7 @@ export declare namespace Anthropic {
     type WebFetchTool20250910 as WebFetchTool20250910,
     type WebFetchTool20260209 as WebFetchTool20260209,
     type WebFetchTool20260309 as WebFetchTool20260309,
+    type WebFetchTool20260318 as WebFetchTool20260318,
     type WebFetchToolResultBlock as WebFetchToolResultBlock,
     type WebFetchToolResultBlockParam as WebFetchToolResultBlockParam,
     type WebFetchToolResultErrorBlock as WebFetchToolResultErrorBlock,
@@ -1262,6 +1947,7 @@ export declare namespace Anthropic {
     type WebSearchResultBlockParam as WebSearchResultBlockParam,
     type WebSearchTool20250305 as WebSearchTool20250305,
     type WebSearchTool20260209 as WebSearchTool20260209,
+    type WebSearchTool20260318 as WebSearchTool20260318,
     type WebSearchToolRequestError as WebSearchToolRequestError,
     type WebSearchToolResultBlock as WebSearchToolResultBlock,
     type WebSearchToolResultBlockContent as WebSearchToolResultBlockContent,
@@ -1290,16 +1976,37 @@ export declare namespace Anthropic {
     type ModelListParams as ModelListParams,
   };
 
+  export {
+    Files as Files,
+    type DeletedFile as DeletedFile,
+    type FileMetadata as FileMetadata,
+    type FileMetadataPageCursor as FileMetadataPageCursor,
+    type FileListParams as FileListParams,
+    type FileUploadParams as FileUploadParams,
+  };
+
+  export {
+    Skills as Skills,
+    type DeletedSkill as DeletedSkill,
+    type Skill as Skill,
+    type SkillSource as SkillSource,
+    type SkillsPageCursor as SkillsPageCursor,
+    type SkillCreateParams as SkillCreateParams,
+    type SkillListParams as SkillListParams,
+  };
+
   export {
     Beta as Beta,
     type AnthropicBeta as AnthropicBeta,
     type BetaAPIError as BetaAPIError,
     type BetaAuthenticationError as BetaAuthenticationError,
     type BetaBillingError as BetaBillingError,
+    type BetaCurrency as BetaCurrency,
     type BetaError as BetaError,
     type BetaErrorResponse as BetaErrorResponse,
     type BetaGatewayTimeoutError as BetaGatewayTimeoutError,
     type BetaInvalidRequestError as BetaInvalidRequestError,
+    type BetaMonetaryAmount as BetaMonetaryAmount,
     type BetaNotFoundError as BetaNotFoundError,
     type BetaOverloadedError as BetaOverloadedError,
     type BetaPermissionError as BetaPermissionError,