@flue/sdk 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,1001 +0,0 @@
-import { a as parseFrontmatterFile, n as createTools, t as BUILTIN_TOOL_NAMES } from "./agent-BYG0nVbQ.mjs";
-import * as esbuild from "esbuild";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { packageUpSync } from "package-up";
-import { parse } from "jsonc-parser";
-
-//#region src/cloudflare-wrangler-merge.ts
-/**
-* Merge Flue's Cloudflare additions into the user's wrangler config.
-*
-* Philosophy: the user's wrangler.jsonc is the source of truth. Flue contributes
-* the pieces it owns (the Worker entrypoint, its per-agent Durable Object
-* bindings, the Sandbox DO, the migration tag) and leaves everything else
-* untouched. The merged result is written to `dist/wrangler.jsonc` so the
-* deployed Worker sees both.
-*
-* We use `jsonc-parser` (the same library wrangler uses internally) for
-* reading. TOML is intentionally unsupported — Cloudflare itself recommends
-* wrangler.jsonc for new projects, and supporting both formats here would
-* double the surface area for no real benefit. Users with wrangler.toml get a
-* clear error directing them to convert.
-*/
-/** Minimum compatibility_date Flue supports. */
-const MIN_COMPATIBILITY_DATE = "2024-04-03";
-/** compatibility_flag Flue requires for pi-ai's process.env-based API key lookup. */
-const REQUIRED_COMPAT_FLAG = "nodejs_compat";
-/**
-* Read the user's wrangler config from `outputDir` if present.
-*
-* Looks for `wrangler.jsonc` then `wrangler.json` (in that order — jsonc is the
-* recommended format). If a `wrangler.toml` is present instead, throws with a
-* clear conversion hint. Returns an empty config if no file is present.
-*/
-function readUserWranglerConfig(outputDir) {
-	const jsoncPath = path.join(outputDir, "wrangler.jsonc");
-	const jsonPath = path.join(outputDir, "wrangler.json");
-	const tomlPath = path.join(outputDir, "wrangler.toml");
-	const foundPath = fs.existsSync(jsoncPath) ? jsoncPath : fs.existsSync(jsonPath) ? jsonPath : null;
-	if (!foundPath) {
-		if (fs.existsSync(tomlPath)) throw new Error(`[flue] Found wrangler.toml at ${tomlPath}. Flue only supports wrangler.jsonc (the format Cloudflare recommends for new projects). Convert your config to wrangler.jsonc — you can use any online TOML-to-JSON converter, or copy the fields over by hand.`);
-		return {
-			config: {},
-			path: null
-		};
-	}
-	const source = fs.readFileSync(foundPath, "utf-8");
-	const errors = [];
-	const parsed = parse(source, errors, { allowTrailingComma: true });
-	if (errors.length > 0) {
-		const summary = errors.slice(0, 3).map((e) => `offset ${e.offset}: error code ${e.error}`).join("; ");
-		throw new Error(`[flue] Failed to parse ${foundPath}: ${summary}. Please fix syntax errors in your wrangler config before building.`);
-	}
-	if (parsed === void 0 || parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`[flue] ${foundPath} did not contain a JSON object at the top level. A wrangler config must be an object.`);
-	return {
-		config: parsed,
-		path: foundPath
-	};
-}
-/**
-* Validate that the user's wrangler config meets Flue's minimum runtime
-* requirements. Throws a clear error describing the fix if it doesn't.
-*
-* We're intentionally strict here rather than silently massaging bad configs —
-* the failure modes when these are wrong (missing nodejs_compat, old
-* compat_date) produce confusing runtime errors, and surfacing the problem at
-* build time is much friendlier.
-*/
-function validateUserWranglerConfig(config) {
-	if (Array.isArray(config.compatibility_flags)) {
-		if (!config.compatibility_flags.includes(REQUIRED_COMPAT_FLAG)) throw new Error(`[flue] Your wrangler config's "compatibility_flags" is missing "${REQUIRED_COMPAT_FLAG}". Flue relies on it at runtime (e.g. for API key resolution via process.env). Add "${REQUIRED_COMPAT_FLAG}" to the list.`);
-	}
-	if (typeof config.compatibility_date === "string") {
-		const userDate = config.compatibility_date;
-		if (!/^\d{4}-\d{2}-\d{2}$/.test(userDate)) throw new Error(`[flue] Your wrangler config's "compatibility_date" ("${userDate}") is not in YYYY-MM-DD format.`);
-		if (userDate < MIN_COMPATIBILITY_DATE) throw new Error(`[flue] Your wrangler config's "compatibility_date" is "${userDate}". Flue requires at least "${MIN_COMPATIBILITY_DATE}" for SQLite-backed Durable Object support and nodejs_compat v2. Bump the date (set it to today unless you have a specific reason).`);
-	}
-}
-/**
-* Produce the merged wrangler config: start from the user's, layer Flue's
-* contributions on top. Pure function — caller handles reading and writing.
-*/
-function mergeFlueAdditions(userConfig, additions) {
-	const merged = { ...userConfig };
-	merged.main = additions.main;
-	if (typeof merged.name !== "string" || merged.name.length === 0) merged.name = additions.defaultName;
-	if (typeof merged.compatibility_date !== "string") merged.compatibility_date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-	const existingFlags = Array.isArray(merged.compatibility_flags) ? merged.compatibility_flags.filter((f) => typeof f === "string") : [];
-	if (!existingFlags.includes(REQUIRED_COMPAT_FLAG)) existingFlags.push(REQUIRED_COMPAT_FLAG);
-	merged.compatibility_flags = existingFlags;
-	const existingDo = typeof merged.durable_objects === "object" && merged.durable_objects !== null ? merged.durable_objects : {};
-	const existingBindings = Array.isArray(existingDo.bindings) ? existingDo.bindings : [];
-	const existingBindingNames = new Set(existingBindings.filter((b) => typeof b === "object" && b !== null).map((b) => b.name).filter((n) => typeof n === "string"));
-	const flueBindingsToAdd = additions.doBindings.filter((b) => !existingBindingNames.has(b.name));
-	merged.durable_objects = {
-		...existingDo,
-		bindings: [...existingBindings, ...flueBindingsToAdd]
-	};
-	const existingMigrations = Array.isArray(merged.migrations) ? merged.migrations : [];
-	const existingMigrationTags = new Set(existingMigrations.filter((m) => typeof m === "object" && m !== null).map((m) => m.tag).filter((t) => typeof t === "string"));
-	const migrationsOut = [...existingMigrations];
-	if (!existingMigrationTags.has(additions.migration.tag)) migrationsOut.push(additions.migration);
-	merged.migrations = migrationsOut;
-	return merged;
-}
-/**
-* Return the list of `class_name`s declared in the user's wrangler
-* `durable_objects.bindings` that contain the literal substring `Sandbox`
-* (case-sensitive).
-*
-* This is Flue's convention for wiring `@cloudflare/sandbox`: any DO binding
-* whose class name contains `Sandbox` triggers an automatic re-export in the
-* generated Worker entry:
-*
-*   export { Sandbox as <class_name> } from '@cloudflare/sandbox';
-*
-* The alias lets users pick arbitrary class names (e.g. `PyBoxSandbox`,
-* `SupportSandbox`) while still pointing at the single class shipped by the
-* `@cloudflare/sandbox` package. Each distinct `class_name` can be paired with
-* a different container image in the user's `containers[]` config.
-*
-* Returns unique, sorted class names. Non-object bindings or bindings without
-* a string `class_name` are ignored.
-*/
-function detectSandboxBindings(userConfig) {
-	const doObj = userConfig.durable_objects;
-	if (typeof doObj !== "object" || doObj === null) return [];
-	const bindings = doObj.bindings;
-	if (!Array.isArray(bindings)) return [];
-	const found = /* @__PURE__ */ new Set();
-	for (const entry of bindings) {
-		if (typeof entry !== "object" || entry === null) continue;
-		const className = entry.class_name;
-		if (typeof className !== "string") continue;
-		if (className.includes("Sandbox")) found.add(className);
-	}
-	return Array.from(found).sort();
-}
-/**
-* When the user has declared one or more `Sandbox`-named DO bindings, verify
-* that `@cloudflare/sandbox` is declared in the nearest package.json. Surfaces
-* a friendly, actionable error at build time rather than letting esbuild emit
-* a confusing module-resolution failure.
-*
-* The check is lenient: if no package.json can be located or parsed, we skip
-* silently and let esbuild's own error path take over. This avoids false
-* positives in unusual project layouts.
-*/
-function assertSandboxPackageInstalled(sandboxClassNames, searchDirs) {
-	if (sandboxClassNames.length === 0) return;
-	for (const dir of searchDirs) {
-		let current = dir;
-		while (current !== path.dirname(current)) {
-			const pkgPath = path.join(current, "package.json");
-			if (fs.existsSync(pkgPath)) try {
-				const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-				if ("@cloudflare/sandbox" in {
-					...pkg.dependencies ?? {},
-					...pkg.devDependencies ?? {},
-					...pkg.peerDependencies ?? {},
-					...pkg.optionalDependencies ?? {}
-				}) return;
-			} catch {
-				return;
-			}
-			current = path.dirname(current);
-		}
-	}
-	throw new Error(`[flue] Your wrangler config declares DO binding(s) whose class_name contains "Sandbox" (${sandboxClassNames.join(", ")}), but @cloudflare/sandbox is not in your package.json. Install it: \`npm install @cloudflare/sandbox\`.`);
-}
-/**
-* Write the wrangler deploy-redirect file at `<outputDir>/.wrangler/deploy/config.json`
-* so that `wrangler deploy` run from `outputDir` automatically picks up the
-* generated `dist/wrangler.jsonc`.
-*
-* This is wrangler's own native redirection mechanism (the same one Astro's
-* Cloudflare adapter uses). We only write the file if one doesn't already
-* exist — if the user has set one up, respect their intent.
-*/
-function writeDeployRedirectIfMissing(outputDir) {
-	const redirectDir = path.join(outputDir, ".wrangler", "deploy");
-	const redirectPath = path.join(redirectDir, "config.json");
-	if (fs.existsSync(redirectPath)) return;
-	fs.mkdirSync(redirectDir, { recursive: true });
-	fs.writeFileSync(redirectPath, JSON.stringify({ configPath: "../../dist/wrangler.jsonc" }, null, 2) + "\n", "utf-8");
-}
-
-//#endregion
-//#region src/build-plugin-cloudflare.ts
-var CloudflarePlugin = class {
-	name = "cloudflare";
-	generateEntryPoint(ctx) {
-		const { agents, roles } = ctx;
-		const rolesJson = JSON.stringify(roles);
-		const webhookAgents = agents.filter((a) => a.triggers.webhook);
-		const agentImports = agents.map((a) => {
-			return `import ${agentVarName$1(a.name)} from '${a.filePath.replace(/\\/g, "/")}';`;
-		}).join("\n");
-		const manifest = JSON.stringify({ agents: agents.map((a) => ({
-			name: a.name,
-			triggers: a.triggers
-		})) }, null, 2);
-		const agentClasses = webhookAgents.map((a) => {
-			const className = agentClassName(a.name);
-			const handlerVar = agentVarName$1(a.name);
-			return `export class ${className} extends Agent {
-  async onRequest(request) {
-    return handleAgentRequest(request, this, ${JSON.stringify(a.name)}, ${handlerVar});
-  }
-}`;
-		}).join("\n\n");
-		const { config: userConfig } = readUserWranglerConfig(ctx.outputDir);
-		return `
-// Auto-generated by @flue/sdk build (cloudflare)
-import { Agent, routeAgentRequest } from 'agents';
-import { Bash, InMemoryFs } from 'just-bash';
-import { getModel } from '@mariozechner/pi-ai';
-import { createFlueContext, InMemorySessionStore, bashToSessionEnv } from '@flue/sdk/internal';
-import { setCloudflareContext, clearCloudflareContext, cfSandboxToSessionEnv } from '@flue/sdk/cloudflare';
-
-${agentImports}
-
-// ─── Config ─────────────────────────────────────────────────────────────────
-
-const roles = ${rolesJson};
-const skills = {};
-const systemPrompt = '';
-const manifest = ${manifest};
-
-// ─── Infrastructure ─────────────────────────────────────────────────────────
-
-// No build-time model default. The user sets model at runtime via
-// \`init({ model: "provider/model-id" })\` for a session default, or via
-// \`{ model: "provider/model-id" }\` on any individual prompt/skill/task call.
-const model = undefined;
-
-function resolveModel(modelString) {
-  const slash = modelString.indexOf('/');
-  if (slash === -1) {
-    throw new Error(
-      '[flue] Invalid model "' + modelString + '". ' +
-      'Use the "provider/model-id" format (e.g. "anthropic/claude-haiku-4-5").'
-    );
-  }
-  const provider = modelString.slice(0, slash);
-  const modelId = modelString.slice(slash + 1);
-  const resolved = getModel(provider, modelId);
-  if (!resolved) {
-    throw new Error(
-      '[flue] Unknown model "' + modelString + '". ' +
-      'Provider "' + provider + '" / model id "' + modelId + '" ' +
-      'is not registered with @mariozechner/pi-ai.'
-    );
-  }
-  return resolved;
-}
-
-// ─── Sandbox Environments ───────────────────────────────────────────────────
-
-/**
- * Create an empty in-memory sandbox (default).
- */
-async function createDefaultEnv() {
-  const bash = new Bash({
-    fs: new InMemoryFs(),
-    network: { dangerouslyAllowFullInternetAccess: true },
-  });
-  return bashToSessionEnv(bash);
-}
-
-/**
- * 'local' sandbox is not available on Cloudflare Workers.
- */
-async function createLocalEnv() {
-  throw new Error(
-    "[flue] 'local' sandbox is not supported on Cloudflare Workers. " +
-    "Use the default empty sandbox, pass a custom Bash instance, " +
-    "or pass a sandbox instance (from any SDK — e.g. @cloudflare/sandbox " +
-    "or a Flue connector) to init({ sandbox })."
-  );
-}
-
-/**
- * Detect and wrap external sandbox instances (e.g. from @cloudflare/sandbox's
- * getSandbox()). Returns SessionEnv if the object quacks like a container
- * sandbox, null otherwise.
- */
-function resolveSandbox(sandbox) {
-  if (
-    sandbox && typeof sandbox === 'object' &&
-    typeof sandbox.exec === 'function' &&
-    typeof sandbox.readFile === 'function' &&
-    typeof sandbox.destroy === 'function' &&
-    !('getCwd' in sandbox) && !('fs' in sandbox)
-  ) {
-    return cfSandboxToSessionEnv(sandbox);
-  }
-  return null;
-}
-
-// Fallback in-memory store (used if no DO storage is available).
-const memoryStore = new InMemorySessionStore();
-
-// Create a DO-backed session store from the Durable Object's SQL storage.
-function createDOStore(sql) {
-  // Ensure the table exists
-  sql.exec(
-    'CREATE TABLE IF NOT EXISTS flue_sessions (id TEXT PRIMARY KEY, data TEXT NOT NULL, updated_at INTEGER NOT NULL)'
-  );
-  return {
-    async save(id, data) {
-      const json = JSON.stringify(data);
-      sql.exec(
-        'INSERT OR REPLACE INTO flue_sessions (id, data, updated_at) VALUES (?, ?, ?)',
-        id, json, Date.now()
-      );
-    },
-    async load(id) {
-      const rows = sql.exec('SELECT data FROM flue_sessions WHERE id = ?', id).toArray();
-      if (rows.length === 0) return null;
-      return JSON.parse(rows[0].data);
-    },
-    async delete(id) {
-      sql.exec('DELETE FROM flue_sessions WHERE id = ?', id);
-    },
-  };
-}
-
-function createContextForRequest(sessionId, payload, doInstance) {
-  // Use DO SQLite storage by default, fall back to in-memory
-  const defaultStore = doInstance?.ctx?.storage?.sql
-    ? createDOStore(doInstance.ctx.storage.sql)
-    : memoryStore;
-
-  return createFlueContext({
-    sessionId,
-    payload,
-    env: doInstance?.env ?? {},
-    agentConfig: {
-      systemPrompt, skills, roles, model, resolveModel,
-    },
-    createDefaultEnv,
-    createLocalEnv,
-    defaultStore,
-    resolveSandbox,
-  });
-}
-
-// ─── Shared Request Handler ────────────────────────────────────────────────
-
-async function handleAgentRequest(request, doInstance, agentName, handler) {
-  // Session ID is the DO "room name" set by routeAgentRequest
-  const sessionId = doInstance.name;
-
-  // Parse payload
-  let payload;
-  try {
-    payload = await request.json();
-  } catch {
-    payload = {};
-  }
-
-  // Set up Cloudflare context for runtime primitives
-  setCloudflareContext({ env: doInstance.env, agentInstance: doInstance, storage: doInstance.ctx.storage });
-
-  const accept = request.headers.get('accept') || '';
-  const isWebhook = request.headers.get('x-webhook') === 'true';
-  const isSSE = accept.includes('text/event-stream') && !isWebhook;
-
-  try {
-    // Fire-and-forget (webhook mode)
-    if (isWebhook) {
-      const requestId = crypto.randomUUID();
-      const ctx = createContextForRequest(sessionId, payload, doInstance);
-      handler(ctx).then(
-        (result) => {
-          ctx.setEventCallback(undefined);
-          clearCloudflareContext();
-          console.log('[flue] Webhook handler complete:', agentName,
-            result !== undefined ? JSON.stringify(result) : '(no return)');
-        },
-        (err) => {
-          ctx.setEventCallback(undefined);
-          clearCloudflareContext();
-          console.error('[flue] Webhook handler error:', agentName, err);
-        },
-      );
-      return new Response(JSON.stringify({ status: 'accepted', requestId }), {
-        status: 202,
-        headers: { 'content-type': 'application/json' },
-      });
-    }
-
-    // SSE streaming mode
-    if (isSSE) {
-      const { readable, writable } = new TransformStream();
-      const writer = writable.getWriter();
-      const encoder = new TextEncoder();
-      let eventId = 0;
-
-      const writeSSE = async (data, event) => {
-        const lines = [];
-        if (event) lines.push('event: ' + event);
-        lines.push('id: ' + eventId++);
-        lines.push('data: ' + JSON.stringify(data));
-        lines.push('', '');
-        await writer.write(encoder.encode(lines.join('\\n')));
-      };
-
-      const ctx = createContextForRequest(sessionId, payload, doInstance);
-      ctx.setEventCallback((event) => {
-        writeSSE(event, event.type).catch(() => {});
-      });
-
-      (async () => {
-        try {
-          const result = await handler(ctx);
-          await writeSSE(
-            { type: 'result', data: result !== undefined ? result : null },
-            'result',
-          );
-        } catch (err) {
-          await writeSSE(
-            { type: 'error', error: String(err) },
-            'error',
-          );
-        } finally {
-          ctx.setEventCallback(undefined);
-          clearCloudflareContext();
-          await writer.close();
-        }
-      })();
-
-      return new Response(readable, {
-        headers: {
-          'content-type': 'text/event-stream',
-          'cache-control': 'no-cache',
-          'connection': 'keep-alive',
-        },
-      });
-    }
-
-    // Sync mode (default)
-    const ctx = createContextForRequest(sessionId, payload, doInstance);
-    const result = await handler(ctx);
-    ctx.setEventCallback(undefined);
-    clearCloudflareContext();
-    return new Response(
-      JSON.stringify({ result: result !== undefined ? result : null }),
-      { headers: { 'content-type': 'application/json' } },
-    );
-  } catch (err) {
-    clearCloudflareContext();
-    console.error('[flue] Agent error:', agentName, err);
-    return new Response(
-      JSON.stringify({ error: String(err) }),
-      { status: 500, headers: { 'content-type': 'application/json' } },
-    );
-  }
-}
-
-// ─── Per-Agent Durable Object Classes ──────────────────────────────────────
-
-${agentClasses}
-
-// ─── User-declared Sandbox re-exports ──────────────────────────────────────
-// One line per DO binding in the user's wrangler.jsonc whose class_name
-// contains "Sandbox". Flue aliases the single \`Sandbox\` class shipped by
-// \`@cloudflare/sandbox\` so each user-chosen class_name resolves at the
-// bundle's top level. The binding + container image configuration is owned
-// by the user's wrangler.jsonc.
-${detectSandboxBindings(userConfig).map((name) => `export { Sandbox as ${name} } from '@cloudflare/sandbox';`).join("\n")}
-
-// ─── Worker Fetch Handler ───────────────────────────────────────────────────
-
-export default {
-  async fetch(request, env) {
-    const url = new URL(request.url);
-
-    // Health check
-    if (url.pathname === '/health') {
-      return new Response(JSON.stringify({ status: 'ok' }), {
-        headers: { 'content-type': 'application/json' },
-      });
-    }
-
-    // Agent manifest
-    if (url.pathname === '/agents' && request.method === 'GET') {
-      return new Response(JSON.stringify(manifest), {
-        headers: { 'content-type': 'application/json' },
-      });
-    }
-
-    // Route to per-agent DOs via the Agents SDK
-    // URL: /agents/<agent-name>/<session-id>
-    const response = await routeAgentRequest(request, env);
-    if (response) return response;
-
-    return new Response('Not found', { status: 404 });
-  },
-};
-`;
-	}
-	esbuildOptions(_ctx) {
-		return {
-			target: "esnext",
-			external: [
-				"node:*",
-				"cloudflare:*",
-				"node-liblzma",
-				"@mongodb-js/zstd"
-			]
-		};
-	}
-	additionalOutputs(ctx) {
-		const outputs = {};
-		const flueBindings = ctx.agents.filter((a) => a.triggers.webhook).map((a) => ({
-			class_name: agentClassName(a.name),
-			name: agentClassName(a.name)
-		}));
-		const flueSqliteClasses = flueBindings.map((b) => b.class_name);
-		const additions = {
-			defaultName: ctx.outputDir.split("/").pop() ?? "flue-agents",
-			main: "server.mjs",
-			doBindings: flueBindings,
-			migration: {
-				tag: "flue-v1",
-				new_sqlite_classes: flueSqliteClasses
-			}
-		};
-		const { config: userConfig, path: userConfigPath } = readUserWranglerConfig(ctx.outputDir);
-		if (userConfigPath) console.log(`[flue] Merging with user wrangler config: ${userConfigPath}`);
-		validateUserWranglerConfig(userConfig);
-		const sandboxClassNames = detectSandboxBindings(userConfig);
-		if (sandboxClassNames.length > 0) {
-			assertSandboxPackageInstalled(sandboxClassNames, [ctx.outputDir, ctx.workspaceDir]);
-			for (const className of sandboxClassNames) console.log(`[flue] Detected Sandbox-named DO binding "${className}" — re-exporting from @cloudflare/sandbox.`);
-		}
-		const merged = mergeFlueAdditions(userConfig, additions);
-		if (typeof merged.$schema !== "string") merged.$schema = "https://workers.cloudflare.com/schema/wrangler.json";
-		outputs["wrangler.jsonc"] = JSON.stringify(merged, null, 2);
-		writeDeployRedirectIfMissing(ctx.outputDir);
-		return outputs;
-	}
-};
-function agentVarName$1(name) {
-	return "handler_" + name.replace(/[^a-zA-Z0-9]/g, "_");
-}
-/**
-* Convert agent name to a PascalCase DO class name.
-* "hello" → "Hello", "with-cloudflare" → "WithCloudflare"
-*
-* routeAgentRequest() converts binding names to kebab-case for URL matching,
-* so "WithCloudflare" → "with-cloudflare" → URL /agents/with-cloudflare/:id
-*/
-function agentClassName(name) {
-	return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-
-//#endregion
-//#region src/build-plugin-node.ts
-var NodePlugin = class {
-	name = "node";
-	generateEntryPoint(ctx) {
-		const { agents, roles } = ctx;
-		const rolesJson = JSON.stringify(roles);
-		const webhookAgents = agents.filter((a) => a.triggers.webhook);
-		return `
-// Auto-generated by @flue/sdk build (node)
-import { Hono } from 'hono';
-import { streamSSE } from 'hono/streaming';
-import { serve } from '@hono/node-server';
-import { Bash, InMemoryFs, MountableFs, ReadWriteFs } from 'just-bash';
-import { getModel } from '@mariozechner/pi-ai';
-import { createFlueContext, InMemorySessionStore, bashToSessionEnv } from '@flue/sdk/internal';
-import { randomUUID } from 'node:crypto';
-
-${agents.map((a) => {
-			return `import ${agentVarName(a.name)} from '${a.filePath.replace(/\\/g, "/")}';`;
-		}).join("\n")}
-
-// ─── Config ─────────────────────────────────────────────────────────────────
-
-const skills = {};
-const roles = ${rolesJson};
-const systemPrompt = '';
-
-const handlers = {
-${agents.map((a) => `  ${JSON.stringify(a.name)}: ${agentVarName(a.name)},`).join("\n")}
-};
-
-const webhookAgents = new Set(${JSON.stringify(webhookAgents.map((a) => a.name))});
-
-// When the CLI starts this server via \`flue run\`, it sets FLUE_MODE=local.
-// In local mode the HTTP route accepts any registered agent (including
-// trigger-less CI-only agents). In any other mode the route is restricted to
-// agents with \`webhook: true\`, preventing accidental public exposure of
-// agents that the user only intended to invoke from their CI pipeline.
-const isLocalMode = process.env.FLUE_MODE === 'local';
-
-const manifest = ${JSON.stringify({ agents: agents.map((a) => ({
-			name: a.name,
-			triggers: a.triggers
-		})) }, null, 2)};
-
-// ─── Infrastructure ─────────────────────────────────────────────────────────
-
-// No build-time model default. The user sets model at runtime via
-// \`init({ model: "provider/model-id" })\` for a session default, or via
-// \`{ model: "provider/model-id" }\` on any individual prompt/skill/task call.
-const model = undefined;
-
-function resolveModel(modelString) {
-  const slash = modelString.indexOf('/');
-  if (slash === -1) {
-    throw new Error(
-      '[flue] Invalid model "' + modelString + '". ' +
-      'Use the "provider/model-id" format (e.g. "anthropic/claude-haiku-4-5").'
-    );
-  }
-  const provider = modelString.slice(0, slash);
-  const modelId = modelString.slice(slash + 1);
-  const resolved = getModel(provider, modelId);
-  if (!resolved) {
-    throw new Error(
-      '[flue] Unknown model "' + modelString + '". ' +
-      'Provider "' + provider + '" / model id "' + modelId + '" ' +
-      'is not registered with @mariozechner/pi-ai.'
-    );
-  }
-  return resolved;
-}
-
-// ─── Sandbox Environments ───────────────────────────────────────────────────
-
-/**
- * Create an empty in-memory sandbox (default).
- * Uses InMemoryFs (no real filesystem access) with sensible defaults:
- * cwd = /home/user, /tmp exists, /bin and /usr/bin exist.
- */
-async function createDefaultEnv() {
-  const bash = new Bash({
-    fs: new InMemoryFs(),
-    network: { dangerouslyAllowFullInternetAccess: true },
-  });
-  return bashToSessionEnv(bash);
-}
-
-/**
- * Create a local sandbox backed by the host filesystem.
- * Mounts process.cwd() at /workspace via ReadWriteFs + MountableFs.
- */
-async function createLocalEnv() {
-  const rwfs = new ReadWriteFs({ root: process.cwd() });
-  const fs = new MountableFs({ base: new InMemoryFs() });
-  fs.mount('/workspace', rwfs);
-  const bash = new Bash({
-    fs,
-    cwd: '/workspace',
-    network: { dangerouslyAllowFullInternetAccess: true },
-  });
-  return bashToSessionEnv(bash);
-}
-
-// Default persistence store for Node — in-memory, process lifetime.
-const defaultStore = new InMemorySessionStore();
-
-function createContextForRequest(sessionId, payload) {
-  return createFlueContext({
-    sessionId,
-    payload,
-    env: process.env,
-    agentConfig: {
-      systemPrompt, skills, roles, model, resolveModel,
-    },
-    createDefaultEnv,
-    createLocalEnv,
-    defaultStore,
-  });
-}
-
-// ─── Server ─────────────────────────────────────────────────────────────────
-
-const app = new Hono();
-
-app.get('/health', (c) => c.json({ status: 'ok' }));
-app.get('/agents', (c) => c.json(manifest));
-
-// Session ID is required in the URL
-app.post('/agents/:name', (c) => {
-  return c.json({
-    error: 'Session ID is required. Use /agents/:name/:sessionId',
-  }, 400);
-});
-
-app.post('/agents/:name/:sessionId', async (c) => {
-  const name = c.req.param('name');
-  const sessionId = c.req.param('sessionId');
-
-  if (!handlers[name]) {
-    return c.json({ error: 'Agent not found' }, 404);
-  }
-  if (!webhookAgents.has(name) && !isLocalMode) {
-    return c.json({ error: 'Agent "' + name + '" is not web-accessible (no webhook trigger)' }, 404);
-  }
-
-  const handler = handlers[name];
-  let payload;
-  try {
-    payload = await c.req.json();
-  } catch {
-    payload = {};
-  }
-
-  const accept = c.req.header('accept') || '';
-  const isWebhook = c.req.header('x-webhook') === 'true';
-  const isSSE = accept.includes('text/event-stream') && !isWebhook;
-
-  // Fire-and-forget (webhook mode)
-  if (isWebhook) {
-    const requestId = randomUUID();
-    const ctx = createContextForRequest(sessionId, payload);
-    handler(ctx).then(
-      (result) => {
-        ctx.setEventCallback(undefined);
-        console.log('[flue] Webhook handler complete:', name, result !== undefined ? JSON.stringify(result) : '(no return)');
-      },
-      (err) => {
-        ctx.setEventCallback(undefined);
-        console.error('[flue] Webhook handler error:', name, err);
-      },
-    );
-    return c.json({ status: 'accepted', requestId }, 202);
-  }
-
-  // SSE streaming mode
-  if (isSSE) {
-    return streamSSE(c, async (stream) => {
-      let eventId = 0;
-      const ctx = createContextForRequest(sessionId, payload);
-      ctx.setEventCallback((event) => {
-        stream.writeSSE({ data: JSON.stringify(event), event: event.type, id: String(eventId++) }).catch(() => {});
-      });
-
-      try {
-        const result = await handler(ctx);
-        await stream.writeSSE({
-          data: JSON.stringify({ type: 'result', data: result !== undefined ? result : null }),
-          event: 'result',
-          id: String(eventId++),
-        });
-      } catch (err) {
-        await stream.writeSSE({
-          data: JSON.stringify({ type: 'error', error: String(err) }),
-          event: 'error',
-          id: String(eventId++),
-        });
-      } finally {
-        ctx.setEventCallback(undefined);
-      }
-    });
-  }
-
-  // Sync mode (default)
-  try {
-    const ctx = createContextForRequest(sessionId, payload);
-    const result = await handler(ctx);
-    ctx.setEventCallback(undefined);
-    return c.json({ result: result !== undefined ? result : null });
-  } catch (err) {
-    console.error('[flue] Agent error:', name, err);
-    return c.json({ error: String(err) }, 500);
-  }
-});
-
-// ─── Start ──────────────────────────────────────────────────────────────────
-
-const port = parseInt(process.env.PORT || '3000', 10);
-
-const server = serve({ fetch: app.fetch, port });
-console.log('[flue] Server listening on http://localhost:' + port);
-if (isLocalMode) {
-  console.log('[flue] Mode: local (all agents invokable, including trigger-less)');
-  console.log('[flue] Available agents: ' + ${JSON.stringify(agents.map((a) => a.name).join(", "))});
-} else {
-  console.log('[flue] Available agents: ' + ${JSON.stringify(webhookAgents.map((a) => a.name).join(", "))});
-}
-
-process.on('SIGINT', () => { server.close(); process.exit(0); });
-process.on('SIGTERM', () => { server.close(); process.exit(0); });
-`;
-	}
-	esbuildOptions(_ctx) {
-		return {
-			platform: "node",
-			target: "node22",
-			external: ["node-liblzma", "@mongodb-js/zstd"]
-		};
-	}
-};
-function agentVarName(name) {
-	return "handler_" + name.replace(/[^a-zA-Z0-9]/g, "_");
-}
-
-//#endregion
-//#region src/build.ts
-/**
-* Build a workspace into a deployable artifact.
-*
-* `options.workspaceDir` is treated as an explicit workspace root — the directory
-* directly containing agents/ and roles/. No .flue/ waterfall is performed here;
-* callers that want waterfall behavior (e.g. the CLI when --workspace is omitted)
-* should use `resolveWorkspaceFromCwd` first.
-*
-* AGENTS.md and .agents/skills/ are NOT bundled — discovered at runtime from session cwd.
-*/
-async function build(options) {
-	const workspaceDir = path.resolve(options.workspaceDir);
-	const outputDir = path.resolve(options.outputDir);
-	const plugin = resolvePlugin(options);
-	console.log(`[flue] Building workspace: ${workspaceDir}`);
-	console.log(`[flue] Output: ${outputDir}/dist`);
-	console.log(`[flue] Target: ${plugin.name}`);
-	const roles = discoverRoles(workspaceDir);
-	const agents = discoverAgents(workspaceDir);
-	if (agents.length === 0) throw new Error(`[flue] No agent files found.\n\nExpected at: ${path.join(workspaceDir, "agents")}/\nAdd at least one agent file (e.g. hello.ts).`);
-	const webhookAgents = agents.filter((a) => a.triggers.webhook);
-	const cronAgents = agents.filter((a) => a.triggers.cron);
-	const triggerlessAgents = agents.filter((a) => !a.triggers.webhook && !a.triggers.cron);
-	console.log(`[flue] Found ${Object.keys(roles).length} role(s): ${Object.keys(roles).join(", ") || "(none)"}`);
-	console.log(`[flue] Found ${agents.length} agent(s): ${agents.map((a) => a.name).join(", ")}`);
-	if (webhookAgents.length > 0) console.log(`[flue] Webhook agents: ${webhookAgents.map((a) => a.name).join(", ")}`);
-	if (cronAgents.length > 0) console.log(`[flue] Cron agents (manifest only): ${cronAgents.map((a) => `${a.name} (${a.triggers.cron})`).join(", ")}`);
-	if (triggerlessAgents.length > 0) console.log(`[flue] CLI-only agents (no HTTP route in deployed build): ${triggerlessAgents.map((a) => a.name).join(", ")}`);
-	console.log(`[flue] AGENTS.md and .agents/skills/ will be discovered at runtime from session cwd`);
-	const distDir = path.join(outputDir, "dist");
-	fs.mkdirSync(distDir, { recursive: true });
-	const manifest = { agents: agents.map((a) => ({
-		name: a.name,
-		triggers: a.triggers
-	})) };
-	const manifestPath = path.join(distDir, "manifest.json");
-	fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
-	console.log(`[flue] Generated: ${manifestPath}`);
-	const ctx = {
-		agents,
-		roles,
-		workspaceDir,
-		outputDir,
-		options
-	};
-	const serverCode = plugin.generateEntryPoint(ctx);
-	const entryPath = path.join(distDir, "_entry_server.ts");
-	const outPath = path.join(distDir, "server.mjs");
-	fs.writeFileSync(entryPath, serverCode, "utf-8");
-	try {
-		const nodePathsSet = collectNodePaths(workspaceDir);
-		const { external: pluginExternal = [], ...pluginEsbuildOpts } = plugin.esbuildOptions(ctx);
-		const userExternals = getUserExternals(workspaceDir);
-		await esbuild.build({
-			entryPoints: [entryPath],
-			bundle: true,
-			outfile: outPath,
-			format: "esm",
-			external: [...pluginExternal, ...userExternals],
-			nodePaths: [...nodePathsSet],
-			logLevel: "warning",
-			loader: {
-				".ts": "ts",
-				".node": "empty"
-			},
-			treeShaking: true,
-			sourcemap: true,
-			...pluginEsbuildOpts
-		});
-		console.log(`[flue] Built: ${outPath}`);
-	} finally {
-		try {
-			fs.unlinkSync(entryPath);
-		} catch {}
-	}
-	if (plugin.additionalOutputs) {
-		const outputs = plugin.additionalOutputs(ctx);
-		for (const [filename, content] of Object.entries(outputs)) {
-			const filePath = path.join(distDir, filename);
-			fs.mkdirSync(path.dirname(filePath), { recursive: true });
-			fs.writeFileSync(filePath, content, "utf-8");
-			console.log(`[flue] Generated: ${filePath}`);
-		}
-	}
-	console.log(`[flue] Build complete. Output: ${distDir}`);
-}
-function resolvePlugin(options) {
-	if (options.plugin) return options.plugin;
-	if (!options.target) throw new Error("[flue] No build target specified. Use --target to choose a target:\n  flue build --target node\n  flue build --target cloudflare");
-	switch (options.target) {
-		case "node": return new NodePlugin();
-		case "cloudflare": return new CloudflarePlugin();
-		default: throw new Error(`[flue] Unknown target: "${options.target}". Supported targets: node, cloudflare`);
-	}
-}
-/**
-* Resolve a Flue workspace directory from the current working directory,
-* using the two-layout convention. Intended for the CLI when `--workspace` is
-* not provided — callers that pass an explicit workspace path should skip this
-* and pass the path straight to `build()`.
-*
-* Two supported layouts, checked in order:
-*   1. `<cwd>/.flue/` — use this when Flue is embedded in an existing project.
-*   2. `<cwd>/` — use this when the project itself is the Flue workspace.
-*
-* If `.flue/` exists, it wins unconditionally — no mixing with the bare layout.
-* Returns null if neither is present so the caller can produce a helpful error.
-*/
-function resolveWorkspaceFromCwd(cwd) {
-	const dotFlue = path.join(cwd, ".flue");
-	if (fs.existsSync(dotFlue)) return dotFlue;
-	if (fs.existsSync(path.join(cwd, "agents"))) return cwd;
-	return null;
-}
-function discoverRoles(workspaceRoot) {
-	const rolesDir = path.join(workspaceRoot, "roles");
-	if (!fs.existsSync(rolesDir)) return {};
-	const roles = {};
-	for (const entry of fs.readdirSync(rolesDir)) {
-		if (!/\.(md|markdown)$/i.test(entry)) continue;
-		const filePath = path.join(rolesDir, entry);
-		const content = fs.readFileSync(filePath, "utf-8");
-		const name = entry.replace(/\.(md|markdown)$/i, "");
-		const parsed = parseFrontmatterFile(content, name);
-		roles[name] = {
-			name,
-			description: parsed.description,
-			instructions: parsed.body,
-			model: parsed.frontmatter.model
-		};
-	}
-	return roles;
-}
-function discoverAgents(workspaceRoot) {
-	const agentsDir = path.join(workspaceRoot, "agents");
-	if (!fs.existsSync(agentsDir)) return [];
-	return fs.readdirSync(agentsDir).filter((f) => /\.(ts|js|mts|mjs)$/.test(f)).map((f) => {
-		const filePath = path.join(agentsDir, f);
-		const triggers = parseTriggers(filePath);
-		return {
-			name: f.replace(/\.(ts|js|mts|mjs)$/, ""),
-			filePath,
-			triggers
-		};
-	});
-}
-/** Extract trigger config via regex. Only triggers are parsed at build time (needed for routing). */
-function parseTriggers(filePath) {
-	const source = fs.readFileSync(filePath, "utf-8");
-	const result = {};
-	const triggersExportMatch = source.match(/export\s+const\s+triggers\s*=\s*\{([^}]*)\}/);
-	if (!triggersExportMatch) return result;
-	const triggersBlock = triggersExportMatch[1] ?? "";
-	if (/webhook\s*:\s*true/.test(triggersBlock)) result.webhook = true;
-	const cronMatch = triggersBlock.match(/cron\s*:\s*['"]([^'"]+)['"]/);
-	if (cronMatch?.[1]) result.cron = cronMatch[1];
-	return result;
-}
-/** Externalize user's direct deps (bare name + subpath wildcard). */
-function getUserExternals(workspaceDir) {
-	const pkgPath = packageUpSync({ cwd: workspaceDir });
-	if (!pkgPath) return [];
-	try {
-		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-		return Object.keys({
-			...pkg.dependencies,
-			...pkg.devDependencies,
-			...pkg.peerDependencies
-		}).flatMap((name) => [name, `${name}/*`]);
-	} catch {
-		return [];
-	}
-}
-function collectNodePaths(workspaceDir) {
-	const nodePathsSet = /* @__PURE__ */ new Set();
-	for (const startDir of [workspaceDir, getSDKDir()]) {
-		let dir = startDir;
-		while (dir !== path.dirname(dir)) {
-			const nm = path.join(dir, "node_modules");
-			if (fs.existsSync(nm)) nodePathsSet.add(nm);
-			dir = path.dirname(dir);
-		}
-	}
-	return nodePathsSet;
-}
-function getSDKDir() {
-	try {
-		return path.dirname(new URL(import.meta.url).pathname);
-	} catch {
-		return __dirname;
-	}
-}
-
-//#endregion
-export { BUILTIN_TOOL_NAMES, build, createTools, resolveWorkspaceFromCwd };