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

package/dist/knowledge/index.d.mts

@@ -1,2 +1,2 @@
-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-B0AdFbgr.mjs";
+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-D4mWV2zG.mjs";
 export { AgentsMdOptions, ContextBlock, ContextProvider, InMemoryMemoryStore, KnowledgeContext, LoadSkillFileOptions, MemoryQuery, MemoryRecord, MemoryStore, MemoryWrite, ProgressiveSkillProvider, SkillDefinition, createAgentsMdContextProvider, createMemoryContextProvider, defineContextProvider, defineSkill, isProgressiveSkillProvider, loadSkillFile, loadSkillFiles };

package/dist/models/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ModelResult, c as ReasoningEffort, i as ModelRef, l as ToolChoice, n as ModelInput, o as ModelStreamEvent, r as ModelMetadata, s as ModelUsage, t as ModelGateway } from "../index-BgKFd9yw.mjs";
-export { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort, ToolChoice };
+import { a as ModelResult, c as ReasoningEffort, i as ModelRef, l as ToolChoice, n as ModelInput, o as ModelStreamEvent, r as ModelMetadata, s as ModelUsage, t as ModelGateway, u as EmbeddingModel } from "../index-D7r0puBi.mjs";
+export { EmbeddingModel, ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort, ToolChoice };

package/dist/observability/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as TraceSpanKind, a as RunTrace, c as TraceContentKind, d as TraceExportQueueOptions, f as TraceExporter, g as TraceSpan, h as TraceRunKind, i as ObservabilityStats, l as TraceContentPolicy, m as TraceRedactorInput, n as CostCalculatorInput, o as TraceAnnotation, p as TraceRedactor, r as ObservabilityOptions, s as TraceContent, t as CostCalculator, u as TraceCost, v as TraceStatus } from "../index-CpLDt6Rw.mjs";
+import { _ as TraceSpanKind, a as RunTrace, c as TraceContentKind, d as TraceExportQueueOptions, f as TraceExporter, g as TraceSpan, h as TraceRunKind, i as ObservabilityStats, l as TraceContentPolicy, m as TraceRedactorInput, n as CostCalculatorInput, o as TraceAnnotation, p as TraceRedactor, r as ObservabilityOptions, s as TraceContent, t as CostCalculator, u as TraceCost, v as TraceStatus } from "../index-D7FoZ7aQ.mjs";
 export { CostCalculator, CostCalculatorInput, ObservabilityOptions, ObservabilityStats, RunTrace, TraceAnnotation, TraceContent, TraceContentKind, TraceContentPolicy, TraceCost, TraceExportQueueOptions, TraceExporter, TraceRedactor, TraceRedactorInput, TraceRunKind, TraceSpan, TraceSpanKind, TraceStatus };

package/dist/policies/index.d.mts

@@ -1,2 +1,2 @@
-import { i as definePolicy, n as PolicyDecision, r as PolicyDefinition, t as PolicyAuthorization } from "../index-CbACw6xZ.mjs";
+import { i as definePolicy, n as PolicyDecision, r as PolicyDefinition, t as PolicyAuthorization } from "../index-BLgiXQK4.mjs";
 export { PolicyAuthorization, PolicyDecision, PolicyDefinition, definePolicy };

package/dist/runtime/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as validateListEventsOptions, A as RunPause, B as TeamRun, C as PurgeRunsResult, D as RunCheckpoint, E as RetainableRunStore, F as RunStore, G as WorkflowBudgetUsage, H as ToolExecutionRecord, I as Session, J as WorkflowRun, K as WorkflowCheckpoint, L as SessionId, M as RunRequest, N as RunResult, O as RunCorrelation, P as RunStatus, Q as isRetainableRunStore, R as StoredRunCheckpoint, S as PurgeRunsOptions, T as RetainableRunStatus, U as ToolExecutionResolution, V as TimerResolution, W as ToolExecutionStatus, X as WorkflowWaitRecord, Y as WorkflowStepRecord, Z as isDurableRunStore, _ as EventResolution, a as AgentRun, b as ListEventsOptions, c as ApprovalRequest, d as CoordinatorRun, et as validatePurgeRunsOptions, f as CredentialStore, g as ElicitationResolution, h as ElicitationRequest, i as InMemoryRunStore, j as RunRecord, k as RunLease, l as ApprovalResolution, m as ElicitationMode, o as AgentRunPause, p as DurableRunStore, q as WorkflowCompensationRecord, s as ApprovalMode, u as CoordinatorCheckpoint, v as ExecutionCommit, w as ResumeRunResolution, x as PendingToolExecution, y as ExecutionCreate, z as TeamCheckpoint } from "../index-CzAi2Y_Z.mjs";
-export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, PendingToolExecution, PurgeRunsOptions, PurgeRunsResult, ResumeRunResolution, RetainableRunStatus, RetainableRunStore, RunCheckpoint, RunCorrelation, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, isDurableRunStore, isRetainableRunStore, validateListEventsOptions, validatePurgeRunsOptions };
+import { $ as SessionCompaction, A as ElicitationMode, B as ResumeRunResolution, C as ApprovalMode, D as CoordinatorRun, E as CoordinatorCheckpoint, F as ExecutionCreate, G as RunLease, H as RetainableRunStore, I as ListEventsOptions, J as RunRequest, K as RunPause, L as PendingToolExecution, M as ElicitationResolution, N as EventResolution, O as CredentialStore, P as ExecutionCommit, Q as Session, R as PurgeRunsOptions, S as AgentRunPause, T as ApprovalResolution, U as RunCheckpoint, V as RetainableRunStatus, W as RunCorrelation, X as RunStatus, Y as RunResult, Z as RunStore, _ as createDigestContextCompactor, _t as validatePurgeRunsOptions, at as ToolExecutionRecord, b as resolveContextBudget, c as InMemoryRunStore, ct as WorkflowBudgetUsage, d as ContextCompactionStats, dt as WorkflowRun, et as SessionId, f as ContextCompactor, ft as WorkflowStepRecord, g as ResolvedContextBudget, gt as validateListEventsOptions, h as ModelContextCompactorOptions, ht as isRetainableRunStore, it as TimerResolution, j as ElicitationRequest, k as DurableRunStore, l as ContextCompactionInput, lt as WorkflowCheckpoint, m as DigestContextCompactorOptions, mt as isDurableRunStore, nt as TeamCheckpoint, ot as ToolExecutionResolution, p as ContextTokenEstimator, pt as WorkflowWaitRecord, q as RunRecord, rt as TeamRun, st as ToolExecutionStatus, tt as StoredRunCheckpoint, u as ContextCompactionOptions, ut as WorkflowCompensationRecord, v as createModelContextCompactor, w as ApprovalRequest, x as AgentRun, y as estimateContextTokens, z as PurgeRunsResult } from "../index-3bFNzCiY.mjs";
+export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, ContextCompactionInput, ContextCompactionOptions, ContextCompactionStats, ContextCompactor, ContextTokenEstimator, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DigestContextCompactorOptions, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, ModelContextCompactorOptions, PendingToolExecution, PurgeRunsOptions, PurgeRunsResult, ResolvedContextBudget, ResumeRunResolution, RetainableRunStatus, RetainableRunStore, RunCheckpoint, RunCorrelation, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionCompaction, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/runtime/index.mjs

@@ -1,4 +1,175 @@
 import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+//#region src/runtime/compaction.ts
+/** Validates a context budget and fills in defaults. */
+function resolveContextBudget(budget, label) {
+	if (budget === void 0) return void 0;
+	if (!isRecord(budget)) throw new TypeError(`${label} must be an object`);
+	const contextWindow = budget.contextWindow;
+	if (!Number.isSafeInteger(contextWindow) || contextWindow <= 0) throw new TypeError(`${label}.contextWindow must be a positive safe integer`);
+	const reserveOutputTokens = budget.reserveOutputTokens ?? 0;
+	if (!Number.isSafeInteger(reserveOutputTokens) || reserveOutputTokens < 0 || reserveOutputTokens >= contextWindow) throw new TypeError(`${label}.reserveOutputTokens must be a non-negative safe integer below contextWindow`);
+	const usable = contextWindow - reserveOutputTokens;
+	const compactAt = budget.compactAt ?? .8;
+	if (typeof compactAt !== "number" || !Number.isFinite(compactAt) || compactAt <= 0 || compactAt > 1) throw new TypeError(`${label}.compactAt must be greater than 0 and at most 1`);
+	const targetTokens = budget.targetTokens ?? Math.max(1, Math.floor(usable * Math.min(.5, compactAt * .9)));
+	if (!Number.isSafeInteger(targetTokens) || targetTokens <= 0 || targetTokens >= usable) throw new TypeError(`${label}.targetTokens must be a positive safe integer below the usable window`);
+	if (targetTokens > Math.floor(usable * compactAt)) throw new TypeError(`${label}.targetTokens must not exceed the compaction threshold`);
+	const safetyFactor = budget.safetyFactor ?? 1.1;
+	if (typeof safetyFactor !== "number" || !Number.isFinite(safetyFactor) || safetyFactor < 1 || safetyFactor > 2) throw new TypeError(`${label}.safetyFactor must be between 1 and 2`);
+	return {
+		contextWindow,
+		reserveOutputTokens,
+		compactAt,
+		targetTokens,
+		safetyFactor
+	};
+}
+/**
+* Rough provider-neutral estimate: about four characters per token plus
+* message and tool framing. Hosts can inject a real tokenizer instead.
+*/
+function estimateContextTokens(input) {
+	let characters = 0;
+	for (const message of input.messages) {
+		characters += message.role.length + message.content.length + 16;
+		if (message.name !== void 0) characters += message.name.length;
+		if (message.toolCallId !== void 0) characters += message.toolCallId.length;
+		if (message.toolCalls !== void 0) characters += JSON.stringify(message.toolCalls).length;
+	}
+	if (input.tools?.length) characters += JSON.stringify(input.tools).length;
+	return Math.max(1, Math.ceil(characters / 4));
+}
+const DEFAULT_COMPACTOR_PROMPT = "You compact conversation history for another agent. Preserve decisions, approvals, constraints, identifiers, tool results and open tasks. Return only the summary.";
+/**
+* Creates a semantic compactor backed by a model. Use a cheap, fast model and
+* keep it separate from the agent model when possible. Large transcripts are
+* summarized in chunks and then merged.
+*/
+function createModelContextCompactor(options) {
+	const maxOutputTokens = options.maxOutputTokens ?? 1024;
+	if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) throw new TypeError("Model compactor maxOutputTokens must be a positive safe integer");
+	const maxInputChars = options.maxInputChars ?? 12e4;
+	if (!Number.isSafeInteger(maxInputChars) || maxInputChars < 1e3) throw new TypeError("Model compactor maxInputChars must be a safe integer of at least 1,000");
+	const systemPrompt = options.systemPrompt ?? DEFAULT_COMPACTOR_PROMPT;
+	const summarize = async (text, instruction, signal) => {
+		const stream = options.model.stream({
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: `${instruction}\n\n${text || "(empty)"}`
+			}],
+			maxOutputTokens,
+			...signal === void 0 ? {} : { signal }
+		});
+		let deltas = "";
+		let output;
+		for await (const event of stream) if (event.type === "output.delta") deltas += event.delta;
+		else output = event.result.output;
+		const summary = typeof output === "string" ? output : deltas;
+		if (!summary.trim()) throw new Error("Model context compactor returned an empty summary");
+		return summary.trim();
+	};
+	return { async compact(input) {
+		let current = formatTranscript(input.messages);
+		let depth = 0;
+		while (current.length > maxInputChars && depth < 4) {
+			const summaries = [];
+			for (const chunk of splitText(current, maxInputChars)) summaries.push(await summarize(chunk, "Summarize this part of a longer conversation. Preserve decisions, constraints, identifiers, tool results and open tasks.", input.signal));
+			current = summaries.join("\n\n");
+			depth += 1;
+		}
+		if (current.length > maxInputChars) current = `${current.slice(0, maxInputChars - 1)}…`;
+		return [{
+			role: "system",
+			content: await summarize(current, `Merge the following into one summary in at most ${input.targetTokens} tokens.`, input.signal)
+		}];
+	} };
+}
+function formatTranscript(messages) {
+	return messages.map((message) => {
+		const toolCalls = message.toolCalls?.length ? `\nTool calls: ${message.toolCalls.map((call) => `${call.name}(${JSON.stringify(call.input)})`).join(", ")}` : "";
+		const name = message.name === void 0 ? "" : ` (${message.name})`;
+		return `${message.role}${name}: ${message.content}${toolCalls}`;
+	}).join("\n\n");
+}
+function splitText(text, maxChars) {
+	const chunks = [];
+	let rest = text;
+	while (rest.length > maxChars) {
+		let cut = rest.lastIndexOf("\n", maxChars);
+		if (cut < Math.floor(maxChars / 2)) cut = maxChars;
+		chunks.push(rest.slice(0, cut));
+		rest = rest.slice(cut).trimStart();
+	}
+	if (rest) chunks.push(rest);
+	return chunks;
+}
+/**
+* Deterministic compactor used when the host does not inject one. It keeps
+* role-aware excerpts of older messages and drops the oldest excerpts first.
+* It never calls a model.
+*/
+function createDigestContextCompactor(options = {}) {
+	const maxChars = options.maxCharsPerMessage ?? 400;
+	if (!Number.isSafeInteger(maxChars) || maxChars < 40) throw new TypeError("Digest compactor maxCharsPerMessage must be a safe integer of at least 40");
+	return { compact(input) {
+		if (input.messages.length === 0) return [{
+			role: "system",
+			content: "[Compacted earlier conversation]"
+		}];
+		let perMessage = maxChars;
+		let lines = input.messages.flatMap((message) => digestMessage(message, perMessage));
+		while (input.estimateTokens([{
+			role: "system",
+			content: digestContent(lines, input.messages.length)
+		}]) > input.targetTokens && perMessage > 40) {
+			perMessage = Math.max(40, Math.floor(perMessage * .7));
+			lines = input.messages.flatMap((message) => digestMessage(message, perMessage));
+		}
+		let selected = lines;
+		let content = digestContent(selected, input.messages.length);
+		while (input.estimateTokens([{
+			role: "system",
+			content
+		}]) > input.targetTokens && selected.length > 1) {
+			selected = selected.slice(1);
+			content = digestContent(selected, input.messages.length);
+		}
+		const limit = Math.max(80, input.targetTokens * 4);
+		if (content.length > limit) content = `${content.slice(0, Math.max(0, limit - 1))}…`;
+		return [{
+			role: "system",
+			content
+		}];
+	} };
+}
+function digestContent(lines, totalMessages) {
+	const omitted = Math.max(0, totalMessages - lines.length);
+	return [`[Compacted conversation: ${totalMessages} earlier messages${omitted ? `, ${omitted} omitted` : ""}]`, ...lines].join("\n");
+}
+function digestMessage(message, maxChars) {
+	const content = truncate(message.content, maxChars);
+	if (message.role === "user") return content ? [`User: ${content}`] : [];
+	if (message.role === "assistant") {
+		const lines = [];
+		if (content) lines.push(`Assistant: ${content}`);
+		for (const call of message.toolCalls ?? []) lines.push(`Tool call ${call.name}: ${truncate(JSON.stringify(call.input), Math.min(maxChars, 200))}`);
+		return lines;
+	}
+	if (message.role === "tool") return content ? [`Tool result${message.name === void 0 ? "" : ` (${message.name})`}: ${content}`] : [];
+	return content ? [`System: ${content}`] : [];
+}
+function truncate(value, maxChars) {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	if (normalized.length <= maxChars) return normalized;
+	return `${normalized.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region src/runtime/run-store.ts
 function validateListEventsOptions(options) {
 	if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit < 1)) throw new TypeError("Event limit must be a positive safe integer");
@@ -180,4 +351,4 @@ var InMemoryRunStore = class {
 	}
 };
 //#endregion
-export { InMemoryRunStore, isDurableRunStore, isRetainableRunStore, validateListEventsOptions, validatePurgeRunsOptions };
+export { InMemoryRunStore, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/sandbox/index.d.mts

@@ -1,2 +1,2 @@
-import { a as SandboxError, c as sandboxResultToJson, i as SandboxCapabilities, n as createLocalSandbox, o as SandboxRunRequest, r as Sandbox, s as SandboxRunResult, t as LocalSandboxOptions } from "../index-Df84VWmN.mjs";
+import { a as SandboxError, c as sandboxResultToJson, i as SandboxCapabilities, n as createLocalSandbox, o as SandboxRunRequest, r as Sandbox, s as SandboxRunResult, t as LocalSandboxOptions } from "../index-CL7mu_x9.mjs";
 export { LocalSandboxOptions, Sandbox, SandboxCapabilities, SandboxError, SandboxRunRequest, SandboxRunResult, createLocalSandbox, sandboxResultToJson };

package/dist/teams/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "../index-1cHr7KB_.mjs";
+import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "../index-D8lCFkc7.mjs";
 export { type TeamDefinition, type TeamDelegation, type TeamHandoff, type TeamLimits, type TeamMember, type TeamStep, type TeamTaskResult, defineTeam };

package/dist/testing/index.d.mts

@@ -1,9 +1,9 @@
-import { m as ToolCall } from "../types-B8laW1hM.mjs";
-import { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-BgKFd9yw.mjs";
-import { h as ElicitationRequest, p as DurableRunStore } from "../index-CzAi2Y_Z.mjs";
-import { f as MemoryStore } from "../index-B0AdFbgr.mjs";
-import { d as ToolProvider } from "../index-5p3q2yIp.mjs";
-import { d as ChannelMessage, f as ChannelOutput, o as ChannelElicitationContext, r as ChannelAdapter } from "../index-BTD1c4Ys.mjs";
+import { E as ToolProvider } from "../index-BbwT5XxQ.mjs";
+import { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-D7r0puBi.mjs";
+import { m as ToolCall } from "../types-CckDlhYo.mjs";
+import { j as ElicitationRequest, k as DurableRunStore } from "../index-3bFNzCiY.mjs";
+import { f as MemoryStore } from "../index-D4mWV2zG.mjs";
+import { d as ChannelMessage, f as ChannelOutput, o as ChannelElicitationContext, r as ChannelAdapter } from "../index-CmFBB4Px.mjs";
 //#region src/testing/contracts.d.ts
 interface ModelGatewayContract {
   output?: unknown;

package/dist/tools/index.d.mts

@@ -1,3 +1,3 @@
-import { g as ToolSpec, m as ToolCall } from "../types-B8laW1hM.mjs";
-import { C as toToolSpec, S as defineTool, _ as ToolExecutionContext, a as compileFevexJsonSchema, b as ToolRetryPolicy, c as ConnectionToolPolicy, d as ToolProvider, f as ToolProviderContext, g as ToolDefinition, h as ToolApproval, i as FevexJsonSchemaValidator, l as IntegrationError, m as defineConnection, n as FevexJsonSchemaProfileLimits, o as validateFevexJsonSchemaProfile, p as ToolProviderTool, r as FevexJsonSchemaProfileOptions, s as ConnectionDefinition, t as FEVEX_JSON_SCHEMA_PROFILE_VERSION, u as IntegrationErrorCategory, v as ToolIdempotency, x as ToolRisk, y as ToolResult } from "../index-5p3q2yIp.mjs";
-export { ConnectionDefinition, ConnectionToolPolicy, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexJsonSchemaProfileLimits, FevexJsonSchemaProfileOptions, FevexJsonSchemaValidator, IntegrationError, IntegrationErrorCategory, ToolApproval, type ToolCall, ToolDefinition, ToolExecutionContext, ToolIdempotency, ToolProvider, ToolProviderContext, ToolProviderTool, ToolResult, ToolRetryPolicy, ToolRisk, type ToolSpec, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile };
+import { A as ToolApproval, C as ConnectionToolPolicy, D as ToolProviderContext, E as ToolProvider, F as ToolRetryPolicy, I as ToolRisk, L as defineTool, M as ToolExecutionContext, N as ToolIdempotency, O as ToolProviderTool, P as ToolResult, R as toToolSpec, S as ConnectionDefinition, T as IntegrationErrorCategory, _ as FevexJsonSchemaProfileLimits, a as InMemoryToolEmbeddingCacheOptions, b as compileFevexJsonSchema, c as ToolEmbeddingIndexEntry, d as cosineSimilarity, f as schemaKeywords, g as FEVEX_JSON_SCHEMA_PROFILE_VERSION, h as toolEmbeddingText, i as InMemoryToolEmbeddingCache, j as ToolDefinition, k as defineConnection, l as ToolEmbeddingMatch, m as toolEmbeddingKey, n as ToolSearchCandidate, o as ToolEmbeddingCache, p as searchToolEmbeddingIndex, r as BuildToolEmbeddingIndexOptions, s as ToolEmbeddingIndex, t as ToolReranker, u as buildToolEmbeddingIndex, v as FevexJsonSchemaProfileOptions, w as IntegrationError, x as validateFevexJsonSchemaProfile, y as FevexJsonSchemaValidator } from "../index-BbwT5XxQ.mjs";
+import { g as ToolSpec, m as ToolCall } from "../types-CckDlhYo.mjs";
+export { BuildToolEmbeddingIndexOptions, ConnectionDefinition, ConnectionToolPolicy, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexJsonSchemaProfileLimits, FevexJsonSchemaProfileOptions, FevexJsonSchemaValidator, InMemoryToolEmbeddingCache, InMemoryToolEmbeddingCacheOptions, IntegrationError, IntegrationErrorCategory, ToolApproval, type ToolCall, ToolDefinition, ToolEmbeddingCache, ToolEmbeddingIndex, ToolEmbeddingIndexEntry, ToolEmbeddingMatch, ToolExecutionContext, ToolIdempotency, ToolProvider, ToolProviderContext, ToolProviderTool, ToolReranker, ToolResult, ToolRetryPolicy, ToolRisk, ToolSearchCandidate, type ToolSpec, buildToolEmbeddingIndex, compileFevexJsonSchema, cosineSimilarity, defineConnection, defineTool, schemaKeywords, searchToolEmbeddingIndex, toToolSpec, toolEmbeddingKey, toolEmbeddingText, validateFevexJsonSchemaProfile };

package/dist/tools/index.mjs

@@ -230,4 +230,224 @@ function toToolSpec(tool, inputSchema) {
 	};
 }
 //#endregion
-export { FEVEX_JSON_SCHEMA_PROFILE_VERSION, IntegrationError, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile };
+//#region src/tools/tool-index.ts
+/** Bounded LRU cache for tool embeddings. */
+var InMemoryToolEmbeddingCache = class {
+	#entries = /* @__PURE__ */ new Map();
+	#maxEntries;
+	constructor(options = {}) {
+		const maxEntries = options.maxEntries ?? 1e3;
+		if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) throw new TypeError("Tool embedding cache maxEntries must be a positive safe integer");
+		this.#maxEntries = maxEntries;
+	}
+	get size() {
+		return this.#entries.size;
+	}
+	get(key) {
+		assertKey(key);
+		const value = this.#entries.get(key);
+		if (value === void 0) return void 0;
+		this.#entries.delete(key);
+		this.#entries.set(key, value);
+		return [...value];
+	}
+	set(key, vector) {
+		assertKey(key);
+		assertVector(vector, "Tool embedding cache vector");
+		this.#entries.delete(key);
+		this.#entries.set(key, [...vector]);
+		while (this.#entries.size > this.#maxEntries) {
+			const oldest = this.#entries.keys().next().value;
+			if (oldest === void 0) break;
+			this.#entries.delete(oldest);
+		}
+	}
+	getMany(keys) {
+		return keys.map((key) => this.get(key));
+	}
+	setMany(entries) {
+		for (const entry of entries) this.set(entry.key, entry.vector);
+	}
+};
+/**
+* Builds or refreshes a semantic index for a tool catalog. The content key is
+* `sha256(embeddingModel.id + text)`, so changing the model or the tool text
+* invalidates the cached vector.
+*/
+async function buildToolEmbeddingIndex(options) {
+	assertEmbeddingModel(options.embeddings);
+	const batchSize = options.batchSize ?? 64;
+	if (!Number.isSafeInteger(batchSize) || batchSize < 1) throw new TypeError("Tool embedding batchSize must be a positive safe integer");
+	const tools = options.tools;
+	const texts = tools.map(toolEmbeddingText);
+	const keys = await Promise.all(texts.map((text) => toolEmbeddingKey(options.embeddings.id, text)));
+	const vectors = /* @__PURE__ */ new Map();
+	const missing = /* @__PURE__ */ new Map();
+	const batchCached = await readCacheMany(options.cache, keys, options.embeddings.dimensions);
+	for (let index = 0; index < tools.length; index += 1) {
+		const key = keys[index];
+		const cached = batchCached === void 0 ? await readCache(options.cache, key, options.embeddings.dimensions) : batchCached[index];
+		if (cached !== void 0) {
+			vectors.set(key, cached);
+			continue;
+		}
+		if (!missing.has(key)) missing.set(key, texts[index]);
+	}
+	const pending = [...missing.entries()];
+	for (let offset = 0; offset < pending.length; offset += batchSize) {
+		options.signal?.throwIfAborted();
+		const batch = pending.slice(offset, offset + batchSize);
+		const embedded = await options.embeddings.embed({
+			texts: batch.map(([, text]) => text),
+			...options.signal === void 0 ? {} : { signal: options.signal }
+		});
+		if (!Array.isArray(embedded) || embedded.length !== batch.length) throw new Error(`Embedding model "${options.embeddings.id}" returned ${embedded.length} vectors for ${batch.length} texts`);
+		const writes = [];
+		for (let index = 0; index < batch.length; index += 1) {
+			const vector = embedded[index];
+			assertVector(vector, `Embedding for "${batch[index][1]}"`);
+			vectors.set(batch[index][0], vector);
+			writes.push({
+				key: batch[index][0],
+				vector
+			});
+		}
+		if (options.cache?.setMany !== void 0) try {
+			await options.cache.setMany(writes);
+		} catch {}
+		else for (const write of writes) await writeCache(options.cache, write.key, write.vector);
+	}
+	const dimensions = options.embeddings.dimensions ?? vectors.values().next().value?.length ?? 0;
+	for (const vector of vectors.values()) if (vector.length !== dimensions) throw new Error(`Embedding model "${options.embeddings.id}" returned mixed dimensions: ${dimensions} and ${vector.length}`);
+	return {
+		modelId: options.embeddings.id,
+		dimensions,
+		entries: tools.map((tool, index) => ({
+			tool,
+			vector: [...vectors.get(keys[index])]
+		}))
+	};
+}
+/** Returns cosine matches above `minScore`, ordered by score. */
+function searchToolEmbeddingIndex(index, query, limit, minScore = 0) {
+	if (!Number.isSafeInteger(limit) || limit < 1) throw new TypeError("Tool embedding search limit must be a positive safe integer");
+	if (query.length !== index.dimensions) throw new TypeError(`Query embedding has ${query.length} dimensions; index expects ${index.dimensions}`);
+	assertVector([...query], "Query embedding");
+	if (typeof minScore !== "number" || !Number.isFinite(minScore)) throw new TypeError("Tool embedding minScore must be a finite number");
+	return index.entries.map((entry) => ({
+		tool: entry.tool,
+		score: cosineSimilarity(query, entry.vector)
+	})).filter(({ score }) => score >= minScore).sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name)).slice(0, limit);
+}
+/** Canonical text indexed for one tool: name, description and schema keywords. */
+function toolEmbeddingText(tool) {
+	return [
+		tool.name,
+		tool.description ?? "",
+		schemaKeywords(tool.inputSchema)
+	].filter(Boolean).join("\n");
+}
+/** Extracts property names, descriptions, titles, required fields and enum values. */
+function schemaKeywords(schema) {
+	if (schema === void 0) return "";
+	const terms = /* @__PURE__ */ new Set();
+	const visit = (value, key) => {
+		if (typeof value === "string") {
+			if (key === "description" || key === "title" || key === "const") terms.add(value);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item, key);
+			return;
+		}
+		if (value === null || typeof value !== "object") return;
+		for (const [childKey, child] of Object.entries(value)) {
+			if (childKey === "properties" && child !== null && typeof child === "object" && !Array.isArray(child)) {
+				for (const property of Object.keys(child)) terms.add(property);
+				visit(child, childKey);
+				continue;
+			}
+			if (childKey === "required" && Array.isArray(child)) {
+				for (const item of child) if (typeof item === "string") terms.add(item);
+				continue;
+			}
+			if (childKey === "enum" && Array.isArray(child)) {
+				for (const item of child) terms.add(String(item));
+				continue;
+			}
+			visit(child, childKey);
+		}
+	};
+	visit(schema);
+	return [...terms].join(" ");
+}
+/** Stable content key for one embedding model and tool text. */
+async function toolEmbeddingKey(modelId, text) {
+	if (!modelId.trim()) throw new TypeError("Embedding model id cannot be empty");
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${modelId}\n${text}`));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function cosineSimilarity(left, right) {
+	assertVector(left, "Left cosine vector");
+	assertVector(right, "Right cosine vector");
+	if (left.length !== right.length) throw new TypeError(`Cosine vectors must have the same dimensions: ${left.length} and ${right.length}`);
+	let dot = 0;
+	let leftNorm = 0;
+	let rightNorm = 0;
+	for (let index = 0; index < left.length; index += 1) {
+		const a = left[index];
+		const b = right[index];
+		dot += a * b;
+		leftNorm += a * a;
+		rightNorm += b * b;
+	}
+	if (leftNorm === 0 || rightNorm === 0) return 0;
+	return dot / Math.sqrt(leftNorm * rightNorm);
+}
+function assertEmbeddingModel(model) {
+	if (typeof model.id !== "string" || !model.id.trim()) throw new TypeError("Embedding model id must be a non-empty string");
+	if (typeof model.embed !== "function") throw new TypeError("Embedding model must implement embed");
+	if (model.dimensions !== void 0 && (!Number.isSafeInteger(model.dimensions) || model.dimensions < 1)) throw new TypeError("Embedding model dimensions must be a positive safe integer");
+}
+function assertKey(key) {
+	if (typeof key !== "string" || !key.trim()) throw new TypeError("Tool embedding cache key must be a non-empty string");
+}
+function assertVector(vector, label) {
+	if (!Array.isArray(vector) || vector.length === 0 || vector.some((value) => typeof value !== "number" || !Number.isFinite(value))) throw new TypeError(`${label} must be a non-empty array of finite numbers`);
+}
+async function readCache(cache, key, dimensions) {
+	if (cache === void 0) return void 0;
+	try {
+		return normalizeCached(await cache.get(key), dimensions);
+	} catch {
+		return;
+	}
+}
+async function readCacheMany(cache, keys, dimensions) {
+	if (cache?.getMany === void 0) return void 0;
+	try {
+		const values = await cache.getMany(keys);
+		if (!Array.isArray(values) || values.length !== keys.length) return void 0;
+		return values.map((value) => normalizeCached(value, dimensions));
+	} catch {
+		return;
+	}
+}
+function normalizeCached(value, dimensions) {
+	if (value === void 0) return void 0;
+	try {
+		assertVector(value, "Cached tool embedding");
+		if (dimensions !== void 0 && value.length !== dimensions) return void 0;
+		return [...value];
+	} catch {
+		return;
+	}
+}
+async function writeCache(cache, key, vector) {
+	if (cache === void 0) return;
+	try {
+		await cache.set(key, [...vector]);
+	} catch {}
+}
+//#endregion
+export { FEVEX_JSON_SCHEMA_PROFILE_VERSION, InMemoryToolEmbeddingCache, IntegrationError, buildToolEmbeddingIndex, compileFevexJsonSchema, cosineSimilarity, defineConnection, defineTool, schemaKeywords, searchToolEmbeddingIndex, toToolSpec, toolEmbeddingKey, toolEmbeddingText, validateFevexJsonSchemaProfile };

package/dist/{types-B8laW1hM.d.mts → types-CckDlhYo.d.mts}

@@ -258,7 +258,7 @@ interface ToolEventSource {
   connectionName: string;
   remoteToolName: string;
 }
-type AgentEventType = 'run.started' | 'run.recovered' | 'run.paused' | 'run.resumed' | 'model.started' | 'model.output.delta' | 'model.completed' | 'tool.started' | 'tool.completed' | 'tool.failed' | 'tool.retrying' | 'tool.execution_unknown' | 'artifact.created' | 'elicitation.requested' | 'elicitation.resolved' | 'approval.requested' | 'approval.resolved' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'workflow.run.started' | 'workflow.run.recovered' | 'workflow.step.started' | 'workflow.step.completed' | 'workflow.step.failed' | 'workflow.compensation.started' | 'workflow.compensation.completed' | 'workflow.compensation.failed' | 'workflow.wait.started' | 'workflow.wait.completed' | 'workflow.run.paused' | 'workflow.run.resumed' | 'workflow.run.completed' | 'workflow.run.failed' | 'workflow.run.cancelled' | 'team.run.started' | 'team.run.recovered' | 'team.agent.assigned' | 'team.handoff.created' | 'team.task.completed' | 'team.task.failed' | 'team.merge.started' | 'team.merge.completed' | 'team.merge.failed' | 'team.run.paused' | 'team.run.resumed' | 'team.run.completed' | 'team.run.failed' | 'team.run.cancelled';
+type AgentEventType = 'run.started' | 'run.recovered' | 'run.paused' | 'run.resumed' | 'model.started' | 'model.output.delta' | 'model.completed' | 'context.compacted' | 'tool.started' | 'tool.completed' | 'tool.failed' | 'tool.retrying' | 'tool.execution_unknown' | 'artifact.created' | 'elicitation.requested' | 'elicitation.resolved' | 'approval.requested' | 'approval.resolved' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'workflow.run.started' | 'workflow.run.recovered' | 'workflow.step.started' | 'workflow.step.completed' | 'workflow.step.failed' | 'workflow.compensation.started' | 'workflow.compensation.completed' | 'workflow.compensation.failed' | 'workflow.wait.started' | 'workflow.wait.completed' | 'workflow.run.paused' | 'workflow.run.resumed' | 'workflow.run.completed' | 'workflow.run.failed' | 'workflow.run.cancelled' | 'team.run.started' | 'team.run.recovered' | 'team.agent.assigned' | 'team.handoff.created' | 'team.task.completed' | 'team.task.failed' | 'team.merge.started' | 'team.merge.completed' | 'team.merge.failed' | 'team.run.paused' | 'team.run.resumed' | 'team.run.completed' | 'team.run.failed' | 'team.run.cancelled';
 interface AgentEventPayloads {
   'run.started': undefined;
   'run.recovered': {
@@ -292,6 +292,20 @@ interface AgentEventPayloads {
     teamDelegationId?: string;
     teamAgentName?: string;
   };
+  'context.compacted': {
+    step: number;
+    removedMessages: number;
+    estimatedTokens: number;
+    compactedTokens: number;
+    targetTokens: number;
+    contextWindow: number;
+    summary: string;
+    summaryTruncated?: boolean;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
   'tool.started': {
     step: number;
     toolCallId: string;

package/dist/workflows/index.d.mts

@@ -1,2 +1,2 @@
-import { a as WorkflowStep, c as defineWorkflow, i as WorkflowEventResult, n as WorkflowDefinition, o as WorkflowStepContext, r as WorkflowEventDefinition, s as WorkflowStepOptions, t as WorkflowAgentResult } from "../index-CseuTR-F.mjs";
+import { a as WorkflowStep, c as defineWorkflow, i as WorkflowEventResult, n as WorkflowDefinition, o as WorkflowStepContext, r as WorkflowEventDefinition, s as WorkflowStepOptions, t as WorkflowAgentResult } from "../index-DgSxJZo4.mjs";
 export { WorkflowAgentResult, WorkflowDefinition, WorkflowEventDefinition, WorkflowEventResult, WorkflowStep, WorkflowStepContext, WorkflowStepOptions, defineWorkflow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fevex/core",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.9",
   "description": "Agent Engineering Framework for code-first, provider-neutral AI agents.",
   "type": "module",
   "license": "Apache-2.0",

package/dist/exact-definition-NHBBFlFR.d.mts

@@ -1,4 +0,0 @@
-//#region src/internal/exact-definition.d.ts
-type ExactDefinition<TInput, TShape> = TInput & { readonly [TKey in Exclude<keyof TInput, keyof TShape>]: never; };
-//#endregion
-export { ExactDefinition as t };