@kuralle-agents/core 0.12.0 → 0.14.0

package/dist/runtime/TraceRecorder.js

@@ -0,0 +1,326 @@
+export class TraceRecorder {
+    trace;
+    root;
+    currentFlow;
+    currentNode;
+    openTools = [];
+    toolCallIds = new Map();
+    emitted = new Set();
+    onSpan;
+    currentAgentId;
+    constructor(options = {}) {
+        const startedAt = Date.now();
+        const sessionId = options.sessionId ?? '';
+        const traceId = crypto.randomUUID().replaceAll('-', '');
+        this.onSpan = options.onSpan;
+        this.currentAgentId = options.agentId;
+        this.root = {
+            traceId,
+            spanId: newSpanId(),
+            name: 'turn',
+            kind: 'turn',
+            startTime: startedAt,
+            status: 'ok',
+            attributes: {
+                sessionId,
+                ...(options.agentId ? { agentId: options.agentId } : {}),
+                ...(options.input !== undefined ? { input: toJsonValue(options.input) } : {}),
+            },
+        };
+        this.trace = {
+            traceId,
+            sessionId,
+            spans: [this.root],
+            answer: '',
+            usedTool: false,
+            toolCalls: [],
+            toolResults: [],
+            startedAt,
+        };
+    }
+    setInitiatingAgent(agentId) {
+        this.currentAgentId = agentId;
+        this.root.attributes.agentId = agentId;
+    }
+    record(part) {
+        try {
+            const at = Date.now();
+            switch (part.type) {
+                case 'text-delta':
+                    this.trace.answer += part.payload.delta;
+                    break;
+                case 'flow-enter':
+                    this.closeNode(at);
+                    this.closeFlow(at);
+                    this.currentFlow = this.openSpan({
+                        name: `flow:${part.payload.flow}`,
+                        kind: 'flow',
+                        parentSpanId: this.root.spanId,
+                        at,
+                        attributes: { activeFlow: part.payload.flow },
+                    });
+                    break;
+                case 'flow-end':
+                    this.closeNode(at);
+                    this.closeFlow(at);
+                    break;
+                case 'node-enter':
+                    this.closeNode(at);
+                    this.currentNode = this.openSpan({
+                        name: `node:${part.payload.nodeName}`,
+                        kind: 'node',
+                        parentSpanId: this.currentFlow?.spanId ?? this.root.spanId,
+                        at,
+                        attributes: {
+                            ...(this.currentFlow ? { activeFlow: activeFlowName(this.currentFlow) } : {}),
+                            nodeId: part.payload.nodeName,
+                        },
+                    });
+                    break;
+                case 'node-exit':
+                    this.closeNode(at);
+                    break;
+                case 'tool-call': {
+                    const span = this.openSpan({
+                        name: `tool:${part.payload.toolName}`,
+                        kind: 'tool',
+                        parentSpanId: this.currentNode?.spanId ?? this.root.spanId,
+                        at,
+                        attributes: {
+                            ...(this.currentFlow ? { activeFlow: activeFlowName(this.currentFlow) } : {}),
+                            ...(this.currentNode ? { nodeId: nodeName(this.currentNode) } : {}),
+                            toolName: part.payload.toolName,
+                            input: toJsonValue(part.payload.args),
+                        },
+                    });
+                    this.toolCallIds.set(span, part.payload.toolCallId);
+                    this.openTools.push(span);
+                    this.trace.usedTool = true;
+                    this.trace.toolCalls.push({
+                        name: part.payload.toolName,
+                        args: toJsonValue(part.payload.args),
+                    });
+                    break;
+                }
+                case 'tool-result': {
+                    this.trace.usedTool = true;
+                    const result = toJsonValue(part.payload.result);
+                    this.trace.toolResults.push({ name: part.payload.toolName, result });
+                    const span = this.takeToolSpan(part.payload.toolName, part.payload.toolCallId) ??
+                        this.openSpan({
+                            name: `tool:${part.payload.toolName}`,
+                            kind: 'tool',
+                            parentSpanId: this.currentNode?.spanId ?? this.root.spanId,
+                            at,
+                            attributes: {
+                                ...(this.currentFlow ? { activeFlow: activeFlowName(this.currentFlow) } : {}),
+                                ...(this.currentNode ? { nodeId: nodeName(this.currentNode) } : {}),
+                                toolName: part.payload.toolName,
+                            },
+                        });
+                    span.attributes.output = result;
+                    span.endTime = at;
+                    this.emitSpan(span);
+                    break;
+                }
+                case 'handoff': {
+                    const handoffFrom = this.currentAgentId;
+                    const span = this.openSpan({
+                        name: `handoff:${part.payload.targetAgent}`,
+                        kind: 'handoff',
+                        parentSpanId: this.root.spanId,
+                        at,
+                        attributes: {
+                            ...(handoffFrom ? { handoffFrom } : {}),
+                            handoffTo: part.payload.targetAgent,
+                        },
+                    });
+                    span.endTime = at;
+                    this.emitSpan(span);
+                    this.currentAgentId = part.payload.targetAgent;
+                    break;
+                }
+                case 'error': {
+                    const span = this.openTools.at(-1) ?? this.currentNode ?? this.currentFlow ?? this.root;
+                    span.status = 'error';
+                    span.attributes.error = part.payload.error;
+                    this.root.status = 'error';
+                    this.root.attributes.error = part.payload.error;
+                    break;
+                }
+                case 'done':
+                    this.setSessionId(part.payload.sessionId);
+                    this.root.attributes.output = this.trace.answer;
+                    if (part.payload.usage) {
+                        if (typeof part.payload.usage.inputTokens === 'number') {
+                            this.root.attributes.tokensIn = part.payload.usage.inputTokens;
+                        }
+                        if (typeof part.payload.usage.outputTokens === 'number') {
+                            this.root.attributes.tokensOut = part.payload.usage.outputTokens;
+                        }
+                        if (typeof part.payload.usage.contextTokens === 'number') {
+                            this.root.attributes.contextTokens = part.payload.usage.contextTokens;
+                        }
+                    }
+                    this.close(at);
+                    break;
+            }
+        }
+        catch {
+            // Tracing is observational: malformed telemetry must never affect the run.
+        }
+    }
+    finish(result) {
+        try {
+            if (!this.trace.answer) {
+                this.trace.answer = result.text;
+            }
+            this.root.attributes.output = this.trace.answer;
+            this.close(Date.now());
+        }
+        catch {
+            // Returning a partial trace is preferable to changing run behavior.
+        }
+        return this.trace;
+    }
+    openSpan(args) {
+        const span = {
+            traceId: this.trace.traceId,
+            spanId: newSpanId(),
+            parentSpanId: args.parentSpanId,
+            name: args.name,
+            kind: args.kind,
+            startTime: args.at,
+            status: 'ok',
+            attributes: {
+                sessionId: this.trace.sessionId,
+                ...(this.currentAgentId ? { agentId: this.currentAgentId } : {}),
+                ...args.attributes,
+            },
+        };
+        this.trace.spans.push(span);
+        return span;
+    }
+    takeToolSpan(toolName, toolCallId) {
+        const index = this.openTools.findIndex((span) => {
+            const spanCallId = this.toolCallIds.get(span);
+            return toolCallId ? spanCallId === toolCallId : span.attributes.toolName === toolName;
+        });
+        if (index < 0)
+            return undefined;
+        const span = this.openTools.splice(index, 1)[0];
+        if (span)
+            this.toolCallIds.delete(span);
+        return span;
+    }
+    closeTools(at) {
+        for (const span of this.openTools.splice(0)) {
+            span.endTime ??= at;
+            this.toolCallIds.delete(span);
+            this.emitSpan(span);
+        }
+    }
+    closeNode(at) {
+        this.closeTools(at);
+        if (this.currentNode) {
+            this.currentNode.endTime ??= at;
+            this.emitSpan(this.currentNode);
+            this.currentNode = undefined;
+        }
+    }
+    closeFlow(at) {
+        if (this.currentFlow) {
+            this.currentFlow.endTime ??= at;
+            this.emitSpan(this.currentFlow);
+            this.currentFlow = undefined;
+        }
+    }
+    setSessionId(sessionId) {
+        this.trace.sessionId = sessionId;
+        for (const span of this.trace.spans) {
+            span.attributes.sessionId = sessionId;
+        }
+    }
+    close(at) {
+        this.closeNode(at);
+        this.closeFlow(at);
+        this.trace.endedAt ??= at;
+        this.root.endTime ??= at;
+        this.emitSpan(this.root);
+    }
+    emitSpan(span) {
+        if (this.emitted.has(span.spanId) || span.endTime === undefined)
+            return;
+        this.emitted.add(span.spanId);
+        try {
+            this.onSpan?.(structuredClone(span));
+        }
+        catch {
+            // A tracing callback is never allowed to change run behavior.
+        }
+    }
+}
+export async function runOnce(runtime, opts) {
+    // Resolve attribution the same way Runtime.runOnce does: caller's agentId
+    // first, then persisted state, then the runtime default. Without this the
+    // standalone helper produced spans with no `agentId` and handoff spans with
+    // no `handoffFrom` — the exact feature it is documented to provide.
+    let agentId = opts.agentId;
+    if (!agentId && opts.sessionId && runtime.getSessionStore) {
+        const existing = await runtime.getSessionStore().get(opts.sessionId);
+        agentId = existing?.activeAgentId ?? existing?.currentAgent;
+    }
+    agentId ??= runtime.getDefaultAgentId?.();
+    const handle = runtime.run(opts);
+    const recorder = new TraceRecorder({
+        sessionId: opts.sessionId,
+        agentId,
+        input: opts.input,
+    });
+    for await (const part of handle.events) {
+        recorder.record(part);
+    }
+    return recorder.finish(await handle);
+}
+function activeFlowName(span) {
+    return span.attributes.activeFlow ?? span.name.slice('flow:'.length);
+}
+function nodeName(span) {
+    return span.attributes.nodeId ?? span.name.slice('node:'.length);
+}
+function newSpanId() {
+    return crypto.randomUUID().replaceAll('-', '').slice(0, 16);
+}
+function toJsonValue(value, seen = new WeakSet()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value === undefined)
+        return null;
+    if (typeof value === 'function' || typeof value === 'symbol')
+        return String(value);
+    if (typeof value !== 'object')
+        return String(value);
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof Error)
+        return { name: value.name, message: value.message };
+    if (Array.isArray(value))
+        return value.map((entry) => toJsonValue(entry, seen));
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        try {
+            output[key] = toJsonValue(entry, seen);
+        }
+        catch {
+            output[key] = '[Unserializable]';
+        }
+    }
+    return output;
+}

package/dist/runtime/buildAgentToolSurface.js

@@ -28,7 +28,7 @@ export async function buildAgentToolSurface(agent, session, deps) {
     let skillPrompt;
     let skillTools = {};
     if (agent.skills) {
-        const wired = await wireAgentSkills(agent);
+        const wired = await wireAgentSkills(agent, resolvedWorkspace?.fs);
         if (wired) {
             skillTools = wired.tools;
             Object.assign(executorTools, wired.tools);

package/dist/runtime/channels/TextDriver.js

@@ -1,7 +1,7 @@
 import { streamText } from 'ai';
 import { buildNodePrompt, resolveInstructions, composeSystem } from '../../flow/nodeBuilders.js';
 import { buildToolSet } from '../../tools/effect/index.js';
-import { executeModelToolCall, toolResultMessage } from './executeModelTool.js';
+import { dispatchModelToolCalls, toolResultMessage } from './executeModelTool.js';
 import { consumeAllPendingUserInput } from './inputBuffer.js';
 import { runSilentExtraction } from './extractionTurn.js';
 import { applyPreTurnPolicies, applyPostTurnPolicies } from '../policies/agentTurn.js';
@@ -29,21 +29,25 @@ export class TextDriver {
         if (!preTurn.proceed) {
             const blocked = preTurn.blockedMessage ?? 'Input blocked by guardrails';
             ctx.emit({
+                channel: 'internal',
                 type: 'safety-blocked',
-                moderator: preTurn.blockedBy ?? 'input-guardrails',
-                rationale: preTurn.blockedReason ?? 'input blocked',
-                userFacingMessage: blocked,
+                payload: {
+                    moderator: preTurn.blockedBy ?? 'input-guardrails',
+                    rationale: preTurn.blockedReason ?? 'input blocked',
+                    userFacingMessage: blocked,
+                },
             });
             const id = crypto.randomUUID();
-            ctx.emit({ type: 'text-start', id });
-            ctx.emit({ type: 'text-delta', id, delta: blocked });
-            ctx.emit({ type: 'text-end', id });
-            ctx.emit({ type: 'turn-end' });
+            ctx.emit({ channel: 'client', type: 'text-start', payload: { id } });
+            ctx.emit({ channel: 'client', type: 'text-delta', payload: { id, delta: blocked } });
+            ctx.emit({ channel: 'client', type: 'text-end', payload: { id } });
+            ctx.emit({ channel: 'internal', type: 'turn-end', payload: {} });
             return { text: blocked, toolResults: [] };
         }
         const scope = resolveNodeGatherScope(replyNode, ctx.runState.state, ctx.runState.messages);
         const gather = await runGatherPhase(ctx, scope);
         const out = { text: '', toolResults: [] };
+        const toolMessages = [];
         const model = replyNode.model ?? ctx.model;
         const nodeSystem = node.prompt || buildNodePrompt(replyNode, ctx.runState.state);
         const baseSystem = composeSystem(ctx.baseInstructions, nodeSystem, ctx.runState.state, ctx.skillPrompt, ctx.workingMemoryPrompt);
@@ -54,6 +58,7 @@ export class TextDriver {
         const toolCallsMade = [];
         const mode = resolveStreamMode(ctx, node);
         const turnId = crypto.randomUUID();
+        let turnUsage;
         const source = {
             async *[Symbol.asyncIterator]() {
                 for (let step = 0; step < maxSteps; step += 1) {
@@ -73,29 +78,32 @@ export class TextDriver {
                         if (part.type === 'error') {
                             const err = part.error;
                             const message = err instanceof Error ? err.message : String(err);
-                            ctx.emit({ type: 'error', error: message });
+                            ctx.emit({ channel: 'client', type: 'error', payload: { error: message } });
                             throw err instanceof Error ? err : new Error(message);
                         }
                     }
                     const finishReason = await result.finishReason;
                     const response = await result.response;
-                    messages.push(...response.messages);
+                    if (result.totalUsage) {
+                        const stepUsage = await result.totalUsage;
+                        if (stepUsage) {
+                            turnUsage = addTurnUsage(turnUsage, stepUsage);
+                        }
+                    }
                     if (finishReason !== 'tool-calls') {
+                        messages.push(...response.messages);
                         break;
                     }
+                    messages.push(...response.messages);
+                    toolMessages.push(...response.messages);
                     const toolCalls = await result.toolCalls;
-                    for (const call of toolCalls) {
-                        ctx.emit({
-                            type: 'tool-call',
-                            toolName: call.toolName,
-                            args: call.input,
-                            toolCallId: call.toolCallId,
-                        });
-                        const { result: toolResult, control, failed } = await executeModelToolCall(ctx, { toolName: call.toolName, input: call.input, toolCallId: call.toolCallId }, {
-                            ...ctx.globalTools,
-                            ...(ctx.workingMemoryTools ?? {}),
-                            ...node.localTools,
-                        });
+                    const mergedTools = {
+                        ...ctx.globalTools,
+                        ...(ctx.workingMemoryTools ?? {}),
+                        ...node.localTools,
+                    };
+                    await dispatchModelToolCalls(ctx, toolCalls, mergedTools, ({ call, outcome }) => {
+                        const { result: toolResult, control, failed } = outcome;
                         out.toolResults.push({
                             name: call.toolName,
                             args: call.input,
@@ -111,14 +119,10 @@ export class TextDriver {
                             timestamp: Date.now(),
                         });
                         out.control ??= control;
-                        ctx.emit({
-                            type: 'tool-result',
-                            toolName: call.toolName,
-                            result: toolResult,
-                            toolCallId: call.toolCallId,
-                        });
-                        messages.push(toolResultMessage({ toolName: call.toolName, input: call.input, toolCallId: call.toolCallId }, toolResult));
-                    }
+                        const resultMessage = toolResultMessage(call, toolResult);
+                        messages.push(resultMessage);
+                        toolMessages.push(resultMessage);
+                    });
                 }
             },
         };
@@ -153,7 +157,13 @@ export class TextDriver {
         out.text = spoken.text;
         out.control = spoken.control ?? out.control;
         out.confidence = spoken.confidence;
-        ctx.emit({ type: 'turn-end' });
+        if (toolMessages.length > 0) {
+            out.toolMessages = toolMessages;
+        }
+        if (turnUsage && turnUsage.totalTokens > 0) {
+            out.usage = turnUsage;
+        }
+        ctx.emit({ channel: 'internal', type: 'turn-end', payload: {} });
         return out;
     }
     // Non-speaking field extraction for collect nodes (shared helper so text and
@@ -210,4 +220,20 @@ export class TextDriver {
         return aiTools;
     }
 }
+function addTurnUsage(current, usage) {
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+    const cacheReadTokens = usage.inputTokenDetails?.cacheReadTokens ?? 0;
+    if (!current) {
+        return { inputTokens, outputTokens, totalTokens, cacheReadTokens, contextTokens: inputTokens };
+    }
+    return {
+        inputTokens: current.inputTokens + inputTokens,
+        outputTokens: current.outputTokens + outputTokens,
+        totalTokens: current.totalTokens + totalTokens,
+        cacheReadTokens: (current.cacheReadTokens ?? 0) + cacheReadTokens,
+        contextTokens: inputTokens,
+    };
+}
 export { buildNodePrompt };

package/dist/runtime/channels/executeModelTool.d.ts

@@ -11,8 +11,21 @@ export interface ModelToolCallOutcome {
     result: unknown;
     control?: TurnControl;
     failed: boolean;
+    /**
+     * Set when the call unwound with a control-flow signal rather than a failure. Held as a
+     * value so a parallel batch can still finalize its siblings; the dispatcher rethrows it
+     * once the batch has settled. Never surfaced to the model.
+     */
+    signal?: unknown;
 }
-export declare function executeModelToolCall(ctx: RunContext, call: ModelToolCall, localTools?: Record<string, AnyTool>): Promise<ModelToolCallOutcome>;
+export declare function executeModelToolCall(ctx: RunContext, call: ModelToolCall, localTools?: Record<string, AnyTool>, durableOpts?: {
+    callsite?: string;
+    index?: number;
+}): Promise<ModelToolCallOutcome>;
+export declare function dispatchModelToolCalls(ctx: RunContext, toolCalls: ModelToolCall[], localTools: Record<string, AnyTool>, onEach: (args: {
+    call: ModelToolCall;
+    outcome: ModelToolCallOutcome;
+}) => void): Promise<void>;
 export declare function toolResultMessage(call: ModelToolCall, result: unknown): {
     role: 'tool';
     content: [

package/dist/runtime/channels/executeModelTool.js

@@ -1,10 +1,15 @@
 import { classifyControl } from '../../flow/classifyControl.js';
-import { toolErrorResult } from '../../tools/controlResults.js';
-export async function executeModelToolCall(ctx, call, localTools) {
+import { toolDeniedResult, toolErrorResult } from '../../tools/controlResults.js';
+import { idempotencyKey, logicalRunId } from '../durable/idempotency.js';
+import { findStepByKey } from '../durable/replay.js';
+import { isApprovalDenial, isControlFlowSignal } from '../controlFlowSignal.js';
+export async function executeModelToolCall(ctx, call, localTools, durableOpts) {
     try {
         const localTool = localTools?.[call.toolName];
         const toolResult = await ctx.tool(call.toolName, call.input, {
             toolCallId: call.toolCallId,
+            callsite: durableOpts?.callsite,
+            index: durableOpts?.index,
             ...(localTool && {
                 def: localTool,
                 toolCtx: {
@@ -20,11 +25,135 @@ export async function executeModelToolCall(ctx, call, localTools) {
         return { result: toolResult, control: classifyControl(toolResult), failed: false };
     }
     catch (error) {
+        if (isControlFlowSignal(error)) {
+            // A suspend. Not a failure, so no client-facing error and no tool result: returning it
+            // as a value keeps this function's never-rejects contract (which `Promise.all` below
+            // depends on) while letting the dispatcher rethrow it once the batch has settled.
+            return { result: undefined, failed: true, signal: error };
+        }
+        if (isApprovalDenial(error)) {
+            // A human declined. The model asked for this call, so the model is told — otherwise
+            // the turn dies and the user never hears why. No client error part: nothing broke.
+            return { result: toolDeniedResult(error.toolName, error.by), failed: true };
+        }
         const message = error instanceof Error ? error.message : String(error);
-        ctx.emit({ type: 'error', error: message });
+        ctx.emit({ channel: 'client', type: 'error', payload: { error: message } });
         return { result: toolErrorResult(error), failed: true };
     }
 }
+function isParallelSafeTool(def) {
+    return def?.parallelSafe === true || def?.replay === false;
+}
+/**
+ * Runs `task` over every item, at most `limit` at a time, preserving result order.
+ *
+ * Unbounded `Promise.all` over a model-emitted batch lets the model decide how many
+ * sockets, subprocesses, or rate-limited API calls open at once. `limit` is a ceiling on
+ * that; omitting it keeps the previous unbounded behaviour.
+ *
+ * `task` is expected not to reject (see the caller's contract). If one does, the rejection
+ * propagates and in-flight siblings still run to completion — they are not cancelled, so
+ * their journal writes complete rather than being abandoned half-done.
+ */
+async function runWithConcurrency(items, task, limit) {
+    if (limit === undefined || limit <= 0 || limit >= items.length) {
+        return Promise.all(items.map((item) => task(item)));
+    }
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await task(items[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: limit }, () => worker()));
+    return results;
+}
+export async function dispatchModelToolCalls(ctx, toolCalls, localTools, onEach) {
+    /** Resolves to a control-flow signal when the call suspended, otherwise `undefined`. */
+    const runOne = async (call, durableOpts) => {
+        ctx.emit({
+            channel: 'internal',
+            type: 'tool-call',
+            payload: {
+                toolName: call.toolName,
+                args: call.input,
+                toolCallId: call.toolCallId,
+            },
+        });
+        const outcome = await executeModelToolCall(ctx, call, localTools, durableOpts);
+        if (outcome.signal !== undefined) {
+            // Suspended: no result exists, so nothing may reach the model or the transcript.
+            return outcome.signal;
+        }
+        onEach({ call, outcome });
+        ctx.emit({
+            channel: 'internal',
+            type: 'tool-result',
+            payload: {
+                toolName: call.toolName,
+                result: outcome.result,
+                toolCallId: call.toolCallId,
+            },
+        });
+        return undefined;
+    };
+    const runParallel = async (parallel) => {
+        const callsites = ctx.reserveCallsites(parallel.length);
+        const steps = await ctx.runStore.getSteps(ctx.runState.runId);
+        const logicalId = logicalRunId(ctx.runState.runId, ctx.runState.runEpoch);
+        const unresolved = parallel.filter((call, i) => {
+            const def = localTools[call.toolName];
+            const key = def?.idempotencyKey != null
+                ? def.idempotencyKey(call.input)
+                : idempotencyKey(logicalId, callsites[i], { name: call.toolName, args: call.input });
+            const hit = findStepByKey(steps, key);
+            return !hit || hit.status === 'running';
+        });
+        let indices;
+        if (unresolved.length > 0 && ctx.runStore.reserveSteps) {
+            indices = await ctx.runStore.reserveSteps(ctx.runState.runId, unresolved.length);
+        }
+        let unresolvedCursor = 0;
+        const assignments = parallel.map((call, i) => {
+            const def = localTools[call.toolName];
+            const key = def?.idempotencyKey != null
+                ? def.idempotencyKey(call.input)
+                : idempotencyKey(logicalId, callsites[i], { name: call.toolName, args: call.input });
+            const hit = findStepByKey(steps, key);
+            const needsIndex = !hit || hit.status === 'running';
+            const index = needsIndex ? indices?.[unresolvedCursor++] : hit?.index;
+            return { call, callsite: callsites[i], index };
+        });
+        // executeModelToolCall never rejects — tool errors resolve with failed: true and control-flow
+        // signals resolve as outcome.signal — so no sibling can be abandoned mid-flight with its
+        // finalizeStep unawaited. A suspend is rethrown only after every sibling has settled: you
+        // cannot cancel an in-flight promise, so failing fast here would let the work happen anyway
+        // while the journal recorded it as still running.
+        const signals = await runWithConcurrency(assignments, ({ call, callsite, index }) => runOne(call, { callsite, index }), ctx.limits?.maxToolConcurrency);
+        const suspended = signals.find((signal) => signal !== undefined);
+        if (suspended !== undefined)
+            throw suspended;
+    };
+    for (let cursor = 0; cursor < toolCalls.length;) {
+        const call = toolCalls[cursor];
+        if (!isParallelSafeTool(localTools[call.toolName])) {
+            const signal = await runOne(call);
+            if (signal !== undefined)
+                throw signal;
+            cursor += 1;
+            continue;
+        }
+        const parallel = [];
+        while (cursor < toolCalls.length &&
+            isParallelSafeTool(localTools[toolCalls[cursor].toolName])) {
+            parallel.push(toolCalls[cursor]);
+            cursor += 1;
+        }
+        await runParallel(parallel);
+    }
+}
 export function toolResultMessage(call, result) {
     return {
         role: 'tool',

package/dist/runtime/channels/extractionTurn.js

@@ -36,7 +36,7 @@ export async function runSilentExtraction(node, ctx, model, maxSteps) {
             if (part.type === 'error') {
                 const err = part.error;
                 const message = err instanceof Error ? err.message : String(err);
-                ctx.emit({ type: 'error', error: message });
+                ctx.emit({ channel: 'client', type: 'error', payload: { error: message } });
                 throw err instanceof Error ? err : new Error(message);
             }
         }