@nexface/agent 0.1.1-alpha.0

package/dist/models/_chunks/879-7e580bb2.js

@@ -0,0 +1,1189 @@
+
+
+
+
+
+
+
+function mergeHeaders(base, override) {
+    if (!base && !override)
+        return undefined;
+    const merged = { ...base };
+    for (const [name, value] of Object.entries(override ?? {})) {
+        const lowerName = name.toLowerCase();
+        for (const existingName of Object.keys(merged)) {
+            if (existingName.toLowerCase() === lowerName)
+                delete merged[existingName];
+        }
+        merged[name] = value;
+    }
+    return merged;
+}
+class ModelsImpl {
+    providers = new Map();
+    credentials;
+    modelsStore;
+    authContext;
+    refreshGenerations = new Map();
+    refreshControllers = new Map();
+    publicationChains = new Map();
+    constructor(options) {
+        this.credentials = options?.credentials ?? new InMemoryCredentialStore();
+        this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore();
+        this.authContext = options?.authContext ?? defaultAuthContext();
+    }
+    setProvider(provider) {
+        this.supersedeProviderRefresh(provider.id);
+        this.providers.set(provider.id, provider);
+    }
+    deleteProvider(id) {
+        this.supersedeProviderRefresh(id);
+        this.providers.delete(id);
+    }
+    clearProviders() {
+        for (const id of new Set([...this.providers.keys(), ...this.refreshControllers.keys()])) {
+            this.supersedeProviderRefresh(id);
+        }
+        this.providers.clear();
+    }
+    getProviders() {
+        return Array.from(this.providers.values());
+    }
+    getProvider(id) {
+        return this.providers.get(id);
+    }
+    getModels(provider) {
+        if (provider !== undefined) {
+            const entry = this.providers.get(provider);
+            if (!entry)
+                return [];
+            try {
+                return entry.getModels();
+            }
+            catch {
+                return [];
+            }
+        }
+        const models = [];
+        for (const entry of this.providers.values()) {
+            try {
+                models.push(...entry.getModels());
+            }
+            catch {
+                // Best-effort: ill-behaved providers yield no models.
+            }
+        }
+        return models;
+    }
+    getModel(provider, id) {
+        return this.getModels(provider).find((model) => model.id === id);
+    }
+    supersedeProviderRefresh(providerId) {
+        const generation = (this.refreshGenerations.get(providerId) ?? 0) + 1;
+        this.refreshGenerations.set(providerId, generation);
+        const previous = this.refreshControllers.get(providerId);
+        if (previous) {
+            this.refreshControllers.delete(providerId);
+            previous.abort();
+        }
+        return generation;
+    }
+    beginProviderRefresh(providerId) {
+        const generation = this.supersedeProviderRefresh(providerId);
+        const controller = new AbortController();
+        this.refreshControllers.set(providerId, controller);
+        return { generation, controller };
+    }
+    publishProviderModels(providerId, generation, signal, publication) {
+        const previous = this.publicationChains.get(providerId) ?? Promise.resolve();
+        const queued = (async () => {
+            await previous.catch(() => { });
+            if (signal.aborted || this.refreshGenerations.get(providerId) !== generation)
+                return false;
+            if (publication.persist === null) {
+                await this.modelsStore.delete(providerId, { signal });
+            }
+            else if (publication.persist !== undefined) {
+                await this.modelsStore.write(providerId, structuredClone(publication.persist), { signal });
+            }
+            if (signal.aborted || this.refreshGenerations.get(providerId) !== generation)
+                return false;
+            publication.update?.();
+            return true;
+        })();
+        const tail = queued.catch(() => { });
+        this.publicationChains.set(providerId, tail);
+        void tail.then(() => {
+            if (this.publicationChains.get(providerId) === tail)
+                this.publicationChains.delete(providerId);
+        });
+        return raceWithAbortSignal(queued, signal);
+    }
+    async runProviderRefreshPhase(provider, credential, allowNetwork, force, generation, signal) {
+        const stored = await this.modelsStore.read(provider.id, { signal });
+        await provider.refreshModels({
+            credential,
+            stored: stored ? structuredClone(stored) : undefined,
+            publish: (publication) => this.publishProviderModels(provider.id, generation, signal, publication),
+            allowNetwork,
+            force: allowNetwork ? force : undefined,
+            signal,
+        });
+    }
+    async refresh(options = {}) {
+        const allowNetwork = options.allowNetwork ?? true;
+        const callerSignal = operationSignal(options.signal);
+        const errors = new Map();
+        if (callerSignal.aborted)
+            return { aborted: true, errors };
+        const selected = options.providers ? new Set(options.providers) : undefined;
+        const refreshable = Array.from(this.providers.values()).filter((provider) => provider.refreshModels !== undefined && (!selected || selected.has(provider.id)));
+        const refresh = Promise.all(refreshable.map(async (provider) => {
+            const { generation, controller } = this.beginProviderRefresh(provider.id);
+            const signal = AbortSignal.any([callerSignal, controller.signal]);
+            const operation = (async () => {
+                let storedCredential;
+                let credentialError;
+                try {
+                    storedCredential = await this.readCredential(provider.id, signal);
+                }
+                catch (error) {
+                    credentialError = error;
+                }
+                // Restore cached provider state before auth resolution or network access.
+                await this.runProviderRefreshPhase(provider, storedCredential, false, undefined, generation, signal);
+                if (credentialError !== undefined)
+                    throw credentialError;
+                if (!allowNetwork || signal.aborted)
+                    return;
+                const credential = await this.resolveRefreshCredential(provider, storedCredential, signal);
+                if (!credential)
+                    return;
+                await this.runProviderRefreshPhase(provider, credential, true, options.force, generation, signal);
+            })();
+            try {
+                await raceWithAbortSignal(operation, signal);
+            }
+            catch (error) {
+                if (!signal.aborted) {
+                    errors.set(provider.id, error instanceof Error
+                        ? error
+                        : new ModelsError("model_source", `Model refresh failed for ${provider.id}`, { cause: error }));
+                }
+            }
+            finally {
+                if (this.refreshControllers.get(provider.id) === controller) {
+                    this.refreshControllers.delete(provider.id);
+                }
+            }
+        }));
+        try {
+            await raceWithAbortSignal(refresh, callerSignal);
+        }
+        catch (error) {
+            if (!callerSignal.aborted)
+                throw error;
+        }
+        return { aborted: callerSignal.aborted, errors: new Map(errors) };
+    }
+    async resolveRefreshCredential(provider, stored, signal) {
+        if (stored?.type === "oauth") {
+            const oauth = provider.auth.oauth;
+            if (!oauth)
+                return undefined;
+            if (Date.now() < stored.expires)
+                return stored;
+            if (signal.aborted)
+                return undefined;
+            const post = await this.credentials.modify(provider.id, async (current) => {
+                if (current?.type !== "oauth" || Date.now() < current.expires)
+                    return undefined;
+                return oauth.refresh(current, signal);
+            }, { signal });
+            return post?.type === "oauth" ? post : undefined;
+        }
+        const apiKey = provider.auth.apiKey;
+        if (!apiKey)
+            return undefined;
+        const credential = stored?.type === "api_key" ? stored : undefined;
+        const result = await apiKey.resolve({ ctx: this.authContext, credential, signal });
+        if (!result)
+            return undefined;
+        return { type: "api_key", key: result.auth.apiKey, env: result.env };
+    }
+    async readCredential(providerId, signal) {
+        try {
+            return await this.credentials.read(providerId, { signal });
+        }
+        catch (error) {
+            throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
+        }
+    }
+    async checkProviderAuth(provider, credential, signal) {
+        if (credential?.type === "oauth") {
+            return provider.auth.oauth ? { source: "OAuth", type: "oauth" } : undefined;
+        }
+        const apiKey = provider.auth.apiKey;
+        if (!apiKey)
+            return undefined;
+        if (apiKey.check) {
+            try {
+                return await apiKey.check({
+                    ctx: this.authContext,
+                    credential: credential?.type === "api_key" ? credential : undefined,
+                    signal,
+                });
+            }
+            catch (error) {
+                throw new ModelsError("auth", `API key auth check failed for provider ${provider.id}`, { cause: error });
+            }
+        }
+        const resolution = await resolveProviderAuth(provider, this.credentials, this.authContext, { signal });
+        return resolution ? { source: resolution.source, type: "api_key" } : undefined;
+    }
+    checkAuth(providerId, options) {
+        const signal = operationSignal(options?.signal);
+        const check = (async () => {
+            signal.throwIfAborted();
+            const provider = this.providers.get(providerId);
+            if (!provider)
+                return undefined;
+            return this.checkProviderAuth(provider, await this.readCredential(providerId, signal), signal);
+        })();
+        return raceWithAbortSignal(check, signal);
+    }
+    getAvailable(providerId, options) {
+        const signal = operationSignal(options?.signal);
+        const available = (async () => {
+            signal.throwIfAborted();
+            const providers = providerId
+                ? [this.providers.get(providerId)].filter((entry) => entry !== undefined)
+                : this.getProviders();
+            const checks = await Promise.all(providers.map(async (provider) => {
+                const credential = await this.readCredential(provider.id, signal);
+                return { provider, credential, auth: await this.checkProviderAuth(provider, credential, signal) };
+            }));
+            return checks.flatMap(({ provider, credential, auth }) => {
+                if (!auth)
+                    return [];
+                const models = provider.getModels();
+                return provider.filterModels?.(models, credential) ?? models;
+            });
+        })();
+        return raceWithAbortSignal(available, signal);
+    }
+    async getAuth(providerOrModel, overrides) {
+        const signal = operationSignal(overrides?.signal);
+        const providerId = typeof providerOrModel === "string" ? providerOrModel : providerOrModel.provider;
+        const provider = this.providers.get(providerId);
+        if (!provider)
+            return undefined;
+        const result = await resolveProviderAuth(provider, this.credentials, this.authContext, { ...overrides, signal });
+        if (!result || typeof providerOrModel === "string" || !providerOrModel.headers)
+            return result;
+        return {
+            ...result,
+            auth: {
+                ...result.auth,
+                headers: mergeHeaders(result.auth.headers, providerOrModel.headers),
+            },
+        };
+    }
+    async login(providerId, type, interaction) {
+        const signal = operationSignal(interaction.signal);
+        signal.throwIfAborted();
+        const provider = this.providers.get(providerId);
+        if (!provider)
+            throw new ModelsError("provider", `Unknown provider: ${providerId}`);
+        const method = type === "oauth" ? provider.auth.oauth : provider.auth.apiKey;
+        if (!method?.login) {
+            throw new ModelsError("auth", `${provider.name} does not support ${type} login`);
+        }
+        const loginOperation = method.login({ ...interaction, signal });
+        const credential = await raceWithAbortSignal(loginOperation, signal);
+        let mutationStarted = false;
+        let markMutationStarted;
+        const started = new Promise((resolve) => {
+            markMutationStarted = resolve;
+        });
+        const mutation = this.credentials.modify(providerId, async () => {
+            mutationStarted = true;
+            markMutationStarted?.();
+            return credential;
+        }, { signal });
+        void mutation.catch(() => { });
+        try {
+            await new Promise((resolve, reject) => {
+                const onAbort = () => {
+                    if (!mutationStarted)
+                        reject(signal.reason);
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                void Promise.race([started, mutation]).then(() => {
+                    signal.removeEventListener("abort", onAbort);
+                    resolve();
+                }, (error) => {
+                    signal.removeEventListener("abort", onAbort);
+                    reject(error);
+                });
+                if (signal.aborted)
+                    onAbort();
+            });
+            await mutation;
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            throw new ModelsError("auth", `Credential store modify failed for ${providerId}`, { cause: error });
+        }
+        return credential;
+    }
+    async logout(providerId, options) {
+        const signal = operationSignal(options?.signal);
+        signal.throwIfAborted();
+        try {
+            await this.credentials.delete(providerId, { signal });
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            throw new ModelsError("auth", `Credential store delete failed for ${providerId}`, { cause: error });
+        }
+    }
+    requireProvider(model) {
+        const provider = this.providers.get(model.provider);
+        if (!provider) {
+            throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
+        }
+        return provider;
+    }
+    async applyAuth(model, options) {
+        this.requireProvider(model);
+        const resolution = await this.getAuth(model, {
+            apiKey: options?.apiKey,
+            env: options?.env,
+            signal: options?.signal,
+        });
+        if (!resolution) {
+            throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
+        }
+        const auth = resolution.auth;
+        // Explicit request options win per-field; the Models-only transform runs last.
+        const apiKey = options?.apiKey ?? auth.apiKey;
+        let headers = mergeHeaders(auth.headers, options?.headers);
+        if (options?.transformHeaders)
+            headers = await options.transformHeaders(headers ?? {});
+        const env = resolution.env || options?.env ? { ...(resolution.env ?? {}), ...(options?.env ?? {}) } : undefined;
+        const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+        const { transformHeaders: _transformHeaders, ...providerOptions } = options ?? {};
+        const requestOptions = { ...providerOptions, apiKey, headers, env };
+        return { requestModel, requestOptions };
+    }
+    stream(model, context, options) {
+        return lazyStream(model, async () => {
+            const provider = this.requireProvider(model);
+            const { requestModel, requestOptions } = await this.applyAuth(model, options);
+            return provider.stream(requestModel, context, requestOptions);
+        });
+    }
+    async complete(model, context, options) {
+        return this.stream(model, context, options).result();
+    }
+    streamSimple(model, context, options) {
+        return lazyStream(model, async () => {
+            const provider = this.requireProvider(model);
+            const { requestModel, requestOptions } = await this.applyAuth(model, options);
+            return provider.streamSimple(requestModel, context, requestOptions);
+        });
+    }
+    async completeSimple(model, context, options) {
+        return this.streamSimple(model, context, options).result();
+    }
+    async fetchDeferred(model, handle, options) {
+        return lazyStream(model, async () => {
+            const provider = this.requireProvider(model);
+            if (!provider.fetchDeferred) {
+                throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
+            }
+            const { requestModel, requestOptions } = await this.applyAuth(model, options);
+            return provider.fetchDeferred(requestModel, handle, requestOptions);
+        }).result();
+    }
+    async cancelDeferred(model, handle, options) {
+        const provider = this.requireProvider(model);
+        if (!provider.cancelDeferred) {
+            throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
+        }
+        const { requestModel, requestOptions } = await this.applyAuth(model, options);
+        await provider.cancelDeferred(requestModel, handle, requestOptions);
+    }
+}
+function createModels(options) {
+    return new ModelsImpl(options);
+}
+/**
+ * Builds a provider from parts. Built-in provider factories and models.json
+ * custom providers both go through this. A single `api` streams all models;
+ * an `api` map dispatches on `model.api`, and a model whose api has no entry
+ * produces a stream error.
+ */
+function createProvider(input) {
+    const baselineModels = input.models;
+    let dynamicModels = [];
+    const fetchModels = input.fetchModels;
+    const currentModels = () => {
+        const merged = [...baselineModels];
+        for (const model of dynamicModels) {
+            const index = merged.findIndex((entry) => entry.id === model.id);
+            if (index >= 0)
+                merged[index] = model;
+            else
+                merged.push(model);
+        }
+        return merged;
+    };
+    const single = typeof input.api.stream === "function" ? input.api : undefined;
+    const byApi = single ? undefined : input.api;
+    const apiFor = (model) => single ?? byApi?.[model.api];
+    const dispatch = (model, run) => {
+        const streams = apiFor(model);
+        if (!streams) {
+            return lazyStream(model, async () => {
+                throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+            });
+        }
+        return run(streams);
+    };
+    const provider = {
+        id: input.id,
+        name: input.name ?? input.id,
+        baseUrl: input.baseUrl,
+        headers: input.headers,
+        auth: input.auth,
+        getModels: currentModels,
+        refreshModels: fetchModels
+            ? async (context) => {
+                if (context.stored) {
+                    const restored = context.stored.models
+                        .filter((model) => model.provider === input.id)
+                        .map((model) => model);
+                    if (!(await context.publish({
+                        update: () => {
+                            dynamicModels = restored;
+                        },
+                    }))) {
+                        return;
+                    }
+                }
+                if (!context.allowNetwork || context.signal.aborted)
+                    return;
+                const refreshed = await fetchModels(context);
+                if (context.signal.aborted)
+                    return;
+                await context.publish({
+                    persist: { models: refreshed, checkedAt: Date.now() },
+                    update: () => {
+                        dynamicModels = refreshed;
+                    },
+                });
+            }
+            : undefined,
+        filterModels: input.filterModels,
+        stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
+        streamSimple: (model, context, options) => dispatch(model, (streams) => streams.streamSimple(model, context, options)),
+    };
+    const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== undefined);
+    if (streams.some((entry) => entry.fetchDeferred !== undefined)) {
+        provider.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+            const implementation = apiFor(model);
+            if (!implementation?.fetchDeferred) {
+                throw new ModelsError("provider", `Provider ${input.id} does not support deferred responses for "${model.api}"`);
+            }
+            return implementation.fetchDeferred(model, handle, options);
+        });
+    }
+    if (streams.some((entry) => entry.cancelDeferred !== undefined)) {
+        provider.cancelDeferred = async (model, handle, options) => {
+            const implementation = apiFor(model);
+            if (!implementation?.cancelDeferred) {
+                throw new ModelsError("provider", `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`);
+            }
+            await implementation.cancelDeferred(model, handle, options);
+        };
+    }
+    return provider;
+}
+/**
+ * Runtime-checked narrowing for dynamically looked-up models:
+ *
+ * ```ts
+ * const model = models.getModel("anthropic", "claude-opus-4-7");
+ * if (model && hasApi(model, "anthropic-messages")) {
+ *   // model: Model<"anthropic-messages">, stream options fully typed
+ * }
+ * ```
+ */
+function hasApi(model, api) {
+    return model.api === api;
+}
+function calculateCost(model, usage) {
+    const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+    let rates = model.cost;
+    let matchedThreshold = -1;
+    for (const tier of model.cost.tiers ?? []) {
+        if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+            rates = tier;
+            matchedThreshold = tier.inputTokensAbove;
+        }
+    }
+    // Anthropic charges 2x base input for 1h cache writes.
+    const longWrite = usage.cacheWrite1h ?? 0;
+    const shortWrite = usage.cacheWrite - longWrite;
+    usage.cost.input = (rates.input / 1000000) * usage.input;
+    usage.cost.output = (rates.output / 1000000) * usage.output;
+    usage.cost.cacheRead = (rates.cacheRead / 1000000) * usage.cacheRead;
+    usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1000000;
+    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+    return usage.cost;
+}
+const EXTENDED_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+function getSupportedThinkingLevels(model) {
+    if (!model.reasoning)
+        return ["off"];
+    return EXTENDED_THINKING_LEVELS.filter((level) => {
+        const mapped = model.thinkingLevelMap?.[level];
+        if (mapped === null)
+            return false;
+        if (level === "xhigh" || level === "max")
+            return mapped !== undefined;
+        return true;
+    });
+}
+function clampThinkingLevel(model, level) {
+    const availableLevels = getSupportedThinkingLevels(model);
+    if (availableLevels.includes(level))
+        return level;
+    const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+    if (requestedIndex === -1)
+        return availableLevels[0] ?? "off";
+    for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
+        const candidate = EXTENDED_THINKING_LEVELS[i];
+        if (availableLevels.includes(candidate))
+            return candidate;
+    }
+    for (let i = requestedIndex - 1; i >= 0; i--) {
+        const candidate = EXTENDED_THINKING_LEVELS[i];
+        if (availableLevels.includes(candidate))
+            return candidate;
+    }
+    return availableLevels[0] ?? "off";
+}
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+function modelsAreEqual(a, b) {
+    if (!a || !b)
+        return false;
+    return a.id === b.id && a.provider === b.provider;
+}
+//# sourceMappingURL=models.js.map
+function headersToRecord(headers) {
+    const result = {};
+    for (const [key, value] of headers.entries()) {
+        result[key] = value;
+    }
+    return result;
+}
+function providerHeadersToRecord(headers) {
+    if (!headers)
+        return undefined;
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value !== null)
+            result[key] = value;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+//# sourceMappingURL=headers.js.map
+const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
+function isProviderError(error) {
+    if (!(error instanceof Error) || !("status" in error) || !("headers" in error))
+        return false;
+    return ((error.status === undefined || typeof error.status === "number") &&
+        (error.headers === undefined || error.headers instanceof Headers));
+}
+/** Mirrors the pinned OpenAI/Anthropic SDK retry policy; review when either SDK is upgraded. */
+function isRetryableProviderError(error) {
+    const shouldRetry = error.headers?.get("x-should-retry");
+    if (shouldRetry === "true")
+        return true;
+    if (shouldRetry === "false")
+        return false;
+    if (error.status === undefined)
+        return true;
+    return (error.status === 408 ||
+        error.status === 409 ||
+        error.status === 429 ||
+        (typeof error.status === "number" && error.status >= 500));
+}
+function validateServerRetryDelayMs(delayMs, maxRetryDelayMs, providerErrorMessage) {
+    const maxDelayMs = maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+    if (maxDelayMs > 0 && delayMs > maxDelayMs) {
+        throw new Error(`Server requested ${Math.ceil(delayMs / 1000)}s retry delay (max: ${Math.ceil(maxDelayMs / 1000)}s). ${providerErrorMessage}`);
+    }
+    return delayMs;
+}
+function getRetryDelayMs(error, retryIndex, maxRetryDelayMs) {
+    const retryAfterMs = error.headers?.get("retry-after-ms");
+    if (retryAfterMs) {
+        const value = Number.parseFloat(retryAfterMs);
+        if (!Number.isNaN(value))
+            return validateServerRetryDelayMs(value, maxRetryDelayMs, error.message);
+    }
+    const retryAfter = error.headers?.get("retry-after");
+    if (retryAfter) {
+        const seconds = Number.parseFloat(retryAfter);
+        const delayMs = Number.isNaN(seconds) ? Date.parse(retryAfter) - Date.now() : seconds * 1000;
+        return validateServerRetryDelayMs(delayMs, maxRetryDelayMs, error.message);
+    }
+    const exponentialDelay = Math.min(0.5 * 2 ** retryIndex, 8) * 1000;
+    return exponentialDelay * (1 - Math.random() * 0.25);
+}
+function createAbortError() {
+    const error = new Error("Request aborted");
+    error.name = "AbortError";
+    return error;
+}
+function abortableSleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(createAbortError());
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(createAbortError());
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, Math.max(0, ms));
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/**
+ * Reproduce the retry behavior used by the OpenAI and Anthropic SDKs while making
+ * their backoff sleep interruptible. Their built-in retry timers ignore the
+ * request AbortSignal, so callers must invoke the SDK with `maxRetries: 0` and
+ * wrap the request with this helper. Provider-requested delays above
+ * `maxRetryDelayMs` fail immediately (60 seconds by default); set it to zero to
+ * disable the limit.
+ */
+async function retryProviderRequest(request, options = {}) {
+    const maxRetries = options.maxRetries ?? 0;
+    let retriesRemaining = maxRetries;
+    for (;;) {
+        try {
+            // Each retry is a fresh SDK request, so X-Stainless-Retry-Count remains zero.
+            return await request();
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw createAbortError();
+            if (retriesRemaining <= 0 || !isProviderError(error) || !isRetryableProviderError(error))
+                throw error;
+            const retryIndex = maxRetries - retriesRemaining;
+            retriesRemaining--;
+            await abortableSleep(getRetryDelayMs(error, retryIndex, options.maxRetryDelayMs), options.signal);
+        }
+    }
+}
+//# sourceMappingURL=provider-retry.js.map
+/**
+ * Removes unpaired Unicode surrogate characters from a string.
+ *
+ * Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
+ * or vice versa) cause JSON serialization errors in many API providers.
+ *
+ * Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
+ * surrogates and will NOT be affected by this function.
+ *
+ * @param text - The text to sanitize
+ * @returns The sanitized text with unpaired surrogates removed
+ *
+ * @example
+ * // Valid emoji (properly paired surrogates) are preserved
+ * sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
+ *
+ * // Unpaired high surrogate is removed
+ * const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
+ * sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
+ */
+function sanitizeSurrogates(text) {
+    // Replace unpaired high surrogates (0xD800-0xDBFF not followed by low surrogate)
+    // Replace unpaired low surrogates (0xDC00-0xDFFF not preceded by high surrogate)
+    return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+//# sourceMappingURL=sanitize-unicode.js.map
+function getGrammarToolInput(toolName, arguments_, inputProperty) {
+    const input = arguments_[inputProperty];
+    if (typeof input !== "string") {
+        throw new Error(`Grammar tool call "${toolName}" requires argument "${inputProperty}" to be a string.`);
+    }
+    return input;
+}
+function appendGrammarToolInputJsonDelta(buffer, inputProperty, nextInput, close) {
+    if (buffer.closed) {
+        if (close && nextInput === buffer.input)
+            return undefined;
+        throw new Error(`grammar tool input for property "${inputProperty}" changed after it was closed`);
+    }
+    if (!nextInput.startsWith(buffer.input)) {
+        throw new Error(`grammar tool input for property "${inputProperty}" changed non-monotonically`);
+    }
+    const inputDelta = nextInput.slice(buffer.input.length);
+    if (!close && inputDelta.length === 0)
+        return undefined;
+    let delta = "";
+    if (!buffer.started) {
+        delta += `{${JSON.stringify(inputProperty)}:"`;
+        buffer.started = true;
+    }
+    delta += JSON.stringify(inputDelta).slice(1, -1);
+    buffer.input = nextInput;
+    if (close) {
+        delta += '"}';
+        buffer.closed = true;
+    }
+    return delta;
+}
+function inferGrammarInputProperty(tool) {
+    const schema = tool.parameters;
+    if (schema.type !== "object") {
+        throw new Error("grammar constrained sampling requires an object parameter schema");
+    }
+    if (!Array.isArray(schema.required) || schema.required.length !== 1 || typeof schema.required[0] !== "string") {
+        throw new Error("grammar constrained sampling requires exactly one required string property");
+    }
+    const inputProperty = schema.required[0];
+    if (!schema.properties?.[inputProperty]) {
+        throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+    }
+    if (schema.properties[inputProperty]?.type !== "string") {
+        throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+    }
+    return inputProperty;
+}
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+    const config = tool.constrainedSampling;
+    if (!config || config.type !== "json_schema") {
+        return undefined;
+    }
+    if (supportsStrictMode) {
+        return true;
+    }
+    if (config.strict === "require") {
+        throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+    }
+    return undefined;
+}
+function resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools) {
+    const config = tool.constrainedSampling;
+    if (!config || config.type !== "grammar") {
+        return undefined;
+    }
+    if (!supportsOpenAIGrammarTools) {
+        return undefined;
+    }
+    const larkDefinition = config.variants.openai_lark;
+    const regexDefinition = config.variants.openai_regex;
+    const hasLarkDefinition = typeof larkDefinition === "string" && larkDefinition.trim().length > 0;
+    const hasRegexDefinition = typeof regexDefinition === "string" && regexDefinition.trim().length > 0;
+    if (!hasLarkDefinition && !hasRegexDefinition) {
+        throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+    }
+    try {
+        return {
+            format: hasLarkDefinition ? "lark" : "regex",
+            definition: hasLarkDefinition ? larkDefinition : regexDefinition,
+            inputProperty: inferGrammarInputProperty(tool),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+    }
+}
+function createGrammarToolInputProperties(tools, supportsOpenAIGrammarTools) {
+    const properties = new Map();
+    for (const tool of tools ?? []) {
+        const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+        if (grammar) {
+            properties.set(tool.name, grammar.inputProperty);
+        }
+    }
+    return properties;
+}
+//# sourceMappingURL=constrained-sampling.js.map
+const CHARS_PER_TOKEN = 4;
+const ESTIMATED_IMAGE_CHARS = 4800;
+function calculateContextTokens(usage) {
+    return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value) ?? "undefined";
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+function estimateTextAndImageContentChars(content) {
+    if (typeof content === "string")
+        return content.length;
+    let chars = 0;
+    for (const block of content)
+        chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+    return chars;
+}
+function estimateTextTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateTextAndImageContentTokens(content) {
+    return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(message) {
+    let chars = 0;
+    if (message.role === "user")
+        return estimateTextAndImageContentTokens(message.content);
+    if (message.role === "toolResult")
+        return estimateTextAndImageContentTokens(message.content);
+    for (const block of message.content) {
+        if (block.type === "text") {
+            chars += block.text.length;
+        }
+        else if (block.type === "thinking") {
+            chars += block.thinking.length;
+        }
+        else {
+            chars += block.name.length + safeJsonStringify(block.arguments).length;
+        }
+    }
+    return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function getLastAssistantUsageInfo(messages) {
+    let latestPrefixTimestamp = Number.NEGATIVE_INFINITY;
+    let usageInfo;
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (message.role === "assistant") {
+            const assistant = message;
+            // A newer prefix message was inserted after this response (for example, a
+            // compaction summary), so its usage cannot describe the current prefix.
+            const usageAppliesToPrefix = assistant.timestamp >= latestPrefixTimestamp;
+            if (usageAppliesToPrefix &&
+                assistant.stopReason !== "aborted" &&
+                assistant.stopReason !== "error" &&
+                calculateContextTokens(assistant.usage) > 0) {
+                usageInfo = { usage: assistant.usage, index: i };
+            }
+        }
+        latestPrefixTimestamp = Math.max(latestPrefixTimestamp, message.timestamp);
+    }
+    return usageInfo;
+}
+function estimateMessages(messages) {
+    const usageInfo = getLastAssistantUsageInfo(messages);
+    if (usageInfo) {
+        const usageTokens = calculateContextTokens(usageInfo.usage);
+        let trailingTokens = 0;
+        for (let i = usageInfo.index + 1; i < messages.length; i++) {
+            trailingTokens += estimateMessageTokens(messages[i]);
+        }
+        return { tokens: usageTokens + trailingTokens, usageTokens, trailingTokens, lastUsageIndex: usageInfo.index };
+    }
+    let tokens = 0;
+    for (const message of messages)
+        tokens += estimateMessageTokens(message);
+    return { tokens, usageTokens: 0, trailingTokens: tokens, lastUsageIndex: null };
+}
+function estimateToolsTokens(tools) {
+    if (!tools || tools.length === 0)
+        return 0;
+    return estimateTextTokens(safeJsonStringify(tools));
+}
+function isMessageArray(value) {
+    return Array.isArray(value);
+}
+function estimateContextTokens(context) {
+    if (isMessageArray(context))
+        return estimateMessages(context);
+    const estimate = estimateMessages(context.messages);
+    if (estimate.lastUsageIndex !== null) {
+        const addedNames = new Set(context.messages
+            .slice(estimate.lastUsageIndex + 1)
+            .filter((message) => message.role === "toolResult")
+            .flatMap((message) => message.addedToolNames ?? []));
+        const addedToolTokens = estimateToolsTokens(context.tools?.filter((tool) => addedNames.has(tool.name)));
+        return {
+            tokens: estimate.tokens + addedToolTokens,
+            usageTokens: estimate.usageTokens,
+            trailingTokens: estimate.trailingTokens + addedToolTokens,
+            lastUsageIndex: estimate.lastUsageIndex,
+        };
+    }
+    const prefixTokens = (context.systemPrompt ? estimateTextTokens(context.systemPrompt) : 0) + estimateToolsTokens(context.tools);
+    return {
+        tokens: estimate.tokens + prefixTokens,
+        usageTokens: estimate.usageTokens,
+        trailingTokens: estimate.trailingTokens + prefixTokens,
+        lastUsageIndex: estimate.lastUsageIndex,
+    };
+}
+//# sourceMappingURL=estimate.js.map
+
+const CONTEXT_SAFETY_TOKENS = 4096;
+const MIN_MAX_TOKENS = 1;
+function clampMaxTokensToContext(model, context, maxTokens) {
+    if (model.contextWindow <= 0)
+        return Math.max(MIN_MAX_TOKENS, maxTokens);
+    const available = model.contextWindow - estimateContextTokens(context).tokens - CONTEXT_SAFETY_TOKENS;
+    return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
+}
+function buildBaseOptions(model, context, options, apiKey) {
+    const samplingParams = model.samplingParams || options?.samplingParams
+        ? { ...model.samplingParams, ...options?.samplingParams }
+        : undefined;
+    return {
+        temperature: options?.temperature,
+        samplingParams,
+        maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
+        signal: options?.signal,
+        telemetryContext: options?.telemetryContext,
+        apiKey: apiKey || options?.apiKey,
+        fetch: options?.fetch,
+        transport: options?.transport,
+        cacheRetention: options?.cacheRetention,
+        sessionId: options?.sessionId,
+        headers: options?.headers,
+        onPayload: options?.onPayload,
+        onResponse: options?.onResponse,
+        timeoutMs: options?.timeoutMs,
+        websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
+        maxRetries: options?.maxRetries,
+        maxRetryDelayMs: options?.maxRetryDelayMs,
+        metadata: options?.metadata,
+        env: options?.env,
+    };
+}
+/** Tokens always left for the answer when a thinking budget shares the response ceiling. */
+const MIN_ANSWER_TOKENS = 1024;
+function clampReasoning(effort) {
+    return effort === "xhigh" || effort === "max" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(
+// Undefined means no explicit caller cap. Use the model cap and fit thinking inside it.
+baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+    const defaultBudgets = {
+        minimal: 1024,
+        low: 2048,
+        medium: 8192,
+        high: 16384,
+    };
+    const budgets = { ...defaultBudgets, ...customBudgets };
+    const level = clampReasoning(reasoningLevel);
+    let thinkingBudget = budgets[level];
+    const maxTokens = baseMaxTokens === undefined ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+    if (maxTokens <= thinkingBudget) {
+        thinkingBudget = Math.max(0, maxTokens - MIN_ANSWER_TOKENS);
+    }
+    return { maxTokens, thinkingBudget };
+}
+//# sourceMappingURL=simple-options.js.map
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+    const result = [];
+    let previousWasPlaceholder = false;
+    for (const block of content) {
+        if (block.type === "image") {
+            if (!previousWasPlaceholder) {
+                result.push({ type: "text", text: placeholder });
+            }
+            previousWasPlaceholder = true;
+            continue;
+        }
+        result.push(block);
+        previousWasPlaceholder = block.text === placeholder;
+    }
+    return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+    if (model.input.includes("image")) {
+        return messages;
+    }
+    return messages.map((msg) => {
+        if (msg.role === "user" && Array.isArray(msg.content)) {
+            return {
+                ...msg,
+                content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER),
+            };
+        }
+        if (msg.role === "toolResult") {
+            return {
+                ...msg,
+                content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER),
+            };
+        }
+        return msg;
+    });
+}
+/**
+ * Normalize tool call ID for cross-provider compatibility.
+ * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+ * Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+ */
+function transformMessages(messages, model, normalizeToolCallId) {
+    // Build a map of original tool call IDs to normalized IDs
+    const toolCallIdMap = new Map();
+    // Normalize null/undefined content from untyped callers (custom tools, hand-built
+    // histories, old session files) so downstream code can rely on the type contract.
+    const normalizedMessages = messages.map((msg) => (msg.content == null ? { ...msg, content: [] } : msg));
+    const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
+    // First pass: transform messages (unsupported image downgrade, thinking blocks, tool call ID normalization)
+    const transformed = imageAwareMessages.map((msg) => {
+        // User messages pass through unchanged
+        if (msg.role === "user") {
+            return msg;
+        }
+        // Handle toolResult messages - normalize toolCallId if we have a mapping
+        if (msg.role === "toolResult") {
+            const normalizedId = toolCallIdMap.get(msg.toolCallId);
+            if (normalizedId && normalizedId !== msg.toolCallId) {
+                return { ...msg, toolCallId: normalizedId };
+            }
+            return msg;
+        }
+        // Assistant messages need transformation check
+        if (msg.role === "assistant") {
+            const assistantMsg = msg;
+            const isSameModel = assistantMsg.provider === model.provider &&
+                assistantMsg.api === model.api &&
+                assistantMsg.model === model.id;
+            const transformedContent = assistantMsg.content.flatMap((block) => {
+                if (block.type === "thinking") {
+                    // Redacted thinking is opaque encrypted content, only valid for the same model.
+                    // Drop it for cross-model to avoid API errors.
+                    if (block.redacted) {
+                        return isSameModel ? block : [];
+                    }
+                    // For same model: keep thinking blocks with signatures (needed for replay)
+                    // even if the thinking text is empty (OpenAI encrypted reasoning)
+                    if (isSameModel && block.thinkingSignature)
+                        return block;
+                    // Skip empty thinking blocks, convert others to plain text
+                    if (!block.thinking || block.thinking.trim() === "")
+                        return [];
+                    if (isSameModel)
+                        return block;
+                    return {
+                        type: "text",
+                        text: block.thinking,
+                    };
+                }
+                if (block.type === "text") {
+                    if (isSameModel)
+                        return block;
+                    return {
+                        type: "text",
+                        text: block.text,
+                    };
+                }
+                if (block.type === "toolCall") {
+                    const toolCall = block;
+                    let normalizedToolCall = toolCall;
+                    if (!isSameModel && toolCall.thoughtSignature) {
+                        normalizedToolCall = { ...toolCall };
+                        delete normalizedToolCall.thoughtSignature;
+                    }
+                    if (!isSameModel && normalizeToolCallId) {
+                        const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+                        if (normalizedId !== toolCall.id) {
+                            toolCallIdMap.set(toolCall.id, normalizedId);
+                            normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+                        }
+                    }
+                    return normalizedToolCall;
+                }
+                return block;
+            });
+            return {
+                ...assistantMsg,
+                content: transformedContent,
+            };
+        }
+        return msg;
+    });
+    // Second pass: insert synthetic empty tool results for orphaned tool calls
+    // This preserves thinking signatures and satisfies API requirements
+    const result = [];
+    let pendingToolCalls = [];
+    let existingToolResultIds = new Set();
+    const insertSyntheticToolResults = () => {
+        if (pendingToolCalls.length > 0) {
+            for (const tc of pendingToolCalls) {
+                if (!existingToolResultIds.has(tc.id)) {
+                    result.push({
+                        role: "toolResult",
+                        toolCallId: tc.id,
+                        toolName: tc.name,
+                        content: [{ type: "text", text: "No result provided" }],
+                        isError: true,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            pendingToolCalls = [];
+            existingToolResultIds = new Set();
+        }
+    };
+    for (let i = 0; i < transformed.length; i++) {
+        const msg = transformed[i];
+        if (msg.role === "assistant") {
+            // If we have pending orphaned tool calls from a previous assistant, insert synthetic results now
+            insertSyntheticToolResults();
+            // Skip errored/aborted assistant messages entirely.
+            // These are incomplete turns that shouldn't be replayed:
+            // - May have partial content (reasoning without message, incomplete tool calls)
+            // - Replaying them can cause API errors (e.g., OpenAI "reasoning without following item")
+            // - The model should retry from the last valid state
+            const assistantMsg = msg;
+            if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+                continue;
+            }
+            // Track tool calls from this assistant message
+            const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+            if (toolCalls.length > 0) {
+                pendingToolCalls = toolCalls;
+                existingToolResultIds = new Set();
+            }
+            result.push(msg);
+        }
+        else if (msg.role === "toolResult") {
+            existingToolResultIds.add(msg.toolCallId);
+            result.push(msg);
+        }
+        else if (msg.role === "user") {
+            // User message interrupts tool flow - insert synthetic results for orphaned calls
+            insertSyntheticToolResults();
+            result.push(msg);
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    // If the conversation ends with unresolved tool calls, synthesize results now.
+    insertSyntheticToolResults();
+    return result;
+}
+//# sourceMappingURL=transform-messages.js.map
+export { adjustMaxTokensForThinking, appendGrammarToolInputJsonDelta, buildBaseOptions, calculateCost, clampMaxTokensToContext, clampReasoning, clampThinkingLevel, createGrammarToolInputProperties, getGrammarToolInput, headersToRecord, providerHeadersToRecord, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, retryProviderRequest, sanitizeSurrogates, transformMessages };