@doist/doistbot-cli 1.0.9 → 1.0.11

package/sandbox/dist/core/pi.js

@@ -3,28 +3,71 @@ import { mkdtempSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { PI_EXECUTION_LIMIT_ENV } from './pi-execution-limits-extension.js';
+export function toPiInvocationTelemetryFields(telemetry) {
+    return {
+        turn_count: telemetry.turnCount,
+        assistant_message_count: telemetry.assistantMessageCount,
+        tool_call_count: telemetry.toolCallCount,
+        tool_wall_clock_duration_ms: telemetry.toolWallClockDurationMs,
+        non_tool_duration_ms: telemetry.nonToolDurationMs,
+        ...(telemetry.timeToFirstActivityMs == null
+            ? {}
+            : { time_to_first_activity_ms: telemetry.timeToFirstActivityMs }),
+        ...(telemetry.timeToFirstThinkingMs == null
+            ? {}
+            : { time_to_first_thinking_ms: telemetry.timeToFirstThinkingMs }),
+        ...(telemetry.timeToFirstResponseMs == null
+            ? {}
+            : { time_to_first_response_ms: telemetry.timeToFirstResponseMs }),
+        ...(telemetry.timeToFirstToolCallMs == null
+            ? {}
+            : { time_to_first_tool_call_ms: telemetry.timeToFirstToolCallMs }),
+        ...(telemetry.finalizationAfterLastToolMs == null
+            ? {}
+            : { finalization_after_last_tool_ms: telemetry.finalizationAfterLastToolMs }),
+        soft_limit_reached: telemetry.softLimit != null,
+        ...(telemetry.softLimit
+            ? {
+                soft_limit_trigger: telemetry.softLimit.trigger,
+                soft_limit_elapsed_ms: telemetry.softLimit.elapsedMs,
+            }
+            : {}),
+        hard_limit_reached: telemetry.hardLimit != null,
+        ...(telemetry.hardLimit
+            ? {
+                hard_limit_trigger: telemetry.hardLimit.trigger,
+                hard_limit_elapsed_ms: telemetry.hardLimit.elapsedMs,
+            }
+            : {}),
+    };
+}
 export const PI_PROVIDER_BY_DOISTBOT_PROVIDER = {
     deepseek: 'openrouter',
     gemini: 'google',
+    grok: 'openrouter',
     zai: 'openrouter',
     openai: 'openai',
 };
 export const DEFAULT_PI_MODELS = {
     deepseek: 'deepseek-v4-pro',
     gemini: 'gemini-3.1-pro-preview',
+    grok: 'grok-4.6',
     zai: 'glm5.2',
     openai: 'gpt-5.6-terra',
 };
 export const DEFAULT_OPENROUTER_MODELS = {
     deepseek: 'deepseek/deepseek-v4-pro-0813',
     gemini: 'google/gemini-3.1-pro-preview',
-    zai: 'z-ai/glm-5.2',
+    grok: 'x-ai/grok-4.6',
+    zai: 'z-ai/glm-5.3-flash',
 };
 // Gemini flash fallback model.
 export const DEFAULT_GEMINI_FLASH_MODEL = 'gemini-3.7-flash';
 export const MAX_PI_THINKING_BY_PROVIDER = {
     deepseek: 'high',
     gemini: 'high',
+    grok: 'high',
     zai: 'high',
     openai: 'xhigh',
 };
@@ -41,6 +84,7 @@ const PI_PROGRESS_HEARTBEAT_MS = 30_000;
 const OPENROUTER_SESSION_ID_ENV_VAR = 'DOISTBOT_OPENROUTER_SESSION_ID';
 const OPENROUTER_SESSION_ID_MAX_LENGTH = 256;
 const PI_TOOLS_BY_PRESET = {
+    none: [],
     'read-only': ['read', 'grep', 'find', 'ls'],
     'workspace-inspection': ['read', 'bash', 'grep', 'find', 'ls'],
     'shell-focused': ['read', 'bash', 'ls'],
@@ -50,6 +94,7 @@ function resolvePiCliPath() {
     return path.join(path.dirname(piPackageEntryPath), 'cli.js');
 }
 const PI_CLI_PATH = resolvePiCliPath();
+const PI_EXECUTION_LIMIT_EXTENSION_PATH = fileURLToPath(new URL('./pi-execution-limits-extension.js', import.meta.url));
 let cachedNodeExecutable;
 let cachedOpenRouterSessionExtensionPath;
 export function resolveNodeExecutable({ execPath = process.execPath, argv0 = process.argv0, canExecute = canExecuteNode, } = {}) {
@@ -174,6 +219,47 @@ function createOpenRouterSessionExtension({ piProviderId, sessionId, }) {
         cleanup() { },
     };
 }
+function createExecutionLimitExtension(limits, startedAtMs) {
+    if (!limits) {
+        return { args: [], extraEnv: {} };
+    }
+    return {
+        args: ['--extension', PI_EXECUTION_LIMIT_EXTENSION_PATH],
+        extraEnv: {
+            [PI_EXECUTION_LIMIT_ENV.startedAtMs]: String(startedAtMs),
+            ...(limits.softTimeMs == null
+                ? {}
+                : { [PI_EXECUTION_LIMIT_ENV.softTimeMs]: String(limits.softTimeMs) }),
+            ...(limits.softToolCalls == null
+                ? {}
+                : { [PI_EXECUTION_LIMIT_ENV.softToolCalls]: String(limits.softToolCalls) }),
+            ...(limits.hardTimeMs == null
+                ? {}
+                : { [PI_EXECUTION_LIMIT_ENV.hardTimeMs]: String(limits.hardTimeMs) }),
+            ...(limits.hardToolCalls == null
+                ? {}
+                : { [PI_EXECUTION_LIMIT_ENV.hardToolCalls]: String(limits.hardToolCalls) }),
+        },
+    };
+}
+function normalizePiExecutionLimits(limits) {
+    if (!limits)
+        return undefined;
+    function positiveInteger(value) {
+        return Number.isInteger(value) && value > 0 ? value : undefined;
+    }
+    const softTimeMs = positiveInteger(limits.softTimeMs);
+    const softToolCalls = positiveInteger(limits.softToolCalls);
+    const hardTimeMs = positiveInteger(limits.hardTimeMs);
+    const hardToolCalls = positiveInteger(limits.hardToolCalls);
+    const normalized = {
+        ...(softTimeMs == null ? {} : { softTimeMs }),
+        ...(softToolCalls == null ? {} : { softToolCalls }),
+        ...(hardTimeMs == null ? {} : { hardTimeMs }),
+        ...(hardToolCalls == null ? {} : { hardToolCalls }),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 function extractTextSegments(content) {
     if (!Array.isArray(content)) {
         return [];
@@ -217,9 +303,32 @@ function readStopReason(message) {
     return typeof stopReason === 'string' ? stopReason : undefined;
 }
 function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt, lastToolUpdateAt, toolStartedAt, }) {
-    if (!onProgress) {
-        return;
+    if (event.type === 'message_update') {
+        const assistantMessageEvent = event.assistantMessageEvent;
+        if (!assistantMessageEvent || typeof assistantMessageEvent !== 'object') {
+            return undefined;
+        }
+        const messageEventType = assistantMessageEvent.type;
+        if (messageEventType !== 'thinking_delta' && messageEventType !== 'text_delta') {
+            return undefined;
+        }
+        const now = Date.now();
+        if (onProgress &&
+            messageEventType === 'thinking_delta' &&
+            now - lastThinkingAt.value >= PI_PROGRESS_HEARTBEAT_MS) {
+            lastThinkingAt.value = now;
+            onProgress({ type: 'thinking' });
+        }
+        if (onProgress &&
+            messageEventType === 'text_delta' &&
+            now - lastRespondingAt.value >= PI_PROGRESS_HEARTBEAT_MS) {
+            lastRespondingAt.value = now;
+            onProgress({ type: 'responding' });
+        }
+        return { type: messageEventType, observedAt: now };
     }
+    if (!onProgress)
+        return undefined;
     switch (event.type) {
         case 'agent_start':
             onProgress({ type: 'agent_start' });
@@ -227,25 +336,6 @@ function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt
         case 'agent_end':
             onProgress({ type: 'agent_end' });
             return;
-        case 'message_update': {
-            const assistantMessageEvent = event.assistantMessageEvent;
-            if (!assistantMessageEvent || typeof assistantMessageEvent !== 'object') {
-                return;
-            }
-            const messageEventType = assistantMessageEvent.type;
-            const now = Date.now();
-            if (messageEventType === 'thinking_delta' &&
-                now - lastThinkingAt.value >= PI_PROGRESS_HEARTBEAT_MS) {
-                lastThinkingAt.value = now;
-                onProgress({ type: 'thinking' });
-            }
-            if (messageEventType === 'text_delta' &&
-                now - lastRespondingAt.value >= PI_PROGRESS_HEARTBEAT_MS) {
-                lastRespondingAt.value = now;
-                onProgress({ type: 'responding' });
-            }
-            return;
-        }
         case 'tool_execution_start': {
             const toolName = event.toolName;
             if (typeof toolName === 'string' && toolName.length > 0) {
@@ -287,8 +377,10 @@ function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt
                     durationMs: startedAt == null ? undefined : Math.max(0, Date.now() - startedAt),
                 });
             }
+            return undefined;
         }
     }
+    return undefined;
 }
 function toSortedToolUsage(toolUsageByName) {
     return [...toolUsageByName.values()].sort((left, right) => {
@@ -298,7 +390,8 @@ function toSortedToolUsage(toolUsageByName) {
         return left.toolName.localeCompare(right.toolName);
     });
 }
-export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv, capabilityPreset = 'workspace-inspection', thinkingLevel, systemPrompt = DOISTBOT_PI_SYSTEM_PROMPT, noContextFiles = false, openRouterSessionId, onProgress, }) {
+export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv, capabilityPreset = 'workspace-inspection', thinkingLevel, systemPrompt = DOISTBOT_PI_SYSTEM_PROMPT, noContextFiles = false, openRouterSessionId, executionLimits, onProgress, }) {
+    const normalizedExecutionLimits = normalizePiExecutionLimits(executionLimits);
     return {
         async invoke({ prompt, modelName, timeoutMs = 5 * 60 * 1000, images, }) {
             const startedAt = Date.now();
@@ -315,6 +408,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 piProviderId: resolvedPiProviderId,
                 sessionId: openRouterSessionId,
             });
+            const executionLimitExtension = createExecutionLimitExtension(normalizedExecutionLimits, startedAt);
             const tools = PI_TOOLS_BY_PRESET[capabilityPreset].join(',');
             const args = [
                 PI_CLI_PATH,
@@ -327,11 +421,11 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 ...(noContextFiles ? ['--no-context-files'] : []),
                 '--model',
                 modelSpec,
-                '--tools',
-                tools,
+                ...(capabilityPreset === 'none' ? ['--no-tools'] : ['--tools', tools]),
                 '--system-prompt',
                 systemPrompt,
                 ...openRouterSessionExtension.args,
+                ...executionLimitExtension.args,
                 ...imageArgs,
             ];
             const inheritedEnv = {
@@ -347,6 +441,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 GIT_TERMINAL_PROMPT: '0',
                 ...extraEnv,
                 ...openRouterSessionExtension.extraEnv,
+                ...executionLimitExtension.extraEnv,
             };
             const apiKeyEnvVar = PI_API_KEY_ENV_VAR_BY_PI_PROVIDER[resolvedPiProviderId];
             if (piAuthProviderId) {
@@ -376,6 +471,100 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 const lastToolUpdateAt = new Map();
                 const toolStartedAt = new Map();
                 const toolUsageByName = new Map();
+                let turnCount = 0;
+                let assistantMessageCount = 0;
+                let toolCallCount = 0;
+                let activeToolCount = 0;
+                let toolBusyStartedAt;
+                let toolWallClockDurationMs = 0;
+                let lastToolEndedAt;
+                let firstThinkingAt;
+                let firstResponseAt;
+                let firstToolCallAt;
+                let softLimit;
+                let hardLimit;
+                function markLimit(level, trigger) {
+                    if ((level === 'soft' && softLimit) || (level === 'hard' && hardLimit)) {
+                        return;
+                    }
+                    const observation = {
+                        level,
+                        trigger,
+                        elapsedMs: Math.max(0, Date.now() - startedAt),
+                        toolCallCount,
+                    };
+                    if (level === 'soft')
+                        softLimit = observation;
+                    else
+                        hardLimit = observation;
+                    onProgress?.({ type: 'limit_reached', ...observation });
+                }
+                function buildTelemetry(durationMs) {
+                    const now = startedAt + durationMs;
+                    const activeToolDurationMs = activeToolCount > 0 && toolBusyStartedAt != null
+                        ? Math.max(0, now - toolBusyStartedAt)
+                        : 0;
+                    const totalToolWallClockDurationMs = toolWallClockDurationMs + activeToolDurationMs;
+                    const activityStarts = [
+                        firstThinkingAt,
+                        firstResponseAt,
+                        firstToolCallAt,
+                    ].filter((value) => value != null);
+                    const firstActivityAt = activityStarts.length > 0 ? Math.min(...activityStarts) : undefined;
+                    return {
+                        turnCount,
+                        assistantMessageCount,
+                        toolCallCount,
+                        toolWallClockDurationMs: totalToolWallClockDurationMs,
+                        nonToolDurationMs: Math.max(0, durationMs - totalToolWallClockDurationMs),
+                        ...(firstActivityAt == null
+                            ? {}
+                            : { timeToFirstActivityMs: firstActivityAt - startedAt }),
+                        ...(firstThinkingAt == null
+                            ? {}
+                            : { timeToFirstThinkingMs: firstThinkingAt - startedAt }),
+                        ...(firstResponseAt == null
+                            ? {}
+                            : { timeToFirstResponseMs: firstResponseAt - startedAt }),
+                        ...(firstToolCallAt == null
+                            ? {}
+                            : { timeToFirstToolCallMs: firstToolCallAt - startedAt }),
+                        ...(lastToolEndedAt == null
+                            ? {}
+                            : {
+                                finalizationAfterLastToolMs: Math.max(0, now - lastToolEndedAt),
+                            }),
+                        ...(softLimit ? { softLimit } : {}),
+                        ...(hardLimit ? { hardLimit } : {}),
+                    };
+                }
+                function resolveWithTelemetry(resolve, result) {
+                    resolve({
+                        ...result,
+                        telemetry: buildTelemetry(result.durationMs),
+                    });
+                }
+                function recordAssistantMessage(message, observedAt) {
+                    if (!message ||
+                        typeof message !== 'object' ||
+                        message.role !== 'assistant') {
+                        return false;
+                    }
+                    const stopReason = readStopReason(message);
+                    if (stopReason) {
+                        lastAssistantStopReason = stopReason;
+                    }
+                    const result = extractAssistantMessageResult(message);
+                    if (result?.text) {
+                        lastAssistantText = result.text;
+                        firstResponseAt ??= observedAt;
+                    }
+                    else if (result?.error) {
+                        lastAssistantError = result.error;
+                        firstResponseAt ??= observedAt;
+                    }
+                    return true;
+                }
                 function parseStdout(chunk) {
                     stdoutBuffer += chunk;
                     const lines = stdoutBuffer.split(/\r?\n/);
@@ -391,7 +580,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 sessionHeaderSeen = true;
                                 continue;
                             }
-                            maybeEmitProgress({
+                            const assistantMessageActivity = maybeEmitProgress({
                                 event: parsed,
                                 onProgress,
                                 lastThinkingAt,
@@ -399,9 +588,33 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 lastToolUpdateAt,
                                 toolStartedAt,
                             });
+                            if (parsed.type === 'turn_start') {
+                                turnCount += 1;
+                            }
+                            if (assistantMessageActivity?.type === 'thinking_delta') {
+                                firstThinkingAt ??= assistantMessageActivity.observedAt;
+                            }
+                            else if (assistantMessageActivity?.type === 'text_delta') {
+                                firstResponseAt ??= assistantMessageActivity.observedAt;
+                            }
                             if (parsed.type === 'tool_execution_start') {
                                 const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : null;
                                 if (toolName) {
+                                    const now = Date.now();
+                                    toolCallCount += 1;
+                                    firstToolCallAt ??= now;
+                                    if (activeToolCount === 0) {
+                                        toolBusyStartedAt = now;
+                                    }
+                                    activeToolCount += 1;
+                                    if (normalizedExecutionLimits?.softToolCalls != null &&
+                                        toolCallCount >= normalizedExecutionLimits.softToolCalls) {
+                                        markLimit('soft', 'tool_calls');
+                                    }
+                                    if (normalizedExecutionLimits?.hardToolCalls != null &&
+                                        toolCallCount >= normalizedExecutionLimits.hardToolCalls) {
+                                        markLimit('hard', 'tool_calls');
+                                    }
                                     const toolCallId = typeof parsed.toolCallId === 'string'
                                         ? parsed.toolCallId
                                         : toolName;
@@ -435,7 +648,14 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                     const startedAt = toolStartedAt.get(toolCallId);
                                     toolStartedAt.delete(toolCallId);
                                     if (startedAt != null) {
-                                        current.totalDurationMs += Math.max(0, Date.now() - startedAt);
+                                        activeToolCount = Math.max(0, activeToolCount - 1);
+                                        const now = Date.now();
+                                        lastToolEndedAt = now;
+                                        if (activeToolCount === 0 && toolBusyStartedAt != null) {
+                                            toolWallClockDurationMs += Math.max(0, now - toolBusyStartedAt);
+                                            toolBusyStartedAt = undefined;
+                                        }
+                                        current.totalDurationMs += Math.max(0, now - startedAt);
                                     }
                                     if (parsed.isError === true) {
                                         current.errorCount += 1;
@@ -444,37 +664,23 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 }
                             }
                             if (parsed.type === 'message_end') {
-                                // Read the stop reason regardless of whether the
-                                // message carried text or an error — a terminal
-                                // "length"/"error"/"aborted" ending must surface
-                                // even when there's no usable text.
-                                const stopReason = readStopReason(parsed.message);
-                                if (stopReason) {
-                                    lastAssistantStopReason = stopReason;
-                                }
-                                const result = extractAssistantMessageResult(parsed.message);
-                                if (result?.text) {
-                                    lastAssistantText = result.text;
-                                }
-                                else if (result?.error) {
-                                    lastAssistantError = result.error;
+                                if (recordAssistantMessage(parsed.message, Date.now())) {
+                                    assistantMessageCount += 1;
                                 }
                                 continue;
                             }
                             if (parsed.type === 'agent_end' && Array.isArray(parsed.messages)) {
+                                const observedAt = Date.now();
+                                let finalAssistantMessageCount = 0;
                                 for (const message of parsed.messages) {
-                                    const stopReason = readStopReason(message);
-                                    if (stopReason) {
-                                        lastAssistantStopReason = stopReason;
-                                    }
-                                    const result = extractAssistantMessageResult(message);
-                                    if (result?.text) {
-                                        lastAssistantText = result.text;
-                                    }
-                                    else if (result?.error) {
-                                        lastAssistantError = result.error;
+                                    if (recordAssistantMessage(message, observedAt)) {
+                                        finalAssistantMessageCount += 1;
                                     }
                                 }
+                                // agent_end repeats messages that were already
+                                // delivered through message_end. Use the larger
+                                // count so fallback-only output is captured once.
+                                assistantMessageCount = Math.max(assistantMessageCount, finalAssistantMessageCount);
                             }
                         }
                         catch {
@@ -485,10 +691,24 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                     }
                 }
                 return await new Promise((resolve) => {
+                    const limitTimeoutHandles = [];
+                    const softTimeMs = normalizedExecutionLimits?.softTimeMs;
+                    if (softTimeMs != null) {
+                        limitTimeoutHandles.push(setTimeout(() => markLimit('soft', 'time'), Math.max(0, softTimeMs - (Date.now() - startedAt))));
+                    }
+                    const hardTimeMs = normalizedExecutionLimits?.hardTimeMs;
+                    if (hardTimeMs != null) {
+                        limitTimeoutHandles.push(setTimeout(() => markLimit('hard', 'time'), Math.max(0, hardTimeMs - (Date.now() - startedAt))));
+                    }
                     const timeoutHandle = setTimeout(() => {
                         timedOut = true;
-                        child.kill('SIGTERM');
+                        child.kill(normalizedExecutionLimits ? 'SIGKILL' : 'SIGTERM');
                     }, timeoutMs);
+                    function clearTimers() {
+                        clearTimeout(timeoutHandle);
+                        for (const handle of limitTimeoutHandles)
+                            clearTimeout(handle);
+                    }
                     child.stdout.setEncoding('utf8');
                     child.stdout.on('data', (chunk) => {
                         parseStdout(chunk);
@@ -498,26 +718,28 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                         stderr += chunk;
                     });
                     child.on('error', (error) => {
-                        clearTimeout(timeoutHandle);
-                        resolve({
+                        clearTimers();
+                        const durationMs = Date.now() - startedAt;
+                        resolveWithTelemetry(resolve, {
                             ok: false,
                             error: error.message,
-                            durationMs: Date.now() - startedAt,
+                            durationMs,
                             timedOut,
                             toolUsage: toSortedToolUsage(toolUsageByName),
                             stopReason: lastAssistantStopReason,
                         });
                     });
                     child.on('close', (code, signal) => {
-                        clearTimeout(timeoutHandle);
+                        clearTimers();
+                        const durationMs = Date.now() - startedAt;
                         if (stdoutBuffer.trim()) {
                             parseStdout('\n');
                         }
                         if (timedOut) {
-                            resolve({
+                            resolveWithTelemetry(resolve, {
                                 ok: false,
                                 error: `Pi request timed out after ${timeoutMs}ms`,
-                                durationMs: Date.now() - startedAt,
+                                durationMs,
                                 timedOut: true,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
                                 stopReason: lastAssistantStopReason,
@@ -525,10 +747,10 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                             return;
                         }
                         if (signal) {
-                            resolve({
+                            resolveWithTelemetry(resolve, {
                                 ok: false,
                                 error: `Pi process terminated with signal ${signal}`,
-                                durationMs: Date.now() - startedAt,
+                                durationMs,
                                 timedOut: false,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
                                 stopReason: lastAssistantStopReason,
@@ -536,10 +758,10 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                             return;
                         }
                         if (code !== 0) {
-                            resolve({
+                            resolveWithTelemetry(resolve, {
                                 ok: false,
                                 error: stderr.trim() || `Pi exited with status ${String(code)}`,
-                                durationMs: Date.now() - startedAt,
+                                durationMs,
                                 timedOut: false,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
                                 stopReason: lastAssistantStopReason,
@@ -548,22 +770,22 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                         }
                         const output = lastAssistantText.trim();
                         if (!output) {
-                            resolve({
+                            resolveWithTelemetry(resolve, {
                                 ok: false,
                                 error: lastAssistantError ||
                                     stderr.trim() ||
                                     'Pi session did not produce an assistant response',
-                                durationMs: Date.now() - startedAt,
+                                durationMs,
                                 timedOut: false,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
                                 stopReason: lastAssistantStopReason,
                             });
                             return;
                         }
-                        resolve({
+                        resolveWithTelemetry(resolve, {
                             ok: true,
                             output,
-                            durationMs: Date.now() - startedAt,
+                            durationMs,
                             toolUsage: toSortedToolUsage(toolUsageByName),
                             stopReason: lastAssistantStopReason,
                         });
@@ -577,7 +799,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
         },
     };
 }
-export async function invokePiPrompt({ provider, apiKey, piProviderId, prompt, cwd, modelName, timeoutMs = 5 * 60 * 1000, extraEnv, images, capabilityPreset, thinkingLevel, systemPrompt, noContextFiles, openRouterSessionId, onProgress, }) {
+export async function invokePiPrompt({ provider, apiKey, piProviderId, prompt, cwd, modelName, timeoutMs = 5 * 60 * 1000, extraEnv, images, capabilityPreset, thinkingLevel, systemPrompt, noContextFiles, openRouterSessionId, executionLimits, onProgress, }) {
     return await createPiInvoker({
         provider,
         apiKey,
@@ -589,6 +811,7 @@ export async function invokePiPrompt({ provider, apiKey, piProviderId, prompt, c
         systemPrompt,
         noContextFiles,
         openRouterSessionId,
+        executionLimits,
         onProgress,
     }).invoke({
         prompt,