@fevex/core 0.1.0-alpha.8 → 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-CAyAoOW0.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-BfYzemR8.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-CecXoEbs.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-Bl0hR7EC.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 ToolExecutionRecord, A as ListEventsOptions, B as RunPause, C as DurableRunStore, D as EventResolution, E as ElicitationResolution, F as RetainableRunStatus, G as RunStore, H as RunRequest, I as RetainableRunStore, J as SessionId, K as Session, L as RunCheckpoint, M as PurgeRunsOptions, N as PurgeRunsResult, O as ExecutionCommit, P as ResumeRunResolution, Q as TimerResolution, R as RunCorrelation, S as CredentialStore, T as ElicitationRequest, U as RunResult, V as RunRecord, W as RunStatus, X as TeamCheckpoint, Y as StoredRunCheckpoint, Z as TeamRun, _ as ApprovalMode, a as InMemoryRunStore, at as WorkflowRun, b as CoordinatorCheckpoint, c as ContextCompactor, ct as isDurableRunStore, d as ResolvedContextBudget, dt as validatePurgeRunsOptions, et as ToolExecutionResolution, f as createDigestContextCompactor, g as AgentRunPause, h as AgentRun, it as WorkflowCompensationRecord, j as PendingToolExecution, k as ExecutionCreate, l as ContextTokenEstimator, lt as isRetainableRunStore, m as resolveContextBudget, nt as WorkflowBudgetUsage, o as ContextCompactionInput, ot as WorkflowStepRecord, p as estimateContextTokens, q as SessionCompaction, rt as WorkflowCheckpoint, s as ContextCompactionOptions, st as WorkflowWaitRecord, tt as ToolExecutionStatus, u as DigestContextCompactorOptions, ut as validateListEventsOptions, v as ApprovalRequest, w as ElicitationMode, x as CoordinatorRun, y as ApprovalResolution, z as RunLease } from "../index-B8molngu.mjs";
-export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, ContextCompactionInput, ContextCompactionOptions, ContextCompactor, ContextTokenEstimator, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DigestContextCompactorOptions, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, 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, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, 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

@@ -39,6 +39,73 @@ function estimateContextTokens(input) {
 	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.
@@ -284,4 +351,4 @@ var InMemoryRunStore = class {
 	}
 };
 //#endregion
-export { InMemoryRunStore, createDigestContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };
+export { InMemoryRunStore, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };

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-CODYPevS.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 { 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 { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-BfYzemR8.mjs";
-import { C as DurableRunStore, T as ElicitationRequest } from "../index-B8molngu.mjs";
-import { f as MemoryStore } from "../index-CAyAoOW0.mjs";
-import { d as ToolProvider } from "../index-DtMxzCqj.mjs";
-import { d as ChannelMessage, f as ChannelOutput, o as ChannelElicitationContext, r as ChannelAdapter } from "../index-CuaetTLQ.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 { 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";
-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-DtMxzCqj.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 };
+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/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-RKE3-CKs.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.8",
+  "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 };