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

package/dist/{fevex-BoPbZ-Tw.d.mts → fevex-B5NxFKcV.d.mts}

@@ -1,14 +1,39 @@
-import { f as RunId, t as AgentEvent } from "./types-CuoRx12Q.mjs";
-import { t as ModelGateway } from "./index-CTIwrVf9.mjs";
-import { A as RunStore, D as RunRequest, E as RunRecord, F as TeamRun, M as SessionId, O as RunResult, S as ResumeRunResolution, U as WorkflowRun, a as AgentRun, b as ListEventsOptions, f as CredentialStore, j as Session, t as AgentDefinition } from "./index-CaE864Kz.mjs";
-import { r as ContextProvider, s as MemoryStore } from "./index-hhbgvfIt.mjs";
-import { r as ObservabilityOptions } from "./index-voIZhQXB.mjs";
-import { r as Sandbox } from "./index-CrOId2px.mjs";
-import { g as ToolDefinition, s as ConnectionDefinition } from "./index-CqOjvtQ9.mjs";
-import { r as PolicyDefinition } from "./index-dkFyTNh4.mjs";
-import { n as WorkflowDefinition } from "./index-CknU-glw.mjs";
-import { t as TeamDefinition } from "./index-C-IFfCNw.mjs";
+import { F as ArtifactStore, f as RunId, o as ExecutionContext, t as AgentEvent } from "./types-BDVUoAU6.mjs";
+import { t as ModelGateway } from "./index-BPwkgdo3.mjs";
+import { A as RunRecord, C as PurgeRunsResult, F as Session, I as SessionId, M as RunResult, P as RunStore, S as PurgeRunsOptions, a as AgentRun, b as ListEventsOptions, f as CredentialStore, j as RunRequest, q as WorkflowRun, t as AgentDefinition, w as ResumeRunResolution, z as TeamRun } from "./index-CGmHXV31.mjs";
+import { r as ContextProvider, s as MemoryStore } from "./index-aayvtf0J.mjs";
+import { r as ObservabilityOptions } from "./index-D6lnI92z.mjs";
+import { r as Sandbox } from "./index-BFnWUu7j.mjs";
+import { g as ToolDefinition, s as ConnectionDefinition } from "./index-CKQCNvJz.mjs";
+import { r as PolicyDefinition } from "./index-Cb3AB98n.mjs";
+import { n as WorkflowDefinition } from "./index-Br-zPxZH.mjs";
+import { t as TeamDefinition } from "./index-Dsulk-n6.mjs";
 //#region src/fevex.d.ts
+interface FevexAdmissionRequest {
+  kind: 'agent' | 'workflow' | 'team';
+  name: string;
+  request: RunRequest;
+  activeRuns: number;
+  activeTenantRuns: number;
+}
+/** Optional host-level admission controls applied before a top-level run starts. */
+interface FevexAdmission {
+  /** Maximum concurrent top-level runs in this runtime. */
+  maxActiveRuns?: number;
+  /** Maximum concurrent top-level runs for one tenant. */
+  maxActiveRunsPerTenant?: number;
+  /** Defaults to a non-empty `context.attributes.tenantId` string. */
+  tenantKey?: (context?: ExecutionContext) => string | undefined;
+  /** Custom admission check, called after the built-in limits. */
+  authorize?: (request: FevexAdmissionRequest) => boolean | Promise<boolean>;
+}
+interface FevexLimits {
+  /**
+   * Maximum non-control events persisted for one run. Control events such as
+   * pause, resume, approval and terminal transitions are always persisted.
+   */
+  maxEventsPerRun?: number;
+}
 /** Provider-neutral definitions and adapters used to create one Fevex runtime. */
 interface FevexConfig {
   models: Record<string, ModelGateway>;
@@ -22,9 +47,13 @@ interface FevexConfig {
   runStore?: RunStore;
   credentialStore?: CredentialStore;
   sandbox?: Sandbox;
+  /** Optional artifact store exposed to tools as `context.artifacts`. */
+  artifacts?: ArtifactStore;
   policies?: PolicyDefinition[];
   onEvent?: (event: AgentEvent) => void;
   observability?: ObservabilityOptions;
+  admission?: FevexAdmission;
+  limits?: FevexLimits;
 }
 interface Fevex {
   startAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<AgentRun<TOutput>>;
@@ -46,6 +75,7 @@ interface Fevex {
       type?: string;
     };
   }): Promise<RunRecord<TOutput>>;
+  purgeRuns(options?: PurgeRunsOptions): Promise<PurgeRunsResult>;
   compactSession(sessionId: SessionId, summary: string): Promise<Session>;
   flushObservability(): Promise<void>;
 }
@@ -57,4 +87,4 @@ interface Fevex {
  */
 declare function createFevex(config: FevexConfig): Fevex;
 //#endregion
-export { FevexConfig as n, createFevex as r, Fevex as t };
+export { FevexLimits as a, FevexConfig as i, FevexAdmission as n, createFevex as o, FevexAdmissionRequest as r, Fevex as t };

package/dist/http/index.d.mts

@@ -1,7 +1,7 @@
-import { l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-CuoRx12Q.mjs";
-import { c as ReasoningEffort } from "../index-CTIwrVf9.mjs";
-import { E as RunRecord, F as TeamRun, M as SessionId, U as WorkflowRun, a as AgentRun } from "../index-CaE864Kz.mjs";
-import { t as Fevex } from "../fevex-BoPbZ-Tw.mjs";
+import { D as ArtifactCatalog, F as ArtifactStore, f as RunId, k as ArtifactDescriptor, l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-BDVUoAU6.mjs";
+import { c as ReasoningEffort } from "../index-BPwkgdo3.mjs";
+import { A as RunRecord, I as SessionId, a as AgentRun, q as WorkflowRun, z as TeamRun } from "../index-CGmHXV31.mjs";
+import { t as Fevex } from "../fevex-B5NxFKcV.mjs";
 //#region src/http/protocol.d.ts
 declare const FEVEX_HTTP_PROTOCOL_VERSION = "3";
 declare const FEVEX_HTTP_PROTOCOL_VERSION_HEADER = "Fevex-Protocol-Version";
@@ -10,6 +10,8 @@ interface StartRunHttpRequest<TInput extends JsonValue = JsonValue> {
   model?: string;
   reasoning?: ReasoningEffort;
   sessionId?: SessionId;
+  /** Maximum wall-clock time for the run, including time spent paused. */
+  deadlineMs?: number;
 }
 type ResumeRunHttpRequest = {
   type: 'elicitation';
@@ -47,11 +49,66 @@ interface FevexProblemDetails {
 interface FevexHttpHandlerContext {
   context?: ExecutionContext;
 }
+/** Host-facing resource access check. */
+type FevexHttpAccess = {
+  action: 'start';
+  kind: 'agent' | 'workflow' | 'team';
+  name: string;
+  sessionId?: SessionId;
+  context?: ExecutionContext;
+} | {
+  action: 'read' | 'observe' | 'cancel' | 'resume' | 'recover';
+  runId: RunId;
+  context?: ExecutionContext;
+};
+/** Host-facing artifact access check. */
+type FevexArtifactAccess = {
+  action: 'read' | 'delete';
+  kind: 'artifact';
+  artifactId: string;
+  context?: ExecutionContext;
+} | {
+  action: 'read';
+  kind: 'artifacts';
+  runId: RunId;
+  context?: ExecutionContext;
+};
 interface FevexHttpHandlerOptions {
   fevex: Fevex;
   pollIntervalMs?: number;
   /** Events per SSE read (default 100, maximum 1000). */
   eventPageSize?: number;
+  /** Maximum concurrent SSE streams (default unlimited). */
+  maxConnections?: number;
+  /**
+   * Authorizes a resource operation before the handler reads or mutates a run,
+   * or starts a run (new or existing session). Return false for a 403 response.
+   * Omit to preserve the host's existing trusted-network behavior.
+   */
+  authorize?: (access: FevexHttpAccess) => boolean | Promise<boolean>;
+  /**
+   * Byte store used by the artifact routes. When omitted, artifact routes
+   * return 501.
+   */
+  artifacts?: ArtifactStore;
+  /**
+   * Metadata catalog used to list artifacts for a run. When omitted, the
+   * run-artifact listing route returns 501.
+   */
+  artifactCatalog?: ArtifactCatalog;
+  /**
+   * Authorizes artifact reads, listings and deletions. Omit to preserve the
+   * host's existing trusted-network behavior.
+   */
+  authorizeArtifact?: (access: FevexArtifactAccess) => boolean | Promise<boolean>;
+  /**
+   * Called after a run starts so the host can persist run and session ownership.
+   * If it throws, the handler cancels the new run and returns 500. A process
+   * crash between start and this callback leaves the run unowned; hosts must
+   * treat unowned runs as inaccessible. Runs created outside the HTTP handler
+   * are not reported.
+   */
+  onRunStarted?: (run: RunRecord, context?: ExecutionContext) => void | Promise<void>;
   onError?: (error: unknown, problem: FevexProblemDetails) => void;
 }
 type FevexHttpHandler = (request: Request, context?: FevexHttpHandlerContext) => Promise<Response>;
@@ -73,6 +130,9 @@ interface FevexHttpClient {
   resumeRun<TOutput = JsonValue>(runId: string, request: ResumeRunHttpRequest): Promise<RunRecord<TOutput>>;
   recoverRun<TOutput = JsonValue>(runId: string): Promise<RunRecord<TOutput>>;
   cancelRun(runId: string): Promise<void>;
+  getArtifact(artifactId: string): Promise<Response>;
+  listArtifacts(runId: string): Promise<ArtifactDescriptor[]>;
+  deleteArtifact(artifactId: string): Promise<void>;
 }
 //#endregion
 //#region src/http/transport.d.ts
@@ -87,4 +147,4 @@ declare class FevexHttpError extends Error {
 }
 declare function createFevexHttpClient(options: FevexHttpClientOptions): FevexHttpClient;
 //#endregion
-export { FEVEX_HTTP_PROTOCOL_VERSION, FEVEX_HTTP_PROTOCOL_VERSION_HEADER, FevexHttpClient, FevexHttpClientOptions, FevexHttpError, FevexHttpFetch, FevexHttpHandler, FevexHttpHandlerContext, FevexHttpHandlerOptions, FevexProblemDetails, ObserveRunOptions, ResumeRunHttpRequest, StartRunHttpRequest, createFevexHttpClient, createFevexHttpHandler };
+export { FEVEX_HTTP_PROTOCOL_VERSION, FEVEX_HTTP_PROTOCOL_VERSION_HEADER, FevexArtifactAccess, FevexHttpAccess, FevexHttpClient, FevexHttpClientOptions, FevexHttpError, FevexHttpFetch, FevexHttpHandler, FevexHttpHandlerContext, FevexHttpHandlerOptions, FevexProblemDetails, ObserveRunOptions, ResumeRunHttpRequest, StartRunHttpRequest, createFevexHttpClient, createFevexHttpHandler };

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,7 @@ const FEVEX_RUN_ERROR_CODES = /* @__PURE__ */ new Set([
 	"CHECKPOINT_UNSUPPORTED",
 	"RUN_DEFINITION_CHANGED",
 	"POLICY_DENIED",
+	"ADMISSION_DENIED",
 	"CREDENTIAL_NOT_FOUND",
 	"SANDBOX_REQUIRED",
 	"ELICITATION_INVALID",
@@ -32,69 +35,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 +171,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 +271,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 +332,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 +371,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 +441,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 +526,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 +610,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 +653,26 @@ 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;
 	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-DyyNLuwO.d.mts → index--_LdSEuF.d.mts}

@@ -1,6 +1,6 @@
-import { f as RunId, o as ExecutionContext, s as JsonObject, t as AgentEvent } from "./types-CuoRx12Q.mjs";
-import { M as SessionId, a as AgentRun, h as ElicitationRequest } from "./index-CaE864Kz.mjs";
-import { t as Fevex } from "./fevex-BoPbZ-Tw.mjs";
+import { f as RunId, o as ExecutionContext, s as JsonObject, t as AgentEvent } from "./types-BDVUoAU6.mjs";
+import { I as SessionId, a as AgentRun, h as ElicitationRequest } from "./index-CGmHXV31.mjs";
+import { t as Fevex } from "./fevex-B5NxFKcV.mjs";
 //#region src/channels/channel.d.ts
 interface ChannelMessage {
   id: string;

package/dist/{index-CrOId2px.d.mts → index-BFnWUu7j.d.mts}

@@ -1,4 +1,4 @@
-import { f as RunId, l as JsonValue, o as ExecutionContext } from "./types-CuoRx12Q.mjs";
+import { f as RunId, l as JsonValue, o as ExecutionContext } from "./types-BDVUoAU6.mjs";
 //#region src/sandbox/sandbox.d.ts
 interface SandboxCapabilities {
   process?: {

package/dist/{index-CTIwrVf9.d.mts → index-BPwkgdo3.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-BDVUoAU6.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-CknU-glw.d.mts → index-Br-zPxZH.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-BDVUoAU6.mjs";
+import { I as SessionId, M as RunResult, j as RunRequest, n as AgentLimits } from "./index-CGmHXV31.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/workflows/workflow.d.ts
 /** Context shared with workflow steps and compensation handlers. */