@claudebuddy/claudebuddy-agent-sdk 0.4.0 → 0.5.0

package/dist/engine.d.ts

@@ -17,11 +17,14 @@ export declare class QueryEngine {
     private config;
     private provider;
     messages: NormalizedMessageParam[];
-    private totalUsage;
-    private totalCost;
+    private ledger;
+    private initialUsage;
+    private initialCost;
+    private initialModelUsage;
     private turnCount;
     private compactState;
     private sessionId;
+    private taskGroup;
     private apiTimeMs;
     private hookRegistry?;
     private spillStore?;
@@ -36,10 +39,11 @@ export declare class QueryEngine {
      * Yields SDKMessage events as the agent works.
      */
     submitMessage(prompt: string | any[]): AsyncGenerator<SDKMessage>;
+    private chargeUsage;
     /**
      * Execute tool calls with concurrency control.
      *
-     * Read-only tools run concurrently (up to 10 at a time).
+     * Adjacent explicitly concurrency-safe read-only tools run concurrently (up to 10).
      * Mutation tools run sequentially.
      */
     private executeTools;

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EAIjB,UAAU,EACX,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAGV,sBAAsB,EAEvB,MAAM,sBAAsB,CAAA;AAwH7B,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAa;IACtB,QAAQ,EAAE,sBAAsB,EAAE,CAAK;IAC9C,OAAO,CAAC,UAAU,CAAoD;IACtE,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,UAAU,CAAC,CAAY;gBAEnB,MAAM,EAAE,iBAAiB;IAWrC;;;OAGG;YACW,YAAY;IAiB1B;;;OAGG;IACI,aAAa,CAClB,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,GACrB,cAAc,CAAC,UAAU,CAAC;IAkR7B;;;;;OAKG;YACW,YAAY;IAkD1B;;;;;OAKG;YACW,mBAAmB;IAiDjC;;OAEG;YACW,iBAAiB;IAuG/B;;OAEG;IACH,WAAW,IAAI,sBAAsB,EAAE;IAIvC;;OAEG;IACH,QAAQ,IAAI,UAAU;IAItB;;OAEG;IACH,OAAO,IAAI,MAAM;CAGlB"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EAIjB,UAAU,EAEX,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAGV,sBAAsB,EAEvB,MAAM,sBAAsB,CAAA;AAqH7B,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAa;IACtB,QAAQ,EAAE,sBAAsB,EAAE,CAAK;IAC9C,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,iBAAiB,CAAiC;IAC1D,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,UAAU,CAAC,CAAY;gBAEnB,MAAM,EAAE,iBAAiB;IAgBrC;;;OAGG;YACW,YAAY;IAiB1B;;;OAGG;IACI,aAAa,CAClB,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,GACrB,cAAc,CAAC,UAAU,CAAC;IAoJ7B,OAAO,CAAC,WAAW;IAYnB;;;;;OAKG;YACW,YAAY;IAoD1B;;;;;OAKG;YACW,mBAAmB;IAiDjC;;OAEG;YACW,iBAAiB;IA6G/B;;OAEG;IACH,WAAW,IAAI,sBAAsB,EAAE;IAIvC;;OAEG;IACH,QAAQ,IAAI,UAAU;IAQtB;;OAEG;IACH,OAAO,IAAI,MAAM;CAGlB"}

package/dist/engine.js

@@ -11,6 +11,7 @@
  * 7. Auto-compact when context exceeds threshold
  * 8. Retry with exponential backoff on transient errors
  */
+import { settleTaskGroup } from './tools/task-tools.js';
 import { estimateCost, } from './utils/tokens.js';
 import { shouldAutoCompact, compactConversation, microCompactMessages, createAutoCompactState, } from './utils/compact.js';
 import { withRetry, isPromptTooLongError, } from './utils/retry.js';
@@ -88,16 +89,24 @@ export class QueryEngine {
     config;
     provider;
     messages = [];
-    totalUsage = { input_tokens: 0, output_tokens: 0 };
-    totalCost = 0;
+    ledger;
+    initialUsage;
+    initialCost;
+    initialModelUsage = {};
     turnCount = 0;
     compactState;
     sessionId;
+    taskGroup = new Set();
     apiTimeMs = 0;
     hookRegistry;
     spillStore;
     constructor(config) {
+        config.tools = config.tools.filter(tool => tool.isEnabled?.() !== false);
         this.config = config;
+        this.ledger = config.executionBudget ?? { cost: 0, usage: { input_tokens: 0, output_tokens: 0 } };
+        this.initialUsage = { ...this.ledger.usage };
+        this.initialCost = this.ledger.cost;
+        config.sessionState ??= new Map();
         this.provider = config.provider;
         this.compactState = createAutoCompactState();
         this.sessionId = config.sessionId || crypto.randomUUID();
@@ -130,258 +139,246 @@ export class QueryEngine {
      * Yields SDKMessage events as the agent works.
      */
     async *submitMessage(prompt) {
-        // Hook: SessionStart
-        await this.executeHooks('SessionStart');
-        // Hook: UserPromptSubmit
-        const userHookResults = await this.executeHooks('UserPromptSubmit', {
-            toolInput: prompt,
-        });
-        // Check if any hook blocks the submission
-        if (userHookResults.some((r) => r.block)) {
+        this.initialUsage = { ...this.ledger.usage };
+        this.initialCost = this.ledger.cost;
+        this.initialModelUsage = Object.fromEntries(Object.entries(this.ledger.modelUsage ?? {}).map(([model, usage]) => [model, { ...usage }]));
+        this.turnCount = 0;
+        this.apiTimeMs = 0;
+        this.taskGroup.clear();
+        let backgroundTasks = [];
+        let status = 'error_max_turns';
+        let errors;
+        let pendingTools = [];
+        const atBudget = () => this.config.maxBudgetUsd !== undefined && this.ledger.cost >= this.config.maxBudgetUsd;
+        const compact = async () => {
+            this.config.abortSignal?.throwIfAborted();
+            await this.executeHooks('PreCompact');
+            this.config.abortSignal?.throwIfAborted();
+            const result = await compactConversation(this.provider, this.config.model, this.messages, this.compactState, {
+                signal: this.config.abortSignal,
+                onUsage: usage => this.chargeUsage(usage),
+            });
+            this.messages = result.compactedMessages;
+            this.compactState = result.state;
+            if (result.success)
+                await this.executeHooks('PostCompact');
+            return result.success;
+        };
+        try {
+            await this.executeHooks('SessionStart');
+            this.config.abortSignal?.throwIfAborted();
+            const userHookResults = await this.executeHooks('UserPromptSubmit', { toolInput: prompt });
+            if (userHookResults.some(r => r.block))
+                throw new Error('Blocked by UserPromptSubmit hook');
+            this.messages.push({ role: 'user', content: prompt });
+            const tools = this.config.tools.map(toProviderTool);
+            const systemPrompt = await buildSystemPrompt(this.config);
             yield {
-                type: 'result',
-                subtype: 'error_during_execution',
-                is_error: true,
-                usage: this.totalUsage,
-                num_turns: 0,
-                cost: 0,
-                errors: ['Blocked by UserPromptSubmit hook'],
+                type: 'system', subtype: 'init', session_id: this.sessionId,
+                tools: this.config.tools.map(t => t.name), model: this.config.model,
+                cwd: this.config.cwd, mcp_servers: [], permission_mode: this.config.permissionMode ?? 'bypassPermissions',
             };
-            return;
-        }
-        // Add user message
-        this.messages.push({ role: 'user', content: prompt });
-        // Build tool definitions for provider
-        const tools = this.config.tools.map(toProviderTool);
-        // Build system prompt
-        const systemPrompt = await buildSystemPrompt(this.config);
-        // Emit init system message
-        yield {
-            type: 'system',
-            subtype: 'init',
-            session_id: this.sessionId,
-            tools: this.config.tools.map(t => t.name),
-            model: this.config.model,
-            cwd: this.config.cwd,
-            mcp_servers: [],
-            permission_mode: 'bypassPermissions',
-        };
-        // Agentic loop
-        let turnsRemaining = this.config.maxTurns;
-        let budgetExceeded = false;
-        let maxOutputRecoveryAttempts = 0;
-        const MAX_OUTPUT_RECOVERY = 3;
-        while (turnsRemaining > 0) {
-            if (this.config.abortSignal?.aborted)
-                break;
-            // Check budget
-            if (this.config.maxBudgetUsd && this.totalCost >= this.config.maxBudgetUsd) {
-                budgetExceeded = true;
-                break;
-            }
-            // Auto-compact if context is too large
-            if (shouldAutoCompact(this.messages, this.config.model, this.compactState, this.config.contextWindowSize)) {
-                await this.executeHooks('PreCompact');
-                try {
-                    const result = await compactConversation(this.provider, this.config.model, this.messages, this.compactState);
-                    this.messages = result.compactedMessages;
-                    this.compactState = result.state;
-                    await this.executeHooks('PostCompact');
+            let recoveryAttempts = 0;
+            let outputRecoveryAttempts = 0;
+            while (this.turnCount < this.config.maxTurns) {
+                this.config.abortSignal?.throwIfAborted();
+                if (atBudget()) {
+                    status = 'error_max_budget_usd';
+                    break;
                 }
-                catch {
-                    // Continue with uncompacted messages
+                if (shouldAutoCompact(this.messages, this.config.model, this.compactState, this.config.contextWindowSize)) {
+                    await compact();
                 }
-            }
-            // Micro-compact: truncate large tool results
-            const apiMessages = microCompactMessages(normalizeMessagesForAPI(this.messages));
-            this.turnCount++;
-            turnsRemaining--;
-            // Make API call with retry via provider
-            let response;
-            const apiStart = performance.now();
-            try {
-                response = await withRetry(async () => {
-                    return this.provider.createMessage({
-                        model: this.config.model,
-                        maxTokens: this.config.maxTokens,
-                        system: systemPrompt,
-                        messages: apiMessages,
-                        tools: tools.length > 0 ? tools : undefined,
-                        thinking: this.config.thinking?.type === 'enabled' &&
-                            this.config.thinking.budgetTokens
-                            ? {
-                                type: 'enabled',
-                                budget_tokens: this.config.thinking.budgetTokens,
+                this.config.abortSignal?.throwIfAborted();
+                if (atBudget()) {
+                    status = 'error_max_budget_usd';
+                    break;
+                }
+                const apiMessages = microCompactMessages(normalizeMessagesForAPI(this.messages));
+                this.turnCount++;
+                let response;
+                let emittedPartial = false;
+                const apiStart = performance.now();
+                try {
+                    const request = {
+                        signal: this.config.abortSignal,
+                        model: this.config.model, maxTokens: this.config.maxTokens,
+                        system: systemPrompt, messages: apiMessages,
+                        tools: tools.length ? tools : undefined,
+                        thinking: this.config.thinking?.type === 'enabled' && this.config.thinking.budgetTokens
+                            ? { type: 'enabled', budget_tokens: this.config.thinking.budgetTokens } : undefined,
+                    };
+                    if (this.config.includePartialMessages && this.provider.streamMessage) {
+                        let complete;
+                        for await (const event of this.provider.streamMessage(request)) {
+                            this.config.abortSignal?.throwIfAborted();
+                            if (event.type === 'response')
+                                complete = event.response;
+                            else {
+                                emittedPartial = true;
+                                yield { type: 'partial_message', partial: event };
                             }
-                            : undefined,
-                    });
-                }, undefined, this.config.abortSignal);
-            }
-            catch (err) {
-                // Handle prompt-too-long by compacting
-                if (isPromptTooLongError(err) && !this.compactState.compacted) {
-                    try {
-                        const result = await compactConversation(this.provider, this.config.model, this.messages, this.compactState);
-                        this.messages = result.compactedMessages;
-                        this.compactState = result.state;
-                        turnsRemaining++; // Retry this turn
-                        this.turnCount--;
-                        continue;
+                        }
+                        if (!complete)
+                            throw new Error('Stream ended without a complete response');
+                        response = complete;
                     }
-                    catch {
-                        // Can't compact, give up
+                    else {
+                        response = await withRetry(() => this.provider.createMessage(request), undefined, this.config.abortSignal);
                     }
                 }
-                const message = err?.message ? String(err.message) : String(err);
-                yield {
-                    type: 'result',
-                    subtype: 'error',
-                    usage: this.totalUsage,
-                    num_turns: this.turnCount,
-                    cost: this.totalCost,
-                    errors: [message],
-                };
-                return;
-            }
-            // Track API timing
-            this.apiTimeMs += performance.now() - apiStart;
-            // Track usage (normalized by provider)
-            if (response.usage) {
-                this.totalUsage.input_tokens += response.usage.input_tokens;
-                this.totalUsage.output_tokens += response.usage.output_tokens;
-                if (response.usage.cache_creation_input_tokens) {
-                    this.totalUsage.cache_creation_input_tokens =
-                        (this.totalUsage.cache_creation_input_tokens || 0) +
-                            response.usage.cache_creation_input_tokens;
+                catch (err) {
+                    this.config.abortSignal?.throwIfAborted();
+                    if (!emittedPartial && isPromptTooLongError(err) && recoveryAttempts < 1 && !atBudget()) {
+                        recoveryAttempts++;
+                        if (await compact()) {
+                            this.turnCount--;
+                            continue;
+                        }
+                    }
+                    throw err;
                 }
-                if (response.usage.cache_read_input_tokens) {
-                    this.totalUsage.cache_read_input_tokens =
-                        (this.totalUsage.cache_read_input_tokens || 0) +
-                            response.usage.cache_read_input_tokens;
+                finally {
+                    this.apiTimeMs += performance.now() - apiStart;
+                }
+                if (response.usage)
+                    this.chargeUsage(response.usage);
+                this.config.abortSignal?.throwIfAborted();
+                this.messages.push({ role: 'assistant', content: response.content });
+                pendingTools = response.content.filter((block) => block.type === 'tool_use');
+                yield { type: 'assistant', message: { role: 'assistant', content: response.content } };
+                this.config.abortSignal?.throwIfAborted();
+                if (pendingTools.length) {
+                    if (response.stopReason === 'max_tokens')
+                        throw new Error('Tool response was truncated before completion');
+                    outputRecoveryAttempts = 0;
+                    const results = await this.executeTools(pendingTools);
+                    const spilled = this.spillStore ? await this.applySpillToResults(results) : results;
+                    // Persist all results before yielding so an early consumer exit preserves valid history.
+                    this.messages.push({ role: 'user', content: spilled.map(r => ({
+                            type: 'tool_result', tool_use_id: r.tool_use_id,
+                            content: typeof r.content === 'string' ? r.content : JSON.stringify(r.content), is_error: r.is_error,
+                        })) });
+                    pendingTools = [];
+                    for (const r of spilled)
+                        yield { type: 'tool_result', result: {
+                                tool_use_id: r.tool_use_id, tool_name: r.tool_name ?? '',
+                                output: typeof r.content === 'string' ? r.content : JSON.stringify(r.content),
+                            } };
+                    this.config.abortSignal?.throwIfAborted();
+                }
+                else if (response.stopReason === 'max_tokens') {
+                    if (outputRecoveryAttempts++ >= 3) {
+                        status = 'error_during_execution';
+                        errors = ['Maximum output recovery attempts exceeded'];
+                        break;
+                    }
+                    this.messages.push({ role: 'user', content: 'Please continue from where you left off.' });
+                }
+                else {
+                    status = 'success';
+                    break;
                 }
-                this.totalCost += estimateCost(this.config.model, response.usage, this.config.pricingPerMillion);
-            }
-            // Add assistant message to conversation
-            this.messages.push({ role: 'assistant', content: response.content });
-            // Yield assistant message
-            yield {
-                type: 'assistant',
-                message: {
-                    role: 'assistant',
-                    content: response.content,
-                },
-            };
-            // Handle max_output_tokens recovery
-            if (response.stopReason === 'max_tokens' &&
-                maxOutputRecoveryAttempts < MAX_OUTPUT_RECOVERY) {
-                maxOutputRecoveryAttempts++;
-                // Add continuation prompt
-                this.messages.push({
-                    role: 'user',
-                    content: 'Please continue from where you left off.',
-                });
-                continue;
             }
-            // Check for tool use
-            const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
-            if (toolUseBlocks.length === 0) {
-                break; // No tool calls - agent is done
+            this.config.abortSignal?.throwIfAborted();
+            if (status === 'error_max_turns' && atBudget())
+                status = 'error_max_budget_usd';
+        }
+        catch (err) {
+            status = this.config.abortSignal?.aborted ? 'cancelled' : 'error_during_execution';
+            errors = [err?.message ? String(err.message) : String(err)];
+        }
+        finally {
+            if (pendingTools.length) {
+                this.messages.push({ role: 'user', content: pendingTools.map(block => ({
+                        type: 'tool_result', tool_use_id: block.id,
+                        content: 'Tool execution interrupted before a result was recorded.', is_error: true,
+                    })) });
             }
-            // Reset max_output recovery counter on successful tool use
-            maxOutputRecoveryAttempts = 0;
-            // Execute tools (concurrent read-only, serial mutations)
-            const toolResults = await this.executeTools(toolUseBlocks);
-            // Apply spill policy to large tool results before they enter context.
-            const spilled = this.spillStore ? await this.applySpillToResults(toolResults) : toolResults;
-            // Yield tool results
-            for (const result of spilled) {
-                yield {
-                    type: 'tool_result',
-                    result: {
-                        tool_use_id: result.tool_use_id,
-                        tool_name: result.tool_name || '',
-                        output: typeof result.content === 'string'
-                            ? result.content
-                            : JSON.stringify(result.content),
-                    },
-                };
+            backgroundTasks = await settleTaskGroup(this.taskGroup, this.config.sessionState, status !== 'success');
+            if (this.config.abortSignal?.aborted) {
+                status = 'cancelled';
+                errors = ['Run cancelled'];
             }
-            // Add tool results to conversation
-            this.messages.push({
-                role: 'user',
-                content: spilled.map((r) => ({
-                    type: 'tool_result',
-                    tool_use_id: r.tool_use_id,
-                    content: typeof r.content === 'string'
-                        ? r.content
-                        : JSON.stringify(r.content),
-                    is_error: r.is_error,
-                })),
-            });
-            if (response.stopReason === 'end_turn')
-                break;
+            await this.executeHooks('Stop');
+            await this.executeHooks('SessionEnd');
         }
-        // Hook: Stop (end of agentic loop)
-        await this.executeHooks('Stop');
-        // Hook: SessionEnd
-        await this.executeHooks('SessionEnd');
-        // Yield enriched final result
-        const endSubtype = budgetExceeded
-            ? 'error_max_budget_usd'
-            : turnsRemaining <= 0
-                ? 'error_max_turns'
-                : 'success';
+        for (const task of backgroundTasks)
+            yield { type: 'system', subtype: 'task_notification', task_id: task.id, status: task.status, message: task.output };
+        const usage = this.getUsage();
+        const cost = this.getCost();
+        const modelUsage = Object.fromEntries(Object.entries(this.ledger.modelUsage ?? {}).map(([model, value]) => [model, {
+                input_tokens: value.input_tokens - (this.initialModelUsage[model]?.input_tokens ?? 0),
+                output_tokens: value.output_tokens - (this.initialModelUsage[model]?.output_tokens ?? 0),
+            }]));
         yield {
-            type: 'result',
-            subtype: endSubtype,
-            session_id: this.sessionId,
-            is_error: endSubtype !== 'success',
-            num_turns: this.turnCount,
-            total_cost_usd: this.totalCost,
-            duration_api_ms: Math.round(this.apiTimeMs),
-            usage: this.totalUsage,
-            model_usage: { [this.config.model]: { input_tokens: this.totalUsage.input_tokens, output_tokens: this.totalUsage.output_tokens } },
-            cost: this.totalCost,
+            type: 'result', subtype: status, session_id: this.sessionId,
+            is_error: status !== 'success', errors, num_turns: this.turnCount,
+            total_cost_usd: cost, cost, usage, duration_api_ms: Math.round(this.apiTimeMs),
+            model_usage: modelUsage,
         };
     }
+    chargeUsage(usage) {
+        this.ledger.modelUsage ??= {};
+        const modelUsage = this.ledger.modelUsage[this.config.model] ??= { input_tokens: 0, output_tokens: 0 };
+        for (const key of ['input_tokens', 'output_tokens', 'cache_creation_input_tokens', 'cache_read_input_tokens']) {
+            if (usage[key] !== undefined) {
+                this.ledger.usage[key] = (this.ledger.usage[key] ?? 0) + usage[key];
+                modelUsage[key] = (modelUsage[key] ?? 0) + usage[key];
+            }
+        }
+        this.ledger.cost += estimateCost(this.config.model, usage, this.config.pricingPerMillion);
+    }
     /**
      * Execute tool calls with concurrency control.
      *
-     * Read-only tools run concurrently (up to 10 at a time).
+     * Adjacent explicitly concurrency-safe read-only tools run concurrently (up to 10).
      * Mutation tools run sequentially.
      */
     async executeTools(toolUseBlocks) {
         const context = {
+            taskGroup: this.taskGroup,
             cwd: this.config.cwd,
             abortSignal: this.config.abortSignal,
             provider: this.provider,
             model: this.config.model,
             apiType: this.provider.apiType,
+            sessionState: this.config.sessionState,
+            tools: this.config.tools,
+            agents: this.config.agents,
+            canUseTool: this.config.canUseTool,
+            executionBudget: this.ledger,
+            maxBudgetUsd: this.config.maxBudgetUsd,
+            pricingPerMillion: this.config.pricingPerMillion,
+            hookRegistry: this.hookRegistry,
+            sessionId: this.sessionId,
         };
-        const MAX_CONCURRENCY = parseInt(process.env.AGENT_SDK_MAX_TOOL_CONCURRENCY || '10');
-        // Partition into read-only (concurrent) and mutation (serial)
-        const readOnly = [];
-        const mutations = [];
-        for (const block of toolUseBlocks) {
-            const tool = this.config.tools.find((t) => t.name === block.name);
-            if (tool?.isReadOnly?.()) {
-                readOnly.push({ block, tool });
+        const configuredConcurrency = Number(process.env.AGENT_SDK_MAX_TOOL_CONCURRENCY ?? 10);
+        const MAX_CONCURRENCY = Number.isFinite(configuredConcurrency) && configuredConcurrency >= 1
+            ? Math.floor(configuredConcurrency) : 10;
+        const results = [];
+        // Mutations and tools without an explicit concurrency guarantee are barriers.
+        // Parallelize only adjacent safe reads; never move a read before an earlier write.
+        for (let i = 0; i < toolUseBlocks.length;) {
+            this.config.abortSignal?.throwIfAborted();
+            const block = toolUseBlocks[i];
+            const tool = this.config.tools.find(t => t.name === block.name);
+            const safe = (t) => t?.isReadOnly?.() === true && t.isConcurrencySafe?.() === true;
+            if (!safe(tool)) {
+                results.push(await this.executeSingleTool(block, tool, context));
+                i++;
+                continue;
             }
-            else {
-                mutations.push({ block, tool });
+            const batch = [];
+            while (i < toolUseBlocks.length && batch.length < MAX_CONCURRENCY) {
+                const next = toolUseBlocks[i];
+                const nextTool = this.config.tools.find(t => t.name === next.name);
+                if (!safe(nextTool))
+                    break;
+                batch.push({ block: next, tool: nextTool });
+                i++;
             }
-        }
-        const results = [];
-        // Execute read-only tools concurrently (batched by MAX_CONCURRENCY)
-        for (let i = 0; i < readOnly.length; i += MAX_CONCURRENCY) {
-            const batch = readOnly.slice(i, i + MAX_CONCURRENCY);
-            const batchResults = await Promise.all(batch.map((item) => this.executeSingleTool(item.block, item.tool, context)));
-            results.push(...batchResults);
-        }
-        // Execute mutation tools sequentially
-        for (const item of mutations) {
-            const result = await this.executeSingleTool(item.block, item.tool, context);
-            results.push(result);
+            results.push(...await Promise.all(batch.map(item => this.executeSingleTool(item.block, item.tool, context))));
         }
         return results;
     }
@@ -438,6 +435,10 @@ export class QueryEngine {
      * Execute a single tool with permission checking.
      */
     async executeSingleTool(block, tool, context) {
+        const cancelled = () => ({ type: 'tool_result', tool_use_id: block.id,
+            content: 'Tool execution cancelled', is_error: true, tool_name: block.name });
+        if (context.abortSignal?.aborted)
+            return cancelled();
         if (!tool) {
             return {
                 type: 'tool_result',
@@ -484,6 +485,8 @@ export class QueryEngine {
                 };
             }
         }
+        if (context.abortSignal?.aborted)
+            return cancelled();
         // Hook: PreToolUse
         const preHookResults = await this.executeHooks('PreToolUse', {
             toolName: block.name,
@@ -503,6 +506,8 @@ export class QueryEngine {
         }
         // Execute the tool
         try {
+            if (context.abortSignal?.aborted)
+                return cancelled();
             const result = await tool.call(block.input, context);
             // Hook: PostToolUse
             await this.executeHooks('PostToolUse', {
@@ -540,13 +545,18 @@ export class QueryEngine {
      * Get total usage across all turns.
      */
     getUsage() {
-        return { ...this.totalUsage };
+        const usage = { input_tokens: 0, output_tokens: 0 };
+        for (const key of ['input_tokens', 'output_tokens', 'cache_creation_input_tokens', 'cache_read_input_tokens']) {
+            if (this.ledger.usage[key] !== undefined)
+                usage[key] = (this.ledger.usage[key] ?? 0) - (this.initialUsage[key] ?? 0);
+        }
+        return usage;
     }
     /**
      * Get total cost.
      */
     getCost() {
-        return this.totalCost;
+        return this.ledger.cost - this.initialCost;
     }
 }
 //# sourceMappingURL=engine.js.map