@code-yeongyu/senpi 2026.8.25 → 2026.8.26

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

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

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

@@ -4,12 +4,48 @@ 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';
 
 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').
    */
@@ -66,6 +102,23 @@ export type RequestOptions = {
    */
   signal?: AbortSignal | undefined | null;
 
+  /**
+   * Additional {@link Middleware} to wrap this request's HTTP attempts.
+   *
+   * 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.
    */
@@ -78,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/node_modules/@anthropic-ai/sdk/src/internal/request-signal.ts

@@ -0,0 +1,68 @@
+/**
+ * Tracks the removal of the per-request abort listener that
+ * `fetchWithTimeout` attaches to a caller-provided signal, so the listener's
+ * lifetime matches the request instead of the signal.
+ *
+ * Without removal, a long-lived signal (e.g. one AbortController reused for
+ * a whole session) accumulates one `{ once: true }` listener plus its bound
+ * AbortController per HTTP attempt until the signal fires or is collected,
+ * and Node warns at the 11th listener. The listener must survive until the
+ * response body is settled - removing it when fetch resolves (headers) would
+ * break aborting an in-flight body read - so the code that finishes the body
+ * (response parsing, stream teardown, retry/error handling) calls
+ * `releaseRequestSignal` with the request's controller.
+ */
+const cleanups = new WeakMap<AbortController, () => void>();
+
+// Backstop for requests that never reach an explicit release point: a caller
+// that partially iterates a stream (or receives a raw binary Response) and
+// drops the reference never completes, errors, or cancels it, so the only
+// remaining lifecycle event is the response being collected. Finalization
+// timing is GC-driven and not guaranteed, so this only bounds abandonment -
+// the explicit release calls stay the primary cleanup. The held value must
+// not reference the response, or it could never be collected. Typed
+// structurally because the compiler lib is es2020.
+type AbandonmentRegistry = {
+  register(target: object, heldValue: AbortController, token: object): void;
+  unregister(token: object): void;
+};
+
+const registry: AbandonmentRegistry | null =
+  typeof (globalThis as any).FinalizationRegistry === 'function' ?
+    new (globalThis as any).FinalizationRegistry((controller: AbortController) =>
+      releaseRequestSignal(controller),
+    )
+  : null;
+
+// Module-scope factory so the cleanup closure captures exactly the signal and
+// the listener - built at the `fetchWithTimeout` call site it would share that
+// scope's context and retain the request body for as long as the cleanup is
+// held (same reason `_makeAbort` exists in client.ts).
+function makeCleanup(signal: AbortSignal, listener: () => void): () => void {
+  return () => signal.removeEventListener('abort', listener);
+}
+
+export function registerRequestSignalCleanup(
+  controller: AbortController,
+  signal: AbortSignal,
+  listener: () => void,
+): void {
+  cleanups.set(controller, makeCleanup(signal, listener));
+}
+
+// The registered target is the response BODY, not the Response: a caller can
+// keep a reader on the body and drop the Response wrapper (`.asResponse()`),
+// and the listener must survive for as long as anything can still read - the
+// body is what a live read keeps alive.
+export function armAbandonmentBackstop(body: object, controller: AbortController): void {
+  if (cleanups.has(controller)) registry?.register(body, controller, controller);
+}
+
+export function releaseRequestSignal(controller: AbortController): void {
+  const cleanup = cleanups.get(controller);
+  if (cleanup) {
+    cleanups.delete(controller);
+    registry?.unregister(controller);
+    cleanup();
+  }
+}

package/node_modules/@anthropic-ai/sdk/src/internal/stainless-helper-header.ts

@@ -0,0 +1,122 @@
+/**
+ * Single source of truth for the `x-stainless-helper` telemetry header — the
+ * key, the closed value vocabulary, and per-object helper tagging. The
+ * append-don't-clobber merge for the header itself lives in
+ * {@link import('../internal/headers').buildHeaders} via `APPEND_HEADERS`.
+ */
+
+/**
+ * Telemetry header naming the SDK helper(s) a request came from. Always this
+ * lowercase form; `buildHeaders` matches it case-insensitively for its append
+ * semantics, but a single canonical casing keeps every call site greppable.
+ */
+export const STAINLESS_HELPER_HEADER = 'x-stainless-helper';
+
+/** Telemetry header naming the SDK method (e.g. `stream`) in use. */
+export const STAINLESS_HELPER_METHOD_HEADER = 'x-stainless-helper-method';
+
+/**
+ * The closed set of helper telemetry tags, shared verbatim across SDKs. A
+ * typo at any call site is a type error rather than silently mistagged
+ * telemetry. Existing values keep their original spellings — telemetry
+ * consumers match on them, so renames lose history. New tags are hyphenated
+ * lowercase.
+ */
+export type StainlessHelperHeaderValue =
+  | 'BetaToolRunner'
+  | 'betaZodTool'
+  | 'compaction'
+  | 'environments-work-poller'
+  | 'environments-worker'
+  | 'fallback-refusal-middleware'
+  | 'mcpContent'
+  | 'mcpMessage'
+  | 'mcpResourceToContent'
+  | 'mcpResourceToFile'
+  | 'mcpTool'
+  | 'session-tool-runner';
+
+/**
+ * The `{ 'x-stainless-helper': value }` header dict, for passing into
+ * `buildHeaders` (which comma-appends `x-stainless-helper` across sources)
+ * or as `defaultHeaders`/per-request `headers`.
+ */
+export function helperHeader(value: StainlessHelperHeaderValue): { [STAINLESS_HELPER_HEADER]: string } {
+  return { [STAINLESS_HELPER_HEADER]: value };
+}
+
+/**
+ * Symbol used to mark objects created by SDK helpers for tracking.
+ * The value is the helper name (e.g., 'mcpTool', 'betaZodTool').
+ */
+export const SDK_HELPER_SYMBOL = Symbol('anthropic.sdk.stainlessHelper');
+
+type StainlessHelperObject = { [SDK_HELPER_SYMBOL]: string };
+
+export function wasCreatedByStainlessHelper(value: unknown): value is StainlessHelperObject {
+  return typeof value === 'object' && value !== null && SDK_HELPER_SYMBOL in value;
+}
+
+/**
+ * Collects helper names from tools and messages arrays.
+ * Returns a deduplicated array of helper names found.
+ */
+export function collectStainlessHelpers(
+  tools: readonly unknown[] | undefined,
+  messages: readonly unknown[] | undefined,
+): string[] {
+  const helpers = new Set<string>();
+
+  // Collect from tools
+  if (tools) {
+    for (const tool of tools) {
+      if (wasCreatedByStainlessHelper(tool)) {
+        helpers.add(tool[SDK_HELPER_SYMBOL]);
+      }
+    }
+  }
+
+  // Collect from messages and their content blocks
+  if (messages) {
+    for (const message of messages) {
+      if (wasCreatedByStainlessHelper(message)) {
+        helpers.add(message[SDK_HELPER_SYMBOL]);
+      }
+
+      const content = (message as { content?: unknown }).content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (wasCreatedByStainlessHelper(block)) {
+            helpers.add(block[SDK_HELPER_SYMBOL]);
+          }
+        }
+      }
+    }
+  }
+
+  return Array.from(helpers);
+}
+
+/**
+ * Builds x-stainless-helper header value from tools and messages.
+ * Returns an empty object if no helpers are found.
+ */
+export function stainlessHelperHeader(
+  tools: readonly unknown[] | undefined,
+  messages: readonly unknown[] | undefined,
+): { 'x-stainless-helper'?: string } {
+  const helpers = collectStainlessHelpers(tools, messages);
+  if (helpers.length === 0) return {};
+  return { [STAINLESS_HELPER_HEADER]: helpers.join(', ') };
+}
+
+/**
+ * Builds x-stainless-helper header value from a file object.
+ * Returns an empty object if the file is not marked with a helper.
+ */
+export function stainlessHelperHeaderFromFile(file: unknown): { 'x-stainless-helper'?: string } {
+  if (wasCreatedByStainlessHelper(file)) {
+    return { [STAINLESS_HELPER_HEADER]: file[SDK_HELPER_SYMBOL] };
+  }
+  return {};
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Chain an external {@link AbortSignal} into a local {@link AbortController}:
+ * the controller aborts whenever `external` aborts (synchronously if it is
+ * already aborted).
+ *
+ * Returns a cleanup function that detaches the listener. Callers MUST invoke it
+ * on their normal teardown path — `{ once: true }` only removes the listener if
+ * abort actually fires, so a long-lived `external` signal (e.g. a daemon-wide
+ * signal reused across many short-lived controllers) would otherwise leak one
+ * listener per controller.
+ */
+export function linkAbort(external: AbortSignal | null | undefined, controller: AbortController): () => void {
+  if (!external) return () => {};
+  if (external.aborted) {
+    controller.abort();
+    return () => {};
+  }
+  const onAbort = () => controller.abort();
+  external.addEventListener('abort', onAbort);
+  return () => external.removeEventListener('abort', onAbort);
+}

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

@@ -0,0 +1,66 @@
+export type AsyncQueueResult<T> = { done: false; value: T } | { done: true; value: undefined };
+
+/**
+ * Single-consumer async queue that bridges background producers to an
+ * `AsyncIterator`-style reader. Producers `push()` items; the consumer awaits
+ * `next()`. `close()` is idempotent and wakes any pending `next()` with
+ * `done: true`. `tryShift()` synchronously drains remaining items after
+ * iteration has been signalled to stop.
+ */
+export class AsyncQueue<T> {
+  #items: T[] = [];
+  #waiters: Array<(r: AsyncQueueResult<T>) => void> = [];
+  #closed = false;
+
+  /** Enqueue an item, or hand it directly to a waiting reader. Returns `false` once closed. */
+  push(item: T): boolean {
+    if (this.#closed) return false;
+    const w = this.#waiters.shift();
+    if (w) w({ done: false, value: item });
+    else this.#items.push(item);
+    return true;
+  }
+
+  /** Mark the queue done. Idempotent; wakes every pending reader with `done: true`. */
+  close(): void {
+    if (this.#closed) return;
+    this.#closed = true;
+    while (this.#waiters.length > 0) {
+      const w = this.#waiters.shift()!;
+      w({ done: true, value: undefined });
+    }
+  }
+
+  /**
+   * Resolve with the next item, or `done: true` once the queue is closed and
+   * drained. When `signal` is supplied, aborting it resolves a pending read
+   * with `done: true` (cancellation is pushed down here rather than handled by
+   * an outer `Promise.race`).
+   */
+  next(signal?: AbortSignal): Promise<AsyncQueueResult<T>> {
+    if (this.#items.length > 0) {
+      return Promise.resolve({ done: false, value: this.#items.shift()! });
+    }
+    if (this.#closed || signal?.aborted) {
+      return Promise.resolve({ done: true, value: undefined });
+    }
+    return new Promise<AsyncQueueResult<T>>((resolve) => {
+      const waiter = (r: AsyncQueueResult<T>) => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve(r);
+      };
+      const onAbort = () => {
+        const idx = this.#waiters.indexOf(waiter);
+        if (idx >= 0) this.#waiters.splice(idx, 1);
+        resolve({ done: true, value: undefined });
+      };
+      this.#waiters.push(waiter);
+      signal?.addEventListener('abort', onAbort, { once: true });
+    });
+  }
+
+  /** Synchronously remove and return the next buffered item, or `undefined` if empty. */
+  tryShift(): T | undefined {
+    return this.#items.shift();
+  }
+}

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

@@ -0,0 +1,41 @@
+import { APIError } from '../../core/error';
+
+/** True when `e` is an {@link APIError} whose HTTP status equals `code`. */
+export function isStatus(e: unknown, code: number): boolean {
+  return e instanceof APIError && e.status === code;
+}
+
+/** True when `e` is an {@link APIError} with a 4xx status. */
+export function is4xx(e: unknown): boolean {
+  return e instanceof APIError && typeof e.status === 'number' && e.status >= 400 && e.status < 500;
+}
+
+/**
+ * True for a 4xx that the core client's retry policy would *not* retry, i.e. a
+ * permanent client error. 408 (request timeout), 409 (lock timeout) and 429
+ * (rate limit) are retryable for the base client (`Anthropic.shouldRetry`), so
+ * they are not treated as fatal here — keeping helper retry behaviour aligned
+ * with the rest of the SDK.
+ */
+export function isFatal4xx(e: unknown): boolean {
+  return is4xx(e) && !isStatus(e, 408) && !isStatus(e, 409) && !isStatus(e, 429);
+}
+
+/** Exponential backoff: `baseMs * 2 ** attempt`, clamped to `capMs`. */
+export function backoff(attempt: number, baseMs: number, capMs: number): number {
+  return Math.min(baseMs * 2 ** attempt, capMs);
+}
+
+/** Uniform random delay in the half-open interval `[lowMs, highMs)`. */
+export function jitter(lowMs: number, highMs: number): number {
+  return lowMs + Math.random() * (highMs - lowMs);
+}
+
+/**
+ * Trim up to 25% off `ms` at random so a fleet of clients backing off after a
+ * shared outage does not retry in lockstep — mirrors the jitter the core client
+ * applies to its own retry timeout.
+ */
+export function applyJitter(ms: number): number {
+  return ms * (1 - Math.random() * 0.25);
+}