@fevex/core 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/index.mjs

@@ -4,8 +4,8 @@ import { n as RunPausedError, t as FevexRunError } from "./run-error-Cr17wPGH.mj
 import { ChannelError, deliverChannelRun, handleChannelInput } from "./channels/index.mjs";
 import { InMemoryMemoryStore, createAgentsMdContextProvider, createMemoryContextProvider, defineContextProvider, defineSkill, isProgressiveSkillProvider, loadSkillFile, loadSkillFiles } from "./knowledge/index.mjs";
 import { n as teamAsWorkflow, t as defineTeam } from "./teams-Ctz676G4.mjs";
-import { InMemoryRunStore, isDurableRunStore, isRetainableRunStore, validateListEventsOptions, validatePurgeRunsOptions } from "./runtime/index.mjs";
-import { FEVEX_JSON_SCHEMA_PROFILE_VERSION, IntegrationError, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile } from "./tools/index.mjs";
+import { InMemoryRunStore, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions } from "./runtime/index.mjs";
+import { FEVEX_JSON_SCHEMA_PROFILE_VERSION, InMemoryToolEmbeddingCache, IntegrationError, buildToolEmbeddingIndex, compileFevexJsonSchema, cosineSimilarity, defineConnection, defineTool, schemaKeywords, searchToolEmbeddingIndex, toToolSpec, toolEmbeddingKey, toolEmbeddingText, validateFevexJsonSchemaProfile } from "./tools/index.mjs";
 import { _ as serializeValue, a as assertTokenBudget, c as eventUsage, d as remainingDeadlineMs, f as remainingOutputTokens, g as serializeJsonValue, h as toErrorMessage, i as assertContinuationBudget, l as isTimeoutError, m as runSignal, n as abortable, o as cancellationReason, p as resumeDeadlineSignal, r as addUsage, s as deadlineAtFromMs, u as minDeadline, v as toJsonValue } from "./run-support-CmZ6Xo6H.mjs";
 import { t as readModelStream } from "./model-stream-JQdHDDcj.mjs";
 import "./models/index.mjs";
@@ -67,6 +67,139 @@ async function validateSchema(schema, value, errorMessage) {
 	return result.value;
 }
 //#endregion
+//#region src/internal/tool-search.ts
+function resolveToolSearchOptions(options, label, defaultCache) {
+	if (options !== void 0 && (typeof options !== "object" || options === null || Array.isArray(options))) throw new TypeError(`${label} must be an object`);
+	const mode = options?.mode ?? "auto";
+	if (mode !== "auto" && mode !== "on" && mode !== "off") throw new TypeError(`${label}.mode must be auto, on or off`);
+	const threshold = options?.threshold ?? 30;
+	if (!Number.isSafeInteger(threshold) || threshold < 1) throw new TypeError(`${label}.threshold must be a positive safe integer`);
+	const tokenThreshold = options?.tokenThreshold;
+	if (tokenThreshold !== void 0 && (!Number.isSafeInteger(tokenThreshold) || tokenThreshold < 1)) throw new TypeError(`${label}.tokenThreshold must be a positive safe integer`);
+	const limit = options?.limit ?? 5;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 20) throw new TypeError(`${label}.limit must be a safe integer between 1 and 20`);
+	const pinned = options?.pinned ?? [];
+	if (!Array.isArray(pinned) || pinned.some((name) => typeof name !== "string" || !name.trim())) throw new TypeError(`${label}.pinned must contain non-empty tool names`);
+	const normalizedPinned = [...new Set(pinned.map((name) => name.trim()))];
+	if (normalizedPinned.length !== pinned.length) throw new TypeError(`${label}.pinned must contain unique tool names`);
+	const semantic = options?.semantic;
+	return {
+		mode,
+		threshold,
+		...tokenThreshold === void 0 ? {} : { tokenThreshold },
+		limit,
+		pinned: normalizedPinned,
+		...semantic === void 0 ? {} : { semantic: resolveSemanticOptions(semantic, `${label}.semantic`, defaultCache) }
+	};
+}
+function serializeToolSearchOptions(options) {
+	return {
+		mode: options.mode,
+		threshold: options.threshold,
+		...options.tokenThreshold === void 0 ? {} : { tokenThreshold: options.tokenThreshold },
+		limit: options.limit,
+		pinned: [...options.pinned]
+	};
+}
+function reciprocalRankFusionCandidates(lexical, semantic, limit, rankConstant = 60) {
+	if (!Number.isSafeInteger(limit) || limit < 1) throw new TypeError("Tool search fusion limit must be a positive safe integer");
+	if (!Number.isSafeInteger(rankConstant) || rankConstant < 1) throw new TypeError("Tool search fusion rankConstant must be a positive safe integer");
+	const scores = /* @__PURE__ */ new Map();
+	const add = (tools) => {
+		for (let index = 0; index < tools.length; index += 1) {
+			const tool = tools[index];
+			const entry = scores.get(tool.name) ?? {
+				tool,
+				score: 0
+			};
+			entry.score += 1 / (rankConstant + index + 1);
+			scores.set(tool.name, entry);
+		}
+	};
+	add(lexical);
+	add(semantic);
+	return [...scores.values()].sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name)).slice(0, limit);
+}
+function resolveSemanticOptions(semantic, label, defaultCache) {
+	if (typeof semantic !== "object" || semantic === null || Array.isArray(semantic)) throw new TypeError(`${label} must be an object`);
+	const embeddings = semantic.embeddings;
+	if (typeof embeddings !== "object" || embeddings === null || typeof embeddings.id !== "string" || !embeddings.id.trim() || typeof embeddings.embed !== "function") throw new TypeError(`${label}.embeddings must implement EmbeddingModel`);
+	if (embeddings.dimensions !== void 0 && (!Number.isSafeInteger(embeddings.dimensions) || embeddings.dimensions < 1)) throw new TypeError(`${label}.embeddings.dimensions must be a positive safe integer`);
+	const cache = semantic.cache ?? defaultCache;
+	if (cache === void 0 || typeof cache.get !== "function" || typeof cache.set !== "function") throw new TypeError(`${label}.cache must implement get and set`);
+	const topK = semantic.topK ?? 20;
+	if (!Number.isSafeInteger(topK) || topK < 1) throw new TypeError(`${label}.topK must be a positive safe integer`);
+	const minScore = semantic.minScore ?? 0;
+	if (typeof minScore !== "number" || !Number.isFinite(minScore) || minScore < -1 || minScore > 1) throw new TypeError(`${label}.minScore must be a finite number between -1 and 1`);
+	const reranker = semantic.reranker;
+	if (reranker !== void 0 && (typeof reranker !== "object" || reranker === null || typeof reranker.rerank !== "function")) throw new TypeError(`${label}.reranker must implement rerank`);
+	return {
+		embeddings,
+		cache,
+		topK,
+		minScore,
+		...reranker === void 0 ? {} : { reranker }
+	};
+}
+function shouldUseToolSearch(options, tools) {
+	if (options.mode === "off" || tools.length === 0) return false;
+	if (options.mode === "on") return true;
+	if (tools.length > options.threshold) return true;
+	if (options.tokenThreshold === void 0) return false;
+	return Math.ceil(JSON.stringify(tools).length / 4) > options.tokenThreshold;
+}
+const searchIndex = /* @__PURE__ */ new WeakMap();
+function indexedTools(tools) {
+	const cached = searchIndex.get(tools);
+	if (cached !== void 0) return cached;
+	const index = tools.map((tool) => {
+		const name = tool.name.toLowerCase();
+		const description = (tool.description ?? "").toLowerCase();
+		return {
+			tool,
+			name,
+			nameTerms: new Set(name.split(/[^a-z0-9]+/).filter(Boolean)),
+			description,
+			descriptionTerms: new Set(description.split(/[^a-z0-9]+/).filter(Boolean)),
+			schema: JSON.stringify(tool.inputSchema ?? {}).toLowerCase()
+		};
+	});
+	searchIndex.set(tools, index);
+	return index;
+}
+function searchToolSpecs(tools, query, limit) {
+	const terms = [...new Set(query.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1))];
+	if (terms.length === 0) return [];
+	return indexedTools(tools).map(({ tool, name, nameTerms, description, descriptionTerms, schema }) => {
+		let score = 0;
+		for (const term of terms) {
+			if (name === term) score += 100;
+			else if (nameTerms.has(term)) score += 40;
+			else if (name.startsWith(term)) score += 30;
+			else if (name.includes(term)) score += 20;
+			if (descriptionTerms.has(term)) score += 8;
+			else if (description.includes(term)) score += 5;
+			if (schema.includes(term)) score += 1;
+		}
+		return {
+			tool,
+			score
+		};
+	}).filter(({ score }) => score > 0).sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name)).slice(0, limit).map(({ tool }) => tool);
+}
+function readToolSearchInput(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new TypeError("Tool search input must be an object");
+	const record = input;
+	const query = record.query;
+	const limit = record.limit;
+	if (typeof query !== "string" || !query.trim()) throw new TypeError("Tool search query must be a non-empty string");
+	if (limit !== void 0 && (typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 1)) throw new TypeError("Tool search limit must be a positive safe integer");
+	return {
+		query: query.trim(),
+		...limit === void 0 ? {} : { limit }
+	};
+}
+//#endregion
 //#region src/internal/configuration.ts
 const REASONING_EFFORTS = /* @__PURE__ */ new Set([
 	"provider-default",
@@ -190,6 +323,7 @@ function expandConnection(connection) {
 		};
 		assertConfiguration(policy?.inputSchema === void 0 || isJsonObject(policy.inputSchema), "INVALID_TOOL", `Input schema for connection tool "${remoteName}" must be a JSON object`);
 		assertConfiguration(policy?.outputSchema === void 0 || isJsonObject(policy.outputSchema), "INVALID_TOOL", `Output schema for connection tool "${remoteName}" must be a JSON object`);
+		assertConfiguration(policy?.maxResultBytes === void 0 || policy.maxResultBytes === false || Number.isSafeInteger(policy.maxResultBytes) && policy.maxResultBytes > 0, "INVALID_TOOL", `maxResultBytes for connection tool "${remoteName}" must be a positive safe integer or false`);
 		return {
 			name: namespacedToolName(connection.name, remoteName),
 			...policy?.label === void 0 ? {} : { label: policy.label },
@@ -201,6 +335,7 @@ function expandConnection(connection) {
 			...policy?.idempotency === void 0 ? {} : { idempotency: policy.idempotency },
 			...policy?.retry === void 0 ? {} : { retry: policy.retry },
 			...policy?.credentials === void 0 ? {} : { credentials: policy.credentials },
+			...policy?.maxResultBytes === void 0 ? {} : { maxResultBytes: policy.maxResultBytes },
 			source,
 			async resolve(context) {
 				try {
@@ -300,6 +435,24 @@ function createComposition(config) {
 	assertConfiguration(config.tools === void 0 || Array.isArray(config.tools), "INVALID_CONFIG", "Fevex config \"tools\" must be an array");
 	assertConfiguration(config.connections === void 0 || Array.isArray(config.connections), "INVALID_CONFIG", "Fevex config \"connections\" must be an array");
 	assertConfiguration(config.contextProviders === void 0 || Array.isArray(config.contextProviders), "INVALID_CONFIG", "Fevex config \"contextProviders\" must be an array");
+	if (config.contextBudget !== void 0) try {
+		resolveContextBudget(config.contextBudget, "Fevex config \"contextBudget\"");
+	} catch (error) {
+		throw configurationError("INVALID_CONFIG", error.message);
+	}
+	assertConfiguration(config.toolSearchCache === void 0 || isRecord(config.toolSearchCache) && typeof config.toolSearchCache.get === "function" && typeof config.toolSearchCache.set === "function", "INVALID_CONFIG", "Fevex config \"toolSearchCache\" must implement get and set");
+	const defaultToolSearchCache = config.toolSearchCache ?? new InMemoryToolEmbeddingCache();
+	if (config.toolSearch !== void 0) try {
+		resolveToolSearchOptions(config.toolSearch, "Fevex config \"toolSearch\"", defaultToolSearchCache);
+	} catch (error) {
+		throw configurationError("INVALID_CONFIG", error.message);
+	}
+	if (config.compaction !== void 0) {
+		assertConfiguration(typeof config.compaction === "object" && config.compaction !== null && !Array.isArray(config.compaction), "INVALID_CONFIG", "Fevex config \"compaction\" must be an object");
+		assertConfiguration(config.compaction.compactor === void 0 || isRecord(config.compaction.compactor) && typeof config.compaction.compactor.compact === "function", "INVALID_CONFIG", "Fevex config \"compaction.compactor\" must implement compact");
+		assertConfiguration(config.compaction.estimateTokens === void 0 || typeof config.compaction.estimateTokens === "function", "INVALID_CONFIG", "Fevex config \"compaction.estimateTokens\" must be a function");
+		assertConfiguration(config.compaction.redactSummary === void 0 || typeof config.compaction.redactSummary === "function", "INVALID_CONFIG", "Fevex config \"compaction.redactSummary\" must be a function");
+	}
 	assertConfiguration(config.memoryStore === void 0 || isMemoryStore(config.memoryStore), "INVALID_CONFIG", "Fevex config \"memoryStore\" must implement MemoryStore");
 	assertConfiguration(config.onEvent === void 0 || typeof config.onEvent === "function", "INVALID_CONFIG", "Fevex config \"onEvent\" must be a function");
 	assertConfiguration(config.runStore === void 0 || isRunStore(config.runStore), "INVALID_CONFIG", "Fevex config \"runStore\" must implement RunStore");
@@ -385,6 +538,7 @@ function createComposition(config) {
 		assertConfiguration(definition.credentials === void 0 || Array.isArray(definition.credentials) && definition.credentials.every((value) => typeof value === "string" && value.trim()), "INVALID_TOOL", `Tool "${name}" credentials must be non-empty strings`);
 		assertSandboxCapabilities(definition.sandbox, name);
 		assertConfiguration(definition.sandbox === void 0 || config.sandbox !== void 0, "INVALID_TOOL", `Tool "${name}" requires Fevex config "sandbox"`);
+		assertConfiguration(definition.maxResultBytes === void 0 || definition.maxResultBytes === false || Number.isSafeInteger(definition.maxResultBytes) && definition.maxResultBytes > 0, "INVALID_TOOL", `Tool "${name}" maxResultBytes must be a positive safe integer or false`);
 		if (definition.retry !== void 0) assertConfiguration(isRecord(definition.retry) && Number.isInteger(definition.retry.maxAttempts) && definition.retry.maxAttempts >= 1 && Number.isInteger(definition.retry.backoffMs) && definition.retry.backoffMs >= 0 && (definition.retry.maxBackoffMs === void 0 || Number.isInteger(definition.retry.maxBackoffMs) && definition.retry.maxBackoffMs >= 0), "INVALID_TOOL", `Tool "${name}" retry is invalid`);
 		if (definition.inputSchema !== void 0) assertConfiguration(isStandardSchema(definition.inputSchema), "INVALID_TOOL", `Input schema for tool "${name}" must implement Standard Schema`);
 		if (definition.inputSchema !== void 0) assertConfiguration(isStandardSchema(definition.inputSchema), "INVALID_AGENT", `Input schema for agent "${name}" must implement Standard Schema`);
@@ -404,6 +558,7 @@ function createComposition(config) {
 			...definition.idempotency === void 0 ? {} : { idempotency: definition.idempotency },
 			...definition.retry === void 0 ? {} : { retry: { ...definition.retry } },
 			...definition.credentials === void 0 ? {} : { credentials: [...definition.credentials] },
+			...definition.maxResultBytes === void 0 ? {} : { maxResultBytes: definition.maxResultBytes },
 			...definition.sandbox === void 0 ? {} : { sandbox: copySandboxCapabilities(definition.sandbox) },
 			...definition.source === void 0 ? {} : { source: { ...definition.source } },
 			...definition.resolve === void 0 ? {} : { resolve: definition.resolve },
@@ -475,12 +630,23 @@ function createComposition(config) {
 		assertConfiguration(definition.approvalMode === void 0 || definition.approvalMode === "pause" || definition.approvalMode === "deny", "INVALID_AGENT", `Agent "${name}" approvalMode is invalid`);
 		assertConfiguration(definition.toolChoice === void 0 || definition.toolChoice === "auto" || definition.toolChoice === "required" || definition.toolChoice === "none" || isRecord(definition.toolChoice) && typeof definition.toolChoice.name === "string" && Boolean(definition.toolChoice.name.trim()), "INVALID_AGENT", `Agent "${name}" toolChoice is invalid`);
 		assertConfiguration(definition.limits === void 0 || isRecord(definition.limits), "INVALID_AGENT", `Agent "${name}" limits must be an object`);
+		if (definition.contextBudget !== void 0) try {
+			resolveContextBudget(definition.contextBudget, `Agent "${name}" contextBudget`);
+		} catch (error) {
+			throw configurationError("INVALID_AGENT", error.message);
+		}
+		if (definition.toolSearch !== void 0) try {
+			resolveToolSearchOptions(definition.toolSearch, `Agent "${name}" toolSearch`, defaultToolSearchCache);
+		} catch (error) {
+			throw configurationError("INVALID_AGENT", error.message);
+		}
 		if (definition.outputSchema !== void 0) assertConfiguration(isStandardSchema(definition.outputSchema), "INVALID_AGENT", `Output schema for agent "${name}" must implement Standard Schema`);
 		const rawLimits = definition.limits;
 		assertLimit(rawLimits?.maxSteps, "maxSteps", 1, name);
 		assertLimit(rawLimits?.maxToolCalls, "maxToolCalls", 0, name);
 		assertLimit(rawLimits?.maxInputTokens, "maxInputTokens", 1, name, true);
 		assertLimit(rawLimits?.maxOutputTokens, "maxOutputTokens", 1, name, true);
+		assertLimit(rawLimits?.maxToolResultBytes, "maxToolResultBytes", 1, name, true);
 		agents.set(name, {
 			name,
 			instructions: definition.instructions,
@@ -498,13 +664,19 @@ function createComposition(config) {
 			...definition.toolChoice === void 0 ? {} : { toolChoice: typeof definition.toolChoice === "string" ? definition.toolChoice : { name: definition.toolChoice.name } },
 			...definition.elicitation === void 0 ? {} : { elicitation: definition.elicitation },
 			...definition.approvalMode === void 0 ? {} : { approvalMode: definition.approvalMode },
+			...definition.contextBudget === void 0 ? {} : { contextBudget: { ...definition.contextBudget } },
+			...definition.toolSearch === void 0 ? {} : { toolSearch: {
+				...definition.toolSearch,
+				...definition.toolSearch.pinned === void 0 ? {} : { pinned: [...definition.toolSearch.pinned] }
+			} },
 			...definition.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
 			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
 			...rawLimits === void 0 ? {} : { limits: {
 				...rawLimits.maxSteps === void 0 ? {} : { maxSteps: rawLimits.maxSteps },
 				...rawLimits.maxToolCalls === void 0 ? {} : { maxToolCalls: rawLimits.maxToolCalls },
 				...rawLimits.maxInputTokens === void 0 ? {} : { maxInputTokens: rawLimits.maxInputTokens },
-				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens }
+				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens },
+				...rawLimits.maxToolResultBytes === void 0 ? {} : { maxToolResultBytes: rawLimits.maxToolResultBytes }
 			} }
 		});
 	}
@@ -541,6 +713,7 @@ function createComposition(config) {
 		assertLimit(rawLimits?.maxToolCalls, "maxToolCalls", 0, name, false, "Workflow", "INVALID_WORKFLOW");
 		assertLimit(rawLimits?.maxInputTokens, "maxInputTokens", 1, name, true, "Workflow", "INVALID_WORKFLOW");
 		assertLimit(rawLimits?.maxOutputTokens, "maxOutputTokens", 1, name, true, "Workflow", "INVALID_WORKFLOW");
+		assertLimit(rawLimits?.maxToolResultBytes, "maxToolResultBytes", 1, name, false, "Workflow", "INVALID_WORKFLOW");
 		assertConfiguration(!workflows.has(name), "DUPLICATE_WORKFLOW", `Workflow "${name}" is duplicated`);
 		workflows.set(name, {
 			name,
@@ -552,7 +725,8 @@ function createComposition(config) {
 				...rawLimits.maxSteps === void 0 ? {} : { maxSteps: rawLimits.maxSteps },
 				...rawLimits.maxToolCalls === void 0 ? {} : { maxToolCalls: rawLimits.maxToolCalls },
 				...rawLimits.maxInputTokens === void 0 ? {} : { maxInputTokens: rawLimits.maxInputTokens },
-				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens }
+				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens },
+				...rawLimits.maxToolResultBytes === void 0 ? {} : { maxToolResultBytes: rawLimits.maxToolResultBytes }
 			} },
 			run: definition.run
 		});
@@ -591,6 +765,7 @@ function createComposition(config) {
 		assertLimit(rawLimits?.maxToolCalls, "maxToolCalls", 0, name, false, "Team", "INVALID_TEAM");
 		assertLimit(rawLimits?.maxInputTokens, "maxInputTokens", 1, name, true, "Team", "INVALID_TEAM");
 		assertLimit(rawLimits?.maxOutputTokens, "maxOutputTokens", 1, name, true, "Team", "INVALID_TEAM");
+		assertLimit(rawLimits?.maxToolResultBytes, "maxToolResultBytes", 1, name, false, "Team", "INVALID_TEAM");
 		assertConfiguration(!teams.has(name), "DUPLICATE_TEAM", `Team "${name}" is duplicated`);
 		assertConfiguration(!workflows.has(name), "INVALID_TEAM", `Team "${name}" conflicts with a workflow of the same name`);
 		const team = {
@@ -606,7 +781,8 @@ function createComposition(config) {
 				...rawLimits.maxSteps === void 0 ? {} : { maxSteps: rawLimits.maxSteps },
 				...rawLimits.maxToolCalls === void 0 ? {} : { maxToolCalls: rawLimits.maxToolCalls },
 				...rawLimits.maxInputTokens === void 0 ? {} : { maxInputTokens: rawLimits.maxInputTokens },
-				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens }
+				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens },
+				...rawLimits.maxToolResultBytes === void 0 ? {} : { maxToolResultBytes: rawLimits.maxToolResultBytes }
 			} },
 			run: definition.run
 		};
@@ -621,6 +797,17 @@ function createComposition(config) {
 		teams,
 		tools,
 		contextProviders,
+		contextBudget: config.contextBudget === void 0 ? void 0 : { ...config.contextBudget },
+		toolSearch: config.toolSearch === void 0 ? void 0 : {
+			...config.toolSearch,
+			...config.toolSearch.pinned === void 0 ? {} : { pinned: [...config.toolSearch.pinned] }
+		},
+		toolSearchCache: defaultToolSearchCache,
+		compaction: {
+			compactor: config.compaction?.compactor ?? createDigestContextCompactor(),
+			estimateTokens: config.compaction?.estimateTokens ?? estimateContextTokens,
+			...config.compaction?.redactSummary === void 0 ? {} : { redactSummary: config.compaction.redactSummary }
+		},
 		memoryStore: config.memoryStore ?? (usesMemory ? new InMemoryMemoryStore() : void 0),
 		runStore: config.runStore ?? new InMemoryRunStore(),
 		credentialStore: config.credentialStore,
@@ -651,6 +838,10 @@ const LEASE_RENEW_MS = 1e4;
 const ELICIT_TOOL_NAME = "fevex__elicit";
 /** Reserved name of the internal progressive skill loader exposed to the model. */
 const LOAD_SKILL_TOOL_NAME = "fevex__load_skill";
+/** Reserved name of the internal on-demand tool search exposed to the model. */
+const SEARCH_TOOLS_TOOL_NAME = "fevex__search_tools";
+/** Default safety cap for one serialized tool result. */
+const DEFAULT_MAX_TOOL_RESULT_BYTES = 1048576;
 //#endregion
 //#region src/internal/run-helpers.ts
 function redact(message, secrets) {
@@ -778,6 +969,208 @@ const runErrorPayload = (error) => {
 	};
 };
 //#endregion
+//#region src/internal/agent-internal-tools.ts
+async function executeInternalTool(input) {
+	if (input.call.name === "fevex__search_tools") {
+		if (!input.searchEnabled) return void 0;
+		const search = readToolSearchInput(input.input);
+		const limit = Math.min(search.limit ?? input.toolSearch.limit, input.toolSearch.limit);
+		const semantic = input.toolSearch.semantic;
+		const candidateLimit = Math.max(limit, semantic?.topK ?? limit);
+		const lexical = searchToolSpecs(input.tools, search.query, candidateLimit);
+		let matches = lexical;
+		if (semantic !== void 0) try {
+			if (input.semanticState.index === void 0 && !input.semanticState.attempted) {
+				input.semanticState.attempted = true;
+				input.semanticState.index = await buildToolEmbeddingIndex({
+					tools: input.tools,
+					embeddings: semantic.embeddings,
+					cache: semantic.cache,
+					...input.signal === void 0 ? {} : { signal: input.signal }
+				});
+			}
+			if (input.semanticState.index !== void 0) {
+				const queryVector = (await semantic.embeddings.embed({
+					texts: [search.query],
+					...input.signal === void 0 ? {} : { signal: input.signal }
+				}))[0];
+				if (!queryVector) throw new Error("Embedding model returned no query vector");
+				const semanticMatches = searchToolEmbeddingIndex(input.semanticState.index, queryVector, semantic.topK, semantic.minScore);
+				if (semanticMatches.length > 0) {
+					const fusionLimit = semantic.reranker === void 0 ? limit : Math.max(limit, semantic.topK);
+					const fused = reciprocalRankFusionCandidates(lexical, semanticMatches.map((match) => match.tool), fusionLimit);
+					if (semantic.reranker !== void 0 && fused.length > 1) matches = (await rerankToolCandidates(semantic.reranker, search.query, fused, limit, input.signal) ?? fused).map((candidate) => candidate.tool);
+					else matches = fused.map((candidate) => candidate.tool);
+				}
+			}
+		} catch (error) {
+			if (input.signal?.aborted) throw error;
+			matches = lexical;
+		}
+		const selected = matches.slice(0, limit);
+		for (const match of selected) input.loadedTools.add(match.name);
+		return { content: serializeValue({
+			tools: selected.map((tool) => ({
+				name: tool.name,
+				...tool.description === void 0 ? {} : { description: tool.description }
+			})),
+			...selected.length === 0 ? { message: "No tools matched; try a different query." } : {}
+		}, "Tool search result must be serializable") };
+	}
+	if (input.call.name === "fevex__load_skill") {
+		if (input.progressiveSkills.length === 0) return void 0;
+		const skillInput = readSkillInput(input.input);
+		const skill = input.progressiveSkills.find((item) => item.name === skillInput.name);
+		if (!skill) throw new Error(`Skill "${skillInput.name}" is not available`);
+		try {
+			return { content: (await abortable(() => skill.load(input.knowledgeContext, skillInput.resource), input.signal)).filter((block) => block.content.trim()).map((block) => `[Skill: ${skill.name}/${block.id}]\n${block.content}`).join("\n\n") };
+		} catch (error) {
+			throw new Error(`Skill provider "${skill.name}" failed: ${toErrorMessage(error)}`, { cause: error });
+		}
+	}
+}
+async function rerankToolCandidates(reranker, query, candidates, limit, signal) {
+	try {
+		const result = await reranker.rerank({
+			query,
+			tools: candidates,
+			limit,
+			...signal === void 0 ? {} : { signal }
+		});
+		if (!Array.isArray(result)) return void 0;
+		const byName = new Map(candidates.map((candidate) => [candidate.tool.name, candidate]));
+		const seen = /* @__PURE__ */ new Set();
+		const ordered = [];
+		for (const candidate of result) {
+			const name = candidate?.tool?.name;
+			const original = typeof name === "string" ? byName.get(name) : void 0;
+			if (!original || seen.has(name)) return void 0;
+			seen.add(name);
+			ordered.push(original);
+		}
+		return ordered.slice(0, limit);
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return;
+	}
+}
+function readSkillInput(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new TypeError(`${LOAD_SKILL_TOOL_NAME} input must be an object`);
+	const record = input;
+	const name = record.name;
+	const resource = record.resource;
+	if (typeof name !== "string" || !name.trim()) throw new TypeError(`${LOAD_SKILL_TOOL_NAME} name must be a non-empty string`);
+	if (resource !== void 0 && (typeof resource !== "string" || !resource.trim())) throw new TypeError(`${LOAD_SKILL_TOOL_NAME} resource must be a non-empty string`);
+	return {
+		name: name.trim(),
+		...resource === void 0 ? {} : { resource: resource.trim() }
+	};
+}
+//#endregion
+//#region src/internal/context-compaction.ts
+/** Maximum summary characters copied into the context.compacted event. */
+const MAX_COMPACTION_EVENT_SUMMARY_CHARS = 4e3;
+/** Keeps the newest summary segments instead of cutting mid-sentence. */
+function capSummary(summary, maxChars) {
+	if (summary.length <= maxChars) return summary;
+	const tail = summary.slice(summary.length - maxChars + 1);
+	const boundary = tail.indexOf("\n\n");
+	return `…${boundary === -1 ? tail : tail.slice(boundary + 2)}`;
+}
+async function compactContext(input) {
+	const estimateWith = (messages, includeTools) => {
+		const value = input.estimateTokens({
+			messages,
+			...includeTools ? { tools: input.tools } : {}
+		});
+		if (!Number.isFinite(value) || value < 0) throw new TypeError("Context token estimator must return a non-negative finite number");
+		return Math.ceil(value * input.contextBudget.safetyFactor);
+	};
+	const estimate = (messages) => estimateWith(messages, true);
+	const estimated = estimate(input.messages);
+	const usable = input.contextBudget.contextWindow - input.contextBudget.reserveOutputTokens;
+	const threshold = Math.floor(usable * input.contextBudget.compactAt);
+	if (input.allowCompaction === false || estimated <= threshold) {
+		if (estimated > usable) throw new FevexRunError("CONTEXT_BUDGET_EXCEEDED", `Agent "${input.agentName}" context budget exceeded: ${estimated} tokens > ${usable} usable${input.allowCompaction === false ? " after compaction" : ""}.`, input.runId);
+		return;
+	}
+	const split = splitContextForCompaction(input.messages);
+	if (split === void 0 || split.compactable.length === 0) {
+		if (estimated > usable) throw new FevexRunError("CONTEXT_BUDGET_EXCEEDED", `Agent "${input.agentName}" context budget exceeded: ${estimated} tokens > ${usable} usable. The preserved system prefix and current turn cannot be compacted further.`, input.runId);
+		return;
+	}
+	const preservedTokens = estimate([...split.prefix, ...split.currentTurn]);
+	const available = Math.max(1, Math.min(input.contextBudget.targetTokens, usable - 1) - preservedTokens);
+	const compactedMessages = validateCompactedMessages(await abortable(() => input.compactor.compact({
+		agentName: input.agentName,
+		sessionId: input.sessionId,
+		messages: split.compactable,
+		tools: input.tools,
+		estimatedTokens: estimated,
+		targetTokens: available,
+		contextWindow: input.contextBudget.contextWindow,
+		step: input.step,
+		...input.context === void 0 ? {} : { context: input.context },
+		signal: input.signal,
+		estimateTokens: (messages) => estimateWith(messages, false)
+	}), input.signal));
+	const messages = [
+		...split.prefix,
+		...compactedMessages,
+		...split.currentTurn
+	];
+	const compactedTokens = estimate(messages);
+	if (compactedTokens > usable) throw new FevexRunError("CONTEXT_BUDGET_EXCEEDED", `Agent "${input.agentName}" context budget exceeded after compaction: ${compactedTokens} tokens > ${usable} usable. The preserved system prefix and current turn cannot be compacted further.`, input.runId);
+	return {
+		messages,
+		removedMessages: split.compactable.length,
+		estimatedTokens: estimated,
+		compactedTokens,
+		summary: compactedMessages.map((message) => message.content).join("\n\n")
+	};
+}
+function splitContextForCompaction(messages) {
+	let lastUser = -1;
+	for (let index = messages.length - 1; index >= 0; index -= 1) if (messages[index].role === "user") {
+		lastUser = index;
+		break;
+	}
+	if (lastUser < 0) return void 0;
+	let lastToolBatch = -1;
+	for (let index = messages.length - 1; index > lastUser; index -= 1) {
+		const message = messages[index];
+		if (message.role === "assistant" && (message.toolCalls?.length ?? 0) > 0) {
+			lastToolBatch = index;
+			break;
+		}
+	}
+	const prefix = messages.filter((message) => message.role === "system");
+	const currentTurn = (lastToolBatch === -1 ? messages.slice(lastUser) : [messages[lastUser], ...messages.slice(lastToolBatch)]).filter((message) => message.role !== "system");
+	const preserved = /* @__PURE__ */ new Set([...prefix, ...currentTurn]);
+	return {
+		prefix,
+		currentTurn,
+		compactable: messages.filter((message) => message.role !== "system" && !preserved.has(message))
+	};
+}
+function validateCompactedMessages(value) {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError("Context compactor must return at least one message");
+	const roles = /* @__PURE__ */ new Set([
+		"system",
+		"user",
+		"assistant",
+		"tool"
+	]);
+	for (const [index, message] of value.entries()) {
+		if (typeof message !== "object" || message === null || Array.isArray(message)) throw new TypeError(`Context compactor message at index ${index} must be an object`);
+		const record = message;
+		if (typeof record.role !== "string" || !roles.has(record.role)) throw new TypeError(`Context compactor message at index ${index} has an invalid role`);
+		if (typeof record.content !== "string") throw new TypeError(`Context compactor message at index ${index} must have string content`);
+		if (record.toolCalls !== void 0 && !Array.isArray(record.toolCalls)) throw new TypeError(`Context compactor message at index ${index} has invalid toolCalls`);
+	}
+	return value;
+}
+//#endregion
 //#region src/internal/definition-hash.ts
 function canonicalize(value) {
 	if (Array.isArray(value)) return value.map(canonicalize);
@@ -796,6 +1189,7 @@ async function transportableTool(tool) {
 		retry: tool.retry,
 		credentials: tool.credentials ?? [],
 		sandbox: tool.sandbox,
+		maxResultBytes: tool.maxResultBytes,
 		source: tool.source
 	};
 }
@@ -804,7 +1198,7 @@ async function sha256(value) {
 	const digest = await crypto.subtle.digest("SHA-256", encoded);
 	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-async function definitionHash(name, modelName, agent, tools) {
+async function definitionHash(name, modelName, agent, tools, contextBudget) {
 	const toolDefinitions = await Promise.all((agent.tools ?? []).map((toolName) => transportableTool(tools.get(toolName))));
 	return sha256({
 		name,
@@ -820,6 +1214,7 @@ async function definitionHash(name, modelName, agent, tools) {
 		elicitation: agent.elicitation,
 		approvalMode: agent.approvalMode,
 		limits: agent.limits,
+		contextBudget,
 		inputSchema: agent.inputSchema === void 0 ? void 0 : toTransportableSchema(agent.inputSchema, "input", `Input schema for agent "${name}" is not transportable`),
 		outputSchema: agent.outputSchema === void 0 ? void 0 : toTransportableSchema(agent.outputSchema, "output", `Output schema for agent "${name}" is not transportable`)
 	});
@@ -864,7 +1259,8 @@ function combineLimits(first, second) {
 		...minLimit(first.maxSteps, second.maxSteps) === void 0 ? {} : { maxSteps: minLimit(first.maxSteps, second.maxSteps) },
 		...minLimit(first.maxToolCalls, second.maxToolCalls) === void 0 ? {} : { maxToolCalls: minLimit(first.maxToolCalls, second.maxToolCalls) },
 		...minLimit(first.maxInputTokens, second.maxInputTokens) === void 0 ? {} : { maxInputTokens: minLimit(first.maxInputTokens, second.maxInputTokens) },
-		...minLimit(first.maxOutputTokens, second.maxOutputTokens) === void 0 ? {} : { maxOutputTokens: minLimit(first.maxOutputTokens, second.maxOutputTokens) }
+		...minLimit(first.maxOutputTokens, second.maxOutputTokens) === void 0 ? {} : { maxOutputTokens: minLimit(first.maxOutputTokens, second.maxOutputTokens) },
+		...minLimit(first.maxToolResultBytes, second.maxToolResultBytes) === void 0 ? {} : { maxToolResultBytes: minLimit(first.maxToolResultBytes, second.maxToolResultBytes) }
 	};
 }
 function subtractLimit(limit, used) {
@@ -877,7 +1273,8 @@ function remainingWorkflowLimits(limits, budget) {
 		...limits.maxSteps === void 0 ? {} : { maxSteps: subtractLimit(limits.maxSteps, budget?.steps) },
 		...limits.maxToolCalls === void 0 ? {} : { maxToolCalls: subtractLimit(limits.maxToolCalls, budget?.toolCalls) },
 		...limits.maxInputTokens === void 0 ? {} : { maxInputTokens: subtractLimit(limits.maxInputTokens, budget?.usage?.inputTokens) },
-		...limits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: subtractLimit(limits.maxOutputTokens, budget?.usage?.outputTokens) }
+		...limits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: subtractLimit(limits.maxOutputTokens, budget?.usage?.outputTokens) },
+		...limits.maxToolResultBytes === void 0 ? {} : { maxToolResultBytes: limits.maxToolResultBytes }
 	};
 }
 function assertWorkflowBudget(workflowName, limits, budget) {
@@ -904,12 +1301,24 @@ function addWorkflowBudget(first, second) {
 * engine — that direction is what keeps the two separable.
 */
 function createAgentEngine(composition, core) {
-	const { models, agents, tools, contextProviders, memoryStore, runStore, credentialStore, sandbox, artifacts, policies } = composition;
+	const { models, agents, tools, contextProviders, contextBudget: defaultContextBudget, compaction, toolSearch: defaultToolSearch, toolSearchCache: defaultToolSearchCache, memoryStore, runStore, credentialStore, sandbox, artifacts, policies } = composition;
+	const compactionStats = {
+		compactions: 0,
+		removedMessages: 0,
+		estimatedTokens: 0,
+		compactedTokens: 0,
+		savedTokens: 0
+	};
 	const { activeRuns, activeSessions, runtimeOwner, isClosed, admitStart, markInternalRun, resolveModel, resolveCheckpointModel, notifyObserver, createEvent, emitEvent, releaseExecution, commit, startLease, cancelExecution, authorize } = core;
 	const prepareExecutionBody = async (name, request, internal = false, correlation = {}) => {
 		if (!internal && isClosed()) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs");
 		const agent = agents.get(name);
 		if (!agent) throw new FevexRunError("AGENT_NOT_FOUND", `Agent "${name}" is not registered`);
+		const contextBudget = resolveContextBudget(request.contextBudget ?? agent.contextBudget ?? defaultContextBudget, `Agent "${name}" contextBudget`);
+		const toolSearch = resolveToolSearchOptions(request.toolSearch ?? agent.toolSearch ?? defaultToolSearch, `Agent "${name}" toolSearch`, defaultToolSearchCache);
+		const toolChoice = effectiveToolChoice(agent, request);
+		const initialLoadedTools = new Set(toolSearch.pinned.filter((toolName) => agent.tools?.includes(toolName)));
+		if (typeof toolChoice === "object" && agent.tools?.includes(toolChoice.name)) initialLoadedTools.add(toolChoice.name);
 		const { modelName, model } = resolveModel(agent, request.model);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		let session;
@@ -967,7 +1376,7 @@ function createAgentEngine(composition, core) {
 						content: agent.instructions
 					},
 					...knowledge.skills,
-					...session.history,
+					...sessionHistoryMessages(session),
 					...knowledge.context,
 					...knowledge.memory,
 					{
@@ -980,8 +1389,11 @@ function createAgentEngine(composition, core) {
 					runId: run.id,
 					...request.model !== void 0 || typeof agent.model === "string" ? { modelName } : {},
 					...request.reasoning === void 0 ? {} : { reasoning: request.reasoning },
-					definitionHash: await definitionHash(name, modelName, agent, tools),
+					definitionHash: await definitionHash(name, modelName, agent, tools, contextBudget),
 					limits: combineLimits(agent.limits, request.limits),
+					...contextBudget === void 0 ? {} : { contextBudget },
+					toolSearch: serializeToolSearchOptions(toolSearch),
+					loadedTools: [...initialLoadedTools],
 					messages,
 					inputContent,
 					context: request.context,
@@ -992,7 +1404,7 @@ function createAgentEngine(composition, core) {
 					pendingIndex: 0,
 					effectiveElicitationMode: effectiveElicitationMode(agent, request),
 					effectiveApprovalMode: effectiveApprovalMode(agent, request),
-					effectiveToolChoice: effectiveToolChoice(agent, request)
+					effectiveToolChoice: toolChoice
 				};
 				const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
 				const lease = {
@@ -1039,6 +1451,8 @@ function createAgentEngine(composition, core) {
 	const durableCheckpoint = async (state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex) => {
 		const agent = agents.get(state.run.agentName);
 		if (agent.model !== void 0 && typeof agent.model !== "string") throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable continuation requires a named model", state.run.id);
+		const contextBudget = resolveContextBudget(state.checkpoint?.contextBudget ?? state.request.contextBudget ?? agent.contextBudget ?? defaultContextBudget, `Agent "${state.run.agentName}" contextBudget`);
+		const toolSearch = state.toolSearch ?? resolveToolSearchOptions(state.checkpoint?.toolSearch ?? state.request.toolSearch ?? agent.toolSearch ?? defaultToolSearch, `Agent "${state.run.agentName}" toolSearch`, defaultToolSearchCache);
 		let serializedState;
 		if (providerState !== void 0) {
 			if (!model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway must provide stateCodec for durable continuation", state.run.id);
@@ -1049,8 +1463,11 @@ function createAgentEngine(composition, core) {
 			runId: state.run.id,
 			modelName,
 			...state.request.reasoning === void 0 ? {} : { reasoning: state.request.reasoning },
-			definitionHash: await definitionHash(state.run.agentName, modelName, agent, tools),
+			definitionHash: await definitionHash(state.run.agentName, modelName, agent, tools, contextBudget),
 			limits: state.checkpoint?.limits ?? combineLimits(agent.limits, state.request.limits),
+			...contextBudget === void 0 ? {} : { contextBudget },
+			toolSearch: serializeToolSearchOptions(toolSearch),
+			loadedTools: [...state.loadedTools ?? []],
 			messages: structuredClone(messages),
 			inputContent,
 			context: state.request.context,
@@ -1109,6 +1526,15 @@ function createAgentEngine(composition, core) {
 		const { request } = state;
 		const agent = agents.get(name);
 		const { modelName, model } = resolveModel(agent, state.checkpoint?.modelName ?? request.model);
+		const contextBudget = resolveContextBudget(state.checkpoint?.contextBudget ?? request.contextBudget ?? agent.contextBudget ?? defaultContextBudget, `Agent "${name}" contextBudget`);
+		const semantic = request.toolSearch?.semantic ?? agent.toolSearch?.semantic ?? defaultToolSearch?.semantic;
+		const toolSearch = resolveToolSearchOptions(state.checkpoint === void 0 ? request.toolSearch ?? agent.toolSearch ?? defaultToolSearch : state.checkpoint.toolSearch === void 0 ? {
+			mode: "off",
+			...semantic === void 0 ? {} : { semantic }
+		} : {
+			...state.checkpoint.toolSearch,
+			...semantic === void 0 ? {} : { semantic }
+		}, `Agent "${name}" toolSearch`, defaultToolSearchCache);
 		const events = [...state.initialEvents ?? []];
 		const firstEvents = state.initialEvents ?? [];
 		state.initialEvents = void 0;
@@ -1126,12 +1552,14 @@ function createAgentEngine(composition, core) {
 		let seenToolCallIds;
 		let pendingTools;
 		let pendingIndex;
+		let compactionApplied = false;
+		const semanticState = { attempted: false };
 		try {
 			for (const event of firstEvents) yield event;
 			if (state.checkpoint) {
 				const checkpoint = state.checkpoint;
 				if (checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${state.run.id}" is unsupported`, state.run.id);
-				const hash = await definitionHash(name, modelName, agent, tools);
+				const hash = await definitionHash(name, modelName, agent, tools, contextBudget);
 				if (checkpoint.definitionHash !== hash) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for agent "${name}" changed`, state.run.id);
 				inputContent = checkpoint.inputContent;
 				messages = checkpoint.messages;
@@ -1153,7 +1581,7 @@ function createAgentEngine(composition, core) {
 						content: agent.instructions
 					},
 					...knowledge.skills,
-					...state.session.history,
+					...sessionHistoryMessages(state.session),
 					...knowledge.context,
 					...knowledge.memory,
 					{
@@ -1201,30 +1629,86 @@ function createAgentEngine(composition, core) {
 					additionalProperties: false
 				}
 			};
+			const searchEnabled = shouldUseToolSearch(toolSearch, agentTools);
+			const searchTool = searchEnabled ? {
+				name: SEARCH_TOOLS_TOOL_NAME,
+				description: `Search ${agentTools.length} tools available to this agent by capability. Use it when you need a tool that is not currently exposed. Returns matching tools and makes their schemas available on the next turn.`,
+				inputSchema: {
+					type: "object",
+					properties: {
+						query: {
+							type: "string",
+							description: "Capability to search for, such as \"send email\" or \"query database\"."
+						},
+						limit: {
+							type: "integer",
+							minimum: 1,
+							maximum: toolSearch.limit
+						}
+					},
+					required: ["query"],
+					additionalProperties: false
+				}
+			} : void 0;
+			const elicitationTool = currentElicitationMode === "pause" ? {
+				name: ELICIT_TOOL_NAME,
+				description: "Request external information required to continue this run. Use prompt for explanatory text shown outside the form. Put short field labels in responseSchema property titles and optional field help in property descriptions.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						prompt: {
+							type: "string",
+							description: "Explanatory text for the user; do not duplicate field labels here."
+						},
+						responseSchema: {
+							type: "object",
+							description: "JSON Schema for the expected response. Each property should include a short title for the form label and may include a description for field help."
+						},
+						expiresAt: { type: "string" }
+					},
+					required: ["prompt", "responseSchema"],
+					additionalProperties: false
+				}
+			} : void 0;
 			const allTools = [
 				...agentTools,
 				...skillTool === void 0 ? [] : [skillTool],
-				...currentElicitationMode === "pause" ? [{
-					name: ELICIT_TOOL_NAME,
-					description: "Request external information required to continue this run. Use prompt for explanatory text shown outside the form. Put short field labels in responseSchema property titles and optional field help in property descriptions.",
-					inputSchema: {
-						type: "object",
-						properties: {
-							prompt: {
-								type: "string",
-								description: "Explanatory text for the user; do not duplicate field labels here."
-							},
-							responseSchema: {
-								type: "object",
-								description: "JSON Schema for the expected response. Each property should include a short title for the form label and may include a description for field help."
-							},
-							expiresAt: { type: "string" }
-						},
-						required: ["prompt", "responseSchema"],
-						additionalProperties: false
-					}
-				}] : []
+				...searchTool === void 0 ? [] : [searchTool],
+				...elicitationTool === void 0 ? [] : [elicitationTool]
 			];
+			const loadedTools = new Set(state.loadedTools ?? state.checkpoint?.loadedTools ?? []);
+			for (const toolName of toolSearch.pinned) if (agent.tools?.includes(toolName)) loadedTools.add(toolName);
+			if (typeof currentToolChoice === "object" && agent.tools?.includes(currentToolChoice.name)) loadedTools.add(currentToolChoice.name);
+			state.loadedTools = loadedTools;
+			state.toolSearch = toolSearch;
+			let loadedToolsVersion = 0;
+			let cachedModelTools;
+			let cachedModelToolsVersion = -1;
+			const modelTools = () => {
+				if (!searchEnabled) return allTools;
+				if (cachedModelTools !== void 0 && cachedModelToolsVersion === loadedToolsVersion) return cachedModelTools;
+				cachedModelTools = [
+					...agentTools.filter((tool) => loadedTools.has(tool.name)),
+					...skillTool === void 0 ? [] : [skillTool],
+					...searchTool === void 0 ? [] : [searchTool],
+					...elicitationTool === void 0 ? [] : [elicitationTool]
+				];
+				cachedModelToolsVersion = loadedToolsVersion;
+				return cachedModelTools;
+			};
+			const toolsTokenCache = /* @__PURE__ */ new WeakMap();
+			const estimateContext = (input) => {
+				if (!input.tools?.length) return compaction.estimateTokens(input);
+				let toolTokens = toolsTokenCache.get(input.tools);
+				if (toolTokens === void 0) {
+					toolTokens = compaction.estimateTokens({
+						messages: [],
+						tools: input.tools
+					});
+					toolsTokenCache.set(input.tools, toolTokens);
+				}
+				return compaction.estimateTokens({ messages: input.messages }) + toolTokens;
+			};
 			const effectiveLimits = state.checkpoint?.limits ?? combineLimits(agent.limits, request.limits);
 			const maxSteps = effectiveLimits?.maxSteps ?? 8;
 			const maxToolCalls = effectiveLimits?.maxToolCalls ?? 16;
@@ -1232,12 +1716,73 @@ function createAgentEngine(composition, core) {
 			while (step <= maxSteps) {
 				request.signal.throwIfAborted();
 				if (pendingTools.length === 0) {
+					const currentTools = modelTools();
+					if (contextBudget !== void 0) {
+						const compacted = await compactContext({
+							runId: state.run.id,
+							agentName: name,
+							sessionId: state.session.id,
+							messages,
+							tools: currentTools,
+							contextBudget,
+							compactor: compaction.compactor,
+							estimateTokens: estimateContext,
+							step,
+							...request.context === void 0 ? {} : { context: request.context },
+							signal: request.signal,
+							allowCompaction: !compactionApplied
+						});
+						if (compacted !== void 0) {
+							messages = compacted.messages;
+							compactionApplied = true;
+							compactionStats.compactions += 1;
+							compactionStats.removedMessages += compacted.removedMessages;
+							compactionStats.estimatedTokens += compacted.estimatedTokens;
+							compactionStats.compactedTokens += compacted.compactedTokens;
+							compactionStats.savedTokens += Math.max(0, compacted.estimatedTokens - compacted.compactedTokens);
+							const previous = state.session.compaction;
+							const combined = previous === void 0 ? compacted.summary : `${previous.summary}\n\n${compacted.summary}`;
+							const maxSummaryChars = Math.max(200, contextBudget.targetTokens * 4);
+							state.session.compaction = {
+								summary: capSummary(combined, maxSummaryChars),
+								coveredMessages: state.session.history.length,
+								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+							};
+							const redactedSummary = compaction.redactSummary?.(compacted.summary) ?? compacted.summary;
+							if (typeof redactedSummary !== "string") throw new TypeError("compaction.redactSummary must return a string");
+							const summaryTruncated = redactedSummary.length > MAX_COMPACTION_EVENT_SUMMARY_CHARS;
+							const event = createEvent(state, "context.compacted", {
+								step,
+								removedMessages: compacted.removedMessages,
+								estimatedTokens: compacted.estimatedTokens,
+								compactedTokens: compacted.compactedTokens,
+								targetTokens: contextBudget.targetTokens,
+								contextWindow: contextBudget.contextWindow,
+								summary: summaryTruncated ? capSummary(redactedSummary, MAX_COMPACTION_EVENT_SUMMARY_CHARS) : redactedSummary,
+								...summaryTruncated ? { summaryTruncated: true } : {}
+							});
+							if (isDurableRunStore(runStore)) {
+								const checkpoint = await durableCheckpoint(state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex);
+								await commit(state, {
+									checkpoint,
+									session: state.session,
+									events: [event]
+								});
+								state.checkpoint = checkpoint;
+							} else {
+								await runStore.appendEvent(event);
+								notifyObserver(event);
+							}
+							events.push(event);
+							yield event;
+						}
+					}
 					const hasToolBudget = step < maxSteps && toolCallCount < maxToolCalls;
-					const modelToolChoice = hasToolBudget && allTools.length ? currentToolChoice === "auto" ? void 0 : currentToolChoice : void 0;
+					const modelToolChoice = hasToolBudget && currentTools.length ? currentToolChoice === "auto" ? void 0 : currentToolChoice : void 0;
 					yield await emit("model.started", { step });
 					const modelStream = readModelStream(model, {
 						messages: [...messages],
-						tools: hasToolBudget && allTools.length ? allTools : void 0,
+						tools: hasToolBudget && currentTools.length ? currentTools : void 0,
 						...modelToolChoice === void 0 ? {} : { toolChoice: modelToolChoice },
 						reasoning: state.request.reasoning ?? agent.reasoning,
 						modelOptions: agent.modelOptions,
@@ -1313,52 +1858,63 @@ function createAgentEngine(composition, core) {
 					assertContinuationBudget(name, "maxInputTokens", "inputTokens", effectiveLimits?.maxInputTokens, usage);
 					assertContinuationBudget(name, "maxOutputTokens", "outputTokens", effectiveLimits?.maxOutputTokens, usage);
 					if (result.toolCalls.length > maxToolCalls - toolCallCount) throw new Error(`Agent "${name}" exceeded maxToolCalls limit of ${maxToolCalls}`);
-					const loadSkillCall = progressiveSkills.length === 0 ? void 0 : result.toolCalls.find((call) => call.name === LOAD_SKILL_TOOL_NAME);
-					if (loadSkillCall) {
-						if (result.toolCalls.length !== 1) throw new Error(`${LOAD_SKILL_TOOL_NAME} must be the only tool call in a model turn`);
-						if (!loadSkillCall.id?.trim()) throw new Error("Tool call id cannot be empty");
-						if (seenToolCallIds.has(loadSkillCall.id)) throw new Error(`Tool call id "${loadSkillCall.id}" is duplicated in run "${state.run.id}"`);
+					const internalCall = result.toolCalls.find((call) => searchEnabled && call.name === "fevex__search_tools" || progressiveSkills.length > 0 && call.name === "fevex__load_skill");
+					if (internalCall) {
+						if (result.toolCalls.length !== 1) throw new Error(`${internalCall.name} must be the only tool call in a model turn`);
+						if (!internalCall.id?.trim()) throw new Error("Tool call id cannot be empty");
+						if (seenToolCallIds.has(internalCall.id)) throw new Error(`Tool call id "${internalCall.id}" is duplicated in run "${state.run.id}"`);
 						if (toolCallCount + 1 > maxToolCalls) throw new Error(`Agent "${name}" exceeded maxToolCalls limit of ${maxToolCalls}`);
-						const rawInput = toJsonValue(loadSkillCall.input, `Input for tool "${LOAD_SKILL_TOOL_NAME}" must be JSON-serializable`);
-						const skillInput = readSkillInput(rawInput);
-						const skill = progressiveSkills.find((item) => item.name === skillInput.name);
-						if (!skill) throw new Error(`Skill "${skillInput.name}" is not available to agent "${name}"`);
-						seenToolCallIds.add(loadSkillCall.id);
+						const rawInput = toJsonValue(internalCall.input, `Input for tool "${internalCall.name}" must be JSON-serializable`);
+						const loadedBefore = loadedTools.size;
+						seenToolCallIds.add(internalCall.id);
 						messages.push({
 							role: "assistant",
 							content: result.output === void 0 ? "" : serializeValue(result.output, `Model output for agent "${name}" must be serializable`),
 							toolCalls: [{
-								...loadSkillCall,
+								...internalCall,
 								input: rawInput
 							}]
 						});
 						yield await emit("tool.started", {
 							step,
-							toolCallId: loadSkillCall.id,
-							toolName: LOAD_SKILL_TOOL_NAME
+							toolCallId: internalCall.id,
+							toolName: internalCall.name
 						});
-						let blocks;
+						let execution;
 						try {
-							blocks = await abortable(() => skill.load(knowledgeContext(state, inputContent), skillInput.resource), request.signal);
+							execution = await executeInternalTool({
+								call: internalCall,
+								input: rawInput,
+								tools: agentTools,
+								searchEnabled,
+								toolSearch,
+								loadedTools,
+								progressiveSkills,
+								knowledgeContext: knowledgeContext(state, inputContent),
+								semanticState,
+								signal: request.signal
+							});
 						} catch (error) {
 							yield await emit("tool.failed", {
 								step,
-								toolCallId: loadSkillCall.id,
-								toolName: LOAD_SKILL_TOOL_NAME,
+								toolCallId: internalCall.id,
+								toolName: internalCall.name,
 								error: toErrorMessage(error)
 							});
-							throw new Error(`Skill provider "${skill.name}" failed: ${toErrorMessage(error)}`, { cause: error });
+							throw error;
 						}
+						if (!execution) throw new Error(`Tool "${internalCall.name}" is not available to agent "${name}"`);
+						if (loadedTools.size > loadedBefore) loadedToolsVersion += 1;
 						messages.push({
 							role: "tool",
-							name: LOAD_SKILL_TOOL_NAME,
-							toolCallId: loadSkillCall.id,
-							content: blocks.filter((block) => block.content.trim()).map((block) => `[Skill: ${skill.name}/${block.id}]\n${block.content}`).join("\n\n")
+							name: internalCall.name,
+							toolCallId: internalCall.id,
+							content: execution.content
 						});
 						yield await emit("tool.completed", {
 							step,
-							toolCallId: loadSkillCall.id,
-							toolName: LOAD_SKILL_TOOL_NAME
+							toolCallId: internalCall.id,
+							toolName: internalCall.name
 						});
 						toolCallCount += 1;
 						step += 1;
@@ -1420,6 +1976,7 @@ function createAgentEngine(composition, core) {
 						batch.add(call.id);
 						const tool = agent.tools?.includes(call.name) ? tools.get(call.name) : void 0;
 						if (!tool) throw new Error(`Tool "${call.name}" is not available to agent "${name}"`);
+						if (searchEnabled && !loadedTools.has(call.name)) throw new Error(`Tool "${call.name}" is not loaded; use ${SEARCH_TOOLS_TOOL_NAME} first`);
 						const rawInput = toJsonValue(call.input, `Input for tool "${call.name}" must be JSON-serializable`);
 						let validated;
 						try {
@@ -1676,7 +2233,13 @@ function createAgentEngine(composition, core) {
 								signal: request.signal
 							}), request.signal);
 							for (const event of createdArtifacts.splice(0)) yield event;
-							output = toJsonValue(tool.outputSchema === void 0 ? raw : await validateSchema(tool.outputSchema, raw, `Output from tool "${tool.name}" does not match outputSchema`), `Output from tool "${tool.name}" must be JSON-serializable`);
+							const validated = tool.outputSchema === void 0 ? raw : await validateSchema(tool.outputSchema, raw, `Output from tool "${tool.name}" does not match outputSchema`);
+							const serialized = serializeValue(validated, `Output from tool "${tool.name}" must be JSON-serializable`);
+							const configuredMaxResultBytes = tool.maxResultBytes !== void 0 ? tool.maxResultBytes : effectiveLimits?.maxToolResultBytes;
+							const maxResultBytes = configuredMaxResultBytes === void 0 ? DEFAULT_MAX_TOOL_RESULT_BYTES : configuredMaxResultBytes;
+							const resultBytes = new TextEncoder().encode(serialized).byteLength;
+							if (maxResultBytes !== false && resultBytes > maxResultBytes) throw new FevexRunError("TOOL_RESULT_TOO_LARGE", `Tool "${tool.name}" returned ${resultBytes} bytes; limit is ${maxResultBytes}. Store large outputs as artifacts and return an artifact descriptor.`, state.run.id);
+							output = toJsonValue(validated, `Output from tool "${tool.name}" must be JSON-serializable`);
 							if (containsSecret(output, secrets)) throw new Error(`Output from tool "${tool.name}" contains a credential`);
 							record = {
 								...record,
@@ -1713,7 +2276,7 @@ function createAgentEngine(composition, core) {
 								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 							};
 							if (durable) await commit(state, { toolExecution: record });
-							if (attempt >= maxAttempts || tool.idempotency !== "keyed") {
+							if (attempt >= maxAttempts || tool.idempotency !== "keyed" || error instanceof FevexRunError && error.code === "TOOL_RESULT_TOO_LARGE") {
 								yield await emit("tool.failed", {
 									step,
 									toolCallId: pending.call.id,
@@ -2110,20 +2673,19 @@ function createAgentEngine(composition, core) {
 		nextEvent,
 		drainExecution,
 		resumeAgent,
-		cancelStoredAgent
+		cancelStoredAgent,
+		getCompactionStats() {
+			return { ...compactionStats };
+		}
 	};
 }
-function readSkillInput(input) {
-	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new TypeError(`${LOAD_SKILL_TOOL_NAME} input must be an object`);
-	const record = input;
-	const name = record.name;
-	const resource = record.resource;
-	if (typeof name !== "string" || !name.trim()) throw new TypeError(`${LOAD_SKILL_TOOL_NAME} name must be a non-empty string`);
-	if (resource !== void 0 && (typeof resource !== "string" || !resource.trim())) throw new TypeError(`${LOAD_SKILL_TOOL_NAME} resource must be a non-empty string`);
-	return {
-		name: name.trim(),
-		...resource === void 0 ? {} : { resource: resource.trim() }
-	};
+function sessionHistoryMessages(session) {
+	const compaction = session.compaction;
+	if (compaction === void 0 || compaction.coveredMessages <= 0 || compaction.coveredMessages > session.history.length) return session.history;
+	return [{
+		role: "system",
+		content: `[Compacted conversation]\n${compaction.summary}`
+	}, ...session.history.slice(compaction.coveredMessages)];
 }
 function scopedArtifacts(store, options) {
 	const scopedContext = (value) => {
@@ -2284,6 +2846,17 @@ function annotation(event) {
 				delayMs: event.payload.delayMs
 			}
 		};
+		case "context.compacted": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				removedMessages: event.payload.removedMessages,
+				estimatedTokens: event.payload.estimatedTokens,
+				compactedTokens: event.payload.compactedTokens,
+				targetTokens: event.payload.targetTokens,
+				contextWindow: event.payload.contextWindow
+			}
+		};
 		case "tool.execution_unknown": return {
 			name: event.type,
 			timestamp: event.timestamp,
@@ -2882,12 +3455,12 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 	};
 	const resolveCheckpointModel = async (agentName, agent, checkpoint) => {
 		const preferred = resolveModel(agent, checkpoint.modelName);
-		if (checkpoint.definitionHash === await definitionHash(agentName, preferred.modelName, agent, tools)) return preferred;
+		if (checkpoint.definitionHash === await definitionHash(agentName, preferred.modelName, agent, tools, checkpoint.contextBudget)) return preferred;
 		if (checkpoint.modelName !== void 0) return void 0;
 		for (const candidateName of models.keys()) {
 			if (candidateName === preferred.modelName) continue;
 			const candidate = resolveModel(agent, candidateName);
-			if (checkpoint.definitionHash === await definitionHash(agentName, candidate.modelName, agent, tools)) return candidate;
+			if (checkpoint.definitionHash === await definitionHash(agentName, candidate.modelName, agent, tools, checkpoint.contextBudget)) return candidate;
 		}
 	};
 	const scheduleTraceExport = (event) => {
@@ -4218,7 +4791,7 @@ function createRuntime(composition) {
 	const core = createRunCore(composition);
 	const { activeRuns, activeWorkflowRuns, activeSessions, isIdle, waitForIdle, closeAdmission, isClosed, traceExports, runtimeOwner, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, cancelExecution, releaseWorkflowExecution, commitWorkflow } = core;
 	const agentEngine = createAgentEngine(composition, core);
-	const { prepareExecution, executeAgent, nextEvent, drainExecution, resumeAgent, cancelStoredAgent } = agentEngine;
+	const { prepareExecution, executeAgent, nextEvent, drainExecution, resumeAgent, cancelStoredAgent, getCompactionStats } = agentEngine;
 	const { prepareWorkflowExecution, executeWorkflow, nextWorkflowEvent, drainWorkflowExecution, resumeWorkflow, cancelWorkflowExecution, cancelStoredWorkflow } = createWorkflowEngine(composition, core, agentEngine);
 	const resumeRun = async (runId, resolution) => {
 		if (isClosed()) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs", runId);
@@ -4408,6 +4981,7 @@ function createRuntime(composition) {
 				role: "system",
 				content: summary
 			}];
+			session.compaction = void 0;
 			session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 			await runStore.saveSession(session);
 			return structuredClone(session);
@@ -4418,6 +4992,9 @@ function createRuntime(composition) {
 		getObservabilityStats() {
 			return traceExports.stats();
 		},
+		getCompactionStats() {
+			return getCompactionStats();
+		},
 		shutdown
 	};
 }
@@ -4433,4 +5010,4 @@ function createFevex(config) {
 	return createRuntime(createComposition(config));
 }
 //#endregion
-export { ArtifactError, CatalogedArtifactStore, ChannelError, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexConfigurationError, FevexRunError, FileSystemArtifactStore, InMemoryArtifactCatalog, InMemoryArtifactStore, InMemoryMemoryStore, InMemoryRunStore, IntegrationError, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, S3ArtifactStore, SCHEMA_NOT_TRANSPORTABLE, SandboxError, artifactTenantId, assertArtifactId, compileFevexJsonSchema, createAgentsMdContextProvider, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, deliverChannelRun, handleChannelInput, isDurableRunStore, isProgressiveSkillProvider, isRetainableRunStore, loadSkillFile, loadSkillFiles, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions, validatePurgeRunsOptions };
+export { ArtifactError, CatalogedArtifactStore, ChannelError, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexConfigurationError, FevexRunError, FileSystemArtifactStore, InMemoryArtifactCatalog, InMemoryArtifactStore, InMemoryMemoryStore, InMemoryRunStore, InMemoryToolEmbeddingCache, IntegrationError, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, S3ArtifactStore, SCHEMA_NOT_TRANSPORTABLE, SandboxError, artifactTenantId, assertArtifactId, buildToolEmbeddingIndex, compileFevexJsonSchema, cosineSimilarity, createAgentsMdContextProvider, createDigestContextCompactor, createFevex, createLocalSandbox, createMemoryContextProvider, createModelContextCompactor, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, deliverChannelRun, estimateContextTokens, handleChannelInput, isDurableRunStore, isProgressiveSkillProvider, isRetainableRunStore, loadSkillFile, loadSkillFiles, resolveContextBudget, sandboxResultToJson, schemaKeywords, searchToolEmbeddingIndex, toToolSpec, toolEmbeddingKey, toolEmbeddingText, validateFevexJsonSchemaProfile, validateListEventsOptions, validatePurgeRunsOptions };