@fevex/core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/knowledge/index.d.mts

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

package/dist/knowledge/index.mjs

@@ -0,0 +1,289 @@
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+//#region src/knowledge/knowledge.ts
+function isProgressiveSkillProvider(provider) {
+	const candidate = provider;
+	return typeof candidate.load === "function" && typeof candidate.description === "string";
+}
+function defineContextProvider(provider) {
+	return provider;
+}
+function defineSkill(skill) {
+	return defineContextProvider({
+		name: skill.name,
+		async read() {
+			return [{
+				id: `${skill.name}:instructions`,
+				content: skill.instructions
+			}, ...(skill.resources ?? []).map((resource, index) => {
+				const normalized = isSkillResource(resource) ? resource : { content: resource };
+				return {
+					id: normalized.id ?? `${skill.name}:resource:${index + 1}`,
+					content: stringifyKnowledge(normalized.content),
+					...normalized.metadata === void 0 ? {} : { metadata: normalized.metadata }
+				};
+			})];
+		}
+	});
+}
+function isSkillResource(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "content" in value && (value.id === void 0 || typeof value.id === "string");
+}
+function createMemoryContextProvider(options) {
+	return defineContextProvider({
+		name: options.name ?? "memory",
+		async read(context) {
+			return (await options.store.search({
+				query: context.input,
+				limit: options.limit,
+				agentName: context.agentName,
+				sessionId: context.sessionId,
+				namespace: context.context?.namespace,
+				actor: context.context?.actor
+			}, context)).map((record) => ({
+				id: record.id,
+				content: record.content,
+				metadata: {
+					...record.metadata ?? {},
+					createdAt: record.createdAt,
+					...record.agentName === void 0 ? {} : { agentName: record.agentName },
+					...record.sessionId === void 0 ? {} : { sessionId: record.sessionId }
+				}
+			}));
+		}
+	});
+}
+function stringifyKnowledge(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+//#endregion
+//#region src/knowledge/agents-md.ts
+const DEFAULT_MAX_BYTES$1 = 256 * 1024;
+/**
+* Reads one explicit `AGENTS.md` file as context.
+*
+* Fevex never walks the filesystem looking for `AGENTS.md`; register one
+* provider per file and reference its name from `agent.context`.
+*/
+function createAgentsMdContextProvider(options) {
+	const path = typeof options === "string" ? options : options.path;
+	const name = ((typeof options === "string" ? void 0 : options.name) ?? "agents-md").trim();
+	const maxBytes = (typeof options === "string" ? void 0 : options.maxBytes) ?? DEFAULT_MAX_BYTES$1;
+	if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new TypeError("AGENTS.md maxBytes must be a positive safe integer");
+	if (!name.trim()) throw new TypeError("AGENTS.md provider name cannot be empty");
+	return defineContextProvider({
+		name,
+		async read() {
+			if ((await stat(path)).size > maxBytes) throw new Error(`AGENTS.md file "${path}" exceeds ${maxBytes} bytes`);
+			const content = await readFile(path, "utf8");
+			if (Buffer.byteLength(content) > maxBytes) throw new Error(`AGENTS.md file "${path}" exceeds ${maxBytes} bytes`);
+			return content.trim() ? [{
+				id: "agents-md",
+				content
+			}] : [];
+		}
+	});
+}
+//#endregion
+//#region src/knowledge/in-memory-memory-store.ts
+/** Volatile keyword-search memory store for tests and local development. */
+var InMemoryMemoryStore = class {
+	#records = /* @__PURE__ */ new Map();
+	async search(query, context) {
+		context.signal?.throwIfAborted();
+		const terms = query.query.toLowerCase().split(/\s+/).filter(Boolean);
+		const scored = [...this.#records.values()].filter((record) => matchesScope(record, query)).map((record) => ({
+			record,
+			score: score(record.content, terms)
+		})).filter(({ score }) => !terms.length || score > 0).sort((left, right) => right.score - left.score || right.record.createdAt.localeCompare(left.record.createdAt));
+		return scored.slice(0, query.limit ?? scored.length).map(({ record }) => structuredClone(record));
+	}
+	async write(record, context) {
+		context.signal?.throwIfAborted();
+		const saved = {
+			id: crypto.randomUUID(),
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...structuredClone(record)
+		};
+		this.#records.set(saved.id, saved);
+		return structuredClone(saved);
+	}
+};
+function matchesScope(record, query) {
+	return matches(record.agentName, query.agentName) && matches(record.sessionId, query.sessionId) && matches(record.namespace, query.namespace) && matches(record.actor?.id, query.actor?.id);
+}
+function matches(left, right) {
+	return right === void 0 || left === void 0 || left === right;
+}
+function score(content, terms) {
+	const text = content.toLowerCase();
+	return terms.reduce((total, term) => total + (text.includes(term) ? 1 : 0), 0);
+}
+//#endregion
+//#region src/knowledge/skill-file.ts
+const DEFAULT_MAX_BYTES = 256 * 1024;
+const DEFAULT_MAX_RESOURCE_BYTES = 256 * 1024;
+const MAX_RESOURCES = 200;
+const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const RESOURCE_DIRECTORIES = [
+	"references",
+	"scripts",
+	"assets"
+];
+/**
+* Loads one explicit `SKILL.md` file.
+*
+* Only `name` and `description` are advertised up front. The body and any
+* files under `references/`, `scripts/` or `assets/` load on demand.
+*/
+async function loadSkillFile(path, options = {}) {
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+	const maxResourceBytes = options.maxResourceBytes ?? DEFAULT_MAX_RESOURCE_BYTES;
+	assertPositiveInteger(maxBytes, "maxBytes");
+	assertPositiveInteger(maxResourceBytes, "maxResourceBytes");
+	const absolute = await realpath(resolve(path));
+	if ((await stat(absolute)).size > maxBytes) throw new Error(`Skill file "${path}" exceeds ${maxBytes} bytes`);
+	const source = (await readFile(absolute, "utf8")).replace(/^\uFEFF/, "");
+	if (Buffer.byteLength(source) > maxBytes) throw new Error(`Skill file "${path}" exceeds ${maxBytes} bytes`);
+	const skill = parseSkillFile(source, path);
+	const root = dirname(absolute);
+	return defineContextProvider({
+		name: skill.name,
+		description: skill.description,
+		async read() {
+			return [{
+				id: `${skill.name}:metadata`,
+				content: skill.description
+			}];
+		},
+		async load(_context, resource) {
+			if (resource !== void 0) return [{
+				id: `${skill.name}:resource:${resource}`,
+				content: await readResource(root, resource, maxResourceBytes)
+			}];
+			const blocks = [{
+				id: `${skill.name}:instructions`,
+				content: skill.instructions
+			}];
+			const resources = await listResources(root);
+			if (resources.length) blocks.push({
+				id: `${skill.name}:resources`,
+				content: [
+					"Resources:",
+					...resources.map((item) => `- ${item.path} (${formatBytes(item.size)})`),
+					"Load one by passing its path as the resource argument.",
+					...resources.some((item) => item.path.startsWith("scripts/")) ? ["Scripts are for reference only and are not executed by this runtime."] : []
+				].join("\n")
+			});
+			return blocks;
+		}
+	});
+}
+/** Loads several explicit `SKILL.md` files; it never scans directories. */
+function loadSkillFiles(paths, options = {}) {
+	return Promise.all(paths.map((path) => loadSkillFile(path, options)));
+}
+function parseSkillFile(source, path) {
+	const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(source);
+	if (!match) throw new Error(`Skill file "${path}" must start with --- frontmatter`);
+	const fields = parseFrontmatter(match[1]);
+	const name = fields.name?.trim();
+	const description = fields.description?.trim();
+	const instructions = match[2].trim();
+	if (!name) throw new Error(`Skill file "${path}" must define a name`);
+	if (name.length > 64 || !SKILL_NAME.test(name) || name.startsWith("fevex__")) throw new Error(`Skill file "${path}" has an invalid name; use lowercase letters, numbers and hyphens, up to 64 characters`);
+	if (!description) throw new Error(`Skill file "${path}" must define a description`);
+	if (!instructions) throw new Error(`Skill file "${path}" must contain instructions`);
+	return {
+		name,
+		description,
+		instructions
+	};
+}
+function parseFrontmatter(source) {
+	const fields = {};
+	const lines = source.split(/\r?\n/);
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (!line.trim() || line.trimStart().startsWith("#")) continue;
+		if (/^\s/.test(line)) continue;
+		const colon = line.indexOf(":");
+		if (colon <= 0) continue;
+		const key = line.slice(0, colon).trim();
+		let value = line.slice(colon + 1).trim();
+		if (value === "|" || value === ">" || value === "|-" || value === ">-") {
+			const block = [];
+			while (index + 1 < lines.length) {
+				const next = lines[index + 1];
+				if (next.trim() && !/^\s/.test(next)) break;
+				index += 1;
+				block.push(next.replace(/^\s+/, ""));
+			}
+			while (block.length && !block[block.length - 1]) block.pop();
+			value = value.startsWith(">") ? block.filter(Boolean).join(" ") : block.join("\n");
+		} else if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		fields[key] = value;
+	}
+	return fields;
+}
+async function listResources(root) {
+	const resources = [];
+	for (const directory of RESOURCE_DIRECTORIES) await walkResources(resolve(root, directory), root, resources);
+	return resources.sort((left, right) => left.path.localeCompare(right.path)).slice(0, MAX_RESOURCES);
+}
+async function walkResources(directory, root, resources) {
+	if (resources.length >= MAX_RESOURCES) return;
+	let entries;
+	try {
+		entries = await readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if (isMissing(error)) return;
+		throw error;
+	}
+	for (const entry of entries) {
+		if (resources.length >= MAX_RESOURCES) return;
+		if (entry.isSymbolicLink()) continue;
+		const target = resolve(directory, entry.name);
+		if (entry.isDirectory()) {
+			await walkResources(target, root, resources);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		const info = await stat(target);
+		resources.push({
+			path: relative(root, target).split("\\").join("/"),
+			size: info.size
+		});
+	}
+}
+async function readResource(root, resource, maxBytes) {
+	if (resource.includes("\0")) throw new Error("Skill resource path is invalid");
+	const requested = resolve(root, resource);
+	const requestedPath = relative(root, requested);
+	if (!requestedPath || requestedPath.startsWith("..") || isAbsolute(requestedPath)) throw new Error(`Skill resource "${resource}" is outside the skill directory`);
+	let target;
+	try {
+		target = await realpath(requested);
+	} catch {
+		throw new Error(`Skill resource "${resource}" was not found`);
+	}
+	const path = relative(root, target);
+	if (!path || path.startsWith("..") || isAbsolute(path)) throw new Error(`Skill resource "${resource}" is outside the skill directory`);
+	const info = await stat(target);
+	if (!info.isFile()) throw new Error(`Skill resource "${resource}" is not a file`);
+	if (info.size > maxBytes) throw new Error(`Skill resource "${resource}" exceeds ${maxBytes} bytes`);
+	const buffer = await readFile(target);
+	if (buffer.includes(0)) throw new Error(`Skill resource "${resource}" is not UTF-8 text`);
+	return buffer.toString("utf8");
+}
+function formatBytes(bytes) {
+	return bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} KB`;
+}
+function assertPositiveInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`Skill ${name} must be a positive safe integer`);
+}
+function isMissing(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+export { InMemoryMemoryStore, createAgentsMdContextProvider, createMemoryContextProvider, defineContextProvider, defineSkill, isProgressiveSkillProvider, loadSkillFile, loadSkillFiles };

package/dist/model-stream-JQdHDDcj.mjs

@@ -0,0 +1,131 @@
+import { n as abortable } from "./run-support-CmZ6Xo6H.mjs";
+//#region src/internal/model-stream.ts
+const MAX_DELTA_CHARS = 512;
+const MAX_DELTA_DELAY_MS = 32;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (!isRecord(value)) return value;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)]));
+}
+function assertConsistentOutput(result, outputText) {
+	if (result.output === void 0) {
+		if (outputText) throw new TypeError("Model stream emitted output without a final output");
+		return;
+	}
+	if (typeof result.output === "string") {
+		if (result.output !== outputText) throw new TypeError("Model stream deltas do not match the final output");
+		return;
+	}
+	if (!outputText) throw new TypeError("Model stream returned JSON output without output deltas");
+	let parsed;
+	try {
+		parsed = JSON.parse(outputText);
+	} catch (error) {
+		throw new TypeError("Model stream output deltas are not valid JSON", { cause: error });
+	}
+	if (JSON.stringify(canonicalJson(parsed)) !== JSON.stringify(canonicalJson(result.output))) throw new TypeError("Model stream deltas do not match the final JSON output");
+}
+function assertStreamEvent(value) {
+	if (!isRecord(value)) throw new TypeError("ModelGateway stream event must be an object");
+	if (value.type === "output.delta") {
+		if (typeof value.delta !== "string") throw new TypeError("ModelGateway output.delta must contain a string delta");
+		return;
+	}
+	if (value.type === "completed") {
+		if (!isRecord(value.result)) throw new TypeError("ModelGateway completed event must contain a result");
+		return;
+	}
+	throw new TypeError("ModelGateway returned an unknown stream event");
+}
+function takeCharacters(value, count) {
+	const characters = Array.from(value);
+	return [characters.slice(0, count).join(""), characters.slice(count).join("")];
+}
+async function* readModelStream(model, input) {
+	input.signal?.throwIfAborted();
+	const stream = model.stream(input);
+	if (!stream || typeof stream[Symbol.asyncIterator] !== "function") throw new TypeError("ModelGateway.stream must return an AsyncIterable");
+	const iterator = stream[Symbol.asyncIterator]();
+	let pending;
+	let completed;
+	let outputText = "";
+	let buffer = "";
+	let firstDelta = true;
+	let bufferedAt = 0;
+	const next = () => {
+		const promise = abortable(() => iterator.next(), input.signal);
+		promise.catch(() => {});
+		return promise;
+	};
+	try {
+		while (true) {
+			if (buffer && Array.from(buffer).length >= MAX_DELTA_CHARS) {
+				const [chunk, rest] = takeCharacters(buffer, MAX_DELTA_CHARS);
+				buffer = rest;
+				bufferedAt = performance.now();
+				yield chunk;
+				continue;
+			}
+			pending ??= next();
+			let item;
+			if (buffer) {
+				const remaining = Math.max(0, MAX_DELTA_DELAY_MS - (performance.now() - bufferedAt));
+				const raced = await Promise.race([pending.then((value) => ({
+					type: "item",
+					value
+				})), new Promise((resolve) => {
+					setTimeout(() => resolve({ type: "flush" }), remaining);
+				})]);
+				if (raced.type === "flush") {
+					const chunk = buffer;
+					buffer = "";
+					bufferedAt = 0;
+					yield chunk;
+					continue;
+				}
+				item = raced.value;
+			} else item = await pending;
+			pending = void 0;
+			if (item.done) {
+				if (!completed) throw new TypeError("ModelGateway stream ended without completed");
+				assertConsistentOutput(completed, outputText);
+				return completed;
+			}
+			assertStreamEvent(item.value);
+			if (completed) throw new TypeError("ModelGateway stream emitted an event after completed");
+			if (item.value.type === "completed") {
+				completed = item.value.result;
+				if (buffer) {
+					const chunk = buffer;
+					buffer = "";
+					bufferedAt = 0;
+					yield chunk;
+				}
+				continue;
+			}
+			if (!item.value.delta) continue;
+			outputText += item.value.delta;
+			buffer += item.value.delta;
+			if (firstDelta) {
+				const [chunk, rest] = takeCharacters(buffer, MAX_DELTA_CHARS);
+				firstDelta = false;
+				buffer = rest;
+				bufferedAt = performance.now();
+				yield chunk;
+			} else if (!bufferedAt) bufferedAt = performance.now();
+		}
+	} catch (error) {
+		if (buffer) yield buffer;
+		throw error;
+	} finally {
+		if (pending) pending.catch(() => {});
+		if (iterator.return) Promise.resolve(iterator.return()).catch(() => {});
+	}
+}
+//#endregion
+export { readModelStream as t };

package/dist/models/index.d.mts

@@ -1,27 +1,2 @@
-import { d as ToolCall, f as ToolSpec, o as JsonObject, r as AgentMessage } from "../index-D_RBJmVt.mjs";
-//#region src/models/index.d.ts
-type ReasoningEffort = 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high';
-interface ModelUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-}
-interface ModelGenerateInput {
-  messages: AgentMessage[];
-  tools?: ToolSpec[];
-  reasoning?: ReasoningEffort;
-  modelOptions?: Record<string, unknown>;
-  outputSchema?: JsonObject;
-  signal?: AbortSignal;
-}
-interface ModelGenerateResult<TOutput = unknown> {
-  output?: TOutput;
-  toolCalls?: ToolCall[];
-  usage?: ModelUsage;
-}
-interface ModelGateway {
-  generate(input: ModelGenerateInput): Promise<ModelGenerateResult>;
-}
-type ModelRef = string | ModelGateway;
-//#endregion
-export { ModelGateway, ModelGenerateInput, ModelGenerateResult, ModelRef, ModelUsage, ReasoningEffort };
+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

@@ -0,0 +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-BEqYWean.mjs";
+export { CostCalculator, CostCalculatorInput, ObservabilityOptions, ObservabilityStats, RunTrace, TraceAnnotation, TraceContent, TraceContentKind, TraceContentPolicy, TraceCost, TraceExportQueueOptions, TraceExporter, TraceRedactor, TraceRedactorInput, TraceRunKind, TraceSpan, TraceSpanKind, TraceStatus };

package/dist/observability/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/policies/index.d.mts

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

package/dist/policies/index.mjs

@@ -0,0 +1,6 @@
+//#region src/policies/policy.ts
+function definePolicy(policy) {
+	return policy;
+}
+//#endregion
+export { definePolicy };

package/dist/run-error-Cr17wPGH.mjs

@@ -0,0 +1,23 @@
+//#region src/run-error.ts
+var FevexRunError = class extends Error {
+	code;
+	runId;
+	name = "FevexRunError";
+	constructor(code, message, runId, options) {
+		super(message, options);
+		this.code = code;
+		this.runId = runId;
+	}
+};
+var RunPausedError = class extends FevexRunError {
+	runId;
+	pause;
+	name = "RunPausedError";
+	constructor(runId, pause) {
+		super("RUN_PAUSED", `Run "${runId}" is paused`, runId);
+		this.runId = runId;
+		this.pause = pause;
+	}
+};
+//#endregion
+export { RunPausedError as n, FevexRunError as t };

package/dist/run-support-CmZ6Xo6H.mjs

@@ -0,0 +1,162 @@
+import { t as FevexRunError } from "./run-error-Cr17wPGH.mjs";
+//#region src/internal/json.ts
+const invalidJsonValue = Symbol("invalid-json-value");
+function normalizeJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : invalidJsonValue;
+	if (Array.isArray(value)) {
+		const normalized = [];
+		for (const item of value) {
+			const normalizedItem = normalizeJsonValue(item, seen);
+			if (normalizedItem === invalidJsonValue) return invalidJsonValue;
+			normalized.push(normalizedItem);
+		}
+		return normalized;
+	}
+	if (typeof value !== "object" || value === void 0) return invalidJsonValue;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype) return invalidJsonValue;
+	if (seen.has(value)) return invalidJsonValue;
+	seen.add(value);
+	const normalized = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (item === void 0) continue;
+		const normalizedItem = normalizeJsonValue(item, seen);
+		if (normalizedItem === invalidJsonValue) return invalidJsonValue;
+		Object.defineProperty(normalized, key, {
+			value: normalizedItem,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	}
+	seen.delete(value);
+	return normalized;
+}
+function toJsonValue(value, errorMessage) {
+	let normalized;
+	try {
+		normalized = normalizeJsonValue(value);
+	} catch {
+		throw new TypeError(errorMessage);
+	}
+	if (normalized === invalidJsonValue) throw new TypeError(errorMessage);
+	return normalized;
+}
+function serializeJsonValue(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+function serializeValue(value, errorMessage) {
+	return serializeJsonValue(toJsonValue(value, errorMessage));
+}
+//#endregion
+//#region src/internal/run-support.ts
+/** Largest delay accepted by Node and Bun timers. */
+const MAX_DEADLINE_MS = 2147483647;
+function deadlineAtFromMs(deadlineMs) {
+	if (deadlineMs === void 0) return void 0;
+	if (!Number.isSafeInteger(deadlineMs) || deadlineMs <= 0 || deadlineMs > 2147483647) throw new TypeError(`deadlineMs must be a positive safe integer up to ${MAX_DEADLINE_MS}`);
+	return new Date(Date.now() + deadlineMs).toISOString();
+}
+function runSignal(controller, request) {
+	const signals = [controller.signal];
+	if (request.signal) signals.push(request.signal);
+	if (request.deadlineMs !== void 0) {
+		deadlineAtFromMs(request.deadlineMs);
+		signals.push(AbortSignal.timeout(request.deadlineMs));
+	}
+	return AbortSignal.any(signals);
+}
+function resumeDeadlineSignal(deadlineAt, runId, code) {
+	if (deadlineAt === void 0) return void 0;
+	const expiresAt = Date.parse(deadlineAt);
+	if (!Number.isFinite(expiresAt)) throw new FevexRunError(code, `Run "${runId}" has an invalid deadline`, runId);
+	if (expiresAt <= Date.now()) throw new FevexRunError(code, `Run "${runId}" deadline has passed`, runId);
+	return AbortSignal.timeout(expiresAt - Date.now());
+}
+function remainingDeadlineMs(deadlineAt, runId) {
+	if (deadlineAt === void 0) return void 0;
+	const expiresAt = Date.parse(deadlineAt);
+	if (!Number.isFinite(expiresAt)) throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" has an invalid deadline`, runId);
+	const remaining = expiresAt - Date.now();
+	if (remaining <= 0) throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" deadline has passed`, runId);
+	return remaining;
+}
+function isTimeoutError(error) {
+	return typeof error === "object" && error !== null && error.name === "TimeoutError";
+}
+function minDeadline(first, second) {
+	if (first === void 0) return second;
+	if (second === void 0) return first;
+	return Math.min(first, second);
+}
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error) ?? String(error);
+	} catch {
+		return String(error);
+	}
+}
+async function abortable(operation, signal) {
+	signal?.throwIfAborted();
+	if (!signal) return await operation();
+	const result = await new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			callback();
+		};
+		const onAbort = () => finish(() => reject(signal.reason));
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		Promise.resolve().then(() => {
+			signal.throwIfAborted();
+			return operation();
+		}).then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+	});
+	signal.throwIfAborted();
+	return result;
+}
+function cancellationReason(signal) {
+	return signal.reason instanceof Error && signal.reason.name === "TimeoutError" ? "timeout" : "aborted";
+}
+function addUsage(first, second) {
+	if (!first) return second;
+	if (!second) return first;
+	const inputTokens = first.inputTokens === void 0 && second.inputTokens === void 0 ? void 0 : (first.inputTokens ?? 0) + (second.inputTokens ?? 0);
+	const outputTokens = first.outputTokens === void 0 && second.outputTokens === void 0 ? void 0 : (first.outputTokens ?? 0) + (second.outputTokens ?? 0);
+	const totalTokens = first.totalTokens === void 0 && second.totalTokens === void 0 ? void 0 : (first.totalTokens ?? 0) + (second.totalTokens ?? 0);
+	return {
+		...inputTokens !== void 0 ? { inputTokens } : {},
+		...outputTokens !== void 0 ? { outputTokens } : {},
+		...totalTokens !== void 0 ? { totalTokens } : {}
+	};
+}
+function assertTokenBudget(agentName, limitName, usageName, limit, stepUsage, totalUsage) {
+	if (limit === void 0 || limit === false) return;
+	const stepTokens = stepUsage?.[usageName];
+	if (stepTokens === void 0 || !Number.isFinite(stepTokens) || stepTokens < 0) throw new Error(`Agent "${agentName}" cannot enforce ${limitName}: model usage.${usageName} is missing or invalid`);
+	if ((totalUsage?.[usageName] ?? 0) > limit) throw new Error(`Agent "${agentName}" exceeded ${limitName} limit of ${limit}`);
+}
+function assertContinuationBudget(agentName, limitName, usageName, limit, totalUsage) {
+	if (limit !== void 0 && limit !== false && (totalUsage?.[usageName] ?? 0) >= limit) throw new Error(`Agent "${agentName}" exhausted ${limitName} limit of ${limit} before completing`);
+}
+function remainingOutputTokens(limit, usage) {
+	if (limit === void 0 || limit === false) return void 0;
+	return limit - (usage?.outputTokens ?? 0);
+}
+function eventUsage(usage) {
+	if (usage === void 0) return void 0;
+	const value = toJsonValue(usage, "Model usage must be JSON-serializable");
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Model usage must be a JSON object");
+	return value;
+}
+//#endregion
+export { serializeValue as _, assertTokenBudget as a, eventUsage as c, remainingDeadlineMs as d, remainingOutputTokens as f, serializeJsonValue as g, toErrorMessage as h, assertContinuationBudget as i, isTimeoutError as l, runSignal as m, abortable as n, cancellationReason as o, resumeDeadlineSignal as p, addUsage as r, deadlineAtFromMs as s, MAX_DEADLINE_MS as t, minDeadline as u, toJsonValue as v };