@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/context-compaction-Bxp4WK2B-Ct4RSjlg.mjs

@@ -0,0 +1,811 @@
+import { D as parseChatAttachmentServePath, c as LLM_RUN_KIND_HEADER, l as LLM_SKIP_USAGE_HEADER, o as LLM_KEY_SOURCE_HEADER, s as LLM_RUN_ID_HEADER } from "./dist-D0P3wUQe.mjs";
+import { L as getProjectScopeId, _ as generateId, a as generateText, f as createGateway, s as isFileUIPart } from "./dist-C_APGtUJ.mjs";
+import { z } from "zod";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../agent/dist/schemas-DDyTkszQ.mjs
+function capabilitiesFromGatewayTags(tags) {
+	const set = new Set(tags ?? []);
+	return {
+		images: set.has("vision"),
+		files: set.has("file-input")
+	};
+}
+function attachmentPlaceholderText(filename, mediaType) {
+	return `[attachment omitted: ${filename?.trim() || mediaType} — model has no ${mediaType.startsWith("image/") ? "image" : "file"} support]`;
+}
+const storage = new AsyncLocalStorage();
+/**
+* Best-effort run attribution for LLM proxy traffic. The gateway client reads
+* this to stamp run headers on each request so the platform can tag the usage
+* it records to a run. Billing never depends on it — losing the context only
+* drops the history-UI attribution.
+*/
+function withLlmRunContext(context, fn) {
+	return storage.run(context, fn);
+}
+function currentLlmRunContext() {
+	return storage.getStore();
+}
+const DEFAULT_GATEWAY_ORIGIN = "https://ai-gateway.vercel.sh";
+/**
+* Wrap `fetch` so every gateway request carries the current run's attribution
+* headers. Read at call time (not client-construction time) so the cached
+* singleton client still tags each request with its own run.
+*/
+const runContextFetch = (input, init) => {
+	const run = currentLlmRunContext();
+	if (!run) return fetch(input, init);
+	const headers = new Headers(init?.headers);
+	headers.set(LLM_RUN_ID_HEADER, run.runId);
+	headers.set(LLM_RUN_KIND_HEADER, run.runKind);
+	if (run.skipUsage) headers.set(LLM_SKIP_USAGE_HEADER, "1");
+	return fetch(input, {
+		...init,
+		headers
+	});
+};
+/** Resolve the model catalog URL for pricing metadata (via platform proxy when configured). */
+function resolveGatewayCatalogUrl(modelId) {
+	const baseUrl = resolveGatewayBaseUrl();
+	const apiKey = process.env.AI_GATEWAY_API_KEY?.trim();
+	if (baseUrl && apiKey) return {
+		url: `${baseUrl.replace(/\/$/, "")}/models/${modelId}`,
+		headers: {
+			accept: "application/json",
+			authorization: `Bearer ${apiKey}`
+		},
+		cacheKey: baseUrl
+	};
+	return {
+		url: `${DEFAULT_GATEWAY_ORIGIN}/v1/models/${modelId}`,
+		headers: { accept: "application/json" },
+		cacheKey: DEFAULT_GATEWAY_ORIGIN
+	};
+}
+let cachedGateway;
+function resolveGatewayBaseUrl() {
+	const configured = process.env.AI_GATEWAY_BASE_URL?.trim();
+	if (configured) return configured.replace(/\/$/, "");
+	const platformUrl = process.env.PLATFORM_URL?.trim();
+	if (!platformUrl || !process.env.AI_GATEWAY_API_KEY?.trim()) return;
+	const projectId = getProjectScopeId();
+	return `${platformUrl.replace(/\/$/, "")}/internal/projects/${encodeURIComponent(projectId)}/llm`;
+}
+/** Shared AI Gateway client honoring keystroke env conventions. */
+function getGatewayClient(baseUrl) {
+	const resolvedBaseUrl = baseUrl ?? resolveGatewayBaseUrl();
+	const cacheKey = resolvedBaseUrl ?? DEFAULT_GATEWAY_ORIGIN;
+	if (cachedGateway && cachedGateway.__baseUrl === cacheKey) return cachedGateway;
+	const apiKey = process.env.AI_GATEWAY_API_KEY?.trim();
+	const gateway = createGateway({
+		...resolvedBaseUrl ? { baseURL: resolvedBaseUrl } : {},
+		...apiKey ? { apiKey } : {},
+		fetch: runContextFetch
+	});
+	gateway.__baseUrl = cacheKey;
+	cachedGateway = gateway;
+	return gateway;
+}
+const AGENT_MODEL_ID_PATTERN = /^[a-z0-9-]+\/.+/;
+const AgentModelIdSchema = z.custom((value) => typeof value === "string" && AGENT_MODEL_ID_PATTERN.test(value), "model must be vendor/model-id");
+const GatewayModelPricingSchema = z.object({
+	input: z.string().optional(),
+	output: z.string().optional(),
+	input_cache_read: z.string().optional(),
+	input_cache_write: z.string().optional()
+});
+const GatewayModelResponseSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().optional(),
+	type: z.string().optional(),
+	context_window: z.number().int().positive().optional(),
+	max_tokens: z.number().int().positive().optional(),
+	tags: z.array(z.string()).optional(),
+	pricing: GatewayModelPricingSchema.optional()
+});
+function splitAgentModelId(modelId) {
+	const slash = modelId.indexOf("/");
+	return {
+		vendor: modelId.slice(0, slash),
+		directId: modelId.slice(slash + 1)
+	};
+}
+function parseGatewayModelResponse(body) {
+	const parsed = GatewayModelResponseSchema.safeParse(body);
+	return parsed.success ? parsed.data : void 0;
+}
+function pricePerMillion(value) {
+	if (!value) return 0;
+	const perToken = Number(value);
+	if (!Number.isFinite(perToken) || perToken <= 0) return 0;
+	return perToken * 1e6;
+}
+const gatewayModelCache = /* @__PURE__ */ new Map();
+const gatewayModelPending = /* @__PURE__ */ new Map();
+function gatewayModelCacheKey(modelId, catalog) {
+	return `${catalog.cacheKey}::${modelId}`;
+}
+function catalogLogContext(modelId, catalog) {
+	return {
+		modelId,
+		url: catalog.url,
+		projectScopeId: getProjectScopeId(),
+		cacheKey: gatewayModelCacheKey(modelId, catalog)
+	};
+}
+function snippet(value, max = 400) {
+	const trimmed = value.trim();
+	return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max)}…`;
+}
+async function fetchGatewayModelMetadata(modelId) {
+	const catalog = resolveGatewayCatalogUrl(modelId);
+	const cacheKey = gatewayModelCacheKey(modelId, catalog);
+	const cached = gatewayModelCache.get(cacheKey);
+	if (cached) {
+		if (cached.status === "found") {
+			const { status: _status, ...metadata } = cached;
+			return metadata;
+		}
+		console.warn("[gateway-model] catalog lookup cache miss (missing)", catalogLogContext(modelId, catalog));
+		return;
+	}
+	const pending = gatewayModelPending.get(cacheKey);
+	if (pending) return pending;
+	const request = (async () => {
+		try {
+			const response = await fetch(catalog.url, { headers: catalog.headers });
+			if (!response.ok) {
+				const body = await response.text().catch(() => "");
+				console.warn("[gateway-model] catalog HTTP error", {
+					...catalogLogContext(modelId, catalog),
+					status: response.status,
+					statusText: response.statusText,
+					body: snippet(body)
+				});
+				gatewayModelCache.set(cacheKey, { status: "missing" });
+				return;
+			}
+			const body = await response.json();
+			const raw = parseGatewayModelResponse(body);
+			if (!raw || raw.type && raw.type !== "language") {
+				console.warn("[gateway-model] catalog payload rejected", {
+					...catalogLogContext(modelId, catalog),
+					type: raw?.type,
+					body: snippet(JSON.stringify(body))
+				});
+				gatewayModelCache.set(cacheKey, { status: "missing" });
+				return;
+			}
+			const capabilities = capabilitiesFromGatewayTags(raw.tags);
+			const metadata = {
+				pricing: {
+					inputPerMillion: pricePerMillion(raw.pricing?.input),
+					outputPerMillion: pricePerMillion(raw.pricing?.output),
+					cacheReadPerMillion: pricePerMillion(raw.pricing?.input_cache_read),
+					cacheWritePerMillion: pricePerMillion(raw.pricing?.input_cache_write)
+				},
+				capabilities,
+				...raw.context_window !== void 0 ? { contextWindow: raw.context_window } : {},
+				...raw.max_tokens !== void 0 ? { maxOutputTokens: raw.max_tokens } : {}
+			};
+			gatewayModelCache.set(cacheKey, {
+				status: "found",
+				...metadata
+			});
+			return metadata;
+		} catch (error) {
+			console.warn("[gateway-model] catalog fetch failed", {
+				...catalogLogContext(modelId, catalog),
+				error: error instanceof Error ? error.message : String(error)
+			});
+			gatewayModelCache.set(cacheKey, { status: "missing" });
+			return;
+		} finally {
+			gatewayModelPending.delete(cacheKey);
+		}
+	})();
+	gatewayModelPending.set(cacheKey, request);
+	return request;
+}
+/** Cached gateway catalog lookup for model multimodal capabilities. */
+async function resolveModelCapabilities(modelId) {
+	return (await fetchGatewayModelMetadata(modelId))?.capabilities ?? {
+		images: false,
+		files: false
+	};
+}
+/** Resolve a user-authored model id to an AI Gateway language model + optional pricing metadata. */
+async function resolveAgentModel(modelId) {
+	const baseUrl = resolveGatewayBaseUrl();
+	const gateway = getGatewayClient(baseUrl);
+	const metadata = await fetchGatewayModelMetadata(modelId);
+	const pricing = metadata?.pricing;
+	const capabilities = metadata?.capabilities ?? {
+		images: false,
+		files: false
+	};
+	if (pricing === void 0) {
+		const catalog = resolveGatewayCatalogUrl(modelId);
+		if (gatewayModelCache.get(gatewayModelCacheKey(modelId, catalog))?.status === "missing" && process.env.AI_GATEWAY_API_KEY?.trim()) {
+			console.warn("[gateway-model] rejecting model after catalog miss", catalogLogContext(modelId, catalog));
+			throw new Error(`Unknown gateway model: ${modelId}`);
+		}
+	}
+	return {
+		languageModel: gateway(modelId),
+		modelId,
+		provider: "vercel-ai-gateway",
+		capabilities,
+		...baseUrl ? { baseUrl } : {},
+		...pricing ? { pricing } : {},
+		...metadata?.contextWindow !== void 0 ? { contextWindow: metadata.contextWindow } : {},
+		...metadata?.maxOutputTokens !== void 0 ? { maxOutputTokens: metadata.maxOutputTokens } : {}
+	};
+}
+const ThinkingLevelSchema = z.enum([
+	"provider-default",
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+const DEFAULT_THINKING_LEVEL = "medium";
+/** Default model for automatic context compaction when `compactionModel` is omitted. */
+const DEFAULT_COMPACTION_MODEL_ID = "deepseek/deepseek-v4-flash";
+/** Serializable subset of {@link AgentConfig} for JSON/env/CLI boundaries. */
+const AgentCreateInputSchema = z.object({
+	systemPrompt: z.string(),
+	model: AgentModelIdSchema,
+	/**
+	* Optional model used only for context compaction. Same `vendor/model-id` form as
+	* `model`. When omitted, Keystroke uses {@link DEFAULT_COMPACTION_MODEL_ID}.
+	*/
+	compactionModel: AgentModelIdSchema.optional(),
+	thinkingLevel: ThinkingLevelSchema.optional()
+});
+function parseAgentCreateInput(input) {
+	return AgentCreateInputSchema.parse(input);
+}
+function resolveThinkingLevel(level) {
+	return level ?? "medium";
+}
+//#endregion
+//#region ../agent/dist/context-compaction-Bxp4WK2B.mjs
+/** Map every `FileUIPart` in each message, leaving other parts and non-array messages untouched. */
+async function mapMessageFileParts(messages, mapFilePart) {
+	return Promise.all(messages.map(async (message) => {
+		if (!Array.isArray(message.parts)) return message;
+		const parts = await Promise.all(message.parts.map((part) => isFileUIPart(part) ? mapFilePart(part) : part));
+		return {
+			...message,
+			parts
+		};
+	}));
+}
+/**
+* Approximate model-token cost of one image attachment. Vision pricing is
+* tile-based (provider-dependent, roughly 750–1,600 tokens for a typical
+* photo), not proportional to serialized bytes — a flat per-image charge is
+* closer to reality than counting base64 chars.
+*/
+const APPROX_ATTACHMENT_IMAGE_TOKENS = 1100;
+/**
+* Approximate model-token cost of one non-image attachment (PDFs). Page count
+* is unknown without downloading, so this assumes a short document; a giant
+* PDF under-counts, but the estimate only steers the compaction heuristic.
+*/
+const APPROX_ATTACHMENT_FILE_TOKENS = 3e3;
+function isUnhydratedAttachment(part) {
+	return parseChatAttachmentServePath(part.url) !== null;
+}
+/**
+* Replace unhydrated chat-attachment file parts (relative serve paths) with
+* text placeholders so the messages survive `convertToModelMessages` — the AI
+* SDK's `new URL(part.url)` throws `TypeError: Invalid URL` on relative paths.
+*
+* For estimation and compaction only: the placeholder tells the compaction
+* model an attachment existed, and the real model call hydrates the actual
+* bytes via `hydrateChatAttachmentMessages` instead.
+*/
+function placeholderChatAttachmentMessages(messages) {
+	return mapMessageFileParts(messages, (part) => isUnhydratedAttachment(part) ? {
+		type: "text",
+		text: `[attachment: ${part.filename?.trim() || "file"} (${part.mediaType})]`
+	} : part);
+}
+/**
+* Estimated token cost of the unhydrated attachments in `messages`, to add on
+* top of a char-based serialized estimate (which only sees the placeholder
+* text, not what the attachment will cost once hydrated for the model).
+*/
+function estimateChatAttachmentTokens(messages) {
+	let total = 0;
+	for (const message of messages) {
+		if (!Array.isArray(message.parts)) continue;
+		for (const part of message.parts) {
+			if (!isFileUIPart(part) || !isUnhydratedAttachment(part)) continue;
+			total += part.mediaType.startsWith("image/") ? APPROX_ATTACHMENT_IMAGE_TOKENS : APPROX_ATTACHMENT_FILE_TOKENS;
+		}
+	}
+	return total;
+}
+/** Soft compaction trigger as a fraction of the usable input budget. */
+const CONTEXT_COMPACTION_SOFT_RATIO = .9;
+/**
+* Fraction of the soft limit the retained raw tail may occupy after a
+* compaction. The remainder is headroom for the summary, system prompt, and
+* tool schemas.
+*/
+const COMPACTION_TAIL_BUDGET_RATIO = .4;
+/** Floor for reserved output + framing tokens. */
+const MIN_OUTPUT_RESERVE = 4096;
+/** Cap so million-token models are not compacted prematurely. */
+const MAX_OUTPUT_RESERVE = 32768;
+/** Extra framing/tool-schema overhead beyond the output reservation. */
+const SAFETY_RESERVE = 2048;
+/**
+* Conservative fixed chars-per-token ratio. Anchored estimates only apply it
+* to the delta since the last real `input_tokens`, so a systematic error here
+* is bounded by one step's new content, not the whole transcript.
+*/
+const DEFAULT_CHARS_PER_TOKEN = 3.5;
+/**
+* Derive the usable input budget from gateway context metadata.
+* Returns null when the model has no known context window — auto-compaction is disabled.
+*/
+function resolveContextBudget(resolved) {
+	const contextWindow = resolved.contextWindow;
+	if (contextWindow == null || contextWindow <= 0) return null;
+	const catalogMax = resolved.maxOutputTokens;
+	const proportional = Math.floor(contextWindow * .05);
+	const outputReserve = Math.min(MAX_OUTPUT_RESERVE, Math.max(MIN_OUTPUT_RESERVE, catalogMax ?? proportional, proportional));
+	const safetyReserve = Math.min(SAFETY_RESERVE, Math.floor(contextWindow * .01));
+	const inputBudget = Math.max(1, contextWindow - outputReserve - safetyReserve);
+	return {
+		contextWindow,
+		outputReserve,
+		safetyReserve,
+		inputBudget,
+		softLimit: Math.floor(inputBudget * CONTEXT_COMPACTION_SOFT_RATIO),
+		hardLimit: inputBudget
+	};
+}
+/** Rough serialized size used for preflight estimation (chars ≈ JSON length). */
+function estimateSerializedChars(input) {
+	let total = 0;
+	if (input.systemPrompt) total += input.systemPrompt.length;
+	if (input.messages !== void 0) total += JSON.stringify(input.messages).length;
+	if (input.tools !== void 0) total += JSON.stringify(input.tools).length;
+	return total;
+}
+const DATA_URL_MEDIA_MIN_CHARS = 4096;
+function approxMediaTokens(mediaType) {
+	return typeof mediaType === "string" && mediaType.startsWith("image/") ? APPROX_ATTACHMENT_IMAGE_TOKENS : APPROX_ATTACHMENT_FILE_TOKENS;
+}
+/**
+* Serialized message size with media content measured as flat token estimates
+* instead of chars. Vision/file pricing is tile- or page-based — counting a
+* 4 MB image's ~5.3M base64 chars would estimate ~1.5M tokens for what the
+* provider bills as ~1,100, wrongly triggering compaction on any large image.
+*/
+function measureMessagesForBudget(messages) {
+	let mediaTokens = 0;
+	return {
+		chars: JSON.stringify(messages, (_key, value) => {
+			if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+				mediaTokens += 3e3;
+				return "[media]";
+			}
+			if (typeof value === "object" && value !== null) {
+				const part = value;
+				if (part.type === "image" && part.image !== void 0) {
+					mediaTokens += 1100;
+					return {
+						type: "image",
+						omitted: true
+					};
+				}
+				if ((part.type === "file" || part.type === "media") && part.data !== void 0) {
+					mediaTokens += approxMediaTokens(part.mediaType);
+					return {
+						type: part.type,
+						omitted: true
+					};
+				}
+				if (part.type === "Buffer" && Array.isArray(part.data)) {
+					mediaTokens += 3e3;
+					return "[media]";
+				}
+			}
+			if (typeof value === "string" && value.length >= DATA_URL_MEDIA_MIN_CHARS && value.startsWith("data:")) {
+				mediaTokens += value.startsWith("data:image/") ? 1100 : 3e3;
+				return "[media]";
+			}
+			return value;
+		})?.length ?? 0,
+		mediaTokens
+	};
+}
+/**
+* Per-prompt tracker: anchors on the last real `input_tokens` and estimates
+* only the delta (new content since that request), so estimation error is
+* bounded by one step's new content instead of the whole transcript. Before
+* the first completed step it falls back to a full char scan with media
+* priced at flat token constants.
+*/
+var ContextBudgetTracker = class {
+	budget;
+	anchor;
+	lastMeasure;
+	constructor(budget) {
+		this.budget = budget;
+	}
+	get contextBudget() {
+		return this.budget;
+	}
+	get lastInputTokens() {
+		return this.anchor?.inputTokens;
+	}
+	/**
+	* Anchor on a completed primary-model step's input token count, paired with
+	* the measure taken by the estimate that preceded that request — future
+	* estimates price only content added after this point.
+	*/
+	recordStepUsage(inputTokens) {
+		if (inputTokens > 0 && this.lastMeasure) this.anchor = {
+			inputTokens,
+			...this.lastMeasure
+		};
+	}
+	/** Reset after a successful compaction: the transcript the anchor priced no longer exists. */
+	resetAfterCompaction() {
+		this.anchor = void 0;
+		this.lastMeasure = void 0;
+	}
+	estimate(input) {
+		if (!this.budget) return null;
+		const measure = measureMessagesForBudget(input.messages);
+		const overheadChars = input.overheadChars ?? estimateSerializedChars({
+			systemPrompt: input.systemPrompt,
+			tools: input.tools
+		});
+		const mediaTokens = measure.mediaTokens + (input.extraMessageTokens ?? 0);
+		this.lastMeasure = {
+			chars: measure.chars,
+			mediaTokens
+		};
+		const toTokens = (chars) => Math.ceil(chars / DEFAULT_CHARS_PER_TOKEN);
+		let estimatedInputTokens;
+		let estimatedMessageTokens;
+		if (this.anchor) {
+			const deltaTokens = toTokens(Math.max(0, measure.chars - this.anchor.chars)) + Math.max(0, mediaTokens - this.anchor.mediaTokens);
+			estimatedInputTokens = this.anchor.inputTokens + deltaTokens;
+			estimatedMessageTokens = Math.max(deltaTokens, estimatedInputTokens - toTokens(overheadChars));
+		} else {
+			estimatedInputTokens = toTokens(overheadChars + measure.chars) + mediaTokens;
+			estimatedMessageTokens = toTokens(measure.chars) + mediaTokens;
+		}
+		const decision = estimatedInputTokens >= this.budget.softLimit && estimatedMessageTokens > Math.floor(this.budget.softLimit * .5) ? "compact" : "allow";
+		return {
+			estimatedInputTokens,
+			estimatedMessageTokens,
+			decision,
+			budget: this.budget
+		};
+	}
+};
+/**
+* Key source from the platform LLM proxy's response header. Undefined when the
+* request didn't go through the proxy (standalone / direct provider).
+*/
+function byokFromResponseHeaders(headers) {
+	const value = headers?.[LLM_KEY_SOURCE_HEADER];
+	if (value === "byok") return true;
+	if (value === "platform") return false;
+}
+function llmUsageFromLanguageModelUsage(usage, resolved, options) {
+	const input = usage.inputTokens ?? 0;
+	const output = usage.outputTokens ?? 0;
+	const reasoning = usage.outputTokenDetails.reasoningTokens ?? 0;
+	const cacheRead = usage.inputTokenDetails.cacheReadTokens ?? 0;
+	const cacheWrite = usage.inputTokenDetails.cacheWriteTokens ?? 0;
+	const noCache = usage.inputTokenDetails.noCacheTokens ?? Math.max(0, input - cacheRead - cacheWrite);
+	const totalTokens = usage.totalTokens ?? input + output;
+	const pricing = resolved.pricing;
+	const inputCost = pricing ? noCache / 1e6 * pricing.inputPerMillion : 0;
+	const outputCost = pricing ? output / 1e6 * pricing.outputPerMillion : 0;
+	const cacheReadCost = pricing ? cacheRead / 1e6 * pricing.cacheReadPerMillion : 0;
+	const cacheWriteCost = pricing ? cacheWrite / 1e6 * pricing.cacheWritePerMillion : 0;
+	const total = inputCost + outputCost + cacheReadCost + cacheWriteCost;
+	const { directId } = splitAgentModelId(resolved.modelId);
+	return {
+		label: resolved.modelId,
+		quantity: totalTokens,
+		amount: total,
+		...options?.byok !== void 0 ? { byok: options.byok } : {},
+		...options?.stepRef ? { stepRef: options.stepRef } : {},
+		metadata: {
+			provider: resolved.provider,
+			model: directId,
+			...options?.byok !== void 0 ? { keySource: options.byok ? "byok" : "platform" } : {},
+			responseModel: resolved.modelId,
+			input,
+			noCache,
+			output,
+			reasoning,
+			cacheRead,
+			cacheWrite,
+			cost: {
+				noCache: inputCost,
+				output: outputCost,
+				cacheRead: cacheReadCost,
+				cacheWrite: cacheWriteCost,
+				total
+			}
+		}
+	};
+}
+/** Soft char budget for one compaction-model request (chunk recursively above this). */
+const COMPACTION_CHUNK_CHARS = 12e4;
+function resolveCompactionModelId(explicit) {
+	return explicit ?? "deepseek/deepseek-v4-flash";
+}
+const COMPACTION_SYSTEM_PROMPT = [
+	"You compress long agent conversation history into a compact context summary.",
+	"Preserve durable facts, decisions, IDs, file paths, unresolved tasks, and recent tool outcomes.",
+	"Omit chit-chat, repeated tool dumps, and superseded drafts.",
+	"Write plain prose the primary agent can continue from. Do not call tools.",
+	"Respond with ONLY the summary text."
+].join("\n");
+function messageTextPreview(message) {
+	if (typeof message.content === "string") return message.content;
+	if (!Array.isArray(message.content)) return JSON.stringify(message.content);
+	return message.content.map((part) => {
+		if (typeof part === "object" && part !== null && "type" in part) {
+			if (part.type === "text" && "text" in part) return String(part.text);
+			if (part.type === "tool-call") return `[tool-call ${part.toolName ?? "unknown"}]`;
+			if (part.type === "tool-result") return `[tool-result ${part.toolName ?? "unknown"}]`;
+		}
+		return JSON.stringify(part);
+	}).join("\n");
+}
+function formatMessagesForCompaction(messages) {
+	return messages.map((message, index) => {
+		const role = message.role;
+		return `### ${index + 1}. ${role}\n${messageTextPreview(message)}`;
+	}).join("\n\n");
+}
+/**
+* Split off a recent raw tail. Prefer a user-turn boundary and never start the
+* tail on an orphaned tool result (keeps tool-call / tool-result pairs intact).
+*/
+function splitTail(messages, retain, options) {
+	if (messages.length <= retain) return {
+		prefix: [],
+		tail: messages
+	};
+	let start = messages.length - retain;
+	while (start > 0 && messages[start]?.role === "tool") start -= 1;
+	if (options?.preferUserBoundary !== false) while (start > 0 && messages[start]?.role !== "user") start -= 1;
+	return {
+		prefix: messages.slice(0, start),
+		tail: messages.slice(start)
+	};
+}
+/**
+* Fraction of the soft limit the retained raw tail may occupy. Kept below the
+* compaction trigger's messages-only floor so a just-compacted context can't
+* immediately re-trigger (see COMPACTION_MIN_MESSAGE_RATIO).
+*/
+const TAIL_BUDGET_RATIO = COMPACTION_TAIL_BUDGET_RATIO;
+/**
+* Token allowance for the summary itself: capped at the summarizer's
+* maxOutputTokens, scaled down for small budgets (summaries track content
+* size, not the cap).
+*/
+function summaryReserveTokens(softLimit) {
+	return Math.min(4096, Math.ceil(softLimit * .1));
+}
+/**
+* Choose which messages to summarize vs keep raw. Starts from the requested
+* retained tail, then shrinks it while it exceeds the tail budget — down to
+* zero, so even a single oversized latest message gets summarized instead of
+* staying protected and blowing the context window.
+*/
+function resolveCompactionSplit(options) {
+	const { messages, budget } = options;
+	let retain = options.retainTail;
+	let split = splitTail(messages, retain);
+	if (budget) {
+		const tailBudget = Math.max(1, Math.min(Math.floor(budget.softLimit * TAIL_BUDGET_RATIO), budget.softLimit - (options.overheadTokens ?? 0) - summaryReserveTokens(budget.softLimit)));
+		while (split.tail.length > 0 && estimateSerializedCharsApprox(split.tail) > tailBudget) {
+			retain = Math.min(retain - 1, split.tail.length - 1);
+			if (retain <= 0) {
+				split = {
+					prefix: messages,
+					tail: []
+				};
+				break;
+			}
+			split = splitTail(messages, retain, { preferUserBoundary: false });
+		}
+		return split;
+	}
+	if (split.prefix.length === 0 && !options.hasPriorSummary && split.tail.length > 0) return {
+		prefix: messages,
+		tail: []
+	};
+	return split;
+}
+async function summarizeChunk(resolved, text, priorSummary) {
+	const prompt = [
+		priorSummary ? `Prior summary:\n${priorSummary}\n` : "",
+		"Conversation to compress:\n",
+		text
+	].filter(Boolean).join("\n");
+	const result = await generateText({
+		model: resolved.languageModel,
+		system: COMPACTION_SYSTEM_PROMPT,
+		prompt,
+		maxOutputTokens: 4096,
+		reasoning: "minimal"
+	});
+	const usage = llmUsageFromLanguageModelUsage(result.usage, resolved, {
+		byok: byokFromResponseHeaders(result.response?.headers),
+		stepRef: `compaction:${generateId()}`
+	});
+	usage.label = `LLM compaction · ${resolved.modelId}`;
+	usage.metadata = {
+		...usage.metadata,
+		operation: "context_compaction"
+	};
+	return {
+		summary: result.text.trim() || priorSummary || "(empty summary)",
+		usage
+	};
+}
+async function summarizeMessages(resolved, messages, priorSummary) {
+	const formatted = formatMessagesForCompaction(messages);
+	if (formatted.length <= COMPACTION_CHUNK_CHARS) {
+		const chunk = await summarizeChunk(resolved, priorSummary ? `${priorSummary}\n\n${formatted}` : formatted, void 0);
+		return {
+			summary: chunk.summary,
+			usages: [chunk.usage]
+		};
+	}
+	const usages = [];
+	let rolling = priorSummary;
+	let offset = 0;
+	while (offset < formatted.length) {
+		const chunk = await summarizeChunk(resolved, formatted.slice(offset, offset + COMPACTION_CHUNK_CHARS), rolling);
+		usages.push(chunk.usage);
+		rolling = chunk.summary;
+		offset += COMPACTION_CHUNK_CHARS;
+	}
+	return {
+		summary: rolling ?? "(empty summary)",
+		usages
+	};
+}
+function summaryToModelMessage(summary) {
+	return {
+		role: "user",
+		content: [
+			"Context summary from earlier in this session (older messages were compacted):",
+			"",
+			summary
+		].join("\n")
+	};
+}
+function summaryToUiMessage(summary) {
+	return {
+		id: generateId(),
+		role: "user",
+		parts: [{
+			type: "text",
+			text: [
+				"Context summary from earlier in this session (older messages were compacted):",
+				"",
+				summary
+			].join("\n")
+		}]
+	};
+}
+/**
+* Compact model messages with the compaction model. Retains a recent raw tail.
+* Caller supplies `compactedThroughSeq` for durable checkpoints (message event seq).
+*/
+async function compactModelMessages(options) {
+	const retain = options.retainTail ?? 4;
+	const { prefix, tail } = resolveCompactionSplit({
+		messages: options.messages,
+		retainTail: retain,
+		budget: options.budget ?? null,
+		hasPriorSummary: Boolean(options.priorSummary),
+		...options.overheadTokens !== void 0 ? { overheadTokens: options.overheadTokens } : {}
+	});
+	if (prefix.length === 0 && !options.priorSummary) throw new Error("Nothing to compact");
+	const compactedThroughSeq = typeof options.compactedThroughSeq === "function" ? options.compactedThroughSeq(prefix.length) : options.compactedThroughSeq;
+	const resolved = await resolveAgentModel(options.compactionModelId);
+	const { summary, usages } = await summarizeMessages(resolved, prefix.length > 0 ? prefix : [], options.priorSummary);
+	const primary = usages[0];
+	let quantity = 0;
+	let amount = 0;
+	let summaryInputTokens = 0;
+	let summaryOutputTokens = 0;
+	for (const usage of usages) {
+		quantity += usage.quantity;
+		amount += usage.amount;
+		if (typeof usage.metadata.input === "number") summaryInputTokens += usage.metadata.input;
+		if (typeof usage.metadata.output === "number") summaryOutputTokens += usage.metadata.output;
+	}
+	const usage = {
+		...primary,
+		quantity,
+		amount,
+		label: `LLM compaction · ${resolved.modelId}`,
+		metadata: {
+			...primary.metadata,
+			operation: "context_compaction",
+			sourceModel: options.sourceModel,
+			compactedThroughSeq,
+			durable: options.durable,
+			compactionChunks: usages.length,
+			input: summaryInputTokens || primary.metadata.input,
+			output: summaryOutputTokens || primary.metadata.output,
+			cost: {
+				...primary.metadata.cost ?? {},
+				total: amount
+			}
+		}
+	};
+	const checkpoint = {
+		compactedThroughSeq,
+		summary,
+		compactionModel: resolved.modelId,
+		sourceModel: options.sourceModel,
+		durable: options.durable,
+		...options.estimatedBeforeTokens !== void 0 ? { estimatedBeforeTokens: options.estimatedBeforeTokens } : {},
+		...options.actualBeforeTokens !== void 0 ? { actualBeforeTokens: options.actualBeforeTokens } : {},
+		retainedTailEstimate: estimateSerializedCharsApprox(tail),
+		summaryInputTokens: summaryInputTokens > 0 ? summaryInputTokens : void 0,
+		summaryOutputTokens: summaryOutputTokens > 0 ? summaryOutputTokens : void 0,
+		...options.budget ? {
+			contextWindow: options.budget.contextWindow,
+			softLimit: options.budget.softLimit
+		} : {},
+		...options.promptId !== void 0 ? { promptId: options.promptId } : {}
+	};
+	return {
+		messages: [summaryToModelMessage(summary), ...tail],
+		checkpoint,
+		usage
+	};
+}
+function estimateSerializedCharsApprox(messages) {
+	return Math.ceil(JSON.stringify(messages).length / 4);
+}
+/**
+* Rebuild model-facing UI messages from a durable checkpoint + newer transcript.
+* The full transcript is unchanged; this only shapes what the model sees.
+*/
+function rebuildMessagesFromCheckpoint(options) {
+	const { checkpoint, messageEvents } = options;
+	if (!checkpoint || !checkpoint.durable) return messageEvents.map((event) => event.message);
+	const suffix = messageEvents.filter((event) => event.seq > checkpoint.compactedThroughSeq).map((event) => event.message);
+	return [summaryToUiMessage(checkpoint.summary), ...suffix];
+}
+/** Parse a durable checkpoint from a persisted agent event payload. */
+function parseContextCompactionCheckpoint(payload) {
+	if (typeof payload !== "object" || payload === null) return null;
+	const record = payload;
+	const checkpoint = record.type === "context_compacted" && typeof record.checkpoint === "object" && record.checkpoint !== null ? record.checkpoint : record;
+	if (typeof checkpoint.compactedThroughSeq !== "number" || typeof checkpoint.summary !== "string" || typeof checkpoint.compactionModel !== "string" || typeof checkpoint.sourceModel !== "string" || typeof checkpoint.durable !== "boolean") return null;
+	return checkpoint;
+}
+//#endregion
+export { resolveModelCapabilities as C, withLlmRunContext as E, resolveAgentModel as S, splitAgentModelId as T, DEFAULT_THINKING_LEVEL as _, estimateSerializedChars as a, currentLlmRunContext as b, parseContextCompactionCheckpoint as c, resolveCompactionModelId as d, resolveContextBudget as f, DEFAULT_COMPACTION_MODEL_ID as g, AgentModelIdSchema as h, estimateChatAttachmentTokens as i, placeholderChatAttachmentMessages as l, AgentCreateInputSchema as m, byokFromResponseHeaders as n, llmUsageFromLanguageModelUsage as o, summaryToUiMessage as p, compactModelMessages as r, mapMessageFileParts as s, ContextBudgetTracker as t, rebuildMessagesFromCheckpoint as u, ThinkingLevelSchema as v, resolveThinkingLevel as w, parseAgentCreateInput as x, attachmentPlaceholderText as y };
+
+//# sourceMappingURL=context-compaction-Bxp4WK2B-Ct4RSjlg.mjs.map