@fevex/core 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/http/index.mjs

@@ -1,4 +1,6 @@
+import { o as ArtifactError } from "../artifacts-gUzemET7.mjs";
 import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+import { t as MAX_DEADLINE_MS } from "../run-support-CmZ6Xo6H.mjs";
 //#region src/http/protocol.ts
 const FEVEX_HTTP_PROTOCOL_VERSION = "3";
 const FEVEX_HTTP_PROTOCOL_VERSION_HEADER = "Fevex-Protocol-Version";
@@ -21,6 +23,8 @@ const FEVEX_RUN_ERROR_CODES = /* @__PURE__ */ new Set([
 	"CHECKPOINT_UNSUPPORTED",
 	"RUN_DEFINITION_CHANGED",
 	"POLICY_DENIED",
+	"ADMISSION_DENIED",
+	"RUNTIME_CLOSED",
 	"CREDENTIAL_NOT_FOUND",
 	"SANDBOX_REQUIRED",
 	"ELICITATION_INVALID",
@@ -32,69 +36,135 @@ const FEVEX_RUN_ERROR_CODES = /* @__PURE__ */ new Set([
 function createFevexHttpHandler(options) {
 	const pollIntervalMs = options.pollIntervalMs ?? 100;
 	const eventPageSize = options.eventPageSize ?? 100;
+	const maxConnections = options.maxConnections;
 	if (!Number.isSafeInteger(eventPageSize) || eventPageSize < 1 || eventPageSize > 1e3) throw new TypeError("eventPageSize must be an integer between 1 and 1000");
 	if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) throw new TypeError("pollIntervalMs must be a positive number");
+	if (maxConnections !== void 0 && (!Number.isSafeInteger(maxConnections) || maxConnections < 1)) throw new TypeError("maxConnections must be a positive safe integer");
+	let activeConnections = 0;
+	const authorize = async (access) => {
+		if (options.authorize && !await options.authorize(access)) throw new HttpProtocolError(403, "FORBIDDEN", "Forbidden");
+	};
+	const authorizeArtifact = async (access) => {
+		if (options.authorizeArtifact && !await options.authorizeArtifact(access)) throw new HttpProtocolError(403, "FORBIDDEN", "Forbidden");
+	};
 	return async (request, handlerContext = {}) => {
 		const url = new URL(request.url);
 		const path = url.pathname;
+		const commitStart = async (run) => {
+			try {
+				await options.onRunStarted?.(run, handlerContext.context);
+			} catch (error) {
+				await options.fevex.cancelRun(run.id).catch(() => {});
+				throw error;
+			}
+		};
 		try {
 			const start = path.match(/^\/v1\/agents\/([^/]+)\/runs$/);
 			if (start && request.method === "POST") {
 				const body = await readJson(request);
 				if (!hasOwn(body, "input")) throw badRequest("input is required");
+				const name = decodeURIComponent(start[1]);
 				const sessionId = optionalId(body.sessionId, "sessionId");
 				const model = optionalId(body.model, "model");
 				const reasoning = optionalReasoning(body.reasoning);
-				return json(await options.fevex.startAgent(decodeURIComponent(start[1]), {
+				const deadlineMs = optionalDeadline(body.deadlineMs, "deadlineMs");
+				await authorize({
+					action: "start",
+					kind: "agent",
+					name,
+					sessionId,
+					context: handlerContext.context
+				});
+				const run = await options.fevex.startAgent(name, {
 					input: body.input,
 					...model ? { model } : {},
 					...reasoning === void 0 ? {} : { reasoning },
+					...deadlineMs === void 0 ? {} : { deadlineMs },
 					...sessionId ? { sessionId } : {},
 					...handlerContext.context ? { context: handlerContext.context } : {}
-				}), 202);
+				});
+				await commitStart(run);
+				return json(run, 202);
 			}
 			const startWorkflow = path.match(/^\/v1\/workflows\/([^/]+)\/runs$/);
 			if (startWorkflow && request.method === "POST") {
 				const body = await readJson(request);
 				if (!hasOwn(body, "input")) throw badRequest("input is required");
+				const name = decodeURIComponent(startWorkflow[1]);
 				const sessionId = optionalId(body.sessionId, "sessionId");
 				const model = optionalId(body.model, "model");
 				const reasoning = optionalReasoning(body.reasoning);
-				return json(await options.fevex.startWorkflow(decodeURIComponent(startWorkflow[1]), {
+				const deadlineMs = optionalDeadline(body.deadlineMs, "deadlineMs");
+				await authorize({
+					action: "start",
+					kind: "workflow",
+					name,
+					sessionId,
+					context: handlerContext.context
+				});
+				const run = await options.fevex.startWorkflow(name, {
 					input: body.input,
 					...model ? { model } : {},
 					...reasoning === void 0 ? {} : { reasoning },
+					...deadlineMs === void 0 ? {} : { deadlineMs },
 					...sessionId ? { sessionId } : {},
 					...handlerContext.context ? { context: handlerContext.context } : {}
-				}), 202);
+				});
+				await commitStart(run);
+				return json(run, 202);
 			}
 			const startTeam = path.match(/^\/v1\/teams\/([^/]+)\/runs$/);
 			if (startTeam && request.method === "POST") {
 				const body = await readJson(request);
 				if (!hasOwn(body, "input")) throw badRequest("Run input is required");
+				const name = decodeURIComponent(startTeam[1]);
 				const sessionId = optionalId(body.sessionId, "sessionId");
 				const model = optionalId(body.model, "model");
 				const reasoning = optionalReasoning(body.reasoning);
-				return json(await options.fevex.startTeam(decodeURIComponent(startTeam[1]), {
+				const deadlineMs = optionalDeadline(body.deadlineMs, "deadlineMs");
+				await authorize({
+					action: "start",
+					kind: "team",
+					name,
+					sessionId,
+					context: handlerContext.context
+				});
+				const run = await options.fevex.startTeam(name, {
 					input: body.input,
 					...model ? { model } : {},
 					...reasoning === void 0 ? {} : { reasoning },
+					...deadlineMs === void 0 ? {} : { deadlineMs },
 					...sessionId ? { sessionId } : {},
 					...handlerContext.context ? { context: handlerContext.context } : {}
-				}), 202);
+				});
+				await commitStart(run);
+				return json(run, 202);
 			}
 			const events = path.match(/^\/v1\/runs\/([^/]+)\/events$/);
 			if (events && request.method === "GET") {
 				const runId = decodeURIComponent(events[1]);
+				await authorize({
+					action: "observe",
+					runId,
+					context: handlerContext.context
+				});
 				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
 				const after = request.headers.get("last-event-id")?.trim() || void 0;
 				const initial = await options.fevex.listEvents(runId, {
 					after,
 					limit: eventPageSize
 				});
+				if (maxConnections !== void 0 && activeConnections >= maxConnections) throw new HttpProtocolError(429, "CONNECTION_LIMIT", "Too many event streams");
+				activeConnections += 1;
+				let released = false;
+				const release = () => {
+					if (released) return;
+					released = true;
+					activeConnections -= 1;
+				};
 				const disconnected = new AbortController();
 				const iterator = observeEvents(options.fevex, runId, initial, after, pollIntervalMs, AbortSignal.any([request.signal, disconnected.signal]), eventPageSize);
-				return versioned(new Response(iteratorStream(iterator, () => disconnected.abort()), { headers: {
+				return versioned(new Response(iteratorStream(iterator, () => disconnected.abort(), release), { headers: {
 					"content-type": `${SSE_TYPE}; charset=utf-8`,
 					"cache-control": "no-cache, no-transform"
 				} }));
@@ -102,28 +172,99 @@ function createFevexHttpHandler(options) {
 			const resume = path.match(/^\/v1\/runs\/([^/]+)\/resume$/);
 			if (resume && request.method === "POST") {
 				const runId = decodeURIComponent(resume[1]);
-				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
 				const actor = handlerContext.context?.actor;
 				if (!actor?.id?.trim()) throw new HttpProtocolError(401, "ACTOR_REQUIRED", "Authenticated actor is required");
+				await authorize({
+					action: "resume",
+					runId,
+					context: handlerContext.context
+				});
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
 				const resolution = readResolution(await readJson(request), actor);
 				return json(await options.fevex.resumeRun(runId, resolution), 202);
 			}
 			const recover = path.match(/^\/v1\/runs\/([^/]+)\/recover$/);
 			if (recover && request.method === "POST") {
 				const runId = decodeURIComponent(recover[1]);
-				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
 				const actor = handlerContext.context?.actor;
 				if (!actor?.id?.trim()) throw new HttpProtocolError(401, "ACTOR_REQUIRED", "Authenticated actor is required");
+				await authorize({
+					action: "recover",
+					runId,
+					context: handlerContext.context
+				});
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
 				return json(await options.fevex.recoverRun(runId, { actor }), 202);
 			}
+			const runArtifacts = path.match(/^\/v1\/runs\/([^/]+)\/artifacts$/);
+			if (runArtifacts && request.method === "GET") {
+				const runId = decodeURIComponent(runArtifacts[1]);
+				await authorizeArtifact({
+					action: "read",
+					kind: "artifacts",
+					runId,
+					context: handlerContext.context
+				});
+				if (!options.artifactCatalog) throw new HttpProtocolError(501, "ARTIFACT_CATALOG_NOT_CONFIGURED", "Artifact catalog is not configured");
+				if (!await options.fevex.getRun(runId)) throw notFound("RUN_NOT_FOUND", "Run not found");
+				const limit = optionalLimit(url.searchParams.get("limit"));
+				return json((await options.artifactCatalog.list({
+					runId,
+					...limit === void 0 ? {} : { limit }
+				}, artifactContext(handlerContext, request))).map(({ descriptor }) => descriptor));
+			}
+			const artifactRoute = path.match(/^\/v1\/artifacts\/([^/]+)$/);
+			if (artifactRoute && (request.method === "GET" || request.method === "HEAD")) {
+				const artifactId = decodeURIComponent(artifactRoute[1]);
+				await authorizeArtifact({
+					action: "read",
+					kind: "artifact",
+					artifactId,
+					context: handlerContext.context
+				});
+				if (!options.artifacts) throw new HttpProtocolError(501, "ARTIFACTS_NOT_CONFIGURED", "Artifact store is not configured");
+				const context = artifactContext(handlerContext, request);
+				if (request.method === "HEAD" && options.artifacts.head) {
+					const descriptor = await options.artifacts.head(artifactId, context);
+					if (!descriptor) throw notFound("ARTIFACT_NOT_FOUND", "Artifact not found");
+					return artifactResponse(descriptor, null);
+				}
+				const content = await options.artifacts.get(artifactId, context);
+				if (!content) throw notFound("ARTIFACT_NOT_FOUND", "Artifact not found");
+				return artifactResponse(content.descriptor, request.method === "HEAD" ? null : content.bytes);
+			}
+			if (artifactRoute && request.method === "DELETE") {
+				const artifactId = decodeURIComponent(artifactRoute[1]);
+				await authorizeArtifact({
+					action: "delete",
+					kind: "artifact",
+					artifactId,
+					context: handlerContext.context
+				});
+				if (!options.artifacts) throw new HttpProtocolError(501, "ARTIFACTS_NOT_CONFIGURED", "Artifact store is not configured");
+				if (!options.artifacts.delete) throw new HttpProtocolError(501, "ARTIFACT_DELETE_UNSUPPORTED", "Artifact store does not support deletion");
+				if (!await options.artifacts.delete(artifactId, artifactContext(handlerContext, request))) throw notFound("ARTIFACT_NOT_FOUND", "Artifact not found");
+				return versioned(new Response(null, { status: 204 }));
+			}
 			const run = path.match(/^\/v1\/runs\/([^/]+)$/);
 			if (run && request.method === "GET") {
-				const value = await options.fevex.getRun(decodeURIComponent(run[1]));
+				const runId = decodeURIComponent(run[1]);
+				await authorize({
+					action: "read",
+					runId,
+					context: handlerContext.context
+				});
+				const value = await options.fevex.getRun(runId);
 				if (!value) throw notFound("RUN_NOT_FOUND", "Run not found");
 				return json(value);
 			}
 			if (run && request.method === "DELETE") {
 				const runId = decodeURIComponent(run[1]);
+				await authorize({
+					action: "cancel",
+					runId,
+					context: handlerContext.context
+				});
 				const value = await options.fevex.getRun(runId);
 				if (!value) throw notFound("RUN_NOT_FOUND", "Run not found");
 				if (value.status === "running" || value.status === "paused") {
@@ -131,7 +272,7 @@ function createFevexHttpHandler(options) {
 				}
 				return versioned(new Response(null, { status: 204 }));
 			}
-			if (start || startWorkflow || startTeam || events || resume || recover || run) throw new HttpProtocolError(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+			if (start || startWorkflow || startTeam || events || resume || recover || runArtifacts || artifactRoute || run) throw new HttpProtocolError(405, "METHOD_NOT_ALLOWED", "Method not allowed");
 			throw notFound("ROUTE_NOT_FOUND", "Route not found");
 		} catch (error) {
 			return problem(error, url.pathname, options.onError);
@@ -192,6 +333,17 @@ function createFevexHttpClient(options) {
 		},
 		async cancelRun(runId) {
 			await assertResponse(await fetcher(`${baseUrl}/v1/runs/${encodeURIComponent(runId)}`, { method: "DELETE" }));
+		},
+		async getArtifact(artifactId) {
+			const response = await fetcher(`${baseUrl}/v1/artifacts/${encodeURIComponent(artifactId)}`);
+			await assertResponse(response);
+			return response;
+		},
+		listArtifacts(runId) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}/artifacts`);
+		},
+		async deleteArtifact(artifactId) {
+			await assertResponse(await fetcher(`${baseUrl}/v1/artifacts/${encodeURIComponent(artifactId)}`, { method: "DELETE" }));
 		}
 	};
 }
@@ -220,18 +372,28 @@ async function* observeEvents(fevex, runId, initial, after, pollIntervalMs, sign
 		});
 	}
 }
-function iteratorStream(iterator, cancel) {
+function iteratorStream(iterator, cancel, done) {
+	let finished = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		done?.();
+	};
 	return new ReadableStream({
 		async pull(controller) {
 			try {
 				const next = await iterator.next();
-				if (next.done) controller.close();
-				else controller.enqueue(next.value);
+				if (next.done) {
+					finish();
+					controller.close();
+				} else controller.enqueue(next.value);
 			} catch (error) {
+				finish();
 				controller.error(error);
 			}
 		},
 		async cancel() {
+			finish();
 			cancel();
 			await iterator.return(void 0);
 		}
@@ -280,6 +442,37 @@ function findBoundary(value) {
 function formatEvent(event) {
 	return `id: ${event.id}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
 }
+function artifactContext(handlerContext, request) {
+	const tenantId = handlerContext.context?.attributes?.tenantId;
+	if (tenantId !== void 0 && typeof tenantId !== "string") throw badRequest("tenantId attribute must be a string");
+	const actor = handlerContext.context?.actor;
+	return {
+		...typeof tenantId === "string" ? { tenantId } : {},
+		...actor === void 0 ? {} : { actor },
+		signal: request.signal
+	};
+}
+function optionalLimit(value) {
+	if (value === null) return void 0;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 1) throw badRequest("limit must be a positive integer");
+	return parsed;
+}
+function artifactResponse(descriptor, bytes) {
+	return versioned(new Response(bytes === null ? null : bytes.slice().buffer, { headers: {
+		"content-type": descriptor.mimeType,
+		"content-length": String(descriptor.size),
+		"content-disposition": contentDisposition(descriptor.filename),
+		"cache-control": "private, max-age=0, must-revalidate",
+		etag: `"${descriptor.sha256}"`,
+		"x-content-type-options": "nosniff",
+		"fevex-artifact-id": descriptor.artifactId,
+		"fevex-artifact-sha256": descriptor.sha256
+	} }));
+}
+function contentDisposition(filename) {
+	return `attachment; filename="${filename.replace(/[^\x20-\x7e]/gu, "_").replace(/["\\]/gu, "_")}"; filename*=UTF-8''${encodeURIComponent(filename).replace(/'/gu, "%27")}`;
+}
 function readResolution(body, actor) {
 	if (body.type === "elicitation" && typeof body.requestId === "string" && body.requestId.trim() && hasOwn(body, "value")) return {
 		type: "elicitation",
@@ -334,6 +527,16 @@ function optionalId(value, name) {
 	if (typeof value !== "string" || !value.trim()) throw badRequest(`${name} must be a string`);
 	return value.trim();
 }
+function optionalPositiveInteger(value, name) {
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 1) throw badRequest(`${name} must be a positive integer`);
+	return value;
+}
+function optionalDeadline(value, name) {
+	const deadlineMs = optionalPositiveInteger(value, name);
+	if (deadlineMs !== void 0 && deadlineMs > 2147483647) throw badRequest(`${name} must be at most ${MAX_DEADLINE_MS}`);
+	return deadlineMs;
+}
 function optionalReasoning(value) {
 	if (value === void 0) return void 0;
 	if (typeof value !== "string" || ![
@@ -408,6 +611,11 @@ function problem(error, instance, onError) {
 		({status, code} = error);
 		title = error.message;
 		detail = error.message;
+	} else if (error instanceof ArtifactError) {
+		code = error.code;
+		status = statusForArtifactErrorCode(error.code);
+		title = titleForStatus(status);
+		detail = error.message;
 	} else {
 		const runError = readFevexRunError(error);
 		if (runError) {
@@ -446,13 +654,27 @@ function statusForRunErrorCode(code) {
 	if (code === "AGENT_NOT_FOUND" || code === "WORKFLOW_NOT_FOUND" || code === "TEAM_NOT_FOUND" || code === "SESSION_NOT_FOUND") return 404;
 	if (code === "APPROVAL_INVALID" || code === "INVALID_CURSOR") return 400;
 	if (code === "POLICY_DENIED") return 403;
+	if (code === "ADMISSION_DENIED") return 429;
+	if (code === "RUNTIME_CLOSED") return 503;
 	return 409;
 }
+function statusForArtifactErrorCode(code) {
+	if (code === "ARTIFACT_INVALID_ID" || code === "ARTIFACT_INVALID_INPUT" || code === "ARTIFACT_INVALID_CONTEXT") return 400;
+	if (code === "ARTIFACT_TOO_LARGE") return 413;
+	if (code === "ARTIFACT_MIME_UNSUPPORTED") return 415;
+	if (code === "ARTIFACT_CONFLICT") return 409;
+	return 500;
+}
 function titleForStatus(status) {
-	if (status === 404) return "Not Found";
 	if (status === 400) return "Bad Request";
 	if (status === 403) return "Forbidden";
-	return "Conflict";
+	if (status === 404) return "Not Found";
+	if (status === 409) return "Conflict";
+	if (status === 413) return "Payload Too Large";
+	if (status === 415) return "Unsupported Media Type";
+	if (status === 429) return "Too Many Requests";
+	if (status === 501) return "Not Implemented";
+	return "Internal Server Error";
 }
 function wait(ms, signal) {
 	return new Promise((resolve) => {

package/dist/{index-C-IFfCNw.d.mts → index-1cHr7KB_.d.mts}

@@ -1,7 +1,7 @@
 import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
-import { o as ExecutionContext } from "./types-CuoRx12Q.mjs";
-import { n as AgentLimits } from "./index-CaE864Kz.mjs";
-import { t as WorkflowAgentResult } from "./index-CknU-glw.mjs";
+import { o as ExecutionContext } from "./types-B8laW1hM.mjs";
+import { n as AgentLimits } from "./index-CzAi2Y_Z.mjs";
+import { t as WorkflowAgentResult } from "./index-CseuTR-F.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/teams/team.d.ts
 interface TeamMember {

package/dist/{index-CqOjvtQ9.d.mts → index-5p3q2yIp.d.mts}

@@ -1,6 +1,6 @@
 import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
-import { f as RunId, g as ToolSpec, h as ToolEventSource, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-CuoRx12Q.mjs";
-import { i as SandboxCapabilities, r as Sandbox } from "./index-CrOId2px.mjs";
+import { F as ArtifactStore, f as RunId, g as ToolSpec, h as ToolEventSource, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-B8laW1hM.mjs";
+import { i as SandboxCapabilities, r as Sandbox } from "./index-Df84VWmN.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/tools/tool.d.ts
 interface ToolExecutionContext {
@@ -10,6 +10,8 @@ interface ToolExecutionContext {
   idempotencyKey: string;
   getCredential(name: string): Promise<string>;
   sandbox?: Sandbox;
+  /** Optional artifact store; writes emit `artifact.created`. */
+  artifacts?: ArtifactStore;
   context?: ExecutionContext;
   signal?: AbortSignal;
 }

package/dist/{index-hhbgvfIt.d.mts → index-BJktlD4E.d.mts}

@@ -1,5 +1,5 @@
-import { l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-CuoRx12Q.mjs";
-import { M as SessionId } from "./index-CaE864Kz.mjs";
+import { l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-B8laW1hM.mjs";
+import { L as SessionId } from "./index-CzAi2Y_Z.mjs";
 //#region src/knowledge/knowledge.d.ts
 /** Runtime context supplied to knowledge providers and memory stores. */
 interface KnowledgeContext {

package/dist/{index-CTIwrVf9.d.mts → index-BgKFd9yw.d.mts}

@@ -1,4 +1,4 @@
-import { g as ToolSpec, i as AgentMessage, l as JsonValue, m as ToolCall, s as JsonObject } from "./types-CuoRx12Q.mjs";
+import { g as ToolSpec, i as AgentMessage, l as JsonValue, m as ToolCall, s as JsonObject } from "./types-B8laW1hM.mjs";
 //#region src/models/model.d.ts
 /** Provider-neutral reasoning levels accepted by model gateways. */
 type ReasoningEffort = 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';

package/dist/{index-dkFyTNh4.d.mts → index-CbACw6xZ.d.mts}

@@ -1,5 +1,5 @@
-import { f as RunId, l as JsonValue, o as ExecutionContext } from "./types-CuoRx12Q.mjs";
-import { x as ToolRisk } from "./index-CqOjvtQ9.mjs";
+import { f as RunId, l as JsonValue, o as ExecutionContext } from "./types-B8laW1hM.mjs";
+import { x as ToolRisk } from "./index-5p3q2yIp.mjs";
 //#region src/policies/policy.d.ts
 /** Authorization outcome returned by a policy. */
 type PolicyDecision = 'allow' | 'deny' | 'require_approval';

package/dist/index-CpLDt6Rw.d.mts

@@ -0,0 +1,118 @@
+import { f as RunId, l as JsonValue, s as JsonObject } from "./types-B8laW1hM.mjs";
+import { r as ModelMetadata, s as ModelUsage } from "./index-BgKFd9yw.mjs";
+import { L as SessionId } from "./index-CzAi2Y_Z.mjs";
+//#region src/observability/trace.d.ts
+/** Final state represented by an exported run trace. */
+type TraceStatus = 'completed' | 'failed' | 'cancelled';
+/** Kind of run that produced a trace. Absent means `agent` for older traces. */
+type TraceRunKind = 'agent' | 'workflow' | 'team';
+/** Model and tool calls are agent spans; steps belong to workflow and team traces. */
+type TraceSpanKind = 'model' | 'tool' | 'step';
+type TraceContentKind = 'run.output' | 'model.output' | 'error.message';
+interface TraceCost {
+  amount: number;
+  currency: string;
+}
+interface TraceContent {
+  kind: TraceContentKind;
+  value: JsonValue;
+}
+interface TraceAnnotation {
+  name: string;
+  timestamp: string;
+  attributes?: JsonObject;
+}
+interface TraceSpan {
+  id: string;
+  /** Run or span that contains this span. */
+  parentId: string;
+  kind: TraceSpanKind;
+  name: string;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  status: TraceStatus;
+  attributes: JsonObject;
+  annotations: TraceAnnotation[];
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  content?: TraceContent[];
+}
+interface RunTrace {
+  schemaVersion: '1';
+  /** Absent on traces produced before coordinator traces existed; treat as `agent`. */
+  kind?: TraceRunKind;
+  traceId: string;
+  runId: RunId;
+  sessionId: SessionId;
+  /** Agent, workflow or team name. */
+  agentName: string;
+  /** Run that created this one, when it belongs to a workflow or team. */
+  parentRunId?: RunId;
+  /** Top-level run in the correlation tree. Defaults to `runId`. */
+  rootRunId?: RunId;
+  /** Only present on agent traces. */
+  modelRegistryName?: string;
+  model?: ModelMetadata;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  status: TraceStatus;
+  attributes: JsonObject;
+  annotations: TraceAnnotation[];
+  spans: TraceSpan[];
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  content?: TraceContent[];
+}
+interface CostCalculatorInput {
+  modelRegistryName: string;
+  model?: ModelMetadata;
+  usage: ModelUsage;
+}
+type CostCalculator = (input: CostCalculatorInput) => TraceCost | undefined;
+interface TraceRedactorInput {
+  kind: TraceContentKind;
+  value: JsonValue;
+}
+type TraceRedactor = (input: TraceRedactorInput) => JsonValue | undefined;
+interface TraceContentPolicy {
+  include: readonly TraceContentKind[];
+  redact?: TraceRedactor;
+}
+interface TraceExporter {
+  export(trace: Readonly<RunTrace>): void | Promise<void>;
+}
+interface TraceExportQueueOptions {
+  /** Traces exported at once. Defaults to 4. */
+  concurrency?: number;
+  /** Traces waiting for an export slot before new traces are dropped. Defaults to 100. */
+  maxQueued?: number;
+  /** Deadline for each exporter call. Defaults to 30 seconds. */
+  timeoutMs?: number;
+  /** Failures retained for the next `flushObservability` call. Defaults to 100. */
+  maxFailures?: number;
+}
+/** Queue and failure counters for the runtime's trace exporters. */
+interface ObservabilityStats {
+  /** Traces exported successfully since the runtime started. */
+  exported: number;
+  /** Failed exports and dropped traces since the runtime started. */
+  failed: number;
+  /** Traces dropped because the queue was full. */
+  dropped: number;
+  /** Traces waiting for an export slot. */
+  queued: number;
+  /** Traces currently being exported. */
+  active: number;
+  /** Failures retained for the next flush. */
+  retainedFailures: number;
+}
+interface ObservabilityOptions {
+  exporters: readonly TraceExporter[];
+  calculateCost?: CostCalculator;
+  content?: TraceContentPolicy;
+  exportQueue?: TraceExportQueueOptions;
+}
+//#endregion
+export { TraceSpanKind as _, RunTrace as a, TraceContentKind as c, TraceExportQueueOptions as d, TraceExporter as f, TraceSpan as g, TraceRunKind as h, ObservabilityStats as i, TraceContentPolicy as l, TraceRedactorInput as m, CostCalculatorInput as n, TraceAnnotation as o, TraceRedactor as p, ObservabilityOptions as r, TraceContent as s, CostCalculator as t, TraceCost as u, TraceStatus as v };

package/dist/{index-CknU-glw.d.mts → index-CseuTR-F.d.mts}

@@ -1,6 +1,6 @@
 import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
-import { f as RunId, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-CuoRx12Q.mjs";
-import { D as RunRequest, M as SessionId, O as RunResult, n as AgentLimits } from "./index-CaE864Kz.mjs";
+import { f as RunId, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-B8laW1hM.mjs";
+import { L as SessionId, M as RunRequest, N as RunResult, n as AgentLimits } from "./index-CzAi2Y_Z.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/workflows/workflow.d.ts
 /** Context shared with workflow steps and compensation handlers. */