@doist/doistbot-cli 1.0.4 → 1.0.6

package/dist/actions/auth.js

@@ -1,4 +1,4 @@
-import { deleteGeminiApiKey, getAuthStatus, loginOpenAICodex, logoutOpenAICodex, saveGeminiApiKey, } from '../auth.js';
+import { deleteGeminiApiKey, deleteOpenRouterApiKey, getAuthStatus, loginOpenAICodex, logoutOpenAICodex, saveGeminiApiKey, saveOpenRouterApiKey, } from '../auth.js';
 import { getEnvApiKeys } from '../env.js';
 import { FILE_STORE_PATH } from '../file-store.js';
 import { promptHiddenInput, promptMultiSelect } from '../input.js';
@@ -10,10 +10,8 @@ const AUTH_LOGOUT_PROVIDER_CONFIGS = [
             await logoutOpenAICodex();
             return '✓ OpenAI stored auth cleared.';
         },
-        envWarning: (env) => getEnvApiKeys(env).openai
-            ? 'OpenAI is still configured from an environment variable.'
-            : undefined,
-        name: 'OpenAI Codex',
+        envWarning: () => undefined,
+        name: 'OpenAI',
         value: 'openai',
     },
     {
@@ -29,6 +27,19 @@ const AUTH_LOGOUT_PROVIDER_CONFIGS = [
         name: 'Gemini',
         value: 'gemini',
     },
+    {
+        clear: async ({ deleteOpenRouterApiKey }) => {
+            const deleted = await deleteOpenRouterApiKey();
+            return deleted
+                ? '✓ OpenRouter stored API key cleared.'
+                : 'OpenRouter had no stored API key to clear.';
+        },
+        envWarning: (env) => getEnvApiKeys(env).openrouter
+            ? 'OpenRouter is still configured from OPENROUTER_API_KEY.'
+            : undefined,
+        name: 'OpenRouter',
+        value: 'openrouter',
+    },
 ];
 const AUTH_LOGOUT_PROVIDERS = AUTH_LOGOUT_PROVIDER_CONFIGS.map(({ value }) => value);
 export const AUTH_LOGOUT_PROVIDER_USAGE = `${AUTH_LOGOUT_PROVIDERS.join('|')}|all`;
@@ -39,6 +50,7 @@ export async function runAuthSetup(dependencies = {}) {
         loginOpenAICodex,
         promptHiddenInput,
         saveGeminiApiKey,
+        saveOpenRouterApiKey,
         writeLine,
         ...dependencies,
     };
@@ -46,7 +58,7 @@ export async function runAuthSetup(dependencies = {}) {
     deps.writeLine('1. OpenAI Codex');
     deps.writeLine();
     if (status.openai.configured) {
-        deps.writeLine(formatOpenAIConfiguredMessage(status.openai.source));
+        deps.writeLine('✓ OpenAI already configured (pi-auth).');
     }
     else {
         if (!deps.isInteractive) {
@@ -61,35 +73,70 @@ export async function runAuthSetup(dependencies = {}) {
     deps.writeLine();
     if (status.gemini.source === 'env') {
         deps.writeLine('✓ Gemini already configured from GEMINI_API_KEY.');
-        return;
     }
-    if (status.gemini.source === 'keychain') {
+    else if (status.gemini.source === 'keychain') {
         deps.writeLine(`✓ Gemini already configured in the ${getSecureStoreLabel()}.`);
-        return;
     }
-    if (status.gemini.source === 'file') {
+    else if (status.gemini.source === 'file') {
         deps.writeLine(`✓ Gemini already configured (${FILE_STORE_PATH}).`);
+    }
+    else {
+        if (!deps.isInteractive) {
+            deps.writeLine('Gemini not configured. Skipping optional Gemini provider.');
+        }
+        else {
+            deps.writeLine('Doistbot can use Gemini via Google Vertex. Paste a Gemini API key, or press Enter to skip.');
+            const geminiApiKey = (await deps.promptHiddenInput('Gemini API key (optional): ')).trim();
+            if (!geminiApiKey) {
+                deps.writeLine();
+                deps.writeLine('Gemini skipped. You can add it later with `doistbot auth`.');
+            }
+            else {
+                const backend = await deps.saveGeminiApiKey(geminiApiKey);
+                deps.writeLine();
+                if (backend === 'file') {
+                    deps.writeLine(`Note: ${getSecureStoreLabel()} unavailable; key stored in ${FILE_STORE_PATH} with 0600 permissions.`);
+                }
+                deps.writeLine('✓ Gemini configured.');
+            }
+        }
+    }
+    deps.writeLine();
+    deps.writeLine('3. OpenRouter API key');
+    deps.writeLine();
+    if (status.openrouter.source === 'env') {
+        deps.writeLine('✓ OpenRouter already configured from OPENROUTER_API_KEY.');
+        return;
+    }
+    if (status.openrouter.source === 'keychain') {
+        deps.writeLine(`✓ OpenRouter already configured in the ${getSecureStoreLabel()}.`);
+        return;
+    }
+    if (status.openrouter.source === 'file') {
+        deps.writeLine(`✓ OpenRouter already configured (${FILE_STORE_PATH}).`);
         return;
     }
     if (!deps.isInteractive) {
-        throw new Error('Cannot prompt for Gemini API key in non-interactive mode. Set GEMINI_API_KEY instead.');
+        throw new Error('Cannot prompt for OpenRouter API key in non-interactive mode. Set OPENROUTER_API_KEY instead.');
     }
-    deps.writeLine('Doistbot requires a Gemini API key. Please create one at https://aistudio.google.com/app/api-keys and paste it here.');
-    const backend = await deps.saveGeminiApiKey(await deps.promptHiddenInput('Gemini API key: '));
+    deps.writeLine('Doistbot uses OpenRouter for DeepSeek, Z.ai, and other non-GPT review models. Please create an OpenRouter API key at https://openrouter.ai/keys and paste it here. (Use your Work Perk for it)');
+    const backend = await deps.saveOpenRouterApiKey(await deps.promptHiddenInput('OpenRouter API key: '));
     deps.writeLine();
     if (backend === 'file') {
         deps.writeLine(`Note: ${getSecureStoreLabel()} unavailable; key stored in ${FILE_STORE_PATH} with 0600 permissions.`);
     }
-    deps.writeLine('✓ Gemini configured.');
+    deps.writeLine('✓ OpenRouter configured.');
 }
 export async function runAuthStatus() {
     const status = await getAuthStatus();
     writeLine(`OpenAI: ${status.openai.configured ? `configured (${status.openai.source ?? 'unknown'})` : 'not configured'}`);
-    writeLine(`Gemini: ${status.gemini.configured ? `configured (${status.gemini.source ?? 'unknown'})` : 'not configured'}`);
+    writeLine(`Gemini (optional): ${status.gemini.configured ? `configured (${status.gemini.source ?? 'unknown'})` : 'not configured'}`);
+    writeLine(`OpenRouter: ${status.openrouter.configured ? `configured (${status.openrouter.source ?? 'unknown'})` : 'not configured'}`);
 }
 export async function runAuthLogout(target, dependencies = {}) {
     const deps = {
         deleteGeminiApiKey,
+        deleteOpenRouterApiKey,
         env: process.env,
         isInteractive: process.stdin.isTTY === true,
         logoutOpenAICodex,
@@ -142,16 +189,3 @@ async function promptLogoutProviderSelection() {
         choices: AUTH_LOGOUT_PROVIDER_CONFIGS.map(({ name, value }) => ({ name, value })),
     });
 }
-function formatOpenAIConfiguredMessage(source) {
-    switch (source) {
-        case 'pi-auth':
-            return '✓ OpenAI already configured (pi-auth).';
-        case 'env':
-            return '✓ OpenAI already configured from the environment.';
-        case 'keychain':
-            return '✓ OpenAI already configured (keychain).';
-        case 'file':
-        case undefined:
-            return '✓ OpenAI already configured.';
-    }
-}

package/dist/actions/doctor.js

@@ -1,27 +1,32 @@
 import { getAuthStatus } from '../auth.js';
-import { getEnvApiKeys } from '../env.js';
+import { formatMissingRequiredCliAuthProviders, getMissingRequiredCliAuthProviders, } from '../config.js';
 import { checkGit, checkPiDependency, checkRepository, checkSandboxBuild } from '../runtime.js';
 import { renderDiagnosticCheck } from '../terminal.js';
 export function getConfiguredProviders({ status, }) {
     return [
-        status.openai.configured
-            ? `OpenAI (${status.openai.source === 'pi-auth'
-                ? 'pi-auth record found; validated during review'
-                : (status.openai.source ?? 'configured')})`
+        status.openai.configured ? `OpenAI (${status.openai.source ?? 'configured'})` : undefined,
+        status.gemini.configured
+            ? `Gemini optional (${status.gemini.source ?? 'configured'})`
+            : undefined,
+        status.openrouter.configured
+            ? `OpenRouter (${status.openrouter.source ?? 'configured'})`
             : undefined,
-        status.gemini.configured ? `Gemini (${status.gemini.source ?? 'configured'})` : undefined,
     ].filter((provider) => provider !== undefined);
 }
+export function getMissingRequiredProviders({ status, }) {
+    return getMissingRequiredCliAuthProviders(status);
+}
 export async function checkAuth({ env = process.env, getStatus = getAuthStatus, } = {}) {
     const status = await getStatus({ env });
     const configured = getConfiguredProviders({ status });
-    if (configured.length > 0) {
+    const missingRequiredProviders = getMissingRequiredProviders({ status });
+    if (missingRequiredProviders.length === 0) {
         return { ok: true, message: `${configured.join(', ')} configured` };
     }
-    if (getEnvApiKeys(env).anthropic) {
-        return { ok: true, message: 'provider auth configured' };
-    }
-    return { ok: false, message: 'run `doistbot auth`' };
+    return {
+        ok: false,
+        message: formatMissingRequiredCliAuthProviders(missingRequiredProviders),
+    };
 }
 export async function runDoctor() {
     await renderDiagnosticCheck('git', checkGit);

package/dist/actions/review.js

@@ -1,12 +1,13 @@
-import { getApiKeys } from '../config.js';
+import { formatMissingRequiredCliAuthProviders, getApiKeys, getMissingRequiredCliReviewAuthProviders, } from '../config.js';
 import { getRepositoryRoot, loadSandboxFormatModule, loadSandboxReviewModule } from '../runtime.js';
 import { formatReviewProgress, renderAlert, renderMarkdown, withSpinner, writeLine, } from '../terminal.js';
 const LOCAL_REVIEW_SOURCE_STAGED = 'staged';
 const JSON_SCHEMA_VERSION = 1;
 const PROVIDER_DISPLAY_NAMES = {
+    deepseek: 'DeepSeek',
     gemini: 'Gemini',
-    openai: 'OpenAI Codex',
-    anthropic: 'Anthropic',
+    zai: 'Z.ai',
+    openai: 'OpenAI',
 };
 function stripProviderFailurePrefix(error) {
     return error
@@ -18,8 +19,11 @@ function getReadableProviderFailure(failure) {
     const error = stripProviderFailurePrefix(failure.error);
     const normalized = error.toLowerCase();
     if (failure.model === 'openai' &&
-        (normalized.includes('no api key found for openai-codex') ||
-            normalized.includes('use /login'))) {
+        (normalized.includes('no api key found for openai') ||
+            normalized.includes('no api key found for openai-codex') ||
+            normalized.includes('use /login') ||
+            normalized.includes('invalid api key') ||
+            normalized.includes('incorrect api key'))) {
         return 'OpenAI Codex is not authenticated. Run `doistbot auth` to reconnect OpenAI.';
     }
     if (failure.model === 'gemini' &&
@@ -28,13 +32,16 @@ function getReadableProviderFailure(failure) {
             normalized.includes('quota') ||
             normalized.includes('rate-limit') ||
             normalized.includes('rate limit'))) {
-        return 'Gemini is rate-limited or out of quota. Create a Gemini API key at https://aistudio.google.com/app/api-keys, or wait for quota to reset.';
+        return 'Gemini is rate-limited or out of quota. Check your Google Gemini quota or wait for quota to reset.';
     }
     if (failure.model === 'gemini' &&
         (normalized.includes('api_key_invalid') ||
             normalized.includes('api key not valid') ||
-            normalized.includes('invalid_argument'))) {
-        return 'Gemini API key is invalid. Run `doistbot auth` and paste a valid key from https://aistudio.google.com/app/api-keys.';
+            normalized.includes('invalid_argument') ||
+            normalized.includes('invalid api key') ||
+            normalized.includes('no api key found for google') ||
+            normalized.includes('no api key found for gemini'))) {
+        return 'Gemini API key is invalid or missing. Run `doistbot auth` and paste a valid Gemini key.';
     }
     const firstLine = error
         .split(/\r?\n/)
@@ -186,19 +193,77 @@ function formatReviewForJson(result) {
         providerFailures: getReadableProviderFailureEntries(result.reviewResult.providerFailures),
     };
 }
-async function runLocalReviewForCli({ source, onProgress, }) {
+async function getReviewAuthCheck() {
+    const apiKeys = await getApiKeys();
+    return {
+        apiKeys,
+        missingProviders: getMissingRequiredCliReviewAuthProviders(apiKeys),
+    };
+}
+function getMissingAuthProviderFailures(missingProviders) {
+    const failures = [];
+    if (missingProviders.includes('OpenAI')) {
+        failures.push({
+            model: 'openai',
+            message: 'OpenAI not configured; run `doistbot auth`',
+        });
+    }
+    if (missingProviders.includes('OpenRouter')) {
+        failures.push({
+            model: 'deepseek',
+            message: 'OpenRouter not configured; run `doistbot auth`',
+        }, {
+            model: 'zai',
+            message: 'OpenRouter not configured; run `doistbot auth`',
+        });
+    }
+    return failures;
+}
+function formatMissingAuthForJson({ source, missingProviders, }) {
+    return {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        status: 'unverified',
+        verified: false,
+        unverifiedReason: 'missing_auth',
+        reviewSource: source,
+        repository: {
+            owner: 'unknown',
+            repo: 'unknown',
+            branch: 'unknown',
+            baseBranch: 'unknown',
+        },
+        review: {
+            count: 0,
+            findings: [],
+        },
+        providerFailures: getMissingAuthProviderFailures(missingProviders),
+    };
+}
+async function runLocalReviewForCli({ source, apiKeys, onProgress, }) {
     const reviewModule = await loadSandboxReviewModule();
     return await reviewModule.runLocalReview({
         workspaceDir: getRepositoryRoot(),
         source,
-        apiKeys: await getApiKeys(),
+        apiKeys,
         suppressLogs: true,
         onProgress,
     });
 }
 export async function runReview({ source, json = false } = { source: 'base' }) {
+    const authCheck = await getReviewAuthCheck();
+    if (authCheck.missingProviders.length > 0) {
+        if (json) {
+            writeLine(JSON.stringify(formatMissingAuthForJson({
+                source,
+                missingProviders: authCheck.missingProviders,
+            }), null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw new Error(formatMissingRequiredCliAuthProviders(authCheck.missingProviders));
+    }
     if (json) {
-        const result = await runLocalReviewForCli({ source });
+        const result = await runLocalReviewForCli({ source, apiKeys: authCheck.apiKeys });
         const output = formatReviewForJson(result);
         writeLine(JSON.stringify(output, null, 2));
         if (output.status === 'unverified') {
@@ -210,6 +275,7 @@ export async function runReview({ source, json = false } = { source: 'base' }) {
         ? 'Reviewing staged changes...'
         : 'Reviewing local changes...', async (status) => await runLocalReviewForCli({
         source,
+        apiKeys: authCheck.apiKeys,
         onProgress: status.enabled
             ? (event) => status.update(formatReviewProgress(event))
             : undefined,

package/dist/auth.js

@@ -6,13 +6,17 @@ import { createFileStore } from './file-store.js';
 import { promptInput } from './input.js';
 import { createCompositeStore, createKeyringStore, SecureStoreUnavailableError, } from './secure-store.js';
 const GEMINI_ACCOUNT_NAME = 'gemini-api-key';
+const OPENROUTER_ACCOUNT_NAME = 'openrouter-api-key';
 export function createGeminiKeyStore() {
     return createCompositeStore(createKeyringStore(GEMINI_ACCOUNT_NAME), createFileStore(GEMINI_ACCOUNT_NAME));
 }
+export function createOpenRouterKeyStore() {
+    return createCompositeStore(createKeyringStore(OPENROUTER_ACCOUNT_NAME), createFileStore(OPENROUTER_ACCOUNT_NAME));
+}
 export const OPENAI_CODEX_PROVIDER_ID = 'openai-codex';
 export const PI_AUTH_API_KEY = `pi-auth://${OPENAI_CODEX_PROVIDER_ID}`;
 export async function createPiAuthStorage() {
-    const { AuthStorage } = await import('@mariozechner/pi-coding-agent');
+    const { AuthStorage } = await import('@earendil-works/pi-coding-agent');
     return AuthStorage.create(path.join(homedir(), '.pi', 'agent', 'auth.json'));
 }
 export function getBrowserOpenCommand(platform, url) {
@@ -30,7 +34,12 @@ export async function hasOpenAICodexAuth(storage) {
 }
 export async function loginOpenAICodex(storage) {
     const resolvedStorage = storage ?? (await createPiAuthStorage());
-    await resolvedStorage.login(OPENAI_CODEX_PROVIDER_ID, createOpenAICodexLoginCallbacks());
+    const { loginOpenAICodex: loginInBrowser } = await import('@earendil-works/pi-ai/oauth');
+    const credentials = await loginInBrowser(createOpenAICodexBrowserLoginOptions());
+    saveOpenAICodexCredentials(resolvedStorage, credentials);
+}
+export function saveOpenAICodexCredentials(storage, credentials) {
+    storage.set(OPENAI_CODEX_PROVIDER_ID, { type: 'oauth', ...credentials });
 }
 export async function logoutOpenAICodex(storage) {
     const resolvedStorage = storage ?? (await createPiAuthStorage());
@@ -44,6 +53,14 @@ export async function readStoredGeminiApiKey(store = createGeminiKeyStore()) {
 export async function getStoredGeminiApiKey(store = createGeminiKeyStore()) {
     return (await readStoredGeminiApiKey(store)).value;
 }
+export async function readStoredOpenRouterApiKey(store = createOpenRouterKeyStore()) {
+    const result = await store.getSecret();
+    const trimmed = result.value?.trim();
+    return trimmed ? { value: trimmed, backend: result.backend } : { value: undefined };
+}
+export async function getStoredOpenRouterApiKey(store = createOpenRouterKeyStore()) {
+    return (await readStoredOpenRouterApiKey(store)).value;
+}
 export async function saveGeminiApiKey(apiKey, store = createGeminiKeyStore()) {
     const normalized = apiKey.trim();
     if (!normalized) {
@@ -59,22 +76,40 @@ export async function saveGeminiApiKey(apiKey, store = createGeminiKeyStore()) {
         throw error;
     }
 }
+export async function saveOpenRouterApiKey(apiKey, store = createOpenRouterKeyStore()) {
+    const normalized = apiKey.trim();
+    if (!normalized) {
+        throw new Error('OpenRouter API key cannot be empty');
+    }
+    try {
+        return await store.setSecret(normalized);
+    }
+    catch (error) {
+        if (error instanceof SecureStoreUnavailableError) {
+            throw new SecureStoreUnavailableError(`${error.message} Set OPENROUTER_API_KEY in your environment instead.`);
+        }
+        throw error;
+    }
+}
+export async function deleteOpenRouterApiKey(store = createOpenRouterKeyStore()) {
+    return await store.deleteSecret();
+}
 export async function deleteGeminiApiKey(store = createGeminiKeyStore()) {
     return await store.deleteSecret();
 }
-export async function getAuthStatus({ env = process.env, storage, geminiStore = createGeminiKeyStore(), } = {}) {
+export async function getAuthStatus({ env = process.env, storage, geminiStore = createGeminiKeyStore(), openRouterStore = createOpenRouterKeyStore(), } = {}) {
     const envApiKeys = getEnvApiKeys(env);
     const geminiStored = envApiKeys.gemini
         ? { value: undefined }
         : await readStoredGeminiApiKey(geminiStore).catch(() => ({ value: undefined }));
+    const openRouterStored = envApiKeys.openrouter
+        ? { value: undefined }
+        : await readStoredOpenRouterApiKey(openRouterStore).catch(() => ({ value: undefined }));
     const openAICodexAuthConfigured = await hasOpenAICodexAuth(storage);
     return {
         openai: openAICodexAuthConfigured
             ? { configured: true, source: 'pi-auth' }
-            : {
-                configured: envApiKeys.openai !== undefined,
-                source: envApiKeys.openai !== undefined ? 'env' : undefined,
-            },
+            : { configured: false, source: undefined },
         gemini: envApiKeys.gemini
             ? { configured: true, source: 'env' }
             : {
@@ -85,9 +120,19 @@ export async function getAuthStatus({ env = process.env, storage, geminiStore =
                         : 'keychain'
                     : undefined,
             },
+        openrouter: envApiKeys.openrouter
+            ? { configured: true, source: 'env' }
+            : {
+                configured: openRouterStored.value !== undefined,
+                source: openRouterStored.value !== undefined
+                    ? openRouterStored.backend === 'file'
+                        ? 'file'
+                        : 'keychain'
+                    : undefined,
+            },
     };
 }
-function createOpenAICodexLoginCallbacks() {
+function createOpenAICodexBrowserLoginOptions() {
     return {
         onAuth: (info) => {
             openUrlInBrowser(info.url);

package/dist/config.js

@@ -1,17 +1,51 @@
-import { getStoredGeminiApiKey, hasOpenAICodexAuth, PI_AUTH_API_KEY } from './auth.js';
+import { getStoredGeminiApiKey, getStoredOpenRouterApiKey, hasOpenAICodexAuth, PI_AUTH_API_KEY, } from './auth.js';
 import { getEnvApiKeys } from './env.js';
+const REQUIRED_CLI_AUTH_PROVIDERS = [
+    { provider: 'openai', label: 'OpenAI' },
+    { provider: 'openrouter', label: 'OpenRouter' },
+];
 export async function getApiKeys(env = process.env, auth = {
     getStoredGeminiApiKey,
+    getStoredOpenRouterApiKey,
     hasOpenAICodexAuth,
 }) {
     const envApiKeys = getEnvApiKeys(env);
     const storedGeminiApiKey = envApiKeys.gemini
         ? undefined
         : await auth.getStoredGeminiApiKey().catch(() => undefined);
+    const storedOpenRouterApiKey = envApiKeys.openrouter
+        ? undefined
+        : await auth.getStoredOpenRouterApiKey().catch(() => undefined);
     const openAICodexAuthConfigured = await auth.hasOpenAICodexAuth();
-    return {
-        anthropic: envApiKeys.anthropic,
-        gemini: envApiKeys.gemini || storedGeminiApiKey,
-        openai: openAICodexAuthConfigured ? PI_AUTH_API_KEY : envApiKeys.openai,
-    };
+    const openRouterApiKey = envApiKeys.openrouter || storedOpenRouterApiKey;
+    const apiKeys = {};
+    const geminiApiKey = envApiKeys.gemini || storedGeminiApiKey;
+    if (geminiApiKey) {
+        apiKeys.gemini = geminiApiKey;
+    }
+    if (openRouterApiKey) {
+        apiKeys.deepseek = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+        apiKeys.zai = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+    }
+    if (openAICodexAuthConfigured) {
+        apiKeys.openai = PI_AUTH_API_KEY;
+    }
+    return apiKeys;
+}
+export function getMissingRequiredCliAuthProviders(status) {
+    return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => !status[provider].configured).map(({ label }) => label);
+}
+export function getMissingRequiredCliReviewAuthProviders(apiKeys) {
+    return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => {
+        switch (provider) {
+            case 'openai':
+                return !apiKeys.openai;
+            case 'openrouter':
+                return !(apiKeys.deepseek && apiKeys.zai);
+        }
+        return false;
+    }).map(({ label }) => label);
+}
+export function formatMissingRequiredCliAuthProviders(missingProviders) {
+    return `${missingProviders.join(' and ')} not configured; run \`doistbot auth\``;
 }

package/dist/env.js

@@ -3,8 +3,8 @@ function getEnvValue(value) {
 }
 export function getEnvApiKeys(env = process.env) {
     return {
-        anthropic: getEnvValue(env.ANTHROPIC_KEY) || getEnvValue(env.ANTHROPIC_API_KEY),
         gemini: getEnvValue(env.GEMINI_API_KEY),
         openai: getEnvValue(env.OPENAI_KEY) || getEnvValue(env.OPENAI_API_KEY),
+        openrouter: getEnvValue(env.OPENROUTER_API_KEY),
     };
 }

package/dist/file-store.js

@@ -41,7 +41,7 @@ export function createFileStore(account, filePath = FILE_STORE_PATH) {
 }
 function assertWritableOnThisPlatform() {
     if (process.platform === 'win32') {
-        throw new SecureStoreUnavailableError('File-based credential fallback is not supported on Windows because POSIX 0600 permissions cannot be enforced. Use Windows Credential Manager or set GEMINI_API_KEY.');
+        throw new SecureStoreUnavailableError('File-based credential fallback is not supported on Windows because POSIX 0600 permissions cannot be enforced. Use Windows Credential Manager or set an API key environment variable.');
     }
 }
 async function readCredentialsFile(filePath) {

package/dist/runtime.js

@@ -93,7 +93,7 @@ export function checkSandboxBuild() {
 }
 export function checkPiDependency() {
     try {
-        import.meta.resolve('@mariozechner/pi-coding-agent');
+        import.meta.resolve('@earendil-works/pi-coding-agent');
         return { ok: true, message: 'Pi coding agent is installed' };
     }
     catch {

package/dist/terminal.js

@@ -114,9 +114,10 @@ export async function withSpinner(message, task, terminalConfig = getDefaultTerm
     }
 }
 const PROVIDER_DISPLAY_NAMES = {
+    deepseek: 'DeepSeek',
     gemini: 'Gemini',
+    zai: 'Z.ai',
     openai: 'OpenAI',
-    anthropic: 'Anthropic',
 };
 function pluralizeChangedFiles(fileCount) {
     return `${fileCount} changed file${fileCount === 1 ? '' : 's'}`;
@@ -131,12 +132,6 @@ export function formatReviewProgress(event) {
             return `Prepared ${pluralizeChangedFiles(event.fileCount)} for review`;
         case 'formatting_results':
             return 'Review complete. Formatting results';
-        case 'council_findings_collected':
-            return `Collected ${event.findingCount} model finding${event.findingCount === 1 ? '' : 's'}`;
-        case 'council_consensus_check':
-            return event.findingGroupCount > 0
-                ? `Checking consensus across ${event.findingGroupCount} finding group${event.findingGroupCount === 1 ? '' : 's'}`
-                : 'No model findings to vote on. Finalizing the review';
         case 'agent_start':
             return `${PROVIDER_DISPLAY_NAMES[event.provider]} started reviewing the diff`;
         case 'agent_end':

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/doistbot-cli",
-    "version": "1.0.4",
+    "version": "1.0.6",
     "description": "Local self-review CLI for Doistbot",
     "type": "module",
     "main": "dist/index.js",
@@ -40,19 +40,19 @@
         "test": "vitest run src scripts --config ../../config/vitest.base.ts"
     },
     "dependencies": {
-        "@inquirer/checkbox": "5.1.5",
-        "@inquirer/password": "5.0.13",
-        "@mariozechner/pi-ai": "0.73.1",
-        "@mariozechner/pi-coding-agent": "0.73.1",
+        "@inquirer/checkbox": "5.2.1",
+        "@inquirer/password": "5.1.1",
+        "@earendil-works/pi-ai": "0.79.6",
+        "@earendil-works/pi-coding-agent": "0.79.6",
         "@napi-rs/keyring": "1.3.0",
         "ajv": "8.20.0",
         "chalk": "4.1.2",
         "commander": "14.0.3",
-        "js-yaml": "4.1.1",
+        "js-yaml": "4.2.0",
         "octokit": "5.0.5",
         "yocto-spinner": "1.2.0"
     },
     "devDependencies": {
-        "vitest": "4.1.6"
+        "vitest": "4.1.9"
     }
 }

package/sandbox/_node_modules/doistbot-repo-config/dist/index.d.ts

@@ -1,21 +1,14 @@
 import type { Logger } from 'doistbot-logging';
 import type { Octokit } from 'octokit';
 export declare const CONFIG_FILE_PATH = ".github/doistbot.yml";
-export declare const DEFAULT_COUNCIL_MODELS: readonly ["gemini", "openai"];
-type ParseCouncilModelsEnabledOptions = {
-    defaultModels?: readonly string[];
-};
+export declare const DEFAULT_REVIEW_MODELS: readonly ["gemini", "openai", "deepseek", "zai"];
+export type DefaultReviewModel = (typeof DEFAULT_REVIEW_MODELS)[number];
 export type RepoConfig = {
     review?: {
         skip_forks?: boolean;
         skip_drafts?: boolean;
         skip_title_pattern?: string;
         skip_branch_pattern?: string;
-        prompt_file?: string;
-        engine?: 'council' | 'multi_focus';
-        council?: {
-            enabled: boolean;
-        };
         /**
          * @deprecated Ignored as of #274. Doistbot now posts a GitHub Check
          * Run for every `/review` (always-on; no opt-in) when `HEAD_SHA` is
@@ -53,17 +46,6 @@ export declare function getLocalRepoConfig({ workspaceDir, logger, }: {
     workspaceDir: string;
     logger: Logger;
 }): RepoConfig | null;
-/**
- * Fetches a custom prompt file from the repository.
- * Returns null if the file doesn't exist.
- */
-export declare function getCustomPrompt({ octokit, owner, repo, path, ref, logger, }: FetchFileParams): Promise<string | null>;
-export declare function getLocalCustomPrompt({ workspaceDir, path: promptPath, logger, }: {
-    workspaceDir: string;
-    path: string;
-    logger: Logger;
-}): string | null;
-export declare function parseCouncilModelsEnabled(raw: string | undefined, { defaultModels }?: ParseCouncilModelsEnabledOptions): string[];
-export declare function getDefaultCouncilModels(): string[];
-export type { ReviewEngine } from './review-engine.js';
-export { DEFAULT_REVIEW_ENGINE, parseReviewEngine, resolveReviewEngine } from './review-engine.js';
+export declare function getDefaultReviewModels(): DefaultReviewModel[];
+export declare function parseReviewModelsEnabled(value: string | undefined): string[];
+export {};