@falai/agent 1.1.3 → 1.2.0

package/dist/core/StreamingToolExecutor.d.ts

@@ -0,0 +1,142 @@
+/**
+ * StreamingToolExecutor - Executes tools as they arrive from the LLM stream
+ * with concurrency control, abort handling, and ordered result yielding.
+ *
+ * Concurrency invariant: at any point during execution, either all executing
+ * tools have `isConcurrencySafe === true`, or exactly one tool is executing
+ * with `isConcurrencySafe === false`.
+ *
+ * Results are yielded in the original request order (the order addTool was called).
+ * Progress messages bypass result ordering and are yielded immediately.
+ */
+import type { ToolCallRequest, ToolExecutionUpdate, ToolContext, EnhancedTool } from "../types/tool";
+/** Options for the StreamingToolExecutor */
+interface StreamingToolExecutorOptions {
+    /** Maximum number of tools executing in parallel (default: 10) */
+    maxParallel?: number;
+    /** Parent abort signal — cancels 'cancel' tools, lets 'block' tools finish, stops queue */
+    signal?: AbortSignal;
+}
+/**
+ * StreamingToolExecutor manages queuing, concurrent execution, abort propagation,
+ * and ordered result yielding for tool calls arriving from an LLM stream.
+ */
+export declare class StreamingToolExecutor<TContext = unknown, TData = unknown> {
+    /** Ordered list of tracked tools (insertion order = request order) */
+    private tools;
+    /** Tool context passed to each tool handler */
+    private toolContext;
+    /** Maximum concurrent tool executions */
+    private maxParallel;
+    /** Parent abort signal */
+    private parentSignal?;
+    /** Whether the executor has been discarded (no new tools will be processed) */
+    private discarded;
+    /** Accumulated context updates from completed tools */
+    private contextUpdates;
+    /**
+     * Sibling abort controller for the current concurrent batch.
+     * When one tool in a batch fails, this aborts all siblings.
+     */
+    private siblingAbortController;
+    /**
+     * Set of tool IDs in the current concurrent batch.
+     * Reset when a new batch starts.
+     */
+    private currentBatchIds;
+    /**
+     * Deferred used to wake up getRemainingResults when state changes
+     * (tool completes, progress arrives, or executor finishes).
+     */
+    private waiter;
+    /**
+     * @param toolContext - Context provided to each tool handler during execution
+     * @param options - Optional configuration for max parallelism and abort signal
+     */
+    constructor(toolContext: ToolContext<TContext, TData>, options?: StreamingToolExecutorOptions);
+    /**
+     * Queue a tool for execution. The tool's `isConcurrencySafe` is evaluated
+     * once at queue time and cached on the TrackedTool.
+     *
+     * If the executor has been discarded, the tool is ignored.
+     */
+    addTool(toolCall: ToolCallRequest, tool: EnhancedTool<TContext, TData>): void;
+    /**
+     * Process the tool queue, starting eligible tools while maintaining
+     * the concurrency invariant.
+     *
+     * Invariant: all executing tools are concurrency-safe OR exactly one
+     * non-safe tool is executing. Additionally, the number of concurrently
+     * executing tools never exceeds `maxParallel`.
+     */
+    private processQueue;
+    /**
+     * Start a new sibling abort controller for a concurrent batch.
+     */
+    private startNewBatch;
+    /**
+     * Execute a single tool, handling result capture, progress, truncation,
+     * and error/abort propagation.
+     */
+    private executeTool;
+    /**
+     * Normalize a tool handler return value into a ToolExecutionResult.
+     */
+    private normalizeResult;
+    /**
+     * Apply per-tool maxResultSizeChars truncation to a result.
+     * If the stringified result data exceeds the limit, truncate with a notice.
+     */
+    private applyResultTruncation;
+    /**
+     * Abort sibling tools in the current concurrent batch when one tool fails.
+     * Tools with interruptBehavior 'cancel' are immediately aborted;
+     * tools with 'block' are allowed to complete.
+     */
+    private abortSiblings;
+    /**
+     * Handle parent AbortSignal firing.
+     * Cancel 'cancel' tools immediately, let 'block' tools finish,
+     * and stop processing new queued tools.
+     */
+    private handleParentAbort;
+    /**
+     * Yield completed results in original request order.
+     * Progress messages are yielded immediately regardless of order.
+     *
+     * This is a synchronous generator — it yields what's available now
+     * without waiting for pending tools.
+     */
+    getCompletedResults(): Generator<ToolExecutionUpdate<TData>>;
+    /**
+     * Async generator that yields all results (completed and pending) in
+     * original request order. Waits for pending tools to complete.
+     *
+     * Progress messages are yielded immediately as they arrive.
+     */
+    getRemainingResults(): AsyncGenerator<ToolExecutionUpdate<TData>>;
+    /**
+     * Stop processing new queued tools. Already-executing tools continue
+     * to completion based on their interruptBehavior.
+     */
+    discard(): void;
+    /**
+     * Return the accumulated context updates from all completed tools.
+     */
+    getUpdatedContext(): TContext;
+    /**
+     * Check if there are any tools that haven't completed yet.
+     */
+    hasUnfinishedTools(): boolean;
+    /**
+     * Wait for a state change (tool completion, progress, or discard).
+     * Uses a deferred promise pattern.
+     */
+    private waitForStateChange;
+    /**
+     * Notify the waiting async generator that state has changed.
+     */
+    private notifyWaiter;
+}
+export {};
+//# sourceMappingURL=StreamingToolExecutor.d.ts.map

package/dist/core/StreamingToolExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingToolExecutor.d.ts","sourceRoot":"","sources":["../../src/core/StreamingToolExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EACR,eAAe,EACf,mBAAmB,EAEnB,WAAW,EACX,YAAY,EAEf,MAAM,eAAe,CAAC;AAEvB,4CAA4C;AAC5C,UAAU,4BAA4B;IAClC,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2FAA2F;IAC3F,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB;AAuBD;;;GAGG;AACH,qBAAa,qBAAqB,CAAC,QAAQ,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO;IAClE,sEAAsE;IACtE,OAAO,CAAC,KAAK,CAAsC;IAEnD,+CAA+C;IAC/C,OAAO,CAAC,WAAW,CAA+B;IAElD,yCAAyC;IACzC,OAAO,CAAC,WAAW,CAAS;IAE5B,0BAA0B;IAC1B,OAAO,CAAC,YAAY,CAAC,CAAc;IAEnC,+EAA+E;IAC/E,OAAO,CAAC,SAAS,CAAS;IAE1B,uDAAuD;IACvD,OAAO,CAAC,cAAc,CAAyB;IAE/C;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CAAgC;IAE9D;;;OAGG;IACH,OAAO,CAAC,eAAe,CAA0B;IAEjD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAA+B;IAE7C;;;OAGG;gBAEC,WAAW,EAAE,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,EACzC,OAAO,CAAC,EAAE,4BAA4B;IAY1C;;;;;OAKG;IACH,OAAO,CACH,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC,GACpC,IAAI;IA8BP;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IAiDpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAKrB;;;OAGG;YACW,WAAW;IA2FzB;;OAEG;IACH,OAAO,CAAC,eAAe;IA8BvB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgC7B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAerB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;;;;;OAMG;IACF,mBAAmB,IAAI,SAAS,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IA+B7D;;;;;OAKG;IACI,mBAAmB,IAAI,cAAc,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAiDxE;;;OAGG;IACH,OAAO,IAAI,IAAI;IAMf;;OAEG;IACH,iBAAiB,IAAI,QAAQ;IAO7B;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAM7B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;IACH,OAAO,CAAC,YAAY;CAOvB"}

package/dist/core/StreamingToolExecutor.js

@@ -0,0 +1,448 @@
+/**
+ * StreamingToolExecutor - Executes tools as they arrive from the LLM stream
+ * with concurrency control, abort handling, and ordered result yielding.
+ *
+ * Concurrency invariant: at any point during execution, either all executing
+ * tools have `isConcurrencySafe === true`, or exactly one tool is executing
+ * with `isConcurrencySafe === false`.
+ *
+ * Results are yielded in the original request order (the order addTool was called).
+ * Progress messages bypass result ordering and are yielded immediately.
+ */
+import log from "loglevel";
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+/**
+ * StreamingToolExecutor manages queuing, concurrent execution, abort propagation,
+ * and ordered result yielding for tool calls arriving from an LLM stream.
+ */
+export class StreamingToolExecutor {
+    /**
+     * @param toolContext - Context provided to each tool handler during execution
+     * @param options - Optional configuration for max parallelism and abort signal
+     */
+    constructor(toolContext, options) {
+        /** Ordered list of tracked tools (insertion order = request order) */
+        this.tools = [];
+        /** Whether the executor has been discarded (no new tools will be processed) */
+        this.discarded = false;
+        /** Accumulated context updates from completed tools */
+        this.contextUpdates = {};
+        /**
+         * Sibling abort controller for the current concurrent batch.
+         * When one tool in a batch fails, this aborts all siblings.
+         */
+        this.siblingAbortController = null;
+        /**
+         * Set of tool IDs in the current concurrent batch.
+         * Reset when a new batch starts.
+         */
+        this.currentBatchIds = new Set();
+        /**
+         * Deferred used to wake up getRemainingResults when state changes
+         * (tool completes, progress arrives, or executor finishes).
+         */
+        this.waiter = null;
+        this.toolContext = toolContext;
+        this.maxParallel = options?.maxParallel ?? 10;
+        this.parentSignal = options?.signal;
+        // Listen to parent abort signal
+        if (this.parentSignal) {
+            this.parentSignal.addEventListener("abort", () => this.handleParentAbort(), { once: true });
+        }
+    }
+    /**
+     * Queue a tool for execution. The tool's `isConcurrencySafe` is evaluated
+     * once at queue time and cached on the TrackedTool.
+     *
+     * If the executor has been discarded, the tool is ignored.
+     */
+    addTool(toolCall, tool) {
+        if (this.discarded) {
+            log.warn(`[StreamingToolExecutor] Executor discarded, ignoring tool: ${toolCall.toolName}`);
+            return;
+        }
+        // Evaluate concurrency safety once at queue time (Req 2.3)
+        const isConcurrencySafe = tool.isConcurrencySafe
+            ? tool.isConcurrencySafe(toolCall.arguments)
+            : false; // Default: not concurrency-safe (Req 2.2, 10.2)
+        const tracked = {
+            id: toolCall.id,
+            toolCall,
+            tool,
+            status: "queued",
+            isConcurrencySafe,
+            results: [],
+            pendingProgress: [],
+        };
+        this.tools.push(tracked);
+        log.debug(`[StreamingToolExecutor] Queued tool ${toolCall.toolName} (id=${toolCall.id}, concurrencySafe=${isConcurrencySafe})`);
+        // Kick the queue
+        this.processQueue();
+    }
+    /**
+     * Process the tool queue, starting eligible tools while maintaining
+     * the concurrency invariant.
+     *
+     * Invariant: all executing tools are concurrency-safe OR exactly one
+     * non-safe tool is executing. Additionally, the number of concurrently
+     * executing tools never exceeds `maxParallel`.
+     */
+    processQueue() {
+        if (this.discarded)
+            return;
+        if (this.parentSignal?.aborted)
+            return;
+        for (const tool of this.tools) {
+            if (tool.status !== "queued")
+                continue;
+            const executing = this.tools.filter((t) => t.status === "executing");
+            // Enforce max parallel limit (Req 14.1, 14.2)
+            if (executing.length >= this.maxParallel) {
+                break;
+            }
+            const canExecute = executing.length === 0 ||
+                (tool.isConcurrencySafe && executing.every((t) => t.isConcurrencySafe));
+            if (canExecute) {
+                // Start a new concurrent batch if needed
+                if (executing.length === 0 || !this.currentBatchIds.has(executing[0]?.id)) {
+                    this.startNewBatch();
+                }
+                tool.status = "executing";
+                this.currentBatchIds.add(tool.id);
+                log.debug(`[StreamingToolExecutor] Starting tool ${tool.toolCall.toolName} (id=${tool.id})`);
+                tool.promise = this.executeTool(tool).finally(() => {
+                    // Re-evaluate queue after each tool completes
+                    this.processQueue();
+                    // Wake up any waiting async generator
+                    this.notifyWaiter();
+                });
+            }
+            else if (!tool.isConcurrencySafe) {
+                // Non-concurrent tool must wait — stop scanning to maintain order (Req 1.3, 1.4)
+                break;
+            }
+            // If tool is concurrency-safe but can't run (non-safe tool executing),
+            // skip it and continue scanning — but actually per the design,
+            // we should also break here since we need to maintain request order
+            // for result yielding. A concurrent-safe tool behind a non-safe tool
+            // should wait too.
+        }
+    }
+    /**
+     * Start a new sibling abort controller for a concurrent batch.
+     */
+    startNewBatch() {
+        this.siblingAbortController = new AbortController();
+        this.currentBatchIds = new Set();
+    }
+    /**
+     * Execute a single tool, handling result capture, progress, truncation,
+     * and error/abort propagation.
+     */
+    async executeTool(tracked) {
+        const { tool, toolCall } = tracked;
+        const batchAbortController = this.siblingAbortController;
+        try {
+            // Create a combined abort signal from parent + sibling
+            const toolAbortController = new AbortController();
+            const abortTool = () => {
+                const behavior = tool.interruptBehavior
+                    ? tool.interruptBehavior()
+                    : "block"; // Default: block (Req 3.4, 10.5)
+                if (behavior === "cancel") {
+                    toolAbortController.abort();
+                }
+                // 'block' tools are allowed to complete
+            };
+            // Listen to sibling abort
+            if (batchAbortController) {
+                batchAbortController.signal.addEventListener("abort", abortTool, { once: true });
+            }
+            // Listen to parent abort for this specific tool
+            const parentAbortHandler = () => abortTool();
+            if (this.parentSignal) {
+                this.parentSignal.addEventListener("abort", parentAbortHandler, { once: true });
+            }
+            // Execute the tool handler
+            const result = await tool.handler(this.toolContext, toolCall.arguments);
+            // Clean up abort listeners
+            if (batchAbortController) {
+                batchAbortController.signal.removeEventListener("abort", abortTool);
+            }
+            if (this.parentSignal) {
+                this.parentSignal.removeEventListener("abort", parentAbortHandler);
+            }
+            // Check if we were aborted during execution
+            if (toolAbortController.signal.aborted) {
+                tracked.results.push({
+                    success: false,
+                    error: "Tool execution was cancelled",
+                    metadata: { toolId: tool.id, cancelled: true },
+                });
+                tracked.status = "completed";
+                return;
+            }
+            // Normalize the result
+            const executionResult = this.normalizeResult(result, tool);
+            // Apply per-tool maxResultSizeChars truncation (Req 9.4)
+            const truncatedResult = this.applyResultTruncation(executionResult, tool);
+            tracked.results.push(truncatedResult);
+            // Accumulate context updates
+            if (truncatedResult.contextUpdate) {
+                this.contextUpdates = {
+                    ...this.contextUpdates,
+                    ...truncatedResult.contextUpdate,
+                };
+            }
+            tracked.status = "completed";
+            // If the tool failed, abort siblings in the batch (Req 3.1)
+            if (!truncatedResult.success) {
+                this.abortSiblings(tracked.id, batchAbortController);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log.error(`[StreamingToolExecutor] Tool ${toolCall.toolName} (id=${toolCall.id}) failed: ${errorMessage}`);
+            tracked.results.push({
+                success: false,
+                error: errorMessage,
+                metadata: { toolId: tool.id },
+            });
+            tracked.status = "completed";
+            // Abort siblings on failure (Req 3.1)
+            this.abortSiblings(tracked.id, batchAbortController);
+        }
+    }
+    /**
+     * Normalize a tool handler return value into a ToolExecutionResult.
+     */
+    normalizeResult(result, tool) {
+        if (result &&
+            typeof result === "object" &&
+            ("data" in result || "success" in result || "error" in result)) {
+            const r = result;
+            return {
+                success: r.success !== false,
+                data: r.data,
+                error: r.error,
+                contextUpdate: r.contextUpdate,
+                dataUpdate: r.dataUpdate,
+                metadata: {
+                    toolId: tool.id,
+                    ...r.meta,
+                },
+            };
+        }
+        return {
+            success: true,
+            data: result,
+            metadata: { toolId: tool.id },
+        };
+    }
+    /**
+     * Apply per-tool maxResultSizeChars truncation to a result.
+     * If the stringified result data exceeds the limit, truncate with a notice.
+     */
+    applyResultTruncation(result, tool) {
+        const maxChars = tool.maxResultSizeChars;
+        if (maxChars == null || maxChars <= 0 || result.data == null) {
+            return result;
+        }
+        const serialized = typeof result.data === "string"
+            ? result.data
+            : JSON.stringify(result.data);
+        if (serialized.length <= maxChars) {
+            return result;
+        }
+        const truncated = serialized.slice(0, maxChars);
+        const notice = `\n\n[Truncated: ${serialized.length} chars total, showing first ${maxChars}]`;
+        return {
+            ...result,
+            data: truncated + notice,
+            metadata: {
+                ...result.metadata,
+                truncated: true,
+                originalLength: serialized.length,
+            },
+        };
+    }
+    /**
+     * Abort sibling tools in the current concurrent batch when one tool fails.
+     * Tools with interruptBehavior 'cancel' are immediately aborted;
+     * tools with 'block' are allowed to complete.
+     */
+    abortSiblings(failedToolId, batchAbortController) {
+        if (!batchAbortController)
+            return;
+        log.warn(`[StreamingToolExecutor] Tool ${failedToolId} failed, aborting sibling tools in batch`);
+        // Fire the sibling abort signal — individual tool handlers
+        // check their interruptBehavior to decide whether to cancel or block
+        batchAbortController.abort();
+    }
+    /**
+     * Handle parent AbortSignal firing.
+     * Cancel 'cancel' tools immediately, let 'block' tools finish,
+     * and stop processing new queued tools.
+     */
+    handleParentAbort() {
+        log.warn("[StreamingToolExecutor] Parent abort signal received");
+        // Stop processing new tools
+        this.discarded = true;
+        // Abort the current batch — individual tools respect their interruptBehavior
+        if (this.siblingAbortController) {
+            this.siblingAbortController.abort();
+        }
+        // Mark remaining queued tools as completed with cancellation error
+        for (const tool of this.tools) {
+            if (tool.status === "queued") {
+                tool.results.push({
+                    success: false,
+                    error: "Execution cancelled by parent abort signal",
+                    metadata: { toolId: tool.tool.id, cancelled: true },
+                });
+                tool.status = "completed";
+            }
+        }
+        // Wake up any waiting async generator
+        this.notifyWaiter();
+    }
+    /**
+     * Yield completed results in original request order.
+     * Progress messages are yielded immediately regardless of order.
+     *
+     * This is a synchronous generator — it yields what's available now
+     * without waiting for pending tools.
+     */
+    *getCompletedResults() {
+        for (const tool of this.tools) {
+            // Always yield pending progress immediately (Req 4.1)
+            while (tool.pendingProgress.length > 0) {
+                yield {
+                    toolCallId: tool.id,
+                    progress: tool.pendingProgress.shift(),
+                };
+            }
+            if (tool.status === "yielded")
+                continue;
+            if (tool.status === "completed") {
+                tool.status = "yielded";
+                for (const result of tool.results) {
+                    yield {
+                        toolCallId: tool.id,
+                        result,
+                        contextUpdate: result.contextUpdate,
+                        dataUpdate: result.dataUpdate,
+                    };
+                }
+            }
+            else {
+                // Tool is still queued or executing — stop yielding results
+                // to maintain request order, but continue yielding progress
+                // for subsequent tools
+                break;
+            }
+        }
+    }
+    /**
+     * Async generator that yields all results (completed and pending) in
+     * original request order. Waits for pending tools to complete.
+     *
+     * Progress messages are yielded immediately as they arrive.
+     */
+    async *getRemainingResults() {
+        let yieldIndex = 0;
+        while (yieldIndex < this.tools.length || this.hasUnfinishedTools()) {
+            // Yield progress from all tools (bypass ordering)
+            for (const tool of this.tools) {
+                while (tool.pendingProgress.length > 0) {
+                    yield {
+                        toolCallId: tool.id,
+                        progress: tool.pendingProgress.shift(),
+                    };
+                }
+            }
+            // Yield completed results in order
+            while (yieldIndex < this.tools.length) {
+                const tool = this.tools[yieldIndex];
+                if (tool.status === "yielded") {
+                    yieldIndex++;
+                    continue;
+                }
+                if (tool.status === "completed") {
+                    tool.status = "yielded";
+                    for (const result of tool.results) {
+                        yield {
+                            toolCallId: tool.id,
+                            result,
+                            contextUpdate: result.contextUpdate,
+                            dataUpdate: result.dataUpdate,
+                        };
+                    }
+                    yieldIndex++;
+                }
+                else {
+                    // Tool is still queued or executing — wait for it
+                    break;
+                }
+            }
+            // If there are still unfinished tools, wait for a state change
+            if (yieldIndex < this.tools.length && this.hasUnfinishedTools()) {
+                await this.waitForStateChange();
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Stop processing new queued tools. Already-executing tools continue
+     * to completion based on their interruptBehavior.
+     */
+    discard() {
+        log.info("[StreamingToolExecutor] Executor discarded, stopping queue processing");
+        this.discarded = true;
+        this.notifyWaiter();
+    }
+    /**
+     * Return the accumulated context updates from all completed tools.
+     */
+    getUpdatedContext() {
+        return {
+            ...this.toolContext.context,
+            ...this.contextUpdates,
+        };
+    }
+    /**
+     * Check if there are any tools that haven't completed yet.
+     */
+    hasUnfinishedTools() {
+        return this.tools.some((t) => t.status === "queued" || t.status === "executing");
+    }
+    /**
+     * Wait for a state change (tool completion, progress, or discard).
+     * Uses a deferred promise pattern.
+     */
+    waitForStateChange() {
+        this.waiter = createDeferred();
+        return this.waiter.promise;
+    }
+    /**
+     * Notify the waiting async generator that state has changed.
+     */
+    notifyWaiter() {
+        if (this.waiter) {
+            const w = this.waiter;
+            this.waiter = null;
+            w.resolve();
+        }
+    }
+}
+//# sourceMappingURL=StreamingToolExecutor.js.map

package/dist/core/StreamingToolExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingToolExecutor.js","sourceRoot":"","sources":["../../src/core/StreamingToolExecutor.ts"],"names":[],"mappings":"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"}

package/dist/core/ToolManager.d.ts

@@ -1,7 +1,7 @@
 /**
  * ToolManager - Centralized tool management with simplified creation APIs
  */
-import type { Tool, ToolExecutionResult, DataEnrichmentConfig, ValidationConfig, ValidationResult, ApiCallConfig, ComputationConfig, Event } from "../types";
+import type { Tool, ToolExecutionResult, DataEnrichmentConfig, ValidationConfig, ValidationResult, ApiCallConfig, ComputationConfig, ToolCallRequest, ToolExecutionUpdate, Event } from "../types";
 import { ToolScope } from "../types";
 import { Agent } from "./Agent";
 import { Route } from "./Route";
@@ -163,6 +163,23 @@ export declare class ToolManager<TContext = unknown, TData = unknown> {
         history: Event[];
         data?: Partial<TData>;
     }): Promise<ToolExecutionResult[]>;
+    /**
+     * Execute tool calls with concurrency control using StreamingToolExecutor.
+     * Creates a StreamingToolExecutor, resolves tools, queues them, and yields
+     * ToolExecutionUpdate results in original request order.
+     *
+     * Concurrency-safe tools run in parallel; non-safe tools run serially.
+     * Progress messages are yielded immediately.
+     */
+    executeWithConcurrency(params: {
+        toolCalls: ToolCallRequest[];
+        context: TContext;
+        data?: Partial<TData>;
+        history?: Event[];
+        signal?: AbortSignal;
+        route?: Route<TContext, TData>;
+        step?: Step<TContext, TData>;
+    }): AsyncGenerator<ToolExecutionUpdate<TData>>;
     /**
      * Create a data enrichment tool that modifies collected data
      * Returns a tool instance that can be registered or added to scope