@tembo-io/sdk 0.2.3 → 0.3.0

package/dist/cjs/client.js

@@ -0,0 +1,654 @@
+"use strict";
+// File generated from our OpenAPI spec by Scalar. See README.md for details.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tembo = void 0;
+const api_promise_1 = require("./api-promise");
+const Errors = __importStar(require("./error"));
+const uuid_1 = require("./internal/utils/uuid");
+const values_1 = require("./internal/utils/values");
+const sleep_1 = require("./internal/utils/sleep");
+const errors_1 = require("./internal/errors");
+const detect_platform_1 = require("./internal/detect-platform");
+const Shims = __importStar(require("./internal/shims"));
+const Opts = __importStar(require("./internal/request-options"));
+const env_1 = require("./internal/utils/env");
+const log_1 = require("./internal/utils/log");
+const headers_1 = require("./internal/headers");
+const query_1 = require("./internal/utils/query");
+const uploads_1 = require("./core/uploads");
+const version_1 = require("./version");
+const api_keys_1 = require("./resources/api-keys");
+const skills_1 = require("./resources/skills");
+const insights_1 = require("./resources/insights");
+const organizations_1 = require("./resources/organizations/organizations");
+const mcp_connections_1 = require("./resources/mcp-connections");
+const artifacts_1 = require("./resources/artifacts");
+const messages_1 = require("./resources/messages");
+const models_1 = require("./resources/models");
+const users_1 = require("./resources/users/users");
+const sessions_1 = require("./resources/sessions/sessions");
+const projects_1 = require("./resources/projects/projects");
+const pull_requests_1 = require("./resources/pull-requests");
+const agents_1 = require("./resources/agents/agents");
+const repositories_1 = require("./resources/repositories");
+const integrations_1 = require("./resources/integrations");
+const billing_1 = require("./resources/billing");
+/**
+ * API Client for interfacing with the TemboPublicApi API.
+ */
+class Tembo {
+    apiKey;
+    baseURL;
+    maxRetries;
+    timeout;
+    logger;
+    logLevel;
+    fetchOptions;
+    fetch;
+    #encoder;
+    idempotencyHeader;
+    _baseURLOverridden;
+    _defaultBaseURL;
+    _options;
+    /**
+     * API Client for interfacing with the TemboPublicApi API.
+     *
+     * @param {string | AuthTokenProvider | undefined} [opts.apiKey=process.env["TEMBO_API_KEY"] ?? undefined]
+     * @param {string} [opts.baseURL=process.env["TEMBO_BASE_URL"] ?? https://api.tembo.io] - Override the default base URL for the API.
+     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
+     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
+     */
+    constructor({ baseURL = (0, env_1.readEnv)('TEMBO_BASE_URL'), apiKey = (0, env_1.readEnv)('TEMBO_API_KEY'), ...opts } = {}) {
+        if (apiKey === undefined) {
+            throw new Errors.TemboError("The TEMBO_API_KEY environment variable is missing or empty; either provide it, or instantiate the Tembo client with an apiKey option, like new Tembo({ apiKey: 'My API Key' }).");
+        }
+        const options = {
+            apiKey,
+            ...opts,
+            baseURL: baseURL || 'https://api.tembo.io',
+        };
+        const baseURLOverridden = baseURL !== null && baseURL !== undefined && baseURL !== '';
+        const defaultBaseURL = 'https://api.tembo.io';
+        this.baseURL = options.baseURL || defaultBaseURL;
+        this.timeout = options.timeout ?? Tembo.DEFAULT_TIMEOUT /* 1 minute */;
+        this.logger = options.logger ?? console;
+        const defaultLogLevel = 'warn';
+        // Set default logLevel early so that we can log a warning in parseLogLevel.
+        this.logLevel = defaultLogLevel;
+        this.logLevel =
+            (0, log_1.parseLogLevel)(options.logLevel, 'ClientOptions.logLevel', this) ??
+                (0, log_1.parseLogLevel)((0, env_1.readEnv)('TEMBO_LOG'), 'process.env["TEMBO_LOG"]', this) ??
+                defaultLogLevel;
+        this.fetchOptions = options.fetchOptions;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.fetch = options.fetch ?? Shims.getDefaultFetch();
+        this.#encoder = Opts.FallbackEncoder;
+        const customHeadersEnv = (0, env_1.readEnv)('TEMBO_CUSTOM_HEADERS');
+        if (customHeadersEnv) {
+            const parsed = {};
+            for (const line of customHeadersEnv.split('\n')) {
+                const colon = line.indexOf(':');
+                if (colon >= 0) {
+                    parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+                }
+            }
+            options.defaultHeaders = { ...parsed, ...options.defaultHeaders };
+        }
+        this._options = { ...options, baseURL: baseURLOverridden ? this.baseURL : undefined };
+        this._baseURLOverridden = baseURLOverridden;
+        this._defaultBaseURL = defaultBaseURL;
+        this.apiKey = apiKey;
+    }
+    withOptions(options) {
+        const client = new this.constructor({
+            ...this._options,
+            ...(this.#baseURLOverridden() ? { baseURL: this.baseURL } : {}),
+            maxRetries: this.maxRetries,
+            timeout: this.timeout,
+            logger: this.logger,
+            logLevel: this.logLevel,
+            fetch: this.fetch,
+            fetchOptions: this.fetchOptions,
+            apiKey: this.apiKey,
+            ...options,
+        });
+        return client;
+    }
+    #baseURLOverridden() {
+        // A named environment selects a default URL; only explicit overrides should bypass per-request defaults.
+        return this._baseURLOverridden || this.baseURL !== this._defaultBaseURL;
+    }
+    defaultQuery() {
+        return this._options.defaultQuery;
+    }
+    stringifyQuery(query) {
+        return (0, query_1.stringifyQuery)(query);
+    }
+    getUserAgent() {
+        return `${this.constructor.name}/JS ${version_1.VERSION}`;
+    }
+    defaultIdempotencyKey() {
+        return `scalar-node-retry-${(0, uuid_1.uuid4)()}`;
+    }
+    makeStatusError(status, error, message, headers) {
+        return Errors.APIError.generate(status, error, message, headers);
+    }
+    buildURL(path, query, defaultBaseURL) {
+        const baseURL = (!this.#baseURLOverridden() && defaultBaseURL) || this.baseURL;
+        // Guarantee exactly one "/" between baseURL and path so that bases without a trailing slash
+        // and paths without a leading slash do not fuse into a malformed URL (e.g. ".../v1" + "widgets").
+        const url = (0, values_1.isAbsoluteURL)(path)
+            ? new URL(path)
+            : new URL((baseURL.endsWith('/') ? baseURL : baseURL + '/') + (path.startsWith('/') ? path.slice(1) : path));
+        const defaultQuery = this.defaultQuery();
+        const pathQuery = Object.fromEntries(url.searchParams);
+        if (!(0, values_1.isEmptyObj)(defaultQuery) || !(0, values_1.isEmptyObj)(pathQuery)) {
+            query = { ...pathQuery, ...defaultQuery, ...query };
+        }
+        if (typeof query === 'object' && query && !Array.isArray(query)) {
+            url.search = this.stringifyQuery(query);
+        }
+        return url.toString();
+    }
+    /**
+     * Used as a callback for mutating the given `FinalRequestOptions` object.
+     */
+    async prepareOptions(options) { }
+    /**
+     * Used as a callback for mutating the given `RequestInit` object.
+     *
+     * This is useful for cases where you want to add certain headers based off of
+     * the request properties, e.g. `method` or `url`.
+     */
+    async prepareRequest(request, { url, options }) { }
+    get(path, opts) {
+        return this.methodRequest('get', path, opts);
+    }
+    post(path, opts) {
+        return this.methodRequest('post', path, opts);
+    }
+    patch(path, opts) {
+        return this.methodRequest('patch', path, opts);
+    }
+    put(path, opts) {
+        return this.methodRequest('put', path, opts);
+    }
+    delete(path, opts) {
+        return this.methodRequest('delete', path, opts);
+    }
+    methodRequest(method, path, opts) {
+        return this.request(Promise.resolve(opts).then((opts) => {
+            return { method, path, ...opts };
+        }));
+    }
+    request(options, remainingRetries = null) {
+        return new api_promise_1.APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+    }
+    async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+        const options = await optionsInput;
+        const maxRetries = options.maxRetries ?? this.maxRetries;
+        if (retriesRemaining == null) {
+            retriesRemaining = maxRetries;
+        }
+        await this.prepareOptions(options);
+        const { req, url, timeout } = await this.buildRequest(options, {
+            retryCount: maxRetries - retriesRemaining,
+        });
+        await this.prepareRequest(req, { url, options });
+        /** Not an API request ID, just for correlating local log entries. */
+        const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0');
+        const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`;
+        const startTime = Date.now();
+        (0, log_1.loggerFor)(this).debug(`[${requestLogID}] sending request`, (0, log_1.formatRequestDetails)({
+            retryOfRequestLogID,
+            method: options.method,
+            url,
+            options,
+            headers: req.headers,
+        }));
+        if (options.signal?.aborted) {
+            throw new Errors.APIUserAbortError();
+        }
+        const controller = new AbortController();
+        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(errors_1.castToError);
+        const headersTime = Date.now();
+        if (response instanceof globalThis.Error) {
+            const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+            if (options.signal?.aborted) {
+                throw new Errors.APIUserAbortError();
+            }
+            // detect native connection timeout errors
+            // deno throws "TypeError: error sending request for url (https://example/): client error (Connect): tcp connect error: Operation timed out (os error 60): Operation timed out (os error 60)"
+            // undici throws "TypeError: fetch failed" with cause "ConnectTimeoutError: Connect Timeout Error (attempted address: example:443, timeout: 1ms)"
+            // others do not provide enough information to distinguish timeouts from other connection errors
+            const isTimeout = (0, errors_1.isAbortError)(response) ||
+                /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
+            if (retriesRemaining) {
+                (0, log_1.loggerFor)(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`);
+                (0, log_1.loggerFor)(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`, (0, log_1.formatRequestDetails)({
+                    retryOfRequestLogID,
+                    url,
+                    durationMs: headersTime - startTime,
+                    message: response.message,
+                }));
+                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+            }
+            (0, log_1.loggerFor)(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`);
+            (0, log_1.loggerFor)(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`, (0, log_1.formatRequestDetails)({
+                retryOfRequestLogID,
+                url,
+                durationMs: headersTime - startTime,
+                message: response.message,
+            }));
+            if (isTimeout) {
+                throw new Errors.APIConnectionTimeoutError();
+            }
+            throw new Errors.APIConnectionError({ cause: response });
+        }
+        const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`;
+        if (!response.ok) {
+            const shouldRetry = await this.shouldRetry(response);
+            if (retriesRemaining && shouldRetry) {
+                const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+                // We don't need the body of this response.
+                await Shims.CancelReadableStream(response.body);
+                (0, log_1.loggerFor)(this).info(`${responseInfo} - ${retryMessage}`);
+                (0, log_1.loggerFor)(this).debug(`[${requestLogID}] response error (${retryMessage})`, (0, log_1.formatRequestDetails)({
+                    retryOfRequestLogID,
+                    url: response.url,
+                    status: response.status,
+                    headers: response.headers,
+                    durationMs: headersTime - startTime,
+                }));
+                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
+            }
+            const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+            (0, log_1.loggerFor)(this).info(`${responseInfo} - ${retryMessage}`);
+            const errText = await response.text().catch((err) => (0, errors_1.castToError)(err).message);
+            const errJSON = (0, values_1.safeJSON)(errText);
+            const errMessage = errJSON ? undefined : errText;
+            (0, log_1.loggerFor)(this).debug(`[${requestLogID}] response error (${retryMessage})`, (0, log_1.formatRequestDetails)({
+                retryOfRequestLogID,
+                url: response.url,
+                status: response.status,
+                headers: response.headers,
+                message: errMessage,
+                durationMs: Date.now() - startTime,
+            }));
+            const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+            throw err;
+        }
+        (0, log_1.loggerFor)(this).info(responseInfo);
+        (0, log_1.loggerFor)(this).debug(`[${requestLogID}] response start`, (0, log_1.formatRequestDetails)({
+            retryOfRequestLogID,
+            url: response.url,
+            status: response.status,
+            headers: response.headers,
+            durationMs: headersTime - startTime,
+        }));
+        return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+    }
+    async fetchWithTimeout(url, init, ms, controller) {
+        const { signal, method, ...options } = init || {};
+        const abort = this._makeAbort(controller);
+        if (signal)
+            signal.addEventListener('abort', abort, { once: true });
+        const timeout = setTimeout(abort, ms);
+        const isReadableBody = (globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream) ||
+            (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
+        const fetchOptions = {
+            signal: controller.signal,
+            ...(isReadableBody ? { duplex: 'half' } : {}),
+            method: 'GET',
+            ...options,
+        };
+        if (method) {
+            // Custom methods like 'patch' need to be uppercased
+            // See https://github.com/nodejs/undici/issues/2294
+            fetchOptions.method = method.toUpperCase();
+        }
+        try {
+            // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+            return await this.fetch.call(undefined, url, fetchOptions);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async shouldRetry(response) {
+        // Note this is not a standard header.
+        const shouldRetryHeader = response.headers.get('x-should-retry');
+        // If the server explicitly says whether or not to retry, obey.
+        if (shouldRetryHeader === 'true')
+            return true;
+        if (shouldRetryHeader === 'false')
+            return false;
+        // Retry on request timeouts.
+        if (response.status === 408)
+            return true;
+        // Retry on lock timeouts.
+        if (response.status === 409)
+            return true;
+        // Retry on rate limits.
+        if (response.status === 429)
+            return true;
+        // Retry internal errors.
+        if (response.status >= 500)
+            return true;
+        return false;
+    }
+    async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+        let timeoutMillis;
+        // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
+        const retryAfterMillisHeader = responseHeaders?.get('retry-after-ms');
+        if (retryAfterMillisHeader) {
+            const timeoutMs = parseFloat(retryAfterMillisHeader);
+            if (!Number.isNaN(timeoutMs)) {
+                timeoutMillis = timeoutMs;
+            }
+        }
+        // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        const retryAfterHeader = responseHeaders?.get('retry-after');
+        if (retryAfterHeader && !timeoutMillis) {
+            const timeoutSeconds = parseFloat(retryAfterHeader);
+            if (!Number.isNaN(timeoutSeconds)) {
+                timeoutMillis = timeoutSeconds * 1000;
+            }
+            else {
+                timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+            }
+        }
+        // If the API asks us to wait a certain amount of time, just do what it says,
+        // but cap server-provided delays at 60s so an oversized or malformed Retry-After
+        // (e.g. `retry-after-ms: 999999999`, a past HTTP-date, or a value that Date.parse
+        // failed on) cannot block retries for an unbounded amount of time. Otherwise fall
+        // back to the default exponential-backoff calculation.
+        const maxRetryAfterMillis = 60 * 1000;
+        if (timeoutMillis === undefined ||
+            !Number.isFinite(timeoutMillis) ||
+            timeoutMillis <= 0 ||
+            timeoutMillis > maxRetryAfterMillis) {
+            const maxRetries = options.maxRetries ?? this.maxRetries;
+            timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+        }
+        await (0, sleep_1.sleep)(timeoutMillis);
+        return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+    }
+    calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+        const initialRetryDelay = 0.5;
+        const maxRetryDelay = 8.0;
+        const numRetries = maxRetries - retriesRemaining;
+        // Apply exponential backoff, but not more than the max.
+        const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+        // Apply some jitter, take up to at most 25 percent of the retry time.
+        const jitter = 1 - Math.random() * 0.25;
+        return sleepSeconds * jitter * 1000;
+    }
+    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+        const options = { ...inputOptions };
+        const { method, path, query, defaultBaseURL } = options;
+        const url = this.buildURL(path, query, defaultBaseURL);
+        if ('timeout' in options)
+            (0, values_1.validatePositiveInteger)('timeout', options.timeout);
+        options.timeout = options.timeout ?? this.timeout;
+        const { bodyHeaders, body } = this.buildBody({ options });
+        // Headers read the caller's own options, not the copy defaulted above: `X-Scalar-Timeout`
+        // reports an explicit per-request timeout, and the idempotency key written back here has to
+        // land where the retry can see it.
+        const reqHeaders = await this.buildHeaders({
+            options: inputOptions,
+            method,
+            bodyHeaders,
+            retryCount,
+            url,
+        });
+        const req = {
+            method,
+            headers: reqHeaders,
+            ...(options.signal && { signal: options.signal }),
+            ...(globalThis.ReadableStream &&
+                body instanceof globalThis.ReadableStream && { duplex: 'half' }),
+            // `buildBody` already collapses no-body into `undefined`; here we only need to drop that
+            // sentinel. A truthiness spread would also strip an intentional empty-string body.
+            ...(body !== undefined && { body }),
+            ...(this.fetchOptions ?? {}),
+            ...(options.fetchOptions ?? {}),
+        };
+        return { req, url, timeout: options.timeout };
+    }
+    async buildHeaders({ options, method, bodyHeaders, retryCount, url, }) {
+        let idempotencyHeaders = {};
+        if (this.idempotencyHeader && method !== 'get') {
+            if (!options.idempotencyKey)
+                options.idempotencyKey = this.defaultIdempotencyKey();
+            idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+        }
+        const headers = (0, headers_1.buildHeaders)([
+            idempotencyHeaders,
+            {
+                Accept: 'application/json',
+                'User-Agent': this.getUserAgent(),
+                'X-Scalar-Retry-Count': String(retryCount),
+                ...(options.timeout ? { 'X-Scalar-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
+                ...(0, detect_platform_1.getPlatformHeaders)(),
+            },
+            await this.authHeaders(options),
+            this._options.defaultHeaders,
+            bodyHeaders,
+            options.headers,
+        ]);
+        appendAuthCookies(headers.values, await this.authCookiesAsync());
+        this.validateAuth(url, headers.values, options);
+        return headers.values;
+    }
+    _makeAbort(controller) {
+        // note: we can't just inline this method inside `fetchWithTimeout()` because then the closure
+        //       would capture all request options, and cause a memory leak.
+        return () => controller.abort();
+    }
+    buildBody({ options: { body, headers: rawHeaders } }) {
+        // Skip only `null`/`undefined` so an intentional empty-string (or 0/false) payload still
+        // reaches the encoder. A plain `!body` check would silently drop those falsy-but-valid bodies,
+        // and `null` must be excluded here too because the iterator check below uses `in`, which
+        // throws on null.
+        if (body == null) {
+            return { bodyHeaders: undefined, body: undefined };
+        }
+        const headers = (0, headers_1.buildHeaders)([rawHeaders]);
+        if (
+        // Pass raw type verbatim
+        ArrayBuffer.isView(body) ||
+            body instanceof ArrayBuffer ||
+            body instanceof DataView ||
+            // Always pass strings through verbatim. The previous guard required a caller-set
+            // `content-type` and otherwise fell through to `FallbackEncoder`, which JSON.stringifies
+            // the value and labels it `application/json` — silently quoting plain-text payloads and
+            // mislabeling them as JSON. fetch defaults a string body to `text/plain;charset=UTF-8`
+            // when no `content-type` is set, which is a safer default than misclaiming JSON.
+            typeof body === 'string' ||
+            // `Blob` is superset of `File`
+            (globalThis.Blob && body instanceof globalThis.Blob) ||
+            // `FormData` -> `multipart/form-data`
+            body instanceof FormData ||
+            // `URLSearchParams` -> `application/x-www-form-urlencoded`
+            body instanceof URLSearchParams ||
+            // Send chunked stream (each chunk has own `length`)
+            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
+            return { bodyHeaders: undefined, body: body };
+        }
+        else if (typeof body === 'object' &&
+            (Symbol.asyncIterator in body ||
+                (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
+            return { bodyHeaders: undefined, body: Shims.ReadableStreamFrom(body) };
+        }
+        else if (typeof body === 'object' &&
+            headers.values.get('content-type') === 'application/x-www-form-urlencoded') {
+            return {
+                bodyHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: this.stringifyQuery(body),
+            };
+        }
+        else {
+            return this.#encoder({ body, headers });
+        }
+    }
+    validateAuth(url, headers, options) {
+        if (headers.has('Authorization'))
+            return;
+        if (headerExplicitlyOmitted(options.headers, 'Authorization'))
+            return;
+        throw new Errors.AuthenticationError(401, undefined, 'Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted', headers);
+    }
+    authHeadersSync() {
+        const headers = {};
+        const apiKey = this.resolveAuthOptionSync('apiKey', this.apiKey);
+        if (apiKey)
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        return headers;
+    }
+    webSocketAuthHeaders() {
+        const apiKey = this.resolveAuthOptionSync('apiKey', this.apiKey);
+        if (apiKey)
+            return { Authorization: `Bearer ${apiKey}` };
+        return {};
+    }
+    async authHeaders(opts) {
+        const apiKey = await this.resolveAuthOption('apiKey', this.apiKey);
+        if (apiKey == null) {
+            return undefined;
+        }
+        return (0, headers_1.buildHeaders)([{ Authorization: `Bearer ${apiKey}` }]);
+    }
+    async authQueryAsync() {
+        const query = {};
+        return query;
+    }
+    async authCookiesAsync() {
+        const cookies = {};
+        return cookies;
+    }
+    async resolveAuthOption(optionName, value) {
+        if (value == null)
+            return undefined;
+        const token = typeof value === 'function' ? await value() : value;
+        if (!token)
+            throw new Errors.TemboError(`Expected '${optionName}' to resolve to a non-empty string.`);
+        return token;
+    }
+    resolveAuthOptionSync(optionName, value) {
+        if (value == null)
+            return undefined;
+        const token = typeof value === 'function' ? value() : value;
+        if (typeof token !== 'string' || !token)
+            throw new Errors.TemboError(`Expected '${optionName}' to resolve to a non-empty string.`);
+        return token;
+    }
+    static Tembo = this;
+    static DEFAULT_TIMEOUT = 60000; // 1 minute
+    static TemboError = Errors.TemboError;
+    static APIError = Errors.APIError;
+    static APIConnectionError = Errors.APIConnectionError;
+    static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
+    static APIUserAbortError = Errors.APIUserAbortError;
+    static NotFoundError = Errors.NotFoundError;
+    static ConflictError = Errors.ConflictError;
+    static RateLimitError = Errors.RateLimitError;
+    static BadRequestError = Errors.BadRequestError;
+    static AuthenticationError = Errors.AuthenticationError;
+    static InternalServerError = Errors.InternalServerError;
+    static PermissionDeniedError = Errors.PermissionDeniedError;
+    static UnprocessableEntityError = Errors.UnprocessableEntityError;
+    static toFile = uploads_1.toFile;
+    apiKeys = new api_keys_1.APIKeys(this);
+    skills = new skills_1.Skills(this);
+    insights = new insights_1.Insights(this);
+    organizations = new organizations_1.Organizations(this);
+    mcpConnections = new mcp_connections_1.McpConnections(this);
+    artifacts = new artifacts_1.Artifacts(this);
+    messages = new messages_1.Messages(this);
+    models = new models_1.Models(this);
+    users = new users_1.Users(this);
+    sessions = new sessions_1.Sessions(this);
+    projects = new projects_1.Projects(this);
+    pullRequests = new pull_requests_1.PullRequests(this);
+    agents = new agents_1.Agents(this);
+    repositories = new repositories_1.Repositories(this);
+    integrations = new integrations_1.Integrations(this);
+    billing = new billing_1.Billing(this);
+}
+exports.Tembo = Tembo;
+Tembo.APIKeys = api_keys_1.APIKeys;
+Tembo.Skills = skills_1.Skills;
+Tembo.Insights = insights_1.Insights;
+Tembo.Organizations = organizations_1.Organizations;
+Tembo.McpConnections = mcp_connections_1.McpConnections;
+Tembo.Artifacts = artifacts_1.Artifacts;
+Tembo.Messages = messages_1.Messages;
+Tembo.Models = models_1.Models;
+Tembo.Users = users_1.Users;
+Tembo.Sessions = sessions_1.Sessions;
+Tembo.Projects = projects_1.Projects;
+Tembo.PullRequests = pull_requests_1.PullRequests;
+Tembo.Agents = agents_1.Agents;
+Tembo.Repositories = repositories_1.Repositories;
+Tembo.Integrations = integrations_1.Integrations;
+Tembo.Billing = billing_1.Billing;
+const headerExplicitlyOmitted = (source, name) => {
+    if (!source || Array.isArray(source) || source instanceof Headers)
+        return false;
+    const target = name.toLowerCase();
+    return Object.entries(source).some(([key, value]) => key.toLowerCase() === target && value === null);
+};
+const appendAuthCookies = (headers, cookies) => {
+    for (const [name, value] of Object.entries(cookies)) {
+        if (cookieHeaderHas(headers.get('Cookie'), name))
+            continue;
+        const cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value);
+        const existing = headers.get('Cookie');
+        headers.set('Cookie', existing ? existing + '; ' + cookie : cookie);
+    }
+};
+const cookieHeaderHas = (value, name) => {
+    if (!value)
+        return false;
+    const target = encodeURIComponent(name) + '=';
+    return value.split(';').some((cookie) => cookie.trim().startsWith(target));
+};
+//# sourceMappingURL=client.js.map