@anthropic-ai/sdk 0.100.0 → 0.101.0

package/src/client.ts

@@ -19,6 +19,14 @@ 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 PageCursorParams,
@@ -378,6 +386,14 @@ 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.
+   */
+  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.
@@ -457,6 +473,7 @@ export class BaseAnthropic {
   logger: Logger;
   logLevel: LogLevel | undefined;
   fetchOptions: MergedRequestInit | undefined;
+  middleware: ReadonlyArray<Middleware>;
 
   private fetch: Fetch;
   #encoder: Opts.RequestEncoder;
@@ -532,6 +549,8 @@ export class BaseAnthropic {
     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> = {};
@@ -615,7 +634,7 @@ export class BaseAnthropic {
   private _credentialResolverOptions() {
     return {
       baseURL: this.baseURL,
-      fetch: this.fetch,
+      fetch: this._credentialsFetch(),
       userAgent: this.getUserAgent(),
       onCacheWriteError: (err: unknown) => {
         loggerFor(this).debug('credential cache write failed (best-effort)', err);
@@ -626,6 +645,19 @@ export class BaseAnthropic {
     };
   }
 
+  /**
+   * 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);
+  }
+
   private _makeTokenCache(provider: AccessTokenProvider): TokenCache {
     return new TokenCache(provider, (err) => {
       loggerFor(this).debug('advisory token refresh failed; serving cached token', err);
@@ -659,6 +691,7 @@ export class BaseAnthropic {
       logLevel: this.logLevel,
       fetch: this.fetch,
       fetchOptions: this.fetchOptions,
+      middleware: this.middleware,
       apiKey: this.apiKey,
       authToken: this.authToken,
       webhookKey: this.webhookKey,
@@ -974,7 +1007,7 @@ export class BaseAnthropic {
     }
 
     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).catch(castToError);
     const headersTime = Date.now();
 
     if (response instanceof globalThis.Error) {
@@ -989,6 +1022,25 @@ export class BaseAnthropic {
       const isTimeout =
         isAbortError(response) ||
         /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
+
+      // Errors thrown by middleware 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;
+      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}`,
@@ -1019,6 +1071,11 @@ 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 });
     }
 
@@ -1124,6 +1181,7 @@ export class BaseAnthropic {
     init: RequestInit | undefined,
     ms: number,
     controller: AbortController,
+    requestOptions?: FinalRequestOptions | undefined,
   ): Promise<Response> {
     const { signal, method, ...options } = init || {};
     // Avoid creating a closure over `this`, `init`, or `options` to prevent memory leaks.
@@ -1135,8 +1193,6 @@ export class BaseAnthropic {
     const abort = this._makeAbort(controller);
     if (signal) signal.addEventListener('abort', abort, { once: true });
 
-    const timeout = setTimeout(abort, ms);
-
     const isReadableBody =
       ((globalThis as any).ReadableStream && options.body instanceof (globalThis as any).ReadableStream) ||
       (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
@@ -1153,12 +1209,22 @@ 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);
+      }
+    };
+
+    const middleware = requestOptions?.middleware;
+    const allMiddleware = middleware?.length ? [...this.middleware, ...middleware] : this.middleware;
+    return await wrapFetchWithMiddleware(timedFetch, allMiddleware, requestOptions)(url, fetchOptions);
   }
 
   private async shouldRetry(response: Response, options: FinalRequestOptions): Promise<boolean> {
@@ -1438,6 +1504,7 @@ Anthropic.Beta = Beta;
 
 export declare namespace Anthropic {
   export type RequestOptions = Opts.RequestOptions;
+  export type FinalRequestOptions = Opts.FinalRequestOptions;
 
   export type { ApiKeySetter };
 

package/src/core/api.ts

@@ -0,0 +1,11 @@
+import type { FinalizedRequestInit } from '../internal/types';
+
+/**
+ * An HTTP request as it will be passed to `fetch`, the `RequestInit` plus the request `url`.
+ *
+ * `headers` is always a `Headers` instance and may be mutated in place.
+ */
+export type APIRequest = FinalizedRequestInit & {
+  /** The fully-built request URL, including query parameters. */
+  url: string;
+};

package/src/core/error.ts

@@ -128,6 +128,21 @@ export class APIConnectionTimeoutError extends APIConnectionError {
   }
 }
 
+/**
+ * An error that opts into the SDK's retry policy: throw it (e.g. from
+ * middleware) to have the attempt retried.
+ *
+ * Note that the request will only be retried when `maxRetries` has not been exhausted.
+ */
+export class RetryableError extends AnthropicError {
+  constructor(message?: string, { cause }: { cause?: unknown } = {}) {
+    super(message ?? 'Retryable error.');
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause !== undefined) this.cause = cause;
+  }
+}
+
 export class BadRequestError extends APIError<400, Headers> {}
 
 export class AuthenticationError extends APIError<401, Headers> {}

package/src/core/middleware.ts

@@ -0,0 +1,293 @@
+import type { Fetch } from '../internal/builtin-types';
+import { castToError, isAbortError } from '../internal/errors';
+import { addRequestID } from '../internal/parse';
+import type { FinalRequestOptions } from '../internal/request-options';
+import type { APIRequest } from './api';
+import { AnthropicError, APIConnectionError, RetryableError } from './error';
+import { Stream } from './streaming';
+
+/**
+ * Invokes the rest of the middleware chain, ending with the underlying `fetch`.
+ *
+ * This function can be invoked multiple times.
+ */
+export type MiddlewareNext = (request: APIRequest) => Promise<Response>;
+
+/**
+ * Helpers passed to each middleware alongside `next`, scoped to the request
+ * in flight (one context is shared by every middleware in the chain).
+ */
+export interface MiddlewareContext {
+  /**
+   * The SDK request options the API call in flight was made with: `method`,
+   * `path`, the pre-encoded `body`, `stream`, etc.
+   *
+   * `undefined` when the chain isn't running for an SDK API request, i.e.
+   * for credential token-exchange requests.
+   */
+  readonly options?: FinalRequestOptions | undefined;
+
+  /**
+   * Parse a response body the way the SDK would for the request in flight:
+   *
+   * - JSON responses are decoded, with the non-enumerable `_request_id`
+   *   property attached like SDK return values, and anything else resolves
+   *   to the body text.
+   * - For streaming requests ({@link options}`.stream`), resolves immediately
+   *   with a {@link Stream} reading an independent copy of the response body —
+   *   iterating it doesn't consume the client's events, and aborting or
+   *   `break`ing out of it doesn't cancel the underlying request. Each call
+   *   returns a fresh `Stream` (streams are single-consumer, so they aren't
+   *   cached). Error (non-2xx) responses parse as JSON/text rather than as a
+   *   stream, mirroring the SDK's own handling.
+   * - For binary requests, resolves with the `Response` itself, unconsumed.
+   *
+   * Reads through an internal `response.clone()`, so the response stays
+   * readable: the client (and any other middleware) can still consume the
+   * body afterwards. Non-stream results are cached per `Response` and shared
+   * across the middleware chain, so repeated calls cost a single read.
+   *
+   * @example
+   * ```ts
+   * const mw: Middleware = async (request, next, ctx) => {
+   *   const response = await next(request);
+   *   const data = await ctx.parse<Message>(response);
+   *   if (data.type === 'message') console.log(data.usage);
+   *   return response;
+   * };
+   * ```
+   */
+  parse<T = unknown>(response: Response): Promise<T>;
+}
+
+/**
+ * A function that wraps each HTTP request made by the client.
+ *
+ * Middleware may observe or modify the request before calling `next`, observe
+ * or replace the response, short-circuit by returning a `Response` without
+ * calling `next`, or call `next` multiple times to implement custom retries.
+ *
+ * Middleware must not consume the body of the `Response` it returns - the
+ * client still needs to read it. To inspect the body, use
+ * `await ctx.parse(response)` (cached, leaves the body readable) or read a
+ * clone (`await response.clone().text()`); to transform it, return a
+ * replacement, e.g. `new Response(body, response)`.
+ *
+ * Middleware runs per HTTP attempt, inside the SDK's retry loop; the attempt
+ * number is available via the `X-Stainless-Retry-Count` request header. An
+ * error thrown from middleware propagates to the caller as-is.
+ *
+ * Middleware errors are **not** retried apart from connection-level errors:
+ * timeout/abort errors, errors thrown by `fetch()`, and `APIConnectionError`s
+ * or `RetryableError`s — thrown directly or present anywhere in an error's
+ * `cause` chain. Retryable middleware errors still propagate to the caller
+ * as-is once retries are exhausted.
+ *
+ * @example
+ * ```ts
+ * const logger: Middleware = async (request, next) => {
+ *   console.log('->', request.method, request.url);
+ *   const response = await next(request);
+ *   console.log('<-', response.status, request.url);
+ *   return response;
+ * };
+ *
+ * const client = new Anthropic({ middleware: [logger] });
+ * ```
+ */
+export type Middleware = (
+  request: APIRequest,
+  next: MiddlewareNext,
+  ctx: MiddlewareContext,
+) => Promise<Response>;
+
+/**
+ * Errors thrown by the underlying `fetch`, as opposed to by a middleware.
+ *
+ * Tracked so the client can apply its connection-error retry policy to
+ * transport failures while letting errors thrown by middleware propagate to
+ * the caller untouched.
+ */
+const fetchOriginErrors = new WeakSet<object>();
+
+/** Whether `err` was thrown by the underlying `fetch` rather than by a middleware. */
+export function isFetchOriginError(err: unknown): boolean {
+  return typeof err === 'object' && err !== null && fetchOriginErrors.has(err);
+}
+
+/**
+ * Whether an error thrown by middleware should stay on the SDK's
+ * connection-error retry policy: fetch-origin, abort, `APIConnectionError`, or
+ * `RetryableError` — checked through the error's `cause` chain.
+ */
+export function isRetryableError(err: unknown): boolean {
+  const seen = new Set<unknown>(); // guard against `cause` cycles
+  while (typeof err === 'object' && err !== null && !seen.has(err)) {
+    seen.add(err);
+    if (
+      isFetchOriginError(err) ||
+      isAbortError(err) ||
+      err instanceof APIConnectionError ||
+      err instanceof RetryableError
+    ) {
+      return true;
+    }
+    err = (err as { cause?: unknown }).cause;
+  }
+  return false;
+}
+
+/**
+ * Wraps `fetchFn` so each call runs through `middleware`, keeping the same
+ * call signature as `fetch` itself.
+ *
+ * With no middleware, calls are passed straight through to `fetchFn`.
+ * Otherwise the arguments are normalized into an {@link APIRequest} (headers
+ * coerced to a `Headers` instance, URL stringified) before entering the
+ * chain. The chain is composed per call, so mutations of a `middleware`
+ * array are picked up by later requests.
+ *
+ * `options` — the SDK request options behind this call, when there are any —
+ * is surfaced to middleware as `ctx.options` and drives `ctx.parse`.
+ */
+export function wrapFetchWithMiddleware(
+  fetchFn: Fetch,
+  middleware: readonly Middleware[],
+  options?: FinalRequestOptions | undefined,
+): Fetch {
+  return async (url, init = {}) => {
+    if (middleware.length === 0) {
+      // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+      return fetchFn.call(undefined, url, init);
+    }
+    const headers = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    const response = await applyMiddleware(
+      fetchFn,
+      middleware,
+      options,
+    )({
+      ...init,
+      headers,
+      url:
+        typeof url === 'string' ? url
+        : url instanceof URL ? url.href
+        : url.url,
+    });
+    // Catch a footgun before the client tries to read the body itself and
+    // fails with a confusing low-level stream error.
+    if (response.bodyUsed || response.body?.locked) {
+      throw new AnthropicError(
+        'middleware consumed the response body; use response.clone() to inspect it, ' +
+          'or return new Response(body, response) to consume and replace it',
+      );
+    }
+    return response;
+  };
+}
+
+/**
+ * Creates the {@link MiddlewareContext} shared by every middleware in one chain.
+ */
+function createMiddlewareContext(options: FinalRequestOptions | undefined): MiddlewareContext {
+  // Keyed on the Response so each `next()` call's response (e.g. with custom
+  // retries, or a middleware swapping in a replacement) parses independently,
+  // while several middleware parsing the same response share a single read.
+  const cache = new WeakMap<Response, Promise<unknown>>();
+  return {
+    options,
+    parse<T>(response: Response): Promise<T> {
+      // Streams are single-consumer, so caching one would hand later callers
+      // an already-consumed stream; every call gets a fresh clone-backed one.
+      if (options?.stream && response.ok) {
+        return parseMiddlewareResponse(response, options) as Promise<T>;
+      }
+      let parsed = cache.get(response);
+      if (!parsed) {
+        parsed = parseMiddlewareResponse(response, options);
+        cache.set(response, parsed);
+      }
+      return parsed as Promise<T>;
+    },
+  };
+}
+
+/**
+ * Mirrors the client's own response parsing (`defaultParseResponse` in
+ * `internal/parse.ts`), reading through a clone so the body stays available
+ * to the rest of the chain and the client itself.
+ */
+async function parseMiddlewareResponse(
+  response: Response,
+  options: FinalRequestOptions | undefined,
+): Promise<unknown> {
+  if (response.bodyUsed || response.body?.locked) {
+    throw new AnthropicError(
+      'cannot ctx.parse() a response whose body was already consumed; ' +
+        'call ctx.parse() instead of reading the body, or read via response.clone()',
+    );
+  }
+
+  // Error responses parse as JSON/text below — the SDK only stream-parses
+  // successful responses, and middleware typically wants the error body.
+  if (options?.stream && response.ok) {
+    // A fresh controller rather than the request's own: aborting (or
+    // `break`ing out of) the middleware's stream must not cancel the
+    // in-flight request the client is still reading.
+    const streamClass = options.__streamClass ?? Stream;
+    return streamClass.fromSSEResponse(response.clone(), new AbortController());
+  }
+
+  // fetch refuses to read the body when the status code is 204.
+  if (response.status === 204) {
+    return null;
+  }
+
+  if (options?.__binaryResponse) {
+    return response;
+  }
+
+  const contentType = response.headers.get('content-type');
+  const mediaType = contentType?.split(';')[0]?.trim();
+  const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
+  if (isJSON) {
+    if (response.headers.get('content-length') === '0') {
+      // if there is no content we can't do anything
+      return undefined;
+    }
+    return addRequestID(await response.clone().json(), response);
+  }
+
+  return await response.clone().text();
+}
+
+/**
+ * Composes `middleware` around `fetchFn` and returns the entry point of the chain.
+ */
+export function applyMiddleware(
+  fetchFn: Fetch,
+  middleware: readonly Middleware[],
+  options?: FinalRequestOptions | undefined,
+): MiddlewareNext {
+  // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+  let next: MiddlewareNext = async ({ url, ...init }) => {
+    try {
+      return await fetchFn.call(undefined, url, init);
+    } catch (err) {
+      // Brand the error as fetch-origin, normalizing with `castToError` first since a
+      // WeakSet can't hold primitives and the brand must be on the same object the
+      // client's own `castToError` will later pass through.
+      const error = castToError(err);
+      fetchOriginErrors.add(error);
+      throw error;
+    }
+  };
+
+  const ctx = createMiddlewareContext(options);
+  for (let i = middleware.length - 1; i >= 0; i--) {
+    const mw = middleware[i]!;
+    const nextInner = next;
+    next = async (request) => mw(request, nextInner, ctx);
+  }
+
+  return next;
+}

package/src/index.ts

@@ -4,7 +4,15 @@ export { Anthropic as default } from './client';
 
 export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
-export { BaseAnthropic, Anthropic, type ClientOptions, HUMAN_PROMPT, AI_PROMPT } from './client';
+export { type Middleware, type MiddlewareContext, type MiddlewareNext } from './core/middleware';
+export {
+  BaseAnthropic,
+  Anthropic,
+  type APIRequest,
+  type ClientOptions,
+  HUMAN_PROMPT,
+  AI_PROMPT,
+} from './client';
 export { PagePromise } from './core/pagination';
 export {
   AnthropicError,
@@ -12,6 +20,7 @@ export {
   APIConnectionError,
   APIConnectionTimeoutError,
   APIUserAbortError,
+  RetryableError,
   NotFoundError,
   ConflictError,
   RateLimitError,

package/src/internal/request-options.ts

@@ -4,6 +4,7 @@ import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
 import { Stream } from '../core/streaming';
+import type { Middleware } from '../core/middleware';
 import type { HTTPMethod, MergedRequestInit } from './types';
 import { type HeadersLike } from './headers';
 
@@ -66,6 +67,13 @@ export type RequestOptions = {
    */
   signal?: AbortSignal | undefined | null;
 
+  /**
+   * Additional {@link Middleware} to wrap this request's HTTP attempts.
+   *
+   * These run after any client-level middleware and apply to every attempt of this request, including retries.
+   */
+  middleware?: ReadonlyArray<Middleware> | undefined;
+
   /**
    * A unique key for this request to enable idempotency.
    */

package/src/lib/BetaMessageStream.ts

@@ -578,6 +578,9 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
         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.usage.output_tokens = event.usage.output_tokens;
         snapshot.context_management = event.context_management;
 
@@ -679,6 +682,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
               snapshot.content[event.index] = {
                 ...snapshotContent,
                 content: (snapshotContent.content || '') + event.delta.content,
+                encrypted_content: event.delta.encrypted_content,
               };
             }
             break;

package/src/resources/beta/messages/messages.ts

@@ -60,6 +60,8 @@ const DEPRECATED_MODELS: {
   'claude-2.0': 'July 21st, 2025',
   'claude-3-7-sonnet-latest': 'February 19th, 2026',
   'claude-3-7-sonnet-20250219': 'February 19th, 2026',
+  'claude-opus-4-1': 'August 5th, 2026',
+  'claude-opus-4-1-20250805': 'August 5th, 2026',
 };
 
 const MODELS_TO_WARN_WITH_THINKING_ENABLED: Model[] = ['claude-mythos-preview', 'claude-opus-4-6'];

package/src/resources/messages/messages.ts

@@ -1263,6 +1263,8 @@ const DEPRECATED_MODELS: {
   'claude-opus-4-20250514': 'June 15th, 2026',
   'claude-sonnet-4-0': 'June 15th, 2026',
   'claude-sonnet-4-20250514': 'June 15th, 2026',
+  'claude-opus-4-1': 'August 5th, 2026',
+  'claude-opus-4-1-20250805': 'August 5th, 2026',
 };
 
 const MODELS_TO_WARN_WITH_THINKING_ENABLED: Model[] = ['claude-mythos-preview', 'claude-opus-4-6'];

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.100.0'; // x-release-please-version
+export const VERSION = '0.101.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.100.0";
+export declare const VERSION = "0.101.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.100.0";
+export declare const VERSION = "0.101.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.100.0'; // x-release-please-version
+exports.VERSION = '0.101.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.100.0'; // x-release-please-version
+export const VERSION = '0.101.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map