@flue/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,775 @@
+import { a as createTools, i as BUILTIN_TOOL_NAMES, s as parseFrontmatterFile, t as InMemorySessionStore } from "./session-BD0MEuO3.mjs";
+import { createFlueContext } from "./client.mjs";
+import * as esbuild from "esbuild";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { packageUpSync } from "package-up";
+
+//#region src/build-plugin-cloudflare.ts
+var CloudflarePlugin = class {
+	name = "cloudflare";
+	generateEntryPoint(ctx) {
+		const { agents, roles, options, resolveSDKImport } = ctx;
+		const modelProvider = options.model?.provider ?? "anthropic";
+		const modelId = options.model?.modelId ?? "claude-haiku-4-5";
+		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");
+		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 } from '${resolveSDKImport("client")}';
+import { InMemorySessionStore } from '${resolveSDKImport("session")}';
+import { bashToSessionEnv } from '${resolveSDKImport("sandbox")}';
+import { setCloudflareContext, clearCloudflareContext, cfSandboxToSessionEnv } from '@flue/sdk/cloudflare';
+
+${agentImports}
+
+// ─── Config ─────────────────────────────────────────────────────────────────
+
+const roles = ${rolesJson};
+const skills = {};
+const systemPrompt = '';
+const manifest = ${manifest};
+
+// ─── Infrastructure ─────────────────────────────────────────────────────────
+
+const model = getModel(${JSON.stringify(modelProvider)}, ${JSON.stringify(modelId)});
+
+function resolveModel(modelString) {
+  const slash = modelString.indexOf('/');
+  if (slash !== -1) {
+    return getModel(modelString.slice(0, slash), modelString.slice(slash + 1));
+  }
+  return getModel(${JSON.stringify(modelProvider)}, modelString);
+}
+
+// ─── 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 use getSandbox() from @cloudflare/sandbox for container sandboxes."
+  );
+}
+
+/**
+ * Detect and wrap @cloudflare/sandbox instances (from getSandbox()).
+ * Returns SessionEnv if the sandbox is a CF 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}
+
+// Re-export Sandbox DO class for wrangler binding
+export { Sandbox } from '@cloudflare/sandbox';
+
+// ─── 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:*"]
+		};
+	}
+	additionalOutputs(ctx) {
+		const outputs = {};
+		const allBindings = [...ctx.agents.filter((a) => a.triggers.webhook).map((a) => ({
+			class_name: agentClassName(a.name),
+			name: agentClassName(a.name)
+		})), {
+			class_name: "Sandbox",
+			name: "Sandbox"
+		}];
+		const allSqliteClasses = allBindings.map((b) => b.class_name);
+		const workerName = ctx.agentDir.split("/").pop() ?? "flue-agents";
+		outputs["wrangler.jsonc"] = JSON.stringify({
+			$schema: "https://workers.cloudflare.com/schema/wrangler.json",
+			name: workerName,
+			main: "server.mjs",
+			compatibility_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+			compatibility_flags: ["nodejs_compat"],
+			containers: [{
+				class_name: "Sandbox",
+				image: "./Dockerfile"
+			}],
+			durable_objects: { bindings: allBindings },
+			migrations: [{
+				new_sqlite_classes: allSqliteClasses,
+				tag: "v1"
+			}]
+		}, null, 2);
+		outputs["Dockerfile"] = [
+			"FROM node:22-slim",
+			"",
+			"# Install common tools for agent sandboxes",
+			"RUN apt-get update && apt-get install -y \\",
+			"    git curl wget \\",
+			"    python3 python3-pip \\",
+			"    && rm -rf /var/lib/apt/lists/*",
+			"",
+			"WORKDIR /workspace",
+			"",
+			"# Keep container alive",
+			"CMD [\"sleep\", \"infinity\"]",
+			""
+		].join("\n");
+		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, options, resolveSDKImport } = ctx;
+		const modelProvider = options.model?.provider ?? "anthropic";
+		const modelId = options.model?.modelId ?? "claude-haiku-4-5";
+		const rolesJson = JSON.stringify(roles);
+		const webhookAgents = agents.filter((a) => a.triggers.webhook);
+		const agentImports = agents.map((a) => {
+			return `import ${agentVarName(a.name)} from '${a.filePath.replace(/\\/g, "/")}';`;
+		}).join("\n");
+		const handlerMapEntries = agents.map((a) => `  ${JSON.stringify(a.name)}: ${agentVarName(a.name)},`).join("\n");
+		const webhookNames = JSON.stringify(webhookAgents.map((a) => a.name));
+		const manifest = JSON.stringify({ agents: agents.map((a) => ({
+			name: a.name,
+			triggers: a.triggers
+		})) }, null, 2);
+		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 } from '${resolveSDKImport("client")}';
+import { InMemorySessionStore } from '${resolveSDKImport("session")}';
+import { bashToSessionEnv } from '${resolveSDKImport("sandbox")}';
+import { randomUUID } from 'node:crypto';
+
+${agentImports}
+
+// ─── Config ─────────────────────────────────────────────────────────────────
+
+const skills = {};
+const roles = ${rolesJson};
+const systemPrompt = '';
+
+const handlers = {
+${handlerMapEntries}
+};
+
+const webhookAgents = new Set(${webhookNames});
+
+const manifest = ${manifest};
+
+// ─── Infrastructure ─────────────────────────────────────────────────────────
+
+const model = getModel(${JSON.stringify(modelProvider)}, ${JSON.stringify(modelId)});
+
+function resolveModel(modelString) {
+  const slash = modelString.indexOf('/');
+  if (slash !== -1) {
+    return getModel(modelString.slice(0, slash), modelString.slice(slash + 1));
+  }
+  return getModel(${JSON.stringify(modelProvider)}, modelString);
+}
+
+// ─── 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)) {
+    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);
+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"
+		};
+	}
+};
+function agentVarName(name) {
+	return "handler_" + name.replace(/[^a-zA-Z0-9]/g, "_");
+}
+
+//#endregion
+//#region src/build.ts
+/**
+* Build a workspace into a deployable artifact.
+* AGENTS.md and .agents/skills/ are NOT bundled — discovered at runtime from session cwd.
+*/
+async function build(options) {
+	const agentDir = path.resolve(options.agentDir);
+	const plugin = resolvePlugin(options);
+	console.log(`[flue] Building workspace: ${agentDir}`);
+	console.log(`[flue] Target: ${plugin.name}`);
+	const roles = discoverRoles(agentDir);
+	const agents = discoverAgents(agentDir);
+	if (agents.length === 0) throw new Error(`No agents found in ${path.join(agentDir, ".flue/agents/")}`);
+	for (const agent of agents) if (!(agent.triggers.webhook || agent.triggers.cron)) throw new Error(`[flue] Agent "${agent.name}" has no triggers configured. Add a triggers export to your agent file:\n\n  export const triggers = { webhook: true };\n\nAvailable triggers: webhook (HTTP endpoint), cron (scheduled)`);
+	const webhookAgents = agents.filter((a) => a.triggers.webhook);
+	const cronAgents = agents.filter((a) => 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(", ")}`);
+	console.log(`[flue] AGENTS.md and .agents/skills/ will be discovered at runtime from session cwd`);
+	const distDir = path.join(agentDir, "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,
+		agentDir,
+		options,
+		resolveSDKImport: resolveSDKImportFn
+	};
+	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(agentDir);
+		const { external: pluginExternal = [], ...pluginEsbuildOpts } = plugin.esbuildOptions(ctx);
+		const userExternals = getUserExternals(agentDir);
+		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`);
+	}
+}
+function discoverRoles(agentDir) {
+	const rolesDir = path.join(agentDir, ".flue", "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(agentDir) {
+	let agentsDir = path.join(agentDir, ".flue", "agents");
+	if (!fs.existsSync(agentsDir)) {
+		agentsDir = path.join(agentDir, ".flue", "workflows");
+		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(agentDir) {
+	const pkgPath = packageUpSync({ cwd: agentDir });
+	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(agentDir) {
+	const nodePathsSet = /* @__PURE__ */ new Set();
+	for (const startDir of [agentDir, 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;
+	}
+}
+function getSDKSrcDir() {
+	const thisDir = getSDKDir();
+	if (thisDir.endsWith("/dist") || thisDir.endsWith("\\dist")) {
+		const srcDir = path.join(path.dirname(thisDir), "src");
+		if (fs.existsSync(srcDir)) return srcDir;
+	}
+	return thisDir;
+}
+function resolveSDKImportFn(module) {
+	const srcDir = getSDKSrcDir();
+	return path.join(srcDir, `${module}.ts`).replace(/\\/g, "/");
+}
+
+//#endregion
+export { BUILTIN_TOOL_NAMES, InMemorySessionStore, build, createFlueContext, createTools };