grok-dev 1.0.0-rc1

package/dist/agent/agent.js

@@ -0,0 +1,701 @@
+import { stepCountIs, streamText } from "ai";
+import { createProvider, generateTitle as genTitle } from "../grok/client";
+import { createTools } from "../grok/tools";
+import { appendMessages, appendSystemMessage, buildChatEntries, getSessionTotalTokens, loadTranscript, recordUsageEvent, SessionStore, } from "../storage/index";
+import { BashTool } from "../tools/bash";
+import { loadCustomInstructions } from "../utils/instructions";
+import { discoverSkills, formatSkillsForPrompt } from "../utils/skills";
+import { DelegationManager } from "./delegations";
+const MAX_TOOL_ROUNDS = 400;
+const ENVIRONMENT = `ENVIRONMENT:
+You are running inside a terminal (CLI). Your text output is rendered in a plain terminal — not a browser, not a rich text editor.
+- Use plain text only. No markdown tables, no HTML, no images, no colored text.
+- Use simple markers like dashes (-) or asterisks (*) for lists.
+- Use indentation and blank lines for structure.
+- Keep lines under 100 characters when possible.
+- Use backticks for inline code and triple backticks for code blocks — these are rendered.
+- Never use unicode box-drawing, fancy borders, or ASCII art in your responses.`;
+const MODE_PROMPTS = {
+    agent: `You are Grok CLI in Agent mode — a powerful AI coding agent. You execute tasks directly using tools.
+
+${ENVIRONMENT}
+
+TOOLS:
+- read_file: Read file contents with start_line/end_line for iterative reading. Use for examining code.
+- write_file: Create new files or overwrite existing ones with full content.
+- edit_file: Replace a unique string in a file with new content. The old_string must be unique — include enough context lines.
+- bash: Execute shell commands. Set background=true for long-running processes (dev servers, watchers, builds). Returns a process ID immediately.
+- process_logs: View recent output from a background process by ID.
+- process_stop: Stop a background process by ID.
+- process_list: List all background processes with status and uptime.
+- task: Delegate a focused foreground task to a sub-agent. Use general for multi-step execution and explore for fast read-only research.
+- delegate: Launch a read-only background agent for longer research while you continue working.
+- delegation_read: Retrieve a completed background delegation result by ID.
+- delegation_list: List running and completed background delegations. Do not poll it repeatedly.
+- search_web: Search the web for current information, documentation, APIs, tutorials, etc.
+- search_x: Search X/Twitter for real-time posts, discussions, opinions, and trends.
+
+WORKFLOW:
+1. Understand the request
+2. Decide whether a sub-agent should handle the first investigation pass
+3. Use read_file and bash to explore the codebase directly when the task is small or tightly scoped
+4. Use bash with background=true for dev servers, watchers, or any long-running process — then continue working
+5. Use delegate for read-only work that can run in parallel, then continue productive work
+6. Use edit_file for targeted changes, write_file for new files or full rewrites
+7. Verify changes by reading modified files
+8. Run tests or builds with bash to confirm correctness
+9. Use search_web or search_x when you need up-to-date information
+
+DEFAULT DELEGATION POLICY:
+- Prefer the task tool by default for code review, code quality analysis, architecture research, root-cause investigation, bug triage, or any request that likely needs reading multiple files before acting.
+- Prefer delegate for longer-running read-only exploration when you can keep making progress without blocking.
+- Use the explore sub-agent for read-only investigation, reviews, research, and "how does this work?" tasks.
+- Use the general sub-agent for delegated work that may need editing files, running commands, or producing a concrete implementation.
+- Never use delegate for tasks that should edit files or make shell changes.
+- When a background delegation is running, do not wait idly and do not spam delegation_list(). Continue useful work.
+- Do not wait for the user to explicitly ask for a sub-agent when delegation would clearly help.
+- Skip delegation only when the task is trivial, single-file, or you already have the exact answer.
+
+EXAMPLES:
+- "review this change" -> delegate to explore first
+- "research how auth works" -> delegate to explore first
+- "investigate why this test fails" -> delegate to explore first, then continue with findings
+- "refactor this module" -> delegate a focused part to general when helpful
+
+IMPORTANT:
+- Prefer edit_file for surgical changes to existing files — it shows a clean diff.
+- Use write_file only for new files or when most of the file is changing.
+- Use read_file instead of cat/head/tail for reading files.
+
+Be direct. Execute, don't just describe. Show results, not plans.`,
+    plan: `You are Grok CLI in Plan mode — you analyze and plan but DO NOT execute changes.
+
+${ENVIRONMENT}
+
+TOOLS:
+- read_file: Read file contents for analysis.
+- bash: ONLY for searching (find, grep, ls) — NEVER modify files.
+- generate_plan: ALWAYS use this to present your plan. Creates an interactive UI with steps and questions.
+
+BEHAVIOR:
+- Explore the codebase first using read_file and bash to understand the current state
+- ALWAYS call generate_plan to present your plan — never just describe it in text
+- Include clear, ordered steps with affected file paths
+- Include questions when you need user input on approach, trade-offs, or preferences
+- Use "select" questions for single-choice decisions, "multiselect" for picking multiple options, and "text" for free-form input
+- Highlight potential risks, edge cases, and dependencies in the plan summary
+- NEVER create, modify, or delete files — only read and analyze`,
+    ask: `You are Grok CLI in Ask mode — you answer questions clearly and thoroughly.
+
+${ENVIRONMENT}
+
+TOOLS:
+- read_file: Read file contents for context.
+- bash: ONLY for searching (find, grep, ls) — NEVER modify.
+
+BEHAVIOR:
+- Answer the user's question directly and thoroughly
+- Use tools to gather context when needed
+- Provide code examples when helpful
+- NEVER create, modify, or delete files
+- Focus on explanation, not execution`,
+};
+function buildSystemPrompt(cwd, mode, planContext) {
+    const custom = loadCustomInstructions(cwd);
+    const customSection = custom
+        ? `\n\nCUSTOM INSTRUCTIONS:\n${custom}\n\nFollow the above alongside standard instructions.\n`
+        : "";
+    const skillsText = formatSkillsForPrompt(discoverSkills(cwd));
+    const skillsSection = skillsText ? `\n\n${skillsText}\n` : "";
+    const planSection = planContext
+        ? `\n\nAPPROVED PLAN:\nThe following plan has been approved by the user. Execute it now.\n${planContext}\n`
+        : "";
+    return `${MODE_PROMPTS[mode]}${customSection}${skillsSection}${planSection}
+
+Current working directory: ${cwd}`;
+}
+function buildSubagentPrompt(request, cwd) {
+    const mode = request.agent === "explore" ? "ask" : "agent";
+    const role = request.agent === "explore"
+        ? "You are the Explore sub-agent. You are read-only and focus on fast codebase research."
+        : "You are the General sub-agent. You can investigate, edit files, and run commands to complete delegated work.";
+    const rules = request.agent === "explore"
+        ? [
+            "Do not create, modify, or delete files.",
+            "Prefer `read_file` and search commands over broad shell exploration.",
+            "Return concise findings for the parent agent.",
+        ]
+        : [
+            "Work only on the delegated task below.",
+            "Use tools directly instead of narrating your intent.",
+            "Return a concise summary for the parent agent with key outcomes and any open risks.",
+        ];
+    return [
+        role,
+        "",
+        "You are helping a parent agent. Do not address the end user directly.",
+        "Focus tightly on the delegated scope and summarize what matters back to the parent agent.",
+        "",
+        ...rules,
+        "",
+        `Delegated task: ${request.description}`,
+        "",
+        buildSystemPrompt(cwd, mode),
+    ].join("\n");
+}
+export class Agent {
+    provider = null;
+    apiKey = null;
+    baseURL = null;
+    bash;
+    delegations;
+    sessionStore = null;
+    workspace = null;
+    session = null;
+    messages = [];
+    recordedTokens = 0;
+    abortController = null;
+    maxToolRounds;
+    mode = "agent";
+    modelId;
+    maxTokens;
+    planContext = null;
+    subagentStatusListeners = new Set();
+    constructor(apiKey, baseURL, model, maxToolRounds, options = {}) {
+        this.baseURL = baseURL || null;
+        if (apiKey) {
+            this.setApiKey(apiKey, baseURL);
+        }
+        this.bash = new BashTool();
+        this.delegations = new DelegationManager(() => this.bash.getCwd());
+        this.modelId = model || "grok-4-1-fast";
+        this.maxToolRounds = maxToolRounds || MAX_TOOL_ROUNDS;
+        const envMax = Number(process.env.GROK_MAX_TOKENS);
+        this.maxTokens = Number.isFinite(envMax) && envMax > 0 ? envMax : 16_384;
+        if (options.persistSession !== false) {
+            this.sessionStore = new SessionStore(this.bash.getCwd());
+            this.workspace = this.sessionStore.getWorkspace();
+            this.session = this.sessionStore.openSession(options.session, this.modelId, this.mode, this.bash.getCwd());
+            this.mode = this.session.mode;
+            this.messages = loadTranscript(this.session.id);
+            this.recordedTokens = getSessionTotalTokens(this.session.id);
+            this.sessionStore.setModel(this.session.id, this.modelId);
+        }
+    }
+    getModel() {
+        return this.modelId;
+    }
+    setModel(model) {
+        this.modelId = model;
+        if (this.sessionStore && this.session) {
+            this.sessionStore.setModel(this.session.id, model);
+            this.session = this.sessionStore.getRequiredSession(this.session.id);
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    setMode(mode) {
+        if (mode !== this.mode) {
+            this.mode = mode;
+            if (this.sessionStore && this.session) {
+                this.sessionStore.setMode(this.session.id, mode);
+                this.session = this.sessionStore.getRequiredSession(this.session.id);
+            }
+        }
+    }
+    setPlanContext(ctx) {
+        this.planContext = ctx;
+    }
+    hasApiKey() {
+        return !!this.apiKey;
+    }
+    setApiKey(apiKey, baseURL = this.baseURL ?? undefined) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL || null;
+        this.provider = createProvider(apiKey, baseURL);
+    }
+    getCwd() {
+        return this.bash.getCwd();
+    }
+    getContextStats(contextWindow, inFlightText = "") {
+        const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext);
+        const estimatedTokens = estimateTokens(`${system}\n${JSON.stringify(this.messages)}\n${inFlightText}`);
+        const usedTokens = Math.min(contextWindow, Math.max(estimatedTokens, this.recordedTokens));
+        const remainingTokens = Math.max(0, contextWindow - usedTokens);
+        return {
+            contextWindow,
+            usedTokens,
+            remainingTokens,
+            ratioUsed: usedTokens / contextWindow,
+            ratioRemaining: remainingTokens / contextWindow,
+        };
+    }
+    async generateTitle(userMessage) {
+        const provider = this.provider;
+        if (!provider) {
+            return "New session";
+        }
+        const generated = await genTitle(provider, userMessage);
+        this.recordUsage(generated.usage, "title", "grok-3-mini-fast");
+        if (this.sessionStore && this.session && !this.session.title && generated.title) {
+            this.sessionStore.setTitle(this.session.id, generated.title);
+            this.session = this.sessionStore.getRequiredSession(this.session.id);
+        }
+        return generated.title;
+    }
+    abort() {
+        this.abortController?.abort();
+        this.emitSubagentStatus(null);
+    }
+    clearHistory() {
+        this.startNewSession();
+    }
+    startNewSession() {
+        if (!this.sessionStore) {
+            this.messages = [];
+            this.recordedTokens = 0;
+            return null;
+        }
+        this.sessionStore = new SessionStore(this.bash.getCwd());
+        this.workspace = this.sessionStore.getWorkspace();
+        this.session = this.sessionStore.createSession(this.modelId, this.mode, this.bash.getCwd());
+        this.messages = [];
+        this.recordedTokens = 0;
+        return this.getSessionSnapshot();
+    }
+    getSessionInfo() {
+        return this.session;
+    }
+    getSessionId() {
+        return this.session?.id || null;
+    }
+    getSessionTitle() {
+        return this.session?.title || null;
+    }
+    getChatEntries() {
+        if (!this.session)
+            return [];
+        return buildChatEntries(this.session.id);
+    }
+    getSessionSnapshot() {
+        if (!this.session || !this.workspace)
+            return null;
+        return {
+            workspace: this.workspace,
+            session: this.session,
+            messages: loadTranscript(this.session.id),
+            entries: buildChatEntries(this.session.id),
+            totalTokens: getSessionTotalTokens(this.session.id),
+        };
+    }
+    onSubagentStatus(listener) {
+        this.subagentStatusListeners.add(listener);
+        return () => {
+            this.subagentStatusListeners.delete(listener);
+        };
+    }
+    emitSubagentStatus(status) {
+        for (const listener of this.subagentStatusListeners) {
+            listener(status);
+        }
+    }
+    discardAbortedTurn(userMessage) {
+        const idx = this.messages.lastIndexOf(userMessage);
+        if (idx >= 0) {
+            this.messages.splice(idx, 1);
+        }
+    }
+    recordUsage(usage, source = "message", model = this.modelId) {
+        if (!usage)
+            return;
+        const total = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+        if (Number.isFinite(total) && total > 0) {
+            this.recordedTokens += total;
+        }
+        if (this.session) {
+            recordUsageEvent(this.session.id, source, model, usage);
+        }
+    }
+    async consumeBackgroundNotifications() {
+        try {
+            const notifications = await this.delegations.consumeNotifications();
+            for (const notification of notifications) {
+                this.messages.push({ role: "system", content: notification.message });
+                if (this.session) {
+                    appendSystemMessage(this.session.id, notification.message);
+                }
+            }
+            return notifications.map((notification) => notification.message);
+        }
+        catch {
+            return [];
+        }
+    }
+    async runTaskRequest(request, onActivity, abortSignal) {
+        const provider = this.requireProvider();
+        const signal = abortSignal;
+        const childMode = request.agent === "explore" ? "ask" : "agent";
+        const childBash = new BashTool(this.bash.getCwd());
+        const childTools = createTools(childBash, provider, childMode);
+        const initialDetail = request.agent === "explore" ? "Scanning the codebase" : "Planning delegated work";
+        let assistantText = "";
+        let lastActivity = initialDetail;
+        onActivity?.(initialDetail);
+        try {
+            const result = streamText({
+                model: provider(request.agent === "explore" ? "grok-4-1-fast" : this.modelId),
+                system: buildSubagentPrompt(request, childBash.getCwd()),
+                messages: [{ role: "user", content: request.prompt }],
+                tools: childTools,
+                stopWhen: stepCountIs(Math.min(this.maxToolRounds, request.agent === "explore" ? 60 : 120)),
+                maxRetries: 0,
+                abortSignal: signal,
+                temperature: request.agent === "explore" ? 0.2 : 0.5,
+                maxOutputTokens: Math.min(this.maxTokens, 8_192),
+                onFinish: ({ totalUsage }) => {
+                    this.recordUsage(totalUsage, "task");
+                },
+            });
+            for await (const part of result.fullStream) {
+                if (signal?.aborted) {
+                    break;
+                }
+                if (part.type === "text-delta") {
+                    assistantText += part.text;
+                    continue;
+                }
+                if (part.type === "tool-call") {
+                    lastActivity = formatSubagentActivity(part.toolName, part.input);
+                    onActivity?.(lastActivity);
+                }
+            }
+            if (signal?.aborted) {
+                return { success: false, output: "[Cancelled]" };
+            }
+            await result.response;
+            const output = assistantText.trim() || `Task completed. Last action: ${lastActivity}`;
+            return {
+                success: true,
+                output,
+                task: {
+                    agent: request.agent,
+                    description: request.description,
+                    summary: firstLine(output),
+                    activity: lastActivity,
+                },
+            };
+        }
+        catch (err) {
+            if (signal?.aborted)
+                throw err;
+            const msg = err instanceof Error ? err.message : String(err);
+            const output = `Task failed: ${msg}`;
+            return {
+                success: false,
+                output,
+                task: {
+                    agent: request.agent,
+                    description: request.description,
+                    summary: output,
+                    activity: lastActivity,
+                },
+            };
+        }
+    }
+    async runTask(request, abortSignal) {
+        try {
+            return await this.runTaskRequest(request, (detail) => {
+                if (abortSignal?.aborted)
+                    return;
+                this.emitSubagentStatus({
+                    agent: request.agent,
+                    description: request.description,
+                    detail,
+                });
+            }, abortSignal);
+        }
+        finally {
+            this.emitSubagentStatus(null);
+        }
+    }
+    async runDelegation(request, abortSignal) {
+        try {
+            if (abortSignal?.aborted) {
+                return { success: false, output: "[Cancelled]" };
+            }
+            return await this.delegations.start(request, {
+                model: this.modelId,
+                maxToolRounds: this.maxToolRounds,
+                maxTokens: this.maxTokens,
+            });
+        }
+        catch (err) {
+            if (abortSignal?.aborted)
+                throw err;
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Delegation failed: ${msg}`,
+            };
+        }
+    }
+    async readDelegation(id) {
+        try {
+            return {
+                success: true,
+                output: await this.delegations.read(id),
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Failed to read delegation: ${msg}`,
+            };
+        }
+    }
+    async listDelegations() {
+        try {
+            const delegations = await this.delegations.list();
+            if (delegations.length === 0) {
+                return {
+                    success: true,
+                    output: "No delegations found for this project.",
+                };
+            }
+            const lines = delegations.map((delegation) => {
+                const title = delegation.description || delegation.id;
+                return `- \`${delegation.id}\` [${delegation.status}] ${title}\n  ${delegation.summary}`;
+            });
+            return {
+                success: true,
+                output: `## Delegations\n\n${lines.join("\n")}`,
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Failed to list delegations: ${msg}`,
+            };
+        }
+    }
+    async *processMessage(userMessage) {
+        this.abortController = new AbortController();
+        const signal = this.abortController.signal;
+        this.emitSubagentStatus(null);
+        await this.consumeBackgroundNotifications();
+        const userModelMessage = { role: "user", content: userMessage };
+        this.messages.push(userModelMessage);
+        let assistantText = "";
+        let streamOk = false;
+        try {
+            const provider = this.requireProvider();
+            const tools = createTools(this.bash, provider, this.mode, {
+                runTask: (request, abortSignal) => this.runTask(request, combineAbortSignals(signal, abortSignal)),
+                runDelegation: (request, abortSignal) => this.runDelegation(request, combineAbortSignals(signal, abortSignal)),
+                readDelegation: (id) => this.readDelegation(id),
+                listDelegations: () => this.listDelegations(),
+            });
+            const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.planContext);
+            this.planContext = null;
+            const result = streamText({
+                model: provider(this.modelId),
+                system,
+                messages: this.messages,
+                tools,
+                stopWhen: stepCountIs(this.maxToolRounds),
+                maxRetries: 0,
+                abortSignal: signal,
+                temperature: 0.7,
+                maxOutputTokens: this.maxTokens,
+                onFinish: ({ totalUsage }) => {
+                    this.recordUsage(totalUsage, "message");
+                },
+            });
+            for await (const part of result.fullStream) {
+                if (signal.aborted) {
+                    yield { type: "content", content: "\n\n[Cancelled]" };
+                    break;
+                }
+                switch (part.type) {
+                    case "text-delta":
+                        assistantText += part.text;
+                        yield { type: "content", content: part.text };
+                        break;
+                    case "reasoning-delta":
+                        yield { type: "reasoning", content: part.text };
+                        break;
+                    case "tool-call": {
+                        const tc = toToolCall(part);
+                        yield { type: "tool_calls", toolCalls: [tc] };
+                        break;
+                    }
+                    case "tool-result": {
+                        const tc = {
+                            id: part.toolCallId,
+                            type: "function",
+                            function: { name: part.toolName, arguments: JSON.stringify(part.input ?? {}) },
+                        };
+                        const tr = toToolResult(part.output);
+                        yield { type: "tool_result", toolCall: tc, toolResult: tr };
+                        break;
+                    }
+                    case "error":
+                        yield { type: "error", content: String(part.error) };
+                        break;
+                    case "abort":
+                        yield { type: "content", content: "\n\n[Cancelled]" };
+                        break;
+                }
+            }
+            if (signal.aborted) {
+                this.discardAbortedTurn(userModelMessage);
+                yield { type: "done" };
+                return;
+            }
+            try {
+                const response = await result.response;
+                if (!signal.aborted) {
+                    this.messages.push(...response.messages);
+                    if (this.sessionStore && this.session) {
+                        appendMessages(this.session.id, [userModelMessage, ...response.messages]);
+                        this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+                        this.session = this.sessionStore.getRequiredSession(this.session.id);
+                    }
+                    streamOk = true;
+                }
+            }
+            catch {
+                // response promise can fail after stream errors — fall back to manual message
+            }
+            if (signal.aborted) {
+                this.discardAbortedTurn(userModelMessage);
+                yield { type: "done" };
+                return;
+            }
+            if (!streamOk && assistantText.trim()) {
+                const fallbackMessage = { role: "assistant", content: assistantText };
+                this.messages.push(fallbackMessage);
+                if (this.sessionStore && this.session) {
+                    appendMessages(this.session.id, [userModelMessage, fallbackMessage]);
+                    this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+                    this.session = this.sessionStore.getRequiredSession(this.session.id);
+                }
+            }
+            yield { type: "done" };
+        }
+        catch (err) {
+            if (signal.aborted) {
+                this.discardAbortedTurn(userModelMessage);
+                yield { type: "content", content: "\n\n[Cancelled]" };
+            }
+            else {
+                const msg = err instanceof Error ? err.message : String(err);
+                yield { type: "error", content: `Error: ${msg}` };
+            }
+            if (!signal.aborted && assistantText.trim()) {
+                const fallbackMessage = { role: "assistant", content: assistantText };
+                this.messages.push(fallbackMessage);
+                if (this.sessionStore && this.session) {
+                    appendMessages(this.session.id, [userModelMessage, fallbackMessage]);
+                    this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+                    this.session = this.sessionStore.getRequiredSession(this.session.id);
+                }
+            }
+            yield { type: "done" };
+        }
+        finally {
+            if (this.abortController?.signal === signal) {
+                this.abortController = null;
+            }
+        }
+    }
+    requireProvider() {
+        if (!this.provider) {
+            throw new Error("API key required. Add an API key to continue.");
+        }
+        return this.provider;
+    }
+}
+function toToolCall(part) {
+    return {
+        id: part.toolCallId,
+        type: "function",
+        function: {
+            name: part.toolName,
+            arguments: JSON.stringify(part.input ?? part.args ?? {}),
+        },
+    };
+}
+function toToolResult(output) {
+    if (output && typeof output === "object" && "success" in output) {
+        const r = output;
+        return {
+            success: r.success,
+            output: r.output,
+            error: r.success ? undefined : r.output,
+            diff: r.diff,
+            plan: r.plan,
+            task: r.task,
+            delegation: r.delegation,
+            backgroundProcess: r.backgroundProcess,
+        };
+    }
+    return { success: true, output: String(output) };
+}
+function formatSubagentActivity(toolName, args) {
+    const parsed = parseToolArgs(args);
+    if (toolName === "read_file")
+        return `Read ${parsed.path || "file"}`;
+    if (toolName === "write_file")
+        return `Write ${parsed.path || "file"}`;
+    if (toolName === "edit_file")
+        return `Edit ${parsed.path || "file"}`;
+    if (toolName === "search_web")
+        return `Web search "${truncate(parsed.query || "", 50)}"`;
+    if (toolName === "search_x")
+        return `X search "${truncate(parsed.query || "", 50)}"`;
+    if (toolName === "bash")
+        return truncate(parsed.command || "Run command", 70);
+    return truncate(`${toolName}`, 70);
+}
+function parseToolArgs(args) {
+    if (!args || typeof args !== "object")
+        return {};
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+        result[key] = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    return result;
+}
+function firstLine(text) {
+    return text.trim().split("\n").find(Boolean)?.trim() || "Task completed.";
+}
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function combineAbortSignals(...signals) {
+    const activeSignals = signals.filter((signal) => Boolean(signal));
+    if (activeSignals.length === 0)
+        return undefined;
+    if (activeSignals.length === 1)
+        return activeSignals[0];
+    if (typeof AbortSignal.any === "function") {
+        return AbortSignal.any(activeSignals);
+    }
+    const controller = new AbortController();
+    for (const signal of activeSignals) {
+        if (signal.aborted) {
+            controller.abort();
+            break;
+        }
+        signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return controller.signal;
+}
+//# sourceMappingURL=agent.js.map