@junejs/server 1.0.0-dev.29 → 1.0.0-dev.42

package/dist/agent-compile.d.ts

@@ -1,6 +1,6 @@
 //#region src/agent-compile.d.ts
-declare const AGENT_MODULE_FILE = "_agent.gen.ts";
-type AgentDirScan = {
+export declare const AGENT_MODULE_FILE = "_agent.gen.ts";
+export type AgentDirScan = {
   dir: string;
   name: string;
   hasConfig: boolean;
@@ -21,13 +21,13 @@ type AgentDirScan = {
   }[];
   connections: string[];
 };
-declare function scanAgentDir(dir: string): AgentDirScan | null;
-type EmitOptions = {
+export declare function scanAgentDir(dir: string): AgentDirScan | null;
+export type EmitOptions = {
   tsExtensions?: boolean;
 };
-declare function emitAgentModule(scan: AgentDirScan, opts?: EmitOptions): string;
-declare function findAgentDir(root: string, dirName?: string): string | null;
-declare function generateAgentModule(dir: string, opts?: {
+export declare function emitAgentModule(scan: AgentDirScan, opts?: EmitOptions): string;
+export declare function findAgentDir(root: string, dirName?: string): string | null;
+export declare function generateAgentModule(dir: string, opts?: {
   check?: boolean;
 } & EmitOptions): {
   file: string;
@@ -35,5 +35,4 @@ declare function generateAgentModule(dir: string, opts?: {
   stale: boolean;
   written: boolean;
 } | null;
-//#endregion
-export { AGENT_MODULE_FILE, AgentDirScan, EmitOptions, emitAgentModule, findAgentDir, generateAgentModule, scanAgentDir };
+//#endregion

package/dist/agent-discover.d.ts

@@ -1,6 +1,5 @@
 import { AgentDefinition, AgentModule } from "@junejs/core/agent-config";
 //#region src/agent-discover.d.ts
-declare function discoverAgentModule(dir: string): Promise<AgentModule>;
-declare function discoverAgent(dir: string): Promise<AgentDefinition>;
-//#endregion
-export { discoverAgent, discoverAgentModule };
+export declare function discoverAgentModule(dir: string): Promise<AgentModule>;
+export declare function discoverAgent(dir: string): Promise<AgentDefinition>;
+//#endregion

package/dist/agent-durable.d.ts

@@ -1,31 +1,32 @@
 import { Channel, ChannelFactory } from "@junejs/core/agent-config";
-import { ChannelPolicy, InboundEvent, Model, Msg, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
+import { AuthorizeAnswer, ChannelPolicy, InboundEvent, InputAnnouncement, Model, Msg, NoteKind, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
 import { Connection } from "@junejs/core/connections";
 import { Resources } from "@junejs/core/resources";
 //#region src/agent-durable.d.ts
-type SqlStorageValue = ArrayBuffer | string | number | null;
-interface SqlStorageCursor<T extends Record<string, SqlStorageValue> = Record<string, SqlStorageValue>> {
+export type SqlStorageValue = ArrayBuffer | string | number | null;
+export interface SqlStorageCursor<T extends Record<string, SqlStorageValue> = Record<string, SqlStorageValue>> {
   toArray(): T[];
   one(): T;
 }
-interface SqlStorage {
+export interface SqlStorage {
   exec<T extends Record<string, SqlStorageValue> = Record<string, SqlStorageValue>>(query: string, ...bindings: unknown[]): SqlStorageCursor<T>;
 }
-interface DurableStorage {
+export interface DurableStorage {
   sql: SqlStorage;
   transactionSync<T>(fn: () => T): T;
+  setAlarm?(scheduledTime: number): unknown;
 }
-interface DurableObjectState {
+export interface DurableObjectState {
   storage: DurableStorage;
 }
-interface DurableObjectStub {
+export interface DurableObjectStub {
   fetch(request: Request): Promise<Response>;
 }
-interface DurableObjectNamespace {
+export interface DurableObjectNamespace {
   idFromName(name: string): unknown;
   get(id: unknown): DurableObjectStub;
 }
-declare class DoSessionStore implements SessionStore {
+export declare class DoSessionStore implements SessionStore {
   private readonly storage;
   constructor(storage: DurableStorage);
   private get sql();
@@ -40,10 +41,10 @@ declare class DoSessionStore implements SessionStore {
   getSessionKey(): string | undefined;
   setSessionKey(key: string): void;
   tx<T>(fn: () => T): T;
-  reset(): number;
+  reset(inTx?: () => void): number;
   unwrap<H = unknown>(): H;
 }
-type DoAgentDef = {
+export type DoAgentDef = {
   name?: string;
   model: Model;
   tools: Tool[];
@@ -60,8 +61,10 @@ type DoAgentDef = {
     phase?: TurnFailurePhase;
     step?: string;
   }) => void | Promise<void>;
+  authorizeAnswer?: AuthorizeAnswer;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
-declare class AgentDurableObject {
+export declare class AgentDurableObject {
   private session;
   private sessionKey;
   private readonly name;
@@ -77,11 +80,19 @@ declare class AgentDurableObject {
   private connectionsOpened;
   private readonly doEnv;
   private readonly services;
+  private readonly authorizeAnswer?;
+  private readonly onInputAnnouncement?;
+  private readonly storage;
+  private announceFailures;
   private resolveResources;
   private resolveConnections;
   private ready;
   constructor(state: DurableObjectState, def: DoAgentDef);
   private resolveSession;
+  alarm(): Promise<void>;
+  private armWatchdog;
+  private scheduleAlarm;
+  private deliverHeld;
   turn(input: {
     turnId?: string;
     userText: string;
@@ -98,6 +109,14 @@ declare class AgentDurableObject {
   }): Promise<{
     turnId: string;
   }>;
+  note(input: {
+    by: string;
+    kind: NoteKind;
+    text: string;
+    session?: string;
+  }): Promise<{
+    noteId: string;
+  }>;
   reset(opts?: {
     session?: string;
   }): Promise<{
@@ -107,20 +126,19 @@ declare class AgentDurableObject {
   transcript(): import("@junejs/core/agent-runtime").Turn[];
   fetch(req: Request): Promise<Response>;
 }
-declare function sseTurnFinalText(res: Response): Promise<string>;
-declare function sseTurnEvents(res: Response): AsyncIterable<TurnEvent>;
-declare const SESSION_HEADER = "x-june-session";
-declare function durableFetch(namespace: DurableObjectNamespace, agent: string, session: string, req: Request): Promise<Response>;
-declare function durableAgentSurface(getNamespace: () => DurableObjectNamespace | undefined, opts: {
+export declare function sseTurnFinalText(res: Response): Promise<string>;
+export declare function sseTurnEvents(res: Response): AsyncIterable<TurnEvent>;
+export declare const SESSION_HEADER = "x-june-session";
+export declare function durableFetch(namespace: DurableObjectNamespace, agent: string, session: string, req: Request): Promise<Response>;
+export declare function durableAgentSurface(getNamespace: () => DurableObjectNamespace | undefined, opts: {
   agentName: string;
   chatPath?: string;
 }): (req: Request) => Promise<Response | null>;
-declare function durableChannelSurface(getNamespace: () => DurableObjectNamespace | undefined, opts: {
+export declare function durableChannelSurface(getNamespace: () => DurableObjectNamespace | undefined, opts: {
   agentName: string;
   channels: (Channel | ChannelFactory)[];
   env: unknown;
   services?: (env: unknown) => unknown;
   waitUntil?: (p: Promise<unknown>) => void;
 }): (req: Request) => Promise<Response | null>;
-//#endregion
-export { AgentDurableObject, DoAgentDef, DoSessionStore, DurableObjectNamespace, DurableObjectState, DurableObjectStub, DurableStorage, SESSION_HEADER, SqlStorage, SqlStorageCursor, SqlStorageValue, durableAgentSurface, durableChannelSurface, durableFetch, sseTurnEvents, sseTurnFinalText };
+//#endregion

package/dist/agent-durable.js

@@ -2,7 +2,7 @@ import { observeTurnEvents } from "./turn-events.js";
 import { isolateLocal } from "./isolate-local.js";
 import { assertCoreRuntimeVersion } from "./core-version.js";
 import { DeliverUnsupportedError, actionToTool, channelDispatch, resolveChannel } from "@junejs/core/agent-config";
-import { AgentSession, ResumeAuthorizationError, withSystem } from "@junejs/core/agent-runtime";
+import { AgentSession, ResumeAuthorizationError, grantAnswer, withSystem } from "@junejs/core/agent-runtime";
 import { connectAll } from "@junejs/core/connections";
 import { ensureScope, runInScope } from "@junejs/db";
 //#region src/agent-durable.ts
@@ -54,7 +54,7 @@ var DoSessionStore = class {
 	tx(fn) {
 		return this.storage.transactionSync(fn);
 	}
-	reset() {
+	reset(inTx) {
 		return this.storage.transactionSync(() => {
 			const sql = this.sql;
 			sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
@@ -67,6 +67,7 @@ var DoSessionStore = class {
 			sql.exec("DELETE FROM agent_steps");
 			this.setStatus("new");
 			sql.exec("INSERT INTO agent_meta (k, v) VALUES ('generation', ?) ON CONFLICT(k) DO UPDATE SET v = ?", String(generation + 1), String(generation + 1));
+			inTx?.();
 			return generation;
 		});
 	}
@@ -107,6 +108,10 @@ var AgentDurableObject = class {
 	connectionsOpened;
 	doEnv;
 	services;
+	authorizeAnswer;
+	onInputAnnouncement;
+	storage;
+	announceFailures = 0;
 	resolveResources() {
 		return this.resourcesOpened ??= Promise.resolve(typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : this.resourcesInput ?? {});
 	}
@@ -136,8 +141,14 @@ var AgentDurableObject = class {
 		this.connectionsInput = def.connections;
 		this.doEnv = def.env;
 		this.services = def.services;
+		this.authorizeAnswer = def.authorizeAnswer;
+		this.onInputAnnouncement = def.onInputAnnouncement;
+		this.storage = state.storage;
 		const name = def.name ?? "agent";
 		const sink = new InProcEventSink();
+		sink.subscribe((e) => {
+			if (e.type === "turn.started") this.armWatchdog();
+		});
 		sink.subscribe((e) => {
 			if (e.type !== "turn.failed") return;
 			const defaultLog = () => console.error(`[june] agent "${name}" turn ${e.turnId} failed${e.step ? ` at ${e.step}` : ""}: ${e.error.stack ?? e.error.message}${e.error.causeChain?.length ? `\ncaused by: ${e.error.causeChain.join(" ← ")}` : ""}`);
@@ -191,8 +202,71 @@ var AgentDurableObject = class {
 		if (key !== void 0 && key !== "self" && stored === void 0) this.store.setSessionKey(key);
 		this.sessionKey = resolved;
 		this.session = new AgentSession(this.name, resolved, this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions);
+		this.session.onDequeue = (heldTurnId, held) => {
+			if (held.hostContext?.deliver && held.event) this.deliverHeld(this.session, heldTurnId, held.event);
+		};
+		const announce = this.onInputAnnouncement;
+		if (announce) {
+			this.session.onAnnounce = async (a) => {
+				await ensureScope();
+				const resources = await this.ready();
+				try {
+					await runInScope({
+						resources,
+						services: this.services
+					}, () => announce(a));
+				} catch (err) {
+					this.scheduleAlarm(Math.min(5e3 * 2 ** this.announceFailures, 3e5));
+					this.announceFailures++;
+					throw err;
+				}
+				this.announceFailures = 0;
+			};
+			this.session.flushAnnouncements();
+		}
 		return this.session;
 	}
+	async alarm() {
+		if (!this.onInputAnnouncement) return;
+		await this.resolveSession().flushAnnouncements();
+	}
+	armWatchdog() {
+		if (this.onInputAnnouncement) this.scheduleAlarm(6e4);
+	}
+	scheduleAlarm(inMs) {
+		const failed = (err) => console.error(`[june] agent "${this.name}": could not schedule the announcement alarm — delivery waits for the next announcement, turn or rebuild:`, err);
+		try {
+			Promise.resolve(this.storage.setAlarm?.(Date.now() + inMs)).catch(failed);
+		} catch (err) {
+			failed(err);
+		}
+	}
+	deliverHeld(session, turnId, event) {
+		const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for held turn ${turnId} failed:`, err);
+		try {
+			const channel = this.channels.find((c) => c.name === event.source);
+			if (!channel?.deliver) {
+				logRenderFailure(/* @__PURE__ */ new Error(`no deliver()-capable channel named "${event.source}" is wired into this DO — the held turn runs, but its reply is not rendered`));
+				return;
+			}
+			const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+			const events = { [Symbol.asyncIterator]: () => it };
+			const target = {
+				channelId: event.channelId,
+				threadId: event.threadId,
+				recipientUserId: event.user?.id,
+				recipientTeamId: event.teamId
+			};
+			this.ready().then((resources) => runInScope({
+				resources,
+				services: this.services
+			}, () => channel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
+				it.return?.();
+			});
+		} catch (err) {
+			logRenderFailure(err);
+		}
+	}
 	async turn(input) {
 		await ensureScope();
 		const resources = await this.ready();
@@ -211,8 +285,14 @@ var AgentDurableObject = class {
 			services: this.services
 		}, () => session.start(input));
 	}
+	note(input) {
+		const { session, ...note } = input;
+		return this.resolveSession(session).note(note);
+	}
 	reset(opts) {
-		return this.resolveSession(opts?.session).reset();
+		const session = this.resolveSession(opts?.session);
+		this.armWatchdog();
+		return session.reset();
 	}
 	transcript() {
 		if (this.session) return this.session.transcript();
@@ -223,10 +303,13 @@ var AgentDurableObject = class {
 		const url = new URL(req.url);
 		const key = req.headers.get("x-june-session") ?? void 0;
 		if (req.method === "POST" && url.pathname.endsWith("/turn")) {
-			const { userText, turnId, event, trigger } = await req.json();
+			const { userText, turnId, event, trigger, ifSuspended } = await req.json();
 			await ensureScope();
 			const replace = url.searchParams.get("replace") === "1";
 			const wantsDeliver = url.searchParams.get("deliver") === "1";
+			const detached = url.searchParams.get("detach") === "1";
+			if (ifSuspended === "queue" && !wantsDeliver && !detached) return Response.json({ error: `ifSuspended "queue" needs deliver=1 or detach=1: a held turn runs later, when no one is streaming it` }, { status: 400 });
+			if (ifSuspended === "queue" && replace) return Response.json({ error: `ifSuspended "queue" and replace=1 cannot be combined — replacing would drop held turns that were accepted` }, { status: 400 });
 			let deliverChannel;
 			if (wantsDeliver) {
 				if (!event?.channelId) return Response.json({ error: "deliver=1 needs an inbound event (event.channelId names the reply target)" }, { status: 400 });
@@ -238,6 +321,7 @@ var AgentDurableObject = class {
 			let started;
 			try {
 				session = this.resolveSession(key);
+				this.armWatchdog();
 				started = runInScope({
 					resources,
 					services: this.services
@@ -246,11 +330,17 @@ var AgentDurableObject = class {
 					turnId,
 					event,
 					trigger,
-					replace
+					replace,
+					ifSuspended,
+					hostContext: wantsDeliver ? { deliver: true } : void 0
 				}));
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
+			if (started.queued) return Response.json({
+				turnId: started.turnId,
+				queued: true
+			}, { status: 202 });
 			if (wantsDeliver) {
 				const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for turn ${started.turnId} failed:`, err);
 				try {
@@ -273,11 +363,11 @@ var AgentDurableObject = class {
 				}
 				return Response.json({ turnId: started.turnId }, { status: 202 });
 			}
-			if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
+			if (detached) return Response.json({ turnId: started.turnId }, { status: 202 });
 			return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
 		}
 		if (req.method === "POST" && url.pathname.endsWith("/resume")) {
-			const { turnId, inputId, input, by, source, target } = await req.json();
+			const { turnId, inputId, input, by, principal, source, target } = await req.json();
 			await ensureScope();
 			const wantsDeliver = url.searchParams.get("deliver") === "1";
 			let resumeChannel;
@@ -290,10 +380,33 @@ var AgentDurableObject = class {
 			let session;
 			try {
 				session = this.resolveSession(key);
+			} catch (err) {
+				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+			}
+			let granted;
+			try {
+				granted = await runInScope({
+					resources,
+					services: this.services
+				}, () => grantAnswer(session, {
+					turnId,
+					inputId,
+					by,
+					principal
+				}, this.authorizeAnswer));
+			} catch (err) {
+				console.error(`[june] agent "${this.name}": authorizeAnswer failed for input "${inputId}" of turn ${turnId}:`, err);
+				return Response.json({ error: `authorizeAnswer failed: ${err instanceof Error ? err.message : String(err)} — the answer was NOT applied` }, { status: 500 });
+			}
+			this.armWatchdog();
+			try {
 				runInScope({
 					resources,
 					services: this.services
-				}, () => session.resume(turnId, inputId, input, { by }));
+				}, () => session.resume(turnId, inputId, input, {
+					by,
+					granted
+				}));
 			} catch (err) {
 				const message = err instanceof Error ? err.message : String(err);
 				return Response.json({ error: message }, { status: err instanceof ResumeAuthorizationError ? 403 : 409 });
@@ -323,12 +436,33 @@ var AgentDurableObject = class {
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
+			this.armWatchdog();
 			try {
 				return Response.json(await session.reset());
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
 		}
+		if (req.method === "POST" && url.pathname.endsWith("/note")) {
+			let input;
+			try {
+				input = await req.json();
+			} catch {
+				return Response.json({ error: "note: the body must be JSON { by, kind, text }" }, { status: 400 });
+			}
+			let session;
+			try {
+				session = this.resolveSession(key);
+			} catch (err) {
+				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+			}
+			try {
+				return Response.json(await session.note(input));
+			} catch (err) {
+				if (err instanceof TypeError) return Response.json({ error: err.message }, { status: 400 });
+				throw err;
+			}
+		}
 		if (url.pathname.endsWith("/transcript")) {
 			if (key !== void 0) try {
 				return Response.json({ transcript: this.resolveSession(key).transcript() });
@@ -337,7 +471,7 @@ var AgentDurableObject = class {
 			}
 			return Response.json({ transcript: this.transcript() });
 		}
-		return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
+		return new Response("agent DO — POST /turn, POST /resume, POST /reset, POST /note, or GET /transcript", { status: 404 });
 	}
 };
 const SSE_HEADERS = {
@@ -466,7 +600,8 @@ function resolveServices(factory, env, agentName) {
 	return perAgent.get(agentName);
 }
 function durableChannelSurface(getNamespace, opts) {
-	return channelDispatch(opts.channels.map((c) => resolveChannel(c, opts.env)), {
+	const resolved = opts.channels.map((c) => resolveChannel(c, opts.env));
+	const ctx = {
 		agent: {
 			name: opts.agentName,
 			instructions: "",
@@ -552,7 +687,8 @@ function durableChannelSurface(getNamespace, opts) {
 			}
 			return await res.json();
 		}
-	});
+	};
+	return channelDispatch(resolved, ctx);
 }
 function serializeResume(o) {
 	try {
@@ -561,11 +697,20 @@ function serializeResume(o) {
 			inputId: o.inputId,
 			input: o.input,
 			by: o.by,
+			principal: o.principal,
 			source: o.source,
 			target: o.target
 		});
 	} catch (err) {
-		throw new Error(`resume: input is not JSON-serializable (${err.message}) — a resume answer must round-trip to the DO`);
+		const culprit = ["input", "principal"].find((field) => {
+			try {
+				JSON.stringify(o[field]);
+				return false;
+			} catch {
+				return true;
+			}
+		}) ?? "payload";
+		throw new Error(`resume: ${culprit} is not JSON-serializable (${err.message}) — a resume must round-trip to the DO`);
 	}
 }
 function serializeTurn(userText, o) {
@@ -573,7 +718,8 @@ function serializeTurn(userText, o) {
 		userText,
 		turnId: o?.turnId,
 		event: o?.event,
-		trigger: o?.trigger
+		trigger: o?.trigger,
+		ifSuspended: o?.ifSuspended
 	};
 	try {
 		return JSON.stringify(payload);

package/dist/agent-native.d.ts

@@ -1,44 +1,48 @@
 import { SyncSqlite } from "./sqlite-driver.js";
 import { AgentDefinition, ChannelContext } from "@junejs/core/agent-config";
-import { AgentSession, ChannelPolicy, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
+import { AgentSession, ChannelPolicy, InputAnnouncement, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
 //#region src/agent-native.d.ts
-type AgentDef = {
+export type AgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
   channelInstructions?: Record<string, string | ChannelPolicy>;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
-declare function toAgentDef(agent: AgentDefinition, model: Model): AgentDef;
-type NativeRuntimeOptions = {
+export declare function toAgentDef(agent: AgentDefinition, model: Model): AgentDef;
+export type NativeRuntimeOptions = {
   maxSessions?: number;
 };
-declare class NativeRuntime implements Runtime {
+export declare class NativeRuntime implements Runtime {
   private actors;
   private readonly agents;
   private readonly db;
+  private readonly announceRetry;
   private readonly maxSessions;
   constructor(agents: Record<string, AgentDef>, db: SyncSqlite, opts?: NativeRuntimeOptions);
   agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;
   get sessionCount(): number;
+  recoverAnnouncements(): void;
   private evictIdle;
 }
-declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string, opts?: NativeRuntimeOptions): Promise<NativeRuntime>;
-declare class MemoryRuntime implements Runtime {
+export declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string, opts?: NativeRuntimeOptions): Promise<NativeRuntime>;
+export declare class MemoryRuntime implements Runtime {
   private actors;
   private stores;
   private readonly agents;
+  private readonly announceRetry;
   constructor(agents: Record<string, AgentDef>);
   agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;
 }
-type AgentBackend = "native" | "memory" | "durable";
-declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
+export type AgentBackend = "native" | "memory" | "durable";
+export declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
   backend?: AgentBackend;
   path?: string;
   maxSessions?: number;
 }): Promise<Runtime>;
-declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
+export declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
   chatPath?: string;
   channels?: boolean;
   services?: unknown;
@@ -48,5 +52,4 @@ declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
   startAll: () => Promise<void>;
   ctx: ChannelContext;
 };
-//#endregion
-export { AgentBackend, AgentDef, MemoryRuntime, NativeRuntime, NativeRuntimeOptions, createAgentRuntime, createNativeRuntime, mountAgent, toAgentDef };
+//#endregion