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

package/dist/http/index.mjs

@@ -0,0 +1,470 @@
+import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+//#region src/http/protocol.ts
+const FEVEX_HTTP_PROTOCOL_VERSION = "3";
+const FEVEX_HTTP_PROTOCOL_VERSION_HEADER = "Fevex-Protocol-Version";
+//#endregion
+//#region src/http/transport.ts
+const JSON_TYPE = "application/json";
+const PROBLEM_TYPE = "application/problem+json";
+const SSE_TYPE = "text/event-stream";
+const FEVEX_RUN_ERROR_CODES = /* @__PURE__ */ new Set([
+	"INVALID_CURSOR",
+	"AGENT_NOT_FOUND",
+	"WORKFLOW_NOT_FOUND",
+	"TEAM_NOT_FOUND",
+	"MODEL_NOT_FOUND",
+	"SESSION_NOT_FOUND",
+	"DURABLE_STORE_REQUIRED",
+	"RUN_CONFLICT",
+	"RUN_NOT_RESUMABLE",
+	"RUN_NOT_RECOVERABLE",
+	"CHECKPOINT_UNSUPPORTED",
+	"RUN_DEFINITION_CHANGED",
+	"POLICY_DENIED",
+	"CREDENTIAL_NOT_FOUND",
+	"SANDBOX_REQUIRED",
+	"ELICITATION_INVALID",
+	"APPROVAL_INVALID",
+	"RUN_PAUSED",
+	"TOOL_EXECUTION_UNKNOWN"
+]);
+/** Exposes a Fevex instance through the versioned HTTP protocol. */
+function createFevexHttpHandler(options) {
+	const pollIntervalMs = options.pollIntervalMs ?? 100;
+	const eventPageSize = options.eventPageSize ?? 100;
+	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");
+	return async (request, handlerContext = {}) => {
+		const url = new URL(request.url);
+		const path = url.pathname;
+		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 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]), {
+					input: body.input,
+					...model ? { model } : {},
+					...reasoning === void 0 ? {} : { reasoning },
+					...sessionId ? { sessionId } : {},
+					...handlerContext.context ? { context: handlerContext.context } : {}
+				}), 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 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]), {
+					input: body.input,
+					...model ? { model } : {},
+					...reasoning === void 0 ? {} : { reasoning },
+					...sessionId ? { sessionId } : {},
+					...handlerContext.context ? { context: handlerContext.context } : {}
+				}), 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 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]), {
+					input: body.input,
+					...model ? { model } : {},
+					...reasoning === void 0 ? {} : { reasoning },
+					...sessionId ? { sessionId } : {},
+					...handlerContext.context ? { context: handlerContext.context } : {}
+				}), 202);
+			}
+			const events = path.match(/^\/v1\/runs\/([^/]+)\/events$/);
+			if (events && request.method === "GET") {
+				const runId = decodeURIComponent(events[1]);
+				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
+				});
+				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: {
+					"content-type": `${SSE_TYPE}; charset=utf-8`,
+					"cache-control": "no-cache, no-transform"
+				} }));
+			}
+			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");
+				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");
+				return json(await options.fevex.recoverRun(runId, { actor }), 202);
+			}
+			const run = path.match(/^\/v1\/runs\/([^/]+)$/);
+			if (run && request.method === "GET") {
+				const value = await options.fevex.getRun(decodeURIComponent(run[1]));
+				if (!value) throw notFound("RUN_NOT_FOUND", "Run not found");
+				return json(value);
+			}
+			if (run && request.method === "DELETE") {
+				const runId = decodeURIComponent(run[1]);
+				const value = await options.fevex.getRun(runId);
+				if (!value) throw notFound("RUN_NOT_FOUND", "Run not found");
+				if (value.status === "running" || value.status === "paused") {
+					if (!await options.fevex.cancelRun(runId) && (await options.fevex.getRun(runId))?.status === value.status) throw new HttpProtocolError(409, "RUN_CONFLICT", "Run could not be cancelled");
+				}
+				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");
+			throw notFound("ROUTE_NOT_FOUND", "Route not found");
+		} catch (error) {
+			return problem(error, url.pathname, options.onError);
+		}
+	};
+}
+var FevexHttpError = class extends Error {
+	problem;
+	name = "FevexHttpError";
+	constructor(problem) {
+		super(problem.detail ?? problem.title);
+		this.problem = problem;
+	}
+	get status() {
+		return this.problem.status;
+	}
+	get code() {
+		return this.problem.code;
+	}
+};
+function createFevexHttpClient(options) {
+	const baseUrl = options.baseUrl.replace(/\/$/, "");
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const request = async (path, init) => {
+		const response = await fetcher(`${baseUrl}${path}`, init);
+		await assertResponse(response, JSON_TYPE);
+		return response.json();
+	};
+	return {
+		startRun(agentName, body) {
+			return request(`/v1/agents/${encodeURIComponent(agentName)}/runs`, jsonInit("POST", body));
+		},
+		startWorkflow(workflowName, body) {
+			return request(`/v1/workflows/${encodeURIComponent(workflowName)}/runs`, jsonInit("POST", body));
+		},
+		startTeam(teamName, body) {
+			return request(`/v1/teams/${encodeURIComponent(teamName)}/runs`, jsonInit("POST", body));
+		},
+		getRun(runId) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}`);
+		},
+		observeRun(runId, observeOptions = {}) {
+			return { async *[Symbol.asyncIterator]() {
+				const response = await fetcher(`${baseUrl}/v1/runs/${encodeURIComponent(runId)}/events`, {
+					headers: observeOptions.after ? { "last-event-id": observeOptions.after } : void 0,
+					signal: observeOptions.signal
+				});
+				await assertResponse(response, SSE_TYPE);
+				if (!response.body) throw new TypeError("Fevex event response has no body");
+				yield* parseEventStream(response.body);
+			} };
+		},
+		resumeRun(runId, body) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}/resume`, jsonInit("POST", body));
+		},
+		recoverRun(runId) {
+			return request(`/v1/runs/${encodeURIComponent(runId)}/recover`, { method: "POST" });
+		},
+		async cancelRun(runId) {
+			await assertResponse(await fetcher(`${baseUrl}/v1/runs/${encodeURIComponent(runId)}`, { method: "DELETE" }));
+		}
+	};
+}
+async function* observeEvents(fevex, runId, initial, after, pollIntervalMs, signal, pageSize) {
+	const encoder = new TextEncoder();
+	let pending = initial;
+	let cursor = after;
+	let closedEmptyReads = 0;
+	while (!signal.aborted) {
+		for (const event of pending) {
+			if (signal.aborted) return;
+			cursor = event.id;
+			yield encoder.encode(formatEvent(event));
+		}
+		const run = await fevex.getRun(runId);
+		if (!run) return;
+		if (run.status !== "running" && pending.length === 0) {
+			closedEmptyReads += 1;
+			if (closedEmptyReads >= 2) return;
+		} else closedEmptyReads = 0;
+		if (pending.length < pageSize) await wait(pollIntervalMs, signal);
+		if (signal.aborted) return;
+		pending = await fevex.listEvents(runId, {
+			after: cursor,
+			limit: pageSize
+		});
+	}
+}
+function iteratorStream(iterator, cancel) {
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const next = await iterator.next();
+				if (next.done) controller.close();
+				else controller.enqueue(next.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		async cancel() {
+			cancel();
+			await iterator.return(void 0);
+		}
+	});
+}
+async function* parseEventStream(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let finished = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			buffer += decoder.decode(value, { stream: !done });
+			let boundary = findBoundary(buffer);
+			while (boundary) {
+				const frame = buffer.slice(0, boundary.index);
+				buffer = buffer.slice(boundary.index + boundary.length);
+				const data = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+				if (data) yield JSON.parse(data);
+				boundary = findBoundary(buffer);
+			}
+			if (done) {
+				if (buffer.trim()) throw new TypeError("Fevex event stream ended with an incomplete frame");
+				finished = true;
+				return;
+			}
+		}
+	} finally {
+		if (!finished) await reader.cancel();
+		reader.releaseLock();
+	}
+}
+function findBoundary(value) {
+	const lf = value.indexOf("\n\n");
+	const crlf = value.indexOf("\r\n\r\n");
+	if (lf < 0 && crlf < 0) return void 0;
+	return crlf >= 0 && (lf < 0 || crlf < lf) ? {
+		index: crlf,
+		length: 4
+	} : {
+		index: lf,
+		length: 2
+	};
+}
+function formatEvent(event) {
+	return `id: ${event.id}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+function readResolution(body, actor) {
+	if (body.type === "elicitation" && typeof body.requestId === "string" && body.requestId.trim() && hasOwn(body, "value")) return {
+		type: "elicitation",
+		requestId: body.requestId,
+		value: body.value,
+		actor
+	};
+	if (body.type === "approval" && typeof body.approvalId === "string" && (body.decision === "approve" || body.decision === "reject")) return {
+		type: "approval",
+		approvalId: body.approvalId,
+		decision: body.decision,
+		actor
+	};
+	if (body.type === "tool_execution" && typeof body.toolCallId === "string" && body.decision === "retry") return {
+		type: "tool_execution",
+		toolCallId: body.toolCallId,
+		decision: "retry",
+		actor
+	};
+	if (body.type === "tool_execution" && typeof body.toolCallId === "string" && body.decision === "use_output" && hasOwn(body, "output")) return {
+		type: "tool_execution",
+		toolCallId: body.toolCallId,
+		decision: "use_output",
+		output: body.output,
+		actor
+	};
+	if (body.type === "timer") return {
+		type: "timer",
+		actor
+	};
+	if (body.type === "event" && typeof body.eventName === "string" && body.eventName.trim()) return {
+		type: "event",
+		eventName: body.eventName,
+		...hasOwn(body, "payload") ? { payload: body.payload } : {},
+		actor
+	};
+	throw badRequest("Invalid run resolution");
+}
+async function readJson(request) {
+	if (!request.headers.get("content-type")?.toLowerCase().includes(JSON_TYPE)) throw new HttpProtocolError(415, "UNSUPPORTED_MEDIA_TYPE", "Expected application/json");
+	let value;
+	try {
+		value = await request.json();
+	} catch {
+		throw badRequest("Request body must be valid JSON");
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw badRequest("Request body must be a JSON object");
+	return value;
+}
+function optionalId(value, name) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || !value.trim()) throw badRequest(`${name} must be a string`);
+	return value.trim();
+}
+function optionalReasoning(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || ![
+		"provider-default",
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	].includes(value)) throw badRequest("reasoning must be a valid effort");
+	return value;
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function jsonInit(method, body) {
+	return {
+		method,
+		headers: { "content-type": JSON_TYPE },
+		body: JSON.stringify(body)
+	};
+}
+function json(value, status = 200) {
+	return versioned(Response.json(value, {
+		status,
+		headers: { "content-type": JSON_TYPE }
+	}));
+}
+function versioned(response) {
+	response.headers.set(FEVEX_HTTP_PROTOCOL_VERSION_HEADER, "3");
+	return response;
+}
+async function assertResponse(response, contentType) {
+	const version = response.headers.get(FEVEX_HTTP_PROTOCOL_VERSION_HEADER);
+	if (version !== "3") throw new TypeError(`Unsupported Fevex HTTP protocol version "${version ?? "missing"}"`);
+	if (!response.ok) {
+		if (!response.headers.get("content-type")?.includes(PROBLEM_TYPE)) throw new TypeError(`Expected ${PROBLEM_TYPE} response`);
+		const value = await response.json().catch(() => void 0);
+		if (!isProblemDetails(value)) throw new TypeError("Invalid Fevex Problem Details response");
+		throw new FevexHttpError(value);
+	}
+	if (contentType && !response.headers.get("content-type")?.includes(contentType)) throw new TypeError(`Expected ${contentType} response`);
+}
+function isProblemDetails(value) {
+	if (!value || typeof value !== "object") return false;
+	const problem = value;
+	return typeof problem.type === "string" && typeof problem.title === "string" && typeof problem.status === "number" && typeof problem.code === "string" && (problem.detail === void 0 || typeof problem.detail === "string") && (problem.instance === void 0 || typeof problem.instance === "string");
+}
+var HttpProtocolError = class extends Error {
+	status;
+	code;
+	constructor(status, code, message) {
+		super(message);
+		this.status = status;
+		this.code = code;
+	}
+};
+function badRequest(message, code = "INVALID_REQUEST") {
+	return new HttpProtocolError(400, code, message);
+}
+function notFound(code, message) {
+	return new HttpProtocolError(404, code, message);
+}
+function problem(error, instance, onError) {
+	let status = 500;
+	let code = "INTERNAL_ERROR";
+	let title = "Internal Server Error";
+	let detail;
+	if (error instanceof HttpProtocolError) {
+		({status, code} = error);
+		title = error.message;
+		detail = error.message;
+	} else {
+		const runError = readFevexRunError(error);
+		if (runError) {
+			code = runError.code;
+			status = statusForRunErrorCode(runError.code);
+			title = titleForStatus(status);
+			detail = runError.message;
+		}
+	}
+	const value = {
+		type: `urn:fevex:problem:${code.toLowerCase()}`,
+		title,
+		status,
+		code,
+		...detail ? { detail } : {},
+		instance
+	};
+	if (status >= 500) try {
+		onError?.(error, value);
+	} catch {}
+	return versioned(new Response(JSON.stringify(value), {
+		status,
+		headers: { "content-type": PROBLEM_TYPE }
+	}));
+}
+function readFevexRunError(error) {
+	if (error instanceof FevexRunError) return error;
+	if (!error || typeof error !== "object") return void 0;
+	const value = error;
+	return typeof value.message === "string" && typeof value.code === "string" && FEVEX_RUN_ERROR_CODES.has(value.code) ? {
+		code: value.code,
+		message: value.message
+	} : void 0;
+}
+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;
+	return 409;
+}
+function titleForStatus(status) {
+	if (status === 404) return "Not Found";
+	if (status === 400) return "Bad Request";
+	if (status === 403) return "Forbidden";
+	return "Conflict";
+}
+function wait(ms, signal) {
+	return new Promise((resolve) => {
+		const timeout = setTimeout(finish, ms);
+		function finish() {
+			clearTimeout(timeout);
+			signal.removeEventListener("abort", finish);
+			resolve();
+		}
+		if (signal.aborted) finish();
+		else signal.addEventListener("abort", finish, { once: true });
+	});
+}
+//#endregion
+export { FEVEX_HTTP_PROTOCOL_VERSION, FEVEX_HTTP_PROTOCOL_VERSION_HEADER, FevexHttpError, createFevexHttpClient, createFevexHttpHandler };

package/dist/{index-ojCY3lwm.d.mts → index-B4PIkqOU.d.mts}

@@ -1,7 +1,8 @@
-import { f as RunId, l as JsonValue, s as JsonObject } from "./index-C_Zpr13f.mjs";
-import { ModelMetadata, ModelUsage } from "./models/index.mjs";
-import { y as SessionId } from "./index-DGWOGXzc.mjs";
-//#region src/observability/index.d.ts
+import { f as RunId, l as JsonValue, s as JsonObject } from "./types-CuoRx12Q.mjs";
+import { r as ModelMetadata, s as ModelUsage } from "./index-CTIwrVf9.mjs";
+import { M as SessionId } from "./index-Dx_LotWZ.mjs";
+//#region src/observability/trace.d.ts
+/** Final state represented by an exported run trace. */
 type TraceStatus = 'completed' | 'failed' | 'cancelled';
 type TraceSpanKind = 'model' | 'tool';
 type TraceContentKind = 'run.output' | 'model.output' | 'error.message';

package/dist/index-Bg9rr8Qe.d.mts

@@ -0,0 +1,50 @@
+import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
+import { o as ExecutionContext } from "./types-CuoRx12Q.mjs";
+import { n as AgentLimits } from "./index-Dx_LotWZ.mjs";
+import { t as WorkflowAgentResult } from "./index-DviHtsLo.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/teams/team.d.ts
+interface TeamMember {
+  agent: string;
+  role: string;
+  description?: string;
+}
+interface TeamLimits extends AgentLimits {
+  maxDelegations?: number;
+  maxParallel?: number;
+}
+interface TeamDelegation<TInput = unknown> {
+  agent: string;
+  task: TInput;
+  context?: ExecutionContext;
+  limits?: AgentLimits;
+  expectedOutput?: string;
+  constraints?: string[];
+}
+interface TeamHandoff<TInput = unknown> extends Omit<TeamDelegation<TInput>, 'agent'> {
+  from: string;
+  to: string;
+  reason: string;
+}
+type TeamTaskResult<TOutput = unknown> = WorkflowAgentResult<TOutput> & {
+  delegationId: string;
+  agentName: string;
+};
+interface TeamStep {
+  delegate<TInput = unknown, TOutput = unknown>(delegationId: string, delegation: TeamDelegation<TInput>): Promise<TeamTaskResult<TOutput>>;
+  handoff<TInput = unknown, TOutput = unknown>(delegationId: string, handoff: TeamHandoff<TInput>): Promise<TeamTaskResult<TOutput>>;
+  parallel<TTasks extends Record<string, () => Promise<unknown>>>(stepId: string, tasks: TTasks): Promise<{ [TKey in keyof TTasks]: Awaited<ReturnType<TTasks[TKey]>>; }>;
+}
+interface TeamDefinition<TInput = unknown, TOutput = unknown> {
+  name: string;
+  version?: string;
+  supervisor: string;
+  members: TeamMember[];
+  limits?: TeamLimits;
+  inputSchema?: StandardSchemaV1<unknown, TInput>;
+  outputSchema?: StandardSchemaV1<unknown, TOutput>;
+  run(team: TeamStep, input: TInput): TOutput | Promise<TOutput>;
+}
+declare function defineTeam<T extends TeamDefinition>(team: ExactDefinition<T, TeamDefinition>): T;
+//#endregion
+export { TeamMember as a, defineTeam as c, TeamLimits as i, TeamDelegation as n, TeamStep as o, TeamHandoff as r, TeamTaskResult as s, TeamDefinition as t };

package/dist/index-Bgcxgy66.d.mts

@@ -0,0 +1,82 @@
+import { 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-Dx_LotWZ.mjs";
+import { t as Fevex } from "./fevex-Ddyi6z6L.mjs";
+//#region src/channels/channel.d.ts
+interface ChannelMessage {
+  id: string;
+  deliveryId: string;
+  conversationId: string;
+  threadId?: string;
+  content: string;
+  actor?: ExecutionContext['actor'];
+  metadata?: JsonObject;
+}
+interface ChannelOutput {
+  deliveryId: string;
+  conversationId: string;
+  threadId?: string;
+  content: string;
+  metadata?: JsonObject;
+}
+interface ChannelContext {
+  signal?: AbortSignal;
+}
+interface ChannelAdapter<TInput = unknown, TOutput = unknown> {
+  name: string;
+  parse(input: TInput, context: ChannelContext): Promise<ChannelMessage | null>;
+  deliver(output: ChannelOutput, context: ChannelContext): Promise<TOutput>;
+  deliverElicitation?(request: ElicitationRequest, context: ChannelContext): Promise<TOutput>;
+}
+type ChannelEventType = 'channel.received' | 'channel.delivered' | 'channel.failed';
+type ChannelFailurePhase = 'parse' | 'run' | 'deliver';
+interface ChannelEventBase {
+  id: string;
+  timestamp: string;
+  adapter: string;
+  messageId?: string;
+  deliveryId?: string;
+  conversationId?: string;
+  threadId?: string;
+}
+type ChannelEvent = (ChannelEventBase & {
+  type: 'channel.received';
+  actor?: ExecutionContext['actor'];
+}) | (ChannelEventBase & {
+  type: 'channel.delivered';
+}) | (ChannelEventBase & {
+  type: 'channel.failed';
+  phase: ChannelFailurePhase;
+  error: string;
+});
+type ChannelRunEvent = ChannelEvent | AgentEvent;
+declare class ChannelError extends Error {
+  readonly code: string;
+  readonly safeMessage: string;
+  readonly name = "ChannelError";
+  constructor(code: string, safeMessage: string, options?: ErrorOptions);
+}
+interface ChannelRunOptions<TInput = unknown, TDelivery = unknown> {
+  fevex: Fevex;
+  adapter: ChannelAdapter<TInput, TDelivery>;
+  agentName: string;
+  resolveSessionId?: (message: ChannelMessage) => SessionId | undefined | Promise<SessionId | undefined>;
+  onEvent?: (event: ChannelEvent) => void;
+  signal?: AbortSignal;
+}
+type ChannelRunResult<TDelivery = unknown> = {
+  ignored: true;
+  events: ChannelRunEvent[];
+} | {
+  ignored: false;
+  message: ChannelMessage;
+  run: AgentRun;
+  output: ChannelOutput;
+  delivery: TDelivery;
+  events: ChannelRunEvent[];
+};
+//#endregion
+//#region src/channels/handle-channel-input.d.ts
+/** Parses one channel input, runs the configured agent, and delivers its output. */
+declare function handleChannelInput<TInput, TDelivery>(input: TInput, options: ChannelRunOptions<TInput, TDelivery>): Promise<ChannelRunResult<TDelivery>>;
+//#endregion
+export { ChannelEvent as a, ChannelMessage as c, ChannelRunOptions as d, ChannelRunResult as f, ChannelError as i, ChannelOutput as l, ChannelAdapter as n, ChannelEventType as o, ChannelContext as r, ChannelFailurePhase as s, handleChannelInput as t, ChannelRunEvent as u };

package/dist/index-CTIwrVf9.d.mts

@@ -0,0 +1,51 @@
+import { g as ToolSpec, i as AgentMessage, l as JsonValue, m as ToolCall, s as JsonObject } from "./types-CuoRx12Q.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';
+interface ModelUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+type ToolChoice = 'auto' | 'required' | 'none' | {
+  name: string;
+};
+interface ModelInput {
+  messages: AgentMessage[];
+  tools?: ToolSpec[];
+  toolChoice?: ToolChoice;
+  reasoning?: ReasoningEffort;
+  modelOptions?: Record<string, unknown>;
+  outputSchema?: JsonObject;
+  maxOutputTokens?: number;
+  providerState?: unknown;
+  signal?: AbortSignal;
+}
+interface ModelResult<TOutput = unknown> {
+  output?: TOutput;
+  toolCalls?: ToolCall[];
+  usage?: ModelUsage;
+  providerState?: unknown;
+}
+interface ModelMetadata {
+  provider?: string;
+  model?: string;
+}
+interface ModelGateway {
+  stream(input: ModelInput): AsyncIterable<ModelStreamEvent>;
+  metadata?: ModelMetadata;
+  stateCodec?: {
+    serialize(state: unknown): JsonValue;
+    restore(state: JsonValue): unknown;
+  };
+}
+type ModelStreamEvent<TOutput = unknown> = {
+  type: 'output.delta';
+  delta: string;
+} | {
+  type: 'completed';
+  result: ModelResult<TOutput>;
+};
+type ModelRef = string | ModelGateway;
+//#endregion
+export { ModelResult as a, ReasoningEffort as c, ModelRef as i, ToolChoice as l, ModelInput as n, ModelStreamEvent as o, ModelMetadata as r, ModelUsage as s, ModelGateway as t };