@junejs/server 0.1.2-dev.7 → 0.1.2

package/dist/agent-durable.d.ts

@@ -1,5 +1,5 @@
 import { Channel, ChannelFactory } from "@junejs/core/agent-config";
-import { InboundEvent, Model, Msg, ProactiveTrigger, SessionStore, Tool, TurnEvent } from "@junejs/core/agent-runtime";
+import { Model, Msg, SessionStore, Tool } from "@junejs/core/agent-runtime";
 import { Resources } from "@junejs/core/resources";
 //#region src/agent-durable.d.ts
 type SqlStorageValue = ArrayBuffer | string | number | null;
@@ -30,14 +30,11 @@ declare class DoSessionStore implements SessionStore {
   private get sql();
   appendMessage(m: Msg): void;
   messages(): Msg[];
-  hasOpeningMessage(turnId: string): boolean;
+  hasUserTurn(turnId: string): boolean;
   getStep(id: string): unknown | undefined;
   putStep(id: string, output: unknown): void;
-  delStep(id: string): void;
   getStatus(): string;
   setStatus(s: string): void;
-  getSessionKey(): string | undefined;
-  setSessionKey(key: string): void;
   tx<T>(fn: () => T): T;
   unwrap<H = unknown>(): H;
 }
@@ -46,53 +43,21 @@ type DoAgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
-  channelInstructions?: Record<string, string>;
-  channels?: (Channel | ChannelFactory)[];
-  env?: unknown;
   resources?: Resources;
   services?: unknown;
-  onTurnError?: (failure: {
-    turnId: string;
-    error: {
-      message: string;
-    };
-  }) => void | Promise<void>;
 };
 declare class AgentDurableObject {
   private session;
-  private sessionKey;
-  private readonly name;
-  private readonly store;
-  private readonly sink;
-  private readonly model;
-  private readonly tools;
-  private readonly channelInstructions?;
   private readonly resources;
   private readonly services;
   constructor(state: DurableObjectState, def: DoAgentDef);
-  private resolveSession;
   turn(input: {
     turnId?: string;
     userText: string;
-    event?: InboundEvent;
-    trigger?: ProactiveTrigger;
-    session?: string;
   }): Promise<string>;
-  start(input: {
-    turnId?: string;
-    userText: string;
-    event?: InboundEvent;
-    trigger?: ProactiveTrigger;
-    session?: string;
-  }): Promise<{
-    turnId: string;
-  }>;
   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: {
   agentName: string;
@@ -102,8 +67,7 @@ declare function durableChannelSurface(getNamespace: () => DurableObjectNamespac
   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 };
+export { AgentDurableObject, DoAgentDef, DoSessionStore, DurableObjectNamespace, DurableObjectState, DurableObjectStub, DurableStorage, SqlStorage, SqlStorageCursor, SqlStorageValue, durableAgentSurface, durableChannelSurface, durableFetch };

package/dist/agent-durable.js

@@ -1,5 +1,5 @@
 import { channelDispatch, resolveChannel } from "@junejs/core/agent-config";
-import { AgentSession, ResumeAuthorizationError, withSystem } from "@junejs/core/agent-runtime";
+import { AgentSession, withSystem } from "@junejs/core/agent-runtime";
 import { ensureScope, runInScope } from "@junejs/db";
 //#region src/agent-durable.ts
 var DoSessionStore = class {
@@ -20,8 +20,8 @@ var DoSessionStore = class {
 	messages() {
 		return this.sql.exec("SELECT body FROM agent_messages ORDER BY seq").toArray().map((r) => JSON.parse(r.body));
 	}
-	hasOpeningMessage(turnId) {
-		return this.messages().some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId);
+	hasUserTurn(turnId) {
+		return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
 	}
 	getStep(id) {
 		const rows = this.sql.exec("SELECT output FROM agent_steps WHERE id = ?", id).toArray();
@@ -30,9 +30,6 @@ var DoSessionStore = class {
 	putStep(id, output) {
 		this.sql.exec("INSERT INTO agent_steps (id, output) VALUES (?, ?)", id, JSON.stringify(output));
 	}
-	delStep(id) {
-		this.sql.exec("DELETE FROM agent_steps WHERE id = ?", id);
-	}
 	getStatus() {
 		const rows = this.sql.exec("SELECT v FROM agent_meta WHERE k = 'status'").toArray();
 		return rows.length ? rows[0].v : "new";
@@ -40,13 +37,6 @@ var DoSessionStore = class {
 	setStatus(s) {
 		this.sql.exec("INSERT INTO agent_meta (k, v) VALUES ('status', ?) ON CONFLICT(k) DO UPDATE SET v = ?", s, s);
 	}
-	getSessionKey() {
-		const rows = this.sql.exec("SELECT v FROM agent_meta WHERE k = 'session_key'").toArray();
-		return rows.length ? rows[0].v : void 0;
-	}
-	setSessionKey(key) {
-		this.sql.exec("INSERT INTO agent_meta (k, v) VALUES ('session_key', ?) ON CONFLICT(k) DO UPDATE SET v = ?", key, key);
-	}
 	tx(fn) {
 		return this.storage.transactionSync(fn);
 	}
@@ -54,12 +44,12 @@ var DoSessionStore = class {
 		return this.sql;
 	}
 };
-var InProcEventSink = class {
+var InProcBroadcaster = class {
 	subs = /* @__PURE__ */ new Set();
-	emit(e) {
+	publish(turnId) {
 		this.subs.forEach((cb) => {
 			try {
-				cb(e);
+				cb(turnId);
 			} catch {}
 		});
 	}
@@ -73,13 +63,6 @@ const crossDoUnsupported = { session() {
 } };
 var AgentDurableObject = class {
 	session;
-	sessionKey;
-	name;
-	store;
-	sink;
-	model;
-	tools;
-	channelInstructions;
 	resources;
 	services;
 	constructor(state, def) {
@@ -87,218 +70,33 @@ var AgentDurableObject = class {
 		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
 		this.resources = def.resources ?? {};
 		this.services = def.services;
-		const name = def.name ?? "agent";
-		const sink = new InProcEventSink();
-		sink.subscribe((e) => {
-			if (e.type !== "turn.failed") return;
-			const defaultLog = () => console.error(`[june] agent "${name}" turn ${e.turnId} failed: ${e.error.message}`);
-			if (def.onTurnError) try {
-				const out = def.onTurnError({
-					turnId: e.turnId,
-					error: e.error
-				});
-				if (out && typeof out.then === "function") out.then(void 0, (hookErr) => {
-					console.error(`[june] agent "${name}": onTurnError hook rejected:`, hookErr);
-					defaultLog();
-				});
-				return;
-			} catch (hookErr) {
-				console.error(`[june] agent "${name}": onTurnError hook threw:`, hookErr);
-			}
-			defaultLog();
-		});
-		const channelTools = (def.channels ?? []).flatMap((c) => resolveChannel(c, def.env).tools?.() ?? []);
-		const tools = [...def.tools];
-		const seen = new Set(tools.map((t) => t.spec.name));
-		for (const t of channelTools) {
-			if (seen.has(t.spec.name)) throw new Error(`AgentDurableObject(${def.name ?? "agent"}): duplicate tool name "${t.spec.name}" from a channel — rename so dispatch is unambiguous.`);
-			seen.add(t.spec.name);
-			tools.push(t);
-		}
-		this.name = name;
-		this.store = store;
-		this.sink = sink;
-		this.model = model;
-		this.tools = tools;
-		this.channelInstructions = def.channelInstructions;
-	}
-	resolveSession(key) {
-		if (key !== void 0) assertSessionKey(key);
-		if (this.session) {
-			if (key !== void 0 && this.sessionKey !== key) throw new Error(this.sessionKey === "self" ? `agent "${this.name}": request session "${key}" arrived, but this session is bound to the placeholder "self" (first used without a real key) — carry the key on every path (route through durableFetch, or pass turn({ session }) on the direct API)` : `agent "${this.name}": request session "${key}" does not match this object's session "${this.sessionKey}" — one DO is one session; address each session by its own key (durableFetch, or turn({ session }) on the direct API)`);
-			return this.session;
-		}
-		const stored = this.store.getSessionKey();
-		if (key !== void 0 && stored !== void 0 && key !== stored) throw new Error(`agent "${this.name}": request session "${key}" does not match this object's session "${stored}" — one DO is one session; address each session by its own key (durableFetch, or turn({ session }) on the direct API)`);
-		const resolved = key ?? stored ?? "self";
-		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);
-		return this.session;
+		this.session = new AgentSession(def.name ?? "agent", "self", store, new InProcBroadcaster(), model, def.tools, crossDoUnsupported);
 	}
 	async turn(input) {
 		await ensureScope();
-		const session = this.resolveSession(input.session);
 		return runInScope({
 			resources: this.resources,
 			services: this.services
-		}, () => session.turn(input));
-	}
-	async start(input) {
-		await ensureScope();
-		const session = this.resolveSession(input.session);
-		return runInScope({
-			resources: this.resources,
-			services: this.services
-		}, () => session.start(input));
+		}, () => this.session.turn(input));
 	}
 	transcript() {
-		if (this.session) return this.session.transcript();
-		if (this.store.getSessionKey() !== void 0) return this.resolveSession().transcript();
-		return new AgentSession(this.name, "self", this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions).transcript();
+		return this.session.transcript();
 	}
 	async fetch(req) {
 		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();
-			await ensureScope();
-			let session;
-			let started;
-			try {
-				session = this.resolveSession(key);
-				started = runInScope({
-					resources: this.resources,
-					services: this.services
-				}, () => session.start({
-					userText,
-					turnId,
-					event,
-					trigger
-				}));
-			} catch (err) {
-				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
-			}
-			if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
-			return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
+			const { userText, turnId } = await req.json();
+			return Response.json({ text: await this.turn({
+				userText,
+				turnId
+			}) });
 		}
-		if (req.method === "POST" && url.pathname.endsWith("/resume")) {
-			const { turnId, inputId, input, by } = await req.json();
-			await ensureScope();
-			let session;
-			try {
-				session = this.resolveSession(key);
-				runInScope({
-					resources: this.resources,
-					services: this.services
-				}, () => session.resume(turnId, inputId, input, { by }));
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				return Response.json({ error: message }, { status: err instanceof ResumeAuthorizationError ? 403 : 409 });
-			}
-			return new Response(sseTurnStream(session, turnId), { headers: SSE_HEADERS });
-		}
-		if (url.pathname.endsWith("/transcript")) {
-			if (key !== void 0) try {
-				return Response.json({ transcript: this.resolveSession(key).transcript() });
-			} catch (err) {
-				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
-			}
-			return Response.json({ transcript: this.transcript() });
-		}
-		return new Response("agent DO — POST /turn, POST /resume, or GET /transcript", { status: 404 });
+		if (url.pathname.endsWith("/transcript")) return Response.json({ transcript: this.transcript() });
+		return new Response("agent DO — POST /turn or GET /transcript", { status: 404 });
 	}
 };
-const SSE_HEADERS = {
-	"content-type": "text/event-stream",
-	"cache-control": "no-store"
-};
-function sseTurnStream(session, turnId) {
-	const enc = new TextEncoder();
-	let unsub;
-	let heartbeat;
-	const stop = () => {
-		unsub?.();
-		clearInterval(heartbeat);
-	};
-	return new ReadableStream({
-		start(controller) {
-			heartbeat = setInterval(() => {
-				try {
-					controller.enqueue(enc.encode(":hb\n\n"));
-				} catch {
-					clearInterval(heartbeat);
-				}
-			}, 2e4);
-			unsub = session.observe((e) => {
-				controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
-				if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "input.requested") {
-					stop();
-					controller.close();
-				}
-			}, { turnId });
-		},
-		cancel() {
-			stop();
-		}
-	});
-}
-async function sseTurnFinalText(res) {
-	const ct = res.headers.get("content-type") ?? "";
-	if (!res.body || !ct.includes("text/event-stream")) {
-		const detail = res.body ? (await res.text()).slice(0, 200) : "no body";
-		throw new Error(`turn stream: expected an SSE response, got ${ct || "no content-type"} (status ${res.status}): ${detail}`);
-	}
-	const reader = res.body.getReader();
-	const dec = new TextDecoder();
-	let buf = "";
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (value) buf += dec.decode(value, { stream: true });
-		let i;
-		while ((i = buf.indexOf("\n\n")) >= 0) {
-			const line = buf.slice(0, i).split("\n").find((l) => l.startsWith("data:"));
-			buf = buf.slice(i + 2);
-			if (!line) continue;
-			const e = JSON.parse(line.slice(5).trim());
-			if (e.type === "turn.completed") return e.text;
-			if (e.type === "turn.failed") throw new Error(e.error.message);
-		}
-		if (done) break;
-	}
-	throw new Error("turn stream ended without a terminal event");
-}
-async function* sseTurnEvents(res) {
-	const ct = res.headers.get("content-type") ?? "";
-	if (!res.body || !ct.includes("text/event-stream")) {
-		const detail = res.body ? (await res.text()).slice(0, 200) : "no body";
-		throw new Error(`turn stream: expected an SSE response, got ${ct || "no content-type"} (status ${res.status}): ${detail}`);
-	}
-	const reader = res.body.getReader();
-	const dec = new TextDecoder();
-	let buf = "";
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (value) buf += dec.decode(value, { stream: true });
-		let i;
-		while ((i = buf.indexOf("\n\n")) >= 0) {
-			const line = buf.slice(0, i).split("\n").find((l) => l.startsWith("data:"));
-			buf = buf.slice(i + 2);
-			if (line) yield JSON.parse(line.slice(5).trim());
-		}
-		if (done) break;
-	}
-}
-const SESSION_HEADER = "x-june-session";
-const SESSION_KEY_RE = /^[\x20-\x7E]+$/;
-function assertSessionKey(session) {
-	if (typeof session !== "string" || !SESSION_KEY_RE.test(session)) throw new Error(`invalid session key ${JSON.stringify(session)} — a session key must be a non-empty printable-ASCII string (it rides an HTTP header and the DO name)`);
-}
 function durableFetch(namespace, agent, session, req) {
-	assertSessionKey(session);
-	const headers = new Headers(req.headers);
-	headers.set(SESSION_HEADER, session);
-	return namespace.get(namespace.idFromName(`${agent}:${session}`)).fetch(new Request(req, { headers }));
+	return namespace.get(namespace.idFromName(`${agent}:${session}`)).fetch(req);
 }
 function durableAgentSurface(getNamespace, opts) {
 	const chatPath = opts.chatPath ?? "/message";
@@ -308,17 +106,10 @@ function durableAgentSurface(getNamespace, opts) {
 		const namespace = getNamespace();
 		if (!namespace) return null;
 		const { message, session } = await req.json();
-		if (session !== void 0) try {
-			assertSessionKey(session);
-		} catch (err) {
-			return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 400 });
-		}
-		const res = await durableFetch(namespace, opts.agentName, session ?? "default", new Request("https://do/turn", {
+		return durableFetch(namespace, opts.agentName, session ?? "default", new Request("https://do/turn", {
 			method: "POST",
 			body: JSON.stringify({ userText: message })
 		}));
-		if (req.headers.get("accept")?.includes("text/event-stream")) return res;
-		return Response.json({ text: await sseTurnFinalText(res) });
 	};
 }
 function durableChannelSurface(getNamespace, opts) {
@@ -331,78 +122,20 @@ function durableChannelSurface(getNamespace, opts) {
 			channels: [],
 			connections: []
 		},
-		services: opts.services?.(opts.env),
 		waitUntil: opts.waitUntil,
 		run: async (message, o) => {
 			const namespace = getNamespace();
 			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			return sseTurnFinalText(await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn", {
+			const { text } = await (await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn", {
 				method: "POST",
-				body: serializeTurn(message, o)
-			})));
-		},
-		runDetached: async (message, o) => {
-			const namespace = getNamespace();
-			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			const res = await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn?detach=1", {
-				method: "POST",
-				body: serializeTurn(message, o)
-			}));
-			if (res.status !== 202) {
-				const detail = (await res.text()).slice(0, 200);
-				throw new Error(`runDetached: turn was not accepted (status ${res.status}): ${detail}`);
-			}
-			return await res.json();
-		},
-		runStream: async function* (message, o) {
-			const namespace = getNamespace();
-			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			yield* sseTurnEvents(await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn", {
-				method: "POST",
-				body: serializeTurn(message, o)
-			})));
-		},
-		resumeStream: async function* (o) {
-			const namespace = getNamespace();
-			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			yield* sseTurnEvents(await durableFetch(namespace, opts.agentName, o.session ?? "default", new Request("https://do/resume", {
-				method: "POST",
-				body: serializeResume(o)
-			})));
+				body: JSON.stringify({
+					userText: message,
+					turnId: o?.turnId
+				})
+			}))).json();
+			return text;
 		}
 	});
 }
-function serializeResume(o) {
-	try {
-		return JSON.stringify({
-			turnId: o.turnId,
-			inputId: o.inputId,
-			input: o.input,
-			by: o.by
-		});
-	} catch (err) {
-		throw new Error(`resumeStream: input is not JSON-serializable (${err.message}) — a resume answer must round-trip to the DO`);
-	}
-}
-function serializeTurn(userText, o) {
-	const payload = {
-		userText,
-		turnId: o?.turnId,
-		event: o?.event,
-		trigger: o?.trigger
-	};
-	try {
-		return JSON.stringify(payload);
-	} catch {
-		const event = o?.event ? {
-			...o.event,
-			raw: void 0
-		} : void 0;
-		return JSON.stringify({
-			...payload,
-			event
-		});
-	}
-}
 //#endregion
-export { AgentDurableObject, DoSessionStore, SESSION_HEADER, durableAgentSurface, durableChannelSurface, durableFetch, sseTurnEvents, sseTurnFinalText };
+export { AgentDurableObject, DoSessionStore, durableAgentSurface, durableChannelSurface, durableFetch };

package/dist/agent-native.d.ts

@@ -6,7 +6,6 @@ type AgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
-  channelInstructions?: Record<string, string>;
 };
 declare class NativeRuntime implements Runtime {
   private actors;
@@ -31,7 +30,6 @@ declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
 declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
   chatPath?: string;
   channels?: boolean;
-  services?: unknown;
 }): {
   surface: (req: Request) => Promise<Response | null>;
   fetch: (req: Request) => Promise<Response | null>;

package/dist/agent-native.js

@@ -20,8 +20,8 @@ var SqliteSessionStore = class {
 	messages() {
 		return this.db.query("SELECT body FROM agent_messages WHERE session_id = ? ORDER BY seq").all(this.sid).map((r) => JSON.parse(r.body));
 	}
-	hasOpeningMessage(turnId) {
-		return this.messages().some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId);
+	hasUserTurn(turnId) {
+		return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
 	}
 	getStep(id) {
 		const r = this.db.query("SELECT output FROM agent_steps WHERE session_id = ? AND id = ?").get(this.sid, id);
@@ -30,9 +30,6 @@ var SqliteSessionStore = class {
 	putStep(id, output) {
 		this.db.query("INSERT INTO agent_steps (session_id, id, output) VALUES (?, ?, ?)").run(this.sid, id, JSON.stringify(output));
 	}
-	delStep(id) {
-		this.db.query("DELETE FROM agent_steps WHERE session_id = ? AND id = ?").run(this.sid, id);
-	}
 	getStatus() {
 		return this.db.query("SELECT status FROM agent_sessions WHERE session_id = ?").get(this.sid)?.status ?? "new";
 	}
@@ -54,12 +51,12 @@ var SqliteSessionStore = class {
 		return this.db;
 	}
 };
-var InProcEventSink = class {
+var InProcBroadcaster = class {
 	subs = /* @__PURE__ */ new Set();
-	emit(e) {
+	publish(turnId) {
 		this.subs.forEach((cb) => {
 			try {
-				cb(e);
+				cb(turnId);
 			} catch {}
 		});
 	}
@@ -84,7 +81,7 @@ var NativeRuntime = class {
 			const def = this.agents[agent];
 			if (!def) throw new Error(`unknown agent: ${agent}`);
 			const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-			a = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), new InProcEventSink(), model, def.tools, this, def.channelInstructions);
+			a = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), new InProcBroadcaster(), model, def.tools, this);
 			this.actors.set(key, a);
 		}
 		return a;
@@ -103,8 +100,8 @@ var MemorySessionStore = class {
 	messages() {
 		return this.msgs.slice();
 	}
-	hasOpeningMessage(turnId) {
-		return this.msgs.some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId);
+	hasUserTurn(turnId) {
+		return this.msgs.some((m) => m.role === "user" && m.turnId === turnId);
 	}
 	getStep(id) {
 		return this.steps.has(id) ? this.steps.get(id) : void 0;
@@ -112,9 +109,6 @@ var MemorySessionStore = class {
 	putStep(id, output) {
 		this.steps.set(id, output);
 	}
-	delStep(id) {
-		this.steps.delete(id);
-	}
 	getStatus() {
 		return this.status;
 	}
@@ -141,7 +135,7 @@ var MemoryRuntime = class {
 			if (!def) throw new Error(`unknown agent: ${agent}`);
 			const store = new MemorySessionStore();
 			this.stores.set(key, store);
-			a = new AgentSession(agent, id, store, new InProcEventSink(), def.model, def.tools, this);
+			a = new AgentSession(agent, id, store, new InProcBroadcaster(), def.model, def.tools, this);
 			this.actors.set(key, a);
 		}
 		return a;
@@ -158,18 +152,9 @@ function mountAgent(agent, runtime, opts = {}) {
 	const channelsOn = opts.channels ?? true;
 	const ctx = {
 		agent,
-		services: opts.services,
 		run: (message, o) => runtime.session(agent.name, o?.session ?? "default").turn({
 			turnId: o?.turnId,
-			userText: message,
-			event: o?.event,
-			trigger: o?.trigger
-		}),
-		runDetached: async (message, o) => runtime.session(agent.name, o?.session ?? "default").start({
-			turnId: o?.turnId,
-			userText: message,
-			event: o?.event,
-			trigger: o?.trigger
+			userText: message
 		})
 	};
 	const channels = channelFetch(agent, ctx);

package/dist/worker.js

@@ -159,7 +159,7 @@ function withAssets(pipeline, opts = {}) {
 				});
 			}
 		}
-		if (assets) {
+		if (assets && (request.method === "GET" || request.method === "HEAD")) {
 			const a = await assets.fetch(request);
 			if (a.status !== 404) {
 				const ct = a.headers.get("content-type") ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.1.2-dev.7",
+  "version": "0.1.2",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -125,8 +125,8 @@
     "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/core": ">=0.1.1-dev.14",
-    "@junejs/db": ">=0.0.34-dev.0",
+    "@junejs/core": ">=0.1.0",
+    "@junejs/db": ">=0.0.33",
     "@momiji-rs/sparkdown": "^0.0.4",
     "lightningcss": "^1.27.0",
     "oxc-parser": "^0.137.0",

package/src/agent-durable.ts

@@ -17,16 +17,12 @@
 
 import {
   AgentSession,
-  ResumeAuthorizationError,
   withSystem,
-  type EventSink,
-  type TurnEvent,
+  type Broadcaster,
   type Model,
   type Msg,
   type Runtime,
-  type InboundEvent,
   type SessionStore,
-  type ProactiveTrigger,
   type Tool,
 } from "@junejs/core/agent-runtime";
 import type { Resources } from "@junejs/core/resources";
@@ -97,8 +93,8 @@ export class DoSessionStore implements SessionStore {
   messages(): Msg[] {
     return this.sql.exec<{ body: string }>("SELECT body FROM agent_messages ORDER BY seq").toArray().map((r) => JSON.parse(r.body));
   }
-  hasOpeningMessage(turnId: string): boolean {
-    return this.messages().some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId);
+  hasUserTurn(turnId: string): boolean {
+    return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
   }
   getStep(id: string): unknown | undefined {
     const rows = this.sql.exec<{ output: string }>("SELECT output FROM agent_steps WHERE id = ?", id).toArray();
@@ -107,9 +103,6 @@ export class DoSessionStore implements SessionStore {
   putStep(id: string, output: unknown) {
     this.sql.exec("INSERT INTO agent_steps (id, output) VALUES (?, ?)", id, JSON.stringify(output));
   }
-  delStep(id: string) {
-    this.sql.exec("DELETE FROM agent_steps WHERE id = ?", id);
-  }
   getStatus(): string {
     const rows = this.sql.exec<{ v: string }>("SELECT v FROM agent_meta WHERE k = 'status'").toArray();
     return rows.length ? rows[0]!.v : "new";
@@ -117,17 +110,6 @@ export class DoSessionStore implements SessionStore {
   setStatus(s: string) {
     this.sql.exec("INSERT INTO agent_meta (k, v) VALUES ('status', ?) ON CONFLICT(k) DO UPDATE SET v = ?", s, s);
   }
-  // The externally-assigned session key (#75). A DO cannot read its own idFromName
-  // name, so the key arrives on the first routed request and is persisted here —
-  // surviving hibernation/eviction, where the constructor re-runs with no request
-  // in hand. Not part of core's SessionStore contract: only the DO seam needs it.
-  getSessionKey(): string | undefined {
-    const rows = this.sql.exec<{ v: string }>("SELECT v FROM agent_meta WHERE k = 'session_key'").toArray();
-    return rows.length ? rows[0]!.v : undefined;
-  }
-  setSessionKey(key: string) {
-    this.sql.exec("INSERT INTO agent_meta (k, v) VALUES ('session_key', ?) ON CONFLICT(k) DO UPDATE SET v = ?", key, key);
-  }
   tx<T>(fn: () => T): T {
     return this.storage.transactionSync(fn);
   }
@@ -136,10 +118,10 @@ export class DoSessionStore implements SessionStore {
   }
 }
 
-class InProcEventSink implements EventSink {
-  private subs = new Set<(e: TurnEvent) => void>();
-  emit(e: TurnEvent) { this.subs.forEach((cb) => { try { cb(e); } catch { /* a bad subscriber must not break emit */ } }); }
-  subscribe(cb: (e: TurnEvent) => void): () => void { this.subs.add(cb); return () => this.subs.delete(cb); }
+class InProcBroadcaster implements Broadcaster {
+  private subs = new Set<(t: string) => void>();
+  publish(turnId: string) { this.subs.forEach((cb) => { try { cb(turnId); } catch { /* a bad subscriber must not break publish */ } }); }
+  subscribe(cb: (t: string) => void): () => void { this.subs.add(cb); return () => this.subs.delete(cb); }
 }
 
 // A DO can't run in-process subagents; a subagent there is a sibling DO (cross-DO
@@ -170,26 +152,8 @@ export type DoAgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
-  // Per-channel-source system overlays (see AgentDefinition.channelInstructions) — the
-  // shared agent branches by real inbound source, no userText marker.
-  channelInstructions?: Record<string, string>;
-  // Channels whose CAPABILITY tools should be available to this session's turns. Their
-  // tools are built HERE, in the DO isolate, from `env` — because a channel's tool `run`
-  // is a closure (over the bot token, etc.) that can't cross the worker→DO RPC. This is
-  // the edge equivalent of defineAgent merging channel.tools() on native: pass the same
-  // channel factories you mount on the worker, plus this DO's env.
-  channels?: (Channel | ChannelFactory)[];
-  env?: unknown;
   resources?: Resources;
   services?: unknown;
-  // Called on every turn.failed for this session — the app's seam for routing turn
-  // failures to its own telemetry (Sentry, a ledger, …). Providing it REPLACES the
-  // default console.error; if the hook throws (or an async hook rejects), the default
-  // log fires anyway (both errors), so a failure is never silent. It happens to run
-  // inside the failed turn's request scope today (turn.failed is emitted mid-turn and
-  // ALS propagates), but that is NOT contract — don't rely on ambient db/services;
-  // close over what you need.
-  onTurnError?: (failure: { turnId: string; error: { message: string } }) => void | Promise<void>;
 };
 
 // The agent runtime INSIDE a Durable Object. A plain class (constructor takes the
@@ -207,20 +171,7 @@ export type DoAgentDef = {
 //     fetch(req) { return this.agent.fetch(req); }
 //   }
 export class AgentDurableObject {
-  // The AgentSession is constructed LAZILY (#75): the DO is keyed externally by
-  // idFromName(`${agent}:${session}`) but cannot read its own name, so the true
-  // session key only exists on a routed request (the SESSION_HEADER durableFetch
-  // sets). First keyed request wins and persists the key (agent_meta) so it
-  // survives hibernation; key-less paths fall back to the persisted key, then
-  // "self" (the pre-#75 behavior, kept for backward compatibility).
-  private session: AgentSession | undefined;
-  private sessionKey: string | undefined;
-  private readonly name: string;
-  private readonly store: DoSessionStore;
-  private readonly sink: InProcEventSink;
-  private readonly model: Model;
-  private readonly tools: Tool[];
-  private readonly channelInstructions?: Record<string, string>;
+  private session: AgentSession;
   // Built from the DO's env in the constructor (this isolate), shared across turns —
   // env is stable per isolate, like bindWorkerResources memoizes per worker isolate.
   private readonly resources: Resources;
@@ -230,94 +181,7 @@ export class AgentDurableObject {
     const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
     this.resources = def.resources ?? {};
     this.services = def.services;
-    const name = def.name ?? "agent";
-    // Failure observability (#76): a turn that dies after the fast-ACK has no other
-    // observable surface on the edge — the webhook already 200'd and runBackground
-    // swallows the rejection unless the channel wired onError. Subscribing HERE (the
-    // session sink) covers every turn path — turn(), /turn, /resume — with one seam.
-    // Default: console.error, which wrangler tail surfaces. An app onTurnError takes
-    // over reporting; if IT throws, fall back to the default so nothing goes silent.
-    // (InProcEventSink already guards emit against a throwing subscriber.)
-    const sink = new InProcEventSink();
-    sink.subscribe((e) => {
-      if (e.type !== "turn.failed") return;
-      const defaultLog = () => console.error(`[june] agent "${name}" turn ${e.turnId} failed: ${e.error.message}`);
-      if (def.onTurnError) {
-        try {
-          const out = def.onTurnError({ turnId: e.turnId, error: e.error });
-          // An async hook (e.g. `await sendToSentry(...)`) types as void but returns a
-          // Promise — a rejection there must hit the same fallback as a sync throw, or
-          // the failure goes silent again (plus an unhandled rejection). No waitUntil
-          // keeper is needed here: unlike a Worker, a DO stays active while it has
-          // pending work/IO, and DurableObjectState.waitUntil is documented as a no-op —
-          // this .then subscription is what retains the promise.
-          if (out && typeof (out as Promise<void>).then === "function") {
-            (out as Promise<void>).then(undefined, (hookErr) => {
-              console.error(`[june] agent "${name}": onTurnError hook rejected:`, hookErr);
-              defaultLog();
-            });
-          }
-          return;
-        } catch (hookErr) {
-          console.error(`[june] agent "${name}": onTurnError hook threw:`, hookErr);
-        }
-      }
-      defaultLog();
-    });
-    // Merge the mounted channels' capability tools (built here from this DO's env, since a
-    // tool's `run` closure can't cross the RPC). The cross-channel source gate on each tool
-    // keeps a Slack tool inert during a Crisp turn, so merging all of them is safe.
-    const channelTools = (def.channels ?? []).flatMap((c) => resolveChannel(c, def.env).tools?.() ?? []);
-    const tools: Tool[] = [...def.tools];
-    const seen = new Set(tools.map((t) => t.spec.name));
-    for (const t of channelTools) {
-      if (seen.has(t.spec.name)) throw new Error(`AgentDurableObject(${def.name ?? "agent"}): duplicate tool name "${t.spec.name}" from a channel — rename so dispatch is unambiguous.`);
-      seen.add(t.spec.name);
-      tools.push(t);
-    }
-    this.name = name;
-    this.store = store;
-    this.sink = sink;
-    this.model = model;
-    this.tools = tools;
-    this.channelInstructions = def.channelInstructions;
-  }
-  // Resolve THE session for this DO: explicit key (from a routed request) → persisted
-  // key (a prior life learned it) → "self". A key that contradicts the persisted or
-  // live identity is a mis-route (or a key-less path was used first) — fail loudly:
-  // silently proceeding is exactly the per-conversation data corruption #75 hit.
-  private resolveSession(key?: string): AgentSession {
-    // Every entry point shares the session-key contract (turn({ session }) and hand-rolled
-    // SESSION_HEADER values included, not just durableFetch): an invalid key persisted here
-    // would bind an identity no routed request could ever address — an orphaned session.
-    if (key !== undefined) assertSessionKey(key);
-    // Live fast path — no storage read once the session exists: this method is the only
-    // writer of the persisted key, so within one life it cannot diverge from the live one.
-    if (this.session) {
-      if (key !== undefined && this.sessionKey !== key) {
-        throw new Error(
-          this.sessionKey === "self"
-            ? `agent "${this.name}": request session "${key}" arrived, but this session is bound to the placeholder "self" (first used without a real key) — carry the key on every path (route through durableFetch, or pass turn({ session }) on the direct API)`
-            : `agent "${this.name}": request session "${key}" does not match this object's session "${this.sessionKey}" — one DO is one session; address each session by its own key (durableFetch, or turn({ session }) on the direct API)`,
-        );
-      }
-      return this.session;
-    }
-    const stored = this.store.getSessionKey();
-    if (key !== undefined && stored !== undefined && key !== stored) {
-      throw new Error(`agent "${this.name}": request session "${key}" does not match this object's session "${stored}" — one DO is one session; address each session by its own key (durableFetch, or turn({ session }) on the direct API)`);
-    }
-    const resolved = key ?? stored ?? "self";
-    // "self" is deliberately NOT persisted — even when a caller passes it EXPLICITLY: it
-    // is a placeholder ("no identity externally assigned yet"), not an identity. Within
-    // one life a keyed request after a "self" binding is refused above — two concurrently
-    // active paths disagreeing is a live bug. But across eviction a keyed request ADOPTS
-    // the legacy transcript: that asymmetry IS the migration path from pre-keyed
-    // deployments, where a persisted "self" would 409 every keyed request forever.
-    if (key !== undefined && key !== "self" && stored === undefined) 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);
-    return this.session;
+    this.session = new AgentSession(def.name ?? "agent", "self", store, new InProcBroadcaster(), model, def.tools, crossDoUnsupported);
   }
   // Run the whole turn inside a request scope seeded from this DO's env, so ambient
   // `db`/`kv`/`blob` and `currentServices()` resolve inside a tool exactly as in a
@@ -326,205 +190,30 @@ export class AgentDurableObject {
   // Juno's batch-loader registry) can't leak across turns on a long-lived DO.
   // ensureScope() lazily wires node:async_hooks (workerd via nodejs_compat), as the
   // pipeline does; without it runInScope is a pass-through and ambient reads throw.
-  async turn(input: { turnId?: string; userText: string; event?: InboundEvent; trigger?: ProactiveTrigger; session?: string }): Promise<string> {
+  async turn(input: { turnId?: string; userText: string }): Promise<string> {
     await ensureScope();
-    const session = this.resolveSession(input.session);
-    return runInScope({ resources: this.resources, services: this.services }, () => session.turn(input));
+    return runInScope({ resources: this.resources, services: this.services }, () => this.session.turn(input));
   }
-  // Fire-and-forget for custom shells (#77): resolves once the turn is durably ACCEPTED;
-  // it then runs under the DO's own lifetime (a DO stays alive while it has pending
-  // work), not the caller's. No live consumer sees the result — failures surface via
-  // the default turn-failure log / onTurnError (#76).
-  async start(input: { turnId?: string; userText: string; event?: InboundEvent; trigger?: ProactiveTrigger; session?: string }): Promise<{ turnId: string }> {
-    await ensureScope();
-    const session = this.resolveSession(input.session);
-    return runInScope({ resources: this.resources, services: this.services }, () => session.start(input));
-  }
-  // Read-only: folds the durable log. When an identity exists (live, or persisted from a
-  // prior life) the session resolves and caches like any other path. Only a read on a
-  // NEVER-keyed object stays non-committal — caching there would bake "self" in as the
-  // identity and 409 a later keyed turn — so it folds through an ephemeral AgentSession.
   transcript() {
-    if (this.session) return this.session.transcript();
-    if (this.store.getSessionKey() !== undefined) return this.resolveSession().transcript();
-    return new AgentSession(this.name, "self", this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions).transcript();
+    return this.session.transcript();
   }
-  // Default HTTP surface: POST …/turn STREAMS the turn's TurnEvents as SSE (start the
-  // turn in-scope, then stream from the session sink); GET …/transcript reads the log.
-  // The app can call turn()/transcript() directly instead (turn() awaits the final text).
+  // Default HTTP surface: POST …/turn runs a durable turn; GET …/transcript reads
+  // the log. The app can call turn()/transcript() directly instead.
   async fetch(req: Request): Promise<Response> {
     const url = new URL(req.url);
-    // The session key durableFetch stamped on the routed request (#75); absent on a
-    // hand-rolled fetch → the pre-#75 "self" fallback keeps old callers working.
-    const key = req.headers.get(SESSION_HEADER) ?? undefined;
     if (req.method === "POST" && url.pathname.endsWith("/turn")) {
-      const { userText, turnId, event, trigger } = (await req.json()) as { userText: string; turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger };
-      await ensureScope();
-      // start() schedules the turn on the chain WITHIN the scope, so it runs with ambient
-      // db/services (ALS propagates to the .then continuation registered here); subscribing
-      // happens synchronously right after, before any event can emit.
-      let session: AgentSession;
-      let started: { turnId: string };
-      try {
-        session = this.resolveSession(key);
-        started = runInScope({ resources: this.resources, services: this.services }, () => session.start({ userText, turnId, event, trigger }));
-      } catch (err) {
-        // e.g. the session is suspended awaiting input, or the key mis-matches this
-        // object's identity — a client-resolvable conflict, not a crash
-        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
-      }
-      // DETACHED (#77): the turn is accepted — 202 now, no stream. It keeps running under
-      // this DO's lifetime (alive while work is pending), so its duration is no longer
-      // bounded by however long the CALLER can hold a connection (the edge waitUntil
-      // ceiling). Nobody consumes the result; failures surface via the #76 log/hook.
-      if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
-      return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
-    }
-    // Provide the input a suspended turn is waiting on and stream its continuation as SSE.
-    // NOTE: this default surface passes `by` straight from the body — the engine treats it as a
-    // VERIFIED identity, so the app must authenticate it upstream (e.g. take the user id from a
-    // signature-checked Slack interaction payload), never expose this endpoint raw to clients.
-    if (req.method === "POST" && url.pathname.endsWith("/resume")) {
-      const { turnId, inputId, input, by } = (await req.json()) as { turnId: string; inputId: string; input: unknown; by?: string };
-      await ensureScope();
-      let session: AgentSession;
-      try {
-        session = this.resolveSession(key);
-        runInScope({ resources: this.resources, services: this.services }, () => session.resume(turnId, inputId, input, { by }));
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        // 403: the resumer may not answer; 409: not suspended / wrong turn / wrong input id / key mismatch
-        return Response.json({ error: message }, { status: err instanceof ResumeAuthorizationError ? 403 : 409 });
-      }
-      return new Response(sseTurnStream(session, turnId), { headers: SSE_HEADERS });
-    }
-    if (url.pathname.endsWith("/transcript")) {
-      // A keyed read still conflict-checks (and may commit the key — it is authentic,
-      // idFromName routed it here); a key-less read stays non-committal via transcript().
-      if (key !== undefined) {
-        try {
-          return Response.json({ transcript: this.resolveSession(key).transcript() });
-        } catch (err) {
-          return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
-        }
-      }
-      return Response.json({ transcript: this.transcript() });
-    }
-    return new Response("agent DO — POST /turn, POST /resume, or GET /transcript", { status: 404 });
-  }
-}
-
-// ── SSE transport for the turn event stream (crosses the worker→DO isolate) ───
-// The DO streams a turn's TurnEvents as text/event-stream; the worker either pipes
-// that straight to a browser (live chat) or collapses it to the final text (channels).
-// no-store (not no-cache): an intermediary must NOT store chat/user content at all, and it
-// matches the repo's other SSE surface (dev-reload).
-const SSE_HEADERS = { "content-type": "text/event-stream", "cache-control": "no-store" };
-
-// A ReadableStream of SSE frames from a session's live event stream, scoped to one turn
-// and closed on its terminal event. Subscribes synchronously (no replay needed — we start
-// the turn then subscribe before any event can emit). A `:hb` comment heartbeat keeps the
-// connection alive across long model/tool gaps (a silent SSE stream gets culled by idle
-// timeouts on hosts/proxies) — cleared on terminal close and on cancel.
-function sseTurnStream(session: AgentSession, turnId: string): ReadableStream<Uint8Array> {
-  const enc = new TextEncoder();
-  let unsub: (() => void) | undefined;
-  let heartbeat: ReturnType<typeof setInterval> | undefined;
-  const stop = () => { unsub?.(); clearInterval(heartbeat); };
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      heartbeat = setInterval(() => {
-        try { controller.enqueue(enc.encode(":hb\n\n")); } catch { clearInterval(heartbeat); }
-      }, 20_000);
-      unsub = session.observe((e) => {
-        controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
-        // terminal for the STREAM: completed, failed, OR suspended (input.requested → the turn
-        // parked; the stream ends and a later /resume opens a fresh continuation stream).
-        if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "input.requested") { stop(); controller.close(); }
-      }, { turnId });
-    },
-    cancel() { stop(); },
-  });
-}
-
-// Consume an SSE turn stream to its terminal state: the final text, or throw on failure.
-// The non-streaming path (channels, a JSON chat response) uses this. Guards a non-SSE /
-// body-less upstream response (a misroute or an error) into a clear error, not a TypeError.
-export async function sseTurnFinalText(res: Response): Promise<string> {
-  const ct = res.headers.get("content-type") ?? "";
-  if (!res.body || !ct.includes("text/event-stream")) {
-    const detail = res.body ? (await res.text()).slice(0, 200) : "no body";
-    throw new Error(`turn stream: expected an SSE response, got ${ct || "no content-type"} (status ${res.status}): ${detail}`);
-  }
-  const reader = res.body.getReader();
-  const dec = new TextDecoder();
-  let buf = "";
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (value) buf += dec.decode(value, { stream: true });
-    let i: number;
-    while ((i = buf.indexOf("\n\n")) >= 0) {
-      const line = buf.slice(0, i).split("\n").find((l) => l.startsWith("data:"));
-      buf = buf.slice(i + 2);
-      if (!line) continue;
-      const e = JSON.parse(line.slice(5).trim()) as TurnEvent;
-      if (e.type === "turn.completed") return e.text;
-      if (e.type === "turn.failed") throw new Error(e.error.message);
+      const { userText, turnId } = (await req.json()) as { userText: string; turnId?: string };
+      return Response.json({ text: await this.turn({ userText, turnId }) });
     }
-    if (done) break;
-  }
-  throw new Error("turn stream ended without a terminal event");
-}
-
-// Parse an SSE turn response into the stream of TurnEvents (skipping `:hb` heartbeats).
-// The streaming consumer (a channel's render path) iterates this to drive live UI.
-export async function* sseTurnEvents(res: Response): AsyncIterable<TurnEvent> {
-  const ct = res.headers.get("content-type") ?? "";
-  if (!res.body || !ct.includes("text/event-stream")) {
-    const detail = res.body ? (await res.text()).slice(0, 200) : "no body";
-    throw new Error(`turn stream: expected an SSE response, got ${ct || "no content-type"} (status ${res.status}): ${detail}`);
-  }
-  const reader = res.body.getReader();
-  const dec = new TextDecoder();
-  let buf = "";
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (value) buf += dec.decode(value, { stream: true });
-    let i: number;
-    while ((i = buf.indexOf("\n\n")) >= 0) {
-      const line = buf.slice(0, i).split("\n").find((l) => l.startsWith("data:"));
-      buf = buf.slice(i + 2);
-      if (line) yield JSON.parse(line.slice(5).trim()) as TurnEvent;
-    }
-    if (done) break;
-  }
-}
-
-// The header durableFetch stamps the session key on (#75). A DO cannot read its own
-// idFromName name, so this is how the externally-assigned session identity crosses
-// into the object — exported so a custom shell that bypasses durableFetch can set it.
-export const SESSION_HEADER = "x-june-session";
-
-// A session key rides an HTTP header (SESSION_HEADER) and the DO name (idFromName) —
-// reject values that can't: CR/LF would be header injection, and Headers.set throws a
-// bare TypeError on control/non-ASCII bytes, turning a bad client value into an opaque
-// 500 deep inside durableFetch. Non-empty printable ASCII is the contract.
-const SESSION_KEY_RE = /^[\x20-\x7E]+$/;
-function assertSessionKey(session: string) {
-  if (typeof session !== "string" || !SESSION_KEY_RE.test(session)) {
-    throw new Error(`invalid session key ${JSON.stringify(session)} — a session key must be a non-empty printable-ASCII string (it rides an HTTP header and the DO name)`);
+    if (url.pathname.endsWith("/transcript")) return Response.json({ transcript: this.transcript() });
+    return new Response("agent DO — POST /turn or GET /transcript", { status: 404 });
   }
 }
 
 // Worker-side routing: address a session's DO by (agent, session) and forward the
-// request to it. `env.AGENT` is the DO namespace binding. The session key rides a
-// header (not the body): one seam covers /turn, /resume, and /transcript without
-// touching any body contract, and an older DO simply ignores it.
+// request to it. `env.AGENT` is the DO namespace binding.
 export function durableFetch(namespace: DurableObjectNamespace, agent: string, session: string, req: Request): Promise<Response> {
-  assertSessionKey(session);
-  const headers = new Headers(req.headers);
-  headers.set(SESSION_HEADER, session);
-  return namespace.get(namespace.idFromName(`${agent}:${session}`)).fetch(new Request(req, { headers }));
+  return namespace.get(namespace.idFromName(`${agent}:${session}`)).fetch(req);
 }
 
 // The EDGE agent surface for June's router: route the chat endpoint to the
@@ -546,26 +235,13 @@ export function durableAgentSurface(
     const namespace = getNamespace();
     if (!namespace) return null; // no DO binding → not mounted here
     const { message, session } = (await req.json()) as { message: string; session?: string };
-    // `session` is CLIENT input here — an un-headerable value must be a clear 400, not
-    // the opaque 500 assertSessionKey would become this deep in the worker.
-    if (session !== undefined) {
-      try {
-        assertSessionKey(session);
-      } catch (err) {
-        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 400 });
-      }
-    }
-    // Forward to the session's DO on its /turn contract — which now STREAMS SSE. A client
-    // that asks for the stream (Accept: text/event-stream) gets live TurnEvents piped
-    // through; otherwise collapse to the final { text } (the prior JSON contract).
-    const res = await durableFetch(
+    // Forward to the session's DO on its /turn contract (AgentDurableObject.fetch).
+    return durableFetch(
       namespace,
       opts.agentName,
       session ?? "default",
       new Request("https://do/turn", { method: "POST", body: JSON.stringify({ userText: message }) }),
     );
-    if (req.headers.get("accept")?.includes("text/event-stream")) return res;
-    return Response.json({ text: await sseTurnFinalText(res) });
   };
 }
 
@@ -601,11 +277,6 @@ export function durableChannelSurface(
     agentName: string;
     channels: (Channel | ChannelFactory)[];
     env: unknown;
-    // The app's services factory — the SAME one AgentDurableObject uses — resolved HERE
-    // (worker isolate) and exposed to channel hooks as ctx.services. Channel hooks run at
-    // the edge, outside the DO, so they can't read the DO's ambient currentServices(); this
-    // gives them the same DI bag. Resolved once per surface construction.
-    services?: (env: unknown) => unknown;
     waitUntil?: (p: Promise<unknown>) => void;
   },
 ): (req: Request) => Promise<Response | null> {
@@ -614,7 +285,6 @@ export function durableChannelSurface(
     // A minimal but complete AgentDefinition — channels only read ctx.agent.name; the
     // full def isn't present in the worker (tools/model live in the DO).
     agent: { name: opts.agentName, instructions: "", tools: [], skills: [], channels: [], connections: [] } satisfies AgentDefinition,
-    services: opts.services?.(opts.env),
     waitUntil: opts.waitUntil,
     run: async (message, o) => {
       const namespace = getNamespace();
@@ -623,84 +293,11 @@ export function durableChannelSurface(
         namespace,
         opts.agentName,
         o?.session ?? "default",
-        new Request("https://do/turn", { method: "POST", body: serializeTurn(message, o) }),
+        new Request("https://do/turn", { method: "POST", body: JSON.stringify({ userText: message, turnId: o?.turnId }) }),
       );
-      // /turn streams SSE; the simple path collapses it to the final text.
-      return sseTurnFinalText(res);
-    },
-    // FIRE-AND-FORGET (#77): POST /turn?detach=1 — the DO 202s once the turn is accepted
-    // and runs it under its OWN lifetime. This is how a shadow/observe hook (onEvent →
-    // assessment turn, reply dropped) escapes the edge waitUntil ceiling that killed
-    // 24–38s turns in production: nothing holds the edge open while the turn runs.
-    runDetached: async (message, o) => {
-      const namespace = getNamespace();
-      if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-      const res = await durableFetch(
-        namespace,
-        opts.agentName,
-        o?.session ?? "default",
-        new Request("https://do/turn?detach=1", { method: "POST", body: serializeTurn(message, o) }),
-      );
-      if (res.status !== 202) {
-        const detail = (await res.text()).slice(0, 200);
-        throw new Error(`runDetached: turn was not accepted (status ${res.status}): ${detail}`);
-      }
-      return (await res.json()) as { turnId: string };
-    },
-    // The LIVE path: hand the channel the TurnEvent stream so it can render as the turn runs.
-    runStream: async function* (message, o) {
-      const namespace = getNamespace();
-      if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-      const res = await durableFetch(
-        namespace,
-        opts.agentName,
-        o?.session ?? "default",
-        new Request("https://do/turn", { method: "POST", body: serializeTurn(message, o) }),
-      );
-      yield* sseTurnEvents(res);
-    },
-    // Resume a parked turn on its session's DO and stream the continuation.
-    resumeStream: async function* (o) {
-      const namespace = getNamespace();
-      if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-      const res = await durableFetch(
-        namespace,
-        opts.agentName,
-        o.session ?? "default",
-        new Request("https://do/resume", { method: "POST", body: serializeResume(o) }),
-      );
-      yield* sseTurnEvents(res);
+      const { text } = (await res.json()) as { text: string };
+      return text;
     },
   };
   return channelDispatch(resolved, ctx);
 }
-
-// Serialize a turn for the /turn RPC body. InboundEvent.raw is `unknown` — the
-// untouched platform payload — so a (third-party) channel could attach something
-// JSON.stringify chokes on (a circular object, a BigInt). raw isn't needed to route or
-// run the turn, so on a serialization failure we drop it rather than let an
-// unserializable payload take down turn forwarding entirely. (raw is optional on
-// InboundEvent precisely because it may not survive this boundary.)
-// Serialize a /resume RPC body. `input` is `unknown` — the human's answer — so a
-// (third-party) host could hand us something JSON.stringify chokes on (BigInt, circular).
-// Unlike serializeTurn's `raw`, `input` is essential: silently dropping it would resume the
-// turn with the wrong answer. So fail loudly with a clear message rather than corrupt the resume.
-function serializeResume(o: { turnId: string; inputId: string; input: unknown; by?: string }): string {
-  try {
-    return JSON.stringify({ turnId: o.turnId, inputId: o.inputId, input: o.input, by: o.by });
-  } catch (err) {
-    throw new Error(`resumeStream: input is not JSON-serializable (${(err as Error).message}) — a resume answer must round-trip to the DO`);
-  }
-}
-
-// `trigger` is ProactiveTrigger — plain strings by construction — so only event.raw can make
-// the stringify throw; the fallback that strips it stays sufficient.
-function serializeTurn(userText: string, o?: { turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger }): string {
-  const payload = { userText, turnId: o?.turnId, event: o?.event, trigger: o?.trigger };
-  try {
-    return JSON.stringify(payload);
-  } catch {
-    const event = o?.event ? { ...o.event, raw: undefined } : undefined;
-    return JSON.stringify({ ...payload, event });
-  }
-}

package/src/agent-native.ts

@@ -10,8 +10,7 @@
 import {
   AgentSession,
   withSystem,
-  type EventSink,
-  type TurnEvent,
+  type Broadcaster,
   type Model,
   type Msg,
   type Runtime,
@@ -46,8 +45,8 @@ class SqliteSessionStore implements SessionStore {
     return (this.db.query("SELECT body FROM agent_messages WHERE session_id = ? ORDER BY seq").all(this.sid) as { body: string }[])
       .map((r) => JSON.parse(r.body));
   }
-  hasOpeningMessage(turnId: string): boolean {
-    return this.messages().some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId);
+  hasUserTurn(turnId: string): boolean {
+    return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
   }
   getStep(id: string): unknown | undefined {
     const r = this.db.query("SELECT output FROM agent_steps WHERE session_id = ? AND id = ?").get(this.sid, id) as { output: string } | undefined;
@@ -56,9 +55,6 @@ class SqliteSessionStore implements SessionStore {
   putStep(id: string, output: unknown) {
     this.db.query("INSERT INTO agent_steps (session_id, id, output) VALUES (?, ?, ?)").run(this.sid, id, JSON.stringify(output));
   }
-  delStep(id: string) {
-    this.db.query("DELETE FROM agent_steps WHERE session_id = ? AND id = ?").run(this.sid, id);
-  }
   getStatus(): string {
     return (this.db.query("SELECT status FROM agent_sessions WHERE session_id = ?").get(this.sid) as { status: string } | undefined)?.status ?? "new";
   }
@@ -81,15 +77,15 @@ class SqliteSessionStore implements SessionStore {
   unwrap<H = unknown>(): H { return this.db as unknown as H; }
 }
 
-class InProcEventSink implements EventSink {
-  private subs = new Set<(e: TurnEvent) => void>();
-  emit(e: TurnEvent) { this.subs.forEach((cb) => { try { cb(e); } catch { /* a bad subscriber must not break emit */ } }); }
-  subscribe(cb: (e: TurnEvent) => void): () => void { this.subs.add(cb); return () => this.subs.delete(cb); }
+class InProcBroadcaster implements Broadcaster {
+  private subs = new Set<(t: string) => void>();
+  publish(turnId: string) { this.subs.forEach((cb) => { try { cb(turnId); } catch { /* a bad subscriber must not break publish */ } }); }
+  subscribe(cb: (t: string) => void): () => void { this.subs.add(cb); return () => this.subs.delete(cb); }
 }
 
 // `instructions` (the agent's system prompt) is injected into the model per turn
 // by the runtime (withSystem) — single-sourced on the def, not baked into `model`.
-export type AgentDef = { model: Model; tools: Tool[]; instructions?: string; channelInstructions?: Record<string, string> };
+export type AgentDef = { model: Model; tools: Tool[]; instructions?: string };
 
 // The native Runtime: a registry of agent definitions over one SQLite handle,
 // handing out (and memoizing) an AgentSession actor per (agent, id).
@@ -111,7 +107,7 @@ export class NativeRuntime implements Runtime {
       const def = this.agents[agent];
       if (!def) throw new Error(`unknown agent: ${agent}`);
       const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-      a = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), new InProcEventSink(), model, def.tools, this, def.channelInstructions);
+      a = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), new InProcBroadcaster(), model, def.tools, this);
       this.actors.set(key, a);
     }
     return a;
@@ -139,10 +135,9 @@ class MemorySessionStore implements SessionStore {
   private status = "new";
   appendMessage(m: Msg) { this.msgs.push(m); }
   messages(): Msg[] { return this.msgs.slice(); }
-  hasOpeningMessage(turnId: string): boolean { return this.msgs.some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId); }
+  hasUserTurn(turnId: string): boolean { return this.msgs.some((m) => m.role === "user" && m.turnId === turnId); }
   getStep(id: string): unknown | undefined { return this.steps.has(id) ? this.steps.get(id) : undefined; }
   putStep(id: string, output: unknown) { this.steps.set(id, output); }
-  delStep(id: string) { this.steps.delete(id); }
   getStatus(): string { return this.status; }
   setStatus(s: string) { this.status = s; }
   tx<T>(fn: () => T): T { return fn(); } // no rollback: an in-memory store is not a durability tier
@@ -164,7 +159,7 @@ export class MemoryRuntime implements Runtime {
       if (!def) throw new Error(`unknown agent: ${agent}`);
       const store = new MemorySessionStore();
       this.stores.set(key, store);
-      a = new AgentSession(agent, id, store, new InProcEventSink(), def.model, def.tools, this);
+      a = new AgentSession(agent, id, store, new InProcBroadcaster(), def.model, def.tools, this);
       this.actors.set(key, a);
     }
     return a;
@@ -200,7 +195,7 @@ export async function createAgentRuntime(
 export function mountAgent(
   agent: AgentDefinition,
   runtime: Runtime,
-  opts: { chatPath?: string; channels?: boolean; services?: unknown } = {},
+  opts: { chatPath?: string; channels?: boolean } = {},
 ): {
   surface: (req: Request) => Promise<Response | null>;
   fetch: (req: Request) => Promise<Response | null>;
@@ -211,14 +206,8 @@ export function mountAgent(
   const channelsOn = opts.channels ?? true;
   const ctx: ChannelContext = {
     agent,
-    services: opts.services, // same DI bag reachable from channel hooks (parity with durableChannelSurface)
     run: (message, o) =>
-      runtime.session(agent.name, o?.session ?? "default").turn({ turnId: o?.turnId, userText: message, event: o?.event, trigger: o?.trigger }),
-    // FIRE-AND-FORGET (#77): start() without awaiting the result. Native has no waitUntil
-    // ceiling (Node keeps floating promises alive), but the seam is the same so a channel
-    // written against ctx.runDetached behaves identically on both targets.
-    runDetached: async (message, o) =>
-      runtime.session(agent.name, o?.session ?? "default").start({ turnId: o?.turnId, userText: message, event: o?.event, trigger: o?.trigger }),
+      runtime.session(agent.name, o?.session ?? "default").turn({ turnId: o?.turnId, userText: message }),
   };
   const channels = channelFetch(agent, ctx);
   const surface = async (req: Request): Promise<Response | null> => {

package/src/worker.ts

@@ -274,8 +274,11 @@ export function withAssets(
       }
 
       // 2. Static assets (prerendered HTML/.md/.json, /client.js, hashed CSS)
-      //    served direct.
-      if (assets) {
+      //    served direct — for reads only. Assets never answer a write, and on
+      //    workerd handing the incoming request to ASSETS.fetch() consumes its
+      //    body: a POST that 404s here would reach the pipeline with a used stream
+      //    (POST /mcp → -32700 Parse error, an action's input gone).
+      if (assets && (request.method === "GET" || request.method === "HEAD")) {
         const a = await assets.fetch(request);
         if (a.status !== 404) {
           const ct = a.headers.get("content-type") ?? "";