@doist/doistbot-cli 1.0.5 → 1.0.6

package/sandbox/dist/core/tracing.js

@@ -0,0 +1,71 @@
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
+// recordDecision/recordEvent emit directly (bypassing the processor), so they
+// apply the same per-attribute cap themselves to keep large arrays/objects
+// from blowing the log-size budget.
+import { truncateAttrs } from './logger-span-processor.js';
+import { logger } from './logging.js';
+const tracer = trace.getTracer('doistbot-sandbox');
+/**
+ * THE phase-boundary API. Works for sequential AND parallel phases — OTel's
+ * async-hooks context manager (registered by setupTracing) parents nested
+ * spans correctly even across Promise.all.
+ *
+ * On throw: records the exception, sets span status ERROR, re-throws.
+ * On normal return: status is left UNSET (OTel's recommended success default;
+ *   the LoggerSpanProcessor maps UNSET → 'ok'). We deliberately do NOT force
+ *   OK, so a callback that returns a failure result (instead of throwing) and
+ *   sets ERROR itself keeps its ERROR status.
+ * Always ends the span.
+ */
+export async function withPhase(name, attributes, fn) {
+    return tracer.startActiveSpan(name, { attributes: { ...attributes, 'doistbot.kind': 'phase' } }, async (span) => {
+        try {
+            return await fn(span);
+        }
+        catch (err) {
+            span.recordException(err);
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+/**
+ * Start a tool span manually. The ONE exception to "withPhase everywhere":
+ * pi emits tool start/end across separate async callbacks (onProgress), so
+ * there is no single scope to wrap. Parent = the currently-active span (the
+ * model phase). Caller MUST call `span.end()` when the matching tool_end
+ * arrives (and may `setStatus({ code: ERROR })` first on failure).
+ */
+export function startToolSpan(name, attributes) {
+    return tracer.startSpan(name, { attributes: { ...attributes, 'doistbot.kind': 'tool' } }, context.active());
+}
+// Point-in-time lines bypass OTel spans entirely; they read the active span
+// id only for correlation. Meta is spread FIRST so callers can never clobber
+// the envelope fields (event/name/span_id). Timestamps come from the logging
+// system, never from meta.
+function emitPointInTime(kind, name, meta) {
+    const span = trace.getActiveSpan();
+    logger.info(`${kind}: ${name}`, {
+        ...truncateAttrs(meta),
+        event: kind,
+        name,
+        span_id: span?.spanContext().spanId ?? null,
+    });
+}
+/**
+ * Record a point-in-time decision (branch taken, scope resolved, gate passed)
+ * correlated to the active span. Not a span — no duration.
+ */
+export function recordDecision(name, meta) {
+    emitPointInTime('decision', name, meta);
+}
+/** Generic point-in-time annotation. Same mechanics as recordDecision. */
+export function recordEvent(name, meta) {
+    emitPointInTime('event', name, meta);
+}

package/sandbox/dist/main.js

@@ -1,3 +1,7 @@
+import { setupTracing } from './core/tracing-setup.js';
+// Register the OTel SDK before any task module loads — withPhase/startToolSpan
+// are no-ops until a tracer provider is registered.
+setupTracing();
 const taskType = process.env.TASK_TYPE ?? 'review';
 switch (taskType) {
     case 'chat':
@@ -32,4 +36,3 @@ switch (taskType) {
         process.stderr.write(`Unknown TASK_TYPE: ${taskType}\n`);
         process.exit(1);
 }
-export {};

package/sandbox/dist/providers/credentials.js

@@ -1,7 +1,15 @@
+import { parsePiAuthProviderId } from '../core/pi.js';
 export function resolveReviewProviderCredential(credential) {
     if (typeof credential === 'string') {
         const apiKey = credential.trim();
-        return apiKey ? { apiKey } : undefined;
+        if (!apiKey) {
+            return undefined;
+        }
+        const piAuthProviderId = parsePiAuthProviderId(apiKey);
+        return {
+            apiKey,
+            ...(piAuthProviderId ? { piProviderId: piAuthProviderId } : {}),
+        };
     }
     if (!credential) {
         return undefined;
@@ -10,9 +18,11 @@ export function resolveReviewProviderCredential(credential) {
     if (!apiKey) {
         return undefined;
     }
+    const piAuthProviderId = parsePiAuthProviderId(apiKey);
+    const piProviderId = piAuthProviderId ?? credential.piProviderId;
     return {
         apiKey,
-        ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
+        ...(piProviderId ? { piProviderId } : {}),
         ...(credential.modelName ? { modelName: credential.modelName } : {}),
     };
 }

package/sandbox/dist/providers/gemini.js

@@ -9,7 +9,11 @@ import { runPiReviewProvider } from './pi-review.js';
 export class GeminiProvider {
     name = 'gemini';
     async review(prompt, config) {
-        const modelName = config.modelName ?? DEFAULT_OPENROUTER_MODELS.gemini ?? DEFAULT_PI_MODELS.gemini;
+        const modelName = config.modelName ??
+            (config.piProviderId === 'openrouter'
+                ? DEFAULT_OPENROUTER_MODELS.gemini
+                : DEFAULT_PI_MODELS.gemini) ??
+            DEFAULT_PI_MODELS.gemini;
         return await runPiReviewProvider({
             provider: this.name,
             modelName,

package/sandbox/dist/providers/helpers.js

@@ -166,29 +166,24 @@ function extractBalancedJsonCandidates(content) {
     }
     return candidates;
 }
+/**
+ * Returns JSON-looking candidates from a response string in parser preference order.
+ * Fenced JSON blocks are preferred over balanced objects because models often include
+ * code snippets or object-shaped prose before the final fenced response.
+ */
+export function extractJsonCandidatesFromResponse(content) {
+    return [
+        ...extractFencedJsonCandidates(content).reverse(),
+        ...extractBalancedJsonCandidates(content).reverse(),
+    ];
+}
 /**
  * Extracts JSON from a response string that may contain additional text.
  * Prefers valid fenced JSON blocks, then valid balanced JSON objects.
  * Throws when no valid JSON candidate can be parsed.
  */
 export function extractJsonFromResponse(content) {
-    const fencedCandidates = extractFencedJsonCandidates(content);
-    for (let index = fencedCandidates.length - 1; index >= 0; index--) {
-        const candidate = fencedCandidates[index];
-        if (!candidate) {
-            continue;
-        }
-        try {
-            JSON.parse(candidate);
-            return candidate;
-        }
-        catch {
-            continue;
-        }
-    }
-    const balancedCandidates = extractBalancedJsonCandidates(content);
-    for (let index = balancedCandidates.length - 1; index >= 0; index--) {
-        const candidate = balancedCandidates[index];
+    for (const candidate of extractJsonCandidatesFromResponse(content)) {
         if (!candidate) {
             continue;
         }

package/sandbox/dist/providers/index.js

@@ -3,11 +3,15 @@
  */
 import { GeminiProvider } from './gemini.js';
 import { OpenAIProvider } from './openai.js';
+import { OpenRouterPiProvider } from './openrouter-pi.js';
 export { GeminiProvider } from './gemini.js';
 export { OpenAIProvider } from './openai.js';
+export { OpenRouterPiProvider } from './openrouter-pi.js';
 export * from './types.js';
 const providers = {
+    deepseek: new OpenRouterPiProvider('deepseek'),
     gemini: new GeminiProvider(),
+    zai: new OpenRouterPiProvider('zai'),
     openai: new OpenAIProvider(),
 };
 /**

package/sandbox/dist/providers/openrouter-pi.js

@@ -0,0 +1,25 @@
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS } from '../core/pi.js';
+import { resolveProviderTimeoutMs } from './config.js';
+import { extractJsonFromResponse } from './helpers.js';
+import { runPiReviewProvider } from './pi-review.js';
+export class OpenRouterPiProvider {
+    name;
+    fallbackModelName;
+    constructor(name, fallbackModelName = DEFAULT_OPENROUTER_MODELS[name] ??
+        DEFAULT_PI_MODELS[name]) {
+        this.name = name;
+        this.fallbackModelName = fallbackModelName;
+    }
+    async review(prompt, config) {
+        return await runPiReviewProvider({
+            provider: this.name,
+            modelName: config.modelName ?? this.fallbackModelName,
+            prompt,
+            config: {
+                ...config,
+                timeout: resolveProviderTimeoutMs(config.timeout),
+            },
+            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
+        });
+    }
+}

package/sandbox/dist/providers/pi-review.js

@@ -1,5 +1,5 @@
 import { logger } from '../core/logging.js';
-import { createPiInvoker } from '../core/pi.js';
+import { createPiInvoker, parsePiAuthProviderId, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../core/pi.js';
 import { logPiProgressEvent } from '../core/pi-progress-logging.js';
 import { WORKSPACE_DIR } from '../core/shared.js';
 import { logRawModelOutput, normalizeParsedModelOutput } from './helpers.js';
@@ -47,6 +47,12 @@ function logReviewRawModelOutput(args) {
     }
     logRawModelOutput(args);
 }
+function isOpenRouterBackedReviewRequest(provider, config) {
+    const resolvedPiProviderId = parsePiAuthProviderId(config.apiKey) ??
+        config.piProviderId ??
+        PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return resolvedPiProviderId === 'openrouter';
+}
 export async function runPiReviewProvider({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
     const startTime = Date.now();
     const timeoutMs = config.timeout ?? 0;
@@ -59,6 +65,9 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         promptLength: prompt.length,
         modelName,
         timeoutMs,
+        ...(isOpenRouterBackedReviewRequest(provider, config) && config.openRouterSessionId
+            ? { openRouterSessionId: config.openRouterSessionId }
+            : {}),
     });
     try {
         const invoker = createPiInvoker({
@@ -72,6 +81,8 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             capabilityPreset: 'read-only',
             thinkingLevel: config.thinkingLevel,
             systemPrompt: REVIEW_PI_SYSTEM_PROMPT,
+            noContextFiles: true,
+            openRouterSessionId: config.openRouterSessionId,
         });
         for (let attempt = 0; attempt < prompts.length; attempt += 1) {
             const result = await invoker.invoke({

package/sandbox/dist/tasks/chat/chat.js

@@ -1,4 +1,5 @@
 import { performance } from 'node:perf_hooks';
+import { SpanStatusCode } from '@opentelemetry/api';
 import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
 import { recordTaskMetrics } from '../../core/datadog-metrics.js';
 import { logger } from '../../core/logging.js';
@@ -6,9 +7,12 @@ import { invokePiPrompt } from '../../core/pi.js';
 import { loadPromptTemplateFile } from '../../core/prompt-template.js';
 import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
 import { cloneRepository, createGitHubClients, parseBaseContext, requiredEnv, WORKSPACE_DIR, } from '../../core/shared.js';
+import { withPhase } from '../../core/tracing.js';
 import { buildPrompt } from './prompt.js';
 const CHAT_PROMPT_FILE = 'chat-prompt.md';
 const CHAT_TIMEOUT_MS = 5 * 60 * 1000;
+const CHAT_PROVIDER = 'zai';
+const CHAT_MODEL = 'z-ai/glm-5.2';
 function parseContext() {
     const base = parseBaseContext();
     const reactionIdRaw = process.env.REACTION_ID;
@@ -19,6 +23,7 @@ function parseContext() {
         reactionId: Number.isFinite(reactionId) ? reactionId : undefined,
         commentType: requiredEnv('COMMENT_TYPE'),
         eventName: requiredEnv('EVENT_NAME'),
+        dryRun: process.env.DRY_RUN?.toLowerCase() === 'true',
     };
 }
 /**
@@ -122,26 +127,46 @@ async function gatherIssueCommentContext(octokit, owner, repo, prNumber, comment
 export async function invokeChatModel(prompt) {
     const apiKey = process.env.OPENROUTER_API_KEY?.trim();
     if (!apiKey) {
+        // Config error: no model call attempted, so no model span. The reason is
+        // returned so the caller's root span reports the real cause.
         logger.warn('Chat model API key missing');
-        return null;
+        return { ok: false, reason: 'OPENROUTER_API_KEY missing' };
     }
-    const result = await invokePiPrompt({
-        provider: 'gemini',
-        apiKey,
-        piProviderId: 'openrouter',
-        prompt,
-        cwd: WORKSPACE_DIR,
-        timeoutMs: CHAT_TIMEOUT_MS,
-        capabilityPreset: 'workspace-inspection',
-    });
-    if (!result.ok) {
-        logger.warn('Chat model request failed', {
-            error: result.error,
-            timedOut: result.timedOut,
+    return withPhase('chat.model', {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': CHAT_PROVIDER,
+        'gen_ai.request.model': CHAT_MODEL,
+    }, async (span) => {
+        const result = await invokePiPrompt({
+            provider: CHAT_PROVIDER,
+            apiKey,
+            piProviderId: 'openrouter',
+            prompt,
+            cwd: WORKSPACE_DIR,
+            timeoutMs: CHAT_TIMEOUT_MS,
+            capabilityPreset: 'workspace-inspection',
+            // Keep the executed model in sync with the recorded span attr.
+            modelName: CHAT_MODEL,
         });
-        return null;
-    }
-    return result.output.trim() || null;
+        if (!result.ok) {
+            // Failure returns a result rather than throwing — mark the span
+            // ERROR explicitly so it survives to phase.end (withPhase only
+            // auto-errors on a throw).
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            logger.warn('Chat model request failed', {
+                error: result.error,
+                timedOut: result.timedOut,
+            });
+            return { ok: false, reason: result.error };
+        }
+        const output = result.output.trim();
+        if (!output) {
+            const reason = 'chat model produced no output';
+            span.setStatus({ code: SpanStatusCode.ERROR, message: reason });
+            return { ok: false, reason };
+        }
+        return { ok: true, output };
+    });
 }
 /**
  * Posts the response to the correct location.
@@ -170,6 +195,17 @@ async function postResponse(octokit, ctx, response) {
         prNumber: ctx.prNumber,
     });
 }
+function formatChatDryRunOutput(ctx, response) {
+    return JSON.stringify({
+        task: 'chat',
+        repository: `${ctx.owner}/${ctx.repo}`,
+        prNumber: ctx.prNumber,
+        commentId: ctx.commentId,
+        commentType: ctx.commentType,
+        eventName: ctx.eventName,
+        response,
+    }, null, 2);
+}
 /**
  * Removes the 👀 reaction from the triggering comment.
  */
@@ -210,102 +246,126 @@ async function main() {
         commentId: ctx.commentId,
     };
     logger.setBaseContext(logContext);
-    logger.info('Chat task started', {
-        commentType: ctx.commentType,
-        eventName: ctx.eventName,
-    });
-    const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
     const reactionId = ctx.reactionId;
     let exitCode = 0;
     let metricOutcome = 'failure';
-    try {
-        // Clone repository
-        await cloneRepository({
-            app,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            prNumber: ctx.prNumber,
-            installationId: ctx.installationId,
-        });
-        // Gather thread context from GitHub API
-        let threadContext;
-        if (ctx.commentType === 'review') {
-            threadContext = await gatherReviewCommentContext(readOctokit, ctx.owner, ctx.repo, ctx.commentId);
-        }
-        else {
-            threadContext = await gatherIssueCommentContext(readOctokit, ctx.owner, ctx.repo, ctx.prNumber, ctx.commentId);
-        }
-        // Build prompt and invoke the chat model
-        const promptTemplate = loadPromptTemplateFile({
-            fileName: CHAT_PROMPT_FILE,
-            promptLabel: 'chat',
-        });
-        const prompt = buildPrompt({
-            promptTemplate,
-            owner: ctx.owner,
-            repo: ctx.repo,
-            prNumber: ctx.prNumber,
-            threadHistory: threadContext.threadHistory,
-            userQuestion: threadContext.userQuestion,
-            codeSnippet: threadContext.codeSnippet,
-            prTitle: threadContext.prTitle,
-            prAuthor: threadContext.prAuthor,
-        });
-        const response = await invokeChatModel(prompt);
-        if (!response) {
-            logger.warn('Chat model request returned no output');
-            return;
-        }
-        // Post response
-        await postResponse(writeOctokit, ctx, response);
-        logger.info('Chat task completed');
-        metricOutcome = 'success';
-    }
-    catch (error) {
-        logger.error('Chat task failed', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        // Post error message to the PR
+    await withPhase('chat', {
+        task: 'chat',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.chat',
+        'pr.number': ctx.prNumber,
+        'comment.id': ctx.commentId,
+        'comment.type': ctx.commentType,
+        'event.name': ctx.eventName,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        // Inside the span so auth/setup failures are captured by the root span.
+        const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
         try {
-            const errorMessage = 'Sorry, I encountered an error while processing your request. Please try again or contact the team maintaining the bot.';
+            // Clone repository
+            await cloneRepository({
+                app,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                prNumber: ctx.prNumber,
+                installationId: ctx.installationId,
+            });
+            // Gather thread context from GitHub API
+            let threadContext;
             if (ctx.commentType === 'review') {
-                await writeOctokit.rest.pulls.createReplyForReviewComment({
-                    owner: ctx.owner,
-                    repo: ctx.repo,
-                    pull_number: ctx.prNumber,
-                    comment_id: ctx.commentId,
-                    body: errorMessage,
-                });
+                threadContext = await gatherReviewCommentContext(readOctokit, ctx.owner, ctx.repo, ctx.commentId);
             }
             else {
-                await writeOctokit.rest.issues.createComment({
-                    owner: ctx.owner,
-                    repo: ctx.repo,
-                    issue_number: ctx.prNumber,
-                    body: errorMessage,
+                threadContext = await gatherIssueCommentContext(readOctokit, ctx.owner, ctx.repo, ctx.prNumber, ctx.commentId);
+            }
+            // Build prompt and invoke the chat model
+            const promptTemplate = loadPromptTemplateFile({
+                fileName: CHAT_PROMPT_FILE,
+                promptLabel: 'chat',
+            });
+            const prompt = buildPrompt({
+                promptTemplate,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                prNumber: ctx.prNumber,
+                threadHistory: threadContext.threadHistory,
+                userQuestion: threadContext.userQuestion,
+                codeSnippet: threadContext.codeSnippet,
+                prTitle: threadContext.prTitle,
+                prAuthor: threadContext.prAuthor,
+            });
+            const modelResult = await invokeChatModel(prompt);
+            if (!modelResult.ok) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: modelResult.reason });
+                logger.warn('Chat model produced no usable response', {
+                    reason: modelResult.reason,
                 });
+                return;
+            }
+            const response = modelResult.output;
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, printing chat response instead of posting to GitHub');
+                process.stdout.write(`${formatChatDryRunOutput(ctx, response)}\n`);
             }
+            else {
+                await postResponse(writeOctokit, ctx, response);
+            }
+            metricOutcome = 'success';
         }
-        catch (replyError) {
-            logger.error('Failed to post error message', {
-                error: replyError instanceof Error ? replyError.message : String(replyError),
-            });
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Chat task failed', { error: message });
+            // The catch swallows the error to post a user reply, so set the
+            // span status explicitly — withPhase only auto-errors on rethrow.
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, skipping chat error response post');
+            }
+            else {
+                try {
+                    const errorMessage = 'Sorry, I encountered an error while processing your request. Please try again or contact the team maintaining the bot.';
+                    if (ctx.commentType === 'review') {
+                        await writeOctokit.rest.pulls.createReplyForReviewComment({
+                            owner: ctx.owner,
+                            repo: ctx.repo,
+                            pull_number: ctx.prNumber,
+                            comment_id: ctx.commentId,
+                            body: errorMessage,
+                        });
+                    }
+                    else {
+                        await writeOctokit.rest.issues.createComment({
+                            owner: ctx.owner,
+                            repo: ctx.repo,
+                            issue_number: ctx.prNumber,
+                            body: errorMessage,
+                        });
+                    }
+                }
+                catch (replyError) {
+                    logger.error('Failed to post error message', {
+                        error: replyError instanceof Error
+                            ? replyError.message
+                            : String(replyError),
+                    });
+                }
+            }
+            exitCode = 1;
         }
-        exitCode = 1;
-    }
-    finally {
-        // Always remove reaction
-        if (reactionId) {
-            await removeReaction(writeOctokit, ctx, reactionId);
+        finally {
+            // Local dry runs must stay side-effect free.
+            if (reactionId && !ctx.dryRun) {
+                await removeReaction(writeOctokit, ctx, reactionId);
+            }
+            await recordTaskMetrics({
+                type: 'chat',
+                repository: `${ctx.owner}/${ctx.repo}`,
+                model: 'zai',
+                outcome: metricOutcome,
+                durationMs: performance.now() - startedAt,
+            });
         }
-        await recordTaskMetrics({
-            type: 'chat',
-            repository: `${ctx.owner}/${ctx.repo}`,
-            model: 'google',
-            outcome: metricOutcome,
-            durationMs: performance.now() - startedAt,
-        });
-    }
+    });
     if (exitCode !== 0) {
         process.exit(exitCode);
     }