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

package/dist/evals/index.mjs

@@ -0,0 +1,419 @@
+//#region src/evals/index.ts
+function assertNonEmpty(value, name) {
+	if (typeof value !== "string" || !value.trim()) throw new TypeError(`${name} must be non-empty`);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function equalJson(left, right) {
+	return serializeCanonical(left) === serializeCanonical(right);
+}
+function addUsage(target, usage) {
+	if (!usage) return;
+	for (const key of [
+		"inputTokens",
+		"outputTokens",
+		"totalTokens"
+	]) if (usage[key] !== void 0) target[key] = (target[key] ?? 0) + usage[key];
+}
+function usageFromEvent(event) {
+	if (event.type !== "run.completed" || !event.payload.usage) return void 0;
+	const usage = {};
+	for (const key of [
+		"inputTokens",
+		"outputTokens",
+		"totalTokens"
+	]) {
+		const value = event.payload.usage[key];
+		if (typeof value === "number") usage[key] = value;
+	}
+	return Object.keys(usage).length ? usage : void 0;
+}
+function validateOptions(options) {
+	assertNonEmpty(options.suiteName, "suiteName");
+	assertNonEmpty(options.targetVersion, "targetVersion");
+	assertNonEmpty(options.agentName, "agentName");
+	assertNonEmpty(options.dataset.name, "dataset.name");
+	assertNonEmpty(options.dataset.version, "dataset.version");
+	if (!Array.isArray(options.dataset.cases) || !options.dataset.cases.length) throw new TypeError("dataset.cases must contain at least one case");
+	const caseIds = /* @__PURE__ */ new Set();
+	for (const testCase of options.dataset.cases) {
+		assertNonEmpty(testCase.id, "case.id");
+		if (caseIds.has(testCase.id)) throw new TypeError(`Eval case "${testCase.id}" is duplicated`);
+		caseIds.add(testCase.id);
+	}
+	if (!Array.isArray(options.scorers) || !options.scorers.length) throw new TypeError("scorers must contain at least one scorer");
+	const scorerIds = /* @__PURE__ */ new Set();
+	for (const scorer of options.scorers) {
+		assertNonEmpty(scorer.id, "scorer.id");
+		if (typeof scorer.score !== "function") throw new TypeError(`Eval scorer "${scorer.id}" must implement score`);
+		if (scorerIds.has(scorer.id)) throw new TypeError(`Eval scorer "${scorer.id}" is duplicated`);
+		scorerIds.add(scorer.id);
+	}
+	if (options.reporters !== void 0 && (!Array.isArray(options.reporters) || options.reporters.some((reporter) => typeof reporter.report !== "function"))) throw new TypeError("reporters must implement report");
+}
+async function evaluateCase(options, testCase) {
+	options.signal?.throwIfAborted();
+	const startedAt = performance.now();
+	const events = [];
+	let executionError;
+	try {
+		for await (const event of options.app.streamAgent(options.agentName, {
+			input: testCase.input,
+			context: testCase.context,
+			signal: options.signal
+		})) events.push(event);
+	} catch (error) {
+		if (options.signal?.aborted) throw error;
+		executionError = errorMessage(error);
+	}
+	const latencyMs = performance.now() - startedAt;
+	const completed = events.find((event) => event.type === "run.completed");
+	const failed = [...events].reverse().find((event) => event.type === "run.failed" || event.type === "run.cancelled");
+	const output = completed?.type === "run.completed" ? completed.payload.output : void 0;
+	const usage = completed ? usageFromEvent(completed) : void 0;
+	const selectedTools = [];
+	const selectedIds = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		if (event.type !== "tool.started" || selectedIds.has(event.payload.toolCallId)) continue;
+		selectedIds.add(event.payload.toolCallId);
+		selectedTools.push(event.payload.toolName);
+	}
+	const cost = options.cost && usage ? options.cost.calculate({
+		modelRegistryName: options.cost.modelRegistryName,
+		model: options.cost.model,
+		usage
+	}) : void 0;
+	if (cost && (!Number.isFinite(cost.amount) || cost.amount < 0 || !cost.currency.trim())) throw new TypeError("CostCalculator must return a non-negative amount and currency");
+	const runError = executionError ?? (failed?.type === "run.failed" ? failed.payload.error : failed?.type === "run.cancelled" ? failed.payload.reason : completed ? void 0 : "Run did not complete");
+	const context = {
+		testCase,
+		output,
+		tools: selectedTools,
+		events,
+		usage,
+		cost,
+		latencyMs,
+		error: runError
+	};
+	const scores = [];
+	for (const scorer of options.scorers) try {
+		const result = await scorer.score(context);
+		if ("skipped" in result) scores.push({
+			scorerId: scorer.id,
+			status: "skipped",
+			...result.reason ? { details: result.reason } : {}
+		});
+		else {
+			if (!Number.isFinite(result.score) || result.score < 0 || result.score > 1) throw new TypeError("score must be between 0 and 1");
+			scores.push({
+				scorerId: scorer.id,
+				status: result.passed ? "passed" : "failed",
+				score: result.score,
+				...result.details === void 0 ? {} : { details: result.details }
+			});
+		}
+	} catch (error) {
+		scores.push({
+			scorerId: scorer.id,
+			status: "error",
+			error: errorMessage(error)
+		});
+	}
+	return {
+		caseId: testCase.id,
+		status: completed ? "completed" : "failed",
+		...output === void 0 ? {} : { output },
+		tools: selectedTools,
+		...usage ? { usage } : {},
+		...cost ? { cost } : {},
+		latencyMs,
+		scores,
+		...runError ? { error: runError } : {}
+	};
+}
+function summarize(cases) {
+	const scores = cases.flatMap((testCase) => testCase.scores);
+	const numericScores = scores.flatMap((score) => score.score === void 0 ? [] : [score.score]);
+	const usage = {};
+	for (const testCase of cases) addUsage(usage, testCase.usage);
+	const costs = cases.flatMap((testCase) => testCase.cost ? [testCase.cost] : []);
+	const currencies = new Set(costs.map(({ currency }) => currency));
+	const totalCost = costs.length && currencies.size === 1 ? {
+		amount: costs.reduce((sum, cost) => sum + cost.amount, 0),
+		currency: costs[0].currency
+	} : void 0;
+	return {
+		caseCount: cases.length,
+		completedCount: cases.filter(({ status }) => status === "completed").length,
+		failedCount: cases.filter(({ status }) => status === "failed").length,
+		passedScoreCount: scores.filter(({ status }) => status === "passed").length,
+		failedScoreCount: scores.filter(({ status }) => status === "failed").length,
+		skippedScoreCount: scores.filter(({ status }) => status === "skipped").length,
+		errorScoreCount: scores.filter(({ status }) => status === "error").length,
+		...numericScores.length ? { averageScore: numericScores.reduce((sum, score) => sum + score, 0) / numericScores.length } : {},
+		...Object.keys(usage).length ? { usage } : {},
+		...totalCost ? { cost: totalCost } : {},
+		latencyMs: cases.reduce((sum, testCase) => sum + testCase.latencyMs, 0)
+	};
+}
+async function runEvaluation(options) {
+	validateOptions(options);
+	const cases = [];
+	for (const testCase of options.dataset.cases) cases.push(await evaluateCase(options, testCase));
+	const report = {
+		schemaVersion: "fevex.eval.v1",
+		suiteName: options.suiteName,
+		targetVersion: options.targetVersion,
+		agentName: options.agentName,
+		dataset: {
+			name: options.dataset.name,
+			version: options.dataset.version
+		},
+		scorerIds: options.scorers.map(({ id }) => id),
+		cases,
+		summary: summarize(cases)
+	};
+	for (const reporter of options.reporters ?? []) await reporter.report(report);
+	return report;
+}
+function exactOutputScorer(id = "output.exact") {
+	return {
+		id,
+		score({ testCase, output }) {
+			if (testCase.expected?.output === void 0) return {
+				skipped: true,
+				reason: "No expected output"
+			};
+			const passed = equalJson(output, testCase.expected.output);
+			return {
+				passed,
+				score: passed ? 1 : 0
+			};
+		}
+	};
+}
+function toolSelectionScorer(options = {}) {
+	return {
+		id: options.id ?? "tools.selected",
+		score({ testCase, tools }) {
+			const expected = testCase.expected?.tools;
+			if (!expected) return {
+				skipped: true,
+				reason: "No expected tools"
+			};
+			const passed = options.ordered === false ? [...tools].sort().join("\0") === [...expected].sort().join("\0") : tools.join("\0") === expected.join("\0");
+			return {
+				passed,
+				score: passed ? 1 : 0
+			};
+		}
+	};
+}
+function forbiddenToolsScorer(tools, id = "tools.forbidden") {
+	const forbidden = new Set(tools);
+	return {
+		id,
+		score(context) {
+			const selected = context.tools.filter((tool) => forbidden.has(tool));
+			return {
+				passed: selected.length === 0,
+				score: selected.length ? 0 : 1,
+				...selected.length ? { details: { selected } } : {}
+			};
+		}
+	};
+}
+function maxLatencyScorer(maxMs, id = "latency.max") {
+	if (!Number.isFinite(maxMs) || maxMs < 0) throw new TypeError("maxMs must be non-negative");
+	return {
+		id,
+		score({ latencyMs }) {
+			return {
+				passed: latencyMs <= maxMs,
+				score: latencyMs <= maxMs ? 1 : 0,
+				details: {
+					actualMs: latencyMs,
+					maxMs
+				}
+			};
+		}
+	};
+}
+function maxTokensScorer(limits, id = "tokens.max") {
+	for (const [name, value] of Object.entries(limits)) if (!Number.isFinite(value) || value < 0) throw new TypeError(`${name} token limit is invalid`);
+	return {
+		id,
+		score({ usage }) {
+			if (!usage) return {
+				passed: false,
+				score: 0,
+				details: "Model usage is unavailable"
+			};
+			const passed = (limits.input === void 0 || (usage.inputTokens ?? Infinity) <= limits.input) && (limits.output === void 0 || (usage.outputTokens ?? Infinity) <= limits.output) && (limits.total === void 0 || (usage.totalTokens ?? Infinity) <= limits.total);
+			return {
+				passed,
+				score: passed ? 1 : 0,
+				details: {
+					usage: {
+						...usage.inputTokens === void 0 ? {} : { inputTokens: usage.inputTokens },
+						...usage.outputTokens === void 0 ? {} : { outputTokens: usage.outputTokens },
+						...usage.totalTokens === void 0 ? {} : { totalTokens: usage.totalTokens }
+					},
+					limits: {
+						...limits.input === void 0 ? {} : { input: limits.input },
+						...limits.output === void 0 ? {} : { output: limits.output },
+						...limits.total === void 0 ? {} : { total: limits.total }
+					}
+				}
+			};
+		}
+	};
+}
+function maxCostScorer(maxAmount, currency, id = "cost.max") {
+	if (!Number.isFinite(maxAmount) || maxAmount < 0) throw new TypeError("maxAmount must be non-negative");
+	assertNonEmpty(currency, "currency");
+	return {
+		id,
+		score({ cost }) {
+			if (!cost) return {
+				passed: false,
+				score: 0,
+				details: "Cost is unavailable"
+			};
+			const passed = cost.currency === currency && cost.amount <= maxAmount;
+			return {
+				passed,
+				score: passed ? 1 : 0,
+				details: {
+					actual: {
+						amount: cost.amount,
+						currency: cost.currency
+					},
+					maximum: {
+						amount: maxAmount,
+						currency
+					}
+				}
+			};
+		}
+	};
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (value === null || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
+}
+function serializeCanonical(value) {
+	return JSON.stringify(canonicalize(value), null, 2);
+}
+function serializeEvalReport(report) {
+	return `${serializeCanonical(report)}\n`;
+}
+function parseEvalReport(json) {
+	const value = JSON.parse(json);
+	if (typeof value !== "object" || value === null || value.schemaVersion !== "fevex.eval.v1" || typeof value.suiteName !== "string" || typeof value.targetVersion !== "string" || typeof value.agentName !== "string" || typeof value.dataset !== "object" || value.dataset === null || typeof value.dataset.name !== "string" || typeof value.dataset.version !== "string" || !Array.isArray(value.cases) || !Array.isArray(value.scorerIds) || !value.scorerIds.every((scorerId) => typeof scorerId === "string" && Boolean(scorerId)) || typeof value.summary !== "object" || value.summary === null) throw new TypeError("Invalid fevex.eval.v1 report");
+	const report = value;
+	const caseIds = /* @__PURE__ */ new Set();
+	for (const testCase of report.cases) {
+		if (typeof testCase !== "object" || testCase === null || typeof testCase.caseId !== "string" || !testCase.caseId || caseIds.has(testCase.caseId) || !["completed", "failed"].includes(testCase.status) || !Array.isArray(testCase.tools) || !testCase.tools.every((tool) => typeof tool === "string") || !Number.isFinite(testCase.latencyMs) || testCase.latencyMs < 0 || !Array.isArray(testCase.scores)) throw new TypeError("Invalid fevex.eval.v1 report");
+		caseIds.add(testCase.caseId);
+		for (const score of testCase.scores) if (typeof score !== "object" || score === null || typeof score.scorerId !== "string" || !report.scorerIds.includes(score.scorerId) || ![
+			"passed",
+			"failed",
+			"skipped",
+			"error"
+		].includes(score.status) || score.score !== void 0 && (!Number.isFinite(score.score) || score.score < 0 || score.score > 1)) throw new TypeError("Invalid fevex.eval.v1 report");
+	}
+	return value;
+}
+function jsonReporter(write) {
+	return { report: (report) => write(serializeEvalReport(report)) };
+}
+function textReporter(write) {
+	return { report(report) {
+		return write(`${[
+			`${report.suiteName} (${report.targetVersion})`,
+			`dataset ${report.dataset.name}@${report.dataset.version}`,
+			...report.cases.map((testCase) => {
+				const passed = testCase.scores.filter(({ status }) => status === "passed").length;
+				const failed = testCase.scores.filter(({ status }) => status === "failed" || status === "error").length;
+				return `${testCase.caseId}: ${testCase.status}; ${passed} passed, ${failed} failed`;
+			}),
+			`summary: ${report.summary.completedCount}/${report.summary.caseCount} completed; ${report.summary.failedScoreCount + report.summary.errorScoreCount} failed scores`
+		].join("\n")}\n`);
+	} };
+}
+function assertRatio(value, name) {
+	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new TypeError(`${name} must be non-negative`);
+}
+function compareEvaluationReports(baseline, current, options = {}) {
+	if (baseline.suiteName !== current.suiteName || baseline.dataset.name !== current.dataset.name || baseline.dataset.version !== current.dataset.version) throw new TypeError("Evaluation reports must use the same suite and dataset version");
+	assertRatio(options.maxScoreDrop, "maxScoreDrop");
+	assertRatio(options.maxLatencyIncreaseRatio, "maxLatencyIncreaseRatio");
+	assertRatio(options.maxCostIncreaseRatio, "maxCostIncreaseRatio");
+	const maxScoreDrop = options.maxScoreDrop ?? 0;
+	const regressions = [];
+	const currentCases = new Map(current.cases.map((testCase) => [testCase.caseId, testCase]));
+	for (const baselineCase of baseline.cases) {
+		const currentCase = currentCases.get(baselineCase.caseId);
+		if (!currentCase) {
+			regressions.push({
+				kind: "case_removed",
+				caseId: baselineCase.caseId,
+				message: `Case "${baselineCase.caseId}" was removed`
+			});
+			continue;
+		}
+		if (baselineCase.status === "completed" && currentCase.status === "failed") regressions.push({
+			kind: "case_failed",
+			caseId: baselineCase.caseId,
+			message: `Case "${baselineCase.caseId}" no longer completes`
+		});
+		const currentScores = new Map(currentCase.scores.map((score) => [score.scorerId, score]));
+		for (const baselineScore of baselineCase.scores) {
+			const currentScore = currentScores.get(baselineScore.scorerId);
+			if (!currentScore) {
+				regressions.push({
+					kind: "scorer_removed",
+					caseId: baselineCase.caseId,
+					scorerId: baselineScore.scorerId,
+					message: `Scorer "${baselineScore.scorerId}" was removed from "${baselineCase.caseId}"`
+				});
+				continue;
+			}
+			if (baselineScore.status === "passed" && currentScore.status !== "passed") regressions.push({
+				kind: "score_failed",
+				caseId: baselineCase.caseId,
+				scorerId: baselineScore.scorerId,
+				message: `Scorer "${baselineScore.scorerId}" changed from pass to fail`
+			});
+			else if (baselineScore.score !== void 0 && currentScore.score !== void 0 && baselineScore.score - currentScore.score > maxScoreDrop) regressions.push({
+				kind: "score_dropped",
+				caseId: baselineCase.caseId,
+				scorerId: baselineScore.scorerId,
+				message: `Scorer "${baselineScore.scorerId}" dropped from ${baselineScore.score} to ${currentScore.score}`
+			});
+		}
+		if (options.maxLatencyIncreaseRatio !== void 0 && baselineCase.latencyMs > 0 && currentCase.latencyMs / baselineCase.latencyMs - 1 > options.maxLatencyIncreaseRatio) regressions.push({
+			kind: "latency_increased",
+			caseId: baselineCase.caseId,
+			message: `Latency increased from ${baselineCase.latencyMs}ms to ${currentCase.latencyMs}ms`
+		});
+		if (options.maxCostIncreaseRatio !== void 0 && baselineCase.cost && currentCase.cost) {
+			if (baselineCase.cost.currency !== currentCase.cost.currency || baselineCase.cost.amount > 0 && currentCase.cost.amount / baselineCase.cost.amount - 1 > options.maxCostIncreaseRatio) regressions.push({
+				kind: "cost_increased",
+				caseId: baselineCase.caseId,
+				message: `Cost changed from ${baselineCase.cost.amount} ${baselineCase.cost.currency} to ${currentCase.cost.amount} ${currentCase.cost.currency}`
+			});
+		}
+	}
+	return {
+		passed: regressions.length === 0,
+		baselineTargetVersion: baseline.targetVersion,
+		currentTargetVersion: current.targetVersion,
+		regressions
+	};
+}
+//#endregion
+export { compareEvaluationReports, exactOutputScorer, forbiddenToolsScorer, jsonReporter, maxCostScorer, maxLatencyScorer, maxTokensScorer, parseEvalReport, runEvaluation, serializeCanonical, serializeEvalReport, textReporter, toolSelectionScorer };

package/dist/fevex-Dz6GBz9o.d.mts

@@ -0,0 +1,32 @@
+import { f as RunId, t as AgentEvent } from "./index-C_Zpr13f.mjs";
+import { ModelGateway } from "./models/index.mjs";
+import { t as AgentDefinition } from "./index-BzxHfyYV.mjs";
+import { _ as RunStore, c as ListEventsOptions, h as RunResult, i as CredentialStore, m as RunRequest, t as AgentRun, u as ResumeRunResolution, v as Session, y as SessionId } from "./index-DGWOGXzc.mjs";
+import { r as ObservabilityOptions } from "./index-ojCY3lwm.mjs";
+import { n as ToolDefinition } from "./index-CZGyhNIQ.mjs";
+import { r as PolicyDefinition } from "./index-QTkd6a7C.mjs";
+//#region src/fevex.d.ts
+interface FevexConfig {
+  models: Record<string, ModelGateway>;
+  agents: AgentDefinition[];
+  tools?: ToolDefinition[];
+  runStore?: RunStore;
+  credentialStore?: CredentialStore;
+  policies?: PolicyDefinition[];
+  onEvent?: (event: AgentEvent) => void;
+  observability?: ObservabilityOptions;
+}
+interface Fevex {
+  startAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<AgentRun<TOutput>>;
+  runAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  streamAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): AsyncIterable<AgentEvent>;
+  getRun<TOutput = unknown>(runId: RunId): Promise<AgentRun<TOutput> | undefined>;
+  listEvents(runId: RunId, options?: ListEventsOptions): Promise<AgentEvent[]>;
+  cancelRun(runId: RunId): Promise<boolean>;
+  resumeRun<TOutput = unknown>(runId: RunId, resolution: ResumeRunResolution): Promise<AgentRun<TOutput>>;
+  compactSession(sessionId: SessionId, summary: string): Promise<Session>;
+  flushObservability(): Promise<void>;
+}
+declare function createFevex(config: FevexConfig): Fevex;
+//#endregion
+export { FevexConfig as n, createFevex as r, Fevex as t };

package/dist/index-BzxHfyYV.d.mts

@@ -0,0 +1,23 @@
+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
+export { AgentLimits as n, defineAgent as r, AgentDefinition as t };

package/dist/index-CZGyhNIQ.d.mts

@@ -0,0 +1,47 @@
+import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
+import { f as RunId, h as ToolSpec, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./index-C_Zpr13f.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/tools/index.d.ts
+interface ToolExecutionContext {
+  runId: RunId;
+  toolCallId: string;
+  attempt: number;
+  idempotencyKey: string;
+  getCredential(name: string): Promise<string>;
+  context?: ExecutionContext;
+  signal?: AbortSignal;
+}
+type ToolRisk = 'read' | 'write' | 'sensitive' | 'destructive';
+type ToolApproval = 'never' | 'required';
+type ToolIdempotency = 'none' | 'keyed';
+interface ToolRetryPolicy {
+  maxAttempts: number;
+  backoffMs: number;
+  maxBackoffMs?: number;
+}
+interface ToolDefinition<TInput = unknown, TOutput = unknown> {
+  name: string;
+  description?: string;
+  inputSchema?: StandardSchemaV1<unknown, TInput>;
+  outputSchema?: StandardSchemaV1<unknown, TOutput>;
+  risk?: ToolRisk;
+  approval?: ToolApproval;
+  idempotency?: ToolIdempotency;
+  retry?: ToolRetryPolicy;
+  credentials?: string[];
+  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 { ToolResult as a, defineTool as c, ToolIdempotency as i, toToolSpec as l, ToolDefinition as n, ToolRetryPolicy as o, ToolExecutionContext as r, ToolRisk as s, ToolApproval as t };

package/dist/index-C_Zpr13f.d.mts

@@ -0,0 +1,124 @@
+//#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";
+declare const PROVIDER_SCHEMA_UNSUPPORTED = "PROVIDER_SCHEMA_UNSUPPORTED";
+declare const PROVIDER_REASONING_UNSUPPORTED = "PROVIDER_REASONING_UNSUPPORTED";
+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' | 'run.paused' | 'run.resumed' | 'model.started' | 'model.output.delta' | 'model.completed' | 'tool.started' | 'tool.completed' | 'tool.failed' | 'tool.retrying' | 'tool.execution_unknown' | 'approval.requested' | 'approval.resolved' | 'run.completed' | 'run.failed' | 'run.cancelled';
+interface AgentEventPayloads {
+  'run.started': undefined;
+  'run.paused': {
+    reason: 'approval' | 'tool_execution_unknown';
+    toolCallId: string;
+  };
+  'run.resumed': undefined;
+  'model.started': {
+    step: number;
+  };
+  'model.output.delta': {
+    step: number;
+    delta: string;
+  };
+  'model.completed': {
+    step: number;
+    usage?: JsonObject;
+  };
+  'tool.started': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt?: number;
+  };
+  'tool.completed': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt?: number;
+  };
+  'tool.failed': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    error: string;
+  };
+  'tool.retrying': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt: number;
+    delayMs: number;
+    error: string;
+  };
+  'tool.execution_unknown': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+  };
+  'approval.requested': {
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+  };
+  'approval.resolved': {
+    approvalId: string;
+    toolCallId: string;
+    decision: 'approve' | 'reject';
+    actorId: string;
+  };
+  'run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'run.failed': {
+    error: string;
+  };
+  'run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+}
+interface AgentEventBase {
+  id: string;
+  sequence: number;
+  runId: RunId;
+  timestamp: string;
+}
+type AgentEvent<TType extends AgentEventType = AgentEventType> = { [TCurrent in TType]: AgentEventBase & {
+  type: TCurrent;
+} & (AgentEventPayloads[TCurrent] extends undefined ? {
+  payload?: never;
+} : {
+  payload: AgentEventPayloads[TCurrent];
+}); }[TType];
+//#endregion
+export { AgentMessageRole as a, JsonPrimitive as c, PROVIDER_SCHEMA_UNSUPPORTED as d, RunId as f, ToolSpec as h, AgentMessage as i, JsonValue as l, ToolCall as m, AgentEventPayloads as n, ExecutionContext as o, SCHEMA_NOT_TRANSPORTABLE as p, AgentEventType as r, JsonObject as s, AgentEvent as t, PROVIDER_REASONING_UNSUPPORTED as u };