@ebowwa/coder 0.7.63 → 0.7.65

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

@@ -0,0 +1,74 @@
+/**
+ * Loop State - Mutable state management for the agent loop
+ */
+import type { Message, ToolUseBlock, QueryMetrics, CacheMetrics, UsageMetrics } from "../../types/index.js";
+import type { CompactionResult, getCompactionStats } from "../context-compaction.js";
+/**
+ * Creates an initial cache metrics object
+ */
+export declare function createInitialCacheMetrics(): CacheMetrics;
+/**
+ * LoopState class encapsulates all mutable state during the agent loop
+ */
+export declare class LoopState {
+    messages: Message[];
+    metrics: QueryMetrics[];
+    allToolsUsed: ToolUseBlock[];
+    totalCost: number;
+    totalDuration: number;
+    turnNumber: number;
+    previousCost: number;
+    compactionCount: number;
+    totalTokensCompacted: number;
+    cacheMetrics: CacheMetrics;
+    constructor(initialMessages: Message[]);
+    /**
+     * Get the latest metrics entry
+     */
+    get latestMetrics(): QueryMetrics | undefined;
+    /**
+     * Get usage for reminder building (with fallback)
+     */
+    get currentUsage(): UsageMetrics;
+    /**
+     * Add a turn's results to the state
+     */
+    addTurnResult(result: {
+        message: {
+            content: unknown[];
+            stop_reason: string | null;
+            id: string;
+        };
+        usage: UsageMetrics;
+        cacheMetrics?: CacheMetrics;
+        costUSD: number;
+        durationMs: number;
+        model: string;
+        messageCount: number;
+    }): QueryMetrics;
+    /**
+     * Add assistant message to history
+     */
+    addAssistantMessage(content: unknown[]): void;
+    /**
+     * Add user message (tool results) to history
+     */
+    addUserMessage(content: import("../../types/index.js").ToolResultBlock[]): void;
+    /**
+     * Track tool usage
+     */
+    trackToolUse(toolUseBlocks: ToolUseBlock[]): void;
+    /**
+     * Apply compaction result to state
+     */
+    applyCompaction(compactionResult: CompactionResult, getStats: typeof getCompactionStats): boolean;
+    /**
+     * Increment turn counter
+     */
+    incrementTurn(): number;
+    /**
+     * Convert to AgentLoopResult
+     */
+    toResult(): import("./types.js").AgentLoopResult;
+}
+//# sourceMappingURL=loop-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loop-state.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/loop-state.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAErF;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,YAAY,CASxD;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,YAAY,EAAE,CAAM;IAC7B,YAAY,EAAE,YAAY,EAAE,CAAM;IAClC,SAAS,SAAK;IACd,aAAa,SAAK;IAClB,UAAU,SAAK;IACf,YAAY,SAAK;IACjB,eAAe,SAAK;IACpB,oBAAoB,SAAK;IACzB,YAAY,EAAE,YAAY,CAAC;gBAEf,eAAe,EAAE,OAAO,EAAE;IAKtC;;OAEG;IACH,IAAI,aAAa,IAAI,YAAY,GAAG,SAAS,CAE5C;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,YAAY,CAK/B;IAED;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE;QACpB,OAAO,EAAE;YAAE,OAAO,EAAE,OAAO,EAAE,CAAC;YAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QACxE,KAAK,EAAE,YAAY,CAAC;QACpB,YAAY,CAAC,EAAE,YAAY,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,YAAY,EAAE,MAAM,CAAC;KACtB,GAAG,YAAY;IAqChB;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI;IAO7C;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,OAAO,sBAAsB,EAAE,eAAe,EAAE,GAAG,IAAI;IAO/E;;OAEG;IACH,YAAY,CAAC,aAAa,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD;;OAEG;IACH,eAAe,CACb,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,EAAE,OAAO,kBAAkB,GAClC,OAAO;IAoBV;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,QAAQ,IAAI,OAAO,YAAY,EAAE,eAAe;CAWjD"}

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

@@ -0,0 +1,147 @@
+/**
+ * Loop State - Mutable state management for the agent loop
+ */
+/**
+ * Creates an initial cache metrics object
+ */
+export function createInitialCacheMetrics() {
+    return {
+        cacheHits: 0,
+        cacheMisses: 0,
+        totalCacheReadTokens: 0,
+        totalCacheWriteTokens: 0,
+        cacheHitRate: 0,
+        estimatedSavingsUSD: 0,
+    };
+}
+/**
+ * LoopState class encapsulates all mutable state during the agent loop
+ */
+export class LoopState {
+    messages;
+    metrics = [];
+    allToolsUsed = [];
+    totalCost = 0;
+    totalDuration = 0;
+    turnNumber = 0;
+    previousCost = 0;
+    compactionCount = 0;
+    totalTokensCompacted = 0;
+    cacheMetrics;
+    constructor(initialMessages) {
+        this.messages = [...initialMessages];
+        this.cacheMetrics = createInitialCacheMetrics();
+    }
+    /**
+     * Get the latest metrics entry
+     */
+    get latestMetrics() {
+        return this.metrics[this.metrics.length - 1];
+    }
+    /**
+     * Get usage for reminder building (with fallback)
+     */
+    get currentUsage() {
+        return this.latestMetrics?.usage ?? {
+            input_tokens: 0,
+            output_tokens: 0,
+        };
+    }
+    /**
+     * Add a turn's results to the state
+     */
+    addTurnResult(result) {
+        const queryMetrics = {
+            model: result.model,
+            messageCount: result.messageCount,
+            messageTokens: result.usage.input_tokens + result.usage.output_tokens,
+            usage: result.usage,
+            cacheMetrics: result.cacheMetrics,
+            durationMs: result.durationMs,
+            ttftMs: 0, // Will be set by caller if available
+            costUSD: result.costUSD,
+            stopReason: result.message.stop_reason,
+            requestId: result.message.id,
+        };
+        this.metrics.push(queryMetrics);
+        this.previousCost = this.totalCost;
+        this.totalCost += result.costUSD;
+        this.totalDuration += result.durationMs;
+        // Aggregate cache metrics
+        if (result.cacheMetrics) {
+            this.cacheMetrics.cacheHits += result.cacheMetrics.cacheHits;
+            this.cacheMetrics.cacheMisses += result.cacheMetrics.cacheMisses;
+            this.cacheMetrics.totalCacheReadTokens += result.cacheMetrics.totalCacheReadTokens;
+            this.cacheMetrics.totalCacheWriteTokens += result.cacheMetrics.totalCacheWriteTokens;
+            this.cacheMetrics.estimatedSavingsUSD += result.cacheMetrics.estimatedSavingsUSD;
+        }
+        // Update cache hit rate
+        const totalCacheOps = this.cacheMetrics.cacheHits + this.cacheMetrics.cacheMisses;
+        this.cacheMetrics.cacheHitRate = totalCacheOps > 0
+            ? this.cacheMetrics.cacheHits / totalCacheOps
+            : 0;
+        return queryMetrics;
+    }
+    /**
+     * Add assistant message to history
+     */
+    addAssistantMessage(content) {
+        this.messages.push({
+            role: "assistant",
+            content: content,
+        });
+    }
+    /**
+     * Add user message (tool results) to history
+     */
+    addUserMessage(content) {
+        this.messages.push({
+            role: "user",
+            content,
+        });
+    }
+    /**
+     * Track tool usage
+     */
+    trackToolUse(toolUseBlocks) {
+        this.allToolsUsed.push(...toolUseBlocks);
+    }
+    /**
+     * Apply compaction result to state
+     */
+    applyCompaction(compactionResult, getStats) {
+        // Only apply compaction if it actually saved tokens
+        if (!compactionResult.didCompact || compactionResult.tokensAfter >= compactionResult.tokensBefore) {
+            return false;
+        }
+        // Replace messages array content
+        this.messages.length = 0;
+        this.messages.push(...compactionResult.messages);
+        this.compactionCount++;
+        const tokensSaved = compactionResult.tokensBefore - compactionResult.tokensAfter;
+        this.totalTokensCompacted += tokensSaved;
+        const stats = getStats(compactionResult);
+        console.log(`Context compacted: ${stats.reductionPercent}% reduction, ${stats.tokensSaved} tokens saved`);
+        return true;
+    }
+    /**
+     * Increment turn counter
+     */
+    incrementTurn() {
+        return ++this.turnNumber;
+    }
+    /**
+     * Convert to AgentLoopResult
+     */
+    toResult() {
+        return {
+            messages: this.messages,
+            metrics: this.metrics,
+            totalCost: this.totalCost,
+            totalDuration: this.totalDuration,
+            totalCacheMetrics: this.cacheMetrics,
+            compactionCount: this.compactionCount,
+            totalTokensCompacted: this.totalTokensCompacted,
+        };
+    }
+}

package/dist/core/agent-loop/message-builder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Message Builder - API message construction with reminder injection
+ */
+import type { Message, ContentBlock } from "../../types/index.js";
+/**
+ * Build API messages with system reminders injected
+ */
+export declare function buildAPIMessages(messages: Message[], systemPrompt: string, systemReminder?: string): Message[];
+/**
+ * Inject system reminder into content blocks
+ */
+export declare function injectReminderIntoContent(content: ContentBlock[], reminder: string): ContentBlock[];
+//# sourceMappingURL=message-builder.d.ts.map

package/dist/core/agent-loop/message-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-builder.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/message-builder.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAa,MAAM,sBAAsB,CAAC;AAE7E;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,EAAE,CAuBX;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,YAAY,EAAE,EACvB,QAAQ,EAAE,MAAM,GACf,YAAY,EAAE,CAiBhB"}

package/dist/core/agent-loop/message-builder.js

@@ -0,0 +1,49 @@
+/**
+ * Message Builder - API message construction with reminder injection
+ */
+/**
+ * Build API messages with system reminders injected
+ */
+export function buildAPIMessages(messages, systemPrompt, systemReminder) {
+    // If we have a system reminder, inject it into the last user message
+    if (systemReminder && messages.length > 0) {
+        const result = [...messages];
+        // Find the last user message
+        for (let i = result.length - 1; i >= 0; i--) {
+            const msg = result[i];
+            if (msg && msg.role === "user") {
+                // Clone the message to avoid mutating original
+                const updatedMessage = {
+                    role: "user",
+                    content: Array.isArray(msg.content)
+                        ? injectReminderIntoContent(msg.content, systemReminder)
+                        : [{ type: "text", text: `${String(msg.content)}\n\n${systemReminder}` }],
+                };
+                result[i] = updatedMessage;
+                break;
+            }
+        }
+        return result;
+    }
+    return messages;
+}
+/**
+ * Inject system reminder into content blocks
+ */
+export function injectReminderIntoContent(content, reminder) {
+    // Check if the last block is a text block we can append to
+    if (content.length > 0) {
+        const lastBlock = content[content.length - 1];
+        if (lastBlock && lastBlock.type === "text") {
+            // Append to existing text block
+            const textBlock = {
+                type: "text",
+                text: `${lastBlock.text}\n\n${reminder}`,
+            };
+            return [...content.slice(0, -1), textBlock];
+        }
+    }
+    // Add as new text block
+    const newBlock = { type: "text", text: `\n\n${reminder}` };
+    return [...content, newBlock];
+}

package/dist/core/agent-loop/tool-executor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tool Executor - Parallel tool execution with hooks and permissions
+ */
+import type { ToolDefinition, ToolUseBlock, ToolResultBlock, ToolResult, PermissionMode } from "../../types/index.js";
+import type { HookManager } from "../../ecosystem/hooks/index.js";
+export interface ToolExecutionOptions {
+    tools: ToolDefinition[];
+    workingDirectory: string;
+    permissionMode: PermissionMode;
+    hookManager?: HookManager;
+    sessionId?: string;
+    signal?: AbortSignal;
+    permissionManager: import("../permissions.js").PermissionManager;
+    onToolResult?: (result: {
+        id: string;
+        result: ToolResult;
+    }) => void;
+}
+/**
+ * Execute multiple tools in parallel and collect results
+ */
+export declare function executeTools(toolUseBlocks: ToolUseBlock[], options: ToolExecutionOptions): Promise<ToolResultBlock[]>;
+//# sourceMappingURL=tool-executor.d.ts.map

package/dist/core/agent-loop/tool-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-executor.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/tool-executor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,eAAe,EACf,UAAU,EACV,cAAc,EACf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,iBAAiB,EAAE,OAAO,mBAAmB,EAAE,iBAAiB,CAAC;IACjE,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,KAAK,IAAI,CAAC;CACrE;AA8JD;;GAEG;AACH,wBAAsB,YAAY,CAChC,aAAa,EAAE,YAAY,EAAE,EAC7B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,eAAe,EAAE,CAAC,CAwB5B"}

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

@@ -0,0 +1,152 @@
+/**
+ * Tool Executor - Parallel tool execution with hooks and permissions
+ */
+/**
+ * Execute a single tool with permission checks and hooks
+ */
+async function executeSingleTool(toolUse, options) {
+    const { tools, workingDirectory, permissionMode, hookManager, sessionId, signal, permissionManager } = options;
+    const tool = tools.find((t) => t.name === toolUse.name);
+    if (!tool) {
+        return {
+            toolUseId: toolUse.id,
+            result: {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: `Error: Unknown tool "${toolUse.name}"`,
+                is_error: true,
+            },
+            toolResult: null,
+        };
+    }
+    // Check permissions using PermissionManager
+    const permissionResult = await permissionManager.checkPermission(tool.name, toolUse.input);
+    if (permissionResult.decision === "deny" || permissionResult.decision === "denyAlways") {
+        return {
+            toolUseId: toolUse.id,
+            result: {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: `Permission denied for tool "${toolUse.name}"${permissionResult.reason ? `: ${permissionResult.reason}` : ""}`,
+                is_error: true,
+            },
+            toolResult: null,
+        };
+    }
+    // Execute PreToolUse hooks
+    if (hookManager) {
+        const hookResult = await hookManager.execute("PreToolUse", {
+            tool_name: tool.name,
+            tool_input: toolUse.input,
+            session_id: sessionId,
+        });
+        if (hookResult.decision === "deny" || hookResult.decision === "block") {
+            return {
+                toolUseId: toolUse.id,
+                result: {
+                    type: "tool_result",
+                    tool_use_id: toolUse.id,
+                    content: hookResult.reason || `Tool "${tool.name}" blocked by hook`,
+                    is_error: true,
+                },
+                toolResult: null,
+            };
+        }
+        // Apply modified input if provided
+        if (hookResult.modified_input) {
+            Object.assign(toolUse.input, hookResult.modified_input);
+        }
+    }
+    // Execute tool
+    try {
+        const handlerResult = await tool.handler(toolUse.input, {
+            workingDirectory,
+            permissionMode,
+            abortSignal: signal,
+        });
+        // Execute PostToolUse hooks
+        let finalContent = handlerResult.content;
+        if (hookManager) {
+            const hookResult = await hookManager.execute("PostToolUse", {
+                tool_name: tool.name,
+                tool_input: toolUse.input,
+                tool_result: handlerResult,
+                tool_result_is_error: handlerResult.is_error,
+                session_id: sessionId,
+            });
+            if (hookResult.decision === "deny" || hookResult.decision === "block") {
+                return {
+                    toolUseId: toolUse.id,
+                    result: {
+                        type: "tool_result",
+                        tool_use_id: toolUse.id,
+                        content: hookResult.reason || `Tool "${tool.name}" result blocked by hook`,
+                        is_error: true,
+                    },
+                    toolResult: null,
+                };
+            }
+            // Apply modified output if provided
+            if (hookResult.modified_input?.tool_result) {
+                finalContent = hookResult.modified_input.tool_result;
+            }
+        }
+        return {
+            toolUseId: toolUse.id,
+            result: {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: finalContent,
+                is_error: handlerResult.is_error,
+            },
+            toolResult: {
+                id: toolUse.id,
+                result: { ...handlerResult, content: finalContent },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Execute PostToolUseFailure hooks
+        if (hookManager) {
+            await hookManager.execute("PostToolUseFailure", {
+                tool_name: tool.name,
+                tool_input: toolUse.input,
+                error: errorMessage,
+                session_id: sessionId,
+            });
+        }
+        return {
+            toolUseId: toolUse.id,
+            result: {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: `Error: ${errorMessage}`,
+                is_error: true,
+            },
+            toolResult: null,
+        };
+    }
+}
+/**
+ * Execute multiple tools in parallel and collect results
+ */
+export async function executeTools(toolUseBlocks, options) {
+    // Check for abort before starting parallel execution
+    if (options.signal?.aborted) {
+        return [];
+    }
+    // Map each tool use to an async operation
+    const toolExecutions = toolUseBlocks.map((toolUse) => executeSingleTool(toolUse, options));
+    // Execute all tools in parallel
+    const executionResults = await Promise.all(toolExecutions);
+    // Collect results and notify callbacks
+    const toolResults = [];
+    for (const executionResult of executionResults) {
+        toolResults.push(executionResult.result);
+        if (executionResult.toolResult && options.onToolResult) {
+            options.onToolResult(executionResult.toolResult);
+        }
+    }
+    return toolResults;
+}

package/dist/core/agent-loop/turn-executor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Turn Executor - Single turn execution logic
+ */
+import type { ToolDefinition, StopReason, PermissionMode } from "../../types/index.js";
+import type { PermissionManager } from "../permissions.js";
+import type { HookManager } from "../../ecosystem/hooks/index.js";
+import type { LoopState } from "./loop-state.js";
+/**
+ * Options for turn execution
+ */
+export interface TurnExecutorOptions {
+    apiKey: string;
+    model: string;
+    maxTokens: number;
+    systemPrompt: string;
+    tools: ToolDefinition[];
+    cacheConfig: import("../../types/index.js").CacheConfig;
+    thinking?: import("../../types/index.js").ThinkingConfig;
+    extendedThinking?: import("../../types/index.js").ExtendedThinkingConfig;
+    workingDirectory: string;
+    gitStatus: import("../../types/index.js").GitStatus | null;
+    reminderConfig: import("../system-reminders.js").SystemReminderConfig;
+    hookManager?: HookManager;
+    sessionId?: string;
+    signal?: AbortSignal;
+    onText?: (text: string) => void;
+    onThinking?: (thinking: string) => void;
+    onToolUse?: (toolUse: {
+        id: string;
+        name: string;
+        input: unknown;
+    }) => void;
+    onReminder?: (reminder: string) => void;
+    permissionMode: PermissionMode;
+    permissionManager: PermissionManager;
+    onMetrics?: (metrics: import("../../types/index.js").QueryMetrics) => void;
+    onToolResult?: (result: {
+        id: string;
+        result: import("../../types/index.js").ToolResult;
+    }) => void;
+}
+/**
+ * Result of executing a turn
+ */
+export interface ExecuteTurnResult {
+    /** Whether the loop should continue */
+    shouldContinue: boolean;
+    /** Stop reason if the loop should stop */
+    stopReason?: StopReason;
+    /** The metrics from this turn (if any) */
+    metrics?: import("../../types/index.js").QueryMetrics;
+}
+/**
+ * Execute a single turn of the agent loop
+ */
+export declare function executeTurn(state: LoopState, options: TurnExecutorOptions): Promise<ExecuteTurnResult>;
+//# sourceMappingURL=turn-executor.d.ts.map

package/dist/core/agent-loop/turn-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-executor.d.ts","sourceRoot":"","sources":["../../../packages/src/core/agent-loop/turn-executor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,cAAc,EAGd,UAAU,EACV,cAAc,EACf,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,WAAW,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;IACxD,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,cAAc,CAAC;IACzD,gBAAgB,CAAC,EAAE,OAAO,sBAAsB,EAAE,sBAAsB,CAAC;IACzE,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,OAAO,sBAAsB,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3D,cAAc,EAAE,OAAO,wBAAwB,EAAE,oBAAoB,CAAC;IACtE,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC5E,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,sBAAsB,EAAE,YAAY,KAAK,IAAI,CAAC;IAC3E,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,UAAU,CAAA;KAAE,KAAK,IAAI,CAAC;CACpG;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,cAAc,EAAE,OAAO,CAAC;IACxB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,OAAO,sBAAsB,EAAE,YAAY,CAAC;CACvD;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA2J5B"}

package/dist/core/agent-loop/turn-executor.js

@@ -0,0 +1,124 @@
+/**
+ * Turn Executor - Single turn execution logic
+ */
+import { createMessageStream } from "../api-client.js";
+import { buildCombinedReminder } from "../system-reminders.js";
+import { buildAPIMessages } from "./message-builder.js";
+import { handleProactiveCompaction, handleReactiveCompaction, DEFAULT_PROACTIVE_OPTIONS, DEFAULT_REACTIVE_OPTIONS } from "./compaction.js";
+import { executeTools } from "./tool-executor.js";
+/**
+ * Execute a single turn of the agent loop
+ */
+export async function executeTurn(state, options) {
+    const { apiKey, model, maxTokens, systemPrompt, tools, cacheConfig, thinking, extendedThinking, workingDirectory, gitStatus, reminderConfig, hookManager, sessionId, signal, onText, onThinking, onToolUse, onReminder, permissionMode, permissionManager, onToolResult, } = options;
+    // Increment turn counter
+    state.incrementTurn();
+    const turnNumber = state.turnNumber;
+    // Build system reminder for this turn
+    const reminder = buildCombinedReminder({
+        usage: state.currentUsage,
+        maxTokens,
+        totalCost: state.totalCost,
+        previousCost: state.previousCost,
+        toolsUsed: state.allToolsUsed,
+        workingDirectory,
+        gitStatus,
+        turnNumber,
+        config: reminderConfig,
+    });
+    if (reminder) {
+        onReminder?.(reminder);
+    }
+    // Proactive compaction check - compact BEFORE hitting the limit
+    await handleProactiveCompaction(state, maxTokens, DEFAULT_PROACTIVE_OPTIONS);
+    // Build API messages with system reminders
+    const apiMessages = buildAPIMessages(state.messages, systemPrompt, reminder);
+    // Create streaming request
+    const streamResult = await createMessageStream(apiMessages, {
+        apiKey,
+        model,
+        maxTokens,
+        systemPrompt,
+        cacheConfig,
+        thinking,
+        extendedThinking,
+        tools: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.input_schema,
+        })),
+        onToken: onText,
+        onThinking,
+        onToolUse,
+        signal,
+    });
+    const { message, usage, cacheMetrics, costUSD, durationMs, ttftMs } = streamResult;
+    // Track metrics
+    const queryMetrics = state.addTurnResult({
+        message,
+        usage,
+        cacheMetrics,
+        costUSD,
+        durationMs,
+        model,
+        messageCount: state.messages.length,
+    });
+    // Add assistant message to history
+    state.addAssistantMessage(message.content);
+    // Check stop reason
+    if (message.stop_reason === "end_turn" || message.stop_reason === "stop_sequence") {
+        return {
+            shouldContinue: false,
+            stopReason: message.stop_reason,
+            metrics: queryMetrics,
+        };
+    }
+    if (message.stop_reason === "max_tokens") {
+        // Context window limit reached - compact and continue
+        const compacted = await handleReactiveCompaction(state, maxTokens, DEFAULT_REACTIVE_OPTIONS);
+        if (compacted) {
+            // Continue the loop with compacted context
+            return {
+                shouldContinue: true,
+                metrics: queryMetrics,
+            };
+        }
+        else {
+            // Could not compact further or compaction didn't help, must stop
+            return {
+                shouldContinue: false,
+                stopReason: "max_tokens",
+                metrics: queryMetrics,
+            };
+        }
+    }
+    // Handle tool use
+    const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
+    // Track all tools used for summary
+    state.trackToolUse(toolUseBlocks);
+    if (toolUseBlocks.length === 0) {
+        return {
+            shouldContinue: false,
+            metrics: queryMetrics,
+        };
+    }
+    // Execute tools in parallel and collect results
+    const toolExecutionOptions = {
+        tools,
+        workingDirectory,
+        permissionMode,
+        hookManager,
+        sessionId,
+        signal,
+        permissionManager,
+        onToolResult,
+    };
+    const toolResults = await executeTools(toolUseBlocks, toolExecutionOptions);
+    // Add tool results as user message
+    state.addUserMessage(toolResults);
+    // Continue loop to process tool results
+    return {
+        shouldContinue: true,
+        metrics: queryMetrics,
+    };
+}