@doist/doistbot-cli 1.0.3 → 1.0.5

package/sandbox/dist/core/pi.js

@@ -4,26 +4,26 @@ import { tmpdir } from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 const PI_PROVIDER_BY_DOISTBOT_PROVIDER = {
-    gemini: 'google',
+    gemini: '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 = {
     gemini: 'gemini-3.1-pro-preview',
     openai: 'gpt-5.4',
-    anthropic: 'claude-opus-4-6',
+};
+export const DEFAULT_OPENROUTER_MODELS = {
+    gemini: 'google/gemini-3.1-pro-preview',
 };
 export const MAX_PI_THINKING_BY_PROVIDER = {
     gemini: '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 = {
+    openai: 'OPENAI_API_KEY',
+    'openai-codex': 'OPENAI_API_KEY',
+    openrouter: 'OPENROUTER_API_KEY',
+};
+const PI_PROVIDER_IDS = new Set(['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;
@@ -62,7 +62,9 @@ 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) {
@@ -222,9 +224,10 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
         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],
             });
@@ -253,7 +256,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 GIT_TERMINAL_PROMPT: '0',
                 ...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];
             }

package/sandbox/dist/providers/config.js

@@ -15,7 +15,7 @@ export function resolveProviderTimeoutMs(explicitTimeoutMs) {
         explicitTimeoutMs > 0) {
         return explicitTimeoutMs;
     }
-    const sharedTimeout = parseTimeoutMs(process.env.COUNCIL_MODEL_TIMEOUT_MS);
+    const sharedTimeout = parseTimeoutMs(process.env.REVIEW_MODEL_TIMEOUT_MS);
     if (sharedTimeout != null) {
         return sharedTimeout;
     }

package/sandbox/dist/providers/credentials.js

@@ -0,0 +1,30 @@
+export function resolveReviewProviderCredential(credential) {
+    if (typeof credential === 'string') {
+        const apiKey = credential.trim();
+        return apiKey ? { apiKey } : undefined;
+    }
+    if (!credential) {
+        return undefined;
+    }
+    const apiKey = credential.apiKey.trim();
+    if (!apiKey) {
+        return undefined;
+    }
+    return {
+        apiKey,
+        ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
+        ...(credential.modelName ? { modelName: credential.modelName } : {}),
+    };
+}
+export function hasReviewProviderCredential(credential) {
+    return resolveReviewProviderCredential(credential) !== undefined;
+}
+export function getReviewProviderCredential(apiKeys, provider) {
+    return resolveReviewProviderCredential(apiKeys[provider]);
+}
+export function createOpenRouterCredential(apiKey) {
+    return {
+        apiKey,
+        piProviderId: 'openrouter',
+    };
+}

package/sandbox/dist/providers/gemini.js

@@ -2,29 +2,23 @@
  * Gemini provider for the multi-model code review system.
  * Uses the Pi harness instead of the Gemini CLI.
  */
-import { DEFAULT_PI_MODELS } from '../core/pi.js';
+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 GeminiProvider {
     name = 'gemini';
-    async review(prompt, config, logOptions) {
+    async review(prompt, config) {
+        const modelName = config.modelName ?? DEFAULT_OPENROUTER_MODELS.gemini ?? DEFAULT_PI_MODELS.gemini;
         return await runPiReviewProvider({
             provider: this.name,
-            modelName: config.modelName ?? DEFAULT_PI_MODELS.gemini,
+            modelName,
             prompt,
             config: {
                 ...config,
                 timeout: resolveProviderTimeoutMs(config.timeout),
             },
-            prompts: config.jsonSchema
-                ? [
-                    prompt,
-                    `${prompt}\n\nReturn only JSON that matches the provided schema. Do not include analysis text.`,
-                ]
-                : [prompt],
             parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
-            logOptions,
         });
     }
 }

package/sandbox/dist/providers/helpers.js

@@ -3,8 +3,9 @@
  */
 import { randomUUID } from 'crypto';
 import { logger } from '../core/logging.js';
-import { isBatchVoteResponse, isRawReviewResult, isVoteResponse } from './schemas.js';
+import { isRawReviewResult } from './schemas.js';
 const RAW_MODEL_LOG_CHUNK_CHARS = 8000;
+const REVIEW_LOG_ENGINE = 'multi_focus';
 function redactSensitiveStrings(content) {
     return content
         .replace(/(sk-[A-Za-z0-9_-]{10,})/g, '[REDACTED_OPENAI_KEY]')
@@ -34,7 +35,7 @@ export function buildRawModelOutputEntries(content) {
         originalLength: content.length,
     }));
 }
-export function logRawModelOutput({ model, engine = 'council', stage, success, status, durationMs, stdout, stderr, }) {
+export function logRawModelOutput({ model, stage, success, status, durationMs, stdout, stderr, }) {
     const streams = [
         { name: 'stdout', value: stdout },
         { name: 'stderr', value: stderr },
@@ -48,7 +49,7 @@ export function logRawModelOutput({ model, engine = 'council', stage, success, s
         for (const entry of entries) {
             logger.info('Review model raw output', {
                 model,
-                engine,
+                engine: REVIEW_LOG_ENGINE,
                 stage,
                 success,
                 status: status ?? null,
@@ -95,30 +96,14 @@ export function parseRawFindings(comments, modelName) {
 /**
  * Normalizes structured model output into a single provider response shape.
  */
-export function normalizeParsedModelOutput(parsed, modelName, structuredOutputKind = 'auto') {
+export function normalizeParsedModelOutput(parsed, modelName) {
     if (isRawReviewResult(parsed)) {
         return {
             summary: parsed.summary,
             findings: parseRawFindings(parsed.comments, modelName),
         };
     }
-    if ((structuredOutputKind === 'auto' || structuredOutputKind === 'vote') &&
-        isVoteResponse(parsed)) {
-        return {
-            summary: '',
-            findings: [],
-            structuredOutput: parsed,
-        };
-    }
-    if ((structuredOutputKind === 'auto' || structuredOutputKind === 'batch-vote') &&
-        isBatchVoteResponse(parsed)) {
-        return {
-            summary: '',
-            findings: [],
-            structuredOutput: parsed,
-        };
-    }
-    throw new Error('Model output did not match review or vote schema');
+    throw new Error('Model output did not match review schema');
 }
 function extractFencedJsonCandidates(content) {
     const matches = content.match(/```json\s*([\s\S]*?)\s*```/gi);

package/sandbox/dist/providers/index.js

@@ -1,17 +1,14 @@
 /**
  * Provider factory and exports for the multi-model code review system.
  */
-import { AnthropicProvider } from './anthropic.js';
 import { GeminiProvider } from './gemini.js';
 import { OpenAIProvider } from './openai.js';
-export { AnthropicProvider } from './anthropic.js';
 export { GeminiProvider } from './gemini.js';
 export { OpenAIProvider } from './openai.js';
 export * from './types.js';
 const providers = {
     gemini: new GeminiProvider(),
     openai: new OpenAIProvider(),
-    anthropic: new AnthropicProvider(),
 };
 /**
  * Gets a provider instance by name.

package/sandbox/dist/providers/openai.js

@@ -8,7 +8,7 @@ import { extractJsonFromResponse } from './helpers.js';
 import { runPiReviewProvider } from './pi-review.js';
 export class OpenAIProvider {
     name = 'openai';
-    async review(prompt, config, logOptions) {
+    async review(prompt, config) {
         return await runPiReviewProvider({
             provider: this.name,
             modelName: config.modelName ?? DEFAULT_PI_MODELS.openai,
@@ -17,14 +17,7 @@ export class OpenAIProvider {
                 ...config,
                 timeout: resolveProviderTimeoutMs(config.timeout),
             },
-            prompts: config.jsonSchema
-                ? [
-                    prompt,
-                    `${prompt}\n\nReturn only JSON that matches the provided schema. Do not include analysis text.`,
-                ]
-                : [prompt],
             parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
-            logOptions,
         });
     }
 }

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

@@ -3,20 +3,10 @@ import { createPiInvoker } 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';
-import { BATCH_VOTE_SCHEMA, VOTE_SCHEMA } from './schemas.js';
 const VERBOSE_PI_PROGRESS_LOGS = process.env.DOISTBOT_VERBOSE_PI_PROGRESS === 'true';
 const VERBOSE_PI_RAW_OUTPUT_LOGS = process.env.DOISTBOT_VERBOSE_PI_RAW_OUTPUT === 'true';
+const REVIEW_LOG_ENGINE = 'multi_focus';
 const REVIEW_PI_SYSTEM_PROMPT = 'You are running inside doistbot in a non-interactive environment. Stay tightly focused on the review task in the user prompt. Read only the files that are directly relevant to the changed code, the explicitly named guidance files, and any immediately connected definitions needed to verify a concrete finding. Do not broadly explore the repository, inspect unrelated modules, or search history unless it is necessary to validate a specific review concern. Stop gathering context once you have enough evidence to answer the review task accurately.';
-const DEFAULT_REVIEW_LOG_ENGINE = 'council';
-function getStructuredOutputKind(jsonSchema) {
-    if (jsonSchema === BATCH_VOTE_SCHEMA) {
-        return 'batch-vote';
-    }
-    if (jsonSchema === VOTE_SCHEMA) {
-        return 'vote';
-    }
-    return 'auto';
-}
 function buildModelFailureResult({ model, error, durationMs, timedOut = false, }) {
     return {
         model,
@@ -27,7 +17,7 @@ function buildModelFailureResult({ model, error, durationMs, timedOut = false, }
         durationMs,
     };
 }
-function logReviewModelProgress(model, event, engine) {
+function logReviewModelProgress(model, event) {
     logPiProgressEvent({
         event,
         messages: {
@@ -39,17 +29,17 @@ function logReviewModelProgress(model, event, engine) {
             toolUpdate: 'Review model tool still running',
             toolEnd: 'Review model tool finished',
         },
-        meta: { model, engine },
+        meta: { model, engine: REVIEW_LOG_ENGINE },
         logResponding: VERBOSE_PI_PROGRESS_LOGS,
         logTools: VERBOSE_PI_PROGRESS_LOGS,
     });
 }
-function emitReviewModelProgress(provider, event, config, engine) {
+function emitReviewModelProgress(provider, event, config) {
     config.onProgress?.({
         ...event,
         provider,
     });
-    logReviewModelProgress(provider, event, engine);
+    logReviewModelProgress(provider, event);
 }
 function logReviewRawModelOutput(args) {
     if (!VERBOSE_PI_RAW_OUTPUT_LOGS) {
@@ -57,16 +47,15 @@ function logReviewRawModelOutput(args) {
     }
     logRawModelOutput(args);
 }
-export async function runPiReviewProvider({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, logOptions, }) {
+export async function runPiReviewProvider({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
     const startTime = Date.now();
     const timeoutMs = config.timeout ?? 0;
-    const engine = logOptions?.engine ?? DEFAULT_REVIEW_LOG_ENGINE;
     let stdout = '';
     let stderr = '';
     let status = null;
     logger.info('Review model request', {
         model: provider,
-        engine,
+        engine: REVIEW_LOG_ENGINE,
         promptLength: prompt.length,
         modelName,
         timeoutMs,
@@ -75,9 +64,10 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         const invoker = createPiInvoker({
             provider,
             apiKey: config.apiKey,
+            piProviderId: config.piProviderId,
             cwd: config.workspaceDir ?? WORKSPACE_DIR,
             onProgress: (event) => {
-                emitReviewModelProgress(provider, event, config, engine);
+                emitReviewModelProgress(provider, event, config);
             },
             capabilityPreset: 'read-only',
             thinkingLevel: config.thinkingLevel,
@@ -95,7 +85,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             status = result.ok ? 0 : null;
             logger.info('Review model tool usage', {
                 model: provider,
-                engine,
+                engine: REVIEW_LOG_ENGINE,
                 attempt: attempt + 1,
                 attemptsTotal: prompts.length,
                 attemptDurationMs: result.durationMs,
@@ -104,7 +94,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             if (!result.ok && result.timedOut) {
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'timeout',
                     success: false,
                     status,
@@ -115,7 +104,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 const error = result.error || `Pi ${provider} request timed out after ${timeoutMs}ms`;
                 logger.error('Review model failed', {
                     model: provider,
-                    engine,
+                    engine: REVIEW_LOG_ENGINE,
                     error,
                     durationMs,
                 });
@@ -129,7 +118,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             if (!result.ok) {
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'non-zero-exit',
                     success: false,
                     status,
@@ -140,7 +128,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 const error = `Pi ${provider} request failed: ${result.error.slice(0, 500)}`;
                 logger.error('Review model failed', {
                     model: provider,
-                    engine,
+                    engine: REVIEW_LOG_ENGINE,
                     error,
                     durationMs,
                 });
@@ -154,7 +142,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             if (!output.trim()) {
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'empty-output',
                     success: false,
                     status,
@@ -169,10 +156,10 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 });
             }
             try {
-                const normalized = normalizeParsedModelOutput(parseOutput(output), provider, getStructuredOutputKind(config.jsonSchema));
+                const normalized = normalizeParsedModelOutput(parseOutput(output), provider);
                 logger.info('Review model response', {
                     model: provider,
-                    engine,
+                    engine: REVIEW_LOG_ENGINE,
                     findingsCount: normalized.findings.length,
                     durationMs,
                     parseMethod: 'extract_json',
@@ -180,13 +167,12 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 if (VERBOSE_PI_RAW_OUTPUT_LOGS) {
                     logger.info('Review model findings', {
                         model: provider,
-                        engine,
+                        engine: REVIEW_LOG_ENGINE,
                         findings: normalized.findings,
                     });
                 }
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'success',
                     success: true,
                     status,
@@ -198,35 +184,12 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                     model: provider,
                     summary: normalized.summary,
                     findings: normalized.findings,
-                    structuredOutput: normalized.structuredOutput,
                     durationMs,
                 };
             }
             catch (error) {
-                if (config.jsonSchema && attempt < prompts.length - 1) {
-                    const retryError = error instanceof Error ? error.message : String(error);
-                    logReviewRawModelOutput({
-                        model: provider,
-                        engine,
-                        stage: 'schema-retry',
-                        success: false,
-                        status,
-                        durationMs,
-                        stdout,
-                        stderr,
-                    });
-                    logger.warn('Review model schema retry', {
-                        model: provider,
-                        engine,
-                        durationMs,
-                        attempt: attempt + 1,
-                        error: retryError,
-                    });
-                    continue;
-                }
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'parse-error',
                     success: false,
                     status,
@@ -248,7 +211,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         const errorMessage = error instanceof Error ? error.message : String(error);
         logReviewRawModelOutput({
             model: provider,
-            engine,
             stage: 'exception',
             success: false,
             status,
@@ -258,7 +220,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         });
         logger.error('Review model failed', {
             model: provider,
-            engine,
+            engine: REVIEW_LOG_ENGINE,
             error: errorMessage,
             durationMs,
         });

package/sandbox/dist/providers/schemas.js

@@ -21,37 +21,6 @@ export const REVIEW_SCHEMA = {
     },
     required: ['summary', 'comments'],
 };
-export const VOTE_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-        approve: { type: 'boolean' },
-        confidence: { type: 'number', minimum: 0, maximum: 1 },
-        reasoning: { type: 'string', minLength: 1 },
-    },
-    required: ['approve', 'confidence', 'reasoning'],
-};
-export const BATCH_VOTE_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-        votes: {
-            type: 'array',
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    findingId: { type: 'string', minLength: 1 },
-                    approve: { type: 'boolean' },
-                    confidence: { type: 'number', minimum: 0, maximum: 1 },
-                    reasoning: { type: 'string', minLength: 1 },
-                },
-                required: ['findingId', 'approve', 'confidence', 'reasoning'],
-            },
-        },
-    },
-    required: ['votes'],
-};
 export const DEDUPE_SCHEMA = {
     type: 'object',
     additionalProperties: false,
@@ -76,18 +45,10 @@ export const DEDUPE_SCHEMA = {
 };
 const ajv = new Ajv();
 const validateRawReviewResult = ajv.compile(REVIEW_SCHEMA);
-const validateVoteResponse = ajv.compile(VOTE_SCHEMA);
-const validateBatchVoteResponse = ajv.compile(BATCH_VOTE_SCHEMA);
 const validateDedupeResponse = ajv.compile(DEDUPE_SCHEMA);
 export function isRawReviewResult(value) {
     return validateRawReviewResult(value);
 }
-export function isVoteResponse(value) {
-    return validateVoteResponse(value);
-}
-export function isBatchVoteResponse(value) {
-    return validateBatchVoteResponse(value);
-}
 export function isDedupeResponse(value) {
     return validateDedupeResponse(value);
 }

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

@@ -120,7 +120,7 @@ async function gatherIssueCommentContext(octokit, owner, repo, prNumber, comment
     };
 }
 export async function invokeChatModel(prompt) {
-    const apiKey = process.env.GEMINI_API_KEY?.trim();
+    const apiKey = process.env.OPENROUTER_API_KEY?.trim();
     if (!apiKey) {
         logger.warn('Chat model API key missing');
         return null;
@@ -128,6 +128,7 @@ export async function invokeChatModel(prompt) {
     const result = await invokePiPrompt({
         provider: 'gemini',
         apiKey,
+        piProviderId: 'openrouter',
         prompt,
         cwd: WORKSPACE_DIR,
         timeoutMs: CHAT_TIMEOUT_MS,

package/sandbox/dist/tasks/issue-summarize/context.js

@@ -11,7 +11,7 @@ export function parseSummarizeContext(env = process.env) {
         appId: requiredEnv('APP_ID', env),
         privateKey: requiredEnv('PRIVATE_KEY', env),
         githubToken: requiredEnv('GITHUB_TOKEN', env),
-        geminiApiKey: requiredEnv('GEMINI_API_KEY', env),
+        openRouterApiKey: requiredEnv('OPENROUTER_API_KEY', env),
         commentId,
         reactionId,
         deliveryId: env.DELIVERY_ID,

package/sandbox/dist/tasks/issue-summarize/model.js

@@ -1,10 +1,12 @@
 import { logger } from '../../core/logging.js';
 import { buildPiImageContent, createPiInvoker } from '../../core/pi.js';
 const ISSUE_SUMMARIZE_TIMEOUT_MS = 5 * 60 * 1000;
+const ISSUE_SUMMARIZE_MULTIMODAL_MODEL = 'google/gemini-2.5-pro';
 export function createIssueSummarizeModel(apiKey) {
     return createPiInvoker({
         provider: 'gemini',
         apiKey,
+        piProviderId: 'openrouter',
         cwd: process.cwd(),
         capabilityPreset: 'read-only',
     });
@@ -43,7 +45,7 @@ export async function invokeIssueSummarizeModel({ model, prompt, mediaImages, })
         .join('\n\n');
     try {
         const result = await model.invoke({
-            modelName: 'gemini-2.5-pro',
+            modelName: ISSUE_SUMMARIZE_MULTIMODAL_MODEL,
             prompt: `${prompt}\n\n<media_context>\n${mediaContext}\n</media_context>`,
             timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
             images: mediaImages.map((mediaImage) => buildPiImageContent({

package/sandbox/dist/tasks/issue-summarize/summarize.js

@@ -39,7 +39,7 @@ function summarizeMediaInspectionStats(mediaInspections) {
 async function summarizeIssue({ ctx, issue, entries, mediaReferences, mediaInspections, }) {
     const template = loadPromptTemplate();
     const threadPrompt = prepareThreadPrompt(entries);
-    const summarizeModel = createIssueSummarizeModel(ctx.geminiApiKey);
+    const summarizeModel = createIssueSummarizeModel(ctx.openRouterApiKey);
     logger.info('Prepared summarize thread prompt', {
         entryCount: entries.length,
         chunked: threadPrompt.chunked,

package/sandbox/dist/tasks/issue-triage/context.js

@@ -35,7 +35,6 @@ export function parseIssueTriageContext(env = process.env) {
         dryRun: env.DRY_RUN?.toLowerCase() === 'true',
         triggerType,
         enableAutoFixOverride: parseOptionalBoolean(env.ENABLE_AUTO_FIX),
-        geminiApiKey: env.GEMINI_API_KEY?.trim() || undefined,
-        anthropicApiKey: env.ANTHROPIC_API_KEY?.trim() || undefined,
+        openRouterApiKey: env.OPENROUTER_API_KEY?.trim() || undefined,
     };
 }

package/sandbox/dist/tasks/issue-triage/fix-dispatch.js

@@ -1,4 +1,5 @@
 import { logger } from '../../core/logging.js';
+import { createOpenRouterCredential } from '../../providers/credentials.js';
 import { DefaultLoopEffects } from './fix-loop/effects.js';
 import { runFixLoop } from './fix-loop/runners.js';
 import { attemptFix, buildFixAssessmentSkipReason, shouldAttemptFix } from './fix-attempt.js';
@@ -132,9 +133,8 @@ export async function runConfiguredFix(input) {
         pushToken: input.ctx.githubToken,
         apiKeys: {
             openai: input.ctx.openaiApiKey,
-            ...(input.ctx.geminiApiKey !== undefined && { gemini: input.ctx.geminiApiKey }),
-            ...(input.ctx.anthropicApiKey !== undefined && {
-                anthropic: input.ctx.anthropicApiKey,
+            ...(input.ctx.openRouterApiKey !== undefined && {
+                gemini: createOpenRouterCredential(input.ctx.openRouterApiKey),
             }),
         },
     };

package/sandbox/dist/tasks/persist-logs/dd-proxy.js

@@ -7,8 +7,8 @@ const DD_HOST = 'api.datadoghq.com';
  * Starts a localhost HTTP proxy that forwards requests to the Datadog API,
  * scrubs PII from responses, and logs each query for auditability.
  *
- * Claude hits http://localhost:{port}/api/v2/... instead of the DD API directly.
- * The proxy injects DD auth headers so Claude never sees the API keys.
+ * The agent hits http://localhost:{port}/api/v2/... instead of the DD API directly.
+ * The proxy injects DD auth headers so the agent never sees the API keys.
  */
 export function startDdProxy({ port, datadogApiKey, datadogAppKey }) {
     return new Promise((resolve, reject) => {

package/sandbox/dist/tasks/persist-logs/llm-query-planner.js

@@ -49,7 +49,7 @@ export async function runInvestigation(params) {
     });
     // Ensure output directory exists
     fs.mkdirSync(params.outputDir, { recursive: true });
-    // Start the DD proxy — Claude queries localhost, proxy injects auth and scrubs PII from responses
+    // Start the DD proxy so the agent queries localhost; the proxy injects auth and scrubs PII.
     const proxy = await startDdProxy({
         port: DD_PROXY_PORT,
         datadogApiKey: params.datadogApiKey,

package/sandbox/dist/tasks/persist-logs/persist-logs.js

@@ -441,7 +441,7 @@ export function buildSnapshotComment({ analysisContent, csvContent, worklogConte
         '_Links expire in 7 days. Use `@doistbot /refresh-s3-urls` to generate new links._',
     ].join('\n');
     const csvPreview = buildCsvPreview(csvContent);
-    // Always prepend the marker — Claude's output won't contain it
+    // Always prepend the marker; model output won't contain it.
     const analysis = analysisContent
         ? `${LOG_SNAPSHOT_MARKER}\n${analysisContent}`
         : `${LOG_SNAPSHOT_MARKER}\n## Datadog Log Snapshot\n\n**${totalLogs} log entries** captured from Datadog.`;