@scuffi/gardener 0.1.1

package/assets/apps/gardener/dist/gardener_runtime/assets/openai-responses-vjbR2NOB.js

@@ -0,0 +1,240 @@
+import { c as AssistantMessageEventStream, i as clampThinkingLevel } from "./json-parse-DCA_fvRV.js";
+import { a as hasCopilotVisionInput, c as getProviderEnvValue, i as buildCopilotDynamicHeaders, n as buildBaseOptions, o as retryProviderRequest, s as headersToRecord } from "./simple-options-tFhuCUzS.js";
+import { t as splitDeferredTools } from "./deferred-tools-BwNJSp7E.js";
+import { r as createGrammarToolInputProperties } from "./transform-messages-B41ICucH.js";
+import { n as normalizeProviderError, r as OpenAI, t as formatProviderError } from "./error-body-D8mmocwO.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache-IAZGhS1U.js";
+import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared-BptkVdeL.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/api/openai-responses.js
+var OPENAI_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"openai-codex",
+	"opencode"
+]);
+var OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
+function hasHeader(headers, name) {
+	if (!headers) return false;
+	const expected = name.toLowerCase();
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === expected && value !== null && value.trim().length > 0) return true;
+	return false;
+}
+function getClientApiKey(provider, apiKey, headers) {
+	if (apiKey) return apiKey;
+	if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization")) return "unused";
+	throw new Error(`No API key for provider: ${provider}`);
+}
+function detectSessionAffinityFormat(model) {
+	return model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai") ? "openrouter" : "openai";
+}
+/**
+* Resolve cache retention preference.
+* Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
+*/
+function resolveCacheRetention(cacheRetention, env) {
+	if (cacheRetention) return cacheRetention;
+	if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") return "long";
+	return "short";
+}
+function getCompat(model) {
+	return {
+		supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
+		sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
+		supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+		supportsStrictMode: model.compat?.supportsStrictMode ?? false,
+		supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
+		supportsToolSearch: model.compat?.supportsToolSearch ?? false,
+		supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false
+	};
+}
+function getPromptCacheRetention(compat, cacheRetention) {
+	return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : void 0;
+}
+function formatOpenAIResponsesError(error) {
+	return formatProviderError(normalizeProviderError(error), "OpenAI API error");
+}
+/**
+* Generate function for OpenAI Responses API
+*/
+var stream = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = {
+			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: "pending",
+			timestamp: Date.now()
+		};
+		try {
+			const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
+			const cacheSessionId = resolveCacheRetention(options?.cacheRetention, options?.env) === "none" ? void 0 : options?.sessionId;
+			const compat = getCompat(model);
+			const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
+			const client = createClient(model, context, apiKey, options?.headers, options?.fetch, cacheSessionId);
+			let params = buildParams(model, context, options, compat, grammarToolInputProperties);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			const requestOptions = {
+				...options?.signal ? { signal: options.signal } : {},
+				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+				maxRetries: 0
+			};
+			const { data: openaiStream, response } = await retryProviderRequest(() => client.responses.create(params, requestOptions).withResponse(), {
+				maxRetries: options?.maxRetries,
+				maxRetryDelayMs: options?.maxRetryDelayMs,
+				signal: options?.signal
+			});
+			await options?.onResponse?.({
+				status: response.status,
+				headers: headersToRecord(response.headers)
+			}, model);
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			await processResponsesStream(openaiStream, output, stream, model, {
+				serviceTier: options?.serviceTier,
+				grammarToolInputProperties,
+				applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+			});
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "pending") throw new Error("OpenAI Responses stream ended without a stop reason");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				delete block.index;
+				delete block.partialJson;
+				delete block.customInput;
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatOpenAIResponsesError(error);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+var streamSimple = (model, context, options) => {
+	getClientApiKey(model.provider, options?.apiKey, options?.headers);
+	const base = buildBaseOptions(model, context, options, options?.apiKey);
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+	const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning;
+	return stream(model, context, {
+		...base,
+		reasoningEffort
+	});
+};
+function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId) {
+	const compat = getCompat(model);
+	const headers = { ...model.headers };
+	if (model.provider === "github-copilot") {
+		const hasImages = hasCopilotVisionInput(context.messages);
+		const copilotHeaders = buildCopilotDynamicHeaders({
+			messages: context.messages,
+			hasImages
+		});
+		Object.assign(headers, copilotHeaders);
+	}
+	if (sessionId) {
+		if (compat.sessionAffinityFormat === "openrouter") headers["x-session-id"] = sessionId;
+		else {
+			if (compat.sessionAffinityFormat === "openai") headers.session_id = sessionId;
+			headers["x-client-request-id"] = sessionId;
+		}
+	}
+	if (optionsHeaders) Object.assign(headers, optionsHeaders);
+	return new OpenAI({
+		apiKey,
+		baseURL: model.baseUrl,
+		dangerouslyAllowBrowser: true,
+		fetch,
+		defaultHeaders: headers
+	});
+}
+function buildParams(model, context, options, compat = getCompat(model), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
+	const toolPlacement = splitDeferredTools(context, compat.supportsToolSearch);
+	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+		grammarToolInputProperties,
+		deferredTools: toolPlacement.deferred,
+		toolOptions: {
+			supportsStrictMode: compat.supportsStrictMode,
+			supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
+		}
+	});
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
+	const disableImplicitPromptCache = cacheRetention === "none" && compat.supportsExplicitPromptCacheMode;
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.sessionId),
+		prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
+		prompt_cache_options: disableImplicitPromptCache ? { mode: "explicit" } : void 0,
+		store: false
+	};
+	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
+	if (options?.temperature !== void 0) params.temperature = options?.temperature;
+	if (options?.serviceTier !== void 0) params.service_tier = options.serviceTier;
+	if (toolPlacement.immediate.length > 0) params.tools = convertResponsesTools(toolPlacement.immediate, {
+		supportsStrictMode: compat.supportsStrictMode,
+		supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
+	});
+	if (options?.toolChoice !== void 0) params.tool_choice = options.toolChoice;
+	if (model.reasoning) {
+		if (options?.reasoningEffort || options?.reasoningSummary) {
+			params.reasoning = {
+				effort: options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium",
+				summary: options?.reasoningSummary || "auto"
+			};
+			params.include = ["reasoning.encrypted_content"];
+		} else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+		if (model.provider === "xai") params.include = ["reasoning.encrypted_content"];
+	}
+	return params;
+}
+function getServiceTierCostMultiplier(model, serviceTier) {
+	switch (serviceTier) {
+		case "flex": return .5;
+		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
+		default: return 1;
+	}
+}
+function applyServiceTierPricing(usage, serviceTier, model) {
+	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
+	if (multiplier === 1) return;
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+//#endregion
+export { stream, streamSimple };
+
+//# sourceMappingURL=openai-responses-vjbR2NOB.js.map

package/assets/apps/gardener/dist/gardener_runtime/assets/rolldown-runtime-7_rZTKki.js

@@ -0,0 +1,42 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+export { __toESM as a, __toCommonJS as i, __esmMin as n, __exportAll as r, __commonJSMin as t };

package/assets/apps/gardener/dist/gardener_runtime/assets/simple-options-tFhuCUzS.js

@@ -0,0 +1,300 @@
+import { t as __commonJSMin } from "./rolldown-runtime-7_rZTKki.js";
+import * as m from "node:fs";
+//#region builtin:esm-external-require-node:fs
+var require_builtin_esm_external_require_node_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = m.default;
+}));
+//#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/provider-env.js
+var procEnvCache = null;
+/**
+* Fallback for https://github.com/oven-sh/bun/issues/27802.
+* Bun compiled binaries can expose an empty process.env inside Linux sandboxes
+* even though /proc/self/environ contains the environment.
+*
+* This intentionally duplicates restoreSandboxEnv() in
+* packages/coding-agent/src/bun/restore-sandbox-env.ts. The ai package can be
+* used directly, without going through that entrypoint, so provider env lookup
+* must not depend on process.env having been patched.
+*/
+function getBunSandboxEnvValue(name) {
+	if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) return;
+	if (procEnvCache === null) {
+		procEnvCache = /* @__PURE__ */ new Map();
+		try {
+			const { readFileSync } = require_builtin_esm_external_require_node_fs();
+			const data = readFileSync("/proc/self/environ", "utf-8");
+			for (const entry of data.split("\0")) {
+				const idx = entry.indexOf("=");
+				if (idx > 0) procEnvCache.set(entry.slice(0, idx), entry.slice(idx + 1));
+			}
+		} catch {}
+	}
+	return procEnvCache.get(name);
+}
+/**
+* Resolve a provider env value from scoped overrides, normal process.env, then
+* the duplicated Bun sandbox fallback for direct pi-ai consumers.
+*/
+function getProviderEnvValue(name, env) {
+	return env?.[name] || (typeof process !== "undefined" ? process.env[name] : void 0) || getBunSandboxEnvValue(name) || void 0;
+}
+//#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/headers.js
+function headersToRecord(headers) {
+	const result = {};
+	for (const [key, value] of headers.entries()) result[key] = value;
+	return result;
+}
+//#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/provider-retry.js
+var DEFAULT_MAX_RETRY_DELAY_MS = 6e4;
+function isProviderError(error) {
+	if (!(error instanceof Error) || !("status" in error) || !("headers" in error)) return false;
+	return (error.status === void 0 || typeof error.status === "number") && (error.headers === void 0 || 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 === void 0) 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 / 1e3)}s retry delay (max: ${Math.ceil(maxDelayMs / 1e3)}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);
+		return validateServerRetryDelayMs(Number.isNaN(seconds) ? Date.parse(retryAfter) - Date.now() : seconds * 1e3, maxRetryDelayMs, error.message);
+	}
+	return Math.min(.5 * 2 ** retryIndex, 8) * 1e3 * (1 - Math.random() * .25);
+}
+function createAbortError() {
+	const error = /* @__PURE__ */ 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 {
+		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);
+	}
+}
+//#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/github-copilot-headers.js
+function inferCopilotInitiator(messages) {
+	const last = messages[messages.length - 1];
+	return last && last.role !== "user" ? "agent" : "user";
+}
+function hasCopilotVisionInput(messages) {
+	return messages.some((msg) => {
+		if (msg.role === "user" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
+		if (msg.role === "toolResult" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
+		return false;
+	});
+}
+function buildCopilotDynamicHeaders(params) {
+	const headers = {
+		"X-Initiator": inferCopilotInitiator(params.messages),
+		"Openai-Intent": "conversation-edits"
+	};
+	if (params.hasImages) headers["Copilot-Vision-Request"] = "true";
+	return headers;
+}
+//#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/estimate.js
+var CHARS_PER_TOKEN = 4;
+var 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;
+			if (assistant.timestamp >= latestPrefixTimestamp && 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
+	};
+}
+//#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/simple-options.js
+var CONTEXT_SAFETY_TOKENS = 4096;
+var 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) {
+	return {
+		temperature: options?.temperature,
+		maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
+		signal: options?.signal,
+		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
+	};
+}
+function clampReasoning(effort) {
+	return effort === "xhigh" || effort === "max" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+	const budgets = {
+		minimal: 1024,
+		low: 2048,
+		medium: 8192,
+		high: 16384,
+		...customBudgets
+	};
+	const minOutputTokens = 1024;
+	let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
+	const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+	if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+	return {
+		maxTokens,
+		thinkingBudget
+	};
+}
+//#endregion
+export { hasCopilotVisionInput as a, getProviderEnvValue as c, buildCopilotDynamicHeaders as i, buildBaseOptions as n, retryProviderRequest as o, clampMaxTokensToContext as r, headersToRecord as s, adjustMaxTokensForThinking as t };
+
+//# sourceMappingURL=simple-options-tFhuCUzS.js.map