min-agent 0.1.0 → 0.1.2

package/dist/sessions.js

@@ -0,0 +1,74 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from "fs";
+import path from "path";
+import { getConfigDir } from "./config.js";
+function getSessionsDir() {
+    return path.join(getConfigDir(), "sessions");
+}
+function sessionPath(id) {
+    return path.join(getSessionsDir(), `${id}.json`);
+}
+function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+function deriveTitle(messages) {
+    const first = messages.find((m) => m.role === "user");
+    if (!first)
+        return "Untitled";
+    const content = typeof first.content === "string" ? first.content : "";
+    return content.slice(0, 60) || "Untitled";
+}
+export function saveSession(messages, existingId) {
+    const dir = getSessionsDir();
+    mkdirSync(dir, { recursive: true });
+    const id = existingId ?? generateId();
+    const now = new Date().toISOString();
+    const data = {
+        meta: {
+            id,
+            title: deriveTitle(messages),
+            created: existingId ? loadSession(id)?.meta.created ?? now : now,
+            updated: now,
+            messageCount: messages.length,
+        },
+        messages,
+    };
+    writeFileSync(sessionPath(id), JSON.stringify(data, null, 2), "utf-8");
+    return id;
+}
+export function loadSession(id) {
+    const file = sessionPath(id);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function listSessions() {
+    const dir = getSessionsDir();
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => {
+        try {
+            const data = JSON.parse(readFileSync(path.join(dir, f), "utf-8"));
+            return data.meta;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((m) => m !== null)
+        .sort((a, b) => b.updated.localeCompare(a.updated));
+}
+export function deleteSession(id) {
+    const file = sessionPath(id);
+    if (!existsSync(file))
+        return false;
+    const { unlinkSync } = require("fs");
+    unlinkSync(file);
+    return true;
+}

package/dist/skills.js

@@ -0,0 +1,127 @@
+import { tool, jsonSchema } from "ai";
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import os from "os";
+import path from "path";
+import { globSync } from "glob";
+/**
+ * Skill scan order: later entries win on duplicate `name` in frontmatter.
+ * Global user skills first, then project-local dirs so repo skills override ~/.agents.
+ */
+const SKILL_DIRS = [
+    path.join(os.homedir(), ".agents", "skills"),
+    path.join(process.cwd(), ".min-agent", "skills"),
+    path.join(process.cwd(), ".agent-demo", "skills"),
+    path.join(process.cwd(), ".opencode", "skills"),
+    path.join(process.cwd(), ".claude", "skills"),
+];
+let loadedSkills = {};
+export function discoverSkills() {
+    loadedSkills = {};
+    for (const dir of SKILL_DIRS) {
+        if (!existsSync(dir))
+            continue;
+        const matches = globSync("**/SKILL.md", { cwd: dir, absolute: true });
+        for (const match of matches) {
+            const skill = parseSkillFile(match);
+            if (skill) {
+                loadedSkills[skill.name] = skill;
+            }
+        }
+    }
+    const count = Object.keys(loadedSkills).length;
+    if (count > 0) {
+        console.log(`\x1b[90m  Skills loaded: ${count} (${Object.keys(loadedSkills).join(", ")})\x1b[0m`);
+    }
+}
+function parseSkillFile(filePath) {
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        // Parse frontmatter (---\n...\n---)
+        const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!fmMatch)
+            return null;
+        const frontmatter = fmMatch[1];
+        const content = fmMatch[2];
+        const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+        const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+        if (!nameMatch || !descMatch)
+            return null;
+        return {
+            name: nameMatch[1].trim().replace(/^["']|["']$/g, ""),
+            description: descMatch[1].trim().replace(/^["']|["']$/g, ""),
+            location: filePath,
+            content: content.trim(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function getSkills() {
+    return Object.values(loadedSkills);
+}
+export function getSkill(name) {
+    return loadedSkills[name];
+}
+export function getSkillsTool() {
+    return tool({
+        description: buildSkillDescription(),
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                name: { type: "string", description: "The name of the skill to load" },
+            },
+            required: ["name"],
+        }),
+        execute: async ({ name }) => {
+            const skill = loadedSkills[name];
+            if (!skill) {
+                const available = Object.keys(loadedSkills);
+                return `Skill "${name}" not found. Available skills: ${available.length ? available.join(", ") : "none"}`;
+            }
+            const dir = path.dirname(skill.location);
+            let files = [];
+            try {
+                files = readdirSync(dir)
+                    .filter((f) => f !== "SKILL.md" && !statSync(path.join(dir, f)).isDirectory())
+                    .slice(0, 10);
+            }
+            catch { }
+            return [
+                `<skill_content name="${skill.name}">`,
+                `# Skill: ${skill.name}`,
+                "",
+                skill.content,
+                "",
+                `Base directory: ${dir}`,
+                "",
+                files.length ? `<skill_files>\n${files.map((f) => `  ${f}`).join("\n")}\n</skill_files>` : "",
+                `</skill_content>`,
+            ]
+                .filter(Boolean)
+                .join("\n");
+        },
+    });
+}
+export function getSkillsSystemPrompt() {
+    const skills = Object.values(loadedSkills);
+    if (skills.length === 0)
+        return "";
+    return [
+        "## Available Skills",
+        "Use the `skill` tool to load specialized instructions when a task matches a skill's description.",
+        "",
+        ...skills.map((s) => `- **${s.name}**: ${s.description}`),
+    ].join("\n");
+}
+function buildSkillDescription() {
+    const skills = Object.values(loadedSkills);
+    if (skills.length === 0)
+        return "Load a specialized skill. No skills are currently available.";
+    return [
+        "Load a specialized skill that provides domain-specific instructions and workflows.",
+        "",
+        "Available skills:",
+        ...skills.map((s) => `- ${s.name}: ${s.description}`),
+    ].join("\n");
+}

package/dist/tool-output.js

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+import { randomBytes } from "crypto";
+import { getConfigDir } from "./config.js";
+/** Default limits (aligned with common agent tooling practice). */
+export const TOOL_OUTPUT_MAX_LINES = 2000;
+export const TOOL_OUTPUT_MAX_BYTES = 50 * 1024;
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+function toolOutputDir() {
+    return path.join(getConfigDir(), "tool-output");
+}
+function cleanupOldToolOutputs(dir) {
+    if (!existsSync(dir))
+        return;
+    const now = Date.now();
+    try {
+        for (const f of readdirSync(dir)) {
+            if (!f.startsWith("tool-") || !f.endsWith(".txt"))
+                continue;
+            const p = path.join(dir, f);
+            try {
+                if (now - statSync(p).mtimeMs > RETENTION_MS)
+                    unlinkSync(p);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+/** Write full text to ~/.min-agent/tool-output/ and return absolute path. */
+export function writeFullToolOutput(fullText) {
+    const dir = toolOutputDir();
+    mkdirSync(dir, { recursive: true });
+    cleanupOldToolOutputs(dir);
+    const name = `tool-${Date.now()}-${randomBytes(4).toString("hex")}.txt`;
+    const filePath = path.join(dir, name);
+    writeFileSync(filePath, fullText, "utf-8");
+    return filePath;
+}
+const hint = (filePath) => `The tool output was truncated. Full output saved to: ${filePath}\nUse the read tool with startLine/endLine, or grep, to inspect further.`;
+/** Keep end of text within line/byte limits (good for shell logs). */
+export function tailPreview(text, maxLines, maxBytes) {
+    const lines = text.split("\n");
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= maxLines && totalBytes <= maxBytes) {
+        return { text, cut: false };
+    }
+    const out = [];
+    let bytes = 0;
+    for (let i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
+        const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0);
+        if (bytes + size > maxBytes) {
+            if (out.length === 0) {
+                const buf = Buffer.from(lines[i], "utf-8");
+                let start = buf.length - maxBytes;
+                if (start < 0)
+                    start = 0;
+                while (start < buf.length && (buf[start] & 0xc0) === 0x80)
+                    start++;
+                out.unshift(buf.subarray(start).toString("utf-8"));
+            }
+            break;
+        }
+        out.unshift(lines[i]);
+        bytes += size;
+    }
+    return { text: out.join("\n"), cut: true };
+}
+/** Keep start of text within line/byte limits (good for files / HTTP bodies). */
+export function headPreview(text, maxLines, maxBytes) {
+    const lines = text.split("\n");
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= maxLines && totalBytes <= maxBytes) {
+        return { text, cut: false };
+    }
+    const out = [];
+    let bytes = 0;
+    for (let i = 0; i < lines.length && out.length < maxLines; i++) {
+        const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0);
+        if (bytes + size > maxBytes) {
+            if (out.length === 0) {
+                const buf = Buffer.from(lines[i], "utf-8");
+                let end = Math.min(maxBytes, buf.length);
+                while (end > 0 && (buf[end - 1] & 0xc0) === 0x80)
+                    end--;
+                out.push(buf.subarray(0, end).toString("utf-8"));
+            }
+            break;
+        }
+        out.push(lines[i]);
+        bytes += size;
+    }
+    return { text: out.join("\n"), cut: true };
+}
+/**
+ * If text exceeds limits, write full text to disk and return a preview + path hint.
+ * Otherwise returns the original string.
+ */
+export function truncateToolOutput(text, options = {}) {
+    const maxLines = options.maxLines ?? TOOL_OUTPUT_MAX_LINES;
+    const maxBytes = options.maxBytes ?? TOOL_OUTPUT_MAX_BYTES;
+    const direction = options.direction ?? "head";
+    const lines = text.split("\n");
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= maxLines && totalBytes <= maxBytes) {
+        return { content: text, truncated: false };
+    }
+    const filePath = writeFullToolOutput(text);
+    const preview = direction === "tail" ? tailPreview(text, maxLines, maxBytes).text : headPreview(text, maxLines, maxBytes).text;
+    const header = "...output truncated...\n\n";
+    const content = direction === "tail"
+        ? `${header}${hint(filePath)}\n\n${preview}`
+        : `${preview}\n\n${header}${hint(filePath)}`;
+    return { content, truncated: true, outputPath: filePath };
+}

package/dist/tools/bash.js

@@ -0,0 +1,93 @@
+import { spawn } from "child_process";
+import { tool, jsonSchema } from "ai";
+import { confirm, isDangerousCommand, isAutoApprove } from "../confirm.js";
+import { truncateToolOutput } from "../tool-output.js";
+/** Hard cap for in-memory collection before killing the process (avoid OOM on huge stdout). */
+const COLLECT_HARD_CAP_BYTES = 16 * 1024 * 1024;
+function runCommand(command, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            shell: true,
+            cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const outChunks = [];
+        const errChunks = [];
+        let total = 0;
+        let killedCap = false;
+        let killedTimeout = false;
+        const timer = setTimeout(() => {
+            killedTimeout = true;
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 2000).unref();
+        }, timeoutMs);
+        const push = (buf, arr) => {
+            total += buf.length;
+            if (total > COLLECT_HARD_CAP_BYTES && !killedCap) {
+                killedCap = true;
+                child.kill("SIGKILL");
+                return;
+            }
+            arr.push(buf);
+        };
+        child.stdout?.on("data", (b) => push(b, outChunks));
+        child.stderr?.on("data", (b) => push(b, errChunks));
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const stdout = Buffer.concat(outChunks).toString("utf-8");
+            const stderr = Buffer.concat(errChunks).toString("utf-8");
+            let combined = stdout.replace(/\s+$/, "");
+            if (stderr)
+                combined += (combined ? "\n" : "") + stderr.replace(/\s+$/, "");
+            if (killedCap) {
+                combined +=
+                    `\n\n[bash] Output collection stopped: exceeded ${COLLECT_HARD_CAP_BYTES} bytes in-memory cap (process was killed). Prefer redirecting to a file (e.g. > out.txt) then read with startLine/endLine.`;
+            }
+            else if (killedTimeout) {
+                combined += `\n\n[bash] Command exceeded timeout ${timeoutMs} ms (process terminated).`;
+            }
+            resolve({
+                code,
+                output: combined || "(no output)",
+                killedByTimeout: killedTimeout,
+                killedByCap: killedCap,
+            });
+        });
+    });
+}
+export const bashTool = tool({
+    description: "Run a shell command. Use this for system operations, running builds, tests, git commands, etc. The command runs in the current working directory. Very long stdout/stderr is truncated: full output may be saved under ~/.min-agent/tool-output/ with a preview returned.",
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            command: { type: "string", description: "The shell command to execute" },
+            timeout: { type: "number", description: "Timeout in milliseconds (default: 30000)" },
+        },
+        required: ["command"],
+    }),
+    execute: async ({ command, timeout }) => {
+        if (!isAutoApprove() && isDangerousCommand(command)) {
+            const approved = await confirm(`Execute dangerous command: ${command}`);
+            if (!approved)
+                return "Command rejected by user.";
+        }
+        const timeoutMs = timeout ?? 30000;
+        try {
+            const { code, output, killedByTimeout, killedByCap } = await runCommand(command, process.cwd(), timeoutMs);
+            let body = output;
+            if (code !== 0 && code !== null && !killedByTimeout && !killedByCap) {
+                body = `Exit code ${code}\n${body}`;
+            }
+            const { content } = truncateToolOutput(body, { direction: "tail" });
+            return content.trim() || "(no output)";
+        }
+        catch (err) {
+            return `Error: ${err.message ?? String(err)}`;
+        }
+    },
+});

package/dist/tools/edit.js

@@ -0,0 +1,51 @@
+import { tool, jsonSchema } from "ai";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import path from "path";
+import { confirm, isAutoApprove } from "../confirm.js";
+export const editTool = tool({
+    description: "Edit a file by replacing a specific text block with new content. The oldText must match exactly (including whitespace and indentation). Use this for precise edits instead of rewriting entire files.",
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            filePath: { type: "string", description: "Path to the file to edit (relative to cwd or absolute)" },
+            oldText: { type: "string", description: "The exact text to find and replace (must match exactly)" },
+            newText: { type: "string", description: "The new text to replace it with" },
+        },
+        required: ["filePath", "oldText", "newText"],
+    }),
+    execute: async ({ filePath, oldText, newText }) => {
+        const resolved = path.resolve(process.cwd(), filePath);
+        if (!existsSync(resolved)) {
+            return `Error: File not found: ${filePath}`;
+        }
+        const content = readFileSync(resolved, "utf-8");
+        const occurrences = content.split(oldText).length - 1;
+        if (occurrences === 0) {
+            // Try to help: show nearby content
+            const lines = content.split("\n");
+            const searchLines = oldText.split("\n");
+            const firstLine = searchLines[0].trim();
+            const nearbyIdx = lines.findIndex((l) => l.includes(firstLine));
+            if (nearbyIdx >= 0) {
+                const context = lines.slice(Math.max(0, nearbyIdx - 1), nearbyIdx + 3).join("\n");
+                return `Error: oldText not found exactly. Found similar content near line ${nearbyIdx + 1}:\n${context}\n\nMake sure whitespace and indentation match exactly.`;
+            }
+            return `Error: oldText not found in ${filePath}. Make sure the text matches exactly including whitespace.`;
+        }
+        if (occurrences > 1) {
+            return `Error: oldText found ${occurrences} times in ${filePath}. Please provide more context to make the match unique.`;
+        }
+        // Confirm edit
+        if (!isAutoApprove()) {
+            const preview = oldText.length > 80 ? oldText.slice(0, 80) + "..." : oldText;
+            const approved = await confirm(`Edit ${filePath}: replace "${preview}"`);
+            if (!approved)
+                return "Edit rejected by user.";
+        }
+        const updated = content.replace(oldText, newText);
+        writeFileSync(resolved, updated, "utf-8");
+        const oldLines = oldText.split("\n").length;
+        const newLines = newText.split("\n").length;
+        return `Edited ${filePath}: replaced ${oldLines} line(s) with ${newLines} line(s)`;
+    },
+});

package/dist/tools/glob.js

@@ -0,0 +1,36 @@
+import { tool, jsonSchema } from "ai";
+import { globSync } from "glob";
+import { truncateToolOutput } from "../tool-output.js";
+export const globTool = tool({
+    description: "Find files matching a glob pattern. Returns a list of file paths. Use this to discover project structure and find files.",
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Glob pattern to match (e.g. 'src/**/*.ts', '*.json')" },
+            cwd: { type: "string", description: "Directory to search in (defaults to working directory)" },
+        },
+        required: ["pattern"],
+    }),
+    execute: async ({ pattern, cwd }) => {
+        try {
+            const matches = globSync(pattern, {
+                cwd: cwd ?? process.cwd(),
+                ignore: ["**/node_modules/**", "**/.git/**"],
+                nodir: true,
+            });
+            if (matches.length === 0)
+                return "No files found matching pattern";
+            let text;
+            if (matches.length > 100) {
+                text = matches.slice(0, 100).join("\n") + `\n\n... (${matches.length - 100} more files)`;
+            }
+            else {
+                text = matches.join("\n");
+            }
+            return truncateToolOutput(text, { direction: "head" }).content;
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+});

package/dist/tools/grep.js

@@ -0,0 +1,35 @@
+import { tool, jsonSchema } from "ai";
+import { execSync } from "child_process";
+import { truncateToolOutput } from "../tool-output.js";
+export const grepTool = tool({
+    description: "Search for a pattern in files using grep. Returns matching lines with file paths and line numbers. Use this to find code references, usages, and definitions.",
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "The regex pattern to search for" },
+            path: { type: "string", description: "File or directory path to search in (defaults to current directory)" },
+            include: { type: "string", description: "File pattern to include (e.g. '*.ts')" },
+        },
+        required: ["pattern"],
+    }),
+    execute: async ({ pattern, path: searchPath, include }) => {
+        const target = searchPath ?? ".";
+        const includeFlag = include ? `--include='${include}'` : "";
+        const cmd = `grep -rn ${includeFlag} --color=never -E '${pattern.replace(/'/g, "'\\''")}' '${target}' 2>/dev/null | head -50`;
+        try {
+            const output = execSync(cmd, {
+                encoding: "utf-8",
+                cwd: process.cwd(),
+                timeout: 10000,
+                maxBuffer: 512 * 1024,
+            });
+            const text = output.trim() || "No matches found";
+            return truncateToolOutput(text, { direction: "head" }).content;
+        }
+        catch (err) {
+            if (err.status === 1)
+                return "No matches found";
+            return `Error: ${err.message}`;
+        }
+    },
+});

package/dist/tools/index.js

@@ -0,0 +1,20 @@
+import { bashTool } from "./bash.js";
+import { readTool } from "./read.js";
+import { writeTool } from "./write.js";
+import { editTool } from "./edit.js";
+import { globTool } from "./glob.js";
+import { grepTool } from "./grep.js";
+import { webSearchTool } from "./web_search.js";
+import { webFetchTool } from "./web_fetch.js";
+export function createTools() {
+    return {
+        bash: bashTool,
+        read: readTool,
+        write: writeTool,
+        edit: editTool,
+        glob: globTool,
+        grep: grepTool,
+        web_search: webSearchTool,
+        web_fetch: webFetchTool,
+    };
+}

package/dist/tools/read.js

@@ -0,0 +1,36 @@
+import { tool, jsonSchema } from "ai";
+import { readFileSync, statSync } from "fs";
+import path from "path";
+import { truncateToolOutput } from "../tool-output.js";
+export const readTool = tool({
+    description: "Read the contents of a file. Returns the file content as text. Use this to understand code, check configurations, etc.",
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            filePath: { type: "string", description: "Path to the file to read (relative to cwd or absolute)" },
+            startLine: { type: "number", description: "Start line number (1-indexed)" },
+            endLine: { type: "number", description: "End line number (1-indexed, inclusive)" },
+        },
+        required: ["filePath"],
+    }),
+    execute: async ({ filePath, startLine, endLine }) => {
+        const resolved = path.resolve(process.cwd(), filePath);
+        try {
+            const stat = statSync(resolved);
+            if (stat.isDirectory())
+                return `Error: ${filePath} is a directory, not a file`;
+            const content = readFileSync(resolved, "utf-8");
+            if (startLine || endLine) {
+                const lines = content.split("\n");
+                const start = (startLine ?? 1) - 1;
+                const end = endLine ?? lines.length;
+                const slice = lines.slice(start, end).join("\n");
+                return truncateToolOutput(slice, { direction: "head" }).content;
+            }
+            return truncateToolOutput(content, { direction: "head" }).content;
+        }
+        catch (err) {
+            return `Error reading file: ${err.message}`;
+        }
+    },
+});

package/dist/tools/web_fetch.js

@@ -0,0 +1,83 @@
+import { tool, jsonSchema } from "ai";
+import { truncateToolOutput } from "../tool-output.js";
+const FIRECRAWL_BASE = "https://fireclawl.xc.lonae.com";
+export const webFetchTool = tool({
+    description: "Fetch content from a URL. Use this to access web pages, APIs, or any HTTP resource. Returns the response body as text (or markdown for HTML pages). Supports JavaScript-rendered SPA pages via fallback.",
+    inputSchema: jsonSchema({
+        type: "object",
+        properties: {
+            url: { type: "string", description: "The URL to fetch" },
+            method: { type: "string", description: "HTTP method (default: GET)" },
+        },
+        required: ["url"],
+    }),
+    execute: async ({ url, method }) => {
+        // First try: direct fetch
+        const directResult = await directFetch(url, method);
+        // If we got meaningful content, return it
+        if (directResult && hasContent(directResult)) {
+            return directResult;
+        }
+        // Fallback: use Firecrawl for SPA/dynamic pages
+        const firecrawlResult = await firecrawlFetch(url);
+        if (firecrawlResult)
+            return firecrawlResult;
+        // Return whatever we got from direct fetch
+        return directResult || "Failed to fetch content from URL";
+    },
+});
+async function directFetch(url, method) {
+    try {
+        const response = await fetch(url, {
+            method: method ?? "GET",
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok)
+            return `HTTP ${response.status}`;
+        const text = await response.text();
+        return truncateToolOutput(text, { direction: "head" }).content;
+    }
+    catch (err) {
+        return null;
+    }
+}
+async function firecrawlFetch(url) {
+    try {
+        const response = await fetch(`${FIRECRAWL_BASE}/v1/scrape`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                url,
+                formats: ["markdown"],
+                onlyMainContent: true,
+                waitFor: 3000,
+                timeout: 30000,
+            }),
+            signal: AbortSignal.timeout(35000),
+        });
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        const markdown = data?.data?.markdown || data?.data?.content;
+        if (!markdown)
+            return null;
+        return truncateToolOutput(markdown, { direction: "head" }).content;
+    }
+    catch {
+        return null;
+    }
+}
+function hasContent(html) {
+    // Check if the response has meaningful content (not just an empty SPA shell)
+    if (html.length < 200)
+        return false;
+    // SPA shells typically have very little text content outside of script tags
+    const withoutScripts = html.replace(/<script[\s\S]*?<\/script>/gi, "");
+    const textContent = withoutScripts.replace(/<[^>]*>/g, "").trim();
+    // If after removing scripts and tags there's less than 100 chars, it's likely an empty shell
+    return textContent.length > 100;
+}