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

package/dist/agents/index.d.mts

@@ -1,23 +1,2 @@
-import { t as ExactDefinition } from "../exact-definition-NHBBFlFR.mjs";
-import { ModelRef, ReasoningEffort } from "../models/index.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/agents/index.d.ts
-interface AgentLimits {
-  maxSteps?: number;
-  maxToolCalls?: number;
-  maxInputTokens?: number | false;
-  maxOutputTokens?: number | false;
-}
-interface AgentDefinition<TOutput = unknown> {
-  name: string;
-  instructions: string;
-  model?: ModelRef;
-  tools?: string[];
-  reasoning?: ReasoningEffort;
-  modelOptions?: Record<string, unknown>;
-  outputSchema?: StandardSchemaV1<unknown, TOutput>;
-  limits?: AgentLimits;
-}
-declare function defineAgent<T extends AgentDefinition>(agent: ExactDefinition<T, AgentDefinition>): T;
-//#endregion
+import { n as AgentLimits, r as defineAgent, t as AgentDefinition } from "../index-Dx_LotWZ.mjs";
 export { AgentDefinition, AgentLimits, defineAgent };

package/dist/agents/index.mjs

@@ -1,4 +1,4 @@
-//#region src/agents/index.ts
+//#region src/agents/agent.ts
 function defineAgent(agent) {
 	return agent;
 }

package/dist/channels/index.d.mts

@@ -0,0 +1,2 @@
+import { a as ChannelEvent, c as ChannelMessage, d as ChannelRunOptions, f as ChannelRunResult, i as ChannelError, l as ChannelOutput, n as ChannelAdapter, o as ChannelEventType, r as ChannelContext, s as ChannelFailurePhase, t as handleChannelInput, u as ChannelRunEvent } from "../index-Bgcxgy66.mjs";
+export { ChannelAdapter, ChannelContext, ChannelError, ChannelEvent, ChannelEventType, ChannelFailurePhase, ChannelMessage, ChannelOutput, ChannelRunEvent, ChannelRunOptions, ChannelRunResult, handleChannelInput };

package/dist/channels/index.mjs

@@ -0,0 +1,150 @@
+//#region src/channels/channel.ts
+var ChannelError = class extends Error {
+	code;
+	safeMessage;
+	name = "ChannelError";
+	constructor(code, safeMessage, options) {
+		super(safeMessage, options);
+		this.code = code;
+		this.safeMessage = safeMessage;
+	}
+};
+//#endregion
+//#region src/channels/handle-channel-input.ts
+/** Parses one channel input, runs the configured agent, and delivers its output. */
+async function handleChannelInput(input, options) {
+	const channelEvents = [];
+	const emit = (event) => {
+		channelEvents.push(event);
+		options.onEvent?.(event);
+	};
+	let parsed;
+	try {
+		parsed = await options.adapter.parse(input, { signal: options.signal });
+	} catch (cause) {
+		const error = channelError("CHANNEL_PARSE_FAILED", "Channel parse failed", cause);
+		emit(failed(options.adapter.name, "parse", error));
+		throw error;
+	}
+	if (parsed === null) return {
+		ignored: true,
+		events: []
+	};
+	const message = parsed;
+	emit(received(options.adapter.name, message));
+	let result;
+	try {
+		const sessionId = await options.resolveSessionId?.(message);
+		result = await options.fevex.runAgent(options.agentName, {
+			input: message.content,
+			...sessionId ? { sessionId } : {},
+			context: channelContext(options.adapter.name, message),
+			signal: options.signal
+		});
+	} catch (cause) {
+		const error = channelError("CHANNEL_RUN_FAILED", "Channel run failed", cause);
+		emit(failed(options.adapter.name, "run", error, message));
+		throw error;
+	}
+	const run = await options.fevex.getRun(result.runId);
+	if (!run || run.kind === "workflow" || run.kind === "team") {
+		const error = channelError("CHANNEL_RUN_FAILED", "Channel run was not found after completion");
+		emit(failed(options.adapter.name, "run", error, message));
+		throw error;
+	}
+	const output = {
+		deliveryId: message.deliveryId,
+		conversationId: message.conversationId,
+		...message.threadId ? { threadId: message.threadId } : {},
+		content: stringifyOutput(result.output),
+		metadata: {
+			runId: result.runId,
+			sessionId: result.sessionId
+		}
+	};
+	let delivery;
+	try {
+		delivery = await options.adapter.deliver(output, { signal: options.signal });
+	} catch (cause) {
+		const error = channelError("CHANNEL_DELIVERY_FAILED", "Channel delivery failed", cause);
+		emit(failed(options.adapter.name, "deliver", error, message));
+		throw error;
+	}
+	const deliveredEvent = delivered(options.adapter.name, message);
+	emit(deliveredEvent);
+	return {
+		ignored: false,
+		message,
+		run,
+		output,
+		delivery,
+		events: [
+			channelEvents[0],
+			...result.events ?? [],
+			deliveredEvent
+		]
+	};
+}
+function channelContext(adapter, message) {
+	return {
+		namespace: adapter,
+		...message.actor ? { actor: message.actor } : {},
+		attributes: {
+			...message.metadata ?? {},
+			channel: adapter,
+			messageId: message.id,
+			deliveryId: message.deliveryId,
+			conversationId: message.conversationId,
+			...message.threadId ? { threadId: message.threadId } : {}
+		}
+	};
+}
+function received(adapter, message) {
+	return {
+		type: "channel.received",
+		id: crypto.randomUUID(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		adapter,
+		messageId: message.id,
+		deliveryId: message.deliveryId,
+		conversationId: message.conversationId,
+		...message.threadId ? { threadId: message.threadId } : {},
+		...message.actor ? { actor: message.actor } : {}
+	};
+}
+function delivered(adapter, message) {
+	return {
+		type: "channel.delivered",
+		id: crypto.randomUUID(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		adapter,
+		messageId: message.id,
+		deliveryId: message.deliveryId,
+		conversationId: message.conversationId,
+		...message.threadId ? { threadId: message.threadId } : {}
+	};
+}
+function failed(adapter, phase, error, message) {
+	return {
+		type: "channel.failed",
+		id: crypto.randomUUID(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		adapter,
+		phase,
+		error: error.safeMessage,
+		...message ? {
+			messageId: message.id,
+			deliveryId: message.deliveryId,
+			conversationId: message.conversationId,
+			...message.threadId ? { threadId: message.threadId } : {}
+		} : {}
+	};
+}
+function channelError(code, safeMessage, cause) {
+	return new ChannelError(code, safeMessage, cause === void 0 ? void 0 : { cause });
+}
+function stringifyOutput(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+//#endregion
+export { ChannelError, handleChannelInput };

package/dist/evals/index.d.mts

@@ -0,0 +1,153 @@
+import { l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-CuoRx12Q.mjs";
+import { r as ModelMetadata, s as ModelUsage } from "../index-CTIwrVf9.mjs";
+import { l as TraceCost, t as CostCalculator } from "../index-B4PIkqOU.mjs";
+import { t as Fevex } from "../fevex-Ddyi6z6L.mjs";
+//#region src/evals/canonical-json.d.ts
+/** Serializes JSON-like data with stable object-key ordering. */
+declare function serializeCanonical(value: unknown): string;
+//#endregion
+//#region src/evals/types.d.ts
+interface EvalExpectation {
+  output?: JsonValue;
+  tools?: string[];
+}
+interface EvalCase<TInput = unknown> {
+  id: string;
+  input: TInput;
+  expected?: EvalExpectation;
+  context?: ExecutionContext;
+}
+interface EvalDataset<TInput = unknown> {
+  name: string;
+  version: string;
+  cases: readonly EvalCase<TInput>[];
+}
+interface EvalScorerContext<TInput = unknown> {
+  testCase: EvalCase<TInput>;
+  output?: JsonValue;
+  tools: readonly string[];
+  events: readonly AgentEvent[];
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  latencyMs: number;
+  error?: string;
+}
+type EvalScorerResult = {
+  passed: boolean;
+  score: number;
+  details?: JsonValue;
+} | {
+  skipped: true;
+  reason?: string;
+};
+interface EvalScorer<TInput = unknown> {
+  id: string;
+  score(context: EvalScorerContext<TInput>): EvalScorerResult | Promise<EvalScorerResult>;
+}
+type EvalScoreStatus = 'passed' | 'failed' | 'skipped' | 'error';
+interface EvalScore {
+  scorerId: string;
+  status: EvalScoreStatus;
+  score?: number;
+  details?: JsonValue;
+  error?: string;
+}
+interface EvalCaseReport {
+  caseId: string;
+  status: 'completed' | 'failed';
+  output?: JsonValue;
+  tools: string[];
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  latencyMs: number;
+  scores: EvalScore[];
+  error?: string;
+}
+interface EvalSummary {
+  caseCount: number;
+  completedCount: number;
+  failedCount: number;
+  passedScoreCount: number;
+  failedScoreCount: number;
+  skippedScoreCount: number;
+  errorScoreCount: number;
+  averageScore?: number;
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  latencyMs: number;
+}
+interface EvalReport {
+  schemaVersion: 'fevex.eval.v1';
+  suiteName: string;
+  targetVersion: string;
+  agentName: string;
+  dataset: {
+    name: string;
+    version: string;
+  };
+  scorerIds: string[];
+  cases: EvalCaseReport[];
+  summary: EvalSummary;
+}
+interface EvalReporter {
+  report(report: Readonly<EvalReport>): void | Promise<void>;
+}
+interface EvalCostOptions {
+  calculate: CostCalculator;
+  modelRegistryName: string;
+  model?: ModelMetadata;
+}
+interface RunEvaluationOptions<TInput = unknown> {
+  app: Fevex;
+  suiteName: string;
+  targetVersion: string;
+  agentName: string;
+  dataset: EvalDataset<TInput>;
+  scorers: readonly EvalScorer<TInput>[];
+  reporters?: readonly EvalReporter[];
+  cost?: EvalCostOptions;
+  signal?: AbortSignal;
+}
+interface Regression {
+  kind: 'case_removed' | 'case_failed' | 'scorer_removed' | 'score_failed' | 'score_dropped' | 'latency_increased' | 'cost_increased';
+  caseId: string;
+  scorerId?: string;
+  message: string;
+}
+interface RegressionReport {
+  passed: boolean;
+  baselineTargetVersion: string;
+  currentTargetVersion: string;
+  regressions: Regression[];
+}
+interface RegressionOptions {
+  maxScoreDrop?: number;
+  maxLatencyIncreaseRatio?: number;
+  maxCostIncreaseRatio?: number;
+}
+//#endregion
+//#region src/evals/evaluation.d.ts
+/** Runs every case and scorer, producing a deterministic aggregate report. */
+declare function runEvaluation<TInput = unknown>(options: RunEvaluationOptions<TInput>): Promise<EvalReport>;
+declare function serializeEvalReport(report: EvalReport): string;
+declare function parseEvalReport(json: string): EvalReport;
+declare function jsonReporter(write: (output: string) => void | Promise<void>): EvalReporter;
+declare function textReporter(write: (output: string) => void | Promise<void>): EvalReporter;
+declare function compareEvaluationReports(baseline: EvalReport, current: EvalReport, options?: RegressionOptions): RegressionReport;
+//#endregion
+//#region src/evals/scorers.d.ts
+declare function exactOutputScorer(id?: string): EvalScorer;
+declare function toolSelectionScorer(options?: {
+  id?: string;
+  ordered?: boolean;
+}): EvalScorer;
+declare function forbiddenToolsScorer(tools: readonly string[], id?: string): EvalScorer;
+declare function maxLatencyScorer(maxMs: number, id?: string): EvalScorer;
+declare function maxTokensScorer(limits: {
+  input?: number;
+  output?: number;
+  total?: number;
+}, id?: string): EvalScorer;
+declare function maxCostScorer(maxAmount: number, currency: string, id?: string): EvalScorer;
+//#endregion
+export { EvalCase, EvalCaseReport, EvalCostOptions, EvalDataset, EvalExpectation, EvalReport, EvalReporter, EvalScore, EvalScoreStatus, EvalScorer, EvalScorerContext, EvalScorerResult, EvalSummary, Regression, RegressionOptions, RegressionReport, RunEvaluationOptions, compareEvaluationReports, exactOutputScorer, forbiddenToolsScorer, jsonReporter, maxCostScorer, maxLatencyScorer, maxTokensScorer, parseEvalReport, runEvaluation, serializeCanonical, serializeEvalReport, textReporter, toolSelectionScorer };