@ebowwa/coder 0.2.1 → 0.7.64

package/dist/core/agent-loop/__tests__/tool-executor.test.js

@@ -0,0 +1,331 @@
+/**
+ * Tool Executor Tests - Parallel tool execution with hooks and permissions
+ */
+import { describe, it, expect, beforeEach } from "bun:test";
+import { executeTools } from "../tool-executor.js";
+import { PermissionManager } from "../../permissions.js";
+// Mock tool definitions
+const createMockTool = (name, handler) => ({
+    name,
+    description: `Mock ${name} tool`,
+    input_schema: {
+        type: "object",
+        properties: {},
+    },
+    handler,
+});
+describe("executeTools", () => {
+    let permissionManager;
+    let toolResults;
+    beforeEach(() => {
+        permissionManager = new PermissionManager("bypassPermissions");
+        toolResults = [];
+    });
+    const createOptions = (tools, overrides = {}) => ({
+        tools,
+        workingDirectory: "/test",
+        permissionMode: "bypassPermissions",
+        permissionManager,
+        onToolResult: (result) => toolResults.push(result),
+        ...overrides,
+    });
+    describe("basic execution", () => {
+        it("should execute a single tool and return result", async () => {
+            const tools = [
+                createMockTool("TestTool", async () => ({ content: "Success" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "TestTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools));
+            expect(results).toHaveLength(1);
+            expect(results[0]?.tool_use_id).toBe("tool1");
+            expect(results[0]?.content).toBe("Success");
+            expect(results[0]?.is_error).toBeFalsy();
+        });
+        it("should execute multiple tools in parallel", async () => {
+            const executionOrder = [];
+            const tools = [
+                createMockTool("Tool1", async () => {
+                    executionOrder.push("Tool1");
+                    await new Promise((r) => setTimeout(r, 10));
+                    return { content: "Result 1" };
+                }),
+                createMockTool("Tool2", async () => {
+                    executionOrder.push("Tool2");
+                    await new Promise((r) => setTimeout(r, 5));
+                    return { content: "Result 2" };
+                }),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "Tool1", input: {} },
+                { type: "tool_use", id: "tool2", name: "Tool2", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools));
+            expect(results).toHaveLength(2);
+            // Both should have been started before either finished (parallel)
+            expect(executionOrder).toContain("Tool1");
+            expect(executionOrder).toContain("Tool2");
+        });
+        it("should return error for unknown tool", async () => {
+            const tools = [
+                createMockTool("KnownTool", async () => ({ content: "OK" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "UnknownTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools));
+            expect(results).toHaveLength(1);
+            expect(results[0]?.is_error).toBe(true);
+            expect(results[0]?.content).toContain("Unknown tool");
+        });
+        it("should handle tool handler errors", async () => {
+            const tools = [
+                createMockTool("FailingTool", async () => {
+                    throw new Error("Handler error");
+                }),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "FailingTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools));
+            expect(results).toHaveLength(1);
+            expect(results[0]?.is_error).toBe(true);
+            expect(results[0]?.content).toContain("Handler error");
+        });
+        it("should pass tool input to handler", async () => {
+            let receivedInput = null;
+            const tools = [
+                createMockTool("InputTool", async (args) => {
+                    receivedInput = args;
+                    return { content: "OK" };
+                }),
+            ];
+            const toolUseBlocks = [
+                {
+                    type: "tool_use",
+                    id: "tool1",
+                    name: "InputTool",
+                    input: { path: "/test/file.txt", mode: "read" },
+                },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools));
+            expect(receivedInput).not.toBeNull();
+            expect(receivedInput).toEqual({ path: "/test/file.txt", mode: "read" });
+        });
+    });
+    describe("tool result callbacks", () => {
+        it("should call onToolResult for successful tools", async () => {
+            const tools = [
+                createMockTool("SuccessTool", async () => ({ content: "Done" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "SuccessTool", input: {} },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools));
+            expect(toolResults).toHaveLength(1);
+            expect(toolResults[0]?.id).toBe("tool1");
+            expect(toolResults[0]?.result.content).toBe("Done");
+        });
+        it("should not call onToolResult for unknown tools", async () => {
+            const tools = [];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "Unknown", input: {} },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools));
+            expect(toolResults).toHaveLength(0);
+        });
+        it("should not call onToolResult for failed tools", async () => {
+            const tools = [
+                createMockTool("FailingTool", async () => {
+                    throw new Error("Fail");
+                }),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "FailingTool", input: {} },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools));
+            expect(toolResults).toHaveLength(0);
+        });
+    });
+    describe("abort signal", () => {
+        it("should return empty array if signal is already aborted", async () => {
+            const tools = [
+                createMockTool("Tool", async () => ({ content: "OK" })),
+            ];
+            const controller = new AbortController();
+            controller.abort();
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "Tool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools, { signal: controller.signal }));
+            expect(results).toHaveLength(0);
+        });
+    });
+    describe("permission checks", () => {
+        it("should deny tool when permission is denied", async () => {
+            const tools = [
+                createMockTool("RestrictedTool", async () => ({ content: "Should not reach" })),
+            ];
+            const denyManager = new PermissionManager("dontAsk");
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "RestrictedTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools, { permissionManager: denyManager }));
+            expect(results).toHaveLength(1);
+            expect(results[0]?.is_error).toBe(true);
+            expect(results[0]?.content).toContain("Permission denied");
+        });
+        it("should allow tool when permission is granted", async () => {
+            const tools = [
+                createMockTool("AllowedTool", async () => ({ content: "Success" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "AllowedTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools, { permissionManager }));
+            expect(results[0]?.is_error).toBeFalsy();
+            expect(results[0]?.content).toBe("Success");
+        });
+    });
+    describe("hook integration", () => {
+        it("should execute PreToolUse hooks", async () => {
+            let hookCalled = false;
+            const mockHookManager = {
+                execute: async (event, input) => {
+                    if (event === "PreToolUse") {
+                        hookCalled = true;
+                    }
+                    return { decision: "allow" };
+                },
+            };
+            const tools = [
+                createMockTool("HookTool", async () => ({ content: "OK" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "HookTool", input: {} },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools, { hookManager: mockHookManager }));
+            expect(hookCalled).toBe(true);
+        });
+        it("should block tool when PreToolUse hook denies", async () => {
+            const mockHookManager = {
+                execute: async (event, input) => {
+                    if (event === "PreToolUse") {
+                        return { decision: "deny", reason: "Blocked by hook" };
+                    }
+                    return { decision: "allow" };
+                },
+            };
+            const tools = [
+                createMockTool("BlockedTool", async () => ({ content: "Should not reach" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "BlockedTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools, { hookManager: mockHookManager }));
+            expect(results[0]?.is_error).toBe(true);
+            expect(results[0]?.content).toContain("Blocked by hook");
+        });
+        it("should execute PostToolUse hooks", async () => {
+            let postHookCalled = false;
+            const mockHookManager = {
+                execute: async (event, input) => {
+                    if (event === "PostToolUse") {
+                        postHookCalled = true;
+                    }
+                    return { decision: "allow" };
+                },
+            };
+            const tools = [
+                createMockTool("PostHookTool", async () => ({ content: "Result" })),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "PostHookTool", input: {} },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools, { hookManager: mockHookManager }));
+            expect(postHookCalled).toBe(true);
+        });
+        it("should modify tool input via hook", async () => {
+            let receivedInput = null;
+            const mockHookManager = {
+                execute: async (event, input) => {
+                    if (event === "PreToolUse") {
+                        return {
+                            decision: "allow",
+                            modified_input: { modified: true },
+                        };
+                    }
+                    return { decision: "allow" };
+                },
+            };
+            const tools = [
+                createMockTool("ModifiedInputTool", async (args) => {
+                    receivedInput = args;
+                    return { content: "OK" };
+                }),
+            ];
+            const toolUseBlocks = [
+                {
+                    type: "tool_use",
+                    id: "tool1",
+                    name: "ModifiedInputTool",
+                    input: { original: true },
+                },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools, { hookManager: mockHookManager }));
+            // Object.assign merges properties, so we get both original and modified
+            expect(receivedInput).not.toBeNull();
+            expect(receivedInput).toEqual({ original: true, modified: true });
+        });
+        it("should execute PostToolUseFailure hooks on error", async () => {
+            let failureHookCalled = false;
+            const mockHookManager = {
+                execute: async (event, input) => {
+                    if (event === "PostToolUseFailure") {
+                        failureHookCalled = true;
+                        expect(input.error).toContain("Handler crashed");
+                    }
+                    return { decision: "allow" };
+                },
+            };
+            const tools = [
+                createMockTool("CrashTool", async () => {
+                    throw new Error("Handler crashed");
+                }),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "CrashTool", input: {} },
+            ];
+            await executeTools(toolUseBlocks, createOptions(tools, { hookManager: mockHookManager }));
+            expect(failureHookCalled).toBe(true);
+        });
+    });
+    describe("error handling", () => {
+        it("should handle non-Error thrown objects", async () => {
+            const tools = [
+                createMockTool("StringThrowTool", async () => {
+                    throw "String error";
+                }),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "StringThrowTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools));
+            expect(results[0]?.is_error).toBe(true);
+            expect(results[0]?.content).toContain("String error");
+        });
+        it("should handle null thrown", async () => {
+            const tools = [
+                createMockTool("NullThrowTool", async () => {
+                    throw null;
+                }),
+            ];
+            const toolUseBlocks = [
+                { type: "tool_use", id: "tool1", name: "NullThrowTool", input: {} },
+            ];
+            const results = await executeTools(toolUseBlocks, createOptions(tools));
+            expect(results[0]?.is_error).toBe(true);
+        });
+    });
+});

package/dist/core/agent-loop/compaction.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Compaction Handler - Context compaction strategies
+ */
+import { needsCompaction } from "../context-compaction.js";
+import type { LoopState } from "./loop-state.js";
+/**
+ * Compaction options
+ */
+export interface CompactionOptions {
+    /** Number of initial messages to preserve (0 = none) */
+    keepFirst?: number;
+    /** Number of recent messages to preserve */
+    keepLast?: number;
+    /** Preserve tool use/result pairs */
+    preserveToolPairs?: boolean;
+}
+/** Default compaction options for proactive compaction */
+export declare const DEFAULT_PROACTIVE_OPTIONS: CompactionOptions;
+/** Default compaction options for reactive compaction (on max_tokens) */
+export declare const DEFAULT_REACTIVE_OPTIONS: CompactionOptions;
+/**
+ * Check if compaction is needed and apply it proactively
+ * @returns true if compaction was applied
+ */
+export declare function handleProactiveCompaction(state: LoopState, maxTokens: number, options?: CompactionOptions): Promise<boolean>;
+/**
+ * Handle reactive compaction when max_tokens is hit
+ * @returns true if compaction was applied and loop should continue
+ */
+export declare function handleReactiveCompaction(state: LoopState, maxTokens: number, options?: CompactionOptions): Promise<boolean>;
+/**
+ * Check if messages need compaction
+ */
+export { needsCompaction };
+/**
+ * Get token estimate for messages
+ */
+export { estimateMessagesTokens } from "../context-compaction.js";
+//# sourceMappingURL=compaction.d.ts.map

package/dist/core/agent-loop/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/compaction.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,eAAe,EAIhB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,0DAA0D;AAC1D,eAAO,MAAM,yBAAyB,EAAE,iBAIvC,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,EAAE,iBAItC,CAAC;AAEF;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,iBAA6C,GACrD,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,iBAA4C,GACpD,OAAO,CAAC,OAAO,CAAC,CAQlB;AAED;;GAEG;AACH,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B;;GAEG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/core/agent-loop/compaction.js

@@ -0,0 +1,51 @@
+/**
+ * Compaction Handler - Context compaction strategies
+ */
+import { needsCompaction, compactMessages, getCompactionStats, } from "../context-compaction.js";
+/** Default compaction options for proactive compaction */
+export const DEFAULT_PROACTIVE_OPTIONS = {
+    keepFirst: 0, // Don't preserve first message - summary covers it
+    keepLast: 3, // Only keep last 3 messages for more aggressive compaction
+    preserveToolPairs: true,
+};
+/** Default compaction options for reactive compaction (on max_tokens) */
+export const DEFAULT_REACTIVE_OPTIONS = {
+    keepFirst: 0, // Don't preserve first message
+    keepLast: 3, // More aggressive - only keep last 3
+    preserveToolPairs: true,
+};
+/**
+ * Check if compaction is needed and apply it proactively
+ * @returns true if compaction was applied
+ */
+export async function handleProactiveCompaction(state, maxTokens, options = DEFAULT_PROACTIVE_OPTIONS) {
+    if (!needsCompaction(state.messages, maxTokens)) {
+        return false;
+    }
+    const compactionResult = await compactMessages(state.messages, maxTokens, {
+        keepFirst: options.keepFirst ?? 0,
+        keepLast: options.keepLast ?? 3,
+        preserveToolPairs: options.preserveToolPairs ?? true,
+    });
+    return state.applyCompaction(compactionResult, getCompactionStats);
+}
+/**
+ * Handle reactive compaction when max_tokens is hit
+ * @returns true if compaction was applied and loop should continue
+ */
+export async function handleReactiveCompaction(state, maxTokens, options = DEFAULT_REACTIVE_OPTIONS) {
+    const compactionResult = await compactMessages(state.messages, maxTokens, {
+        keepFirst: options.keepFirst ?? 0,
+        keepLast: options.keepLast ?? 3,
+        preserveToolPairs: options.preserveToolPairs ?? true,
+    });
+    return state.applyCompaction(compactionResult, getCompactionStats);
+}
+/**
+ * Check if messages need compaction
+ */
+export { needsCompaction };
+/**
+ * Get token estimate for messages
+ */
+export { estimateMessagesTokens } from "../context-compaction.js";

package/dist/core/agent-loop/formatters.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Formatters - Cost and metrics display utilities
+ */
+import type { QueryMetrics, CacheMetrics } from "../../types/index.js";
+/**
+ * Format cost for display
+ */
+export declare function formatCost(costUSD: number): string;
+/**
+ * Format metrics for display
+ */
+export declare function formatMetrics(metrics: QueryMetrics): string;
+/**
+ * Format brief cost for per-turn display (less verbose)
+ */
+export declare function formatCostBrief(metrics: QueryMetrics): string;
+/**
+ * Format cache metrics for display
+ */
+export declare function formatCacheMetrics(cacheMetrics: CacheMetrics): string;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/core/agent-loop/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/formatters.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAY3D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAI7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAIrE"}

package/dist/core/agent-loop/formatters.js

@@ -0,0 +1,42 @@
+/**
+ * Formatters - Cost and metrics display utilities
+ */
+/**
+ * Format cost for display
+ */
+export function formatCost(costUSD) {
+    if (costUSD < 0.01) {
+        return `$${costUSD.toFixed(4)}`;
+    }
+    return `$${costUSD.toFixed(2)}`;
+}
+/**
+ * Format metrics for display
+ */
+export function formatMetrics(metrics) {
+    const cost = formatCost(metrics.costUSD);
+    const tokens = `${metrics.usage.input_tokens.toLocaleString()} input, ${metrics.usage.output_tokens.toLocaleString()} output`;
+    // Include cache info if available
+    if (metrics.usage.cache_read_input_tokens || metrics.usage.cache_creation_input_tokens) {
+        const cacheRead = metrics.usage.cache_read_input_tokens?.toLocaleString() ?? "0";
+        const cacheWrite = metrics.usage.cache_creation_input_tokens?.toLocaleString() ?? "0";
+        return `Cost: ${cost} | Tokens: ${tokens} | Cache: ${cacheRead} read, ${cacheWrite} write`;
+    }
+    return `Cost: ${cost} | Tokens: ${tokens}`;
+}
+/**
+ * Format brief cost for per-turn display (less verbose)
+ */
+export function formatCostBrief(metrics) {
+    const cost = formatCost(metrics.costUSD);
+    const totalTokens = metrics.usage.input_tokens + metrics.usage.output_tokens;
+    return `Cost: ${cost} | Tokens: ${totalTokens.toLocaleString()}`;
+}
+/**
+ * Format cache metrics for display
+ */
+export function formatCacheMetrics(cacheMetrics) {
+    const savings = formatCost(cacheMetrics.estimatedSavingsUSD);
+    const hitRate = (cacheMetrics.cacheHitRate * 100).toFixed(1);
+    return `Cache: ${hitRate}% hit rate | ${cacheMetrics.totalCacheReadTokens.toLocaleString()} read | ${cacheMetrics.totalCacheWriteTokens.toLocaleString()} written | Saved: ${savings}`;
+}

package/dist/core/agent-loop/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Agent Loop - Turn-based processing system
+ *
+ * This is the main orchestrator that coordinates:
+ * - State management (loop-state.ts)
+ * - Turn execution (turn-executor.ts)
+ * - Tool execution (tool-executor.ts)
+ * - Context compaction (compaction.ts)
+ * - Message building (message-builder.ts)
+ * - Formatting utilities (formatters.ts)
+ */
+import type { Message } from "../../types/index.js";
+import type { AgentLoopOptions, AgentLoopResult } from "./types.js";
+export type { AgentLoopOptions, AgentLoopResult } from "./types.js";
+export { formatCost, formatMetrics, formatCostBrief, formatCacheMetrics } from "./formatters.js";
+export { LoopState } from "./loop-state.js";
+export { executeTurn } from "./turn-executor.js";
+export { executeTools, type ToolExecutionOptions } from "./tool-executor.js";
+export { buildAPIMessages, injectReminderIntoContent } from "./message-builder.js";
+export { handleProactiveCompaction, handleReactiveCompaction, needsCompaction, estimateMessagesTokens, DEFAULT_PROACTIVE_OPTIONS, DEFAULT_REACTIVE_OPTIONS, } from "./compaction.js";
+/**
+ * Main agent loop - processes messages in turns until completion
+ */
+export declare function agentLoop(initialMessages: Message[], options: AgentLoopOptions): Promise<AgentLoopResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/agent-loop/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAMpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAKpE,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACjG,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,eAAe,EACf,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA0F1B"}

package/dist/core/agent-loop/index.js

@@ -0,0 +1,83 @@
+/**
+ * Agent Loop - Turn-based processing system
+ *
+ * This is the main orchestrator that coordinates:
+ * - State management (loop-state.ts)
+ * - Turn execution (turn-executor.ts)
+ * - Tool execution (tool-executor.ts)
+ * - Context compaction (compaction.ts)
+ * - Message building (message-builder.ts)
+ * - Formatting utilities (formatters.ts)
+ */
+import { DEFAULT_CACHE_CONFIG } from "../../types/index.js";
+import { PermissionManager } from "../permissions.js";
+import { DEFAULT_REMINDER_CONFIG } from "../system-reminders.js";
+import { LoopState } from "./loop-state.js";
+import { executeTurn } from "./turn-executor.js";
+export { formatCost, formatMetrics, formatCostBrief, formatCacheMetrics } from "./formatters.js";
+export { LoopState } from "./loop-state.js";
+export { executeTurn } from "./turn-executor.js";
+export { executeTools } from "./tool-executor.js";
+export { buildAPIMessages, injectReminderIntoContent } from "./message-builder.js";
+export { handleProactiveCompaction, handleReactiveCompaction, needsCompaction, estimateMessagesTokens, DEFAULT_PROACTIVE_OPTIONS, DEFAULT_REACTIVE_OPTIONS, } from "./compaction.js";
+/**
+ * Main agent loop - processes messages in turns until completion
+ */
+export async function agentLoop(initialMessages, options) {
+    const { apiKey, model = "claude-sonnet-4-6", maxTokens = 4096, systemPrompt, tools, permissionMode, workingDirectory, gitStatus = null, reminderConfig, cacheConfig = DEFAULT_CACHE_CONFIG, thinking, extendedThinking, hookManager, sessionId, onText, onThinking, onToolUse, onToolResult, onMetrics, onReminder, onPermissionRequest, signal, } = options;
+    // Initialize state
+    const state = new LoopState(initialMessages);
+    const permissionManager = new PermissionManager(permissionMode, onPermissionRequest);
+    const mergedReminderConfig = { ...DEFAULT_REMINDER_CONFIG, ...reminderConfig };
+    // Execute SessionStart hook
+    if (hookManager) {
+        await hookManager.execute("SessionStart", {
+            session_id: sessionId,
+        });
+    }
+    let shouldContinue = true;
+    while (shouldContinue) {
+        if (signal?.aborted) {
+            break;
+        }
+        // Build turn executor options
+        const turnOptions = {
+            apiKey,
+            model,
+            maxTokens,
+            systemPrompt,
+            tools,
+            cacheConfig,
+            thinking,
+            extendedThinking,
+            workingDirectory,
+            gitStatus,
+            reminderConfig: mergedReminderConfig,
+            hookManager,
+            sessionId,
+            signal,
+            onText,
+            onThinking,
+            onToolUse,
+            onReminder,
+            permissionMode,
+            permissionManager,
+            onMetrics,
+            onToolResult,
+        };
+        // Execute a single turn
+        const turnResult = await executeTurn(state, turnOptions);
+        shouldContinue = turnResult.shouldContinue;
+        // Call onMetrics callback with the latest metrics
+        if (turnResult.metrics && onMetrics) {
+            onMetrics(turnResult.metrics);
+        }
+    }
+    // Execute SessionEnd hook
+    if (hookManager) {
+        await hookManager.execute("SessionEnd", {
+            session_id: sessionId,
+        });
+    }
+    return state.toResult();
+}