@oneie/claude 0.6.0 → 0.8.0

package/scripts/node_modules/@anthropic-ai/sdk/src/lib/helper-client.ts

@@ -1,89 +0,0 @@
-import { AnthropicError } from '../core/error';
-import type { Anthropic } from '../client';
-import { buildHeaders, type HeadersLike, type NullableHeaders } from '../internal/headers';
-
-/**
- * Shared util for building a runner-helper-bound sub-client.
- *
- * The work poller, the environment worker, and the session tool runner each
- * need to issue requests authenticated by a per-helper credential (a
- * self-hosted environment key, today) rather than the parent client's own
- * `X-Api-Key`, *and* tagged with their own `x-stainless-helper` telemetry
- * value. Each wants to inherit the parent's full configuration — `timeout`,
- * `maxRetries`, `fetch`, `fetchOptions`, custom `defaultHeaders`,
- * `defaultQuery` — and override only the auth + telemetry bits.
- *
- * {@link copyClientForHelper} is the one shared construction.
- */
-
-/**
- * The closed set of `x-stainless-helper` telemetry tags the runner helpers
- * stamp on outgoing requests. Constrained as a string union so a typo at any
- * call site is a type error rather than silently mistagged telemetry.
- */
-export type HelperTag = 'environments-work-poller' | 'environments-worker' | 'session-tool-runner';
-
-interface ClientInternalAccess {
-  _options: { defaultHeaders?: HeadersLike };
-  _authState?: { extraHeaders?: Record<string, string> };
-}
-
-/**
- * Return a `withOptions()` clone of `client` set up for use *by* one of the
- * runner helpers: authenticated with `authToken` as Bearer credentials, with
- * the parent's `X-Api-Key` cleared, and tagged with the helper's
- * `x-stainless-helper` value on every outgoing request.
- *
- * The returned sub-client inherits the parent's full configuration
- * (`baseURL`, `timeout`, `maxRetries`, `fetch`, `fetchOptions`, custom
- * `defaultHeaders`, `defaultQuery`). Overrides applied:
- *
- * - `authToken: authToken` — the new credential.
- * - `apiKey: null` — the parent's `X-Api-Key` is cleared. `withOptions`
- *   inherits the parent's `apiKey` by default; without this, both
- *   `X-Api-Key` *and* `Authorization: Bearer …` would land on the wire.
- *   `client.ts` only triggers the env-var fallback when `apiKey === undefined`,
- *   so explicit `null` is honored.
- * - `credentials: undefined` — opts the clone out of any inherited
- *   credentials/config/profile so the explicit bearer is the unambiguous auth.
- * - `baseURL: client.baseURL` — pins the parent's resolved host (auth override otherwise resets it).
- * - `defaultHeaders` is rebuilt as `parent._authState.extraHeaders ⊕ parent.defaultHeaders ⊕
- *   {'x-stainless-helper': helper}`. `withOptions` *replaces* (does not
- *   merge) `defaultHeaders`, so we merge here so any custom headers the
- *   caller set on the parent client survive on the sub-client.
- */
-export function copyClientForHelper<T extends Anthropic>(
-  client: T,
-  { authToken, helper }: { authToken: string; helper: HelperTag },
-): T {
-  if (!authToken) {
-    throw new AnthropicError(
-      `copyClientForHelper: expected a non-empty authToken but received ${JSON.stringify(authToken)}`,
-    );
-  }
-  const internal = client as unknown as ClientInternalAccess;
-  const parentDefaults = internal._options.defaultHeaders;
-  // Carry the parent's credential/profile headers; strip the auth ones (we re-auth below).
-  const parentAuthExtraHeaders = internal._authState?.extraHeaders;
-  const inheritedAuthExtraHeaders: Record<string, string> | undefined =
-    parentAuthExtraHeaders ?
-      Object.fromEntries(
-        Object.entries(parentAuthExtraHeaders).filter(([name]) => {
-          const lower = name.toLowerCase();
-          return lower !== 'authorization' && lower !== 'x-api-key';
-        }),
-      )
-    : undefined;
-  const defaultHeaders: NullableHeaders = buildHeaders([
-    inheritedAuthExtraHeaders,
-    parentDefaults,
-    { 'x-stainless-helper': helper },
-  ]);
-  return client.withOptions({
-    apiKey: null,
-    authToken,
-    baseURL: client.baseURL,
-    credentials: undefined,
-    defaultHeaders,
-  }) as T;
-}

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

@@ -1,125 +0,0 @@
-import type { Logger } from '../client';
-import { AnthropicError } from '../core/error';
-import {
-  ContentBlock,
-  JSONOutputFormat,
-  Message,
-  OutputConfig,
-  TextBlock,
-  MessageCreateParams,
-} from '../resources/messages/messages';
-
-// vendored from typefest just to make things look a bit nicer on hover
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
-
-type AutoParseableOutputConfig = Omit<OutputConfig, 'format'> & {
-  format?: JSONOutputFormat | AutoParseableOutputFormat<any> | null;
-};
-
-export type ParseableMessageCreateParams = Simplify<
-  Omit<MessageCreateParams, 'output_config'> & {
-    output_config?: AutoParseableOutputConfig | null;
-  }
->;
-
-export type ExtractParsedContentFromParams<Params extends ParseableMessageCreateParams> =
-  Params['output_config'] extends { format: AutoParseableOutputFormat<infer P> } ? P : null;
-
-export type AutoParseableOutputFormat<ParsedT> = JSONOutputFormat & {
-  parse(content: string): ParsedT;
-};
-
-export type ParsedMessage<ParsedT> = Message & {
-  content: Array<ParsedContentBlock<ParsedT>>;
-  parsed_output: ParsedT | null;
-};
-
-export type ParsedContentBlock<ParsedT> =
-  | (TextBlock & { parsed_output: ParsedT | null })
-  | Exclude<ContentBlock, TextBlock>;
-
-function getOutputFormat(
-  params: ParseableMessageCreateParams | null,
-): JSONOutputFormat | AutoParseableOutputFormat<any> | null | undefined {
-  return params?.output_config?.format;
-}
-
-export function maybeParseMessage<Params extends ParseableMessageCreateParams | null>(
-  message: Message,
-  params: Params,
-  opts: { logger: Logger },
-): ParsedMessage<ExtractParsedContentFromParams<NonNullable<Params>>> {
-  const outputFormat = getOutputFormat(params);
-  if (!params || !('parse' in (outputFormat ?? {}))) {
-    return {
-      ...message,
-      content: message.content.map((block) => {
-        if (block.type === 'text') {
-          const parsedBlock = Object.defineProperty({ ...block }, 'parsed_output', {
-            value: null,
-            enumerable: false,
-          }) as ParsedContentBlock<ExtractParsedContentFromParams<NonNullable<Params>>>;
-
-          return parsedBlock;
-        }
-        return block;
-      }),
-      parsed_output: null,
-    } as ParsedMessage<ExtractParsedContentFromParams<NonNullable<Params>>>;
-  }
-
-  return parseMessage(message, params, opts);
-}
-
-export function parseMessage<Params extends ParseableMessageCreateParams>(
-  message: Message,
-  params: Params,
-  opts: { logger: Logger },
-): ParsedMessage<ExtractParsedContentFromParams<Params>> {
-  let firstParsedOutput: ReturnType<typeof parseOutputFormat<Params>> | null = null;
-
-  const content: Array<ParsedContentBlock<ExtractParsedContentFromParams<Params>>> = message.content.map(
-    (block) => {
-      if (block.type === 'text') {
-        const parsedOutput = parseOutputFormat(params, block.text);
-
-        if (firstParsedOutput === null) {
-          firstParsedOutput = parsedOutput;
-        }
-
-        const parsedBlock = Object.defineProperty({ ...block }, 'parsed_output', {
-          value: parsedOutput,
-          enumerable: false,
-        }) as ParsedContentBlock<ExtractParsedContentFromParams<Params>>;
-        return parsedBlock;
-      }
-      return block;
-    },
-  );
-
-  return {
-    ...message,
-    content,
-    parsed_output: firstParsedOutput,
-  } as ParsedMessage<ExtractParsedContentFromParams<Params>>;
-}
-
-function parseOutputFormat<Params extends ParseableMessageCreateParams>(
-  params: Params,
-  content: string,
-): ExtractParsedContentFromParams<Params> | null {
-  const outputFormat = getOutputFormat(params);
-  if (outputFormat?.type !== 'json_schema') {
-    return null;
-  }
-
-  try {
-    if ('parse' in outputFormat) {
-      return outputFormat.parse(content);
-    }
-
-    return JSON.parse(content);
-  } catch (error) {
-    throw new AnthropicError(`Failed to parse structured output: ${error}`);
-  }
-}

package/scripts/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/scripts/node_modules/@anthropic-ai/sdk/src/lib/tools/BetaRunnableTool.ts

@@ -1,130 +0,0 @@
-import {
-  BetaMemoryTool20250818,
-  BetaTool,
-  BetaToolBash20241022,
-  BetaToolBash20250124,
-  BetaToolComputerUse20241022,
-  BetaToolComputerUse20250124,
-  BetaToolComputerUse20251124,
-  BetaToolResultContentBlockParam,
-  BetaToolTextEditor20241022,
-  BetaToolTextEditor20250124,
-  BetaToolTextEditor20250429,
-  BetaToolTextEditor20250728,
-  BetaToolUnion,
-  BetaToolUseBlock,
-} from '../../resources/beta';
-import type {
-  BetaManagedAgentsAgentCustomToolUseEvent,
-  BetaManagedAgentsAgentToolUseEvent,
-} from '../../resources/beta/sessions/events';
-import { ToolError } from './ToolError';
-
-export type Promisable<T> = T | Promise<T>;
-
-/**
- * Tool types that can be implemented on the client.
- * Excludes server-side tools like code execution, web search, and MCP toolsets.
- */
-export type BetaClientRunnableToolType =
-  | BetaTool
-  | BetaMemoryTool20250818
-  | BetaToolBash20241022
-  | BetaToolBash20250124
-  | BetaToolComputerUse20241022
-  | BetaToolComputerUse20250124
-  | BetaToolComputerUse20251124
-  | BetaToolTextEditor20241022
-  | BetaToolTextEditor20250124
-  | BetaToolTextEditor20250429
-  | BetaToolTextEditor20250728;
-
-/**
- * The tool-use that triggered a {@link BetaRunnableTool.run}:
- *
- * - from `client.beta.messages.toolRunner`, a Messages `tool_use` content block;
- * - from `client.beta.sessions.events.toolRunner`, the `agent.tool_use` /
- *   `agent.custom_tool_use` session event.
- *
- * The shapes overlap on the common fields (`id`, `name`, `input`), so code that
- * only reads those works without narrowing; narrow on the shape (e.g. `'type' in
- * x`) when you need surface-specific properties.
- */
-export type BetaToolUse =
-  | BetaToolUseBlock
-  | BetaManagedAgentsAgentToolUseEvent
-  | BetaManagedAgentsAgentCustomToolUseEvent;
-
-export type BetaToolRunContext = {
-  /** The tool-use that triggered this run. See {@link BetaToolUse}. */
-  toolUse: BetaToolUse;
-  /**
-   * @deprecated Renamed to `toolUse`. Also note that for
-   * `client.beta.sessions.events.toolRunner` this is the `agent.tool_use` /
-   * `agent.custom_tool_use` *event*, not a Messages content block, despite the
-   * name — which is why it was renamed.
-   */
-  toolUseBlock: BetaToolUse;
-  signal?: AbortSignal | null | undefined;
-};
-
-// this type is just an extension of BetaTool with a run and parse method
-// that will be called by `toolRunner()` helpers
-export type BetaRunnableTool<Input = any> = BetaClientRunnableToolType & {
-  run: (
-    args: Input,
-    context?: BetaToolRunContext,
-  ) => Promisable<string | Array<BetaToolResultContentBlockParam>>;
-  parse: (content: unknown) => Input;
-  /**
-   * Optional cleanup hook for tools that hold process-level resources (e.g. a
-   * persistent shell). `SessionToolRunner` (`client.beta.sessions.events.toolRunner`)
-   * calls it once when iteration ends.
-   */
-  close?: () => Promisable<void>;
-};
-
-/**
- * Resolve the registry key for a tool — the name the model addresses it by.
- * MCP toolsets are keyed on `mcp_server_name`; every other tool on `name`.
- * Shared so the tool-name lookup is identical across `toolRunner()` surfaces.
- */
-export function toolName(tool: BetaToolUnion | BetaRunnableTool): string {
-  return 'name' in tool ? tool.name : tool.mcp_server_name;
-}
-
-/**
- * Format a thrown value into tool-result content: a {@link ToolError} carries
- * its own structured content, anything else becomes an `Error: <message>`
- * string. Shared so every `toolRunner()` surface reports tool failures the
- * same way to the model.
- */
-export function toolErrorContent(e: unknown): string | Array<BetaToolResultContentBlockParam> {
-  return e instanceof ToolError ? e.content : `Error: ${e instanceof Error ? e.message : String(e)}`;
-}
-
-/** Outcome of {@link runRunnableTool}: the content to post back and whether it is an error. */
-export interface RunnableToolOutcome {
-  content: string | Array<BetaToolResultContentBlockParam>;
-  isError: boolean;
-}
-
-/**
- * Run a {@link BetaRunnableTool} end-to-end: parse the raw input, invoke `run`,
- * and format any thrown value via {@link toolErrorContent}. Shared so the
- * parse → run → catch → format pipeline is identical across `toolRunner()`
- * surfaces.
- */
-export async function runRunnableTool(
-  tool: BetaRunnableTool,
-  rawInput: unknown,
-  context: BetaToolRunContext,
-): Promise<RunnableToolOutcome> {
-  try {
-    const input = tool.parse ? tool.parse(rawInput) : rawInput;
-    const content = await tool.run(input, context);
-    return { content, isError: false };
-  } catch (e) {
-    return { content: toolErrorContent(e), isError: true };
-  }
-}