@flue/sdk 0.1.1 → 0.1.2

package/dist/agent-BYG0nVbQ.mjs

@@ -0,0 +1,432 @@
+import { Type } from "@mariozechner/pi-ai";
+
+//#region src/context.ts
+/** Parse optional YAML frontmatter (--- delimited). Basic `key: value` only. */
+function parseFrontmatterFile(content, defaultName) {
+	const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+	if (!frontmatterMatch) return {
+		name: defaultName,
+		description: "",
+		body: content.trim(),
+		frontmatter: {}
+	};
+	const rawFrontmatter = frontmatterMatch[1] ?? "";
+	const body = frontmatterMatch[2] ?? "";
+	const frontmatter = {};
+	for (const line of rawFrontmatter.split("\n")) {
+		const match = line.match(/^(\w+):\s*(.+)$/);
+		if (match?.[1] && match[2]) frontmatter[match[1]] = match[2].trim();
+	}
+	return {
+		name: frontmatter.name || defaultName,
+		description: frontmatter.description || "",
+		body: body.trim(),
+		frontmatter
+	};
+}
+/** Read AGENTS.md (and CLAUDE.md if present) from a directory. Returns concatenated contents. */
+async function readAgentsMd(env, basePath) {
+	const parts = [];
+	for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
+		const filePath = basePath.endsWith("/") ? basePath + filename : `${basePath}/${filename}`;
+		if (await env.exists(filePath)) {
+			const content = await env.readFile(filePath);
+			parts.push(content.trim());
+		}
+	}
+	return parts.join("\n\n");
+}
+/**
+* Load a skill directly by relative path under `.agents/skills/`.
+*
+* The path is taken as-is — no extension is auto-appended. Callers reference
+* the full filename, e.g. `'triage/reproduce.md'`. Returns `null` if the file
+* doesn't exist.
+*
+* Used as a fallback by `session.skill()` when the requested name doesn't match
+* a discovered skill's frontmatter `name:` field. Lets users organise skills as
+* a pack of sibling markdown files under one directory (orchestration SKILL.md
+* + stage files) without forcing each stage into its own `SKILL.md` subdirectory.
+*/
+async function loadSkillByPath(env, basePath, relPath) {
+	const filePath = `${basePath.endsWith("/") ? `${basePath}.agents/skills` : `${basePath}/.agents/skills`}/${relPath}`;
+	if (!await env.exists(filePath)) return null;
+	const parsed = parseFrontmatterFile(await env.readFile(filePath), relPath.replace(/\.(md|markdown)$/i, ""));
+	return {
+		name: parsed.name,
+		description: parsed.description,
+		instructions: parsed.body
+	};
+}
+/** Discover skills from .agents/skills/<name>/SKILL.md under basePath. */
+async function discoverLocalSkills(env, basePath) {
+	const skillsDir = basePath.endsWith("/") ? `${basePath}.agents/skills` : `${basePath}/.agents/skills`;
+	if (!await env.exists(skillsDir)) return {};
+	const skills = {};
+	const entries = await env.readdir(skillsDir);
+	for (const entry of entries) {
+		const skillDir = `${skillsDir}/${entry}`;
+		try {
+			if (!(await env.stat(skillDir)).isDirectory) continue;
+		} catch {
+			continue;
+		}
+		const skillMdPath = `${skillDir}/SKILL.md`;
+		if (!await env.exists(skillMdPath)) continue;
+		const parsed = parseFrontmatterFile(await env.readFile(skillMdPath), entry);
+		skills[parsed.name] = {
+			name: parsed.name,
+			description: parsed.description,
+			instructions: parsed.body
+		};
+	}
+	return skills;
+}
+function composeSystemPrompt(agentsMd, skills, env) {
+	const parts = [];
+	if (agentsMd) parts.push(agentsMd);
+	const skillEntries = Object.values(skills);
+	if (skillEntries.length > 0) {
+		parts.push("", "## Available Skills", "");
+		for (const skill of skillEntries) {
+			const desc = skill.description ? ` - ${skill.description}` : "";
+			parts.push(`- **${skill.name}**${desc}`);
+		}
+	}
+	if (env) {
+		const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+			weekday: "short",
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		});
+		parts.push("", `Date: ${date}`);
+		parts.push(`Working directory: ${env.cwd}`);
+		if (env.directoryListing && env.directoryListing.length > 0) parts.push("", "Directory structure:", env.directoryListing.join("\n"));
+	}
+	return parts.join("\n");
+}
+/** Discover AGENTS.md, local skills, and directory listing from the session's cwd. */
+async function discoverSessionContext(env) {
+	const cwd = env.cwd;
+	const agentsMd = await readAgentsMd(env, cwd);
+	const skills = await discoverLocalSkills(env, cwd);
+	let directoryListing;
+	try {
+		directoryListing = await env.readdir(cwd);
+	} catch {}
+	return {
+		systemPrompt: composeSystemPrompt(agentsMd, skills, {
+			cwd,
+			directoryListing
+		}),
+		skills
+	};
+}
+
+//#endregion
+//#region src/agent.ts
+const MAX_READ_LINES = 2e3;
+const MAX_READ_BYTES = 50 * 1024;
+const MAX_GREP_MATCHES = 100;
+const MAX_GREP_LINE_LENGTH = 500;
+const MAX_GLOB_RESULTS = 1e3;
+const BUILTIN_TOOL_NAMES = new Set([
+	"read",
+	"write",
+	"edit",
+	"bash",
+	"grep",
+	"glob"
+]);
+function createTools(env) {
+	return [
+		createReadTool(env),
+		createWriteTool(env),
+		createEditTool(env),
+		createBashTool(env),
+		createGrepTool(env),
+		createGlobTool(env)
+	];
+}
+function createReadTool(env) {
+	return {
+		name: "read",
+		label: "Read File",
+		description: "Read a file or list a directory. For files, output is truncated to 2000 lines or 50KB — use offset/limit for large files. For directories, returns the list of entries.",
+		parameters: Type.Object({
+			path: Type.String({ description: "Path to the file to read" }),
+			offset: Type.Optional(Type.Number({ description: "Line number to start from (1-indexed)" })),
+			limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			try {
+				if ((await env.stat(params.path)).isDirectory) {
+					const entries = await env.readdir(params.path);
+					return {
+						content: [{
+							type: "text",
+							text: entries.join("\n") || "(empty directory)"
+						}],
+						details: {
+							path: params.path,
+							isDirectory: true,
+							entries: entries.length
+						}
+					};
+				}
+			} catch {}
+			const allLines = (await env.readFile(params.path)).split("\n");
+			const startLine = params.offset ? Math.max(0, params.offset - 1) : 0;
+			if (startLine >= allLines.length) throw new Error(`Offset ${params.offset} is beyond end of file (${allLines.length} lines total)`);
+			const endLine = params.limit ? startLine + params.limit : allLines.length;
+			const { text: truncatedText, wasTruncated } = truncateHead(allLines.slice(startLine, endLine), MAX_READ_LINES, MAX_READ_BYTES);
+			let output = truncatedText;
+			if (wasTruncated) {
+				const shownEnd = startLine + truncatedText.split("\n").length;
+				output += `\n\n[Showing lines ${startLine + 1}-${shownEnd} of ${allLines.length}. Use offset=${shownEnd + 1} to continue.]`;
+			}
+			return {
+				content: [{
+					type: "text",
+					text: output
+				}],
+				details: {
+					path: params.path,
+					lines: allLines.length
+				}
+			};
+		}
+	};
+}
+function createWriteTool(env) {
+	return {
+		name: "write",
+		label: "Write File",
+		description: "Write content to a file. Creates the file and parent directories if they do not exist.",
+		parameters: Type.Object({
+			path: Type.String({ description: "Path to the file to write" }),
+			content: Type.String({ description: "Content to write to the file" })
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const resolved = env.resolvePath(params.path);
+			const dir = resolved.replace(/\/[^/]*$/, "");
+			if (dir && dir !== resolved) await env.mkdir(dir, { recursive: true });
+			await env.writeFile(resolved, params.content);
+			return {
+				content: [{
+					type: "text",
+					text: `Successfully wrote ${params.content.length} bytes to ${params.path}`
+				}],
+				details: {
+					path: params.path,
+					size: params.content.length
+				}
+			};
+		}
+	};
+}
+function createEditTool(env) {
+	return {
+		name: "edit",
+		label: "Edit File",
+		description: "Edit a file using exact text replacement. The oldText must match a unique region of the file. Use replaceAll to replace all occurrences.",
+		parameters: Type.Object({
+			path: Type.String({ description: "Path to the file to edit" }),
+			oldText: Type.String({ description: "Exact text to find (must be unique)" }),
+			newText: Type.String({ description: "Replacement text" }),
+			replaceAll: Type.Optional(Type.Boolean({ description: "Replace all occurrences" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const content = await env.readFile(params.path);
+			if (params.replaceAll) {
+				const newContent = content.replaceAll(params.oldText, params.newText);
+				if (newContent === content) throw new Error(`Could not find the text in ${params.path}. No changes made.`);
+				await env.writeFile(params.path, newContent);
+				const count = content.split(params.oldText).length - 1;
+				return {
+					content: [{
+						type: "text",
+						text: `Replaced ${count} occurrences in ${params.path}`
+					}],
+					details: {
+						path: params.path,
+						replacements: count
+					}
+				};
+			}
+			const occurrences = countOccurrences(content, params.oldText);
+			if (occurrences === 0) throw new Error(`Could not find the exact text in ${params.path}. Make sure your oldText matches exactly, including whitespace and indentation.`);
+			if (occurrences > 1) throw new Error(`Found ${occurrences} occurrences of the text in ${params.path}. Provide more surrounding context to make the match unique, or use replaceAll.`);
+			const newContent = content.replace(params.oldText, params.newText);
+			await env.writeFile(params.path, newContent);
+			return {
+				content: [{
+					type: "text",
+					text: `Successfully edited ${params.path}`
+				}],
+				details: { path: params.path }
+			};
+		}
+	};
+}
+function createBashTool(env) {
+	return {
+		name: "bash",
+		label: "Run Command",
+		description: "Execute a bash command. Returns stdout and stderr. Output is truncated to the last 2000 lines or 50KB.",
+		parameters: Type.Object({
+			command: Type.String({ description: "Bash command to execute" }),
+			timeout: Type.Optional(Type.Number({ description: "Timeout in seconds" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			return formatBashResult(await env.exec(params.command), params.command);
+		}
+	};
+}
+function formatBashResult(result, command) {
+	const { text: output } = truncateTail((result.stdout + (result.stderr ? "\n" + result.stderr : "")).trim(), MAX_READ_LINES, MAX_READ_BYTES);
+	if (result.exitCode !== 0) throw new Error(`${output}\n\nCommand exited with code ${result.exitCode}`);
+	return {
+		content: [{
+			type: "text",
+			text: output || "(no output)"
+		}],
+		details: {
+			command,
+			exitCode: result.exitCode
+		}
+	};
+}
+function createGrepTool(env) {
+	return {
+		name: "grep",
+		label: "Search Files",
+		description: "Search file contents for a regex pattern. Returns matching lines with file paths and line numbers.",
+		parameters: Type.Object({
+			pattern: Type.String({ description: "Search pattern (regex)" }),
+			path: Type.Optional(Type.String({ description: "Directory or file to search (default: .)" })),
+			include: Type.Optional(Type.String({ description: "Glob filter, e.g. \"*.ts\"" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const searchPath = params.path || ".";
+			let cmd = `grep -rn "${escapeShellArg(params.pattern)}" ${escapeShellArg(searchPath)}`;
+			if (params.include) cmd = `grep -rn --include="${escapeShellArg(params.include)}" "${escapeShellArg(params.pattern)}" ${escapeShellArg(searchPath)}`;
+			const result = await env.exec(cmd);
+			if (result.exitCode === 1 && !result.stdout.trim()) return {
+				content: [{
+					type: "text",
+					text: "No matches found."
+				}],
+				details: { matchCount: 0 }
+			};
+			if (result.exitCode > 1) throw new Error(`grep failed: ${result.stderr}`);
+			const lines = result.stdout.trim().split("\n");
+			let finalOutput = lines.slice(0, MAX_GREP_MATCHES).map((line) => line.length > MAX_GREP_LINE_LENGTH ? line.slice(0, MAX_GREP_LINE_LENGTH) + "..." : line).join("\n");
+			if (lines.length > MAX_GREP_MATCHES) finalOutput += `\n\n[Showing ${MAX_GREP_MATCHES} of ${lines.length} matches. Narrow your search.]`;
+			return {
+				content: [{
+					type: "text",
+					text: finalOutput
+				}],
+				details: { matchCount: Math.min(lines.length, MAX_GREP_MATCHES) }
+			};
+		}
+	};
+}
+function createGlobTool(env) {
+	return {
+		name: "glob",
+		label: "Find Files",
+		description: "Find files by glob pattern. Returns matching file paths.",
+		parameters: Type.Object({
+			pattern: Type.String({ description: "Glob pattern, e.g. \"**/*.ts\"" }),
+			path: Type.Optional(Type.String({ description: "Directory to search in (default: .)" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const cmd = `find ${escapeShellArg(params.path || ".")} -type f -name "${escapeShellArg(params.pattern)}" 2>/dev/null | head -${MAX_GLOB_RESULTS}`;
+			const result = await env.exec(cmd);
+			if (result.exitCode !== 0 && !result.stdout.trim()) return {
+				content: [{
+					type: "text",
+					text: "No files found matching pattern."
+				}],
+				details: { matchCount: 0 }
+			};
+			const paths = result.stdout.trim().split("\n").filter(Boolean);
+			if (paths.length === 0) return {
+				content: [{
+					type: "text",
+					text: "No files found matching pattern."
+				}],
+				details: { matchCount: 0 }
+			};
+			return {
+				content: [{
+					type: "text",
+					text: paths.join("\n")
+				}],
+				details: { matchCount: paths.length }
+			};
+		}
+	};
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new Error("Operation aborted");
+}
+function countOccurrences(str, substr) {
+	let count = 0;
+	let pos = str.indexOf(substr, 0);
+	while (pos !== -1) {
+		count++;
+		pos = str.indexOf(substr, pos + substr.length);
+	}
+	return count;
+}
+function escapeShellArg(arg) {
+	return arg.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+function truncateHead(lines, maxLines, maxBytes) {
+	let result = "";
+	let lineCount = 0;
+	let wasTruncated = false;
+	for (const line of lines) {
+		if (lineCount >= maxLines) {
+			wasTruncated = true;
+			break;
+		}
+		const next = lineCount === 0 ? line : "\n" + line;
+		if (result.length + next.length > maxBytes) {
+			wasTruncated = true;
+			break;
+		}
+		result += next;
+		lineCount++;
+	}
+	return {
+		text: result,
+		wasTruncated
+	};
+}
+function truncateTail(text, maxLines, maxBytes) {
+	const lines = text.split("\n");
+	if (lines.length <= maxLines && text.length <= maxBytes) return {
+		text,
+		wasTruncated: false
+	};
+	let result = lines.slice(-maxLines).join("\n");
+	if (result.length > maxBytes) result = result.slice(-maxBytes);
+	return {
+		text: result,
+		wasTruncated: true
+	};
+}
+
+//#endregion
+export { parseFrontmatterFile as a, loadSkillByPath as i, createTools as n, discoverSessionContext as r, BUILTIN_TOOL_NAMES as t };

package/dist/client.d.mts

@@ -1,4 +1,4 @@
-import { C as ShellOptions, D as TaskOptions, E as SkillOptions, O as ToolDef, S as SessionStore, b as SessionEnv, d as FlueContext, f as FlueEvent, g as PromptResponse, h as PromptOptions, l as CommandSupport, m as FlueSession, p as FlueEventCallback, r as BashLike, s as Command, t as AgentConfig, u as FileStat, v as SandboxFactory, w as ShellResult, x as SessionInit, y as SessionData } from "./types-C97_qJ21.mjs";
+import { C as ShellOptions, D as TaskOptions, E as SkillOptions, O as ToolDef, S as SessionStore, b as SessionEnv, d as FlueContext, f as FlueEvent, g as PromptResponse, h as PromptOptions, l as CommandSupport, m as FlueSession, p as FlueEventCallback, r as BashLike, s as Command, t as AgentConfig, u as FileStat, v as SandboxFactory, w as ShellResult, x as SessionInit, y as SessionData } from "./types-C8tsaK1j.mjs";
 import { Type } from "@mariozechner/pi-ai";
 
 //#region src/client.d.ts

package/dist/client.mjs

@@ -1,4 +1,5 @@
-import { n as Session, o as discoverSessionContext } from "./session-0gnaB_aY.mjs";
+import { r as discoverSessionContext } from "./agent-BYG0nVbQ.mjs";
+import { n as Session } from "./session-BRLCNVG1.mjs";
 import { bashToSessionEnv } from "./sandbox.mjs";
 import { Type } from "@mariozechner/pi-ai";
 

package/dist/cloudflare/index.d.mts

@@ -1,4 +1,4 @@
-import { S as SessionStore, b as SessionEnv } from "../types-C97_qJ21.mjs";
+import { S as SessionStore, b as SessionEnv } from "../types-C8tsaK1j.mjs";
 
 //#region src/cloudflare/virtual-sandbox.d.ts
 interface VirtualSandboxOptions {

package/dist/cloudflare/index.mjs

@@ -1,4 +1,5 @@
-import "../session-0gnaB_aY.mjs";
+import "../agent-BYG0nVbQ.mjs";
+import "../session-BRLCNVG1.mjs";
 import { createSandboxSessionEnv } from "../sandbox.mjs";
 import { Workspace, WorkspaceFileSystem } from "@cloudflare/shell";
 

package/dist/index.d.mts

@@ -1,7 +1,5 @@
-import { C as ShellOptions, D as TaskOptions, E as SkillOptions, O as ToolDef, S as SessionStore, T as Skill, _ as Role, a as BuildOptions, b as SessionEnv, c as CommandDef, d as FlueContext, f as FlueEvent, g as PromptResponse, h as PromptOptions, i as BuildContext, l as CommandSupport, m as FlueSession, n as AgentInfo, o as BuildPlugin, p as FlueEventCallback, r as BashLike, s as Command, t as AgentConfig, u as FileStat, v as SandboxFactory, w as ShellResult, x as SessionInit, y as SessionData } from "./types-C97_qJ21.mjs";
-import { FlueContextConfig, FlueContextInternal, createFlueContext } from "./client.mjs";
+import { C as ShellOptions, D as TaskOptions, E as SkillOptions, O as ToolDef, S as SessionStore, T as Skill, _ as Role, a as BuildOptions, b as SessionEnv, c as CommandDef, d as FlueContext, f as FlueEvent, g as PromptResponse, h as PromptOptions, i as BuildContext, l as CommandSupport, m as FlueSession, n as AgentInfo, o as BuildPlugin, p as FlueEventCallback, r as BashLike, s as Command, t as AgentConfig, u as FileStat, v as SandboxFactory, w as ShellResult, x as SessionInit, y as SessionData } from "./types-C8tsaK1j.mjs";
 import { AgentTool } from "@mariozechner/pi-agent-core";
-import "valibot";
 
 //#region src/build.d.ts
 /**
@@ -10,17 +8,8 @@ import "valibot";
  */
 declare function build(options: BuildOptions): Promise<void>;
 //#endregion
-//#region src/session.d.ts
-/** In-memory session store. Sessions persist for the lifetime of the process. */
-declare class InMemorySessionStore implements SessionStore {
-  private store;
-  save(id: string, data: SessionData): Promise<void>;
-  load(id: string): Promise<SessionData | null>;
-  delete(id: string): Promise<void>;
-}
-//#endregion
 //#region src/agent.d.ts
 declare const BUILTIN_TOOL_NAMES: Set<string>;
 declare function createTools(env: SessionEnv): AgentTool<any>[];
 //#endregion
-export { type AgentConfig, type AgentInfo, BUILTIN_TOOL_NAMES, type BashLike, type BuildContext, type BuildOptions, type BuildPlugin, type Command, type CommandDef, type CommandSupport, type FileStat, type FlueContext, type FlueContextConfig, type FlueContextInternal, type FlueEvent, type FlueEventCallback, type FlueSession, InMemorySessionStore, type PromptOptions, type PromptResponse, type Role, type SandboxFactory, type SessionData, type SessionEnv, type SessionInit, type SessionStore, type ShellOptions, type ShellResult, type Skill, type SkillOptions, type TaskOptions, type ToolDef, build, createFlueContext, createTools };
+export { type AgentConfig, type AgentInfo, BUILTIN_TOOL_NAMES, type BashLike, type BuildContext, type BuildOptions, type BuildPlugin, type Command, type CommandDef, type CommandSupport, type FileStat, type FlueContext, type FlueEvent, type FlueEventCallback, type FlueSession, type PromptOptions, type PromptResponse, type Role, type SandboxFactory, type SessionData, type SessionEnv, type SessionInit, type SessionStore, type ShellOptions, type ShellResult, type Skill, type SkillOptions, type TaskOptions, type ToolDef, build, createTools };

package/dist/index.mjs

@@ -1,5 +1,4 @@
-import { a as createTools, i as BUILTIN_TOOL_NAMES, s as parseFrontmatterFile, t as InMemorySessionStore } from "./session-0gnaB_aY.mjs";
-import { createFlueContext } from "./client.mjs";
+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";
@@ -9,43 +8,30 @@ import { packageUpSync } from "package-up";
 var CloudflarePlugin = class {
 	name = "cloudflare";
 	generateEntryPoint(ctx) {
-		const { agents, roles, resolveSDKImport } = 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");
 		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 { createFlueContext, InMemorySessionStore, bashToSessionEnv } from '@flue/sdk/internal';
 import { setCloudflareContext, clearCloudflareContext, cfSandboxToSessionEnv } from '@flue/sdk/cloudflare';
 
-${agentImports}
+${agents.map((a) => {
+			return `import ${agentVarName$1(a.name)} from '${a.filePath.replace(/\\/g, "/")}';`;
+		}).join("\n")}
 
 // ─── Config ─────────────────────────────────────────────────────────────────
 
 const roles = ${rolesJson};
 const skills = {};
 const systemPrompt = '';
-const manifest = ${manifest};
+const manifest = ${JSON.stringify({ agents: agents.map((a) => ({
+			name: a.name,
+			triggers: a.triggers
+		})) }, null, 2)};
 
 // ─── Infrastructure ─────────────────────────────────────────────────────────
 
@@ -279,7 +265,15 @@ async function handleAgentRequest(request, doInstance, agentName, handler) {
 
 // ─── Per-Agent Durable Object Classes ──────────────────────────────────────
 
-${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")}
 
 // Re-export Sandbox DO class for wrangler binding
 export { Sandbox } from '@cloudflare/sandbox';
@@ -384,18 +378,9 @@ function agentClassName(name) {
 var NodePlugin = class {
 	name = "node";
 	generateEntryPoint(ctx) {
-		const { agents, roles, resolveSDKImport } = 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(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';
@@ -403,12 +388,12 @@ 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 { createFlueContext, InMemorySessionStore, bashToSessionEnv } from '@flue/sdk/internal';
 import { randomUUID } from 'node:crypto';
 
-${agentImports}
+${agents.map((a) => {
+			return `import ${agentVarName(a.name)} from '${a.filePath.replace(/\\/g, "/")}';`;
+		}).join("\n")}
 
 // ─── Config ─────────────────────────────────────────────────────────────────
 
@@ -417,12 +402,22 @@ const roles = ${rolesJson};
 const systemPrompt = '';
 
 const handlers = {
-${handlerMapEntries}
+${agents.map((a) => `  ${JSON.stringify(a.name)}: ${agentVarName(a.name)},`).join("\n")}
 };
 
-const webhookAgents = new Set(${webhookNames});
+const webhookAgents = new Set(${JSON.stringify(webhookAgents.map((a) => a.name))});
 
-const manifest = ${manifest};
+// 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 ─────────────────────────────────────────────────────────
 
@@ -521,7 +516,7 @@ app.post('/agents/:name/:sessionId', async (c) => {
   if (!handlers[name]) {
     return c.json({ error: 'Agent not found' }, 404);
   }
-  if (!webhookAgents.has(name)) {
+  if (!webhookAgents.has(name) && !isLocalMode) {
     return c.json({ error: 'Agent "' + name + '" is not web-accessible (no webhook trigger)' }, 404);
   }
 
@@ -600,7 +595,12 @@ 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(", "))});
+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); });
@@ -631,13 +631,14 @@ async function build(options) {
 	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);
+	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(agentDir, "dist");
 	fs.mkdirSync(distDir, { recursive: true });
@@ -652,8 +653,7 @@ async function build(options) {
 		agents,
 		roles,
 		agentDir,
-		options,
-		resolveSDKImport: resolveSDKImportFn
+		options
 	};
 	const serverCode = plugin.generateEntryPoint(ctx);
 	const entryPath = path.join(distDir, "_entry_server.ts");
@@ -786,18 +786,6 @@ function getSDKDir() {
 		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 };
+export { BUILTIN_TOOL_NAMES, build, createTools };

package/dist/internal.d.mts

@@ -0,0 +1,15 @@
+import { S as SessionStore, y as SessionData } from "./types-C8tsaK1j.mjs";
+import { FlueContextConfig, FlueContextInternal, createFlueContext } from "./client.mjs";
+import { bashToSessionEnv } from "./sandbox.mjs";
+import "valibot";
+
+//#region src/session.d.ts
+/** In-memory session store. Sessions persist for the lifetime of the process. */
+declare class InMemorySessionStore implements SessionStore {
+  private store;
+  save(id: string, data: SessionData): Promise<void>;
+  load(id: string): Promise<SessionData | null>;
+  delete(id: string): Promise<void>;
+}
+//#endregion
+export { type FlueContextConfig, type FlueContextInternal, InMemorySessionStore, bashToSessionEnv, createFlueContext };

package/dist/internal.mjs

@@ -0,0 +1,6 @@
+import "./agent-BYG0nVbQ.mjs";
+import { t as InMemorySessionStore } from "./session-BRLCNVG1.mjs";
+import { bashToSessionEnv } from "./sandbox.mjs";
+import { createFlueContext } from "./client.mjs";
+
+export { InMemorySessionStore, bashToSessionEnv, createFlueContext };

package/dist/sandbox.d.mts

@@ -1,4 +1,4 @@
-import { b as SessionEnv, c as CommandDef, r as BashLike, u as FileStat, v as SandboxFactory, w as ShellResult } from "./types-C97_qJ21.mjs";
+import { b as SessionEnv, c as CommandDef, r as BashLike, u as FileStat, v as SandboxFactory, w as ShellResult } from "./types-C8tsaK1j.mjs";
 
 //#region src/sandbox.d.ts
 declare function bashToSessionEnv(bash: BashLike): SessionEnv;

package/dist/sandbox.mjs

@@ -1,4 +1,5 @@
-import { r as normalizePath } from "./session-0gnaB_aY.mjs";
+import "./agent-BYG0nVbQ.mjs";
+import { r as normalizePath } from "./session-BRLCNVG1.mjs";
 
 //#region src/sandbox.ts
 function bashToSessionEnv(bash) {

package/dist/{session-0gnaB_aY.mjs → session-BRLCNVG1.mjs}

@@ -1,437 +1,9 @@
+import { i as loadSkillByPath, n as createTools, r as discoverSessionContext, t as BUILTIN_TOOL_NAMES } from "./agent-BYG0nVbQ.mjs";
+import { completeSimple, isContextOverflow } from "@mariozechner/pi-ai";
 import { Agent } from "@mariozechner/pi-agent-core";
-import { Type, completeSimple, isContextOverflow } from "@mariozechner/pi-ai";
 import { toJsonSchema } from "@valibot/to-json-schema";
 import * as v from "valibot";
 
-//#region src/context.ts
-/** Parse optional YAML frontmatter (--- delimited). Basic `key: value` only. */
-function parseFrontmatterFile(content, defaultName) {
-	const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
-	if (!frontmatterMatch) return {
-		name: defaultName,
-		description: "",
-		body: content.trim(),
-		frontmatter: {}
-	};
-	const rawFrontmatter = frontmatterMatch[1] ?? "";
-	const body = frontmatterMatch[2] ?? "";
-	const frontmatter = {};
-	for (const line of rawFrontmatter.split("\n")) {
-		const match = line.match(/^(\w+):\s*(.+)$/);
-		if (match?.[1] && match[2]) frontmatter[match[1]] = match[2].trim();
-	}
-	return {
-		name: frontmatter.name || defaultName,
-		description: frontmatter.description || "",
-		body: body.trim(),
-		frontmatter
-	};
-}
-/** Read AGENTS.md (and CLAUDE.md if present) from a directory. Returns concatenated contents. */
-async function readAgentsMd(env, basePath) {
-	const parts = [];
-	for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
-		const filePath = basePath.endsWith("/") ? basePath + filename : `${basePath}/${filename}`;
-		if (await env.exists(filePath)) {
-			const content = await env.readFile(filePath);
-			parts.push(content.trim());
-		}
-	}
-	return parts.join("\n\n");
-}
-/**
-* Load a skill directly by relative path under `.agents/skills/`.
-*
-* The path is taken as-is — no extension is auto-appended. Callers reference
-* the full filename, e.g. `'triage/reproduce.md'`. Returns `null` if the file
-* doesn't exist.
-*
-* Used as a fallback by `session.skill()` when the requested name doesn't match
-* a discovered skill's frontmatter `name:` field. Lets users organise skills as
-* a pack of sibling markdown files under one directory (orchestration SKILL.md
-* + stage files) without forcing each stage into its own `SKILL.md` subdirectory.
-*/
-async function loadSkillByPath(env, basePath, relPath) {
-	const filePath = `${basePath.endsWith("/") ? `${basePath}.agents/skills` : `${basePath}/.agents/skills`}/${relPath}`;
-	if (!await env.exists(filePath)) return null;
-	const parsed = parseFrontmatterFile(await env.readFile(filePath), relPath.replace(/\.(md|markdown)$/i, ""));
-	return {
-		name: parsed.name,
-		description: parsed.description,
-		instructions: parsed.body
-	};
-}
-/** Discover skills from .agents/skills/<name>/SKILL.md under basePath. */
-async function discoverLocalSkills(env, basePath) {
-	const skillsDir = basePath.endsWith("/") ? `${basePath}.agents/skills` : `${basePath}/.agents/skills`;
-	if (!await env.exists(skillsDir)) return {};
-	const skills = {};
-	const entries = await env.readdir(skillsDir);
-	for (const entry of entries) {
-		const skillDir = `${skillsDir}/${entry}`;
-		try {
-			if (!(await env.stat(skillDir)).isDirectory) continue;
-		} catch {
-			continue;
-		}
-		const skillMdPath = `${skillDir}/SKILL.md`;
-		if (!await env.exists(skillMdPath)) continue;
-		const parsed = parseFrontmatterFile(await env.readFile(skillMdPath), entry);
-		skills[parsed.name] = {
-			name: parsed.name,
-			description: parsed.description,
-			instructions: parsed.body
-		};
-	}
-	return skills;
-}
-function composeSystemPrompt(agentsMd, skills, env) {
-	const parts = [];
-	if (agentsMd) parts.push(agentsMd);
-	const skillEntries = Object.values(skills);
-	if (skillEntries.length > 0) {
-		parts.push("", "## Available Skills", "");
-		for (const skill of skillEntries) {
-			const desc = skill.description ? ` - ${skill.description}` : "";
-			parts.push(`- **${skill.name}**${desc}`);
-		}
-	}
-	if (env) {
-		const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-			weekday: "short",
-			year: "numeric",
-			month: "short",
-			day: "numeric"
-		});
-		parts.push("", `Date: ${date}`);
-		parts.push(`Working directory: ${env.cwd}`);
-		if (env.directoryListing && env.directoryListing.length > 0) parts.push("", "Directory structure:", env.directoryListing.join("\n"));
-	}
-	return parts.join("\n");
-}
-/** Discover AGENTS.md, local skills, and directory listing from the session's cwd. */
-async function discoverSessionContext(env) {
-	const cwd = env.cwd;
-	const agentsMd = await readAgentsMd(env, cwd);
-	const skills = await discoverLocalSkills(env, cwd);
-	let directoryListing;
-	try {
-		directoryListing = await env.readdir(cwd);
-	} catch {}
-	return {
-		systemPrompt: composeSystemPrompt(agentsMd, skills, {
-			cwd,
-			directoryListing
-		}),
-		skills
-	};
-}
-
-//#endregion
-//#region src/agent.ts
-const MAX_READ_LINES = 2e3;
-const MAX_READ_BYTES = 50 * 1024;
-const MAX_GREP_MATCHES = 100;
-const MAX_GREP_LINE_LENGTH = 500;
-const MAX_GLOB_RESULTS = 1e3;
-const BUILTIN_TOOL_NAMES = new Set([
-	"read",
-	"write",
-	"edit",
-	"bash",
-	"grep",
-	"glob"
-]);
-function createTools(env) {
-	return [
-		createReadTool(env),
-		createWriteTool(env),
-		createEditTool(env),
-		createBashTool(env),
-		createGrepTool(env),
-		createGlobTool(env)
-	];
-}
-function createReadTool(env) {
-	return {
-		name: "read",
-		label: "Read File",
-		description: "Read a file or list a directory. For files, output is truncated to 2000 lines or 50KB — use offset/limit for large files. For directories, returns the list of entries.",
-		parameters: Type.Object({
-			path: Type.String({ description: "Path to the file to read" }),
-			offset: Type.Optional(Type.Number({ description: "Line number to start from (1-indexed)" })),
-			limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" }))
-		}),
-		async execute(_toolCallId, params, signal) {
-			throwIfAborted(signal);
-			try {
-				if ((await env.stat(params.path)).isDirectory) {
-					const entries = await env.readdir(params.path);
-					return {
-						content: [{
-							type: "text",
-							text: entries.join("\n") || "(empty directory)"
-						}],
-						details: {
-							path: params.path,
-							isDirectory: true,
-							entries: entries.length
-						}
-					};
-				}
-			} catch {}
-			const allLines = (await env.readFile(params.path)).split("\n");
-			const startLine = params.offset ? Math.max(0, params.offset - 1) : 0;
-			if (startLine >= allLines.length) throw new Error(`Offset ${params.offset} is beyond end of file (${allLines.length} lines total)`);
-			const endLine = params.limit ? startLine + params.limit : allLines.length;
-			const { text: truncatedText, wasTruncated } = truncateHead(allLines.slice(startLine, endLine), MAX_READ_LINES, MAX_READ_BYTES);
-			let output = truncatedText;
-			if (wasTruncated) {
-				const shownEnd = startLine + truncatedText.split("\n").length;
-				output += `\n\n[Showing lines ${startLine + 1}-${shownEnd} of ${allLines.length}. Use offset=${shownEnd + 1} to continue.]`;
-			}
-			return {
-				content: [{
-					type: "text",
-					text: output
-				}],
-				details: {
-					path: params.path,
-					lines: allLines.length
-				}
-			};
-		}
-	};
-}
-function createWriteTool(env) {
-	return {
-		name: "write",
-		label: "Write File",
-		description: "Write content to a file. Creates the file and parent directories if they do not exist.",
-		parameters: Type.Object({
-			path: Type.String({ description: "Path to the file to write" }),
-			content: Type.String({ description: "Content to write to the file" })
-		}),
-		async execute(_toolCallId, params, signal) {
-			throwIfAborted(signal);
-			const resolved = env.resolvePath(params.path);
-			const dir = resolved.replace(/\/[^/]*$/, "");
-			if (dir && dir !== resolved) await env.mkdir(dir, { recursive: true });
-			await env.writeFile(resolved, params.content);
-			return {
-				content: [{
-					type: "text",
-					text: `Successfully wrote ${params.content.length} bytes to ${params.path}`
-				}],
-				details: {
-					path: params.path,
-					size: params.content.length
-				}
-			};
-		}
-	};
-}
-function createEditTool(env) {
-	return {
-		name: "edit",
-		label: "Edit File",
-		description: "Edit a file using exact text replacement. The oldText must match a unique region of the file. Use replaceAll to replace all occurrences.",
-		parameters: Type.Object({
-			path: Type.String({ description: "Path to the file to edit" }),
-			oldText: Type.String({ description: "Exact text to find (must be unique)" }),
-			newText: Type.String({ description: "Replacement text" }),
-			replaceAll: Type.Optional(Type.Boolean({ description: "Replace all occurrences" }))
-		}),
-		async execute(_toolCallId, params, signal) {
-			throwIfAborted(signal);
-			const content = await env.readFile(params.path);
-			if (params.replaceAll) {
-				const newContent = content.replaceAll(params.oldText, params.newText);
-				if (newContent === content) throw new Error(`Could not find the text in ${params.path}. No changes made.`);
-				await env.writeFile(params.path, newContent);
-				const count = content.split(params.oldText).length - 1;
-				return {
-					content: [{
-						type: "text",
-						text: `Replaced ${count} occurrences in ${params.path}`
-					}],
-					details: {
-						path: params.path,
-						replacements: count
-					}
-				};
-			}
-			const occurrences = countOccurrences(content, params.oldText);
-			if (occurrences === 0) throw new Error(`Could not find the exact text in ${params.path}. Make sure your oldText matches exactly, including whitespace and indentation.`);
-			if (occurrences > 1) throw new Error(`Found ${occurrences} occurrences of the text in ${params.path}. Provide more surrounding context to make the match unique, or use replaceAll.`);
-			const newContent = content.replace(params.oldText, params.newText);
-			await env.writeFile(params.path, newContent);
-			return {
-				content: [{
-					type: "text",
-					text: `Successfully edited ${params.path}`
-				}],
-				details: { path: params.path }
-			};
-		}
-	};
-}
-function createBashTool(env) {
-	return {
-		name: "bash",
-		label: "Run Command",
-		description: "Execute a bash command. Returns stdout and stderr. Output is truncated to the last 2000 lines or 50KB.",
-		parameters: Type.Object({
-			command: Type.String({ description: "Bash command to execute" }),
-			timeout: Type.Optional(Type.Number({ description: "Timeout in seconds" }))
-		}),
-		async execute(_toolCallId, params, signal) {
-			throwIfAborted(signal);
-			return formatBashResult(await env.exec(params.command), params.command);
-		}
-	};
-}
-function formatBashResult(result, command) {
-	const { text: output } = truncateTail((result.stdout + (result.stderr ? "\n" + result.stderr : "")).trim(), MAX_READ_LINES, MAX_READ_BYTES);
-	if (result.exitCode !== 0) throw new Error(`${output}\n\nCommand exited with code ${result.exitCode}`);
-	return {
-		content: [{
-			type: "text",
-			text: output || "(no output)"
-		}],
-		details: {
-			command,
-			exitCode: result.exitCode
-		}
-	};
-}
-function createGrepTool(env) {
-	return {
-		name: "grep",
-		label: "Search Files",
-		description: "Search file contents for a regex pattern. Returns matching lines with file paths and line numbers.",
-		parameters: Type.Object({
-			pattern: Type.String({ description: "Search pattern (regex)" }),
-			path: Type.Optional(Type.String({ description: "Directory or file to search (default: .)" })),
-			include: Type.Optional(Type.String({ description: "Glob filter, e.g. \"*.ts\"" }))
-		}),
-		async execute(_toolCallId, params, signal) {
-			throwIfAborted(signal);
-			const searchPath = params.path || ".";
-			let cmd = `grep -rn "${escapeShellArg(params.pattern)}" ${escapeShellArg(searchPath)}`;
-			if (params.include) cmd = `grep -rn --include="${escapeShellArg(params.include)}" "${escapeShellArg(params.pattern)}" ${escapeShellArg(searchPath)}`;
-			const result = await env.exec(cmd);
-			if (result.exitCode === 1 && !result.stdout.trim()) return {
-				content: [{
-					type: "text",
-					text: "No matches found."
-				}],
-				details: { matchCount: 0 }
-			};
-			if (result.exitCode > 1) throw new Error(`grep failed: ${result.stderr}`);
-			const lines = result.stdout.trim().split("\n");
-			let finalOutput = lines.slice(0, MAX_GREP_MATCHES).map((line) => line.length > MAX_GREP_LINE_LENGTH ? line.slice(0, MAX_GREP_LINE_LENGTH) + "..." : line).join("\n");
-			if (lines.length > MAX_GREP_MATCHES) finalOutput += `\n\n[Showing ${MAX_GREP_MATCHES} of ${lines.length} matches. Narrow your search.]`;
-			return {
-				content: [{
-					type: "text",
-					text: finalOutput
-				}],
-				details: { matchCount: Math.min(lines.length, MAX_GREP_MATCHES) }
-			};
-		}
-	};
-}
-function createGlobTool(env) {
-	return {
-		name: "glob",
-		label: "Find Files",
-		description: "Find files by glob pattern. Returns matching file paths.",
-		parameters: Type.Object({
-			pattern: Type.String({ description: "Glob pattern, e.g. \"**/*.ts\"" }),
-			path: Type.Optional(Type.String({ description: "Directory to search in (default: .)" }))
-		}),
-		async execute(_toolCallId, params, signal) {
-			throwIfAborted(signal);
-			const cmd = `find ${escapeShellArg(params.path || ".")} -type f -name "${escapeShellArg(params.pattern)}" 2>/dev/null | head -${MAX_GLOB_RESULTS}`;
-			const result = await env.exec(cmd);
-			if (result.exitCode !== 0 && !result.stdout.trim()) return {
-				content: [{
-					type: "text",
-					text: "No files found matching pattern."
-				}],
-				details: { matchCount: 0 }
-			};
-			const paths = result.stdout.trim().split("\n").filter(Boolean);
-			if (paths.length === 0) return {
-				content: [{
-					type: "text",
-					text: "No files found matching pattern."
-				}],
-				details: { matchCount: 0 }
-			};
-			return {
-				content: [{
-					type: "text",
-					text: paths.join("\n")
-				}],
-				details: { matchCount: paths.length }
-			};
-		}
-	};
-}
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw new Error("Operation aborted");
-}
-function countOccurrences(str, substr) {
-	let count = 0;
-	let pos = str.indexOf(substr, 0);
-	while (pos !== -1) {
-		count++;
-		pos = str.indexOf(substr, pos + substr.length);
-	}
-	return count;
-}
-function escapeShellArg(arg) {
-	return arg.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`");
-}
-function truncateHead(lines, maxLines, maxBytes) {
-	let result = "";
-	let lineCount = 0;
-	let wasTruncated = false;
-	for (const line of lines) {
-		if (lineCount >= maxLines) {
-			wasTruncated = true;
-			break;
-		}
-		const next = lineCount === 0 ? line : "\n" + line;
-		if (result.length + next.length > maxBytes) {
-			wasTruncated = true;
-			break;
-		}
-		result += next;
-		lineCount++;
-	}
-	return {
-		text: result,
-		wasTruncated
-	};
-}
-function truncateTail(text, maxLines, maxBytes) {
-	const lines = text.split("\n");
-	if (lines.length <= maxLines && text.length <= maxBytes) return {
-		text,
-		wasTruncated: false
-	};
-	let result = lines.slice(-maxLines).join("\n");
-	if (result.length > maxBytes) result = result.slice(-maxBytes);
-	return {
-		text: result,
-		wasTruncated: true
-	};
-}
-
-//#endregion
 //#region src/compaction.ts
 const DEFAULT_COMPACTION_SETTINGS = {
 	enabled: true,
@@ -1350,4 +922,4 @@ function normalizePath(p) {
 }
 
 //#endregion
-export { createTools as a, BUILTIN_TOOL_NAMES as i, Session as n, discoverSessionContext as o, normalizePath as r, parseFrontmatterFile as s, InMemorySessionStore as t };
+export { Session as n, normalizePath as r, InMemorySessionStore as t };

package/dist/{types-C97_qJ21.d.mts → types-C8tsaK1j.d.mts}

@@ -1,5 +1,5 @@
-import { AgentMessage } from "@mariozechner/pi-agent-core";
 import { Model, TSchema } from "@mariozechner/pi-ai";
+import { AgentMessage } from "@mariozechner/pi-agent-core";
 import * as v from "valibot";
 
 //#region src/types.d.ts
@@ -317,7 +317,6 @@ interface BuildContext {
   roles: Record<string, Role>;
   agentDir: string;
   options: BuildOptions;
-  resolveSDKImport: (module: string) => string;
 }
 /** Controls the build output format for a target platform. */
 interface BuildPlugin {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flue/sdk",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "license": "Apache-2.0",
   "exports": {
@@ -16,6 +16,10 @@
       "types": "./dist/sandbox.d.mts",
       "import": "./dist/sandbox.mjs"
     },
+    "./internal": {
+      "types": "./dist/internal.d.mts",
+      "import": "./dist/internal.mjs"
+    },
     "./cloudflare": {
       "types": "./dist/cloudflare/index.d.mts",
       "import": "./dist/cloudflare/index.mjs"