@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/dist/agent/ignore.js

@@ -0,0 +1,129 @@
+/**
+ * Ignore rules for directory walks and reads.
+ *
+ * Defaults cover the usual dependency/build folders. Users can add more with
+ * `.fastcodeignore` in the project root, using a gitignore-like syntax:
+ *
+ *   node_modules/     # trailing slash = directories only
+ *   *.log             # basename at any depth
+ *   /secrets.txt      # anchored to the project root
+ *   !important.log    # re-include (last matching rule wins)
+ */
+import { readFileSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+const DEFAULT_NAMES = new Set([
+    "node_modules",
+    ".git",
+    ".hg",
+    ".svn",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    ".output",
+    ".turbo",
+    ".parcel-cache",
+    ".cache",
+    "coverage",
+    ".nyc_output",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "target",
+    ".gradle",
+    ".idea",
+]);
+const BINARY_EXT = /\.(png|jpe?g|gif|webp|ico|bmp|tiff?|pdf|zip|gz|tgz|bz2|xz|7z|rar|exe|dll|so|dylib|bin|wasm|mp3|mp4|mov|avi|mkv|wav|flac|ttf|otf|woff2?|eot|class|jar|apk|ipa|sqlite|db|lock)$/i;
+export function isBinaryName(name) {
+    return BINARY_EXT.test(name);
+}
+export function createIgnore(root) {
+    const rules = loadRules(root);
+    return {
+        ignored(name, fullPath, isDir) {
+            if (DEFAULT_NAMES.has(name))
+                return true;
+            if (rules.length === 0)
+                return false;
+            const rel = relative(root, fullPath).split(sep).join("/");
+            let ignored = false;
+            for (const rule of rules) {
+                if (rule.dirOnly && !isDir)
+                    continue;
+                if (rule.regex.test(rel) || rule.regex.test(name))
+                    ignored = !rule.negate;
+            }
+            return ignored;
+        },
+        isBinary(name) {
+            return BINARY_EXT.test(name);
+        },
+    };
+}
+function loadRules(root) {
+    const file = join(root, ".fastcodeignore");
+    let text = "";
+    try {
+        const info = statSync(file);
+        if (!info.isFile())
+            return [];
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const rules = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const negate = line.startsWith("!");
+        const body = negate ? line.slice(1).trim() : line;
+        if (!body)
+            continue;
+        const dirOnly = body.endsWith("/");
+        const pattern = dirOnly ? body.slice(0, -1) : body;
+        const anchored = pattern.startsWith("/");
+        const glob = anchored ? pattern.slice(1) : pattern;
+        try {
+            rules.push({
+                regex: globToRegExp(glob, anchored),
+                negate,
+                dirOnly,
+            });
+        }
+        catch {
+            // A bad pattern must not disable the whole ignore file.
+        }
+    }
+    return rules;
+}
+function globToRegExp(glob, anchored) {
+    let source = "";
+    for (let i = 0; i < glob.length; i += 1) {
+        const char = glob[i];
+        if (char === "*") {
+            if (glob[i + 1] === "*") {
+                source += ".*";
+                i += 1;
+                if (glob[i + 1] === "/")
+                    i += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (char === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += escapeRegExp(char);
+        }
+    }
+    // Unanchored patterns match a basename at any depth.
+    return new RegExp("^" + (anchored ? "" : "(?:.*/)?") + source + "$");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/agent/limits.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Single source of truth for how much tool output reaches the model.
+ *
+ * Output is bounded while it is produced, not by slicing a finished string
+ * afterwards, so a runaway command or a huge directory listing cannot grow
+ * without limit. Override the cap with FASTCODE_TOOL_OUTPUT_LIMIT (characters).
+ */
+export declare const DEFAULT_TOOL_OUTPUT_LIMIT = 30000;
+export declare function toolOutputLimit(): number;
+/**
+ * Bounded text accumulator.
+ *
+ * mode "head" keeps the first N characters (listings, search hits);
+ * mode "tail" keeps the last N (command logs, where the error is last).
+ * trimEnd()/toString() mimic a plain string so callers stay simple.
+ */
+export declare function createOutputBuffer(limit?: number, mode?: string): {
+    readonly full: boolean;
+    push(chunk: any): void;
+    line(value: any): void;
+    value(): string;
+    trimEnd(): string;
+    toString(): string;
+};

package/dist/agent/limits.js

@@ -0,0 +1,71 @@
+/**
+ * Single source of truth for how much tool output reaches the model.
+ *
+ * Output is bounded while it is produced, not by slicing a finished string
+ * afterwards, so a runaway command or a huge directory listing cannot grow
+ * without limit. Override the cap with FASTCODE_TOOL_OUTPUT_LIMIT (characters).
+ */
+export const DEFAULT_TOOL_OUTPUT_LIMIT = 30000;
+export function toolOutputLimit() {
+    const raw = Number(process.env["FASTCODE_TOOL_OUTPUT_LIMIT"]);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_TOOL_OUTPUT_LIMIT;
+}
+/**
+ * Bounded text accumulator.
+ *
+ * mode "head" keeps the first N characters (listings, search hits);
+ * mode "tail" keeps the last N (command logs, where the error is last).
+ * trimEnd()/toString() mimic a plain string so callers stay simple.
+ */
+export function createOutputBuffer(limit = toolOutputLimit(), mode = "head") {
+    const NL = String.fromCharCode(10);
+    let text = "";
+    let dropped = 0;
+    const buffer = {
+        get full() {
+            return text.length >= limit;
+        },
+        push(chunk) {
+            const value = String(chunk);
+            if (mode === "tail") {
+                text += value;
+                if (text.length > limit) {
+                    const over = text.length - limit;
+                    dropped += over;
+                    text = text.slice(over);
+                }
+                return;
+            }
+            if (text.length >= limit) {
+                dropped += value.length;
+                return;
+            }
+            const room = limit - text.length;
+            if (value.length <= room) {
+                text += value;
+            }
+            else {
+                text += value.slice(0, room);
+                dropped += value.length - room;
+            }
+        },
+        line(value) {
+            if (text.length > 0)
+                buffer.push(NL);
+            buffer.push(value);
+        },
+        value() {
+            if (dropped <= 0)
+                return text;
+            const note = "[" + dropped + " more characters omitted]";
+            return mode === "tail" ? note + NL + text : text + NL + note;
+        },
+        trimEnd() {
+            return buffer.value().trimEnd();
+        },
+        toString() {
+            return buffer.value();
+        },
+    };
+    return buffer;
+}

package/dist/agent/process-tree.d.ts

@@ -0,0 +1,2 @@
+import { type ChildProcess } from "node:child_process";
+export declare function killProcessTree(child: ChildProcess | undefined, signal?: NodeJS.Signals): void;

package/dist/agent/process-tree.js

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+export function killProcessTree(child, signal = "SIGTERM") {
+    if (!child || typeof child.pid !== "number")
+        return;
+    if (process.platform === "win32") {
+        try {
+            const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+            killer.unref();
+        }
+        catch {
+            try {
+                child.kill();
+            }
+            catch {
+                // The process may already be gone.
+            }
+        }
+        return;
+    }
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // Same as above.
+        }
+    }
+}

package/dist/agent/protocol-mode.d.ts

@@ -0,0 +1,6 @@
+export type ToolProtocol = "legacy" | "native";
+export type ToolCapability = "native" | "pseudo";
+export declare function toolCapabilityKey(providerId: string, model: string): string;
+export declare function resolveToolProtocol(config: any, providerId: string, model: string, env?: NodeJS.ProcessEnv): ToolProtocol;
+export declare function withToolCapability(config: any, providerId: string, model: string, capability: ToolCapability): any;
+export declare function isNativeUnsupportedError(message: string): boolean;

package/dist/agent/protocol-mode.js

@@ -0,0 +1,51 @@
+import { getModelMeta } from "../lib/model-meta.js";
+const NATIVE_PROVIDERS = new Set([
+    "openai",
+    "openrouter",
+    "deepseek",
+    "groq",
+    "mistral",
+    "xai",
+    "moonshot",
+    "zhipu",
+    "qwen",
+    "ollama",
+]);
+export function toolCapabilityKey(providerId, model) {
+    return `${providerId}::${model}`;
+}
+export function resolveToolProtocol(config, providerId, model, env = process.env) {
+    const mode = String(env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase();
+    if (mode === "legacy")
+        return "legacy";
+    if (mode === "native")
+        return "native";
+    if (mode !== "auto")
+        return "legacy";
+    const cached = config?.capabilities?.toolCalling?.[toolCapabilityKey(providerId, model)];
+    if (cached === "pseudo")
+        return "legacy";
+    if (cached === "native")
+        return "native";
+    if (!NATIVE_PROVIDERS.has(providerId))
+        return "legacy";
+    return getModelMeta(providerId, model).supportsTools ? "native" : "legacy";
+}
+export function withToolCapability(config, providerId, model, capability) {
+    const key = toolCapabilityKey(providerId, model);
+    return {
+        ...config,
+        capabilities: {
+            ...(config?.capabilities ?? {}),
+            toolCalling: {
+                ...(config?.capabilities?.toolCalling ?? {}),
+                [key]: capability,
+            },
+        },
+    };
+}
+export function isNativeUnsupportedError(message) {
+    return /\b400\b/.test(message)
+        && /tool|function/i.test(message)
+        && /not supported|unsupported|unrecognized|unknown|invalid|does not support/i.test(message);
+}

package/dist/agent/protocol.d.ts

@@ -0,0 +1,4 @@
+export declare function parseToolCalls(text: any): any[];
+export declare function stripToolCalls(text: any): any;
+export declare function formatToolResults(results: any): string;
+export declare const AGENT_SYSTEM_PROMPT: string;

package/dist/agent/protocol.js

@@ -0,0 +1,129 @@
+const TOOL_RE = /<fastcode_tool>([\s\S]*?)<\/fastcode_tool>/g;
+// Some models (notably DeepSeek) emit their native "DSML" tool-call markup
+// instead of <fastcode_tool>. The markers look like `<｜DSML｜invoke ...>`
+// (U+FF5C fullwidth bar, sometimes doubled or spaced). We canonicalize those
+// markers back to plain angle-bracket tags and then parse the
+// calls -> invoke -> parameter structure as a second dialect.
+const DSML_OPEN_RE = /<\s*(?:[|｜]\s*)+DSML\s*(?:[|｜]\s*)+/gi;
+const DSML_CLOSE_RE = /<\/\s*(?:[|｜]\s*)+DSML\s*(?:[|｜]\s*)+/gi;
+const DSML_BLOCK_RE = /<([a-z_]*calls?)>([\s\S]*?)<\/\1>/gi;
+const DSML_INVOKE_RE = /<invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/invoke>/gi;
+const DSML_PARAM_RE = /<parameter\s+name="([^"]+)"([^>]*)>([\s\S]*?)<\/parameter>/gi;
+/** Turn the DSML glyph markers into ordinary `<tag>` / `</tag>` tags. */
+function canonicalizeDsml(text) {
+    return text.replace(DSML_CLOSE_RE, "</").replace(DSML_OPEN_RE, "<");
+}
+function coerceDsmlValue(attrs, raw) {
+    const value = raw.replace(/^\n/, "").replace(/\n$/, "");
+    if (/\bstring\s*=\s*"true"/i.test(attrs))
+        return value;
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return "";
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        if (trimmed === "true")
+            return true;
+        if (trimmed === "false")
+            return false;
+        const n = Number(trimmed);
+        return Number.isNaN(n) ? value : n;
+    }
+}
+function parseDsmlCalls(text) {
+    const canonical = canonicalizeDsml(text);
+    const bodies = [];
+    for (const block of canonical.matchAll(DSML_BLOCK_RE))
+        bodies.push(block[2] ?? "");
+    if (bodies.length === 0)
+        bodies.push(canonical);
+    const calls = [];
+    for (const body of bodies) {
+        for (const invoke of body.matchAll(DSML_INVOKE_RE)) {
+            const call = { tool: invoke[1] };
+            for (const param of (invoke[2] ?? "").matchAll(DSML_PARAM_RE))
+                call[param[1]] = coerceDsmlValue(param[2] ?? "", param[3] ?? "");
+            calls.push(call);
+        }
+    }
+    return calls;
+}
+export function parseToolCalls(text) {
+    const calls = [];
+    for (const match of text.matchAll(TOOL_RE)) {
+        const raw = match[1]?.trim();
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.tool === "string")
+                calls.push(parsed);
+        }
+        catch {
+            // Ignore malformed tool blocks; the model can correct itself next turn.
+        }
+    }
+    calls.push(...parseDsmlCalls(text));
+    return calls;
+}
+export function stripToolCalls(text) {
+    return canonicalizeDsml(text).replace(TOOL_RE, "").replace(DSML_BLOCK_RE, "").trim();
+}
+export function formatToolResults(results) {
+    const blocks = results.map((r, index) => {
+        const status = r.ok ? "ok" : "error";
+        return [
+            `Tool result ${index + 1} (${status})`,
+            `call: ${JSON.stringify(r.call)}`,
+            "output:",
+            fence(r.output),
+        ].join("\n");
+    });
+    return [
+        "FastCode executed the requested local tools. Use these results to continue.",
+        ...blocks,
+    ].join("\n\n");
+}
+export const AGENT_SYSTEM_PROMPT = `
+You are FastCode Agent, a local coding agent running inside the user's terminal.
+Tools run inside a filesystem sandbox rooted at the current working directory.
+File tools cannot access paths outside that root. Shell commands run with FASTCODE_SANDBOX=1 and FASTCODE_SANDBOX_ROOT set.
+
+You can inspect and change the user's machine by emitting exactly one or more tool calls in this format:
+<fastcode_tool>{"tool":"shell","command":"npm test"}</fastcode_tool>
+
+Available tools:
+- shell: {"tool":"shell","command":"command to run"}
+- shell with timeout: {"tool":"shell","command":"npm test","timeoutMs":120000}
+- shell poll (long commands return a session id): {"tool":"shell","session_id":"sh_..."}
+  Polling returns only new output; use waitMs to wait briefly for more.
+- pwd: {"tool":"pwd"}
+- read_file: {"tool":"read_file","path":"path/to/file"}
+- read_many: {"tool":"read_many","paths":["file1","file2"]}
+- write_file: {"tool":"write_file","path":"path/to/file","content":"full file contents"}
+- append_file: {"tool":"append_file","path":"path/to/file","content":"text to append"}
+- apply_patch: {"tool":"apply_patch","patch":"*** Begin Patch\\n*** Update File: path\\n@@\\n-old\\n+new\\n*** End Patch\\n"}
+- list_files: {"tool":"list_files","path":"optional/path","maxDepth":2,"detail":false}
+- read_file is capped (default 200KB); grep skips files over 1MB. .fastcodeignore is honored.
+- grep: {"tool":"grep","pattern":"text or regex","path":"optional/path"}
+- replace_in_file: {"tool":"replace_in_file","path":"path/to/file","find":"exact text","replace":"replacement"}
+- stat_path: {"tool":"stat_path","path":"path/to/file"}
+- make_dir: {"tool":"make_dir","path":"path/to/dir"}
+- copy_file: {"tool":"copy_file","from":"src","to":"dest"}
+- move_path: {"tool":"move_path","from":"src","to":"dest"}
+- delete_file: {"tool":"delete_file","path":"path/to/file"}
+
+Rules:
+- Prefer inspecting files before editing.
+- Use shell for tests, builds, package scripts, git inspection, and OS commands.
+- Use apply_patch or replace_in_file for focused edits.
+- Use write_file only when replacing the whole file is appropriate.
+- Run verification commands after code changes.
+- After tool results come back, continue working until the user's request is done.
+- When done, answer normally without tool calls.
+`.trim();
+function fence(text) {
+    return `\`\`\`\n${text}\n\`\`\``;
+}

package/dist/agent/registry.d.ts

@@ -0,0 +1,17 @@
+import type { ApprovalDecision } from "./approval.js";
+import type { Tool, ToolCall, ToolCtx, ToolResult } from "./tools/types.js";
+export declare function assertToolContract(tools?: Tool[]): void;
+export declare function toolCatalogHash(tools?: Tool[]): string;
+export declare class ToolRegistry {
+    private readonly tools;
+    constructor(tools?: Tool[]);
+    get(name: string): Tool | undefined;
+    list(): Tool[];
+    approve(call: ToolCall, ctx: ToolCtx): ApprovalDecision;
+    execute(call: ToolCall, ctx: ToolCtx): Promise<ToolResult>;
+}
+export declare const registry: ToolRegistry;
+export declare function runAgentTool(call: ToolCall, cwd?: string, options?: {
+    signal?: AbortSignal;
+    turn?: number;
+}): Promise<ToolResult>;

package/dist/agent/registry.js

@@ -0,0 +1,90 @@
+import { createHash } from "node:crypto";
+import { isTrusted } from "../config/trust.js";
+import { evaluateShellCommand } from "./guards.js";
+import { TOOLS } from "./tools/index.js";
+const STATE_SCOPES = new Set(["call", "turn", "session"]);
+const REVALIDATE_KEYS = new Set(["trust", "sandboxRoots", "schema", "modelCaps"]);
+export function assertToolContract(tools = TOOLS) {
+    const names = new Set();
+    for (const tool of tools) {
+        if (!tool.name || typeof tool.name !== "string")
+            throw new Error("tool contract: every tool needs a name");
+        if (names.has(tool.name))
+            throw new Error(`tool contract: duplicate tool name ${tool.name}`);
+        names.add(tool.name);
+        if (!STATE_SCOPES.has(tool.stateScope))
+            throw new Error(`tool contract: ${tool.name} has an invalid stateScope`);
+        for (const key of tool.revalidate ?? []) {
+            if (!REVALIDATE_KEYS.has(key))
+                throw new Error(`tool contract: ${tool.name} has an invalid revalidate key ${String(key)}`);
+        }
+        if (tool.requiresTrust && !(tool.revalidate ?? []).includes("trust")) {
+            throw new Error(`tool contract: ${tool.name} requiresTrust but does not revalidate "trust"`);
+        }
+    }
+}
+export function toolCatalogHash(tools = TOOLS) {
+    const catalog = tools
+        .map((tool) => ({
+        name: tool.name,
+        trust: Boolean(tool.requiresTrust),
+        scope: tool.stateScope,
+        revalidate: [...(tool.revalidate ?? [])].sort(),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return createHash("sha1").update(JSON.stringify(catalog)).digest("hex").slice(0, 8);
+}
+export class ToolRegistry {
+    tools = new Map();
+    constructor(tools = TOOLS) {
+        assertToolContract(tools);
+        for (const tool of tools)
+            this.tools.set(tool.name, tool);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    list() {
+        return Array.from(this.tools.values());
+    }
+    approve(call, ctx) {
+        const tool = this.get(call.tool);
+        if (!tool)
+            return { kind: "deny", reason: `unknown tool: ${String(call.tool)}` };
+        if (tool.name === "shell") {
+            const verdict = evaluateShellCommand(call.command);
+            if (!verdict.allow)
+                return { kind: "deny", reason: verdict.output };
+        }
+        if ((tool.revalidate ?? []).includes("trust") && !isTrusted(ctx.cwd)) {
+            return {
+                kind: "deny",
+                reason: `project is not trusted: ${ctx.cwd}. Run \`fastcode trust ${ctx.cwd}\` or accept the trust prompt.`,
+            };
+        }
+        return { kind: "allow", scope: "once" };
+    }
+    async execute(call, ctx) {
+        const tool = this.get(call.tool);
+        if (!tool)
+            return { ok: false, output: `unknown tool: ${String(call.tool)}` };
+        const prepared = tool.prepare(call, ctx);
+        if (prepared.ok === false)
+            return { ok: false, output: prepared.output };
+        const decision = this.approve(call, ctx);
+        if (decision.kind === "deny")
+            return { ok: false, output: decision.reason ?? "denied by approval policy" };
+        if (decision.kind === "pending")
+            return { ok: false, output: "approval required, but no approval resolver is registered (fail closed)" };
+        try {
+            return await tool.execute(call, ctx);
+        }
+        catch (err) {
+            return { ok: false, output: err?.message ?? String(err) };
+        }
+    }
+}
+export const registry = new ToolRegistry();
+export async function runAgentTool(call, cwd = process.cwd(), options = {}) {
+    return registry.execute(call, { cwd, signal: options.signal, turn: options.turn });
+}

package/dist/agent/runner.d.ts

@@ -0,0 +1,106 @@
+import type { ChatChunk, ChatMessage, NativeToolCall, Provider, ReasoningEffort, ToolSchema } from "../types.js";
+import type { ActiveFile } from "../session/log.js";
+import type { SideEffects } from "./tools/types.js";
+import { type CompactionConfig } from "./compaction.js";
+import { type ToolProtocol } from "./protocol-mode.js";
+export interface ToolCall {
+    tool: string;
+    [key: string]: any;
+}
+export interface LoopDetectionOptions {
+    readOnlyThreshold?: number;
+    sideEffectThreshold?: number;
+    window?: number;
+    exemptReadOnly?: boolean;
+}
+export interface RunOptions {
+    provider: Provider;
+    apiKey?: string;
+    model: string;
+    messages?: ChatMessage[];
+    prompt: string;
+    system?: string;
+    maxTurns?: number;
+    allowTools?: boolean;
+    tokenBudget?: number;
+    costBudgetUsd?: number;
+    signal?: AbortSignal;
+    cwd?: string;
+    idleTimeoutMs?: number;
+    contextBudgetChars?: number;
+    compaction?: CompactionConfig;
+    contextWindow?: number;
+    serverOpaqueState?: string;
+    loopDetection?: LoopDetectionOptions;
+    reasoningEffort?: ReasoningEffort;
+    protocol?: ToolProtocol;
+    tools?: ToolSchema[];
+    onProtocolFallback?: (message: string) => void;
+    onNativeOk?: () => void;
+    takeSteering?: () => string[];
+    onDelta?: (delta: string, text: string) => void;
+}
+export type AgentStopReason = "complete" | "max_turns" | "token_budget" | "cost_budget" | "loop_detected" | "aborted" | "incomplete" | "stream_error";
+export type AgentErrorKind = "token_budget" | "cost_budget" | "loop_detected" | "aborted" | "stream_error";
+export type AgentEvent = {
+    type: "compaction";
+    beforeChars: number;
+    afterChars: number;
+    beforeTokens: number;
+    afterTokens: number;
+    droppedMessages: number;
+    keptMessages: number;
+    reason: "threshold" | "heap";
+    source: "local" | "server";
+    summaryFile?: string;
+} | {
+    type: "assistant_raw";
+    text: string;
+    toolCalls?: NativeToolCall[];
+} | {
+    type: "assistant_text";
+    text: string;
+} | {
+    type: "tool_call";
+    id: string;
+    call: ToolCall;
+    native?: boolean;
+} | {
+    type: "tool_result";
+    id: string;
+    call: ToolCall;
+    ok: boolean;
+    output: string;
+    sideEffects?: SideEffects;
+} | {
+    type: "usage";
+    usage: NonNullable<ChatChunk["usage"]>;
+} | {
+    type: "loop_detected";
+    fingerprint: string;
+    occurrences: number;
+    warned: boolean;
+} | {
+    type: "notice";
+    text: string;
+} | {
+    type: "error";
+    kind: AgentErrorKind;
+    message: string;
+    text?: string;
+    used?: number;
+} | {
+    type: "checkpoint";
+    turn: number;
+    cwd: string;
+    providerId: string;
+    model: string;
+    activeFiles: ActiveFile[];
+} | {
+    type: "done";
+    history: ChatMessage[];
+    finalText: string;
+    stopReason: AgentStopReason;
+};
+export declare const LOOP_WARNING: string;
+export declare function runAgent(options: RunOptions): AsyncGenerator<AgentEvent, void, void>;