@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/core/pi.js

@@ -0,0 +1,870 @@
+import { spawn, spawnSync } from 'child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { endGeneration, startGeneration } from './langfuse-observation.js';
+import { logger } from './logging.js';
+import { PI_EXECUTION_LIMIT_ENV } from './pi-execution-limits-extension.js';
+import { approvedSkillArgs, buildToolEnvironment } from './tool-environment.js';
+import { recordEvent } from './tracing.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-6.1-sol',
+};
+export const DEFAULT_OPENROUTER_MODELS = {
+    deepseek: 'deepseek/deepseek-v4-pro-0813',
+    gemini: 'google/gemini-3.1-pro-preview',
+    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.8-flash';
+export const MAX_PI_THINKING_BY_PROVIDER = {
+    deepseek: 'high',
+    gemini: 'high',
+    grok: 'high',
+    zai: 'high',
+    openai: 'xhigh',
+};
+const PI_API_KEY_ENV_VAR_BY_PI_PROVIDER = {
+    google: 'GEMINI_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    'openai-codex': 'OPENAI_API_KEY',
+    openrouter: 'OPENROUTER_API_KEY',
+};
+const PI_PROVIDER_IDS = new Set(['google', 'openai', 'openai-codex', 'openrouter']);
+export const PI_AUTH_API_KEY_PREFIX = 'pi-auth://';
+const DOISTBOT_PI_SYSTEM_PROMPT = 'You are running inside doistbot in a non-interactive environment. Inspect the repository, configuration, documentation, and relevant history when they can improve accuracy. Use available tools proactively to gather evidence, avoid guessing when the workspace can answer the question, and follow the task prompt exactly.';
+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'],
+    autofix: [
+        'read',
+        'edit',
+        'write',
+        'grep',
+        'find',
+        'ls',
+        'verify',
+        'query_service',
+        'inspect_git',
+    ],
+};
+function resolvePiCliPath() {
+    const piPackageEntryPath = fileURLToPath(import.meta.resolve('@earendil-works/pi-coding-agent'));
+    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));
+const PI_TOOL_OUTPUT_FILTER_EXTENSION_PATH = fileURLToPath(new URL('./pi-tool-output-filter-extension.js', import.meta.url));
+const PI_AUTOFIX_EXTENSION_PATH = fileURLToPath(new URL('./pi-autofix-extension.js', import.meta.url));
+let cachedNodeExecutable;
+let cachedOpenRouterSessionExtensionPath;
+export function resolveNodeExecutable({ execPath = process.execPath, argv0 = process.argv0, canExecute = canExecuteNode, } = {}) {
+    const canUseCachedExecutable = execPath === process.execPath && argv0 === process.argv0 && canExecute === canExecuteNode;
+    if (canUseCachedExecutable && cachedNodeExecutable) {
+        return cachedNodeExecutable;
+    }
+    for (const candidate of [execPath, argv0, 'node']) {
+        if (candidate && canExecute(candidate)) {
+            if (canUseCachedExecutable) {
+                cachedNodeExecutable = candidate;
+            }
+            return candidate;
+        }
+    }
+    if (canUseCachedExecutable) {
+        cachedNodeExecutable = 'node';
+    }
+    return 'node';
+}
+function canExecuteNode(candidate) {
+    const result = spawnSync(candidate, ['--version'], { stdio: 'ignore' });
+    return result.status === 0;
+}
+function getPiModelSpec({ provider, piProviderId, modelName, thinkingLevel, }) {
+    const providerId = piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    const resolvedModelName = modelName ??
+        (providerId === 'openrouter' ? DEFAULT_OPENROUTER_MODELS[provider] : undefined) ??
+        DEFAULT_PI_MODELS[provider];
+    return `${providerId}/${resolvedModelName}:${thinkingLevel}`;
+}
+export function parsePiAuthProviderId(apiKey) {
+    if (!apiKey.startsWith(PI_AUTH_API_KEY_PREFIX)) {
+        return undefined;
+    }
+    const providerId = apiKey.slice(PI_AUTH_API_KEY_PREFIX.length);
+    return PI_PROVIDER_IDS.has(providerId)
+        ? providerId
+        : undefined;
+}
+function getImageExtension(mimeType) {
+    switch (mimeType) {
+        case 'image/png':
+            return '.png';
+        case 'image/jpeg':
+            return '.jpg';
+        case 'image/webp':
+            return '.webp';
+        case 'image/gif':
+            return '.gif';
+        case 'image/svg+xml':
+            return '.svg';
+        default:
+            return '.img';
+    }
+}
+function createImageArgs(images) {
+    if (!images?.length) {
+        return {
+            imageArgs: [],
+            cleanup() { },
+        };
+    }
+    const tempDir = mkdtempSync(path.join(tmpdir(), 'doistbot-pi-images-'));
+    const imageArgs = images.map((image, index) => {
+        const filePath = path.join(tempDir, `image-${index + 1}${getImageExtension(image.mimeType)}`);
+        writeFileSync(filePath, Buffer.from(image.data, 'base64'));
+        return `@${filePath}`;
+    });
+    return {
+        imageArgs,
+        cleanup() {
+            rmSync(tempDir, { force: true, recursive: true });
+        },
+    };
+}
+function normalizeOpenRouterSessionId(sessionId) {
+    const trimmed = sessionId?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.slice(0, OPENROUTER_SESSION_ID_MAX_LENGTH);
+}
+function getOpenRouterSessionExtensionPath() {
+    if (cachedOpenRouterSessionExtensionPath) {
+        return cachedOpenRouterSessionExtensionPath;
+    }
+    const tempDir = mkdtempSync(path.join(tmpdir(), 'doistbot-pi-openrouter-session-'));
+    const extensionPath = path.join(tempDir, 'openrouter-session-id.mjs');
+    writeFileSync(extensionPath, `export default function(pi) {
+  const sessionId = process.env[${JSON.stringify(OPENROUTER_SESSION_ID_ENV_VAR)}]
+  if (!sessionId) return
+
+  pi.on("before_provider_request", (event) => {
+    const payload = event.payload
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return undefined
+
+    return { ...payload, session_id: sessionId }
+  })
+}
+`);
+    process.once('exit', () => {
+        rmSync(tempDir, { force: true, recursive: true });
+    });
+    cachedOpenRouterSessionExtensionPath = extensionPath;
+    return extensionPath;
+}
+function createOpenRouterSessionExtension({ piProviderId, sessionId, }) {
+    const normalizedSessionId = normalizeOpenRouterSessionId(sessionId);
+    if (piProviderId !== 'openrouter' || !normalizedSessionId) {
+        return {
+            args: [],
+            extraEnv: {},
+            cleanup() { },
+        };
+    }
+    return {
+        args: ['--extension', getOpenRouterSessionExtensionPath()],
+        extraEnv: {
+            [OPENROUTER_SESSION_ID_ENV_VAR]: normalizedSessionId,
+        },
+        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 [];
+    }
+    return content
+        .flatMap((item) => {
+        if (!item || typeof item !== 'object' || !('type' in item) || !('text' in item)) {
+            return [];
+        }
+        const type = item.type;
+        const text = item.text;
+        return type === 'text' && typeof text === 'string' ? [text.trim()] : [];
+    })
+        .filter(Boolean);
+}
+function extractAssistantMessageResult(message) {
+    if (!message || typeof message !== 'object') {
+        return null;
+    }
+    const role = message.role;
+    if (role !== 'assistant') {
+        return null;
+    }
+    const content = message.content;
+    const text = extractTextSegments(content).join('\n').trim();
+    if (text) {
+        return { text };
+    }
+    const errorMessage = message.errorMessage;
+    return typeof errorMessage === 'string' && errorMessage.trim()
+        ? { error: errorMessage.trim() }
+        : null;
+}
+function readStopReason(message) {
+    if (!message || typeof message !== 'object') {
+        return undefined;
+    }
+    const stopReason = message.stopReason;
+    // pi's stopReason follows the PiStopReason contract; cast rather than
+    // re-validate against a runtime list that would duplicate the union.
+    return typeof stopReason === 'string' ? stopReason : undefined;
+}
+function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt, lastToolUpdateAt, toolStartedAt, }) {
+    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' });
+            return;
+        case 'agent_end':
+            onProgress({ type: 'agent_end' });
+            return;
+        case 'tool_execution_start': {
+            const toolName = event.toolName;
+            if (typeof toolName === 'string' && toolName.length > 0) {
+                const toolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : undefined;
+                onProgress({ type: 'tool_start', toolName, ...(toolCallId ? { toolCallId } : {}) });
+            }
+            return;
+        }
+        case 'tool_execution_update': {
+            const toolName = event.toolName;
+            if (typeof toolName !== 'string' || toolName.length === 0) {
+                return;
+            }
+            const rawToolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : undefined;
+            const toolCallId = rawToolCallId ?? toolName;
+            const now = Date.now();
+            const lastUpdateAt = lastToolUpdateAt.get(toolCallId) ?? 0;
+            if (now - lastUpdateAt >= PI_PROGRESS_HEARTBEAT_MS) {
+                lastToolUpdateAt.set(toolCallId, now);
+                onProgress({
+                    type: 'tool_update',
+                    toolName,
+                    ...(rawToolCallId ? { toolCallId: rawToolCallId } : {}),
+                });
+            }
+            return;
+        }
+        case 'tool_execution_end': {
+            const toolName = event.toolName;
+            if (typeof toolName === 'string' && toolName.length > 0) {
+                const rawToolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : undefined;
+                const toolCallId = rawToolCallId ?? toolName;
+                const startedAt = toolStartedAt.get(toolCallId);
+                onProgress({
+                    type: 'tool_end',
+                    toolName,
+                    ...(rawToolCallId ? { toolCallId: rawToolCallId } : {}),
+                    isError: event.isError === true,
+                    durationMs: startedAt == null ? undefined : Math.max(0, Date.now() - startedAt),
+                });
+            }
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function toSortedToolUsage(toolUsageByName) {
+    return [...toolUsageByName.values()].sort((left, right) => {
+        if (right.totalDurationMs !== left.totalDurationMs) {
+            return right.totalDurationMs - left.totalDurationMs;
+        }
+        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, executionLimits, onProgress, }) {
+    const normalizedExecutionLimits = normalizePiExecutionLimits(executionLimits);
+    return {
+        async invoke({ prompt, modelName, timeoutMs = 5 * 60 * 1000, images, }) {
+            const startedAt = Date.now();
+            const piAuthProviderId = parsePiAuthProviderId(apiKey);
+            const resolvedPiProviderId = piAuthProviderId ?? piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+            const modelSpec = getPiModelSpec({
+                provider,
+                piProviderId: resolvedPiProviderId,
+                modelName,
+                thinkingLevel: thinkingLevel ?? MAX_PI_THINKING_BY_PROVIDER[provider],
+            });
+            const { imageArgs, cleanup } = createImageArgs(images);
+            const openRouterSessionExtension = createOpenRouterSessionExtension({
+                piProviderId: resolvedPiProviderId,
+                sessionId: openRouterSessionId,
+            });
+            const executionLimitExtension = createExecutionLimitExtension(normalizedExecutionLimits, startedAt);
+            const tools = PI_TOOLS_BY_PRESET[capabilityPreset].join(',');
+            const args = [
+                PI_CLI_PATH,
+                '--mode',
+                'json',
+                '--no-session',
+                '--no-extensions',
+                ...(process.env.SANDBOX_PROFILE || capabilityPreset === 'autofix'
+                    ? ['--extension', PI_TOOL_OUTPUT_FILTER_EXTENSION_PATH]
+                    : []),
+                '--no-skills',
+                ...(capabilityPreset === 'autofix' ? [] : approvedSkillArgs()),
+                '--no-prompt-templates',
+                ...(noContextFiles ? ['--no-context-files'] : []),
+                '--model',
+                modelSpec,
+                ...(capabilityPreset === 'none' ? ['--no-tools'] : ['--tools', tools]),
+                '--system-prompt',
+                systemPrompt,
+                ...openRouterSessionExtension.args,
+                ...executionLimitExtension.args,
+                ...(capabilityPreset === 'autofix'
+                    ? ['--extension', PI_AUTOFIX_EXTENSION_PATH]
+                    : []),
+                ...imageArgs,
+            ];
+            const childEnv = buildToolEnvironment({
+                ...extraEnv,
+                ...openRouterSessionExtension.extraEnv,
+                ...executionLimitExtension.extraEnv,
+            });
+            const apiKeyEnvVar = PI_API_KEY_ENV_VAR_BY_PI_PROVIDER[resolvedPiProviderId];
+            if (piAuthProviderId) {
+                delete childEnv[apiKeyEnvVar];
+            }
+            else {
+                childEnv[apiKeyEnvVar] = apiKey;
+            }
+            const generation = startGeneration('pi.invoke', prompt);
+            try {
+                const child = spawn(resolveNodeExecutable(), args, {
+                    cwd,
+                    env: childEnv,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                child.stdin?.on('error', () => { });
+                child.stdin?.end(prompt);
+                let timedOut = false;
+                let stdoutBuffer = '';
+                let stderr = '';
+                let lastAssistantText = '';
+                let lastAssistantError = '';
+                let lastAssistantStopReason;
+                let sessionHeaderSeen = false;
+                const lastThinkingAt = { value: 0 };
+                const lastRespondingAt = { value: 0 };
+                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/);
+                    stdoutBuffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed) {
+                            continue;
+                        }
+                        try {
+                            const parsed = JSON.parse(trimmed);
+                            if (parsed.type === 'doistbot_tool_audit') {
+                                logger.info('Sandbox tool query', {
+                                    tool: parsed.tool,
+                                    input: parsed.input,
+                                });
+                                continue;
+                            }
+                            if (parsed.type === 'doistbot_verification_result' ||
+                                parsed.type === 'doistbot_tool_result') {
+                                const { type, ...fields } = parsed;
+                                recordEvent(type === 'doistbot_verification_result'
+                                    ? 'autofix.check.result'
+                                    : 'autofix.tool.result', {
+                                    ...fields,
+                                    output: typeof fields.output === 'string'
+                                        ? fields.output.slice(-4000)
+                                        : '',
+                                });
+                                continue;
+                            }
+                            if (parsed.type === 'session') {
+                                sessionHeaderSeen = true;
+                                continue;
+                            }
+                            const assistantMessageActivity = maybeEmitProgress({
+                                event: parsed,
+                                onProgress,
+                                lastThinkingAt,
+                                lastRespondingAt,
+                                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;
+                                    toolStartedAt.set(toolCallId, Date.now());
+                                    const current = toolUsageByName.get(toolName);
+                                    if (current) {
+                                        current.calls += 1;
+                                    }
+                                    else {
+                                        toolUsageByName.set(toolName, {
+                                            toolName,
+                                            calls: 1,
+                                            totalDurationMs: 0,
+                                            errorCount: 0,
+                                        });
+                                    }
+                                }
+                            }
+                            if (parsed.type === 'tool_execution_end') {
+                                const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : null;
+                                if (toolName) {
+                                    const current = toolUsageByName.get(toolName) ?? {
+                                        toolName,
+                                        calls: 0,
+                                        totalDurationMs: 0,
+                                        errorCount: 0,
+                                    };
+                                    const toolCallId = typeof parsed.toolCallId === 'string'
+                                        ? parsed.toolCallId
+                                        : toolName;
+                                    const startedAt = toolStartedAt.get(toolCallId);
+                                    toolStartedAt.delete(toolCallId);
+                                    if (startedAt != null) {
+                                        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;
+                                    }
+                                    toolUsageByName.set(toolName, current);
+                                }
+                            }
+                            if (parsed.type === 'message_end') {
+                                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) {
+                                    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 {
+                            if (!sessionHeaderSeen && !lastAssistantText) {
+                                lastAssistantText = trimmed;
+                            }
+                        }
+                    }
+                }
+                const result = 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))));
+                    }
+                    let forceKillHandle;
+                    const timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        child.kill(normalizedExecutionLimits ? 'SIGKILL' : 'SIGTERM');
+                        if (capabilityPreset === 'autofix')
+                            forceKillHandle = setTimeout(() => child.kill('SIGKILL'), 2000);
+                    }, timeoutMs);
+                    function clearTimers() {
+                        clearTimeout(timeoutHandle);
+                        if (forceKillHandle)
+                            clearTimeout(forceKillHandle);
+                        for (const handle of limitTimeoutHandles)
+                            clearTimeout(handle);
+                    }
+                    child.stdout.setEncoding('utf8');
+                    child.stdout.on('data', (chunk) => {
+                        parseStdout(chunk);
+                    });
+                    child.stderr.setEncoding('utf8');
+                    child.stderr.on('data', (chunk) => {
+                        stderr += chunk;
+                    });
+                    child.on('error', (error) => {
+                        clearTimers();
+                        const durationMs = Date.now() - startedAt;
+                        resolveWithTelemetry(resolve, {
+                            ok: false,
+                            error: error.message,
+                            durationMs,
+                            timedOut,
+                            toolUsage: toSortedToolUsage(toolUsageByName),
+                            stopReason: lastAssistantStopReason,
+                        });
+                    });
+                    child.on('close', (code, signal) => {
+                        clearTimers();
+                        const durationMs = Date.now() - startedAt;
+                        if (stdoutBuffer.trim()) {
+                            parseStdout('\n');
+                        }
+                        if (timedOut) {
+                            resolveWithTelemetry(resolve, {
+                                ok: false,
+                                error: `Pi request timed out after ${timeoutMs}ms`,
+                                durationMs,
+                                timedOut: true,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
+                            });
+                            return;
+                        }
+                        if (signal) {
+                            resolveWithTelemetry(resolve, {
+                                ok: false,
+                                error: `Pi process terminated with signal ${signal}`,
+                                durationMs,
+                                timedOut: false,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
+                            });
+                            return;
+                        }
+                        if (code !== 0) {
+                            resolveWithTelemetry(resolve, {
+                                ok: false,
+                                error: stderr.trim() || `Pi exited with status ${String(code)}`,
+                                durationMs,
+                                timedOut: false,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
+                            });
+                            return;
+                        }
+                        const output = lastAssistantText.trim();
+                        if (!output) {
+                            resolveWithTelemetry(resolve, {
+                                ok: false,
+                                error: lastAssistantError ||
+                                    stderr.trim() ||
+                                    'Pi session did not produce an assistant response',
+                                durationMs,
+                                timedOut: false,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
+                            });
+                            return;
+                        }
+                        resolveWithTelemetry(resolve, {
+                            ok: true,
+                            output,
+                            durationMs,
+                            toolUsage: toSortedToolUsage(toolUsageByName),
+                            stopReason: lastAssistantStopReason,
+                        });
+                    });
+                });
+                endGeneration(generation, result.ok ? { output: result.output } : { error: result.error });
+                return result;
+            }
+            finally {
+                cleanup();
+                openRouterSessionExtension.cleanup();
+            }
+        },
+    };
+}
+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,
+        piProviderId,
+        cwd,
+        extraEnv,
+        capabilityPreset,
+        thinkingLevel,
+        systemPrompt,
+        noContextFiles,
+        openRouterSessionId,
+        executionLimits,
+        onProgress,
+    }).invoke({
+        prompt,
+        modelName,
+        timeoutMs,
+        images,
+    });
+}
+export function buildPiImageContent({ dataBase64, contentType, }) {
+    return {
+        type: 'image',
+        data: dataBase64,
+        mimeType: contentType,
+    };
+}