@flue/sdk 0.1.3 → 0.3.0

package/README.md

@@ -35,11 +35,10 @@ import * as v from 'valibot';
 export const triggers = { webhook: true };
 
 // The agent handler. Where the orchestration of the agent lives.
-export default async function ({ init, payload, sessionId }: FlueContext) {
-  // `session` -- Your session with the agent, including sandbox, message history, etc.
-  // By default, calling `init()` with no arguments gets you a completely empty agent,
-  // with no skills, AGENTS.md, or files.
-  const session = await init();
+export default async function ({ init, payload }: FlueContext) {
+  // `agent` -- Your initialized agent runtime including sandbox, tools, skills, etc.
+  const agent = await init({ model: 'anthropic/claude-sonnet-4-6' });
+  const session = await agent.session();
 
   // prompt() sends a message in the session, triggering action.
   const result = await session.prompt(`Translate this to ${payload.language}: "${payload.text}"`, {
@@ -73,7 +72,8 @@ export default async function ({ init, payload, env }: FlueContext) {
   // The agent can grep, glob, and read articles with bash, but
   // without needing to spin up an entire container sandbox.
   const sandbox = await getVirtualSandbox(env.KNOWLEDGE_BASE);
-  const session = await init({ sandbox });
+  const agent = await init({ sandbox, model: 'openrouter/moonshotai/kimi-k2.6' });
+  const session = await agent.session();
 
   return await session.prompt(
     `You are a support agent. Search the knowledge base for articles
@@ -114,11 +114,12 @@ export default async function ({ init, payload }: FlueContext) {
   // discovered automatically from the workspace directory.
   //
   // `model` sets the default model for every prompt/skill call in this
-  // session. Override per-call with `{ model: '...' }` on prompt()/skill().
-  const session = await init({
+  // agent. Override per-call with `{ model: '...' }` on prompt()/skill().
+  const agent = await init({
     sandbox: 'local',
-    model: 'anthropic/claude-opus-4-20250514',
+    model: 'anthropic/claude-opus-4-7',
   });
+  const session = await agent.session();
 
   // Skills can be referenced either by their frontmatter `name:` (shown below)
   // or by a relative path under `.agents/skills/` — e.g.
@@ -158,23 +159,35 @@ import { daytona } from '@flue/connectors/daytona';
 export const triggers = { webhook: true };
 
 export default async function ({ init, payload, env }: FlueContext) {
-  // Each session gets a real container via Daytona. The container has
+  // Each agent gets a real container via Daytona. The container has
   // a full Linux environment with persistent filesystem and shell.
   //
   // For simplicity, we always create a new sandbox here. You could also
-  // first check for an existing sandbox for the sessionId, and reuse that
+  // first check for an existing sandbox for the agent id, and reuse that
   // instead to best pick up where you last left off in the conversation.
   const client = new Daytona({ apiKey: env.DAYTONA_API_KEY });
   const sandbox = await client.create();
-  const session = await init({
+  const setupAgent = await init({
     sandbox: daytona(sandbox, { cleanup: true }),
+    model: 'openai/gpt-5.5',
   });
+  const setup = await setupAgent.session();
 
   // For simplicity, we clone the target repo into the sandbox here.
   // You could also bake these into the container image snapshot for a
   // faster / near-instant startup.
-  await session.shell(`git clone ${payload.repo} /workspace/project`);
-  await session.shell('npm install', { cwd: '/workspace/project' });
+  await setup.shell(`git clone ${payload.repo} /workspace/project`);
+  await setup.shell('npm install', { cwd: '/workspace/project' });
+
+  // Start a second agent in the cloned repo. It shares the same sandbox, but
+  // discovers AGENTS.md and skills from /workspace/project.
+  const projectAgent = await init({
+    id: 'project',
+    sandbox: daytona(sandbox),
+    cwd: '/workspace/project',
+    model: 'openai/gpt-5.5',
+  });
+  const session = await projectAgent.session();
 
   // Coding agents don't hide the agent DX from the user, so no need to
   // wrap the user's prompt in anything. Just send it to the agent directly
@@ -183,6 +196,113 @@ export default async function ({ init, payload, env }: FlueContext) {
 }
 ```
 
+### Remote MCP Tools
+
+MCP is available as a runtime tool adapter. Connect to a remote MCP server in trusted code, pass its tools to `init()`, and keep secrets in `env` instead of filesystem context or prompts.
+
+```ts
+// .flue/agents/assistant.ts
+import { connectMcpServer, type FlueContext } from '@flue/sdk/client';
+
+export const triggers = { webhook: true };
+
+export default async function ({ init, payload, env }: FlueContext) {
+  const github = await connectMcpServer('github', {
+    url: 'https://mcp.github.com/mcp',
+    headers: {
+      Authorization: `Bearer ${env.GITHUB_TOKEN}`,
+    },
+  });
+
+  try {
+    const agent = await init({
+      model: 'anthropic/claude-sonnet-4-6',
+      tools: github.tools,
+    });
+    const session = await agent.session();
+    return await session.prompt(payload.prompt);
+  } finally {
+    await github.close();
+  }
+}
+```
+
+`connectMcpServer()` defaults to modern streamable HTTP. For legacy SSE servers, pass `transport: 'sse'`. Flue does not auto-detect transports, spawn local stdio MCP servers, or handle OAuth callbacks in this first version.
+
+## Agents And Sessions
+
+Every agent invocation runs inside an initialized agent runtime. For HTTP agents, the agent ID is the last path segment:
+
+```txt
+POST /agents/<agent-name>/<id>
+```
+
+By default, `agent.session()` opens the default session for that agent ID. Reuse the same agent ID to continue the same default conversation. Use a new agent ID to start fresh.
+
+```bash
+# Start a conversation
+curl http://localhost:8787/agents/hello/session-abc \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Alice"}'
+
+# Continue that conversation
+curl http://localhost:8787/agents/hello/session-abc \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Alice"}'
+
+# Start a separate conversation
+curl http://localhost:8787/agents/hello/session-xyz \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Alice"}'
+```
+
+Agents own sandbox state such as files written during a run. Sessions persist message history and conversation metadata inside an agent. On Cloudflare, session data is backed by Durable Objects and survives across requests. On Node.js, sessions are stored in memory by default unless you provide a custom store.
+
+In production, generate a stable agent ID for the sandbox/runtime scope you want to preserve. Use `agent.session(threadId)` when you need multiple conversations inside the same agent.
+
+### Tasks
+
+Use `session.task()` to run a focused, one-shot child agent in a detached session. Tasks share the same sandbox/filesystem, but get their own message history and discover `AGENTS.md` plus `.agents/skills/` from their working directory. The same `task` tool is also available to the LLM during `prompt()` and `skill()` calls, so the agent can delegate parallel research or exploration work itself.
+
+```ts
+const session = await agent.session();
+
+const research = await session.task('Research the auth flow and summarize the key files.', {
+  cwd: '/workspace/project',
+  role: 'researcher',
+});
+
+const answer = await session.prompt(
+  `Use this research to draft the implementation plan:\n\n${research.text}`,
+);
+```
+
+Roles can be set at the agent, session, or call level. Precedence is `call role > session role > agent role`. Role instructions are applied as call-scoped system prompt overlays, not injected into the persisted user message history.
+
+```ts
+const agent = await init({ model: 'anthropic/claude-sonnet-4-6', role: 'coder' });
+const session = await agent.session('review-thread', { role: 'reviewer' });
+
+await session.prompt('Review the latest changes.'); // uses reviewer
+await session.task('Research related issues.', { role: 'researcher' }); // uses researcher
+```
+
+### Custom Virtual Sandboxes
+
+For most agents, use the built-in virtual sandbox or `sandbox: 'local'`. If you need to customize just-bash directly, pass a Bash factory. The factory must return a fresh Bash-like runtime each time; share the filesystem object in the closure to persist files across sessions and prompts.
+
+```ts
+import { Bash, InMemoryFs } from 'just-bash';
+
+const fs = new InMemoryFs();
+
+const agent = await init({
+  sandbox: () => new Bash({ fs, cwd: '/workspace', python: true }),
+  model: 'anthropic/claude-sonnet-4-6',
+});
+const session = await agent.session();
+```
+
 ## Running Agents
 
 ### Trigger From the CLI
@@ -190,7 +310,7 @@ export default async function ({ init, payload, env }: FlueContext) {
 Build and run any agent locally, perfect for fast local testing or running in CI.
 
 ```bash
-flue run hello --target node --session-id test-1 \
+flue run hello --target node --id test-1 \
   --payload '{"text": "Hello world", "language": "French"}'
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flue/sdk",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "type": "module",
   "license": "Apache-2.0",
   "exports": {
@@ -39,10 +39,11 @@
     "@hono/node-server": "^1.14.0",
     "@mariozechner/pi-agent-core": "*",
     "@mariozechner/pi-ai": "*",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@valibot/to-json-schema": "^1.0.0",
-    "agentfs-sdk": "^0.6.4",
     "esbuild": "^0.25.0",
     "hono": "^4.7.0",
+    "jsonc-parser": "^3.3.1",
     "just-bash": "^2.14.2",
     "package-up": "^5.0.0",
     "valibot": "^1.0.0"

package/dist/agent-BYG0nVbQ.mjs

@@ -1,432 +0,0 @@
-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,25 +0,0 @@
-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-BZPltYah.mjs";
-import { Type } from "@mariozechner/pi-ai";
-
-//#region src/client.d.ts
-interface FlueContextConfig {
-  sessionId: string;
-  payload: any;
-  env: Record<string, any>;
-  agentConfig: AgentConfig;
-  createDefaultEnv: () => Promise<SessionEnv>;
-  createLocalEnv: () => Promise<SessionEnv>;
-  defaultStore: SessionStore;
-  /**
-   * Platform-specific sandbox resolver hook. Called before default resolution.
-   * Returns SessionEnv to use, or null to fall through to default logic.
-   */
-  resolveSandbox?: (sandbox: unknown) => Promise<SessionEnv> | null;
-}
-/** Extends FlueContext with server-only methods. Agent handlers only see FlueContext. */
-interface FlueContextInternal extends FlueContext {
-  setEventCallback(callback: FlueEventCallback | undefined): void;
-}
-declare function createFlueContext(config: FlueContextConfig): FlueContextInternal;
-//#endregion
-export { type BashLike, type Command, type CommandSupport, type FileStat, type FlueContext, FlueContextConfig, FlueContextInternal, type FlueEvent, type FlueEventCallback, type FlueSession, type PromptOptions, type PromptResponse, type SandboxFactory, type SessionData, type SessionEnv, type SessionInit, type SessionStore, type ShellOptions, type ShellResult, type SkillOptions, type TaskOptions, type ToolDef, Type, createFlueContext };