@fevex/core 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/index.mjs

@@ -2,9 +2,9 @@ import { defineAgent } from "./agents/index.mjs";
 import { a as CatalogedArtifactStore, c as assertArtifactId, i as FileSystemArtifactStore, n as InMemoryArtifactStore, o as ArtifactError, r as InMemoryArtifactCatalog, s as artifactTenantId, t as S3ArtifactStore } from "./artifacts-gUzemET7.mjs";
 import { n as RunPausedError, t as FevexRunError } from "./run-error-Cr17wPGH.mjs";
 import { ChannelError, deliverChannelRun, handleChannelInput } from "./channels/index.mjs";
-import { InMemoryMemoryStore, createMemoryContextProvider, defineContextProvider, defineSkill } from "./knowledge/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 { InMemoryRunStore, createDigestContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions } from "./runtime/index.mjs";
 import { FEVEX_JSON_SCHEMA_PROFILE_VERSION, IntegrationError, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, 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";
@@ -300,6 +300,16 @@ 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);
+	}
+	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.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");
@@ -475,6 +485,11 @@ 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.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);
@@ -498,6 +513,7 @@ 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.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
 			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
 			...rawLimits === void 0 ? {} : { limits: {
@@ -621,6 +637,11 @@ function createComposition(config) {
 		teams,
 		tools,
 		contextProviders,
+		contextBudget: config.contextBudget === void 0 ? void 0 : { ...config.contextBudget },
+		compaction: {
+			compactor: config.compaction?.compactor ?? createDigestContextCompactor(),
+			estimateTokens: config.compaction?.estimateTokens ?? estimateContextTokens
+		},
 		memoryStore: config.memoryStore ?? (usesMemory ? new InMemoryMemoryStore() : void 0),
 		runStore: config.runStore ?? new InMemoryRunStore(),
 		credentialStore: config.credentialStore,
@@ -649,6 +670,8 @@ const LEASE_MS = 3e4;
 const LEASE_RENEW_MS = 1e4;
 /** Reserved name of the internal elicitation tool exposed to the model. */
 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";
 //#endregion
 //#region src/internal/run-helpers.ts
 function redact(message, secrets) {
@@ -776,6 +799,103 @@ const runErrorPayload = (error) => {
 	};
 };
 //#endregion
+//#region src/internal/context-compaction.ts
+/** Maximum summary characters copied into the context.compacted event. */
+const MAX_COMPACTION_EVENT_SUMMARY_CHARS = 4e3;
+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);
@@ -802,7 +922,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,
@@ -818,6 +938,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`)
 	});
@@ -902,12 +1023,13 @@ 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, memoryStore, runStore, credentialStore, sandbox, artifacts, policies } = composition;
 	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 { modelName, model } = resolveModel(agent, request.model);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		let session;
@@ -965,7 +1087,7 @@ function createAgentEngine(composition, core) {
 						content: agent.instructions
 					},
 					...knowledge.skills,
-					...session.history,
+					...sessionHistoryMessages(session),
 					...knowledge.context,
 					...knowledge.memory,
 					{
@@ -978,8 +1100,9 @@ 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 },
 					messages,
 					inputContent,
 					context: request.context,
@@ -1037,6 +1160,7 @@ 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`);
 		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);
@@ -1047,8 +1171,9 @@ 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 },
 			messages: structuredClone(messages),
 			inputContent,
 			context: state.request.context,
@@ -1107,6 +1232,7 @@ 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 events = [...state.initialEvents ?? []];
 		const firstEvents = state.initialEvents ?? [];
 		state.initialEvents = void 0;
@@ -1124,12 +1250,13 @@ function createAgentEngine(composition, core) {
 		let seenToolCallIds;
 		let pendingTools;
 		let pendingIndex;
+		let compactionApplied = 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;
@@ -1151,7 +1278,7 @@ function createAgentEngine(composition, core) {
 						content: agent.instructions
 					},
 					...knowledge.skills,
-					...state.session.history,
+					...sessionHistoryMessages(state.session),
 					...knowledge.context,
 					...knowledge.memory,
 					{
@@ -1179,26 +1306,50 @@ function createAgentEngine(composition, core) {
 					description: remote.description
 				} : tool, inputSchema);
 			}));
-			const allTools = currentElicitationMode === "pause" ? [...agentTools, {
-				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.",
+			const progressiveSkills = (agent.skills ?? []).map((skillName) => contextProviders.get(skillName)).filter((provider) => provider !== void 0 && isProgressiveSkillProvider(provider));
+			const skillTool = progressiveSkills.length === 0 ? void 0 : {
+				name: LOAD_SKILL_TOOL_NAME,
+				description: `Load the full instructions for one of this agent's skills. Available skills: ${progressiveSkills.map((skill) => skill.name).join(", ")}. Pass a resource path from the loaded skill to read one resource.`,
 				inputSchema: {
 					type: "object",
 					properties: {
-						prompt: {
+						name: {
 							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."
+							enum: progressiveSkills.map((skill) => skill.name)
 						},
-						expiresAt: { type: "string" }
+						resource: {
+							type: "string",
+							description: "Optional resource path returned by a previous load."
+						}
 					},
-					required: ["prompt", "responseSchema"],
+					required: ["name"],
 					additionalProperties: false
 				}
-			}] : agentTools;
+			};
+			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
+					}
+				}] : []
+			];
 			const effectiveLimits = state.checkpoint?.limits ?? combineLimits(agent.limits, request.limits);
 			const maxSteps = effectiveLimits?.maxSteps ?? 8;
 			const maxToolCalls = effectiveLimits?.maxToolCalls ?? 16;
@@ -1206,6 +1357,59 @@ function createAgentEngine(composition, core) {
 			while (step <= maxSteps) {
 				request.signal.throwIfAborted();
 				if (pendingTools.length === 0) {
+					if (contextBudget !== void 0) {
+						const compacted = await compactContext({
+							runId: state.run.id,
+							agentName: name,
+							sessionId: state.session.id,
+							messages,
+							tools: allTools,
+							contextBudget,
+							compactor: compaction.compactor,
+							estimateTokens: compaction.estimateTokens,
+							step,
+							...request.context === void 0 ? {} : { context: request.context },
+							signal: request.signal,
+							allowCompaction: !compactionApplied
+						});
+						if (compacted !== void 0) {
+							messages = compacted.messages;
+							compactionApplied = true;
+							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: combined.length > maxSummaryChars ? `…${combined.slice(combined.length - maxSummaryChars + 1)}` : combined,
+								coveredMessages: state.session.history.length,
+								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+							};
+							const summaryTruncated = compacted.summary.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 ? `${compacted.summary.slice(0, MAX_COMPACTION_EVENT_SUMMARY_CHARS - 1)}…` : compacted.summary,
+								...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;
 					yield await emit("model.started", { step });
@@ -1287,6 +1491,57 @@ 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}"`);
+						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);
+						messages.push({
+							role: "assistant",
+							content: result.output === void 0 ? "" : serializeValue(result.output, `Model output for agent "${name}" must be serializable`),
+							toolCalls: [{
+								...loadSkillCall,
+								input: rawInput
+							}]
+						});
+						yield await emit("tool.started", {
+							step,
+							toolCallId: loadSkillCall.id,
+							toolName: LOAD_SKILL_TOOL_NAME
+						});
+						let blocks;
+						try {
+							blocks = await abortable(() => skill.load(knowledgeContext(state, inputContent), skillInput.resource), request.signal);
+						} catch (error) {
+							yield await emit("tool.failed", {
+								step,
+								toolCallId: loadSkillCall.id,
+								toolName: LOAD_SKILL_TOOL_NAME,
+								error: toErrorMessage(error)
+							});
+							throw new Error(`Skill provider "${skill.name}" failed: ${toErrorMessage(error)}`, { cause: error });
+						}
+						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")
+						});
+						yield await emit("tool.completed", {
+							step,
+							toolCallId: loadSkillCall.id,
+							toolName: LOAD_SKILL_TOOL_NAME
+						});
+						toolCallCount += 1;
+						step += 1;
+						continue;
+					}
 					const elicitationCall = result.toolCalls.find(isElicitationToolCall);
 					if (elicitationCall) {
 						if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "Elicitation requires a DurableRunStore", state.run.id);
@@ -2036,6 +2291,26 @@ function createAgentEngine(composition, core) {
 		cancelStoredAgent
 	};
 }
+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 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 scopedArtifacts(store, options) {
 	const scopedContext = (value) => {
 		const contextTenant = options.request.context?.attributes?.tenantId;
@@ -2195,6 +2470,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,
@@ -2793,12 +3079,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) => {
@@ -4319,6 +4605,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);
@@ -4344,4 +4631,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, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, deliverChannelRun, handleChannelInput, isDurableRunStore, isRetainableRunStore, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions, validatePurgeRunsOptions };
+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, createDigestContextCompactor, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, deliverChannelRun, estimateContextTokens, handleChannelInput, isDurableRunStore, isProgressiveSkillProvider, isRetainableRunStore, loadSkillFile, loadSkillFiles, resolveContextBudget, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/knowledge/index.d.mts

@@ -1,2 +1,2 @@
-import { a as MemoryQuery, c as MemoryWrite, d as defineContextProvider, f as defineSkill, i as KnowledgeContext, l as SkillDefinition, n as ContextBlock, o as MemoryRecord, r as ContextProvider, s as MemoryStore, t as InMemoryMemoryStore, u as createMemoryContextProvider } from "../index-BJktlD4E.mjs";
-export { ContextBlock, ContextProvider, InMemoryMemoryStore, KnowledgeContext, MemoryQuery, MemoryRecord, MemoryStore, MemoryWrite, SkillDefinition, createMemoryContextProvider, defineContextProvider, defineSkill };
+import { _ as defineContextProvider, a as AgentsMdOptions, c as ContextProvider, d as MemoryRecord, f as MemoryStore, g as createMemoryContextProvider, h as SkillDefinition, i as InMemoryMemoryStore, l as KnowledgeContext, m as ProgressiveSkillProvider, n as loadSkillFile, o as createAgentsMdContextProvider, p as MemoryWrite, r as loadSkillFiles, s as ContextBlock, t as LoadSkillFileOptions, u as MemoryQuery, v as defineSkill, y as isProgressiveSkillProvider } from "../index-CAyAoOW0.mjs";
+export { AgentsMdOptions, ContextBlock, ContextProvider, InMemoryMemoryStore, KnowledgeContext, LoadSkillFileOptions, MemoryQuery, MemoryRecord, MemoryStore, MemoryWrite, ProgressiveSkillProvider, SkillDefinition, createAgentsMdContextProvider, createMemoryContextProvider, defineContextProvider, defineSkill, isProgressiveSkillProvider, loadSkillFile, loadSkillFiles };