@anthropic-ai/sdk 0.102.0 → 0.103.0

package/src/internal/request-options.ts

@@ -10,7 +10,42 @@ import { type HeadersLike } from './headers';
 
 export type FinalRequestOptions = RequestOptions & { method: HTTPMethod; path: string };
 
-export type RequestOptions = {
+/**
+ * Tracks which fallback a sequence of requests is pinned to.
+ *
+ * Create one (`new BetaFallbackState()`) and pass it via the `fallbackState`
+ * request option on every request that should share the pin — the turns of one
+ * conversation, or any wider scope the stickiness should apply to;
+ * `betaRefusalFallbackMiddleware` mutates it in place when a model refuses.
+ */
+export class BetaFallbackState {
+  /**
+   * Index into the fallback chain the requests are pinned to.
+   *
+   * `undefined` (or -1) targets the original request params; the middleware
+   * sets it to the index of the fallback that accepted the request.
+   */
+  index?: number;
+}
+
+/**
+ * Options for an individual API request.
+ *
+ * Declared as an interface so it can be extended via declaration merging, e.g.
+ * to thread custom per-request context through to {@link Middleware}:
+ *
+ * ```ts
+ * declare module '@anthropic-ai/sdk/internal/request-options' {
+ *   interface RequestOptions {
+ *     myContext?: string;
+ *   }
+ * }
+ * ```
+ *
+ * The SDK ignores properties it doesn't know about; they are visible to
+ * middleware on `ctx.options`.
+ */
+export interface RequestOptions {
   /**
    * The HTTP method for the request (e.g., 'get', 'post', 'put', 'delete').
    */
@@ -70,10 +105,20 @@ export type RequestOptions = {
   /**
    * 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.
+   * These run after any client-level middleware (but still outside any backend
+   * adaptation) and apply to every attempt of this request, including retries.
    */
   middleware?: ReadonlyArray<Middleware> | undefined;
 
+  /**
+   * Sticky state for `betaRefusalFallbackMiddleware`.
+   *
+   * The middleware records which fallback it settled on, so requests sharing
+   * the state skip models that already refused. Pass the same object across
+   * whatever scope the pin should apply to — typically a conversation.
+   */
+  fallbackState?: BetaFallbackState;
+
   /**
    * A unique key for this request to enable idempotency.
    */
@@ -86,7 +131,7 @@ export type RequestOptions = {
 
   __binaryResponse?: boolean | undefined;
   __streamClass?: typeof Stream;
-};
+}
 
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };
 export type RequestEncoder = (request: { headers: NullableHeaders; body: unknown }) => EncodedContent;

package/src/internal/utils/log.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { hasOwn } from './values';
+import { readEnv } from './env';
 import { type BaseAnthropic } from '../../client';
 import { RequestOptions } from '../request-options';
 
@@ -13,6 +14,8 @@ export type Logger = {
 };
 export type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
 
+export const defaultLogLevel: LogLevel = 'warn';
+
 const levelNumbers = {
   off: 0,
   error: 200,
@@ -24,7 +27,7 @@ const levelNumbers = {
 export const parseLogLevel = (
   maybeLevel: string | undefined,
   sourceName: string,
-  client: BaseAnthropic,
+  logger: Logger,
 ): LogLevel | undefined => {
   if (!maybeLevel) {
     return undefined;
@@ -32,7 +35,7 @@ export const parseLogLevel = (
   if (hasOwn(levelNumbers, maybeLevel)) {
     return maybeLevel;
   }
-  loggerFor(client).warn(
+  logger.warn(
     `${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(
       Object.keys(levelNumbers),
     )}`,
@@ -60,13 +63,7 @@ const noopLogger = {
 
 let cachedLoggers = /* @__PURE__ */ new WeakMap<Logger, [LogLevel, Logger]>();
 
-export function loggerFor(client: BaseAnthropic): Logger {
-  const logger = client.logger;
-  const logLevel = client.logLevel ?? 'off';
-  if (!logger) {
-    return noopLogger;
-  }
-
+function filterLogger(logger: Logger, logLevel: LogLevel): Logger {
   const cachedLogger = cachedLoggers.get(logger);
   if (cachedLogger && cachedLogger[0] === logLevel) {
     return cachedLogger[1];
@@ -84,6 +81,39 @@ export function loggerFor(client: BaseAnthropic): Logger {
   return levelLogger;
 }
 
+export function loggerFor(client: BaseAnthropic): Logger {
+  const logger = client.logger;
+  const logLevel = client.logLevel ?? 'off';
+  if (!logger) {
+    return noopLogger;
+  }
+  return filterLogger(logger, logLevel);
+}
+
+let lastEnvLevel: string | undefined;
+let cachedDefaultLogger: Logger | undefined;
+
+/**
+ * A logger matching the client defaults — `console`, filtered to
+ * `ANTHROPIC_LOG` or {@link defaultLogLevel} — for contexts with no client to
+ * read the configured `logger`/`logLevel` from.
+ *
+ * Cached per `ANTHROPIC_LOG` value so an invalid value warns once, like a
+ * client construction does, rather than on every request.
+ */
+export function defaultLogger(): Logger {
+  const envLevel = readEnv('ANTHROPIC_LOG');
+  if (!cachedDefaultLogger || envLevel !== lastEnvLevel) {
+    lastEnvLevel = envLevel;
+    cachedDefaultLogger = filterLogger(
+      console,
+      parseLogLevel(envLevel, "process.env['ANTHROPIC_LOG']", filterLogger(console, defaultLogLevel)) ??
+        defaultLogLevel,
+    );
+  }
+  return cachedDefaultLogger;
+}
+
 export const formatRequestDetails = (details: {
   options?: RequestOptions | undefined;
   headers?: Headers | Record<string, string> | undefined;

package/src/lib/BetaMessageStream.ts

@@ -607,6 +607,11 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
         return snapshot;
       case 'content_block_start':
         snapshot.content.push(event.content_block);
+        if (event.content_block.type === 'fallback') {
+          // the final hop's fallback block names the model that served the response —
+          // keeps the snapshot consistent with the relabeled non-streaming message
+          snapshot.model = event.content_block.to.model;
+        }
         return snapshot;
       case 'content_block_delta': {
         const snapshotContent = snapshot.content.at(event.index);