@code-yeongyu/senpi 2026.8.24 → 2026.8.26

package/node_modules/@anthropic-ai/sdk/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;
@@ -106,8 +136,9 @@ export const formatRequestDetails = (details: {
         ([name, value]) => [
           name,
           (
-            name.toLowerCase() === 'x-api-key' ||
             name.toLowerCase() === 'authorization' ||
+            name.toLowerCase() === 'api-key' ||
+            name.toLowerCase() === 'x-api-key' ||
             name.toLowerCase() === 'cookie' ||
             name.toLowerCase() === 'set-cookie'
           ) ?

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

@@ -0,0 +1,18 @@
+/**
+ * A deferred: a `Promise` together with its `resolve` / `reject` functions.
+ * This is `Promise.withResolvers()`, which is not available in all supported
+ * runtimes.
+ */
+export function promiseWithResolvers<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: unknown) => void;
+} {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}

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

@@ -1,23 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { AnthropicError } from '../../core/error';
+import * as qs from '../qs/stringify';
 
-/**
- * Basic re-implementation of `qs.stringify` for primitive types.
- */
 export function stringifyQuery(query: object | Record<string, unknown>) {
-  return Object.entries(query)
-    .filter(([_, value]) => typeof value !== 'undefined')
-    .map(([key, value]) => {
-      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-      }
-      if (value === null) {
-        return `${encodeURIComponent(key)}=`;
-      }
-      throw new AnthropicError(
-        `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
-      );
-    })
-    .join('&');
+  return qs.stringify(query, { arrayFormat: 'brackets' });
 }

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

@@ -1,3 +1,26 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Resolve after `ms`, or immediately when `signal` aborts.
+ *
+ * When a `signal` is passed the abort listener is always removed so repeated
+ * calls do not accumulate listeners on a long-lived signal. Resolves (rather
+ * than rejects) on abort — callers treat abort as "wake up early," not as a
+ * failure; callers that want to unwind should check the signal themselves.
+ */
+export const sleep = (ms: number, signal?: AbortSignal): Promise<void> =>
+  new Promise<void>((resolve) => {
+    if (signal?.aborted) return resolve();
 
-export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+
+    // `{ once: true }` auto-removes the listener if abort fires first,
+    // so we only need an explicit remove on the timer-wins path above.
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });

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

@@ -0,0 +1,4 @@
+/** Current time as unix epoch seconds. */
+export function nowAsSeconds(): number {
+  return Math.floor(Date.now() / 1000);
+}

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

@@ -1,4 +1,4 @@
-import { partialParse } from '../_vendor/partial-json-parser/parser';
+import { STAINLESS_HELPER_METHOD_HEADER } from '../internal/stainless-helper-header';
 import type { Logger } from '../client';
 import { AnthropicError, APIUserAbortError } from '../error';
 import { isAbortError } from '../internal/errors';
@@ -20,6 +20,7 @@ import {
 } from '../resources/beta/messages/messages';
 import { Stream } from '../streaming';
 import { maybeParseBetaMessage, type ParsedBetaMessage } from './beta-parser';
+import { JSON_BUF_PROPERTY, withLazyInput } from '../internal/message-stream-utils';
 
 export interface MessageStreamEvents {
   connect: () => void;
@@ -43,8 +44,6 @@ type MessageStreamEventListeners<Event extends keyof MessageStreamEvents> = {
   once?: boolean;
 }[];
 
-const JSON_BUF_PROPERTY = '__json_buf';
-
 export type TracksToolInput = BetaToolUseBlock | BetaServerToolUseBlock | BetaMCPToolUseBlock;
 
 function tracksToolInput(content: BetaContentBlock): content is TracksToolInput {
@@ -75,6 +74,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
   #catchingPromiseCreated = false;
   #response: Response | null | undefined;
   #request_id: string | null | undefined;
+  #workspace_id: string | null | undefined;
   #logger: Logger;
 
   constructor(params: MessageCreateParamsBase | null, opts?: { logger?: Logger | undefined }) {
@@ -107,6 +107,10 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     return this.#request_id;
   }
 
+  get workspace_id(): string | null | undefined {
+    return this.#workspace_id;
+  }
+
   /**
    * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request,
    * returned vie the `request-id` header which is useful for debugging requests and resporting
@@ -121,6 +125,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     data: BetaMessageStream<ParsedT>;
     response: Response;
     request_id: string | null | undefined;
+    workspace_id: string | null | undefined;
   }> {
     this.#catchingPromiseCreated = true;
 
@@ -133,6 +138,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
       data: this,
       response,
       request_id: response.headers.get('request-id'),
+      workspace_id: response.headers.get('anthropic-workspace-id'),
     };
   }
 
@@ -164,7 +170,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
       runner._createMessage(
         messages,
         { ...params, stream: true },
-        { ...options, headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' } },
+        { ...options, headers: { ...options?.headers, [STAINLESS_HELPER_METHOD_HEADER]: 'stream' } },
       ),
     );
     return runner;
@@ -224,6 +230,7 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
     if (this.ended) return;
     this.#response = response;
     this.#request_id = response?.headers.get('request-id');
+    this.#workspace_id = response?.headers.get('anthropic-workspace-id');
     this.#resolveConnectedPromise(response);
     this._emit('connect');
   }
@@ -462,8 +469,15 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
             break;
           }
           case 'input_json_delta': {
-            if (tracksToolInput(content) && content.input) {
-              this._emit('inputJson', event.delta.partial_json, content.input);
+            if (tracksToolInput(content) && this.#listeners.inputJson?.length) {
+              let jsonSnapshot: unknown;
+              try {
+                jsonSnapshot = content.input;
+              } catch (err) {
+                this.#handleError(this.#toolInputParseError(content, err));
+                break;
+              }
+              this._emit('inputJson', event.delta.partial_json, jsonSnapshot);
             }
             break;
           }
@@ -575,12 +589,21 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
       case 'message_stop':
         return snapshot;
       case 'message_delta':
-        snapshot.container = event.delta.container;
         snapshot.stop_reason = event.delta.stop_reason;
         snapshot.stop_sequence = event.delta.stop_sequence;
+        snapshot.stop_details = event.delta.stop_details;
         snapshot.usage.output_tokens = event.usage.output_tokens;
-        snapshot.context_management = event.context_management;
 
+        if (event.delta.container != null) {
+          snapshot.container = event.delta.container;
+        }
+
+        if (event.context_management != null) {
+          snapshot.context_management = event.context_management;
+        }
+
+        // The remaining usage counters are cumulative whole-message totals that are
+        // omitted when they don't apply, so overwrite when present and never add.
         if (event.usage.input_tokens != null) {
           snapshot.usage.input_tokens = event.usage.input_tokens;
         }
@@ -601,9 +624,22 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
           snapshot.usage.iterations = event.usage.iterations;
         }
 
+        if (event.usage.fallback_credit != null) {
+          snapshot.usage.fallback_credit = event.usage.fallback_credit;
+        }
+
+        if (event.usage.output_tokens_details != null) {
+          snapshot.usage.output_tokens_details = event.usage.output_tokens_details;
+        }
+
         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);
@@ -629,30 +665,8 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
           }
           case 'input_json_delta': {
             if (snapshotContent && tracksToolInput(snapshotContent)) {
-              // we need to keep track of the raw JSON string as well so that we can
-              // re-parse it for each delta, for now we just store it as an untyped
-              // non-enumerable property on the snapshot
-              let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || '';
-              jsonBuf += event.delta.partial_json;
-
-              const newContent = { ...snapshotContent };
-              Object.defineProperty(newContent, JSON_BUF_PROPERTY, {
-                value: jsonBuf,
-                enumerable: false,
-                writable: true,
-              });
-
-              if (jsonBuf) {
-                try {
-                  newContent.input = partialParse(jsonBuf);
-                } catch (err) {
-                  const error = new AnthropicError(
-                    `Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err}. JSON: ${jsonBuf}`,
-                  );
-                  this.#handleError(error);
-                }
-              }
-              snapshot.content[event.index] = newContent;
+              const jsonBuf = ((snapshotContent as any)[JSON_BUF_PROPERTY] || '') + event.delta.partial_json;
+              snapshot.content[event.index] = withLazyInput(snapshotContent, jsonBuf);
             }
             break;
           }
@@ -679,6 +693,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;
@@ -688,11 +703,35 @@ export class BetaMessageStream<ParsedT = null> implements AsyncIterable<BetaMess
         }
         return snapshot;
       }
-      case 'content_block_stop':
+      case 'content_block_stop': {
+        const snapshotContent = snapshot.content.at(event.index);
+        if (snapshotContent && tracksToolInput(snapshotContent) && JSON_BUF_PROPERTY in snapshotContent) {
+          let input: unknown;
+          try {
+            input = snapshotContent.input;
+          } catch (err) {
+            input = {};
+            this.#handleError(this.#toolInputParseError(snapshotContent, err));
+          }
+          Object.defineProperty(snapshotContent, 'input', {
+            value: input,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+          });
+        }
         return snapshot;
+      }
     }
   }
 
+  #toolInputParseError(block: TracksToolInput, err: unknown): AnthropicError {
+    const jsonBuf = (block as any)[JSON_BUF_PROPERTY];
+    return new AnthropicError(
+      `Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err}. JSON: ${jsonBuf}`,
+    );
+  }
+
   [Symbol.asyncIterator](): AsyncIterator<BetaMessageStreamEvent> {
     const pushQueue: BetaMessageStreamEvent[] = [];
     const readQueue: {

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

@@ -1,3 +1,4 @@
+import { STAINLESS_HELPER_METHOD_HEADER } from '../internal/stainless-helper-header';
 import { isAbortError } from '../internal/errors';
 import { AnthropicError, APIUserAbortError } from '../error';
 import {
@@ -14,10 +15,10 @@ import {
   type ServerToolUseBlock,
 } from '../resources/messages';
 import { Stream } from '../streaming';
-import { partialParse } from '../_vendor/partial-json-parser/parser';
 import { RequestOptions } from '../internal/request-options';
 import type { Logger } from '../client';
 import { maybeParseMessage, type ParsedMessage } from './parser';
+import { JSON_BUF_PROPERTY, withLazyInput } from '../internal/message-stream-utils';
 
 export interface MessageStreamEvents<ParsedT = null> {
   connect: () => void;
@@ -40,8 +41,6 @@ type MessageStreamEventListeners<ParsedT, Event extends keyof MessageStreamEvent
   once?: boolean;
 }[];
 
-const JSON_BUF_PROPERTY = '__json_buf';
-
 export type TracksToolInput = ToolUseBlock | ServerToolUseBlock;
 
 function tracksToolInput(content: ContentBlock): content is TracksToolInput {
@@ -74,6 +73,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
   #catchingPromiseCreated = false;
   #response: Response | null | undefined;
   #request_id: string | null | undefined;
+  #workspace_id: string | null | undefined;
   #logger: Logger;
 
   constructor(params: MessageCreateParamsBase | null, opts?: { logger?: Logger | undefined }) {
@@ -106,6 +106,10 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     return this.#request_id;
   }
 
+  get workspace_id(): string | null | undefined {
+    return this.#workspace_id;
+  }
+
   /**
    * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request,
    * returned vie the `request-id` header which is useful for debugging requests and resporting
@@ -120,6 +124,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     data: MessageStream<ParsedT>;
     response: Response;
     request_id: string | null | undefined;
+    workspace_id: string | null | undefined;
   }> {
     this.#catchingPromiseCreated = true;
 
@@ -132,6 +137,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
       data: this,
       response,
       request_id: response.headers.get('request-id'),
+      workspace_id: response.headers.get('anthropic-workspace-id'),
     };
   }
 
@@ -163,7 +169,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
       runner._createMessage(
         messages,
         { ...params, stream: true },
-        { ...options, headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' } },
+        { ...options, headers: { ...options?.headers, [STAINLESS_HELPER_METHOD_HEADER]: 'stream' } },
       ),
     );
     return runner;
@@ -223,6 +229,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
     if (this.ended) return;
     this.#response = response;
     this.#request_id = response?.headers.get('request-id');
+    this.#workspace_id = response?.headers.get('anthropic-workspace-id');
     this.#resolveConnectedPromise(response);
     this._emit('connect');
   }
@@ -470,7 +477,7 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
             break;
           }
           case 'input_json_delta': {
-            if (tracksToolInput(content) && content.input) {
+            if (tracksToolInput(content) && this.#listeners.inputJson?.length) {
               this._emit('inputJson', event.delta.partial_json, content.input);
             }
             break;
@@ -576,9 +583,15 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
       case 'message_delta':
         snapshot.stop_reason = event.delta.stop_reason;
         snapshot.stop_sequence = event.delta.stop_sequence;
+        snapshot.stop_details = event.delta.stop_details;
         snapshot.usage.output_tokens = event.usage.output_tokens;
 
-        // Update other usage fields if they exist in the event
+        if (event.delta.container != null) {
+          snapshot.container = event.delta.container;
+        }
+
+        // The remaining usage counters are cumulative whole-message totals that are
+        // omitted when they don't apply, so overwrite when present and never add.
         if (event.usage.input_tokens != null) {
           snapshot.usage.input_tokens = event.usage.input_tokens;
         }
@@ -595,6 +608,10 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
           snapshot.usage.server_tool_use = event.usage.server_tool_use;
         }
 
+        if (event.usage.output_tokens_details != null) {
+          snapshot.usage.output_tokens_details = event.usage.output_tokens_details;
+        }
+
         return snapshot;
       case 'content_block_start':
         snapshot.content.push({ ...event.content_block });
@@ -623,23 +640,8 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
           }
           case 'input_json_delta': {
             if (snapshotContent && tracksToolInput(snapshotContent)) {
-              // we need to keep track of the raw JSON string as well so that we can
-              // re-parse it for each delta, for now we just store it as an untyped
-              // non-enumerable property on the snapshot
-              let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || '';
-              jsonBuf += event.delta.partial_json;
-
-              const newContent = { ...snapshotContent };
-              Object.defineProperty(newContent, JSON_BUF_PROPERTY, {
-                value: jsonBuf,
-                enumerable: false,
-                writable: true,
-              });
-
-              if (jsonBuf) {
-                newContent.input = partialParse(jsonBuf);
-              }
-              snapshot.content[event.index] = newContent;
+              const jsonBuf = ((snapshotContent as any)[JSON_BUF_PROPERTY] || '') + event.delta.partial_json;
+              snapshot.content[event.index] = withLazyInput(snapshotContent, jsonBuf);
             }
             break;
           }
@@ -667,8 +669,18 @@ export class MessageStream<ParsedT = null> implements AsyncIterable<MessageStrea
 
         return snapshot;
       }
-      case 'content_block_stop':
+      case 'content_block_stop': {
+        const snapshotContent = snapshot.content.at(event.index);
+        if (snapshotContent && tracksToolInput(snapshotContent) && JSON_BUF_PROPERTY in snapshotContent) {
+          Object.defineProperty(snapshotContent, 'input', {
+            value: snapshotContent.input,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+          });
+        }
         return snapshot;
+      }
     }
   }