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

package/dist/testing/index.mjs

@@ -1,44 +1,64 @@
+import { t as readModelStream } from "../model-stream-u2xMsEaf.mjs";
 //#region src/testing/index.ts
 function fakeModel(...responses) {
 	const calls = [];
 	return {
 		calls,
-		async generate(input) {
+		async *stream(input) {
 			input.signal?.throwIfAborted();
 			const response = responses[calls.length];
 			calls.push(input);
 			if (!response) throw new Error(`fakeModel has no response for call ${calls.length}`);
-			return response;
+			if (response.output !== void 0) {
+				const delta = typeof response.output === "string" ? response.output : JSON.stringify(response.output);
+				if (delta) yield {
+					type: "output.delta",
+					delta
+				};
+			}
+			yield {
+				type: "completed",
+				result: response
+			};
 		}
 	};
 }
-const contractOutputSchema = { type: "string" };
+const contractOutputSchema = {
+	type: "object",
+	properties: { answer: { type: "string" } },
+	required: ["answer"],
+	additionalProperties: false
+};
 const contractToolInputSchema = {
 	type: "object",
 	properties: { query: { type: "string" } },
-	required: ["query"]
+	required: ["query"],
+	additionalProperties: false
 };
 function assert(condition, message) {
 	if (!condition) throw new TypeError(message);
 }
 async function testModelGateway(model, contract = {}) {
-	const output = contract.output ?? "ok";
+	const output = contract.output ?? { answer: "ok" };
 	const toolCall = contract.toolCall ?? {
 		id: "call-1",
 		name: "lookup",
 		input: { query: "value" }
 	};
-	const outputResult = await model.generate({
+	const outputStream = readModelStream(model, {
 		messages: [{
 			role: "user",
 			content: "Return a final answer."
 		}],
 		outputSchema: contractOutputSchema
 	});
+	const firstOutput = await outputStream.next();
+	assert(!firstOutput.done && firstOutput.value.length > 0, "ModelGateway must stream an output delta before completed");
+	const outputResult = await collectModelResult(outputStream);
 	assert(outputResult.output !== void 0, "ModelGateway must return output for a final answer");
-	assert(outputResult.output === output, "ModelGateway returned an unexpected output");
+	assert(JSON.stringify(outputResult.output) === JSON.stringify(output), "ModelGateway returned an unexpected output");
 	if (contract.usage) assert(outputResult.usage !== void 0, "ModelGateway must return usage when the contract requires it");
-	const toolResult = await model.generate({
+	const toolResult = await collectModelResult(model, {
 		messages: [{
 			role: "user",
 			content: "Call lookup."
@@ -52,9 +72,14 @@ async function testModelGateway(model, contract = {}) {
 	assert(toolResult.toolCalls?.length === 1, "ModelGateway must return one tool call");
 	assert(toolResult.toolCalls[0]?.id === toolCall.id, "ModelGateway returned an unexpected tool call id");
 	assert(toolResult.toolCalls[0]?.name === toolCall.name, "ModelGateway returned an unexpected tool name");
+	if (model.stateCodec && toolResult.providerState !== void 0) {
+		const serialized = model.stateCodec.serialize(toolResult.providerState);
+		const restored = model.stateCodec.restore(structuredClone(serialized));
+		assert(JSON.stringify(model.stateCodec.serialize(restored)) === JSON.stringify(serialized), "ModelGateway stateCodec must preserve provider state across a JSON round-trip");
+	}
 	const controller = new AbortController();
 	controller.abort();
-	await model.generate({
+	await collectModelResult(model, {
 		messages: [{
 			role: "user",
 			content: "This call is aborted."
@@ -63,7 +88,7 @@ async function testModelGateway(model, contract = {}) {
 	}).then(() => {
 		throw new TypeError("ModelGateway must reject aborted calls");
 	}, () => {});
-	if (contract.error) await model.generate({ messages: [{
+	if (contract.error) await collectModelResult(model, { messages: [{
 		role: "user",
 		content: "Propagate an error."
 	}] }).then(() => {
@@ -72,5 +97,141 @@ async function testModelGateway(model, contract = {}) {
 		assert(error === contract.error, "ModelGateway must preserve provider error identity");
 	});
 }
+async function collectModelResult(modelOrStream, input) {
+	const stream = "stream" in modelOrStream ? readModelStream(modelOrStream, input) : modelOrStream;
+	while (true) {
+		const next = await stream.next();
+		if (next.done) return next.value;
+	}
+}
+async function testRunStore(store) {
+	const suffix = crypto.randomUUID();
+	const runId = `contract-run-${suffix}`;
+	const sessionId = `contract-session-${suffix}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const session = {
+		id: sessionId,
+		history: [],
+		createdAt: now,
+		updatedAt: now
+	};
+	const run = {
+		id: runId,
+		sessionId,
+		agentName: "contract-agent",
+		status: "running",
+		revision: 0,
+		createdAt: now,
+		updatedAt: now
+	};
+	await store.saveSession(session);
+	await store.saveRun(run);
+	const snapshot = await store.getRun(runId);
+	assert(snapshot?.status === "running", "RunStore must return saved runs");
+	snapshot.status = "failed";
+	assert((await store.getRun(runId))?.status === "running", "RunStore must not expose mutable run references");
+	const firstEvent = {
+		id: `event-1-${suffix}`,
+		sequence: 1,
+		type: "run.started",
+		runId,
+		timestamp: now
+	};
+	await store.appendEvent(firstEvent);
+	const checkpoint = {
+		runId,
+		definitionHash: "definition",
+		messages: [{
+			role: "user",
+			content: "input"
+		}],
+		inputContent: "input",
+		step: 1,
+		toolCallCount: 0,
+		seenToolCallIds: ["tool-call"],
+		pendingTools: [{
+			call: {
+				id: "tool-call",
+				name: "lookup",
+				input: { query: "value" }
+			},
+			input: { query: "value" },
+			idempotencyKey: `key-${suffix}`,
+			attempt: 1
+		}],
+		pendingIndex: 0
+	};
+	const toolExecution = {
+		runId,
+		toolCallId: "tool-call",
+		toolName: "lookup",
+		input: { query: "value" },
+		status: "completed",
+		attempt: 1,
+		idempotencyKey: `key-${suffix}`,
+		output: { answer: "ok" },
+		updatedAt: now
+	};
+	session.history.push({
+		role: "system",
+		content: "committed"
+	});
+	const secondEvent = {
+		id: `event-2-${suffix}`,
+		sequence: 2,
+		type: "tool.completed",
+		runId,
+		timestamp: now,
+		payload: {
+			step: 1,
+			toolCallId: "tool-call",
+			toolName: "lookup"
+		}
+	};
+	assert(await store.commitExecution({
+		expectedRevision: 0,
+		run,
+		session,
+		checkpoint,
+		toolExecution,
+		events: [secondEvent]
+	}), "RunStore must commit a matching revision");
+	assert(run.revision === 1, "RunStore must advance the committed run revision");
+	assert((await store.getSession(sessionId))?.history.length === 1 && (await store.getCheckpoint(runId))?.definitionHash === "definition" && (await store.getToolExecution(runId, "tool-call"))?.status === "completed", "RunStore atomic commits must include session, checkpoint, and tool ledger");
+	assert(!await store.commitExecution({
+		expectedRevision: 0,
+		run: {
+			...run,
+			status: "failed"
+		},
+		events: [{
+			id: `stale-event-${suffix}`,
+			sequence: 3,
+			type: "run.failed",
+			runId,
+			timestamp: now,
+			payload: { error: "stale" }
+		}]
+	}), "RunStore must reject stale revisions");
+	const events = await store.listEvents(runId, { after: firstEvent.id });
+	assert(events.length === 1 && events[0]?.id === secondEvent.id, "RunStore cursors must return stable ordered suffixes");
+	const lease1 = {
+		runId,
+		ownerId: `owner-1-${suffix}`,
+		expiresAt: new Date(Date.now() + 3e4).toISOString()
+	};
+	const lease2 = {
+		runId,
+		ownerId: `owner-2-${suffix}`,
+		expiresAt: new Date(Date.now() + 3e4).toISOString()
+	};
+	assert(await store.acquireLease(lease1), "RunStore must acquire a free lease");
+	assert(!await store.acquireLease(lease2), "RunStore must reject a competing lease");
+	assert(!await store.renewLease(lease2), "RunStore must reject renewal by another owner");
+	assert(await store.renewLease(lease1), "RunStore must renew a matching lease");
+	await store.releaseLease(runId, lease1.ownerId);
+	assert(await store.acquireLease(lease2), "RunStore must release a lease for another owner");
+	await store.releaseLease(runId, lease2.ownerId);
+}
 //#endregion
-export { fakeModel, testModelGateway };
+export { fakeModel, testModelGateway, testRunStore };

package/dist/tools/index.d.mts

@@ -1,31 +1,3 @@
-import { t as ExactDefinition } from "../exact-definition-NHBBFlFR.mjs";
-import { a as ExecutionContext, c as JsonValue, d as ToolCall, f as ToolSpec, l as RunId, o as JsonObject } from "../index-D_RBJmVt.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/tools/index.d.ts
-interface ToolExecutionContext {
-  runId: RunId;
-  toolCallId: string;
-  context?: ExecutionContext;
-  signal?: AbortSignal;
-}
-interface ToolDefinition<TInput = unknown, TOutput = unknown> {
-  name: string;
-  description?: string;
-  inputSchema?: StandardSchemaV1<unknown, TInput>;
-  outputSchema?: StandardSchemaV1<unknown, TOutput>;
-  execute(input: TInput, context: ToolExecutionContext): TOutput | Promise<TOutput>;
-}
-type ToolWithSchemas<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1> = Omit<ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, StandardSchemaV1.InferOutput<TOutputSchema>>, 'inputSchema' | 'outputSchema'> & {
-  inputSchema: TInputSchema;
-  outputSchema: TOutputSchema;
-};
-type ToolWithInputSchema<TInputSchema extends StandardSchemaV1> = Omit<ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, unknown>, 'inputSchema'> & {
-  inputSchema: TInputSchema;
-};
-declare function defineTool<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TDefinition extends ToolWithSchemas<TInputSchema, TOutputSchema>>(tool: ToolWithSchemas<TInputSchema, TOutputSchema> & ExactDefinition<TDefinition, ToolWithSchemas<TInputSchema, TOutputSchema>>): TDefinition;
-declare function defineTool<TInputSchema extends StandardSchemaV1, TDefinition extends ToolWithInputSchema<TInputSchema>>(tool: ToolWithInputSchema<TInputSchema> & ExactDefinition<TDefinition, ToolWithInputSchema<TInputSchema>>): TDefinition;
-declare function defineTool<TDefinition extends ToolDefinition>(tool: ToolDefinition & ExactDefinition<TDefinition, ToolDefinition>): TDefinition;
-declare function toToolSpec(tool: ToolDefinition, inputSchema?: JsonObject): ToolSpec;
-type ToolResult = JsonValue;
-//#endregion
-export { type ToolCall, ToolDefinition, ToolExecutionContext, ToolResult, type ToolSpec, defineTool, toToolSpec };
+import { h as ToolSpec, m as ToolCall } from "../index-C_Zpr13f.mjs";
+import { a as ToolResult, c as defineTool, i as ToolIdempotency, l as toToolSpec, n as ToolDefinition, o as ToolRetryPolicy, r as ToolExecutionContext, s as ToolRisk, t as ToolApproval } from "../index-CZGyhNIQ.mjs";
+export { ToolApproval, type ToolCall, ToolDefinition, ToolExecutionContext, ToolIdempotency, ToolResult, ToolRetryPolicy, ToolRisk, type ToolSpec, defineTool, toToolSpec };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fevex/core",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.1",
   "description": "Agent Engineering Framework for code-first, provider-neutral AI agents.",
   "type": "module",
   "license": "Apache-2.0",
@@ -43,15 +43,27 @@
       "types": "./dist/runtime/index.d.mts",
       "import": "./dist/runtime/index.mjs"
     },
+    "./policies": {
+      "types": "./dist/policies/index.d.mts",
+      "import": "./dist/policies/index.mjs"
+    },
+    "./observability": {
+      "types": "./dist/observability/index.d.mts",
+      "import": "./dist/observability/index.mjs"
+    },
+    "./evals": {
+      "types": "./dist/evals/index.d.mts",
+      "import": "./dist/evals/index.mjs"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.mts",
       "import": "./dist/testing/index.mjs"
     }
   },
   "scripts": {
-    "build": "tsdown src/index.ts src/agents/index.ts src/models/index.ts src/tools/index.ts src/runtime/index.ts src/testing/index.ts --format esm --dts",
+    "build": "tsdown src/index.ts src/agents/index.ts src/models/index.ts src/tools/index.ts src/runtime/index.ts src/policies/index.ts src/observability/index.ts src/evals/index.ts src/testing/index.ts --format esm --dts --clean",
     "prepack": "bun run build",
-    "test": "bun test src/index.test.ts src/testing/index.test.ts",
+    "test": "bun test src/index.test.ts src/internal/json.test.ts src/internal/model-stream.test.ts src/observability/index.test.ts src/evals/index.test.ts src/testing/index.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "publishConfig": {

package/dist/index-D_RBJmVt.d.mts

@@ -1,44 +0,0 @@
-//#region src/core/index.d.ts
-type JsonPrimitive = string | number | boolean | null;
-type JsonObject = {
-  [key: string]: JsonValue;
-};
-type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
-type RunId = string;
-declare const SCHEMA_NOT_TRANSPORTABLE = "SCHEMA_NOT_TRANSPORTABLE";
-interface ExecutionContext {
-  namespace?: string;
-  actor?: {
-    id: string;
-    type?: string;
-  };
-  attributes?: JsonObject;
-  prompt?: JsonObject;
-}
-type AgentMessageRole = 'system' | 'user' | 'assistant' | 'tool';
-interface AgentMessage {
-  role: AgentMessageRole;
-  content: string;
-  name?: string;
-  toolCallId?: string;
-  toolCalls?: ToolCall[];
-}
-interface ToolSpec {
-  name: string;
-  description?: string;
-  inputSchema?: JsonObject;
-}
-interface ToolCall {
-  id: string;
-  name: string;
-  input: JsonValue;
-}
-type AgentEventType = 'run.started' | 'model.completed' | 'tool.completed' | 'tool.failed' | 'run.completed' | 'run.failed';
-interface AgentEvent<TPayload extends JsonValue = JsonObject> {
-  type: AgentEventType;
-  runId: RunId;
-  timestamp: string;
-  payload?: TPayload;
-}
-//#endregion
-export { ExecutionContext as a, JsonValue as c, ToolCall as d, ToolSpec as f, AgentMessageRole as i, RunId as l, AgentEventType as n, JsonObject as o, AgentMessage as r, JsonPrimitive as s, AgentEvent as t, SCHEMA_NOT_TRANSPORTABLE as u };