Add extracted source directory and README navigation

extracted-source/node_modules/@anthropic-ai/foundry-sdk/internal/utils/base64.mjs

@@ -0,0 +1,33 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { AnthropicError } from "../../core/error.mjs";
+import { encodeUTF8 } from "./bytes.mjs";
+export const toBase64 = (data) => {
+    if (!data)
+        return '';
+    if (typeof globalThis.Buffer !== 'undefined') {
+        return globalThis.Buffer.from(data).toString('base64');
+    }
+    if (typeof data === 'string') {
+        data = encodeUTF8(data);
+    }
+    if (typeof btoa !== 'undefined') {
+        return btoa(String.fromCharCode.apply(null, data));
+    }
+    throw new AnthropicError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
+};
+export const fromBase64 = (str) => {
+    if (typeof globalThis.Buffer !== 'undefined') {
+        const buf = globalThis.Buffer.from(str, 'base64');
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    if (typeof atob !== 'undefined') {
+        const bstr = atob(str);
+        const buf = new Uint8Array(bstr.length);
+        for (let i = 0; i < bstr.length; i++) {
+            buf[i] = bstr.charCodeAt(i);
+        }
+        return buf;
+    }
+    throw new AnthropicError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
+};
+//# sourceMappingURL=base64.mjs.map

extracted-source/node_modules/@anthropic-ai/foundry-sdk/internal/utils/env.mjs

@@ -0,0 +1,18 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+export const readEnv = (env) => {
+    if (typeof globalThis.process !== 'undefined') {
+        return globalThis.process.env?.[env]?.trim() ?? undefined;
+    }
+    if (typeof globalThis.Deno !== 'undefined') {
+        return globalThis.Deno.env?.get?.(env)?.trim();
+    }
+    return undefined;
+};
+//# sourceMappingURL=env.mjs.map

extracted-source/node_modules/@anthropic-ai/foundry-sdk/internal/utils/log.mjs

@@ -0,0 +1,80 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { hasOwn } from "./values.mjs";
+const levelNumbers = {
+    off: 0,
+    error: 200,
+    warn: 300,
+    info: 400,
+    debug: 500,
+};
+export const parseLogLevel = (maybeLevel, sourceName, client) => {
+    if (!maybeLevel) {
+        return undefined;
+    }
+    if (hasOwn(levelNumbers, maybeLevel)) {
+        return maybeLevel;
+    }
+    loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
+    return undefined;
+};
+function noop() { }
+function makeLogFn(fnLevel, logger, logLevel) {
+    if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+        return noop;
+    }
+    else {
+        // Don't wrap logger functions, we want the stacktrace intact!
+        return logger[fnLevel].bind(logger);
+    }
+}
+const noopLogger = {
+    error: noop,
+    warn: noop,
+    info: noop,
+    debug: noop,
+};
+let cachedLoggers = /* @__PURE__ */ new WeakMap();
+export function loggerFor(client) {
+    const logger = client.logger;
+    const logLevel = client.logLevel ?? 'off';
+    if (!logger) {
+        return noopLogger;
+    }
+    const cachedLogger = cachedLoggers.get(logger);
+    if (cachedLogger && cachedLogger[0] === logLevel) {
+        return cachedLogger[1];
+    }
+    const levelLogger = {
+        error: makeLogFn('error', logger, logLevel),
+        warn: makeLogFn('warn', logger, logLevel),
+        info: makeLogFn('info', logger, logLevel),
+        debug: makeLogFn('debug', logger, logLevel),
+    };
+    cachedLoggers.set(logger, [logLevel, levelLogger]);
+    return levelLogger;
+}
+export const formatRequestDetails = (details) => {
+    if (details.options) {
+        details.options = { ...details.options };
+        delete details.options['headers']; // redundant + leaks internals
+    }
+    if (details.headers) {
+        details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
+            name,
+            (name.toLowerCase() === 'x-api-key' ||
+                name.toLowerCase() === 'authorization' ||
+                name.toLowerCase() === 'cookie' ||
+                name.toLowerCase() === 'set-cookie') ?
+                '***'
+                : value,
+        ]));
+    }
+    if ('retryOfRequestLogID' in details) {
+        if (details.retryOfRequestLogID) {
+            details.retryOf = details.retryOfRequestLogID;
+        }
+        delete details.retryOfRequestLogID;
+    }
+    return details;
+};
+//# sourceMappingURL=log.mjs.map

extracted-source/node_modules/@anthropic-ai/foundry-sdk/internal/utils/values.mjs

@@ -0,0 +1,100 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { AnthropicError } from "../../core/error.mjs";
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+export const isAbsoluteURL = (url) => {
+    return startsWithSchemeRegexp.test(url);
+};
+export let isArray = (val) => ((isArray = Array.isArray), isArray(val));
+export let isReadonlyArray = isArray;
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x) {
+    if (typeof x !== 'object') {
+        return {};
+    }
+    return x ?? {};
+}
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj) {
+    if (!obj)
+        return true;
+    for (const _k in obj)
+        return false;
+    return true;
+}
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+export function isObj(obj) {
+    return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+export const ensurePresent = (value) => {
+    if (value == null) {
+        throw new AnthropicError(`Expected a value to be given but received ${value} instead.`);
+    }
+    return value;
+};
+export const validatePositiveInteger = (name, n) => {
+    if (typeof n !== 'number' || !Number.isInteger(n)) {
+        throw new AnthropicError(`${name} must be an integer`);
+    }
+    if (n < 0) {
+        throw new AnthropicError(`${name} must be a positive integer`);
+    }
+    return n;
+};
+export const coerceInteger = (value) => {
+    if (typeof value === 'number')
+        return Math.round(value);
+    if (typeof value === 'string')
+        return parseInt(value, 10);
+    throw new AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+export const coerceFloat = (value) => {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string')
+        return parseFloat(value);
+    throw new AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+export const coerceBoolean = (value) => {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string')
+        return value === 'true';
+    return Boolean(value);
+};
+export const maybeCoerceInteger = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    return coerceInteger(value);
+};
+export const maybeCoerceFloat = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    return coerceFloat(value);
+};
+export const maybeCoerceBoolean = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    return coerceBoolean(value);
+};
+export const safeJSON = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+// Gets a value from an object, deletes the key, and returns the value (or undefined if not found)
+export const pop = (obj, key) => {
+    const value = obj[key];
+    delete obj[key];
+    return value;
+};
+//# sourceMappingURL=values.mjs.map