@electric-ax/agents 0.2.4 → 0.3.0

package/dist/index.js

@@ -1,25 +1,24 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { CODING_SESSION_CURSOR_COLLECTION_TYPE, CODING_SESSION_EVENT_COLLECTION_TYPE, CODING_SESSION_META_COLLECTION_TYPE, createEntityRegistry, createRuntimeHandler, db } from "@electric-ax/agents-runtime";
-import fsSync, { promises, watch } from "node:fs";
+import { completeWithLowCostModel, createEntityRegistry, createRuntimeHandler, db, detectAvailableProviders, readCodexAccessToken, registerToolProvider, unregisterToolProvider } from "@electric-ax/agents-runtime";
+import fs from "node:fs";
 import pino from "pino";
-import { spawn } from "node:child_process";
-import { homedir } from "node:os";
+import { eq, not, queryOnce } from "@durable-streams/state";
 import { z } from "zod";
-import { deserializeCursor, discoverSessions, importLocalSession, loadSession, resolveSession, serializeCursor, tailSession } from "agent-session-protocol";
-import Anthropic from "@anthropic-ai/sdk";
 import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
+import fs$1 from "node:fs/promises";
 import Database from "better-sqlite3";
 import { Type } from "@sinclair/typebox";
 import { load } from "sqlite-vec";
 import { nanoid } from "nanoid";
-import { braveSearchTool, braveSearchTool as braveSearchTool$1, createBashTool, createEditTool, createReadFileTool, createWriteTool, fetchUrlTool } from "@electric-ax/agents-runtime/tools";
+import { getModels } from "@mariozechner/pi-ai";
+import { braveSearchTool, braveSearchTool as braveSearchTool$1, createBashTool, createEditTool, createFetchUrlTool, createReadFileTool, createWriteTool, fetchUrlTool } from "@electric-ax/agents-runtime/tools";
+import { bridgeMcpTool, buildPromptTools, buildResourceTools, createRegistry, keychainPersistence, loadConfig, mcp, watchConfig } from "@electric-ax/agents-mcp";
 import { createServer } from "node:http";
 
 //#region src/log.ts
 const LOG_DIR = process.env.ELECTRIC_AGENTS_LOG_DIR ?? path.resolve(process.cwd(), `logs`);
-fsSync.mkdirSync(LOG_DIR, { recursive: true });
+fs.mkdirSync(LOG_DIR, { recursive: true });
 const LOG_FILE = path.join(LOG_DIR, `builtin-agents-${Date.now()}.jsonl`);
 const LOG_LEVEL = process.env.ELECTRIC_AGENTS_LOG_LEVEL ?? `info`;
 const USE_PRETTY_LOGS = LOG_LEVEL !== `silent` && !process.env.VITEST;
@@ -70,516 +69,6 @@ const serverLog = {
 	}
 };
 
-//#endregion
-//#region src/agents/coding-session.ts
-const defaultCliRunner = { async run(opts) {
-	return new Promise((resolve, reject) => {
-		const isClaude = opts.agent === `claude`;
-		const bin = isClaude ? `claude` : `codex`;
-		const args = isClaude ? opts.sessionId ? [
-			`-r`,
-			opts.sessionId,
-			`--dangerously-skip-permissions`,
-			`-p`
-		] : [`--dangerously-skip-permissions`, `-p`] : opts.sessionId ? [
-			`exec`,
-			`--skip-git-repo-check`,
-			`resume`,
-			opts.sessionId,
-			opts.prompt
-		] : [
-			`exec`,
-			`--skip-git-repo-check`,
-			opts.prompt
-		];
-		const child = spawn(bin, args, {
-			cwd: opts.cwd,
-			stdio: [
-				isClaude ? `pipe` : `ignore`,
-				`pipe`,
-				`pipe`
-			]
-		});
-		const MAX_BUF_CHARS = 4096;
-		let stdout = ``;
-		let stderr = ``;
-		child.stdout?.on(`data`, (d) => {
-			if (stdout.length < MAX_BUF_CHARS) stdout += d.toString().slice(0, MAX_BUF_CHARS - stdout.length);
-		});
-		child.stderr?.on(`data`, (d) => {
-			if (stderr.length < MAX_BUF_CHARS) stderr += d.toString().slice(0, MAX_BUF_CHARS - stderr.length);
-		});
-		child.on(`error`, reject);
-		child.on(`exit`, (code) => {
-			resolve({
-				exitCode: code ?? -1,
-				stdout,
-				stderr
-			});
-		});
-		if (isClaude && child.stdin) {
-			child.stdin.write(opts.prompt);
-			child.stdin.end();
-		}
-	});
-} };
-async function discoverNewestSession(agent, cwd, excludeIds) {
-	const all = await discoverSessions(agent);
-	const candidates = all.filter((s) => !excludeIds.has(s.sessionId) && (!s.cwd || s.cwd === cwd));
-	if (candidates.length === 0) return null;
-	return candidates[0].sessionId;
-}
-/**
-* Compute the candidate directories where Claude Code stores per-cwd
-* session JSONL files. Claude resolves the cwd to its realpath when
-* choosing the directory name (so /tmp/foo on macOS lands under
-* `-private-tmp-foo`), but the entity may have been spawned with the
-* non-realpath form. Return both candidates so the caller can union
-* their contents.
-*/
-async function getClaudeProjectDirs(cwd) {
-	const home = homedir();
-	const make = (c) => path.join(home, `.claude`, `projects`, c.replace(/\//g, `-`));
-	const dirs = [make(cwd)];
-	try {
-		const real = await promises.realpath(cwd);
-		if (real !== cwd) dirs.push(make(real));
-	} catch {}
-	return dirs;
-}
-async function listClaudeJsonlIdsByCwd(cwd) {
-	const ids = new Set();
-	for (const dir of await getClaudeProjectDirs(cwd)) try {
-		const files = await promises.readdir(dir);
-		for (const f of files) if (f.endsWith(`.jsonl`)) ids.add(f.slice(0, -`.jsonl`.length));
-	} catch {}
-	return ids;
-}
-/**
-* Deterministic-path discovery for a freshly created session. After the
-* Claude CLI runs in `-p` mode it writes the new JSONL straight into
-* `~/.claude/projects/<sanitize(cwd)>/<id>.jsonl` *without* leaving a
-* `~/.claude/sessions/<pid>.json` lock file (those are interactive-only),
-* so `discoverSessions` can miss it. Compute the expected dir directly
-* and diff its contents against a pre-run snapshot. Returns the newest
-* fresh sessionId or null. Codex falls back to discoverNewestSession.
-*/
-async function findNewSessionAfterRun(agent, cwd, preDirectIds, preDiscoveredIds) {
-	if (agent === `claude`) {
-		const dirs = await getClaudeProjectDirs(cwd);
-		let best = null;
-		for (const dir of dirs) try {
-			const files = await promises.readdir(dir);
-			for (const f of files) {
-				if (!f.endsWith(`.jsonl`)) continue;
-				const id = f.slice(0, -`.jsonl`.length);
-				if (preDirectIds.has(id)) continue;
-				const st = await promises.stat(path.join(dir, f)).catch(() => null);
-				if (!st) continue;
-				if (!best || st.mtimeMs > best.mtime) best = {
-					id,
-					mtime: st.mtimeMs
-				};
-			}
-		} catch {}
-		if (best) return best.id;
-	}
-	return discoverNewestSession(agent, cwd, preDiscoveredIds);
-}
-const sessionMetaRowSchema = z.object({
-	key: z.literal(`current`),
-	electricSessionId: z.string(),
-	nativeSessionId: z.string().optional(),
-	agent: z.enum([`claude`, `codex`]),
-	cwd: z.string(),
-	status: z.enum([
-		`initializing`,
-		`idle`,
-		`running`,
-		`error`
-	]),
-	error: z.string().optional(),
-	currentPromptInboxKey: z.string().optional()
-});
-const cursorStateRowSchema = z.object({
-	key: z.literal(`current`),
-	cursor: z.string(),
-	lastProcessedInboxKey: z.string().optional()
-});
-const eventRowSchema = z.object({
-	key: z.string(),
-	ts: z.number(),
-	type: z.string(),
-	callId: z.string().optional(),
-	payload: z.looseObject({})
-});
-const creationArgsSchema = z.object({
-	agent: z.enum([`claude`, `codex`]),
-	cwd: z.string().optional(),
-	nativeSessionId: z.string().optional(),
-	importFrom: z.object({
-		agent: z.enum([`claude`, `codex`]),
-		sessionId: z.string()
-	}).optional()
-});
-const promptMessageSchema = z.object({ text: z.string() });
-/**
-* Stable key for an events-collection row, derived from the event's content.
-* Lets us re-insert the same event without producing duplicates — the caller
-* (or the collection's uniqueness guard) uses this to de-dup across retries,
-* replays, and crash recovery. Sorts chronologically by ts, then by type.
-*/
-function eventKey(event) {
-	const tsPart = String(event.ts).padStart(16, `0`);
-	return `${tsPart}_${event.type}_${contentHashHex(event)}`;
-}
-function contentHashHex(event) {
-	const json = JSON.stringify(event);
-	let h = 5381;
-	for (let i = 0; i < json.length; i++) h = (h * 33 ^ json.charCodeAt(i)) >>> 0;
-	return h.toString(16).padStart(8, `0`);
-}
-function buildEventRow(event) {
-	const callId = `callId` in event && typeof event.callId === `string` ? event.callId : void 0;
-	return {
-		key: eventKey(event),
-		ts: event.ts,
-		type: event.type,
-		...callId !== void 0 ? { callId } : {},
-		payload: event
-	};
-}
-function appendIfNew(ctx, event) {
-	const row = buildEventRow(event);
-	if (ctx.events.get(row.key) !== void 0) return;
-	ctx.actions.events_insert({ row });
-}
-/**
-* Mirror every event that lands in the JSONL file while `runWork` is
-* executing (i.e. while the CLI is running). Returns the advanced cursor
-* and the `runWork` result once everything has settled and every append
-* has been persisted to the entity's durable stream.
-*
-* If setup fails (e.g. the session file can't be resolved), `runWork`
-* still runs — but nothing is mirrored and `setupError` is populated so
-* the caller can surface the condition. If `runWork` throws, the error
-* propagates after the watcher has been cleaned up.
-*/
-async function runWithLiveMirror(opts) {
-	let cursor = null;
-	let setupError = void 0;
-	try {
-		const session = await resolveSession(opts.nativeSessionId, opts.agent);
-		if (opts.serializedCursor) cursor = deserializeCursor({
-			...opts.serializedCursor,
-			path: session.path
-		});
-		else {
-			const initial = await loadSession({
-				sessionId: opts.nativeSessionId,
-				agent: opts.agent
-			});
-			for (const ev of initial.events) appendIfNew(opts.ctx, ev);
-			cursor = initial.cursor;
-		}
-	} catch (e) {
-		setupError = e;
-	}
-	if (!cursor) {
-		const result$1 = await opts.runWork();
-		return {
-			cursor: opts.serializedCursor,
-			setupError,
-			result: result$1
-		};
-	}
-	let activeCursor = cursor;
-	let busy = false;
-	let pending = false;
-	let stopped = false;
-	const drainOnce = async () => {
-		if (stopped && busy) return;
-		if (busy) {
-			pending = true;
-			return;
-		}
-		busy = true;
-		try {
-			const res = await tailSession({ cursor: activeCursor });
-			activeCursor = res.cursor;
-			for (const ev of res.newEvents) appendIfNew(opts.ctx, ev);
-		} catch {} finally {
-			busy = false;
-			if (pending && !stopped) {
-				pending = false;
-				drainOnce();
-			}
-		}
-	};
-	const fileWatcher = watch(activeCursor.path, () => {
-		drainOnce();
-	});
-	const pollHandle = setInterval(() => {
-		drainOnce();
-	}, 1500);
-	let result;
-	try {
-		result = await opts.runWork();
-	} finally {
-		stopped = true;
-		clearInterval(pollHandle);
-		fileWatcher.close();
-		while (busy) await new Promise((r) => setTimeout(r, 10));
-		try {
-			const final = await tailSession({ cursor: activeCursor });
-			activeCursor = final.cursor;
-			for (const ev of final.newEvents) appendIfNew(opts.ctx, ev);
-		} catch {}
-	}
-	return {
-		cursor: serializeCursor(activeCursor),
-		setupError,
-		result
-	};
-}
-function registerCodingSession(registry, options = {}) {
-	const runner = options.cliRunner ?? defaultCliRunner;
-	const defaultCwd = options.defaultWorkingDirectory ?? process.cwd();
-	registry.define(`coder`, {
-		description: `Runs a Claude Code / Codex CLI session and mirrors its normalized event stream into a durable store. Prompts arrive via message_received (type: "prompt") and are executed serially.`,
-		creationSchema: creationArgsSchema,
-		inboxSchemas: { prompt: promptMessageSchema },
-		state: {
-			sessionMeta: {
-				schema: sessionMetaRowSchema,
-				type: CODING_SESSION_META_COLLECTION_TYPE,
-				primaryKey: `key`
-			},
-			cursorState: {
-				schema: cursorStateRowSchema,
-				type: CODING_SESSION_CURSOR_COLLECTION_TYPE,
-				primaryKey: `key`
-			},
-			events: {
-				schema: eventRowSchema,
-				type: CODING_SESSION_EVENT_COLLECTION_TYPE,
-				primaryKey: `key`
-			}
-		},
-		async handler(ctx, _wake) {
-			const existingMeta = ctx.db.collections.sessionMeta.get(`current`);
-			if (!existingMeta) {
-				const args = creationArgsSchema.parse(ctx.args);
-				const cwd = args.cwd ?? defaultCwd;
-				const electricSessionId = ctx.entityUrl.split(`/`).pop() ?? ctx.entityUrl;
-				let resolvedNativeId = args.nativeSessionId;
-				if (args.importFrom) {
-					const result = await importLocalSession({
-						source: {
-							sessionId: args.importFrom.sessionId,
-							agent: args.importFrom.agent
-						},
-						target: {
-							agent: args.agent,
-							cwd
-						}
-					});
-					resolvedNativeId = result.sessionId;
-				}
-				const hasNative = resolvedNativeId !== void 0;
-				ctx.db.actions.sessionMeta_insert({ row: {
-					key: `current`,
-					electricSessionId,
-					...hasNative ? { nativeSessionId: resolvedNativeId } : {},
-					agent: args.agent,
-					cwd,
-					status: hasNative ? `idle` : `initializing`
-				} });
-			}
-			if (!ctx.db.collections.cursorState.get(`current`)) ctx.db.actions.cursorState_insert({ row: {
-				key: `current`,
-				cursor: ``
-			} });
-			const metaRow = ctx.db.collections.sessionMeta.get(`current`);
-			const cursorRow = ctx.db.collections.cursorState.get(`current`);
-			if (!metaRow || !cursorRow) throw new Error(`[coding-session] expected sessionMeta and cursorState rows to exist after init`);
-			if (metaRow.nativeSessionId && !cursorRow.cursor) {
-				const mirrorCtx = {
-					events: { get: (k) => ctx.db.collections.events.get(k) },
-					actions: { events_insert: ctx.db.actions.events_insert }
-				};
-				try {
-					const initial = await loadSession({
-						sessionId: metaRow.nativeSessionId,
-						agent: metaRow.agent
-					});
-					for (const ev of initial.events) appendIfNew(mirrorCtx, ev);
-					const serialized = serializeCursor(initial.cursor);
-					ctx.db.actions.cursorState_update({
-						key: `current`,
-						updater: (d) => {
-							d.cursor = JSON.stringify(serialized);
-						}
-					});
-				} catch (e) {
-					const message = e instanceof Error ? e.message : String(e);
-					ctx.db.actions.sessionMeta_update({
-						key: `current`,
-						updater: (d) => {
-							d.error = `initial mirror failed: ${message}`;
-						}
-					});
-				}
-			}
-			const inboxRows = ctx.db.collections.inbox.toArray.slice().sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-			const lastKey = cursorRow.lastProcessedInboxKey ?? ``;
-			const pending = inboxRows.filter((m) => m.key > lastKey);
-			if (pending.length === 0) {
-				if (metaRow.status === `running` || metaRow.status === `error`) ctx.db.actions.sessionMeta_update({
-					key: `current`,
-					updater: (d) => {
-						d.status = `idle`;
-						delete d.currentPromptInboxKey;
-						delete d.error;
-					}
-				});
-				return;
-			}
-			let runningMeta = metaRow;
-			let runningCursor = cursorRow;
-			for (const inboxMsg of pending) {
-				const parsed = promptMessageSchema.safeParse(inboxMsg.payload);
-				if (!parsed.success) {
-					ctx.db.actions.cursorState_update({
-						key: `current`,
-						updater: (d) => {
-							d.lastProcessedInboxKey = inboxMsg.key;
-						}
-					});
-					runningCursor = {
-						...runningCursor,
-						lastProcessedInboxKey: inboxMsg.key
-					};
-					continue;
-				}
-				const prompt = parsed.data.text;
-				const existingTitle = ctx.tags.title;
-				if (typeof existingTitle !== `string` || existingTitle.length === 0) ctx.setTag(`title`, prompt.slice(0, 80));
-				ctx.db.actions.sessionMeta_update({
-					key: `current`,
-					updater: (d) => {
-						d.status = `running`;
-						d.currentPromptInboxKey = inboxMsg.key;
-						delete d.error;
-					}
-				});
-				const recordedRun = ctx.recordRun();
-				const eventKeysBefore = new Set(ctx.db.collections.events.toArray.map((e) => e.key));
-				try {
-					const mirrorCtx = {
-						events: { get: (k) => ctx.db.collections.events.get(k) },
-						actions: { events_insert: ctx.db.actions.events_insert }
-					};
-					let nextCursorJson = runningCursor.cursor;
-					if (!runningMeta.nativeSessionId) {
-						const preDirectIds = runningMeta.agent === `claude` ? await listClaudeJsonlIdsByCwd(runningMeta.cwd) : new Set();
-						const preDiscoveredIds = new Set((await discoverSessions(runningMeta.agent)).map((s) => s.sessionId));
-						const cliResult = await runner.run({
-							agent: runningMeta.agent,
-							cwd: runningMeta.cwd,
-							prompt
-						});
-						if (cliResult.exitCode !== 0) throw new Error(`[coding-session] ${runningMeta.agent} CLI exited ${cliResult.exitCode}. stderr=${cliResult.stderr.slice(0, 800) || `<empty>`} stdout=${cliResult.stdout.slice(0, 800) || `<empty>`}`);
-						const foundId = await findNewSessionAfterRun(runningMeta.agent, runningMeta.cwd, preDirectIds, preDiscoveredIds);
-						if (!foundId) throw new Error(`[coding-session] ${runningMeta.agent} CLI succeeded but no new session file was found`);
-						ctx.db.actions.sessionMeta_update({
-							key: `current`,
-							updater: (d) => {
-								d.nativeSessionId = foundId;
-							}
-						});
-						runningMeta = {
-							...runningMeta,
-							nativeSessionId: foundId
-						};
-						const initial = await loadSession({
-							sessionId: foundId,
-							agent: runningMeta.agent
-						});
-						for (const ev of initial.events) appendIfNew(mirrorCtx, ev);
-						nextCursorJson = JSON.stringify(serializeCursor(initial.cursor));
-					} else {
-						const serializedCursor = runningCursor.cursor ? JSON.parse(runningCursor.cursor) : null;
-						const { cursor: nextSerialized, setupError, result: cliResult } = await runWithLiveMirror({
-							agent: runningMeta.agent,
-							nativeSessionId: runningMeta.nativeSessionId,
-							serializedCursor,
-							ctx: mirrorCtx,
-							runWork: () => runner.run({
-								agent: runningMeta.agent,
-								sessionId: runningMeta.nativeSessionId,
-								cwd: runningMeta.cwd,
-								prompt
-							})
-						});
-						if (setupError) throw setupError instanceof Error ? setupError : new Error(String(setupError));
-						if (cliResult.exitCode !== 0) throw new Error(`[coding-session] ${runningMeta.agent} CLI exited ${cliResult.exitCode}. stderr=${cliResult.stderr.slice(0, 800) || `<empty>`} stdout=${cliResult.stdout.slice(0, 800) || `<empty>`}`);
-						const persistedCursor = nextSerialized ?? serializedCursor;
-						nextCursorJson = persistedCursor ? JSON.stringify(persistedCursor) : ``;
-					}
-					ctx.db.actions.cursorState_update({
-						key: `current`,
-						updater: (d) => {
-							d.cursor = nextCursorJson;
-							d.lastProcessedInboxKey = inboxMsg.key;
-						}
-					});
-					runningCursor = {
-						...runningCursor,
-						cursor: nextCursorJson,
-						lastProcessedInboxKey: inboxMsg.key
-					};
-					for (const row of ctx.db.collections.events.toArray) {
-						if (eventKeysBefore.has(row.key)) continue;
-						if (row.type !== `assistant_message`) continue;
-						const text = row.payload?.text;
-						if (typeof text === `string` && text.length > 0) recordedRun.attachResponse(text);
-					}
-					recordedRun.end({ status: `completed` });
-				} catch (e) {
-					const message = e instanceof Error ? e.message : String(e);
-					recordedRun.end({
-						status: `failed`,
-						finishReason: `error`
-					});
-					ctx.db.actions.sessionMeta_update({
-						key: `current`,
-						updater: (d) => {
-							d.status = `error`;
-							d.error = message;
-						}
-					});
-					ctx.db.actions.cursorState_update({
-						key: `current`,
-						updater: (d) => {
-							d.lastProcessedInboxKey = inboxMsg.key;
-						}
-					});
-					throw e;
-				}
-			}
-			ctx.db.actions.sessionMeta_update({
-				key: `current`,
-				updater: (d) => {
-					d.status = `idle`;
-					delete d.currentPromptInboxKey;
-					delete d.error;
-				}
-			});
-		}
-	});
-}
-
 //#endregion
 //#region src/docs/embed.ts
 const EMBEDDING_DIMENSIONS = 128;
@@ -650,7 +139,7 @@ function normalizeWhitespace(value) {
 }
 async function collectMarkdownFiles(root) {
 	async function walk(dir) {
-		const entries = await fs.readdir(dir, { withFileTypes: true });
+		const entries = await fs$1.readdir(dir, { withFileTypes: true });
 		const files = [];
 		for (const entry of entries) {
 			const fullPath = path.join(dir, entry.name);
@@ -826,7 +315,7 @@ function resolveDocsRoot(workingDirectory) {
 			requireIndex: false
 		}
 	].filter((value) => Boolean(value));
-	for (const candidate of candidates) if (fsSync.existsSync(candidate.path) && (!candidate.requireIndex || fsSync.existsSync(path.join(candidate.path, `index.md`)))) return candidate.path;
+	for (const candidate of candidates) if (fs.existsSync(candidate.path) && (!candidate.requireIndex || fs.existsSync(path.join(candidate.path, `index.md`)))) return candidate.path;
 	return null;
 }
 var DocsKnowledgeBase = class {
@@ -847,7 +336,7 @@ var DocsKnowledgeBase = class {
 		this.readyPromise = this.ensureIngested();
 	}
 	openDatabase() {
-		fsSync.mkdirSync(path.dirname(this.dbPath), { recursive: true });
+		fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
 		try {
 			const db$1 = new Database(this.dbPath);
 			load(db$1);
@@ -914,11 +403,11 @@ var DocsKnowledgeBase = class {
 		};
 	}
 	async ensureIngested() {
-		await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
+		await fs$1.mkdir(path.dirname(this.dbPath), { recursive: true });
 		const files = (await collectMarkdownFiles(this.docsRoot)).sort();
 		const docs = await Promise.all(files.map(async (filePath) => ({
 			path: path.relative(this.docsRoot, filePath),
-			content: await fs.readFile(filePath, `utf8`)
+			content: await fs$1.readFile(filePath, `utf8`)
 		})));
 		const fingerprint = createFingerprint(docs);
 		if (!this.db) {
@@ -1265,7 +754,7 @@ function createSkillTools(registry, ctx) {
 			const mdFiles = allRefFiles.filter((f) => f.endsWith(`.md`));
 			const refContents = [];
 			for (const f of mdFiles) try {
-				const refContent = await fs.readFile(path.join(skillDir, f), `utf-8`);
+				const refContent = await fs$1.readFile(path.join(skillDir, f), `utf-8`);
 				const refId = `${skillContextId(name)}:${f}`;
 				ctx.insertContext(refId, {
 					name: `skill_reference`,
@@ -1365,10 +854,10 @@ function substituteArgs(content, rawArgs, argNames) {
 function listRefFiles(dir, prefix = ``) {
 	try {
 		const results = [];
-		for (const entry of fsSync.readdirSync(dir)) {
+		for (const entry of fs.readdirSync(dir)) {
 			const full = path.join(dir, entry);
 			const rel = prefix ? `${prefix}/${entry}` : entry;
-			if (fsSync.statSync(full).isDirectory()) results.push(...listRefFiles(full, rel));
+			if (fs.statSync(full).isDirectory()) results.push(...listRefFiles(full, rel));
 			else results.push(rel);
 		}
 		return results;
@@ -1384,11 +873,11 @@ const WORKER_TOOL_NAMES = [
 	`read`,
 	`write`,
 	`edit`,
-	`brave_search`,
+	`web_search`,
 	`fetch_url`,
 	`spawn_worker`
 ];
-function createSpawnWorkerTool(ctx) {
+function createSpawnWorkerTool(ctx, modelConfig) {
 	return {
 		name: `spawn_worker`,
 		label: `Spawn Worker`,
@@ -1415,10 +904,16 @@ function createSpawnWorkerTool(ctx) {
 				details: { spawned: false }
 			};
 			const id = nanoid(10);
+			const workerModelArgs = modelConfig ? {
+				provider: modelConfig.provider,
+				model: modelConfig.model,
+				...modelConfig.reasoningEffort && { reasoningEffort: modelConfig.reasoningEffort }
+			} : {};
 			try {
 				const handle = await ctx.spawn(`worker`, id, {
 					systemPrompt,
-					tools
+					tools,
+					...workerModelArgs
 				}, {
 					initialMessage,
 					wake: {
@@ -1452,140 +947,138 @@ function createSpawnWorkerTool(ctx) {
 }
 
 //#endregion
-//#region src/tools/spawn-coder.ts
-const CODER_AGENT_NAMES = [`claude`, `codex`];
-function createSpawnCoderTool(ctx) {
+//#region src/model-catalog.ts
+const REASONING_EFFORT_VALUES = [
+	`auto`,
+	`minimal`,
+	`low`,
+	`medium`,
+	`high`
+];
+const DEFAULT_ANTHROPIC_MODEL = `claude-sonnet-4-6`;
+const DEFAULT_OPENAI_MODEL = `gpt-4.1`;
+const DEFAULT_CODEX_MODEL = `gpt-5.4`;
+function modelValue(provider, id) {
+	return `${provider}:${id}`;
+}
+function providerLabel(provider) {
+	if (provider === `anthropic`) return `Anthropic`;
+	if (provider === `openai-codex`) return `OpenAI Codex`;
+	return `OpenAI`;
+}
+function configuredProviders() {
+	return detectAvailableProviders();
+}
+function mockFallbackCatalog() {
+	const fallback = {
+		provider: `anthropic`,
+		id: DEFAULT_ANTHROPIC_MODEL,
+		label: `Anthropic ${DEFAULT_ANTHROPIC_MODEL}`,
+		value: modelValue(`anthropic`, DEFAULT_ANTHROPIC_MODEL),
+		reasoning: true
+	};
 	return {
-		name: `spawn_coder`,
-		label: `Spawn Coder`,
-		description: `Spawn a coding-session subagent (a coder) that drives a Claude Code or Codex CLI session in a working directory. Use when the user asks for code changes, file edits, debugging, or any task that benefits from a real coding agent with tool access. The coder is long-lived — its URL stays valid across many turns, so you can keep prompting it via prompt_coder without re-spawning. End your turn after spawning; you'll be woken when the coder finishes its first reply.`,
-		parameters: Type.Object({
-			prompt: Type.String({ description: `First user message sent to the coder. This is what kicks off the run — without it the coder will idle. Be concrete: describe the task, mention the files/paths involved, and what form of answer you want back.` }),
-			agent: Type.Optional(Type.Union(CODER_AGENT_NAMES.map((n) => Type.Literal(n)), { description: `Which coding agent to use. Defaults to "claude". Use "codex" only if the user explicitly asks for it.` })),
-			cwd: Type.Optional(Type.String({ description: `Working directory the coder runs in. Defaults to the runtime's cwd (the same directory Horton is running in). Set this when the user wants the coder to operate on a different repo.` }))
-		}),
-		execute: async (_toolCallId, params) => {
-			const { prompt, agent, cwd } = params;
-			if (typeof prompt !== `string` || prompt.length === 0) return {
-				content: [{
-					type: `text`,
-					text: `Error: prompt is required and must be a non-empty string.`
-				}],
-				details: { spawned: false }
-			};
-			const id = nanoid(10);
-			const spawnArgs = { agent: agent ?? `claude` };
-			if (cwd) spawnArgs.cwd = cwd;
-			try {
-				const handle = await ctx.spawn(`coder`, id, spawnArgs, {
-					initialMessage: { text: prompt },
-					wake: {
-						on: `runFinished`,
-						includeResponse: true
-					}
-				});
-				const coderUrl = handle.entityUrl;
-				return {
-					content: [{
-						type: `text`,
-						text: `Coder dispatched at ${coderUrl}. End your turn — when the coder finishes its current reply you'll be woken with the response. To send follow-up prompts to the same coder, call prompt_coder with this URL.`
-					}],
-					details: {
-						spawned: true,
-						coderUrl
-					}
-				};
-			} catch (err) {
-				serverLog.warn(`[spawn_coder tool] failed to spawn coder ${id}: ${err instanceof Error ? err.message : String(err)}`, err instanceof Error ? err : void 0);
-				return {
-					content: [{
-						type: `text`,
-						text: `Error spawning coder: ${err instanceof Error ? err.message : `Unknown error`}`
-					}],
-					details: { spawned: false }
-				};
-			}
-		}
+		choices: [fallback],
+		defaultChoice: fallback
 	};
 }
-function createPromptCoderTool(ctx) {
+async function fetchAvailableModelIds(provider) {
+	try {
+		const res = provider === `anthropic` ? await fetch(`https://api.anthropic.com/v1/models`, {
+			headers: {
+				"x-api-key": process.env.ANTHROPIC_API_KEY ?? ``,
+				"anthropic-version": `2023-06-01`
+			},
+			signal: AbortSignal.timeout(3e3)
+		}) : await fetch(`https://api.openai.com/v1/models`, {
+			headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY ?? ``}` },
+			signal: AbortSignal.timeout(3e3)
+		});
+		if (res.status === 401 || res.status === 403) return new Set();
+		if (!res.ok) return null;
+		const body = await res.json();
+		const ids = new Set((body.data ?? []).map((model) => model.id).filter((id) => typeof id === `string`));
+		return ids.size > 0 ? ids : null;
+	} catch {
+		return null;
+	}
+}
+async function choicesForProvider(provider) {
+	const knownModels = getModels(provider);
+	if (provider === `openai-codex`) return knownModels.map((model) => ({
+		provider,
+		id: model.id,
+		label: `${providerLabel(provider)} ${model.name}`,
+		value: modelValue(provider, model.id),
+		reasoning: model.reasoning
+	}));
+	const availableIds = await fetchAvailableModelIds(provider);
+	const models = availableIds === null ? knownModels : knownModels.filter((model) => availableIds.has(model.id));
+	return models.map((model) => ({
+		provider,
+		id: model.id,
+		label: `${providerLabel(provider)} ${model.name}`,
+		value: modelValue(provider, model.id),
+		reasoning: model.reasoning
+	}));
+}
+function withProviderPayloadDefaults(config, choice, reasoningEffort) {
+	if (choice.provider !== `openai` && choice.provider !== `openai-codex` || !choice.reasoning) return config;
+	const defaultEffort = choice.provider === `openai-codex` ? `low` : `minimal`;
+	const effort = reasoningEffort === `minimal` && choice.provider === `openai-codex` ? `low` : reasoningEffort ?? defaultEffort;
 	return {
-		name: `prompt_coder`,
-		label: `Prompt Coder`,
-		description: `Send a follow-up prompt to a coder you previously spawned. The prompt is queued on the coder's inbox and runs as the next CLI turn. End your turn after calling — you'll be woken when the coder's reply lands.`,
-		parameters: Type.Object({
-			coder_url: Type.String({ description: `Entity URL returned by spawn_coder, e.g. "/coder/abc123". Must be the URL of a coder you previously spawned in this conversation.` }),
-			prompt: Type.String({ description: `Follow-up message to send to the coder. Treat this like the next turn in a chat — reference earlier context the coder already saw rather than restating it.` })
-		}),
-		execute: async (_toolCallId, params) => {
-			const { coder_url, prompt } = params;
-			if (typeof coder_url !== `string` || !coder_url.startsWith(`/coder/`)) return {
-				content: [{
-					type: `text`,
-					text: `Error: coder_url must be a path like "/coder/<id>".`
-				}],
-				details: { sent: false }
-			};
-			if (typeof prompt !== `string` || prompt.length === 0) return {
-				content: [{
-					type: `text`,
-					text: `Error: prompt is required and must be a non-empty string.`
-				}],
-				details: { sent: false }
+		...config,
+		onPayload: (payload) => {
+			if (typeof payload !== `object` || payload === null) return void 0;
+			const body = payload;
+			const existingReasoning = typeof body.reasoning === `object` && body.reasoning !== null ? body.reasoning : {};
+			return {
+				...body,
+				reasoning: {
+					...existingReasoning,
+					effort
+				}
 			};
-			try {
-				ctx.send(coder_url, { text: prompt });
-				return {
-					content: [{
-						type: `text`,
-						text: `Prompt queued for ${coder_url}. End your turn — you'll be woken when the coder's reply lands.`
-					}],
-					details: {
-						sent: true,
-						coderUrl: coder_url
-					}
-				};
-			} catch (err) {
-				serverLog.warn(`[prompt_coder tool] failed to send to ${coder_url}: ${err instanceof Error ? err.message : String(err)}`, err instanceof Error ? err : void 0);
-				return {
-					content: [{
-						type: `text`,
-						text: `Error sending prompt to coder: ${err instanceof Error ? err.message : `Unknown error`}`
-					}],
-					details: { sent: false }
-				};
-			}
 		}
 	};
 }
+function parseReasoningEffort(value) {
+	return value === `minimal` || value === `low` || value === `medium` || value === `high` ? value : null;
+}
+async function createBuiltinModelCatalog(options = {}) {
+	const providers = configuredProviders();
+	if (providers.length === 0 && options.allowMockFallback) return mockFallbackCatalog();
+	const choices = (await Promise.all(providers.map((provider) => choicesForProvider(provider)))).flat();
+	if (choices.length === 0) return options.allowMockFallback ? mockFallbackCatalog() : null;
+	const defaultChoice = choices.find((choice) => choice.provider === `anthropic` && choice.id === DEFAULT_ANTHROPIC_MODEL) ?? choices.find((choice) => choice.provider === `openai` && choice.id === DEFAULT_OPENAI_MODEL) ?? choices.find((choice) => choice.provider === `openai-codex` && choice.id === DEFAULT_CODEX_MODEL) ?? choices[0];
+	return {
+		choices,
+		defaultChoice
+	};
+}
+function resolveBuiltinModelConfig(catalog, args) {
+	const modelArg = args.model;
+	const providerArg = args.provider;
+	const reasoningEffort = parseReasoningEffort(args.reasoningEffort);
+	const selected = typeof modelArg === `string` ? catalog.choices.find((choice$1) => choice$1.value === modelArg || choice$1.id === modelArg && choice$1.provider === providerArg) : void 0;
+	const choice = selected ?? catalog.defaultChoice;
+	const config = {
+		provider: choice.provider,
+		model: choice.id,
+		...reasoningEffort && { reasoningEffort },
+		...choice.provider === `openai-codex` && { getApiKey: () => readCodexAccessToken() }
+	};
+	return withProviderPayloadDefaults(config, choice, reasoningEffort);
+}
+function modelChoiceValues(catalog) {
+	return catalog.choices.map((choice) => choice.value);
+}
 
 //#endregion
 //#region src/agents/horton.ts
-const TITLE_MODEL = `claude-haiku-4-5-20251001`;
 const HORTON_MODEL = `claude-sonnet-4-6`;
-let anthropic = null;
-function getClient() {
-	if (!anthropic) anthropic = new Anthropic();
-	return anthropic;
-}
-async function defaultHaikuCall(prompt) {
-	const client = getClient();
-	const res = await client.messages.create({
-		model: TITLE_MODEL,
-		max_tokens: 64,
-		messages: [{
-			role: `user`,
-			content: prompt
-		}]
-	});
-	const block = res.content[0];
-	return block?.type === `text` ? block.text : ``;
-}
-const TITLE_PROMPT = (userMessage) => `Summarize the following user request in 3-5 words for use as a chat session title.
-Respond with only the title, no quotes, no punctuation, no preamble.
-
-User request:
-${userMessage}`;
+const TITLE_SYSTEM_PROMPT = "You generate concise chat session titles in 3-5 words. Respond with only the title, no quotes, no punctuation, no preamble.";
+const TITLE_USER_PROMPT = (userMessage) => `User request:\n${userMessage}`;
 const TITLE_STOP_WORDS = new Set([
 	`a`,
 	`an`,
@@ -1653,19 +1146,34 @@ function buildFallbackTitle(userMessage) {
 	const selected = informativeWords.length >= 2 ? informativeWords.slice(0, 5) : backupWords;
 	return selected.join(` `).slice(0, 80).trim() || `Untitled Chat`;
 }
-async function generateTitle(userMessage, llmCall = defaultHaikuCall) {
+function createConfiguredTitleCall(catalog, modelConfig, logPrefix) {
+	return (prompt) => completeWithLowCostModel({
+		catalog,
+		modelConfig,
+		log: (message) => serverLog.info(message),
+		logPrefix,
+		purpose: `title generation`,
+		systemPrompt: TITLE_SYSTEM_PROMPT,
+		prompt,
+		maxTokens: 64
+	});
+}
+async function generateTitle(userMessage, llmCall, onFallback) {
 	try {
-		const raw = await llmCall(TITLE_PROMPT(userMessage));
+		const raw = await llmCall(TITLE_USER_PROMPT(userMessage));
 		const title = raw.trim();
-		return title.length > 0 ? title : buildFallbackTitle(userMessage);
-	} catch {
+		if (title.length > 0) return title;
+		onFallback?.(`empty LLM title response`);
+		return buildFallbackTitle(userMessage);
+	} catch (err) {
+		onFallback?.(err instanceof Error ? err.message : String(err));
 		return buildFallbackTitle(userMessage);
 	}
 }
 function buildHortonSystemPrompt(workingDirectory, opts = {}) {
 	const docsTools = opts.hasDocsSupport ? `\n- search_durable_agents_docs: hybrid search over the built-in Durable Agents docs index` : ``;
 	const skillsTools = opts.hasSkills ? `\n- use_skill: load a skill (knowledge, instructions, or a tutorial) into your context to help with the user's request\n- remove_skill: unload a skill from context when you're done with it` : ``;
-	const docsGuidance = opts.hasDocsSupport ? `\n- For ANY question about Electric Agents, Durable Agents, or this framework, ALWAYS use search_durable_agents_docs FIRST. Do not use brave_search or fetch_url for Electric Agents topics unless the docs search returns no useful results.\n- The search tool returns chunk content directly — you do not need to read the source files.\n- Use repo read/bash tools only for non-doc files or when you need to inspect exact implementation code in the workspace.` : ``;
+	const docsGuidance = opts.hasDocsSupport ? `\n- For ANY question about Electric Agents, Durable Agents, or this framework, ALWAYS use search_durable_agents_docs FIRST. Do not use web_search or fetch_url for Electric Agents topics unless the docs search returns no useful results.\n- The search tool returns chunk content directly — you do not need to read the source files.\n- Use repo read/bash tools only for non-doc files or when you need to inspect exact implementation code in the workspace.` : ``;
 	const skillsGuidance = opts.hasSkills ? `\n# Skills\nYou have access to skills — specialized knowledge and guided workflows you can load on demand. Your context includes a skills catalog listing what's available. When the user's request matches a skill's description or keywords, load it with use_skill.
 
 Some skills are user-invocable — the user can trigger them with a slash command like \`/quickstart\`. When you see a message starting with \`/\` followed by a skill name, load that skill immediately with use_skill. Pass any text after the skill name as args.
@@ -1701,7 +1209,9 @@ Don't force onboarding. If someone just wants to chat or code, let them. When in
 - ${opts.hasDocsSupport ? `If search_durable_agents_docs is available, use it first (faster, hybrid search).` : `Use fetch_url to look up documentation pages.`}
 - The Electric Agents docs site is at ${opts.docsUrl}
 - The docs site covers: Usage (entity definition, handlers, tools, state, spawning, coordination, waking, shared state, client integration, app setup), Reference (handler context, entity definitions, configurations, tools, state proxies, wake events, registries), Entities (Horton, Worker), and Patterns (Manager-Worker, Pipeline, Map-Reduce, Dispatcher, Blackboard, Reactive Observers).
-- For general coding questions unrelated to Electric Agents, use brave_search or your own knowledge.` : ``;
+- For general coding questions unrelated to Electric Agents, use web_search or your own knowledge.` : ``;
+	const modelGuidance = opts.modelProvider && opts.modelId ? `\n# Runtime model
+You are currently running via provider "${opts.modelProvider}" with model "${opts.modelId}". If the user asks what model or provider you are using, answer with these exact runtime values. Do not infer your model identity from training data or from the name of another coding tool.` : ``;
 	return `You are Horton, a friendly and capable assistant. You can chat, research the web, read and edit code, run shell commands, and dispatch subagents (workers) for isolated subtasks. Be warm and engaging in conversation; be precise and concrete when working with code.
 
 # Greetings
@@ -1712,18 +1222,16 @@ When a user opens with a greeting ("hi", "hello", "hey", etc.) or a broad statem
 - read: read a file
 - write: create or overwrite a file
 - edit: targeted string replacement in an existing file (you must read the file first)
-- brave_search: search the web
+- web_search: search the web
 - fetch_url: fetch and convert a URL to markdown
 - spawn_worker: dispatch a subagent for an isolated task
-- spawn_coder: spawn a long-lived coding agent (Claude Code or Codex CLI) for code changes, file edits, debugging
-- prompt_coder: send a follow-up prompt to a coder you previously spawned
 ${docsTools}${skillsTools}
 
 # Working with files
 - Prefer edit over write when modifying existing files.
 - You must read a file before you can edit it.
 - Use absolute paths or paths relative to the current working directory.
-${docsGuidance}${skillsGuidance}${onboardingGuidance}${docsUrlGuidance}
+${modelGuidance}${docsGuidance}${skillsGuidance}${onboardingGuidance}${docsUrlGuidance}
 
 # Risky actions
 Pause and confirm with the user before:
@@ -1744,13 +1252,6 @@ When you spawn a worker, write its system prompt the way you'd brief a colleague
 
 After spawning, end your turn (optionally with a brief "I've dispatched a worker for X; I'll respond when it finishes"). When the worker finishes, you'll receive a message describing which worker completed and what it returned. Multiple workers may finish at different times — check the message for the worker URL to know which one you're hearing about.
 
-# When to spawn a coder
-Spawn a coder when the user asks for code changes, file edits, debugging, or any task that benefits from a real coding agent with full tool access (bash, file edits, etc.). A coder runs Claude Code or Codex CLI under the hood.
-
-Unlike a worker, a coder is **long-lived**: its URL stays valid across many turns. Spawn once with spawn_coder, then keep prompting it via prompt_coder for follow-ups — don't spawn a new coder for each turn. Treat the coder URL like a chat handle.
-
-After calling spawn_coder or prompt_coder, end your turn. When the coder's reply lands, you'll be woken with the response in the wake message — relay it (or a summary) back to the user, and call prompt_coder again if there's a follow-up.
-
 # Reporting
 Report outcomes faithfully. If a command failed, say so with the relevant output. If you didn't run a verification step, say that rather than implying you did. Don't hedge confirmed results with unnecessary disclaimers.
 
@@ -1764,34 +1265,82 @@ function createHortonTools(workingDirectory, ctx, readSet, opts = {}) {
 		createWriteTool(workingDirectory, readSet),
 		createEditTool(workingDirectory, readSet),
 		braveSearchTool$1,
-		fetchUrlTool,
-		createSpawnWorkerTool(ctx),
-		createSpawnCoderTool(ctx),
-		createPromptCoderTool(ctx),
+		...opts.modelCatalog && opts.modelConfig ? [createFetchUrlTool({
+			catalog: opts.modelCatalog,
+			modelConfig: opts.modelConfig,
+			log: (message) => serverLog.info(message),
+			logPrefix: opts.logPrefix ?? `[horton]`
+		})] : [fetchUrlTool],
+		createSpawnWorkerTool(ctx, opts.modelConfig),
 		...opts.docsSearchTool ? [opts.docsSearchTool] : []
 	];
 }
-function extractFirstUserMessage(events) {
-	for (const event of events) {
-		if (event.type !== `message_received`) continue;
-		const value = event.value;
-		if (!value || value.from === `system`) continue;
-		const payload = value.payload;
-		if (typeof payload === `string`) return payload;
-		if (payload != null) return JSON.stringify(payload);
+function payloadToTitleText(payload) {
+	if (typeof payload === `string`) return payload;
+	if (payload == null) return ``;
+	if (typeof payload === `object`) {
+		const text = payload.text;
+		return typeof text === `string` ? text : JSON.stringify(payload);
+	}
+	return String(payload);
+}
+async function extractFirstUserMessage(ctx) {
+	const firstMessage = await queryOnce((q) => q.from({ inbox: ctx.db.collections.inbox }).where(({ inbox }) => not(eq(inbox.from, `system`))).orderBy(({ inbox }) => inbox._seq, `asc`).findOne());
+	if (!firstMessage) return null;
+	const text = payloadToTitleText(firstMessage.payload);
+	return text.length > 0 ? text : null;
+}
+function readAgentsMd(workingDirectory) {
+	const agentsMdPath = path.join(workingDirectory, `AGENTS.md`);
+	try {
+		if (!fs.existsSync(agentsMdPath) || !fs.statSync(agentsMdPath).isFile()) return null;
+		const content = fs.readFileSync(agentsMdPath, `utf8`);
+		return [
+			`<context_file kind="instructions" path="${agentsMdPath}">`,
+			content,
+			`</context_file>`
+		].join(`\n`);
+	} catch {
+		return null;
 	}
-	return null;
 }
 function createAssistantHandler(options) {
-	const { workingDirectory, streamFn, docsSupport, docsSearchTool, skillsRegistry, docsUrl } = options;
+	const { workingDirectory, streamFn, docsSupport, docsSearchTool, skillsRegistry, modelCatalog, docsUrl } = options;
 	const hasSkills = Boolean(skillsRegistry && skillsRegistry.catalog.size > 0);
 	return async function assistantHandler(ctx, wake) {
 		const readSet = new Set();
+		const effectiveCwd = typeof ctx.args.workingDirectory === `string` && ctx.args.workingDirectory.trim().length > 0 ? ctx.args.workingDirectory : workingDirectory;
+		const modelConfig = resolveBuiltinModelConfig(modelCatalog, ctx.args);
+		const agentsMd = readAgentsMd(effectiveCwd);
 		const tools = [
 			...ctx.electricTools,
-			...createHortonTools(workingDirectory, ctx, readSet, { docsSearchTool }),
-			...skillsRegistry && skillsRegistry.catalog.size > 0 ? createSkillTools(skillsRegistry, ctx) : []
+			...createHortonTools(effectiveCwd, ctx, readSet, {
+				docsSearchTool,
+				modelConfig,
+				modelCatalog,
+				logPrefix: `[horton ${ctx.entityUrl}]`
+			}),
+			...skillsRegistry && skillsRegistry.catalog.size > 0 ? createSkillTools(skillsRegistry, ctx) : [],
+			...mcp.tools()
 		];
+		const titlePromise = ctx.firstWake && !ctx.tags.title ? (async () => {
+			const firstUserMessage = await extractFirstUserMessage(ctx);
+			if (!firstUserMessage) return;
+			let title = null;
+			try {
+				const result = await generateTitle(firstUserMessage, createConfiguredTitleCall(modelCatalog, modelConfig, `[horton ${ctx.entityUrl}]`), (reason) => {
+					serverLog.warn(`[horton ${ctx.entityUrl}] title generation fell back to local title: ${reason}`);
+				});
+				if (result.length > 0) title = result;
+			} catch (err) {
+				serverLog.warn(`[horton ${ctx.entityUrl}] title generation failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			if (title !== null) try {
+				await ctx.setTag(`title`, title);
+			} catch (err) {
+				serverLog.warn(`[horton ${ctx.entityUrl}] setTag failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		})() : Promise.resolve();
 		if (docsSupport) ctx.useContext({
 			sourceBudget: 1e5,
 			sources: {
@@ -1809,6 +1358,11 @@ function createAssistantHandler(options) {
 					content: () => ctx.timelineMessages(),
 					cache: `volatile`
 				},
+				...agentsMd ? { agents_md: {
+					content: () => agentsMd,
+					max: 2e4,
+					cache: `stable`
+				} } : {},
 				...skillsRegistry && skillsRegistry.catalog.size > 0 ? { skills_catalog: {
 					content: () => skillsRegistry.renderCatalog(2e3),
 					max: 2e3,
@@ -1827,41 +1381,46 @@ function createAssistantHandler(options) {
 				conversation: {
 					content: () => ctx.timelineMessages(),
 					cache: `volatile`
+				},
+				...agentsMd ? { agents_md: {
+					content: () => agentsMd,
+					max: 2e4,
+					cache: `stable`
+				} } : {}
+			}
+		});
+		else if (agentsMd) ctx.useContext({
+			sourceBudget: 1e5,
+			sources: {
+				conversation: {
+					content: () => ctx.timelineMessages(),
+					cache: `volatile`
+				},
+				agents_md: {
+					content: () => agentsMd,
+					max: 2e4,
+					cache: `stable`
 				}
 			}
 		});
 		ctx.useAgent({
-			systemPrompt: buildHortonSystemPrompt(workingDirectory, {
+			systemPrompt: buildHortonSystemPrompt(effectiveCwd, {
 				hasDocsSupport: Boolean(docsSupport),
 				hasSkills,
-				docsUrl
+				docsUrl,
+				modelProvider: modelConfig.provider,
+				modelId: String(modelConfig.model)
 			}),
-			model: HORTON_MODEL,
+			...modelConfig,
 			tools,
 			...streamFn && { streamFn }
 		});
 		await ctx.agent.run();
-		if (ctx.firstWake && !ctx.tags.title) {
-			const firstUserMessage = extractFirstUserMessage(ctx.events);
-			if (firstUserMessage) {
-				let title = null;
-				try {
-					const result = await generateTitle(firstUserMessage);
-					if (result.length > 0) title = result;
-				} catch (err) {
-					serverLog.warn(`[horton ${ctx.entityUrl}] title generation failed: ${err instanceof Error ? err.message : String(err)}`);
-				}
-				if (title !== null) try {
-					await ctx.setTag(`title`, title);
-				} catch (err) {
-					serverLog.warn(`[horton ${ctx.entityUrl}] setTag failed: ${err instanceof Error ? err.message : String(err)}`);
-				}
-			}
-		}
+		await titlePromise;
 	};
 }
 function registerHorton(registry, options) {
-	const { workingDirectory, streamFn, skillsRegistry = null } = options;
+	const { workingDirectory, streamFn, skillsRegistry = null, modelCatalog } = options;
 	const docsUrl = options.docsUrl ?? process.env.HORTON_DOCS_URL;
 	if (process.env.BRAVE_SEARCH_API_KEY) serverLog.info(`[horton] Web search: using Brave Search API`);
 	else serverLog.warn(`[horton] BRAVE_SEARCH_API_KEY not set — web search will fall back to Anthropic built-in search (uses your ANTHROPIC_API_KEY)`);
@@ -1876,10 +1435,17 @@ function registerHorton(registry, options) {
 		docsSupport,
 		docsSearchTool,
 		skillsRegistry,
+		modelCatalog,
 		docsUrl
 	});
+	const hortonCreationSchema = z.object({
+		model: z.enum(modelChoiceValues(modelCatalog)).default(modelCatalog.defaultChoice.value),
+		reasoningEffort: z.enum(REASONING_EFFORT_VALUES).default(`auto`).describe(`Reasoning effort for compatible reasoning models. Auto uses a safe provider default.`),
+		workingDirectory: z.string().optional().describe(`Working directory for file operations. Defaults to the server's configured cwd.`)
+	});
 	registry.define(`horton`, {
 		description: `Friendly capable assistant — chat, code, research, dispatch`,
+		creationSchema: hortonCreationSchema,
 		handler: assistantHandler
 	});
 	const typeNames = [`horton`];
@@ -1924,6 +1490,9 @@ function parseWorkerArgs(value) {
 		};
 	}
 	if (tools.length === 0 && !args.sharedDb) throw new Error(`[worker] must provide tools and/or sharedDb`);
+	if (typeof value.model === `string`) args.model = value.model;
+	if (typeof value.provider === `string`) args.provider = value.provider;
+	if (typeof value.reasoningEffort === `string` && REASONING_EFFORT_VALUES.includes(value.reasoningEffort)) args.reasoningEffort = value.reasoningEffort;
 	return args;
 }
 function buildToolsForWorker(tools, workingDirectory, ctx, readSet) {
@@ -1941,7 +1510,7 @@ function buildToolsForWorker(tools, workingDirectory, ctx, readSet) {
 		case `edit`:
 			out.push(createEditTool(workingDirectory, readSet));
 			break;
-		case `brave_search`:
+		case `web_search`:
 			out.push(braveSearchTool$1);
 			break;
 		case `fetch_url`:
@@ -2050,13 +1619,14 @@ function buildSharedStateTools(shared, schema, mode) {
 	return tools;
 }
 function registerWorker(registry, options) {
-	const { workingDirectory, streamFn } = options;
+	const { workingDirectory, streamFn, modelCatalog } = options;
 	registry.define(`worker`, {
 		description: `Internal — generic worker spawned by other agents. Configure via spawn args (systemPrompt + tools + optional sharedDb).`,
 		async handler(ctx) {
 			const args = parseWorkerArgs(ctx.args);
 			const readSet = new Set();
 			const builtinTools = buildToolsForWorker(args.tools, workingDirectory, ctx, readSet);
+			const modelConfig = resolveBuiltinModelConfig(modelCatalog, args);
 			const sharedStateTools = [];
 			if (args.sharedDb) {
 				const shared = await ctx.observe(db(args.sharedDb.id, args.sharedDb.schema));
@@ -2064,7 +1634,7 @@ function registerWorker(registry, options) {
 			}
 			ctx.useAgent({
 				systemPrompt: `${args.systemPrompt}${WORKER_PROMPT_FOOTER}`,
-				model: HORTON_MODEL,
+				...modelConfig,
 				tools: [...builtinTools, ...sharedStateTools],
 				...streamFn && { streamFn }
 			});
@@ -2154,7 +1724,6 @@ function stripQuotes(value) {
 
 //#endregion
 //#region src/skills/extract-meta.ts
-const EXTRACT_MODEL = `claude-haiku-4-5-20251001`;
 const DEFAULT_MAX = 1e4;
 async function extractSkillMeta(name, content) {
 	const preamble = parsePreamble(content);
@@ -2167,7 +1736,7 @@ async function extractSkillMeta(name, content) {
 		...preamble.userInvocable && { userInvocable: true },
 		max: preamble.max ?? DEFAULT_MAX
 	};
-	if (process.env.ANTHROPIC_API_KEY) try {
+	try {
 		return await llmExtract(name, content, preamble);
 	} catch (err) {
 		serverLog.warn(`[skills] LLM metadata extraction failed for "${name}": ${err instanceof Error ? err.message : String(err)}`);
@@ -2180,7 +1749,6 @@ async function extractSkillMeta(name, content) {
 	};
 }
 async function llmExtract(name, content, partial) {
-	const client = new Anthropic();
 	const truncated = content.slice(0, 8e3);
 	const prompt = `Analyze this skill document and extract metadata. The skill is named "${name}".
 
@@ -2194,15 +1762,14 @@ Return ONLY a JSON object with these fields:
 - "keywords": array of 3-8 relevant keywords
 
 Return raw JSON, no markdown fences.`;
-	const res = await client.messages.create({
-		model: EXTRACT_MODEL,
-		max_tokens: 256,
-		messages: [{
-			role: `user`,
-			content: prompt
-		}]
+	const text = await completeWithLowCostModel({
+		purpose: `skill metadata extraction`,
+		systemPrompt: `Extract metadata from skill documents. Return only valid JSON that matches the requested schema.`,
+		prompt,
+		maxTokens: 256,
+		log: (message) => serverLog.info(message),
+		logPrefix: `[skills]`
 	});
-	const text = res.content[0]?.type === `text` ? res.content[0].text : ``;
 	const parsed = JSON.parse(text);
 	return {
 		description: partial.description ?? parsed.description ?? humanize(name),
@@ -2227,7 +1794,7 @@ async function createSkillsRegistry(opts) {
 	if (appSkillsDir) await scanDir(appSkillsDir, files);
 	const catalog = new Map();
 	for (const [name, filePath] of files) {
-		const content = await fs.readFile(filePath, `utf-8`);
+		const content = await fs$1.readFile(filePath, `utf-8`);
 		const hash = sha256(content);
 		const cached = existingCache[name];
 		if (cached && cached.contentHash === hash && cached.source === filePath) {
@@ -2261,7 +1828,7 @@ async function createSkillsRegistry(opts) {
 			const meta = catalog.get(name);
 			if (!meta) return null;
 			try {
-				return await fs.readFile(meta.source, `utf-8`);
+				return await fs$1.readFile(meta.source, `utf-8`);
 			} catch {
 				return null;
 			}
@@ -2271,7 +1838,7 @@ async function createSkillsRegistry(opts) {
 async function scanDir(dir, out) {
 	let entries;
 	try {
-		entries = await fs.readdir(dir, { withFileTypes: true });
+		entries = await fs$1.readdir(dir, { withFileTypes: true });
 	} catch {
 		return;
 	}
@@ -2283,7 +1850,7 @@ async function scanDir(dir, out) {
 }
 async function loadCache(cachePath) {
 	try {
-		const raw = await fs.readFile(cachePath, `utf-8`);
+		const raw = await fs$1.readFile(cachePath, `utf-8`);
 		return JSON.parse(raw);
 	} catch {
 		return {};
@@ -2292,9 +1859,9 @@ async function loadCache(cachePath) {
 async function saveCache(cachePath, catalog, cacheDir) {
 	const obj = {};
 	for (const [name, meta] of catalog) obj[name] = meta;
-	fsSync.mkdirSync(cacheDir, { recursive: true });
-	await fs.writeFile(path.join(cacheDir, `.gitignore`), `*\n`, `utf-8`);
-	await fs.writeFile(cachePath, JSON.stringify(obj, null, 2), `utf-8`);
+	fs.mkdirSync(cacheDir, { recursive: true });
+	await fs$1.writeFile(path.join(cacheDir, `.gitignore`), `*\n`, `utf-8`);
+	await fs$1.writeFile(cachePath, JSON.stringify(obj, null, 2), `utf-8`);
 }
 function sha256(content) {
 	return createHash(`sha256`).update(content).digest(`hex`);
@@ -2333,9 +1900,10 @@ function truncate(str, max) {
 //#region src/bootstrap.ts
 const DEFAULT_BUILTIN_AGENT_HANDLER_PATH = `/_electric/builtin-agent-handler`;
 async function createBuiltinAgentHandler(options) {
-	const { agentServerUrl, serveEndpoint = `${agentServerUrl}${DEFAULT_BUILTIN_AGENT_HANDLER_PATH}`, workingDirectory, streamFn, createElectricTools } = options;
-	if (!streamFn && !process.env.ANTHROPIC_API_KEY) {
-		serverLog.warn(`[builtin-agents] ANTHROPIC_API_KEY not set — skipping built-in agent registration`);
+	const { agentServerUrl, serveEndpoint = `${agentServerUrl}${DEFAULT_BUILTIN_AGENT_HANDLER_PATH}`, workingDirectory, streamFn, createElectricTools, publicUrl, runtimeName } = options;
+	const modelCatalog = await createBuiltinModelCatalog({ allowMockFallback: Boolean(streamFn) });
+	if (!modelCatalog) {
+		serverLog.warn(`[builtin-agents] no supported model provider API key found — set ANTHROPIC_API_KEY or OPENAI_API_KEY`);
 		return null;
 	}
 	const cwd = workingDirectory ?? process.cwd();
@@ -2356,22 +1924,24 @@ async function createBuiltinAgentHandler(options) {
 	const typeNames = registerHorton(registry, {
 		workingDirectory: cwd,
 		streamFn,
-		skillsRegistry
+		skillsRegistry,
+		modelCatalog
 	});
 	registerWorker(registry, {
 		workingDirectory: cwd,
-		streamFn
+		streamFn,
+		modelCatalog
 	});
 	typeNames.push(`worker`);
-	registerCodingSession(registry, { defaultWorkingDirectory: cwd });
-	typeNames.push(`coder`);
 	const runtime = createRuntimeHandler({
 		baseUrl: agentServerUrl,
 		serveEndpoint,
 		registry,
 		subscriptionPathForType: (name) => `/${name}/*/main`,
 		idleTimeout: 5e3,
-		createElectricTools
+		createElectricTools,
+		publicUrl,
+		name: runtimeName ?? `builtin-agents`
 	});
 	return {
 		handler: runtime.onEnter,
@@ -2403,10 +1973,19 @@ var BuiltinAgentsServer = class {
 	bootstrap = null;
 	_url = null;
 	publicBaseUrl = null;
+	_mcpRegistry = null;
+	mcpWatcherCloser = null;
+	mcpToolProviderName = null;
+	mcpApplyInFlight = new Set();
+	mcpStopping = false;
 	options;
 	constructor(options) {
 		this.options = options;
 	}
+	/** Embedded MCP registry. `null` until `start()` has run. */
+	get mcpRegistry() {
+		return this._mcpRegistry;
+	}
 	get url() {
 		if (!this._url) throw new Error(`Builtin agents server not started`);
 		return this._url;
@@ -2440,14 +2019,124 @@ var BuiltinAgentsServer = class {
 					this.publicBaseUrl = this.options.baseUrl ?? this._url;
 					const webhookPath = this.options.webhookPath ?? DEFAULT_BUILTIN_AGENT_HANDLER_PATH;
 					const serveEndpoint = new URL(webhookPath, this.publicBaseUrl.endsWith(`/`) ? this.publicBaseUrl : `${this.publicBaseUrl}/`).toString();
+					const publicUrl = this.options.mcpOAuthRedirectBase ?? this.publicBaseUrl;
+					const mcpRegistry = createRegistry({
+						publicUrl,
+						openAuthorizeUrl: this.options.openAuthorizeUrl
+					});
+					this._mcpRegistry = mcpRegistry;
+					const mcpConfigPath = this.options.loadProjectMcpConfig ? path.resolve(this.options.workingDirectory ?? process.cwd(), `mcp.json`) : null;
+					const extras = this.options.extraMcpServers ?? [];
+					const wirePersistence = async (cfg) => {
+						const servers = [];
+						for (const s of cfg.servers) if (s.transport === `http` && s.auth?.mode === `authorizationCode`) {
+							const persist = await keychainPersistence({ server: s.name });
+							servers.push({
+								...s,
+								auth: {
+									...s.auth,
+									...persist
+								}
+							});
+						} else servers.push(s);
+						return {
+							...cfg,
+							servers
+						};
+					};
+					const merge = (jsonCfg) => {
+						const jsonServers = jsonCfg?.servers ?? [];
+						const jsonNames = new Set(jsonServers.map((s) => s.name));
+						const filteredExtras = extras.filter((s) => !jsonNames.has(s.name));
+						return {
+							servers: [...filteredExtras, ...jsonServers],
+							raw: jsonCfg?.raw
+						};
+					};
+					const onConfigError = this.options.onConfigError;
+					const runApply = async (jsonCfg) => {
+						if (this.mcpStopping) return;
+						try {
+							const wired = await wirePersistence(merge(jsonCfg));
+							if (this.mcpStopping) return;
+							await mcpRegistry.applyConfig(wired);
+						} catch (e) {
+							serverLog.error(`[mcp] applyConfig:`, e);
+							try {
+								onConfigError?.(e);
+							} catch (cbErr) {
+								serverLog.error(`[mcp] onConfigError callback failed:`, cbErr);
+							}
+						}
+					};
+					const applyMerged = (jsonCfg) => {
+						const p = runApply(jsonCfg);
+						this.mcpApplyInFlight.add(p);
+						p.finally(() => this.mcpApplyInFlight.delete(p));
+						return p;
+					};
+					if (mcpConfigPath) {
+						try {
+							const cfg = await loadConfig(mcpConfigPath, process.env);
+							applyMerged(cfg);
+						} catch (err) {
+							if (err.code !== `ENOENT`) throw err;
+							if (extras.length === 0) serverLog.info(`[mcp] no ${mcpConfigPath} — starting with no servers`);
+							else serverLog.info(`[mcp] no ${mcpConfigPath} — starting with ${extras.length} server(s) from extras`);
+							applyMerged(null);
+						}
+						try {
+							this.mcpWatcherCloser = await watchConfig(mcpConfigPath, {
+								onChange: (cfg) => void applyMerged(cfg),
+								onError: (e) => serverLog.error(`[mcp] config error:`, e)
+							});
+						} catch (e) {
+							serverLog.error(`[mcp] config watcher failed to start:`, e);
+						}
+					} else {
+						if (extras.length > 0) serverLog.info(`[mcp] starting with ${extras.length} server(s) from extras`);
+						applyMerged(null);
+					}
+					this.mcpToolProviderName = `mcp`;
+					registerToolProvider({
+						name: `mcp`,
+						tools: () => {
+							const tools = [];
+							for (const entry of mcpRegistry.list()) {
+								if (entry.status !== `ready`) continue;
+								const live = mcpRegistry.get(entry.name);
+								if (!live?.transport) continue;
+								for (const t of entry.tools) tools.push(bridgeMcpTool({
+									server: entry.name,
+									tool: t,
+									client: live.transport.client,
+									timeoutMs: live.config.timeoutMs
+								}));
+								const caps = live.transport.client.getServerCapabilities?.();
+								if (caps?.resources) tools.push(...buildResourceTools({
+									server: entry.name,
+									client: live.transport.client,
+									timeoutMs: live.config.timeoutMs
+								}));
+								if (caps?.prompts) tools.push(...buildPromptTools({
+									server: entry.name,
+									client: live.transport.client,
+									timeoutMs: live.config.timeoutMs
+								}));
+							}
+							return tools;
+						}
+					});
 					this.bootstrap = await createBuiltinAgentHandler({
 						agentServerUrl: this.options.agentServerUrl,
 						serveEndpoint,
 						workingDirectory: this.options.workingDirectory,
 						streamFn: this.options.mockStreamFn,
-						createElectricTools: this.options.createElectricTools
+						createElectricTools: this.options.createElectricTools,
+						publicUrl,
+						runtimeName: `builtin-agents`
 					});
-					if (!this.bootstrap) throw new Error(`ANTHROPIC_API_KEY must be set before starting builtin agents`);
+					if (!this.bootstrap) throw new Error(`ANTHROPIC_API_KEY or OPENAI_API_KEY must be set before starting builtin agents`);
 					await registerBuiltinAgentTypes(this.bootstrap);
 					serverLog.info(`[builtin-agents] webhook handler listening at ${serveEndpoint}`);
 					resolve(this._url);
@@ -2464,6 +2153,26 @@ var BuiltinAgentsServer = class {
 			await Promise.race([this.bootstrap.runtime.drainWakes().catch(() => {}), new Promise((resolve) => setTimeout(resolve, 5e3))]);
 			this.bootstrap = null;
 		}
+		this.mcpStopping = true;
+		if (this.mcpWatcherCloser) {
+			try {
+				this.mcpWatcherCloser();
+			} catch (e) {
+				serverLog.error(`[mcp] watcher close failed:`, e);
+			}
+			this.mcpWatcherCloser = null;
+		}
+		if (this.mcpApplyInFlight.size > 0) await Promise.allSettled([...this.mcpApplyInFlight]);
+		if (this.mcpToolProviderName) {
+			unregisterToolProvider(this.mcpToolProviderName);
+			this.mcpToolProviderName = null;
+		}
+		if (this._mcpRegistry) {
+			await this._mcpRegistry.close().catch((e) => {
+				serverLog.error(`[mcp] registry close failed:`, e);
+			});
+			this._mcpRegistry = null;
+		}
 		if (this.server) {
 			const server = this.server;
 			await new Promise((resolve) => {
@@ -2471,19 +2180,20 @@ var BuiltinAgentsServer = class {
 			});
 			this.server = null;
 		}
+		this.mcpStopping = false;
 		this._url = null;
 		this.publicBaseUrl = null;
 	}
 	async handleRequest(req, res) {
 		const method = req.method?.toUpperCase();
-		const path$1 = new URL(req.url ?? `/`, `http://localhost`).pathname;
+		const pathname = new URL(req.url ?? `/`, `http://localhost`).pathname;
 		const webhookPath = this.options.webhookPath ?? DEFAULT_BUILTIN_AGENT_HANDLER_PATH;
-		if (path$1 === `/_electric/health` && method === `GET`) {
+		if (pathname === `/_electric/health` && method === `GET`) {
 			res.writeHead(200, { "content-type": `application/json` });
 			res.end(JSON.stringify({ status: `ok` }));
 			return;
 		}
-		if (path$1 === webhookPath && method === `POST` && this.bootstrap) {
+		if (pathname === webhookPath && method === `POST` && this.bootstrap) {
 			await this.bootstrap.handler(req, res);
 			return;
 		}
@@ -2546,4 +2256,4 @@ async function runBuiltinAgentsEntrypoint({ env = process.env, cwd = process.cwd
 }
 
 //#endregion
-export { BuiltinAgentsServer, DEFAULT_BUILTIN_AGENT_HANDLER_PATH, HORTON_MODEL, WORKER_TOOL_NAMES, braveSearchTool, buildHortonSystemPrompt, createAgentHandler, createBuiltinAgentHandler, createHortonDocsSupport, createHortonTools, createSpawnWorkerTool, generateTitle, registerAgentTypes, registerBuiltinAgentTypes, registerCodingSession, registerHorton, registerWorker, resolveBuiltinAgentsEntrypointOptions, runBuiltinAgentsEntrypoint };
+export { BuiltinAgentsServer, DEFAULT_BUILTIN_AGENT_HANDLER_PATH, HORTON_MODEL, WORKER_TOOL_NAMES, braveSearchTool, buildHortonSystemPrompt, createAgentHandler, createBuiltinAgentHandler, createHortonDocsSupport, createHortonTools, createSpawnWorkerTool, generateTitle, registerAgentTypes, registerBuiltinAgentTypes, registerHorton, registerWorker, resolveBuiltinAgentsEntrypointOptions, runBuiltinAgentsEntrypoint };