@agent-native/core 0.84.62 → 0.84.64

package/dist/agent/production-agent.js

@@ -544,6 +544,7 @@ function maxRetriesForError(err) {
 const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
 const ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS = 90_000;
 const ACTION_PREPARATION_ZERO_BYTE_RESTART_LIMIT = 2;
+const MODEL_STREAM_NO_PROGRESS_TIMEOUT_MS = 90_000;
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
 const MAX_RESOURCE_INVENTORY_ITEMS = 40;
@@ -1962,7 +1963,8 @@ export async function runAgentLoop(opts) {
                 let lastToolInputActivityAt = 0;
                 const activeToolInputs = new Map();
                 let zeroByteToolInputRestart;
-                let endedForActionPreparationNoProgress = false;
+                let endedForNoProgress = false;
+                let lastModelStreamProgressAt = Date.now();
                 const sendToolInputActivity = (toolName, toolInputId, progressBytes, force = false) => {
                     const now = Date.now();
                     if (!force &&
@@ -1978,10 +1980,12 @@ export async function runAgentLoop(opts) {
                         ...(typeof progressBytes === "number" ? { progressBytes } : {}),
                     });
                 };
-                const hasActionPreparationStalled = () => {
-                    if (activeToolInputs.size === 0)
-                        return false;
-                    const now = Date.now();
+                const actionPreparationDeadlineAt = () => {
+                    let deadlineAt = Number.POSITIVE_INFINITY;
+                    if (zeroByteToolInputRestart) {
+                        deadlineAt = Math.min(deadlineAt, zeroByteToolInputRestart.firstStartedAt +
+                            ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS);
+                    }
                     let earliestStartedAt = Number.POSITIVE_INFINITY;
                     let latestPositiveProgressAt = 0;
                     for (const active of activeToolInputs.values()) {
@@ -1996,9 +2000,74 @@ export async function runAgentLoop(opts) {
                     const progressAt = latestPositiveProgressAt > 0
                         ? latestPositiveProgressAt
                         : earliestStartedAt;
-                    if (!Number.isFinite(progressAt))
-                        return false;
-                    return now - progressAt >= ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS;
+                    if (Number.isFinite(progressAt)) {
+                        deadlineAt = Math.min(deadlineAt, progressAt + ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS);
+                    }
+                    return Number.isFinite(deadlineAt) ? deadlineAt : undefined;
+                };
+                const modelStreamNoProgressDeadlineAt = () => lastModelStreamProgressAt + MODEL_STREAM_NO_PROGRESS_TIMEOUT_MS;
+                const noProgressDeadlineAt = () => {
+                    const actionDeadlineAt = actionPreparationDeadlineAt();
+                    const modelDeadlineAt = modelStreamNoProgressDeadlineAt();
+                    return actionDeadlineAt === undefined
+                        ? modelDeadlineAt
+                        : Math.min(actionDeadlineAt, modelDeadlineAt);
+                };
+                const hasNoProgressStalled = () => Date.now() >= noProgressDeadlineAt();
+                const checkpointNoProgress = () => {
+                    if (endedForNoProgress)
+                        return;
+                    send({
+                        type: "auto_continue",
+                        reason: "no_progress",
+                    });
+                    endedForNoProgress = true;
+                };
+                let eventIteratorReturnRequested = false;
+                const requestEventIteratorReturn = (iterator, awaitReturn) => {
+                    if (eventIteratorReturnRequested)
+                        return;
+                    eventIteratorReturnRequested = true;
+                    let returnPromise;
+                    try {
+                        returnPromise = iterator.return?.();
+                    }
+                    catch {
+                        return;
+                    }
+                    if (!returnPromise)
+                        return;
+                    if (awaitReturn)
+                        return returnPromise.catch(() => undefined);
+                    void returnPromise.catch(() => undefined);
+                };
+                const nextEngineEventWithNoProgressTimeout = async (iterator) => {
+                    const deadlineAt = noProgressDeadlineAt();
+                    const timeoutMs = Math.max(0, deadlineAt - Date.now());
+                    if (timeoutMs <= 0) {
+                        checkpointNoProgress();
+                        requestEventIteratorReturn(iterator, false);
+                        return { done: true, value: undefined };
+                    }
+                    let timeoutId;
+                    const next = iterator.next();
+                    void next.catch(() => undefined);
+                    const timeout = new Promise((resolve) => {
+                        timeoutId = setTimeout(() => resolve("timeout"), timeoutMs);
+                    });
+                    try {
+                        const result = await Promise.race([next, timeout]);
+                        if (result === "timeout") {
+                            checkpointNoProgress();
+                            requestEventIteratorReturn(iterator, false);
+                            return { done: true, value: undefined };
+                        }
+                        return result;
+                    }
+                    finally {
+                        if (timeoutId)
+                            clearTimeout(timeoutId);
+                    }
                 };
                 const trackActiveToolInput = (key, toolName, bytes) => {
                     const now = Date.now();
@@ -2043,140 +2112,150 @@ export async function runAgentLoop(opts) {
                         now - zeroByteToolInputRestart.firstStartedAt >=
                             ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS);
                 };
-                for await (const event of eventStream) {
-                    if (hasActionPreparationStalled()) {
-                        send({
-                            type: "auto_continue",
-                            reason: "no_progress",
-                        });
-                        endedForActionPreparationNoProgress = true;
-                        break;
-                    }
-                    // In-loop processor seam (stream hook). Each chunk is offered to every
-                    // processor's `processOutputStream` before the loop handles it. A
-                    // processor `abort()` throws a TripWire; catch it locally so it is not
-                    // mistaken for a retryable engine error, then break out cleanly.
-                    if (processorChain) {
-                        try {
-                            await processorChain.runStream(event);
+                const eventIterator = eventStream[Symbol.asyncIterator]();
+                let eventIteratorDone = false;
+                try {
+                    while (true) {
+                        const nextEvent = await nextEngineEventWithNoProgressTimeout(eventIterator);
+                        if (nextEvent.done) {
+                            eventIteratorDone = true;
+                            break;
                         }
-                        catch (err) {
-                            if (err instanceof TripWire) {
-                                emitTripwire(err);
-                                break;
+                        const event = nextEvent.value;
+                        if (hasNoProgressStalled()) {
+                            checkpointNoProgress();
+                            break;
+                        }
+                        if (event.type !== "gateway-heartbeat") {
+                            lastModelStreamProgressAt = Date.now();
+                        }
+                        // In-loop processor seam (stream hook). Each chunk is offered to every
+                        // processor's `processOutputStream` before the loop handles it. A
+                        // processor `abort()` throws a TripWire; catch it locally so it is not
+                        // mistaken for a retryable engine error, then break out cleanly.
+                        if (processorChain) {
+                            try {
+                                await processorChain.runStream(event);
+                            }
+                            catch (err) {
+                                if (err instanceof TripWire) {
+                                    emitTripwire(err);
+                                    break;
+                                }
+                                throw err;
                             }
-                            throw err;
                         }
-                    }
-                    if (event.type === "text-delta") {
-                        resetZeroByteToolInputRestart();
-                        streamedAssistantText += event.text;
-                        send({ type: "text", text: event.text });
-                    }
-                    else if (event.type === "thinking-delta") {
-                        thinkingBuffer += event.text;
-                        // Forward thinking deltas as a distinct event type so the UI
-                        // can render a collapsible "Thinking…" cell while the model
-                        // reasons, then collapse it when content arrives.
-                        send({ type: "thinking", text: event.text });
-                    }
-                    else if (event.type === "tool-input-start") {
-                        const key = event.id ?? event.name;
-                        if (key && event.name) {
-                            toolInputNames.set(key, event.name);
-                            toolInputBytes.set(key, 0);
-                            trackActiveToolInput(key, event.name, 0);
+                        if (event.type === "text-delta") {
+                            resetZeroByteToolInputRestart();
+                            streamedAssistantText += event.text;
+                            send({ type: "text", text: event.text });
                         }
-                        sendToolInputActivity(event.name, key, undefined, true);
-                        if (noteZeroByteToolInputStart(event.name)) {
-                            send({
-                                type: "auto_continue",
-                                reason: "no_progress",
-                            });
-                            endedForActionPreparationNoProgress = true;
-                            break;
+                        else if (event.type === "thinking-delta") {
+                            thinkingBuffer += event.text;
+                            // Forward thinking deltas as a distinct event type so the UI
+                            // can render a collapsible "Thinking…" cell while the model
+                            // reasons, then collapse it when content arrives.
+                            send({ type: "thinking", text: event.text });
                         }
-                    }
-                    else if (event.type === "tool-input-delta") {
-                        const key = event.id ?? event.name;
-                        const toolName = event.name ??
-                            (event.id ? toolInputNames.get(event.id) : undefined);
-                        let progressBytes;
-                        let startedZeroByteInput = false;
-                        if (key) {
-                            const hadByteRecord = toolInputBytes.has(key);
-                            const previous = hadByteRecord
-                                ? (toolInputBytes.get(key) ?? 0)
-                                : 0;
-                            progressBytes =
-                                previous +
-                                    new TextEncoder().encode(event.text ?? "").byteLength;
-                            toolInputBytes.set(key, progressBytes);
-                            if (!hadByteRecord || progressBytes > previous) {
-                                trackActiveToolInput(key, toolName, progressBytes);
-                                if (progressBytes > 0) {
-                                    resetZeroByteToolInputRestart(toolName);
-                                }
-                                else if (!hadByteRecord) {
-                                    startedZeroByteInput = true;
+                        else if (event.type === "tool-input-start") {
+                            const key = event.id ?? event.name;
+                            if (key && event.name) {
+                                toolInputNames.set(key, event.name);
+                                toolInputBytes.set(key, 0);
+                                trackActiveToolInput(key, event.name, 0);
+                            }
+                            sendToolInputActivity(event.name, key, undefined, true);
+                            if (noteZeroByteToolInputStart(event.name)) {
+                                send({
+                                    type: "auto_continue",
+                                    reason: "no_progress",
+                                });
+                                endedForNoProgress = true;
+                                break;
+                            }
+                        }
+                        else if (event.type === "tool-input-delta") {
+                            const key = event.id ?? event.name;
+                            const toolName = event.name ??
+                                (event.id ? toolInputNames.get(event.id) : undefined);
+                            let progressBytes;
+                            let startedZeroByteInput = false;
+                            if (key) {
+                                const hadByteRecord = toolInputBytes.has(key);
+                                const previous = hadByteRecord
+                                    ? (toolInputBytes.get(key) ?? 0)
+                                    : 0;
+                                progressBytes =
+                                    previous +
+                                        new TextEncoder().encode(event.text ?? "").byteLength;
+                                toolInputBytes.set(key, progressBytes);
+                                if (!hadByteRecord || progressBytes > previous) {
+                                    trackActiveToolInput(key, toolName, progressBytes);
+                                    if (progressBytes > 0) {
+                                        resetZeroByteToolInputRestart();
+                                    }
+                                    else if (!hadByteRecord) {
+                                        startedZeroByteInput = true;
+                                    }
                                 }
                             }
+                            sendToolInputActivity(toolName, key, progressBytes);
+                            if (startedZeroByteInput &&
+                                toolName &&
+                                noteZeroByteToolInputStart(toolName)) {
+                                send({
+                                    type: "auto_continue",
+                                    reason: "no_progress",
+                                });
+                                endedForNoProgress = true;
+                                break;
+                            }
                         }
-                        sendToolInputActivity(toolName, key, progressBytes);
-                        if (startedZeroByteInput &&
-                            toolName &&
-                            noteZeroByteToolInputStart(toolName)) {
-                            send({
-                                type: "auto_continue",
-                                reason: "no_progress",
-                            });
-                            endedForActionPreparationNoProgress = true;
-                            break;
+                        else if (event.type === "gateway-heartbeat") {
+                            send({ type: "stream_keepalive" });
                         }
-                    }
-                    else if (event.type === "gateway-heartbeat") {
-                        send({ type: "stream_keepalive" });
-                    }
-                    else if (event.type === "tool-call") {
-                        // The authoritative tool-call blocks arrive in assistant-content.
-                    }
-                    else if (event.type === "tool-call-error") {
-                        toolCallErrors.set(event.id, {
-                            name: event.name,
-                            input: event.input,
-                            error: event.error,
-                        });
-                    }
-                    else if (event.type === "assistant-content") {
-                        assistantContent = event.parts;
-                    }
-                    else if (event.type === "usage") {
-                        usage.inputTokens += event.inputTokens;
-                        usage.outputTokens += event.outputTokens;
-                        usage.cacheReadTokens += event.cacheReadTokens ?? 0;
-                        usage.cacheWriteTokens += event.cacheWriteTokens ?? 0;
-                    }
-                    else if (event.type === "stop") {
-                        terminalStopReason = event.reason;
-                        if (event.reason === "error") {
-                            throw new EngineError(event.error ?? "Engine stream error", {
-                                errorCode: event.errorCode,
-                                upgradeUrl: event.upgradeUrl,
-                                statusCode: event.statusCode,
-                                providerRetryable: event.providerRetryable,
+                        else if (event.type === "tool-call") {
+                            // The authoritative tool-call blocks arrive in assistant-content.
+                        }
+                        else if (event.type === "tool-call-error") {
+                            toolCallErrors.set(event.id, {
+                                name: event.name,
+                                input: event.input,
+                                error: event.error,
                             });
                         }
+                        else if (event.type === "assistant-content") {
+                            assistantContent = event.parts;
+                        }
+                        else if (event.type === "usage") {
+                            usage.inputTokens += event.inputTokens;
+                            usage.outputTokens += event.outputTokens;
+                            usage.cacheReadTokens += event.cacheReadTokens ?? 0;
+                            usage.cacheWriteTokens += event.cacheWriteTokens ?? 0;
+                        }
+                        else if (event.type === "stop") {
+                            terminalStopReason = event.reason;
+                            if (event.reason === "error") {
+                                throw new EngineError(event.error ?? "Engine stream error", {
+                                    errorCode: event.errorCode,
+                                    upgradeUrl: event.upgradeUrl,
+                                    statusCode: event.statusCode,
+                                    providerRetryable: event.providerRetryable,
+                                });
+                            }
+                        }
+                        if (hasNoProgressStalled()) {
+                            checkpointNoProgress();
+                            break;
+                        }
                     }
-                    if (hasActionPreparationStalled()) {
-                        send({
-                            type: "auto_continue",
-                            reason: "no_progress",
-                        });
-                        endedForActionPreparationNoProgress = true;
-                        break;
+                }
+                finally {
+                    if (!eventIteratorDone) {
+                        await requestEventIteratorReturn(eventIterator, !eventIteratorReturnRequested);
                     }
                 }
-                if (endedForActionPreparationNoProgress) {
+                if (endedForNoProgress) {
                     return usage;
                 }
                 break;