@code-yeongyu/senpi 2026.8.25 → 2026.8.26

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

@@ -1,80 +0,0 @@
-/**
- * Shared utilities for tracking SDK helper usage.
- */
-
-import type { BetaMessageParam, BetaToolUnion } from '../resources/beta';
-
-/**
- * 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: BetaToolUnion[] | undefined,
-  messages: BetaMessageParam[] | 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]);
-      }
-
-      if (Array.isArray(message.content)) {
-        for (const block of message.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: BetaToolUnion[] | undefined,
-  messages: BetaMessageParam[] | undefined,
-): { 'x-stainless-helper'?: string } {
-  const helpers = collectStainlessHelpers(tools, messages);
-  if (helpers.length === 0) return {};
-  return { 'x-stainless-helper': 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 { 'x-stainless-helper': file[SDK_HELPER_SYMBOL] };
-  }
-  return {};
-}

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

@@ -1,381 +0,0 @@
-import { BetaRunnableTool } from './BetaRunnableTool';
-import { ToolError } from './ToolError';
-import { Anthropic } from '../..';
-import { AnthropicError } from '../../core/error';
-import { BetaMessage, BetaMessageParam, BetaToolUnion, MessageCreateParams } from '../../resources/beta';
-import { BetaMessageStream } from '../BetaMessageStream';
-
-/**
- * Just Promise.withResolvers(), which is not available in all environments.
- */
-function promiseWithResolvers<T>(): {
-  promise: Promise<T>;
-  resolve: (value: T) => void;
-  reject: (reason?: any) => void;
-} {
-  let resolve: (value: T) => void;
-  let reject: (reason?: any) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve: resolve!, reject: reject! };
-}
-
-/**
- * A ToolRunner handles the automatic conversation loop between the assistant and tools.
- *
- * A ToolRunner is an async iterable that yields either BetaMessage or BetaMessageStream objects
- * depending on the streaming configuration.
- */
-export class BetaToolRunner<Stream extends boolean> {
-  /** Whether the async iterator has been consumed */
-  #consumed = false;
-  /** Whether parameters have been mutated since the last API call */
-  #mutated = false;
-  /** Current state containing the request parameters */
-  #state: { params: BetaToolRunnerParams };
-  /** Promise for the last message received from the assistant */
-  #message?: Promise<BetaMessage> | undefined;
-  /** Cached tool response to avoid redundant executions */
-  #toolResponse?: Promise<BetaMessageParam | null> | undefined;
-  /** Promise resolvers for waiting on completion */
-  #completion: {
-    promise: Promise<BetaMessage>;
-    resolve: (value: BetaMessage) => void;
-    reject: (reason?: any) => void;
-  };
-  /** Number of iterations (API requests) made so far */
-  #iterationCount = 0;
-
-  constructor(
-    private client: Anthropic,
-    params: BetaToolRunnerParams,
-  ) {
-    this.#state = {
-      params: {
-        // You can't clone the entire params since there are functions as handlers.
-        // You also don't really need to clone params.messages, but it probably will prevent a foot gun
-        // somewhere.
-        ...params,
-        messages: structuredClone(params.messages),
-      },
-    };
-
-    this.#completion = promiseWithResolvers();
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<
-    Stream extends true ? BetaMessageStream
-    : Stream extends false ? BetaMessage
-    : BetaMessage | BetaMessageStream
-  > {
-    if (this.#consumed) {
-      throw new AnthropicError('Cannot iterate over a consumed stream');
-    }
-
-    this.#consumed = true;
-    this.#mutated = true;
-    this.#toolResponse = undefined;
-
-    try {
-      while (true) {
-        let stream;
-        try {
-          if (
-            this.#state.params.max_iterations &&
-            this.#iterationCount >= this.#state.params.max_iterations
-          ) {
-            break;
-          }
-
-          this.#mutated = false;
-          this.#message = undefined;
-          this.#toolResponse = undefined;
-          this.#iterationCount++;
-
-          const { max_iterations, ...params } = this.#state.params;
-          if (params.stream) {
-            stream = this.client.beta.messages.stream({ ...params });
-            this.#message = stream.finalMessage();
-            // Make sure that this promise doesn't throw before we get the option to do something about it.
-            // Error will be caught when we call await this.#message ultimately
-            this.#message.catch(() => {});
-            yield stream as any;
-          } else {
-            this.#message = this.client.beta.messages.create({ ...params, stream: false });
-            yield this.#message as any;
-          }
-
-          if (!this.#mutated) {
-            const { role, content } = await this.#message;
-            this.#state.params.messages.push({ role, content });
-          }
-
-          const toolMessage = await this.#generateToolResponse(this.#state.params.messages.at(-1)!);
-          if (toolMessage) {
-            this.#state.params.messages.push(toolMessage);
-          }
-
-          if (!toolMessage && !this.#mutated) {
-            break;
-          }
-        } finally {
-          if (stream) {
-            stream.abort();
-          }
-        }
-      }
-
-      if (!this.#message) {
-        throw new AnthropicError('ToolRunner concluded without a message from the server');
-      }
-
-      this.#completion.resolve(await this.#message);
-    } catch (error) {
-      this.#consumed = false;
-      // Silence unhandled promise errors
-      this.#completion.promise.catch(() => {});
-      this.#completion.reject(error);
-      this.#completion = promiseWithResolvers();
-      throw error;
-    }
-  }
-
-  /**
-   * Update the parameters for the next API call. This invalidates any cached tool responses.
-   *
-   * @param paramsOrMutator - Either new parameters or a function to mutate existing parameters
-   *
-   * @example
-   * // Direct parameter update
-   * runner.setMessagesParams({
-   *   model: 'claude-haiku-4-5',
-   *   max_tokens: 500,
-   * });
-   *
-   * @example
-   * // Using a mutator function
-   * runner.setMessagesParams((params) => ({
-   *   ...params,
-   *   max_tokens: 100,
-   * }));
-   */
-  setMessagesParams(params: BetaToolRunnerParams): void;
-  setMessagesParams(mutator: (prevParams: BetaToolRunnerParams) => BetaToolRunnerParams): void;
-  setMessagesParams(
-    paramsOrMutator: BetaToolRunnerParams | ((prevParams: BetaToolRunnerParams) => BetaToolRunnerParams),
-  ) {
-    if (typeof paramsOrMutator === 'function') {
-      this.#state.params = paramsOrMutator(this.#state.params);
-    } else {
-      this.#state.params = paramsOrMutator;
-    }
-    this.#mutated = true;
-    // Invalidate cached tool response since parameters changed
-    this.#toolResponse = undefined;
-  }
-
-  /**
-   * Get the tool response for the last message from the assistant.
-   * Avoids redundant tool executions by caching results.
-   *
-   * @returns A promise that resolves to a BetaMessageParam containing tool results, or null if no tools need to be executed
-   *
-   * @example
-   * const toolResponse = await runner.generateToolResponse();
-   * if (toolResponse) {
-   *   console.log('Tool results:', toolResponse.content);
-   * }
-   */
-  async generateToolResponse() {
-    const message = (await this.#message) ?? this.params.messages.at(-1);
-    if (!message) {
-      return null;
-    }
-    return this.#generateToolResponse(message);
-  }
-
-  async #generateToolResponse(lastMessage: BetaMessageParam) {
-    if (this.#toolResponse !== undefined) {
-      return this.#toolResponse;
-    }
-    this.#toolResponse = generateToolResponse(this.#state.params, lastMessage);
-    return this.#toolResponse;
-  }
-
-  /**
-   * Wait for the async iterator to complete. This works even if the async iterator hasn't yet started, and
-   * will wait for an instance to start and go to completion.
-   *
-   * @returns A promise that resolves to the final BetaMessage when the iterator completes
-   *
-   * @example
-   * // Start consuming the iterator
-   * for await (const message of runner) {
-   *   console.log('Message:', message.content);
-   * }
-   *
-   * // Meanwhile, wait for completion from another part of the code
-   * const finalMessage = await runner.done();
-   * console.log('Final response:', finalMessage.content);
-   */
-  done(): Promise<BetaMessage> {
-    return this.#completion.promise;
-  }
-
-  /**
-   * Returns a promise indicating that the stream is done. Unlike .done(), this will eagerly read the stream:
-   * * If the iterator has not been consumed, consume the entire iterator and return the final message from the
-   * assistant.
-   * * If the iterator has been consumed, waits for it to complete and returns the final message.
-   *
-   * @returns A promise that resolves to the final BetaMessage from the conversation
-   * @throws {AnthropicError} If no messages were processed during the conversation
-   *
-   * @example
-   * const finalMessage = await runner.runUntilDone();
-   * console.log('Final response:', finalMessage.content);
-   */
-  async runUntilDone(): Promise<BetaMessage> {
-    // If not yet consumed, start consuming and wait for completion
-    if (!this.#consumed) {
-      for await (const _ of this) {
-        // Iterator naturally populates this.#message
-      }
-    }
-
-    // If consumed but not completed, wait for completion
-    return this.done();
-  }
-
-  /**
-   * Get the current parameters being used by the ToolRunner.
-   *
-   * @returns A readonly view of the current ToolRunnerParams
-   *
-   * @example
-   * const currentParams = runner.params;
-   * console.log('Current model:', currentParams.model);
-   * console.log('Message count:', currentParams.messages.length);
-   */
-  get params(): Readonly<BetaToolRunnerParams> {
-    return this.#state.params as Readonly<BetaToolRunnerParams>;
-  }
-
-  /**
-   * Add one or more messages to the conversation history.
-   *
-   * @param messages - One or more BetaMessageParam objects to add to the conversation
-   *
-   * @example
-   * runner.pushMessages(
-   *   { role: 'user', content: 'Also, what about the weather in NYC?' }
-   * );
-   *
-   * @example
-   * // Adding multiple messages
-   * runner.pushMessages(
-   *   { role: 'user', content: 'What about NYC?' },
-   *   { role: 'user', content: 'And Boston?' }
-   * );
-   */
-  pushMessages(...messages: BetaMessageParam[]) {
-    this.setMessagesParams((params) => ({
-      ...params,
-      messages: [...params.messages, ...messages],
-    }));
-  }
-
-  /**
-   * Makes the ToolRunner directly awaitable, equivalent to calling .runUntilDone()
-   * This allows using `await runner` instead of `await runner.runUntilDone()`
-   */
-  then<TResult1 = BetaMessage, TResult2 = never>(
-    onfulfilled?: ((value: BetaMessage) => TResult1 | PromiseLike<TResult1>) | undefined | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
-  ): Promise<TResult1 | TResult2> {
-    return this.runUntilDone().then(onfulfilled, onrejected);
-  }
-}
-
-async function generateToolResponse(
-  params: BetaToolRunnerParams,
-  lastMessage = params.messages.at(-1),
-): Promise<BetaMessageParam | null> {
-  // Only process if the last message is from the assistant and has tool use blocks
-  if (
-    !lastMessage ||
-    lastMessage.role !== 'assistant' ||
-    !lastMessage.content ||
-    typeof lastMessage.content === 'string'
-  ) {
-    return null;
-  }
-
-  const toolUseBlocks = lastMessage.content.filter((content) => content.type === 'tool_use');
-  if (toolUseBlocks.length === 0) {
-    return null;
-  }
-
-  const toolResults = await Promise.all(
-    toolUseBlocks.map(async (toolUse) => {
-      const tool = params.tools.find((t) => ('name' in t ? t.name : t.mcp_server_name) === toolUse.name);
-      if (!tool || !('run' in tool)) {
-        return {
-          type: 'tool_result' as const,
-          tool_use_id: toolUse.id,
-          content: `Error: Tool '${toolUse.name}' not found`,
-          is_error: true,
-        };
-      }
-
-      try {
-        let input = toolUse.input;
-        if ('parse' in tool && tool.parse) {
-          input = tool.parse(input);
-        }
-
-        const result = await tool.run(input);
-        return {
-          type: 'tool_result' as const,
-          tool_use_id: toolUse.id,
-          content: result,
-        };
-      } catch (error) {
-        return {
-          type: 'tool_result' as const,
-          tool_use_id: toolUse.id,
-          content:
-            error instanceof ToolError ?
-              error.content
-            : `Error: ${error instanceof Error ? error.message : String(error)}`,
-          is_error: true,
-        };
-      }
-    }),
-  );
-
-  return {
-    role: 'user' as const,
-    content: toolResults,
-  };
-}
-
-// vendored from typefest just to make things look a bit nicer on hover
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
-
-/**
- * Parameters for creating a ToolRunner, extending MessageCreateParams with runnable tools.
- */
-export type BetaToolRunnerParams = Simplify<
-  Omit<MessageCreateParams, 'tools'> & {
-    tools: (BetaToolUnion | BetaRunnableTool<any>)[];
-    /**
-     * Maximum number of iterations (API requests) to make in the tool execution loop.
-     * Each iteration consists of: assistant response → tool execution → tool results.
-     * When exceeded, the loop will terminate even if tools are still being requested.
-     */
-    max_iterations?: number;
-  }
->;