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

package/dist/model-stream-u2xMsEaf.mjs

@@ -0,0 +1,251 @@
+//#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
+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
+//#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 { assertTokenBudget as a, remainingOutputTokens as c, serializeValue as d, toJsonValue as f, assertContinuationBudget as i, toErrorMessage as l, abortable as n, cancellationReason as o, addUsage as r, eventUsage as s, readModelStream as t, serializeJsonValue as u };

package/dist/models/index.d.mts

@@ -1,4 +1,4 @@
-import { d as ToolCall, f as ToolSpec, o as JsonObject, r as AgentMessage } from "../index-D_RBJmVt.mjs";
+import { h as ToolSpec, i as AgentMessage, l as JsonValue, m as ToolCall, s as JsonObject } from "../index-C_Zpr13f.mjs";
 //#region src/models/index.d.ts
 type ReasoningEffort = 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high';
 interface ModelUsage {
@@ -6,22 +6,41 @@ interface ModelUsage {
   outputTokens?: number;
   totalTokens?: number;
 }
-interface ModelGenerateInput {
+interface ModelInput {
   messages: AgentMessage[];
   tools?: ToolSpec[];
   reasoning?: ReasoningEffort;
   modelOptions?: Record<string, unknown>;
   outputSchema?: JsonObject;
+  maxOutputTokens?: number;
+  providerState?: unknown;
   signal?: AbortSignal;
 }
-interface ModelGenerateResult<TOutput = unknown> {
+interface ModelResult<TOutput = unknown> {
   output?: TOutput;
   toolCalls?: ToolCall[];
   usage?: ModelUsage;
+  providerState?: unknown;
+}
+interface ModelMetadata {
+  provider?: string;
+  model?: string;
 }
 interface ModelGateway {
-  generate(input: ModelGenerateInput): Promise<ModelGenerateResult>;
+  stream(input: ModelInput): AsyncIterable<ModelStreamEvent>;
+  metadata?: ModelMetadata;
+  stateCodec?: {
+    serialize(state: unknown): JsonValue;
+    restore(state: JsonValue): unknown;
+  };
 }
+type ModelStreamEvent<TOutput = unknown> = {
+  type: 'output.delta';
+  delta: string;
+} | {
+  type: 'completed';
+  result: ModelResult<TOutput>;
+};
 type ModelRef = string | ModelGateway;
 //#endregion
-export { ModelGateway, ModelGenerateInput, ModelGenerateResult, ModelRef, ModelUsage, ReasoningEffort };
+export { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort };

package/dist/observability/index.d.mts

@@ -0,0 +1,2 @@
+import { a as TraceAnnotation, c as TraceContentPolicy, d as TraceRedactor, f as TraceRedactorInput, h as TraceStatus, i as RunTrace, l as TraceCost, m as TraceSpanKind, n as CostCalculatorInput, o as TraceContent, p as TraceSpan, r as ObservabilityOptions, s as TraceContentKind, t as CostCalculator, u as TraceExporter } from "../index-ojCY3lwm.mjs";
+export { CostCalculator, CostCalculatorInput, ObservabilityOptions, RunTrace, TraceAnnotation, TraceContent, TraceContentKind, TraceContentPolicy, TraceCost, TraceExporter, TraceRedactor, TraceRedactorInput, 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-QTkd6a7C.mjs";
+export { PolicyAuthorization, PolicyDecision, PolicyDefinition, definePolicy };

package/dist/policies/index.mjs

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

package/dist/runtime/index.d.mts

@@ -1,17 +1,2 @@
-import { a as ExecutionContext, t as AgentEvent } from "../index-D_RBJmVt.mjs";
-import { ModelUsage } from "../models/index.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/runtime/index.d.ts
-interface RunRequest<TInput = unknown, TOutput = unknown> {
-  input: TInput;
-  context?: ExecutionContext;
-  outputSchema?: StandardSchemaV1<unknown, TOutput>;
-  signal?: AbortSignal;
-}
-interface RunResult<TOutput = unknown> {
-  output: TOutput;
-  events?: AgentEvent[];
-  usage?: ModelUsage;
-}
-//#endregion
-export { RunRequest, RunResult };
+import { C as isDurableRunStore, S as ToolExecutionStatus, _ as RunStore, a as DurableRunStore, b as ToolExecutionRecord, c as ListEventsOptions, d as RunCheckpoint, f as RunLease, g as RunStatus, h as RunResult, i as CredentialStore, l as PendingToolExecution, m as RunRequest, n as ApprovalRequest, o as ExecutionCommit, p as RunPause, r as ApprovalResolution, s as InMemoryRunStore, t as AgentRun, u as ResumeRunResolution, v as Session, x as ToolExecutionResolution, y as SessionId } from "../index-DGWOGXzc.mjs";
+export { AgentRun, ApprovalRequest, ApprovalResolution, CredentialStore, DurableRunStore, ExecutionCommit, InMemoryRunStore, ListEventsOptions, PendingToolExecution, ResumeRunResolution, RunCheckpoint, RunLease, RunPause, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, isDurableRunStore };

package/dist/runtime/index.mjs

@@ -1 +1,92 @@
-export {};
+//#region src/runtime/index.ts
+function isDurableRunStore(store) {
+	const value = store;
+	return [
+		value.getCheckpoint,
+		value.getToolExecution,
+		value.commitExecution,
+		value.acquireLease,
+		value.renewLease,
+		value.releaseLease
+	].every((method) => typeof method === "function");
+}
+var InMemoryRunStore = class {
+	#runs = /* @__PURE__ */ new Map();
+	#sessions = /* @__PURE__ */ new Map();
+	#events = /* @__PURE__ */ new Map();
+	#checkpoints = /* @__PURE__ */ new Map();
+	#toolExecutions = /* @__PURE__ */ new Map();
+	#leases = /* @__PURE__ */ new Map();
+	async getRun(runId) {
+		const run = this.#runs.get(runId);
+		return run === void 0 ? void 0 : structuredClone(run);
+	}
+	async saveRun(run) {
+		this.#runs.set(run.id, structuredClone(run));
+		if (!this.#events.has(run.id)) this.#events.set(run.id, []);
+	}
+	async getSession(sessionId) {
+		const session = this.#sessions.get(sessionId);
+		return session === void 0 ? void 0 : structuredClone(session);
+	}
+	async saveSession(session) {
+		this.#sessions.set(session.id, structuredClone(session));
+	}
+	async appendEvent(event) {
+		const events = this.#events.get(event.runId);
+		if (!events) throw new Error(`Run "${event.runId}" does not exist`);
+		events.push(structuredClone(event));
+	}
+	async listEvents(runId, options = {}) {
+		const events = this.#events.get(runId);
+		if (!events) throw new Error(`Run "${runId}" does not exist`);
+		let start = 0;
+		if (options.after !== void 0) {
+			const cursor = events.findIndex(({ id }) => id === options.after);
+			if (cursor < 0) throw new Error(`Event cursor "${options.after}" does not exist in run "${runId}"`);
+			start = cursor + 1;
+		}
+		return structuredClone(events.slice(start).sort((a, b) => a.sequence - b.sequence));
+	}
+	async getCheckpoint(runId) {
+		const checkpoint = this.#checkpoints.get(runId);
+		return checkpoint === void 0 ? void 0 : structuredClone(checkpoint);
+	}
+	async getToolExecution(runId, toolCallId) {
+		const execution = this.#toolExecutions.get(`${runId}:${toolCallId}`);
+		return execution === void 0 ? void 0 : structuredClone(execution);
+	}
+	async commitExecution(commit) {
+		const current = this.#runs.get(commit.run.id);
+		if (!current || current.revision !== commit.expectedRevision) return false;
+		const run = structuredClone(commit.run);
+		run.revision = commit.expectedRevision + 1;
+		this.#runs.set(run.id, run);
+		commit.run.revision = run.revision;
+		if (commit.session) this.#sessions.set(commit.session.id, structuredClone(commit.session));
+		if (commit.checkpoint === null) this.#checkpoints.delete(run.id);
+		else if (commit.checkpoint) this.#checkpoints.set(run.id, structuredClone(commit.checkpoint));
+		if (commit.toolExecution) this.#toolExecutions.set(`${run.id}:${commit.toolExecution.toolCallId}`, structuredClone(commit.toolExecution));
+		const events = this.#events.get(run.id);
+		if (!events) throw new Error(`Run "${run.id}" does not exist`);
+		for (const event of commit.events ?? []) events.push(structuredClone(event));
+		return true;
+	}
+	async acquireLease(lease) {
+		const current = this.#leases.get(lease.runId);
+		if (current && current.ownerId !== lease.ownerId && Date.parse(current.expiresAt) > Date.now()) return false;
+		this.#leases.set(lease.runId, structuredClone(lease));
+		return true;
+	}
+	async renewLease(lease) {
+		const current = this.#leases.get(lease.runId);
+		if (!current || current.ownerId !== lease.ownerId) return false;
+		this.#leases.set(lease.runId, structuredClone(lease));
+		return true;
+	}
+	async releaseLease(runId, ownerId) {
+		if (this.#leases.get(runId)?.ownerId === ownerId) this.#leases.delete(runId);
+	}
+};
+//#endregion
+export { InMemoryRunStore, isDurableRunStore };

package/dist/testing/index.d.mts

@@ -1,10 +1,11 @@
-import { d as ToolCall } from "../index-D_RBJmVt.mjs";
-import { ModelGateway, ModelGenerateInput, ModelGenerateResult } from "../models/index.mjs";
+import { m as ToolCall } from "../index-C_Zpr13f.mjs";
+import { ModelGateway, ModelInput, ModelResult } from "../models/index.mjs";
+import { a as DurableRunStore } from "../index-DGWOGXzc.mjs";
 //#region src/testing/index.d.ts
 interface FakeModel extends ModelGateway {
-  readonly calls: readonly ModelGenerateInput[];
+  readonly calls: readonly ModelInput[];
 }
-declare function fakeModel(...responses: ModelGenerateResult[]): FakeModel;
+declare function fakeModel(...responses: ModelResult[]): FakeModel;
 interface ModelGatewayContract {
   output?: unknown;
   toolCall?: ToolCall;
@@ -12,5 +13,6 @@ interface ModelGatewayContract {
   error?: Error;
 }
 declare function testModelGateway(model: ModelGateway, contract?: ModelGatewayContract): Promise<void>;
+declare function testRunStore(store: DurableRunStore): Promise<void>;
 //#endregion
-export { FakeModel, ModelGatewayContract, fakeModel, testModelGateway };
+export { FakeModel, ModelGatewayContract, fakeModel, testModelGateway, testRunStore };