@junejs/server 1.0.0-dev.14 → 1.0.0-dev.17

package/dist/adapter.d.ts

@@ -4,6 +4,7 @@ type AdapterCapabilities = {
   runtime: "edge" | "node" | "serverless" | "native" | "static";
   persistentConnections: boolean;
   assets: "platform" | "server" | "none";
+  durableObjects?: boolean;
 };
 type AdapterEntry = {
   imports: string[];
@@ -14,6 +15,10 @@ type ResourcePlan = {
     binding: string;
     databaseName: string;
   };
+  agent?: {
+    binding: string;
+    className: string;
+  };
 };
 type AdapterEmitContext = {
   appRoot: string;
@@ -39,6 +44,7 @@ interface JuneAdapter {
   }): AdapterEntry;
   emit(ctx: AdapterEmitContext): Promise<void>;
 }
+declare function hasDurableBinding(text: string, file: string, binding: string, className: string): boolean;
 declare function workers(opts?: {
   name?: string;
   domain?: string;
@@ -53,4 +59,4 @@ declare function deno(opts?: {
 }): JuneAdapter;
 declare function staticSite(): JuneAdapter;
 //#endregion
-export { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, staticSite, vercel, workers };
+export { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, hasDurableBinding, staticSite, vercel, workers };

package/dist/adapter.js

@@ -1,14 +1,51 @@
+import { stripJsonc } from "./tsconfig-jsx.js";
 import { existsSync } from "node:fs";
-import { copyFile, cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { copyFile, cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 //#region src/adapter.ts
+function hasDurableBinding(text, file, binding, className) {
+	if (file.endsWith(".toml")) {
+		const lines = text.split("\n").map((line) => {
+			let inString = false;
+			for (let i = 0; i < line.length; i++) {
+				const ch = line[i];
+				if (ch === "\"" && line[i - 1] !== "\\") inString = !inString;
+				else if (ch === "#" && !inString) return line.slice(0, i);
+			}
+			return line;
+		});
+		let inBindings = false;
+		let name;
+		let cls;
+		const matches = () => name === binding && cls === className;
+		for (const line of lines) {
+			const t = line.trim();
+			if (t.startsWith("[")) {
+				if (inBindings && matches()) return true;
+				inBindings = /^\[\[\s*durable_objects\.bindings\s*\]\]$/.test(t);
+				name = cls = void 0;
+				continue;
+			}
+			if (!inBindings) continue;
+			const kv = t.match(/^(name|class_name)\s*=\s*"([^"]*)"/);
+			if (kv) kv[1] === "name" ? name = kv[2] : cls = kv[2];
+		}
+		return inBindings && matches();
+	}
+	try {
+		return (JSON.parse(stripJsonc(text)).durable_objects?.bindings ?? []).some((b) => b.name === binding && b.class_name === className);
+	} catch {
+		return text.includes(className);
+	}
+}
 function workers(opts) {
 	return {
 		name: "workers",
 		capabilities: {
 			runtime: "edge",
 			persistentConnections: true,
-			assets: "platform"
+			assets: "platform",
+			durableObjects: true
 		},
 		conditions: [
 			"source",
@@ -25,7 +62,17 @@ function workers(opts) {
 			};
 		},
 		async emit({ appRoot, outDir, hasAssets, config, plan, defaultName }) {
-			if (existsSync(join(appRoot, "wrangler.toml")) || existsSync(join(appRoot, "wrangler.jsonc"))) return;
+			const own = ["wrangler.toml", "wrangler.jsonc"].map((f) => join(appRoot, f)).find(existsSync);
+			if (own) {
+				if (plan.agent) {
+					const cls = plan.agent.className;
+					if (!hasDurableBinding(await readFile(own, "utf8"), own, plan.agent.binding, cls)) {
+						const snippet = own.endsWith(".toml") ? `[[durable_objects.bindings]]\nname = "${plan.agent.binding}"\nclass_name = "${cls}"\n\n[[migrations]]\ntag = "v1"\nnew_sqlite_classes = ["${cls}"]` : `"durable_objects": { "bindings": [{ "name": "${plan.agent.binding}", "class_name": "${cls}" }] },\n"migrations": [{ "tag": "v1", "new_sqlite_classes": ["${cls}"] }]`;
+						console.warn(`[june build] durable agent built, but ${basename(own)} doesn't bind it — add:\n${snippet}`);
+					}
+				}
+				return;
+			}
 			const deployCfg = config.deploy;
 			await writeFile(join(outDir, "wrangler.jsonc"), JSON.stringify({
 				name: opts?.name ?? deployCfg?.name ?? defaultName,
@@ -42,6 +89,16 @@ function workers(opts) {
 					database_name: plan.db.databaseName,
 					database_id: ""
 				}] } : {},
+				...plan.agent ? {
+					durable_objects: { bindings: [{
+						name: plan.agent.binding,
+						class_name: plan.agent.className
+					}] },
+					migrations: [{
+						tag: "v1",
+						new_sqlite_classes: [plan.agent.className]
+					}]
+				} : {},
 				...opts?.domain ?? deployCfg?.domain ? { routes: [{
 					pattern: opts?.domain ?? deployCfg?.domain,
 					custom_domain: true
@@ -208,4 +265,4 @@ function staticSite() {
 	};
 }
 //#endregion
-export { deno, staticSite, vercel, workers };
+export { deno, hasDurableBinding, staticSite, vercel, workers };

package/dist/agent-compile.d.ts

@@ -0,0 +1,35 @@
+//#region src/agent-compile.d.ts
+declare const AGENT_MODULE_FILE = "_agent.gen.ts";
+type AgentDirScan = {
+  dir: string;
+  name: string;
+  hasConfig: boolean;
+  instructions: string | null;
+  tools: string[];
+  skills: {
+    name: string;
+    raw: string;
+  }[];
+  channels: string[];
+  channelOverlays: {
+    source: string;
+    raw: string;
+  }[];
+  connections: string[];
+};
+declare function scanAgentDir(dir: string): AgentDirScan | null;
+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?: {
+  check?: boolean;
+} & EmitOptions): {
+  file: string;
+  code: string;
+  stale: boolean;
+  written: boolean;
+} | null;
+//#endregion
+export { AGENT_MODULE_FILE, AgentDirScan, EmitOptions, emitAgentModule, findAgentDir, generateAgentModule, scanAgentDir };

package/dist/agent-compile.js

@@ -0,0 +1,139 @@
+import { stripJsonc } from "./tsconfig-jsx.js";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+//#region src/agent-compile.ts
+const AGENT_MODULE_FILE = "_agent.gen.ts";
+function list(dir, ext) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(ext) && !e.name.startsWith("_")).map((e) => e.name).sort();
+}
+function scanAgentDir(dir) {
+	if (!existsSync(dir)) return null;
+	const instructionsFile = join(dir, "instructions.md");
+	const scan = {
+		dir,
+		name: basename(dir),
+		hasConfig: existsSync(join(dir, "agent.ts")),
+		instructions: existsSync(instructionsFile) ? readFileSync(instructionsFile, "utf8") : null,
+		tools: list(join(dir, "tools"), ".ts").map((f) => `./tools/${f}`),
+		skills: list(join(dir, "skills"), ".md").map((f) => ({
+			name: basename(f, ".md"),
+			raw: readFileSync(join(dir, "skills", f), "utf8")
+		})),
+		channels: list(join(dir, "channels"), ".ts").map((f) => `./channels/${f}`),
+		channelOverlays: list(join(dir, "channels"), ".md").map((f) => ({
+			source: basename(f, ".md"),
+			raw: readFileSync(join(dir, "channels", f), "utf8")
+		})),
+		connections: list(join(dir, "connections"), ".ts").map((f) => `./connections/${f}`)
+	};
+	return !scan.hasConfig && scan.instructions === null && !scan.tools.length && !scan.skills.length && !scan.channels.length && !scan.channelOverlays.length && !scan.connections.length ? null : scan;
+}
+function identFor(prefix, spec, taken) {
+	const stem = basename(spec).replace(/\.ts$/, "").replace(/[^A-Za-z0-9]/g, "_");
+	let id = `${prefix}_${stem}`;
+	for (let i = 2; taken.has(id); i++) id = `${prefix}_${stem}_${i}`;
+	taken.add(id);
+	return id;
+}
+function emitAgentModule(scan, opts) {
+	const spec = (s) => JSON.stringify(opts?.tsExtensions ? s : s.replace(/\.ts$/, ""));
+	const taken = /* @__PURE__ */ new Set();
+	const imports = [];
+	const toolIds = scan.tools.map((s) => {
+		const id = identFor("tool", s, taken);
+		imports.push(`import ${id} from ${spec(s)};`);
+		return id;
+	});
+	const channelIds = scan.channels.map((s) => {
+		const id = identFor("channel", s, taken);
+		imports.push(`import ${id} from ${spec(s)};`);
+		return {
+			key: basename(s, ".ts"),
+			id
+		};
+	});
+	const connectionIds = scan.connections.map((s) => {
+		const id = identFor("connection", s, taken);
+		imports.push(`import ${id} from ${spec(s)};`);
+		return id;
+	});
+	if (scan.hasConfig) imports.push(`import config from ${spec("./agent.ts")};`);
+	const lines = [
+		"// AUTO-GENERATED by June — do not edit. Compiled from this agent/ directory so",
+		"// the definition mounts without filesystem discovery (workerd has no fs).",
+		"// Regenerate with `june gen` after adding, removing, or editing agent files.",
+		...imports,
+		scan.skills.length ? `import { parseSkill, type AgentModule } from "@junejs/core/agent-config";` : `import type { AgentModule } from "@junejs/core/agent-config";`,
+		""
+	];
+	if (!scan.hasConfig) lines.push(`const config = { name: ${JSON.stringify(scan.name)} };`, "");
+	lines.push("export const agentModule: AgentModule = {", "  config,", `  instructions: ${JSON.stringify(scan.instructions ?? "")},`, `  tools: [${toolIds.join(", ")}],`, scan.skills.length ? `  skills: [\n${scan.skills.map((s) => `    parseSkill(${JSON.stringify(s.name)}, ${JSON.stringify(s.raw)}),`).join("\n")}\n  ],` : "  skills: [],", channelIds.length ? `  channels: { ${channelIds.map((c) => `${JSON.stringify(c.key)}: ${c.id}`).join(", ")} },` : "  channels: {},", scan.channelOverlays.length ? `  channelInstructions: {\n${scan.channelOverlays.map((o) => `    ${JSON.stringify(o.source)}: ${JSON.stringify(o.raw)},`).join("\n")}\n  },` : "  channelInstructions: {},", `  connections: [${connectionIds.join(", ")}],`, "};", "export default agentModule;", "");
+	return lines.join("\n");
+}
+function findAgentDir(root, dirName = "agent") {
+	for (const candidate of [join(root, "app", dirName), join(root, dirName)]) if (existsSync(candidate)) return candidate;
+	return null;
+}
+function readTsconfig(path) {
+	try {
+		return JSON.parse(stripJsonc(readFileSync(path, "utf8")));
+	} catch {
+		return;
+	}
+}
+function resolveExtends(fromDir, spec) {
+	const withJson = (p) => existsSync(p) ? p : !p.endsWith(".json") && existsSync(`${p}.json`) ? `${p}.json` : void 0;
+	if (spec.startsWith(".")) return withJson(resolve(fromDir, spec));
+	for (let d = fromDir;;) {
+		const candidate = withJson(join(d, "node_modules", spec));
+		if (candidate) return candidate;
+		const parent = dirname(d);
+		if (parent === d) return void 0;
+		d = parent;
+	}
+}
+function resolveAllowTsExtensions(path, depth) {
+	if (depth > 8) return void 0;
+	const tc = readTsconfig(path);
+	if (!tc) return void 0;
+	const own = tc.compilerOptions?.allowImportingTsExtensions;
+	if (own !== void 0) return own;
+	const bases = typeof tc.extends === "string" ? [tc.extends] : [...tc.extends ?? []].reverse();
+	for (const spec of bases) {
+		const base = resolveExtends(dirname(path), spec);
+		const inherited = base ? resolveAllowTsExtensions(base, depth + 1) : void 0;
+		if (inherited !== void 0) return inherited;
+	}
+}
+function sniffTsExtensions(dir) {
+	for (let d = dir;;) {
+		const candidate = join(d, "tsconfig.json");
+		if (existsSync(candidate)) return resolveAllowTsExtensions(candidate, 0) ?? false;
+		const parent = dirname(d);
+		if (parent === d) return false;
+		d = parent;
+	}
+}
+function generateAgentModule(dir, opts) {
+	const scan = scanAgentDir(dir);
+	if (!scan) return null;
+	const code = emitAgentModule(scan, { tsExtensions: opts?.tsExtensions ?? sniffTsExtensions(dir) });
+	const file = join(dir, AGENT_MODULE_FILE);
+	const stale = (existsSync(file) ? readFileSync(file, "utf8") : null) !== code;
+	if (opts?.check) return {
+		file,
+		code,
+		stale,
+		written: false
+	};
+	if (stale) writeFileSync(file, code);
+	return {
+		file,
+		code,
+		stale,
+		written: stale
+	};
+}
+//#endregion
+export { AGENT_MODULE_FILE, emitAgentModule, findAgentDir, generateAgentModule, scanAgentDir };

package/dist/agent-discover.d.ts

@@ -1,5 +1,6 @@
-import { AgentDefinition } from "@junejs/core/agent-config";
+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 };
+export { discoverAgent, discoverAgentModule };

package/dist/agent-discover.js

@@ -2,42 +2,17 @@ import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { defineAgent, resolveChannel } from "@junejs/core/agent-config";
-import { connectAll } from "@junejs/core/connections";
+import { assembleAgent, parseSkill } from "@junejs/core/agent-config";
 //#region src/agent-discover.ts
 async function scan(dir, ext) {
 	if (!existsSync(dir)) return [];
-	return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isFile() && extname(e.name) === ext).map((e) => join(dir, e.name)).sort();
+	return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isFile() && extname(e.name) === ext && !e.name.startsWith("_")).map((e) => join(dir, e.name)).sort();
 }
-function parseSkill(name, text) {
-	if (text.startsWith("---")) {
-		const end = text.indexOf("\n---", 3);
-		if (end !== -1) {
-			const front = text.slice(3, end);
-			const body = text.slice(end + 4).replace(/^\s*\n/, "");
-			const meta = {};
-			for (const line of front.split("\n")) {
-				const m = line.match(/^\s*(\w+)\s*:\s*(.+?)\s*$/);
-				if (m) meta[m[1]] = m[2];
-			}
-			return {
-				name: meta.name ?? name,
-				description: meta.description ?? "",
-				body
-			};
-		}
-	}
-	return {
-		name,
-		description: (text.split("\n").find((l) => l.trim()) ?? "").replace(/^#\s*/, ""),
-		body: text
-	};
-}
-async function discoverAgent(dir) {
+async function discoverAgentModule(dir) {
 	const configFile = join(dir, "agent.ts");
 	const config = existsSync(configFile) ? (await import(pathToFileURL(configFile).href)).default : { name: basename(dir) };
 	const instructionsFile = join(dir, "instructions.md");
-	const instructions = existsSync(instructionsFile) ? await readFile(instructionsFile, "utf8") : config.instructions ?? "";
+	const instructions = existsSync(instructionsFile) ? await readFile(instructionsFile, "utf8") : "";
 	const tools = [];
 	for (const f of await scan(join(dir, "tools"), ".ts")) {
 		const mod = await import(pathToFileURL(f).href);
@@ -45,31 +20,30 @@ async function discoverAgent(dir) {
 	}
 	const skills = [];
 	for (const f of await scan(join(dir, "skills"), ".md")) skills.push(parseSkill(basename(f, ".md"), await readFile(f, "utf8")));
-	const channels = [];
+	const channels = {};
 	for (const f of await scan(join(dir, "channels"), ".ts")) {
 		const mod = await import(pathToFileURL(f).href);
-		if (mod.default) channels.push(resolveChannel(mod.default, process.env));
+		if (mod.default) channels[basename(f, ".ts")] = mod.default;
 	}
-	const connectionDefs = [];
+	const channelInstructions = {};
+	for (const f of await scan(join(dir, "channels"), ".md")) channelInstructions[basename(f, ".md")] = await readFile(f, "utf8");
+	const connections = [];
 	for (const f of await scan(join(dir, "connections"), ".ts")) {
 		const mod = await import(pathToFileURL(f).href);
-		if (mod.default) connectionDefs.push(mod.default);
+		if (mod.default) connections.push(mod.default);
 	}
-	const { actions: connectionActions, report: connections } = connectionDefs.length ? await connectAll(connectionDefs) : {
-		actions: [],
-		report: []
-	};
-	tools.push(...connectionActions);
-	return defineAgent({
-		name: config.name,
-		model: config.model,
-		description: config.description,
+	return {
+		config,
 		instructions,
 		tools,
 		skills,
 		channels,
+		channelInstructions,
 		connections
-	});
+	};
+}
+async function discoverAgent(dir) {
+	return assembleAgent(await discoverAgentModule(dir), process.env);
 }
 //#endregion
-export { discoverAgent };
+export { discoverAgent, discoverAgentModule };

package/dist/agent-durable.d.ts

@@ -50,7 +50,7 @@ type DoAgentDef = {
   channelInstructions?: Record<string, string>;
   channels?: (Channel | ChannelFactory)[];
   env?: unknown;
-  resources?: Resources;
+  resources?: Resources | ((env: unknown) => Promise<Resources> | Resources);
   services?: unknown;
   onTurnError?: (failure: {
     turnId: string;
@@ -69,8 +69,11 @@ declare class AgentDurableObject {
   private readonly tools;
   private readonly channels;
   private readonly channelInstructions?;
-  private readonly resources;
+  private readonly resourcesInput;
+  private resourcesOpened;
+  private readonly doEnv;
   private readonly services;
+  private resolveResources;
   constructor(state: DurableObjectState, def: DoAgentDef);
   private resolveSession;
   turn(input: {

package/dist/agent-durable.js

@@ -99,13 +99,19 @@ var AgentDurableObject = class {
 	tools;
 	channels;
 	channelInstructions;
-	resources;
+	resourcesInput;
+	resourcesOpened;
+	doEnv;
 	services;
+	resolveResources() {
+		return this.resourcesOpened ??= Promise.resolve(typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : this.resourcesInput ?? {});
+	}
 	constructor(state, def) {
 		assertCoreRuntimeVersion(`AgentDurableObject(${def.name ?? "agent"})`);
 		const store = new DoSessionStore(state.storage);
 		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-		this.resources = def.resources ?? {};
+		this.resourcesInput = def.resources;
+		this.doEnv = def.env;
 		this.services = def.services;
 		const name = def.name ?? "agent";
 		const sink = new InProcEventSink();
@@ -162,17 +168,19 @@ var AgentDurableObject = class {
 	}
 	async turn(input) {
 		await ensureScope();
+		const resources = await this.resolveResources();
 		const session = this.resolveSession(input.session);
 		return runInScope({
-			resources: this.resources,
+			resources,
 			services: this.services
 		}, () => session.turn(input));
 	}
 	async start(input) {
 		await ensureScope();
+		const resources = await this.resolveResources();
 		const session = this.resolveSession(input.session);
 		return runInScope({
-			resources: this.resources,
+			resources,
 			services: this.services
 		}, () => session.start(input));
 	}
@@ -198,12 +206,13 @@ var AgentDurableObject = class {
 				deliverChannel = this.channels.find((c) => c.name === event.source);
 				if (!deliverChannel?.deliver) return Response.json({ error: `agent "${this.name}": no deliver()-capable channel named "${event.source}" is wired into this DO (DoAgentDef.channels) — the turn was NOT started` }, { status: 501 });
 			}
+			const resources = await this.resolveResources();
 			let session;
 			let started;
 			try {
 				session = this.resolveSession(key);
 				started = runInScope({
-					resources: this.resources,
+					resources,
 					services: this.services
 				}, () => session.start({
 					userText,
@@ -227,7 +236,7 @@ var AgentDurableObject = class {
 						recipientTeamId: event.teamId
 					};
 					Promise.resolve().then(() => runInScope({
-						resources: this.resources,
+						resources,
 						services: this.services
 					}, () => deliverChannel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
 						it.return?.();
@@ -250,11 +259,12 @@ var AgentDurableObject = class {
 				resumeChannel = this.channels.find((c) => c.name === source);
 				if (!resumeChannel?.deliverResume) return Response.json({ error: `agent "${this.name}": no deliverResume()-capable channel named "${source}" is wired into this DO (DoAgentDef.channels) — the answer was NOT applied` }, { status: 501 });
 			}
+			const resources = await this.resolveResources();
 			let session;
 			try {
 				session = this.resolveSession(key);
 				runInScope({
-					resources: this.resources,
+					resources,
 					services: this.services
 				}, () => session.resume(turnId, inputId, input, { by }));
 			} catch (err) {
@@ -267,7 +277,7 @@ var AgentDurableObject = class {
 					const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
 					const events = { [Symbol.asyncIterator]: () => it };
 					Promise.resolve().then(() => runInScope({
-						resources: this.resources,
+						resources,
 						services: this.services
 					}, () => resumeChannel.deliverResume(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
 						it.return?.();

package/dist/build.js

@@ -1,8 +1,9 @@
+import { jsxTransform } from "./tsconfig-jsx.js";
 import { deno, staticSite, vercel, workers } from "./adapter.js";
+import { generateAgentModule } from "./agent-compile.js";
 import { findMiddlewareFile } from "./router.js";
 import { resolveBoundary } from "./segment.js";
 import { buildModuleCss, registerCssModules, rolldownCssModulesPlugin } from "./css-modules.js";
-import { jsxTransform } from "./tsconfig-jsx.js";
 import { CLIENT_SCRIPT_URL, bundleClientToFile, findClientEntry } from "./client-bundle.js";
 import { generateIslandRegistry } from "./island-registry.js";
 import { STYLES_URL, cssTargets, findGlobalCss, globalCssUsesTailwind, minifyCss, processCss } from "./css.js";
@@ -262,6 +263,12 @@ async function buildManifest(appRoot) {
 		const mod = await import(pathToFileURL(extraFile).href);
 		if (typeof mod.default === "function") extra = mod.default;
 	}
+	let agentName;
+	const agentDir = join(appDir, frozen.agent.runtime.dir);
+	if (frozen.agent.runtime.enabled && existsSync(agentDir)) {
+		const cfgFile = join(agentDir, "agent.ts");
+		agentName = (existsSync(cfgFile) ? (await import(pathToFileURL(cfgFile).href)).default : void 0)?.name ?? basename(agentDir);
+	}
 	return {
 		routes,
 		dynamicRoutes,
@@ -271,6 +278,7 @@ async function buildManifest(appRoot) {
 		loadings,
 		document: frozen.document,
 		agent: frozen.agent,
+		agentName,
 		i18n: frozen.i18n,
 		earlyHints: frozen.earlyHints,
 		extra
@@ -317,6 +325,24 @@ async function juneBuild(appRoot, options = {}) {
 		} : void 0 },
 		config: fullConfig
 	});
+	const agentDir = join(appDir, frozen.agent.runtime.dir);
+	let agentModule = null;
+	if (frozen.agent.runtime.enabled) {
+		const generated = generateAgentModule(agentDir);
+		if (generated && adapter.capabilities.durableObjects) agentModule = generated;
+		else if (generated) console.warn(`[june build] app/${frozen.agent.runtime.dir}/ found, but the ${adapter.name}() target has no Durable Objects — the durable agent is not mounted.`);
+	}
+	if (agentModule) {
+		const sdkResolvable = (fromDir) => {
+			for (let d = resolve(fromDir);;) {
+				if (existsSync(join(d, "node_modules", "@anthropic-ai", "sdk", "package.json"))) return true;
+				const parent = dirname(d);
+				if (parent === d) return false;
+				d = parent;
+			}
+		};
+		if (!sdkResolvable(appRoot)) throw new Error(`app/${frozen.agent.runtime.dir}/ mounts a durable agent whose model is Claude — add the SDK to the app so it bundles for workerd: bun add @anthropic-ai/sdk`);
+	}
 	const cssOut = await processCss(appDir, { minify: true });
 	let cssAsset = null;
 	if (cssOut !== null) {
@@ -407,7 +433,8 @@ async function juneBuild(appRoot, options = {}) {
 		imports.push(`import { turso } from "@junejs/server/db";`);
 		imports.push(`import { memoizeResources } from "@junejs/server/resources";`);
 	} else if (hasResources) imports.push(`import { bindWorkerResources } from "@junejs/server/resources";`);
-	const resourcesField = tursoDb ? `\n  resources: memoizeResources({ db: turso() }),` : hasResources ? `\n  resources: bindWorkerResources(${JSON.stringify(resourceFlags)}),` : "";
+	const resourcesExpr = tursoDb ? `memoizeResources({ db: turso() })` : hasResources ? `bindWorkerResources(${JSON.stringify(resourceFlags)})` : null;
+	const resourcesField = resourcesExpr ? `\n  resources: ${resourcesExpr},` : "";
 	const dataLayerModule = fullConfig.dataLayer?.module;
 	if (dataLayerModule) imports.push(`import { installDataLayer } from ${JSON.stringify(dataLayerModule)};`);
 	const dataLayerBoot = dataLayerModule ? "\ninstallDataLayer();\n" : "";
@@ -417,6 +444,36 @@ async function juneBuild(appRoot, options = {}) {
 		imports.push(`import { services as __appServices } from ${JSON.stringify(spec)};`);
 	}
 	const servicesField = servicesModule ? `\n  services: __appServices,` : "";
+	if (agentModule) {
+		imports.push(`import __agentModule from ${JSON.stringify(importPath(genDir, agentModule.file))};`);
+		imports.push(`import { assembleDurable } from "@junejs/core/agent-config";`);
+		imports.push(`import { anthropic } from "@junejs/core/agent-models";`);
+		imports.push(`import { AgentDurableObject } from "@junejs/server/agent-durable";`);
+		imports.push(`import { DurableObject } from "cloudflare:workers";`);
+		imports.push(`import Anthropic from "@anthropic-ai/sdk";`);
+	}
+	const agentNameField = agentModule ? `\n  agentName: __agentModule.config.name,` : "";
+	const doClass = agentModule ? `
+// The durable agent: one Durable Object per session, the compiled agent/
+// directory as its definition — adapted tools (+ read_skill when skills exist),
+// the assembled system prompt, channel factories resolved with the DO's own
+// env, and the app's declared resources opened from THIS isolate's env (lazily,
+// at the first turn — the same ambient db a tool sees in native dev). Model:
+// Anthropic over a statically bundled client (workerd cannot resolve a bare
+// import at runtime), keyed by the ANTHROPIC_API_KEY secret — a missing secret
+// surfaces as the SDK's own clear construction error on the first agent request.
+const __agentDef = assembleDurable(__agentModule);
+export class JuneAgentDO extends DurableObject {
+  #agent = new AgentDurableObject(this.ctx, {
+    ...__agentDef,
+    model: anthropic({ model: __agentModule.config.model, client: new Anthropic({ apiKey: (this.env as { ANTHROPIC_API_KEY?: string }).ANTHROPIC_API_KEY }) }),
+    env: this.env,${resourcesExpr ? `\n    resources: ${resourcesExpr},` : ""}${servicesModule ? "\n    services: __appServices(this.env)," : ""}
+  });
+  fetch(req: Request): Promise<Response> {
+    return this.#agent.fetch(req);
+  }
+}
+` : "";
 	const entry = `// AUTO-GENERATED by \`june build\` — do not edit. Regenerate: june build .
 ${adapterEntry.imports.join("\n")}
 ${imports.join("\n")}
@@ -435,12 +492,12 @@ ${chains.join("\n")}
 ${loadings.join("\n")}
   },
   document: ${JSON.stringify(frozen.document, null, 2).replace(/\n/g, "\n  ")},
-  agent: ${JSON.stringify(frozen.agent)},${frozen.i18n ? `\n  i18n: ${JSON.stringify(frozen.i18n)},` : ""}
+  agent: ${JSON.stringify(frozen.agent)},${agentNameField}${frozen.i18n ? `\n  i18n: ${JSON.stringify(frozen.i18n)},` : ""}
   earlyHints: ${JSON.stringify(frozen.earlyHints)},${builtExtraFile ? "\n  extra," : ""}${resourcesField}${servicesField}
 });
 
 ${adapterEntry.wrap("pipeline")}
-`;
+${doClass}`;
 	const entryFile = join(genDir, "worker-entry.tsx");
 	await writeFile(entryFile, entry);
 	const { rolldown } = await import("rolldown");
@@ -455,6 +512,7 @@ ${adapterEntry.wrap("pipeline")}
 		plugins: [rolldownCssModulesPlugin(cssModuleMaps)],
 		external: (id) => {
 			if (isBunSpecifier(id)) return true;
+			if (id.startsWith("cloudflare:")) return true;
 			if (/\.(wasm|ttf|otf|woff2?|png|jpe?g|avif|webp)$/.test(id)) return true;
 			return [...adapter.buildExternal ?? [], ...options.external ?? frozen.buildExternal].some((e) => id === e || id.startsWith(`${e}/`));
 		},
@@ -561,10 +619,16 @@ ${adapterEntry.wrap("pipeline")}
 	}
 	const pkgPath = join(appRoot, "package.json");
 	const defaultName = workerName((existsSync(pkgPath) ? JSON.parse(await Bun.file(pkgPath).text()).name : void 0) ?? basename(appRoot));
-	const plan = resourcesCfg?.db && resourcesCfg.db.kind !== "turso" ? { db: {
-		binding: "DB",
-		databaseName: `${defaultName}-db`
-	} } : {};
+	const plan = {
+		...resourcesCfg?.db && resourcesCfg.db.kind !== "turso" ? { db: {
+			binding: "DB",
+			databaseName: `${defaultName}-db`
+		} } : {},
+		...agentModule ? { agent: {
+			binding: "AGENT",
+			className: "JuneAgentDO"
+		} } : {}
+	};
 	await adapter.emit({
 		appRoot,
 		outDir,
@@ -576,6 +640,7 @@ ${adapterEntry.wrap("pipeline")}
 		publicFiles
 	});
 	if (plan.db) console.log(`  ↳ d1 binding "${plan.db.binding}" emitted — set database_id in wrangler.jsonc (wrangler d1 create ${plan.db.databaseName})`);
+	if (plan.agent) console.log(`  ↳ durable agent mounted (${plan.agent.className} → env.${plan.agent.binding}; chat at ${frozen.agent.runtime.chat.path})`);
 	return {
 		outFile,
 		routes: routes.filter((r) => !r.dynamic).map((r) => r.path),