@doist/doistbot-cli 1.0.4 → 1.0.5

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.`;

package/sandbox/dist/tasks/review/conversation-context.js

@@ -3,6 +3,7 @@ import { fetchIssueComments } from '../../core/github-issues.js';
 import { logger } from '../../core/logging.js';
 import { invokePiPrompt } from '../../core/pi.js';
 import { WORKSPACE_DIR } from '../../core/shared.js';
+import { resolveReviewProviderCredential } from '../../providers/credentials.js';
 import { stripReviewFeedbackFooter } from './review-feedback.js';
 // Roughly 6k tokens: large enough for substantive PR discussions while still
 // keeping conversation context secondary to the diff.
@@ -14,11 +15,8 @@ const GITHUB_ACTIONS_BOT_LOGIN = 'github-actions[bot]';
 const MASKED_PR_AUTHOR_LABEL = 'PR author';
 function getSummaryProviders(apiKeys) {
     return [
-        ...(apiKeys?.gemini ? [{ provider: 'gemini', apiKey: apiKeys.gemini }] : []),
-        ...(apiKeys?.openai ? [{ provider: 'openai', apiKey: apiKeys.openai }] : []),
-        ...(apiKeys?.anthropic
-            ? [{ provider: 'anthropic', apiKey: apiKeys.anthropic }]
-            : []),
+        ...(apiKeys?.gemini ? [{ provider: 'gemini', credential: apiKeys.gemini }] : []),
+        ...(apiKeys?.openai ? [{ provider: 'openai', credential: apiKeys.openai }] : []),
     ];
 }
 function isRelevantBotLogin(login) {
@@ -253,7 +251,7 @@ If a section has no relevant information, use "- None."
 ${rawContext}
 </pr_conversation>`;
 }
-async function summarizeConversationContextWithModel({ provider, apiKey, rawContext, workspaceDir, }) {
+async function summarizeConversationContextWithModel({ provider, credential, rawContext, workspaceDir, }) {
     const startedAt = Date.now();
     logger.info('PR conversation summarization started', {
         task: 'review',
@@ -261,9 +259,17 @@ async function summarizeConversationContextWithModel({ provider, apiKey, rawCont
         raw_chars: rawContext.length,
     });
     try {
+        const resolvedCredential = resolveReviewProviderCredential(credential);
+        if (!resolvedCredential) {
+            return null;
+        }
         const result = await invokePiPrompt({
             provider,
-            apiKey,
+            apiKey: resolvedCredential.apiKey,
+            ...(resolvedCredential.piProviderId
+                ? { piProviderId: resolvedCredential.piProviderId }
+                : {}),
+            ...(resolvedCredential.modelName ? { modelName: resolvedCredential.modelName } : {}),
             prompt: buildSummaryPrompt(rawContext),
             cwd: workspaceDir ?? WORKSPACE_DIR,
             timeoutMs: CONVERSATION_SUMMARY_TIMEOUT_MS,

package/sandbox/dist/tasks/review/engines/dedupe.js

@@ -1,11 +1,14 @@
 import { logger } from '../../../core/logging.js';
 import { invokePiPrompt } from '../../../core/pi.js';
 import { logPiProgressEvent } from '../../../core/pi-progress-logging.js';
+import { resolveReviewProviderCredential } from '../../../providers/credentials.js';
 import { extractJsonFromResponse } from '../../../providers/helpers.js';
 import { isDedupeResponse } from '../../../providers/schemas.js';
 const DEDUPE_TIMEOUT_MS = 5 * 60 * 1000;
 const DEDUPE_PROVIDER = 'gemini';
-const DEDUPE_MODEL_NAME = 'gemini-3-flash-preview';
+const DEDUPE_MODEL_BY_PI_PROVIDER = {
+    openrouter: 'google/gemini-3-flash-preview',
+};
 const DEDUPE_THINKING_LEVEL = 'medium';
 const DEDUPE_MAX_ATTEMPTS = 2;
 const DEDUPE_RETRY_DELAY_MS = 1_000;
@@ -106,28 +109,31 @@ export function applyDedupeGroups(findings, groups) {
     });
     return findings.filter((finding) => !dropped.has(finding.id));
 }
-export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiApiKey, }) {
+export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiCredential, }) {
     if (findings.length <= 1) {
         return findings;
     }
     if (!availableModels.includes(DEDUPE_PROVIDER)) {
         logger.error('Multi-focus dedupe unavailable because Gemini is not enabled', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_NAME,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
         });
         throw new Error('Multi-focus dedupe requires Gemini to be enabled');
     }
-    if (!geminiApiKey) {
-        logger.error('Multi-focus dedupe unavailable because Gemini API key is unavailable', {
+    const credential = resolveReviewProviderCredential(geminiCredential);
+    if (!credential) {
+        logger.error('Multi-focus dedupe unavailable because Gemini review credential is unavailable', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_NAME,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
         });
-        throw new Error('Multi-focus dedupe requires a Gemini API key');
+        throw new Error('Multi-focus dedupe requires a Gemini review credential');
     }
+    const piProviderId = credential.piProviderId ?? 'openrouter';
     const providerConfig = {
         provider: DEDUPE_PROVIDER,
-        apiKey: geminiApiKey,
-        modelName: DEDUPE_MODEL_NAME,
+        apiKey: credential.apiKey,
+        ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
+        modelName: DEDUPE_MODEL_BY_PI_PROVIDER[piProviderId] ?? DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
     };
     for (let attempt = 1; attempt <= DEDUPE_MAX_ATTEMPTS; attempt += 1) {
         let result;
@@ -135,6 +141,9 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
             result = await invokePiPrompt({
                 provider: providerConfig.provider,
                 apiKey: providerConfig.apiKey,
+                ...(providerConfig.piProviderId
+                    ? { piProviderId: providerConfig.piProviderId }
+                    : {}),
                 prompt: buildDedupePrompt(findings),
                 cwd: workspaceDir,
                 timeoutMs: DEDUPE_TIMEOUT_MS,