@doist/doistbot-cli 1.0.4 → 1.0.6

package/sandbox/dist/core/pi.js

@@ -3,41 +3,53 @@ import { mkdtempSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
-const PI_PROVIDER_BY_DOISTBOT_PROVIDER = {
+export const PI_PROVIDER_BY_DOISTBOT_PROVIDER = {
+    deepseek: 'openrouter',
     gemini: 'google',
+    zai: 'openrouter',
     openai: 'openai',
-    anthropic: 'anthropic',
-};
-const PI_API_KEY_ENV_VAR_BY_PROVIDER = {
-    gemini: 'GEMINI_API_KEY',
-    openai: 'OPENAI_API_KEY',
-    anthropic: 'ANTHROPIC_API_KEY',
 };
 export const DEFAULT_PI_MODELS = {
+    deepseek: 'deepseek-v4-pro',
     gemini: 'gemini-3.1-pro-preview',
-    openai: 'gpt-5.4',
-    anthropic: 'claude-opus-4-6',
+    zai: 'glm5.2',
+    openai: 'gpt-5.5',
+};
+export const DEFAULT_OPENROUTER_MODELS = {
+    deepseek: 'deepseek/deepseek-v4-pro',
+    gemini: 'google/gemini-3.1-pro-preview',
+    zai: 'z-ai/glm-5.2',
 };
 export const MAX_PI_THINKING_BY_PROVIDER = {
+    deepseek: 'high',
     gemini: 'high',
+    zai: 'high',
     openai: 'xhigh',
-    anthropic: 'xhigh',
 };
-const PI_PROVIDER_IDS = new Set(['google', 'openai', 'openai-codex', 'anthropic']);
+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 = {
     'read-only': ['read', 'grep', 'find', 'ls'],
     'workspace-inspection': ['read', 'bash', 'grep', 'find', 'ls'],
     'shell-focused': ['read', 'bash', 'ls'],
 };
 function resolvePiCliPath() {
-    const piPackageEntryPath = fileURLToPath(import.meta.resolve('@mariozechner/pi-coding-agent'));
+    const piPackageEntryPath = fileURLToPath(import.meta.resolve('@earendil-works/pi-coding-agent'));
     return path.join(path.dirname(piPackageEntryPath), 'cli.js');
 }
 const PI_CLI_PATH = resolvePiCliPath();
 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) {
@@ -62,10 +74,12 @@ function canExecuteNode(candidate) {
 }
 function getPiModelSpec({ provider, piProviderId, modelName, thinkingLevel, }) {
     const providerId = piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
-    const resolvedModelName = modelName ?? DEFAULT_PI_MODELS[provider];
+    const resolvedModelName = modelName ??
+        (providerId === 'openrouter' ? DEFAULT_OPENROUTER_MODELS[provider] : undefined) ??
+        DEFAULT_PI_MODELS[provider];
     return `${providerId}/${resolvedModelName}:${thinkingLevel}`;
 }
-function parsePiAuthProviderId(apiKey) {
+export function parsePiAuthProviderId(apiKey) {
     if (!apiKey.startsWith(PI_AUTH_API_KEY_PREFIX)) {
         return undefined;
     }
@@ -110,6 +124,54 @@ function createImageArgs(images) {
         },
     };
 }
+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 extractTextSegments(content) {
     if (!Array.isArray(content)) {
         return [];
@@ -176,7 +238,8 @@ function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt
         case 'tool_execution_start': {
             const toolName = event.toolName;
             if (typeof toolName === 'string' && toolName.length > 0) {
-                onProgress({ type: 'tool_start', toolName });
+                const toolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : undefined;
+                onProgress({ type: 'tool_start', toolName, ...(toolCallId ? { toolCallId } : {}) });
             }
             return;
         }
@@ -185,23 +248,30 @@ function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt
             if (typeof toolName !== 'string' || toolName.length === 0) {
                 return;
             }
-            const toolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : toolName;
+            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 });
+                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 toolCallId = typeof event.toolCallId === 'string' ? event.toolCallId : toolName;
+                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),
                 });
@@ -217,18 +287,23 @@ 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, onProgress, }) {
+export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv, capabilityPreset = 'workspace-inspection', thinkingLevel, systemPrompt = DOISTBOT_PI_SYSTEM_PROMPT, noContextFiles = false, openRouterSessionId, onProgress, }) {
     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: piAuthProviderId ?? piProviderId,
+                piProviderId: resolvedPiProviderId,
                 modelName,
                 thinkingLevel: thinkingLevel ?? MAX_PI_THINKING_BY_PROVIDER[provider],
             });
             const { imageArgs, cleanup } = createImageArgs(images);
+            const openRouterSessionExtension = createOpenRouterSessionExtension({
+                piProviderId: resolvedPiProviderId,
+                sessionId: openRouterSessionId,
+            });
             const tools = PI_TOOLS_BY_PRESET[capabilityPreset].join(',');
             const args = [
                 PI_CLI_PATH,
@@ -238,12 +313,14 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 '--no-extensions',
                 '--no-skills',
                 '--no-prompt-templates',
+                ...(noContextFiles ? ['--no-context-files'] : []),
                 '--model',
                 modelSpec,
                 '--tools',
                 tools,
                 '--system-prompt',
                 systemPrompt,
+                ...openRouterSessionExtension.args,
                 ...imageArgs,
             ];
             const childEnv = {
@@ -252,8 +329,9 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 PATH: process.env.PATH,
                 GIT_TERMINAL_PROMPT: '0',
                 ...extraEnv,
+                ...openRouterSessionExtension.extraEnv,
             };
-            const apiKeyEnvVar = PI_API_KEY_ENV_VAR_BY_PROVIDER[provider];
+            const apiKeyEnvVar = PI_API_KEY_ENV_VAR_BY_PI_PROVIDER[resolvedPiProviderId];
             if (piAuthProviderId) {
                 delete childEnv[apiKeyEnvVar];
             }
@@ -261,205 +339,209 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 childEnv[apiKeyEnvVar] = apiKey;
             }
             delete childEnv.GITHUB_TOKEN;
-            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 sessionHeaderSeen = false;
-            const lastThinkingAt = { value: 0 };
-            const lastRespondingAt = { value: 0 };
-            const lastToolUpdateAt = new Map();
-            const toolStartedAt = new Map();
-            const toolUsageByName = new Map();
-            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 === 'session') {
-                            sessionHeaderSeen = true;
+            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 sessionHeaderSeen = false;
+                const lastThinkingAt = { value: 0 };
+                const lastRespondingAt = { value: 0 };
+                const lastToolUpdateAt = new Map();
+                const toolStartedAt = new Map();
+                const toolUsageByName = new Map();
+                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;
                         }
-                        maybeEmitProgress({
-                            event: parsed,
-                            onProgress,
-                            lastThinkingAt,
-                            lastRespondingAt,
-                            lastToolUpdateAt,
-                            toolStartedAt,
-                        });
-                        if (parsed.type === 'tool_execution_start') {
-                            const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : null;
-                            if (toolName) {
-                                const toolCallId = typeof parsed.toolCallId === 'string'
-                                    ? parsed.toolCallId
-                                    : toolName;
-                                toolStartedAt.set(toolCallId, Date.now());
-                                const current = toolUsageByName.get(toolName);
-                                if (current) {
-                                    current.calls += 1;
+                        try {
+                            const parsed = JSON.parse(trimmed);
+                            if (parsed.type === 'session') {
+                                sessionHeaderSeen = true;
+                                continue;
+                            }
+                            maybeEmitProgress({
+                                event: parsed,
+                                onProgress,
+                                lastThinkingAt,
+                                lastRespondingAt,
+                                lastToolUpdateAt,
+                                toolStartedAt,
+                            });
+                            if (parsed.type === 'tool_execution_start') {
+                                const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : null;
+                                if (toolName) {
+                                    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,
+                                        });
+                                    }
                                 }
-                                else {
-                                    toolUsageByName.set(toolName, {
+                            }
+                            if (parsed.type === 'tool_execution_end') {
+                                const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : null;
+                                if (toolName) {
+                                    const current = toolUsageByName.get(toolName) ?? {
                                         toolName,
-                                        calls: 1,
+                                        calls: 0,
                                         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) {
-                                    current.totalDurationMs += Math.max(0, Date.now() - startedAt);
+                                    };
+                                    const toolCallId = typeof parsed.toolCallId === 'string'
+                                        ? parsed.toolCallId
+                                        : toolName;
+                                    const startedAt = toolStartedAt.get(toolCallId);
+                                    toolStartedAt.delete(toolCallId);
+                                    if (startedAt != null) {
+                                        current.totalDurationMs += Math.max(0, Date.now() - startedAt);
+                                    }
+                                    if (parsed.isError === true) {
+                                        current.errorCount += 1;
+                                    }
+                                    toolUsageByName.set(toolName, current);
                                 }
-                                if (parsed.isError === true) {
-                                    current.errorCount += 1;
-                                }
-                                toolUsageByName.set(toolName, current);
-                            }
-                        }
-                        if (parsed.type === 'message_end') {
-                            const result = extractAssistantMessageResult(parsed.message);
-                            if (result?.text) {
-                                lastAssistantText = result.text;
-                            }
-                            else if (result?.error) {
-                                lastAssistantError = result.error;
                             }
-                            continue;
-                        }
-                        if (parsed.type === 'agent_end' && Array.isArray(parsed.messages)) {
-                            for (const message of parsed.messages) {
-                                const result = extractAssistantMessageResult(message);
+                            if (parsed.type === 'message_end') {
+                                const result = extractAssistantMessageResult(parsed.message);
                                 if (result?.text) {
                                     lastAssistantText = result.text;
                                 }
                                 else if (result?.error) {
                                     lastAssistantError = result.error;
                                 }
+                                continue;
+                            }
+                            if (parsed.type === 'agent_end' && Array.isArray(parsed.messages)) {
+                                for (const message of parsed.messages) {
+                                    const result = extractAssistantMessageResult(message);
+                                    if (result?.text) {
+                                        lastAssistantText = result.text;
+                                    }
+                                    else if (result?.error) {
+                                        lastAssistantError = result.error;
+                                    }
+                                }
                             }
                         }
-                    }
-                    catch {
-                        if (!sessionHeaderSeen && !lastAssistantText) {
-                            lastAssistantText = trimmed;
+                        catch {
+                            if (!sessionHeaderSeen && !lastAssistantText) {
+                                lastAssistantText = trimmed;
+                            }
                         }
                     }
                 }
-            }
-            const result = await new Promise((resolve) => {
-                const timeoutHandle = setTimeout(() => {
-                    timedOut = true;
-                    child.kill('SIGTERM');
-                }, timeoutMs);
-                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) => {
-                    clearTimeout(timeoutHandle);
-                    resolve({
-                        ok: false,
-                        error: error.message,
-                        durationMs: Date.now() - startedAt,
-                        timedOut,
-                        toolUsage: toSortedToolUsage(toolUsageByName),
+                return await new Promise((resolve) => {
+                    const timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        child.kill('SIGTERM');
+                    }, timeoutMs);
+                    child.stdout.setEncoding('utf8');
+                    child.stdout.on('data', (chunk) => {
+                        parseStdout(chunk);
                     });
-                });
-                child.on('close', (code, signal) => {
-                    clearTimeout(timeoutHandle);
-                    if (stdoutBuffer.trim()) {
-                        parseStdout('\n');
-                    }
-                    if (timedOut) {
-                        resolve({
-                            ok: false,
-                            error: `Pi request timed out after ${timeoutMs}ms`,
-                            durationMs: Date.now() - startedAt,
-                            timedOut: true,
-                            toolUsage: toSortedToolUsage(toolUsageByName),
-                        });
-                        return;
-                    }
-                    if (signal) {
-                        resolve({
-                            ok: false,
-                            error: `Pi process terminated with signal ${signal}`,
-                            durationMs: Date.now() - startedAt,
-                            timedOut: false,
-                            toolUsage: toSortedToolUsage(toolUsageByName),
-                        });
-                        return;
-                    }
-                    if (code !== 0) {
+                    child.stderr.setEncoding('utf8');
+                    child.stderr.on('data', (chunk) => {
+                        stderr += chunk;
+                    });
+                    child.on('error', (error) => {
+                        clearTimeout(timeoutHandle);
                         resolve({
                             ok: false,
-                            error: stderr.trim() || `Pi exited with status ${String(code)}`,
+                            error: error.message,
                             durationMs: Date.now() - startedAt,
-                            timedOut: false,
+                            timedOut,
                             toolUsage: toSortedToolUsage(toolUsageByName),
                         });
-                        return;
-                    }
-                    const output = lastAssistantText.trim();
-                    if (!output) {
+                    });
+                    child.on('close', (code, signal) => {
+                        clearTimeout(timeoutHandle);
+                        if (stdoutBuffer.trim()) {
+                            parseStdout('\n');
+                        }
+                        if (timedOut) {
+                            resolve({
+                                ok: false,
+                                error: `Pi request timed out after ${timeoutMs}ms`,
+                                durationMs: Date.now() - startedAt,
+                                timedOut: true,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                            });
+                            return;
+                        }
+                        if (signal) {
+                            resolve({
+                                ok: false,
+                                error: `Pi process terminated with signal ${signal}`,
+                                durationMs: Date.now() - startedAt,
+                                timedOut: false,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                            });
+                            return;
+                        }
+                        if (code !== 0) {
+                            resolve({
+                                ok: false,
+                                error: stderr.trim() || `Pi exited with status ${String(code)}`,
+                                durationMs: Date.now() - startedAt,
+                                timedOut: false,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                            });
+                            return;
+                        }
+                        const output = lastAssistantText.trim();
+                        if (!output) {
+                            resolve({
+                                ok: false,
+                                error: lastAssistantError ||
+                                    stderr.trim() ||
+                                    'Pi session did not produce an assistant response',
+                                durationMs: Date.now() - startedAt,
+                                timedOut: false,
+                                toolUsage: toSortedToolUsage(toolUsageByName),
+                            });
+                            return;
+                        }
                         resolve({
-                            ok: false,
-                            error: lastAssistantError ||
-                                stderr.trim() ||
-                                'Pi session did not produce an assistant response',
+                            ok: true,
+                            output,
                             durationMs: Date.now() - startedAt,
-                            timedOut: false,
                             toolUsage: toSortedToolUsage(toolUsageByName),
                         });
-                        return;
-                    }
-                    resolve({
-                        ok: true,
-                        output,
-                        durationMs: Date.now() - startedAt,
-                        toolUsage: toSortedToolUsage(toolUsageByName),
                     });
                 });
-            });
-            cleanup();
-            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, onProgress, }) {
+export async function invokePiPrompt({ provider, apiKey, piProviderId, prompt, cwd, modelName, timeoutMs = 5 * 60 * 1000, extraEnv, images, capabilityPreset, thinkingLevel, systemPrompt, noContextFiles, openRouterSessionId, onProgress, }) {
     return await createPiInvoker({
         provider,
         apiKey,
@@ -469,6 +551,8 @@ export async function invokePiPrompt({ provider, apiKey, piProviderId, prompt, c
         capabilityPreset,
         thinkingLevel,
         systemPrompt,
+        noContextFiles,
+        openRouterSessionId,
         onProgress,
     }).invoke({
         prompt,

package/sandbox/dist/core/tracing-setup.js

@@ -0,0 +1,15 @@
+import { context, trace } from '@opentelemetry/api';
+import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
+import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import { LoggerSpanProcessor } from './logger-span-processor.js';
+let registered = false;
+export function setupTracing() {
+    if (registered)
+        return;
+    registered = true;
+    context.setGlobalContextManager(new AsyncLocalStorageContextManager());
+    const provider = new BasicTracerProvider({
+        spanProcessors: [new LoggerSpanProcessor()],
+    });
+    trace.setGlobalTracerProvider(provider);
+}