@scuffi/gardener 0.1.1

package/assets/apps/gardener/dist/gardener_runtime/assets/json-parse-DCA_fvRV.js

@@ -0,0 +1,1094 @@
+import { t as __commonJSMin } from "./rolldown-runtime-7_rZTKki.js";
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/utils/event-stream.js
+var EventStream = class {
+	queue = [];
+	waiting = [];
+	done = false;
+	finalResultPromise;
+	resolveFinalResult;
+	isComplete;
+	extractResult;
+	constructor(isComplete, extractResult) {
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveFinalResult = resolve;
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) this.resolveFinalResult(result);
+		while (this.waiting.length > 0) this.waiting.shift()({
+			value: void 0,
+			done: true
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve) => this.waiting.push(resolve));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+};
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new Error("Unexpected event type for final result");
+		});
+	}
+};
+/** Factory function for AssistantMessageEventStream (for use in extensions) */
+function createAssistantMessageEventStream() {
+	return new AssistantMessageEventStream();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/api/lazy.js
+function createSetupErrorMessage(model, error) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+function hasResult(source) {
+	return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+	for await (const event of source) target.push(event);
+	target.end(hasResult(source) ? await source.result() : void 0);
+}
+/**
+* Returns a stream synchronously while running async setup (auth resolution,
+* lazy module loading) behind it. Setup failures terminate the stream with an
+* error event.
+*/
+function lazyStream(model, setup) {
+	const outer = new AssistantMessageEventStream();
+	setup().then((inner) => forwardStream(outer, inner)).catch((error) => {
+		const message = createSetupErrorMessage(model, error);
+		outer.push({
+			type: "error",
+			reason: "error",
+			error: message
+		});
+		outer.end(message);
+	});
+	return outer;
+}
+/**
+* Wraps a dynamically imported API implementation module as `ProviderStreams`.
+* The module loads on first stream call; the host's import cache deduplicates
+* loads. Load failures terminate the returned stream with an error event.
+*/
+function lazyApi(load) {
+	return {
+		stream: (model, context, options) => lazyStream(model, async () => (await load()).stream(model, context, options)),
+		streamSimple: (model, context, options) => lazyStream(model, async () => (await load()).streamSimple(model, context, options))
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/auth/context.js
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	return path;
+};
+var importNodeModule = (specifier) => import(__rewriteRelativeImportExtension(specifier));
+function getProcessEnv() {
+	return globalThis.process?.env;
+}
+/**
+* Default auth context: env vars from `process.env` (undefined in browsers),
+* file existence via node:fs (always false in browsers).
+*/
+function defaultProviderAuthContext() {
+	return {
+		async env(name) {
+			const value = getProcessEnv()?.[name];
+			return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+		},
+		async fileExists(path) {
+			try {
+				const fs = await importNodeModule("node:fs/promises");
+				let resolved = path;
+				if (resolved.startsWith("~")) resolved = (await importNodeModule("node:os")).homedir() + resolved.slice(1);
+				await fs.access(resolved);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/auth/credential-store.js
+/**
+* Default in-memory credential store. Apps inject persistent stores.
+* Keyed by `Provider.id`, one credential per provider; see `CredentialStore`.
+* Writes are serialized per provider through a promise chain.
+*/
+var InMemoryCredentialStore = class {
+	credentials = /* @__PURE__ */ new Map();
+	chains = /* @__PURE__ */ new Map();
+	/** Serialize tasks per provider id. */
+	enqueue(providerId, task) {
+		const previous = this.chains.get(providerId) ?? Promise.resolve();
+		const next = (async () => {
+			await previous.catch(() => {});
+			return task();
+		})();
+		this.chains.set(providerId, next.catch(() => {}));
+		return next;
+	}
+	async read(providerId) {
+		return this.credentials.get(providerId);
+	}
+	async list() {
+		return [...this.credentials].map(([providerId, credential]) => ({
+			providerId,
+			type: credential.type
+		}));
+	}
+	modify(providerId, fn) {
+		return this.enqueue(providerId, async () => {
+			const current = this.credentials.get(providerId);
+			const next = await fn(current);
+			if (next !== void 0) this.credentials.set(providerId, next);
+			return next ?? current;
+		});
+	}
+	delete(providerId) {
+		return this.enqueue(providerId, async () => {
+			this.credentials.delete(providerId);
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/utils/diagnostics.js
+function formatThrownValue(value) {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	return String(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/auth/resolve.js
+var ModelsError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(withCauseDetail(message, options?.cause), options);
+		this.name = "ModelsError";
+		this.code = code;
+	}
+};
+/** Callers surface `error.message` only, so keep the underlying reason in it. */
+function withCauseDetail(message, cause) {
+	if (cause === void 0 || cause === null) return message;
+	const detail = formatThrownValue(cause).trim();
+	if (!detail || message.includes(detail)) return message;
+	return `${message}: ${detail}`;
+}
+/**
+* Auth resolution shared by the `Models` and `ImagesModels` collections.
+* A stored credential owns the provider: ambient/env is consulted only when
+* nothing is stored. No silent env fallback after a failed refresh or for a
+* credential type without a matching handler.
+*/
+async function resolveProviderAuth(provider, credentials, authContext, overrides) {
+	const requestAuthContext = overrides?.env ? overlayEnvAuthContext(authContext, overrides.env) : authContext;
+	if (overrides?.apiKey !== void 0 && provider.auth.apiKey) return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, {
+		type: "api_key",
+		key: overrides.apiKey,
+		env: overrides.env
+	});
+	const stored = await readCredential(credentials, provider.id);
+	if (stored) {
+		if (stored.type === "oauth" && provider.auth.oauth) return resolveStoredOAuth(credentials, provider.id, provider.auth.oauth, stored, overrides?.minOAuthValidityMs);
+		if (stored.type === "api_key" && provider.auth.apiKey) {
+			const credential = overrides?.env ? {
+				...stored,
+				env: {
+					...stored.env,
+					...overrides.env
+				}
+			} : stored;
+			return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, credential);
+		}
+		return;
+	}
+	return provider.auth.apiKey ? resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, void 0) : void 0;
+}
+function overlayEnvAuthContext(base, env) {
+	return {
+		env: async (name) => env[name] || await base.env(name),
+		fileExists: (path) => base.fileExists(path)
+	};
+}
+var DEFAULT_OAUTH_MINIMUM_VALIDITY_MS = 3e5;
+/**
+* OAuth resolution with double-checked locking: tokens with less than five
+* minutes remaining lock, re-check expiry under the lock, refresh once
+* globally, and persist the rotated credential before release.
+*/
+async function resolveStoredOAuth(credentials, providerId, oauth, stored, minOAuthValidityMs) {
+	const minimumValidityMs = Math.max(DEFAULT_OAUTH_MINIMUM_VALIDITY_MS, minOAuthValidityMs ?? 0);
+	const expiresSoon = (credential) => Date.now() + minimumValidityMs >= credential.expires;
+	let credential = stored;
+	if (expiresSoon(credential)) {
+		let post;
+		try {
+			post = await credentials.modify(providerId, async (current) => {
+				if (current?.type !== "oauth") return void 0;
+				if (!expiresSoon(current)) return void 0;
+				try {
+					return await oauth.refresh(current);
+				} catch (error) {
+					throw new ModelsError("oauth", `OAuth refresh failed for ${providerId}`, { cause: error });
+				}
+			});
+		} catch (error) {
+			if (error instanceof ModelsError) throw error;
+			throw new ModelsError("auth", `Credential store modify failed for ${providerId}`, { cause: error });
+		}
+		if (post?.type !== "oauth") return void 0;
+		credential = post;
+		if (minOAuthValidityMs !== void 0 && expiresSoon(credential)) throw new ModelsError("oauth", `OAuth refresh returned a token that expires too soon for ${providerId}`);
+	}
+	try {
+		return {
+			auth: await oauth.toAuth(credential),
+			source: "OAuth"
+		};
+	} catch (error) {
+		throw new ModelsError("oauth", `OAuth auth derivation failed for ${providerId}`, { cause: error });
+	}
+}
+async function resolveApiKey(authContext, apiKey, providerId, credential) {
+	try {
+		return await apiKey.resolve({
+			ctx: authContext,
+			credential
+		});
+	} catch (error) {
+		throw new ModelsError("auth", `API key auth failed for provider ${providerId}`, { cause: error });
+	}
+}
+async function readCredential(credentials, providerId) {
+	try {
+		return await credentials.read(providerId);
+	} catch (error) {
+		throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/models-store.js
+var InMemoryModelsStore = class {
+	entries = /* @__PURE__ */ new Map();
+	async read(providerId) {
+		const entry = this.entries.get(providerId);
+		return entry ? structuredClone(entry) : void 0;
+	}
+	async write(providerId, entry) {
+		this.entries.set(providerId, structuredClone(entry));
+	}
+	async delete(providerId) {
+		this.entries.delete(providerId);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/models.js
+function mergeHeaders(base, override) {
+	if (!base && !override) return void 0;
+	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;
+}
+var ModelsImpl = class {
+	providers = /* @__PURE__ */ new Map();
+	credentials;
+	modelsStore;
+	authContext;
+	constructor(options) {
+		this.credentials = options?.credentials ?? new InMemoryCredentialStore();
+		this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore();
+		this.authContext = options?.authContext ?? defaultProviderAuthContext();
+	}
+	setProvider(provider) {
+		this.providers.set(provider.id, provider);
+	}
+	deleteProvider(id) {
+		this.providers.delete(id);
+	}
+	clearProviders() {
+		this.providers.clear();
+	}
+	getProviders() {
+		return Array.from(this.providers.values());
+	}
+	getProvider(id) {
+		return this.providers.get(id);
+	}
+	getModels(provider) {
+		if (provider !== void 0) {
+			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 {}
+		return models;
+	}
+	getModel(provider, id) {
+		return this.getModels(provider).find((model) => model.id === id);
+	}
+	async refresh(options = {}) {
+		const allowNetwork = options.allowNetwork ?? true;
+		const errors = /* @__PURE__ */ new Map();
+		const refreshable = Array.from(this.providers.values()).filter((provider) => provider.refreshModels !== void 0);
+		await Promise.all(refreshable.map(async (provider) => {
+			if (options.signal?.aborted) return;
+			const store = {
+				read: () => this.modelsStore.read(provider.id),
+				write: (entry) => this.modelsStore.write(provider.id, entry),
+				delete: () => this.modelsStore.delete(provider.id)
+			};
+			let stored;
+			try {
+				stored = await this.readCredential(provider.id);
+				const credential = await this.resolveRefreshCredential(provider, stored, allowNetwork, options.signal);
+				if (!credential) return;
+				await provider.refreshModels({
+					credential,
+					store,
+					allowNetwork,
+					force: options.force,
+					signal: options.signal
+				});
+			} catch (error) {
+				if (!options.signal?.aborted) errors.set(provider.id, error instanceof Error ? error : new ModelsError("model_source", `Model refresh failed for ${provider.id}`, { cause: error }));
+				try {
+					await provider.refreshModels({
+						credential: stored,
+						store,
+						allowNetwork: false,
+						signal: options.signal
+					});
+				} catch {}
+			}
+		}));
+		return {
+			aborted: options.signal?.aborted ?? false,
+			errors
+		};
+	}
+	async resolveRefreshCredential(provider, stored, allowNetwork, signal) {
+		if (stored?.type === "oauth") {
+			const oauth = provider.auth.oauth;
+			if (!oauth) return void 0;
+			if (!allowNetwork || Date.now() < stored.expires) return stored;
+			if (signal?.aborted) return void 0;
+			const post = await this.credentials.modify(provider.id, async (current) => {
+				if (current?.type !== "oauth" || Date.now() < current.expires) return void 0;
+				return oauth.refresh(current, signal);
+			});
+			return post?.type === "oauth" ? post : void 0;
+		}
+		const apiKey = provider.auth.apiKey;
+		if (!apiKey) return void 0;
+		const credential = stored?.type === "api_key" ? stored : void 0;
+		const result = await apiKey.resolve({
+			ctx: this.authContext,
+			credential
+		});
+		if (!result) return void 0;
+		return {
+			type: "api_key",
+			key: result.auth.apiKey,
+			env: result.env
+		};
+	}
+	async readCredential(providerId) {
+		try {
+			return await this.credentials.read(providerId);
+		} catch (error) {
+			throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
+		}
+	}
+	async checkProviderAuth(provider, credential) {
+		if (credential?.type === "oauth") return provider.auth.oauth ? {
+			source: "OAuth",
+			type: "oauth"
+		} : void 0;
+		const apiKey = provider.auth.apiKey;
+		if (!apiKey) return void 0;
+		if (apiKey.check) try {
+			return await apiKey.check({
+				ctx: this.authContext,
+				credential: credential?.type === "api_key" ? credential : void 0
+			});
+		} 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);
+		return resolution ? {
+			source: resolution.source,
+			type: "api_key"
+		} : void 0;
+	}
+	async checkAuth(providerId) {
+		const provider = this.providers.get(providerId);
+		if (!provider) return void 0;
+		return this.checkProviderAuth(provider, await this.readCredential(providerId));
+	}
+	async getAvailable(providerId) {
+		const providers = providerId ? [this.providers.get(providerId)].filter((entry) => entry !== void 0) : this.getProviders();
+		return (await Promise.all(providers.map(async (provider) => {
+			const credential = await this.readCredential(provider.id);
+			return {
+				provider,
+				credential,
+				auth: await this.checkProviderAuth(provider, credential)
+			};
+		}))).flatMap(({ provider, credential, auth }) => {
+			if (!auth) return [];
+			const models = provider.getModels();
+			return provider.filterModels?.(models, credential) ?? models;
+		});
+	}
+	async getAuth(providerOrModel, overrides) {
+		const providerId = typeof providerOrModel === "string" ? providerOrModel : providerOrModel.provider;
+		const provider = this.providers.get(providerId);
+		if (!provider) return void 0;
+		const result = await resolveProviderAuth(provider, this.credentials, this.authContext, overrides);
+		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 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 credential = await method.login(interaction);
+		try {
+			await this.credentials.modify(providerId, async () => credential);
+		} catch (error) {
+			throw new ModelsError("auth", `Credential store modify failed for ${providerId}`, { cause: error });
+		}
+		return credential;
+	}
+	async logout(providerId) {
+		try {
+			await this.credentials.delete(providerId);
+		} catch (error) {
+			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
+		});
+		if (!resolution) throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
+		const auth = resolution.auth;
+		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 ?? {}
+		} : void 0;
+		const requestModel = auth.baseUrl ? {
+			...model,
+			baseUrl: auth.baseUrl
+		} : model;
+		const { transformHeaders: _transformHeaders, ...providerOptions } = options ?? {};
+		return {
+			requestModel,
+			requestOptions: {
+				...providerOptions,
+				apiKey,
+				headers,
+				env
+			}
+		};
+	}
+	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();
+	}
+};
+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 = [];
+	let inflightRefresh;
+	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 : void 0;
+	const byApi = single ? void 0 : 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);
+	};
+	return {
+		id: input.id,
+		name: input.name ?? input.id,
+		baseUrl: input.baseUrl,
+		headers: input.headers,
+		auth: input.auth,
+		getModels: currentModels,
+		refreshModels: fetchModels ? (context) => {
+			inflightRefresh ??= (async () => {
+				try {
+					const stored = await context.store.read();
+					if (stored) dynamicModels = stored.models.filter((model) => model.provider === input.id).map((model) => model);
+					if (!context.allowNetwork || context.signal?.aborted) return;
+					const refreshed = await fetchModels(context);
+					if (context.signal?.aborted) return;
+					dynamicModels = refreshed;
+					await context.store.write({
+						models: refreshed,
+						checkedAt: Date.now()
+					});
+				} finally {
+					inflightRefresh = void 0;
+				}
+			})();
+			return inflightRefresh;
+		} : void 0,
+		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))
+	};
+}
+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;
+	}
+	const longWrite = usage.cacheWrite1h ?? 0;
+	const shortWrite = usage.cacheWrite - longWrite;
+	usage.cost.input = rates.input / 1e6 * usage.input;
+	usage.cost.output = rates.output / 1e6 * usage.output;
+	usage.cost.cacheRead = rates.cacheRead / 1e6 * usage.cacheRead;
+	usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1e6;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+var 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 !== void 0;
+		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";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/partial-json@0.1.7/node_modules/partial-json/dist/options.js
+var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Sometimes you don't allow every type to be partially parsed.
+	* For example, you may not want a partial number because it may increase its size gradually before it's complete.
+	* In this case, you can use the `Allow` object to control what types you allow to be partially parsed.
+	* @module
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+	/**
+	* allow partial strings like `"hello \u12` to be parsed as `"hello "`
+	*/
+	exports.STR = 1;
+	/**
+	* allow partial numbers like `123.` to be parsed as `123`
+	*/
+	exports.NUM = 2;
+	/**
+	* allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+	*/
+	exports.ARR = 4;
+	/**
+	* allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+	*/
+	exports.OBJ = 8;
+	/**
+	* allow `nu` to be parsed as `null`
+	*/
+	exports.NULL = 16;
+	/**
+	* allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+	*/
+	exports.BOOL = 32;
+	/**
+	* allow `Na` to be parsed as `NaN`
+	*/
+	exports.NAN = 64;
+	/**
+	* allow `Inf` to be parsed as `Infinity`
+	*/
+	exports.INFINITY = 128;
+	/**
+	* allow `-Inf` to be parsed as `-Infinity`
+	*/
+	exports._INFINITY = 256;
+	exports.INF = exports.INFINITY | exports._INFINITY;
+	exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+	exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+	exports.COLLECTION = exports.ARR | exports.OBJ;
+	exports.ALL = exports.ATOM | exports.COLLECTION;
+	/**
+	* Control what types you allow to be partially parsed.
+	* The default is to allow all types to be partially parsed, which in most casees is the best option.
+	* @example
+	* If you don't want to allow partial objects, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, Allow.ARR); // [ { a: 1, b: 2 } ]
+	* ```
+	* Or you can use `~` to disallow a type:
+	* ```ts
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, ~Allow.OBJ); // [ { a: 1, b: 2 } ]
+	* ```
+	* @example
+	* If you don't want to allow partial strings, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`["complete string", "incompl`, ~Allow.STR); // [ 'complete string' ]
+	* ```
+	*/
+	exports.Allow = {
+		STR: exports.STR,
+		NUM: exports.NUM,
+		ARR: exports.ARR,
+		OBJ: exports.OBJ,
+		NULL: exports.NULL,
+		BOOL: exports.BOOL,
+		NAN: exports.NAN,
+		INFINITY: exports.INFINITY,
+		_INFINITY: exports._INFINITY,
+		INF: exports.INF,
+		SPECIAL: exports.SPECIAL,
+		ATOM: exports.ATOM,
+		COLLECTION: exports.COLLECTION,
+		ALL: exports.ALL
+	};
+	exports.default = exports.Allow;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@earendil-works+pi-ai@0.83.0_@modelcontextprotocol+sdk@1.30.0_@cfworker+json-schema@4.1_c038161535a4cc121d37390bb491fb78/node_modules/@earendil-works/pi-ai/dist/utils/json-parse.js
+var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) 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 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+	var options_1 = require_options();
+	Object.defineProperty(exports, "Allow", {
+		enumerable: true,
+		get: function() {
+			return options_1.Allow;
+		}
+	});
+	__exportStar(require_options(), exports);
+	var PartialJSON = class extends Error {};
+	exports.PartialJSON = PartialJSON;
+	var MalformedJSON = class extends Error {};
+	exports.MalformedJSON = MalformedJSON;
+	/**
+	* Parse incomplete JSON
+	* @param {string} jsonString Partial JSON to be parsed
+	* @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details
+	* @returns The parsed JSON
+	* @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter)
+	* @throws {MalformedJSON} If the JSON is malformed
+	*/
+	function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+		if (typeof jsonString !== "string") throw new TypeError(`expecting str, got ${typeof jsonString}`);
+		if (!jsonString.trim()) throw new Error(`${jsonString} is empty`);
+		return _parseJSON(jsonString.trim(), allowPartial);
+	}
+	exports.parseJSON = parseJSON;
+	var _parseJSON = (jsonString, allow) => {
+		const length = jsonString.length;
+		let index = 0;
+		const markPartialJSON = (msg) => {
+			throw new PartialJSON(`${msg} at position ${index}`);
+		};
+		const throwMalformedError = (msg) => {
+			throw new MalformedJSON(`${msg} at position ${index}`);
+		};
+		const parseAny = () => {
+			skipBlank();
+			if (index >= length) markPartialJSON("Unexpected end of input");
+			if (jsonString[index] === "\"") return parseStr();
+			if (jsonString[index] === "{") return parseObj();
+			if (jsonString[index] === "[") return parseArr();
+			if (jsonString.substring(index, index + 4) === "null" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return null;
+			}
+			if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return true;
+			}
+			if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+				index += 5;
+				return false;
+			}
+			if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+				index += 8;
+				return Infinity;
+			}
+			if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+				index += 9;
+				return -Infinity;
+			}
+			if (jsonString.substring(index, index + 3) === "NaN" || options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) {
+				index += 3;
+				return NaN;
+			}
+			return parseNum();
+		};
+		const parseStr = () => {
+			const start = index;
+			let escape = false;
+			index++;
+			while (index < length && (jsonString[index] !== "\"" || escape && jsonString[index - 1] === "\\")) {
+				escape = jsonString[index] === "\\" ? !escape : false;
+				index++;
+			}
+			if (jsonString.charAt(index) == "\"") try {
+				return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+			} catch (e) {
+				throwMalformedError(String(e));
+			}
+			else if (options_1.Allow.STR & allow) try {
+				return JSON.parse(jsonString.substring(start, index - Number(escape)) + "\"");
+			} catch (e) {
+				return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + "\"");
+			}
+			markPartialJSON("Unterminated string literal");
+		};
+		const parseObj = () => {
+			index++;
+			skipBlank();
+			const obj = {};
+			try {
+				while (jsonString[index] !== "}") {
+					skipBlank();
+					if (index >= length && options_1.Allow.OBJ & allow) return obj;
+					const key = parseStr();
+					skipBlank();
+					index++;
+					try {
+						obj[key] = parseAny();
+					} catch (e) {
+						if (options_1.Allow.OBJ & allow) return obj;
+						else throw e;
+					}
+					skipBlank();
+					if (jsonString[index] === ",") index++;
+				}
+			} catch (e) {
+				if (options_1.Allow.OBJ & allow) return obj;
+				else markPartialJSON("Expected '}' at end of object");
+			}
+			index++;
+			return obj;
+		};
+		const parseArr = () => {
+			index++;
+			const arr = [];
+			try {
+				while (jsonString[index] !== "]") {
+					arr.push(parseAny());
+					skipBlank();
+					if (jsonString[index] === ",") index++;
+				}
+			} catch (e) {
+				if (options_1.Allow.ARR & allow) return arr;
+				markPartialJSON("Expected ']' at end of array");
+			}
+			index++;
+			return arr;
+		};
+		const parseNum = () => {
+			if (index === 0) {
+				if (jsonString === "-") throwMalformedError("Not sure what '-' is");
+				try {
+					return JSON.parse(jsonString);
+				} catch (e) {
+					if (options_1.Allow.NUM & allow) try {
+						return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+					} catch (e) {}
+					throwMalformedError(String(e));
+				}
+			}
+			const start = index;
+			if (jsonString[index] === "-") index++;
+			while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1) index++;
+			if (index == length && !(options_1.Allow.NUM & allow)) markPartialJSON("Unterminated number literal");
+			try {
+				return JSON.parse(jsonString.substring(start, index));
+			} catch (e) {
+				if (jsonString.substring(start, index) === "-") markPartialJSON("Not sure what '-' is");
+				try {
+					return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+				} catch (e) {
+					throwMalformedError(String(e));
+				}
+			}
+		};
+		const skipBlank = () => {
+			while (index < length && " \n\r	".includes(jsonString[index])) index++;
+		};
+		return parseAny();
+	};
+	exports.parse = parseJSON;
+})))();
+var VALID_JSON_ESCAPES = /* @__PURE__ */ new Set([
+	"\"",
+	"\\",
+	"/",
+	"b",
+	"f",
+	"n",
+	"r",
+	"t",
+	"u"
+]);
+function isControlCharacter(char) {
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+function escapeControlCharacter(char) {
+	switch (char) {
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		default: return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+	}
+}
+/**
+* Repairs malformed JSON string literals by:
+* - escaping raw control characters inside strings
+* - doubling backslashes before invalid escape characters
+*/
+function repairJson(json) {
+	let repaired = "";
+	let inString = false;
+	for (let index = 0; index < json.length; index++) {
+		const char = json[index];
+		if (!inString) {
+			repaired += char;
+			if (char === "\"") inString = true;
+			continue;
+		}
+		if (char === "\"") {
+			repaired += char;
+			inString = false;
+			continue;
+		}
+		if (char === "\\") {
+			const nextChar = json[index + 1];
+			if (nextChar === void 0) {
+				repaired += "\\\\";
+				continue;
+			}
+			if (nextChar === "u") {
+				const unicodeDigits = json.slice(index + 2, index + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+					repaired += `\\u${unicodeDigits}`;
+					index += 5;
+					continue;
+				}
+			}
+			if (VALID_JSON_ESCAPES.has(nextChar)) {
+				repaired += `\\${nextChar}`;
+				index += 1;
+				continue;
+			}
+			repaired += "\\\\";
+			continue;
+		}
+		repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+	}
+	return repaired;
+}
+function parseJsonWithRepair(json) {
+	try {
+		return JSON.parse(json);
+	} catch (error) {
+		const repairedJson = repairJson(json);
+		if (repairedJson !== json) return JSON.parse(repairedJson);
+		throw error;
+	}
+}
+/**
+* Attempts to parse potentially incomplete JSON during streaming.
+* Always returns a valid object, even if the JSON is incomplete.
+*
+* @param partialJson The partial JSON string from streaming
+* @returns Parsed object or empty object if parsing fails
+*/
+function parseStreamingJson(partialJson) {
+	if (!partialJson || partialJson.trim() === "") return {};
+	try {
+		return parseJsonWithRepair(partialJson);
+	} catch {
+		try {
+			return (0, import_dist.parse)(partialJson) ?? {};
+		} catch {
+			try {
+				return (0, import_dist.parse)(repairJson(partialJson)) ?? {};
+			} catch {
+				return {};
+			}
+		}
+	}
+}
+//#endregion
+export { createModels as a, AssistantMessageEventStream as c, clampThinkingLevel as i, createAssistantMessageEventStream as l, parseStreamingJson as n, createProvider as o, calculateCost as r, lazyApi as s, parseJsonWithRepair as t };
+
+//# sourceMappingURL=json-parse-DCA_fvRV.js.map