listener-ai 2.6.0 → 2.7.1

package/dist/geminiService.js

@@ -39,8 +39,12 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const genai_1 = require("@google/genai");
+const aiProvider_1 = require("./aiProvider");
 const audioFormats_1 = require("./audioFormats");
+const codexOAuthHolder_1 = require("./codexOAuthHolder");
+const codexTranscription_1 = require("./codexTranscription");
 const outputService_1 = require("./outputService");
+const piAiClient_1 = require("./piAiClient");
 const ffmpegManager_1 = require("./services/ffmpegManager");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 // Append a section to the summary prompt instructing Gemini to enrich each
@@ -145,12 +149,99 @@ class GeminiService {
         return process.platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
     }
     constructor(options) {
-        this.apiKey = options.apiKey;
-        this.ai = new genai_1.GoogleGenAI({ apiKey: options.apiKey });
+        this.provider = options.provider ?? 'gemini';
+        if (this.provider === 'gemini') {
+            if (!options.apiKey) {
+                throw new Error('Gemini API key is required for the Gemini provider.');
+            }
+            this.ai = new genai_1.GoogleGenAI({ apiKey: options.apiKey });
+            this.geminiApiKey = options.apiKey;
+        }
+        else {
+            this.codexAuth = new codexOAuthHolder_1.CodexOAuthHolder({
+                credentials: options.codexOAuth,
+                onUpdate: options.onCodexOAuthUpdate,
+            });
+        }
         this.ffmpegManager = new ffmpegManager_1.FFmpegManager(options.dataPath);
         this.knownWords = options.knownWords || [];
         this.proModel = options.proModel;
         this.flashModel = options.flashModel;
+        this.codexModel = options.codexModel || aiProvider_1.DEFAULT_CODEX_MODEL;
+        this.codexTranscriptionModel =
+            options.codexTranscriptionModel || aiProvider_1.DEFAULT_CODEX_TRANSCRIPTION_MODEL;
+    }
+    gemini() {
+        if (!this.ai) {
+            throw new Error('Gemini client is not configured for the selected AI provider.');
+        }
+        return this.ai;
+    }
+    async getCodexToken() {
+        if (!this.codexAuth) {
+            throw new Error('Codex OAuth holder is not configured.');
+        }
+        return await this.codexAuth.getToken();
+    }
+    requireGeminiApiKey() {
+        if (!this.geminiApiKey) {
+            throw new Error('Gemini API key is not configured.');
+        }
+        return this.geminiApiKey;
+    }
+    // Pi-ai's GoogleOptions doesn't expose Gemini's `responseMimeType=application/json`
+    // knob, so models may wrap the JSON in ```json``` fences. The summary-text
+    // consumer strips fences before parsing (see stripJsonFences in
+    // transcribeWithTwoSteps).
+    async generateSummary(promptText, transcript) {
+        const modelId = this.provider === 'codex' ? this.codexModel : this.proModel;
+        const apiKey = this.provider === 'codex' ? await this.getCodexToken() : this.requireGeminiApiKey();
+        const model = await (0, piAiClient_1.getModel)(this.provider, modelId);
+        const context = {
+            messages: [
+                {
+                    role: 'user',
+                    content: `${promptText}\n\nTranscript:\n${transcript}`,
+                    timestamp: Date.now(),
+                },
+            ],
+        };
+        const response = await (0, piAiClient_1.complete)(model, context, {
+            apiKey,
+            temperature: 0.2,
+            maxTokens: 32768,
+        });
+        return (0, piAiClient_1.extractFinalText)(response);
+    }
+    async prepareAudioForProvider(audioFilePath) {
+        if (this.provider !== 'codex')
+            return { audioFilePath };
+        const ext = path.extname(audioFilePath).toLowerCase();
+        if (codexTranscription_1.OPENAI_TRANSCRIPTION_EXTENSIONS.has(ext))
+            return { audioFilePath };
+        const outputPath = path.join(path.dirname(audioFilePath), `${path.basename(audioFilePath, ext)}_codex_${Date.now()}.webm`);
+        const ffmpegPath = await this.getFFmpegPath();
+        await execFileAsync(ffmpegPath, [
+            '-i',
+            audioFilePath,
+            '-vn',
+            '-c:a',
+            'libopus',
+            '-b:a',
+            '48k',
+            outputPath,
+        ]);
+        return {
+            audioFilePath: outputPath,
+            cleanup: () => {
+                try {
+                    fs.unlinkSync(outputPath);
+                }
+                catch {
+                    /* ignore */
+                }
+            },
+        };
     }
     buildGlossaryBlock() {
         if (this.knownWords.length === 0)
@@ -178,16 +269,17 @@ class GeminiService {
                 suggestedTitle: 'Stubbed Title',
             };
         }
+        const prepared = await this.prepareAudioForProvider(audioFilePath);
         try {
             // Check file size
-            const stats = fs.statSync(audioFilePath);
+            const stats = fs.statSync(prepared.audioFilePath);
             const fileSizeInMB = stats.size / (1024 * 1024);
             console.error(`Audio file size: ${fileSizeInMB.toFixed(2)} MB`);
             if (progressCallback) {
                 progressCallback(15, `Processing ${fileSizeInMB.toFixed(1)} MB audio file...`);
             }
             // Get audio duration using ffmpeg
-            const duration = await this.getAudioDuration(audioFilePath);
+            const duration = await this.getAudioDuration(prepared.audioFilePath);
             console.error(`Audio duration: ${duration} seconds`);
             // If duration is 0, log a warning but continue processing
             if (duration === 0) {
@@ -195,14 +287,16 @@ class GeminiService {
             }
             // Always use the two-step approach for consistency
             console.error('Using two-step transcription approach...');
-            return await this.transcribeWithTwoSteps(audioFilePath, duration, progressCallback, summaryPrompt, liveNotes, options);
+            return await this.transcribeWithTwoSteps(prepared.audioFilePath, duration, progressCallback, summaryPrompt, liveNotes, options);
         }
         catch (error) {
             console.error('Error transcribing audio:', error);
             // Provide more specific error messages
             if (error instanceof Error) {
                 if (error.message.includes('API key')) {
-                    throw new Error('Invalid API key. Please check your Gemini API key configuration.');
+                    throw new Error(this.provider === 'codex'
+                        ? 'Invalid Codex OAuth token. Please sign in again.'
+                        : 'Invalid API key. Please check your Gemini API key configuration.');
                 }
                 else if (error.message.includes('quota')) {
                     throw new Error('API quota exceeded. Please try again later.');
@@ -213,6 +307,9 @@ class GeminiService {
             }
             throw new Error(`Failed to transcribe audio: ${error instanceof Error ? error.message : String(error)}`);
         }
+        finally {
+            prepared.cleanup?.();
+        }
     }
     // Get audio duration using ffmpeg
     async getAudioDuration(audioFilePath) {
@@ -264,15 +361,35 @@ class GeminiService {
         }
     }
     // Split audio file into segments
-    async splitAudioIntoSegments(audioFilePath, segmentDuration = 300) {
+    async splitAudioIntoSegments(audioFilePath, segmentDuration = 300, 
+    // re-encode segments instead of `-c copy`. ffmpeg's segment muxer can
+    // only cut at keyframes when copying, and webm-opus has near-zero
+    // keyframes by default -- so `-c copy -segment_time 300` silently
+    // produces 30+ minute segments that blow past gpt-4o-transcribe's
+    // 1400-second per-request limit. Caller passes `reencode: true` for
+    // the Codex transcription path; Gemini's API is tolerant of long
+    // inputs and stays on the faster `-c copy` path.
+    reencode = false) {
         const outputDir = path.dirname(audioFilePath);
         const baseName = path.basename(audioFilePath, path.extname(audioFilePath));
         const ext = path.extname(audioFilePath);
-        const segmentPath = path.join(outputDir, `${baseName}_segment_%03d${ext}`);
+        // When re-encoding to opus we MUST force a container that supports
+        // opus -- ffmpeg picks the muxer from the output extension, so leaving
+        // an imported `.mp3`/`.m4a`/`.wav` source as `.mp3` makes ffmpeg pick
+        // the MP3 muxer and reject the opus stream. `.webm` is in OpenAI's
+        // supported transcription extensions, so the segments still upload.
+        const segmentExt = reencode ? '.webm' : ext;
+        const segmentPath = path.join(outputDir, `${baseName}_segment_%03d${segmentExt}`);
         // Get the bundled FFmpeg path
         const ffmpegPath = await this.getFFmpegPath();
         try {
-            // Split audio into segments
+            const codecArgs = reencode ? ['-c:a', 'libopus', '-b:a', '48k'] : ['-c', 'copy'];
+            // Split audio into segments. `-reset_timestamps 1` makes each segment
+            // start at PTS 0 and gives it its own container duration. Without it,
+            // webm output keeps the source file's total duration in the header --
+            // and OpenAI rejects the request based on the header value even when
+            // the actual encoded audio is short (`audio duration N seconds is
+            // longer than 1400` errors on small last-segment files).
             await execFileAsync(ffmpegPath, [
                 '-i',
                 audioFilePath,
@@ -280,14 +397,17 @@ class GeminiService {
                 'segment',
                 '-segment_time',
                 String(segmentDuration),
-                '-c',
-                'copy',
+                '-reset_timestamps',
+                '1',
+                ...codecArgs,
                 segmentPath,
             ]);
-            // Find all created segment files
+            // Find all created segment files. Match on the EXTENSION WE TOLD
+            // FFMPEG TO WRITE -- when re-encoding, that's `.webm` regardless of
+            // the source's original extension.
             const segmentFiles = fs
                 .readdirSync(outputDir)
-                .filter((file) => file.startsWith(`${baseName}_segment_`) && file.endsWith(ext))
+                .filter((file) => file.startsWith(`${baseName}_segment_`) && file.endsWith(segmentExt))
                 .map((file) => path.join(outputDir, file))
                 .sort();
             console.error(`Split audio into ${segmentFiles.length} segments`);
@@ -339,11 +459,24 @@ class GeminiService {
     async transcribeWithTwoSteps(audioFilePath, duration, progressCallback, customSummaryPrompt, liveNotes, options = {}) {
         try {
             let fullTranscript = '';
+            const stats = fs.statSync(audioFilePath);
+            const fileSizeInMB = stats.size / (1024 * 1024);
+            // Segment intentionally for parallelism: even when the API would
+            // accept the whole file (Gemini long-context, gpt-4o-transcribe-diarize
+            // via chunking_strategy=auto), N parallel 5-min requests finish much
+            // faster than one big sequential pass. Trade-off for the diarize
+            // model: speaker IDs are mapped fresh per segment ("Speaker 0" in
+            // segment 1 may not be the same physical person as "Speaker 0" in
+            // segment 2). See docs/model-pricing.md.
+            const shouldSegment = duration > 300 || (this.provider === 'codex' && fileSizeInMB > 24);
+            const segmentDuration = this.provider === 'codex' && duration > 0 && fileSizeInMB > 20
+                ? Math.max(30, Math.min(300, Math.floor((20 / fileSizeInMB) * duration)))
+                : 300;
             // Step 1: Get transcript
-            if (duration > 300) {
+            if (shouldSegment) {
                 // Use segmented approach for long audio
-                console.error('Audio is longer than 5 minutes, using segmented transcription...');
-                fullTranscript = await this.getSegmentedTranscript(audioFilePath, duration, progressCallback, options.transcriptionPrompt);
+                console.error('Using segmented transcription...');
+                fullTranscript = await this.getSegmentedTranscript(audioFilePath, duration, progressCallback, options.transcriptionPrompt, segmentDuration);
             }
             else {
                 // Get transcript for short audio
@@ -380,16 +513,7 @@ Return as JSON:
             const enrichableNotes = (liveNotes ?? []).filter((n) => (n.text ?? '').trim().length > 0);
             const highlightsBlock = buildHighlightsPromptBlock(enrichableNotes);
             const summaryPrompt = highlightsBlock ? `${basePrompt}\n\n${highlightsBlock}` : basePrompt;
-            const summaryResult = await this.ai.models.generateContent({
-                model: this.proModel,
-                contents: [{ role: 'user', parts: [{ text: summaryPrompt }, { text: fullTranscript }] }],
-                config: {
-                    temperature: 0.2,
-                    maxOutputTokens: 32768,
-                    responseMimeType: 'application/json',
-                },
-            });
-            const summaryText = summaryResult.text || '';
+            const summaryText = await this.generateSummary(summaryPrompt, fullTranscript);
             let summaryData = {
                 suggestedTitle: '',
                 summary: '',
@@ -407,8 +531,16 @@ Return as JSON:
             ]);
             const customFields = {};
             let rawHighlights;
+            // Pi-ai's unified API doesn't pass through Gemini's responseMimeType
+            // knob, so models can wrap the JSON in ```json``` fences or add leading
+            // chatter. Strip a single fenced block if present, otherwise feed the
+            // raw text to JSON.parse and fall back to a regex extract.
+            const stripJsonFences = (text) => {
+                const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+                return fenced ? fenced[1].trim() : text.trim();
+            };
             try {
-                const parsed = JSON.parse(summaryText);
+                const parsed = JSON.parse(stripJsonFences(summaryText));
                 summaryData = parsed;
                 rawHighlights = parsed.highlights;
                 // Extract custom fields (any keys not in the known set)
@@ -454,6 +586,23 @@ Return as JSON:
             if (progressCallback) {
                 progressCallback(20, 'Processing audio file...');
             }
+            const transcriptPrompt = `${this.buildGlossaryBlock()}${customPrompt ?? DEFAULT_TRANSCRIPT_PROMPT}`;
+            if (this.provider === 'codex') {
+                return await (0, codexTranscription_1.transcribeCodexAudio)({
+                    getToken: () => this.getCodexToken(),
+                    audioFilePath,
+                    model: this.codexTranscriptionModel,
+                    // `prompt` is dropped inside transcribeCodexAudio when the
+                    // diarize model is active. Keep passing it -- the helper picks
+                    // the right shape per model.
+                    prompt: transcriptPrompt,
+                    // Intentionally NOT passing `language: 'ko'`. Whisper-derived
+                    // transcription auto-detects from the first ~30s, which handles
+                    // bilingual/code-switched meetings (Korean primary, English
+                    // acronyms/quotes) better than forcing a single language.
+                });
+            }
+            const ai = this.gemini();
             // Use Files API for files over 20MB
             let fileUri = null;
             if (fileSizeInMB > 20) {
@@ -463,17 +612,17 @@ Return as JSON:
                 }
                 const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
                 const fileData = fs.readFileSync(audioFilePath);
-                const uploadResult = await this.ai.files.upload({
+                const uploadResult = await ai.files.upload({
                     file: new Blob([fileData], { type: mimeType }),
                 });
                 fileUri = uploadResult.uri || '';
                 // Wait for file to be active
-                let file = await this.ai.files.get({ name: uploadResult.name || '' });
+                let file = await ai.files.get({ name: uploadResult.name || '' });
                 let retries = 0;
                 while (file.state === 'PROCESSING' && retries < 30) {
                     console.error(`Waiting for file to be processed... (attempt ${retries + 1}/30)`);
                     await new Promise((resolve) => setTimeout(resolve, 2000));
-                    file = await this.ai.files.get({ name: uploadResult.name || '' });
+                    file = await ai.files.get({ name: uploadResult.name || '' });
                     retries++;
                 }
                 if (file.state !== 'ACTIVE') {
@@ -483,11 +632,10 @@ Return as JSON:
             if (progressCallback) {
                 progressCallback(50, 'Transcribing audio...');
             }
-            const transcriptPrompt = `${this.buildGlossaryBlock()}${customPrompt ?? DEFAULT_TRANSCRIPT_PROMPT}`;
             let result;
             if (fileUri) {
                 const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
-                result = await this.ai.models.generateContent({
+                result = await ai.models.generateContent({
                     model: this.flashModel,
                     contents: [
                         {
@@ -513,7 +661,7 @@ Return as JSON:
                 const audioData = fs.readFileSync(audioFilePath);
                 const base64Audio = audioData.toString('base64');
                 const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
-                result = await this.ai.models.generateContent({
+                result = await ai.models.generateContent({
                     model: this.flashModel,
                     contents: [
                         {
@@ -567,10 +715,23 @@ Return as JSON:
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
                 console.error(`Starting transcription for segment ${segmentIndex + 1}/${totalSegments} (attempt ${attempt}/${maxRetries})...`);
+                if (this.provider === 'codex') {
+                    const transcript = await (0, codexTranscription_1.transcribeCodexAudio)({
+                        getToken: () => this.getCodexToken(),
+                        audioFilePath: segmentFile,
+                        model: this.codexTranscriptionModel,
+                        prompt: segmentPrompt,
+                    });
+                    console.error(`Completed transcription for segment ${segmentIndex + 1}/${totalSegments}`);
+                    return {
+                        index: segmentIndex,
+                        content: this.createSegmentHeader(segmentIndex, segmentStartTime, segmentEndTime) + transcript,
+                    };
+                }
                 const audioData = fs.readFileSync(segmentFile);
                 const base64Audio = audioData.toString('base64');
                 const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(segmentFile));
-                const result = await this.ai.models.generateContent({
+                const result = await this.gemini().models.generateContent({
                     model: this.flashModel,
                     contents: [
                         {
@@ -619,17 +780,20 @@ Return as JSON:
         };
     }
     // Get segmented transcript (renamed from transcribeAudioSegmented)
-    async getSegmentedTranscript(audioFilePath, duration, progressCallback, customPrompt) {
+    async getSegmentedTranscript(audioFilePath, duration, progressCallback, customPrompt, segmentDuration = 300) {
         try {
-            // Split audio into 5-minute segments
-            const segmentFiles = await this.splitAudioIntoSegments(audioFilePath, 300);
+            // Split audio into 5-minute segments. Codex transcription requires
+            // accurate cut times (gpt-4o-transcribe rejects >1400s/segment), so
+            // force re-encode there; Gemini's API tolerates long inputs and we
+            // keep the cheaper `-c copy` path for it.
+            const segmentFiles = await this.splitAudioIntoSegments(audioFilePath, segmentDuration, this.provider === 'codex');
             if (progressCallback) {
                 progressCallback(20, `Processing ${segmentFiles.length} segments...`);
             }
             // Create promises for all segment transcriptions
             const transcriptionPromises = segmentFiles.map(async (segmentFile, i) => {
-                const segmentStartTime = i * 300; // 5 minutes in seconds
-                const segmentEndTime = Math.min(segmentStartTime + 300, duration);
+                const segmentStartTime = i * segmentDuration;
+                const segmentEndTime = Math.min(segmentStartTime + segmentDuration, duration);
                 return this.transcribeSingleSegment(segmentFile, i, segmentFiles.length, segmentStartTime, segmentEndTime, customPrompt);
             });
             // Track progress of concurrent transcriptions

package/dist/main.js

@@ -42,6 +42,8 @@ const electron_1 = require("electron");
 const agentService_1 = require("./agentService");
 const audioFormats_1 = require("./audioFormats");
 const configService_1 = require("./configService");
+const codexOAuth_1 = require("./codexOAuth");
+const dataPath_1 = require("./dataPath");
 const displayDetectorService_1 = require("./displayDetectorService");
 const geminiService_1 = require("./geminiService");
 const meetingDetectorService_1 = require("./meetingDetectorService");
@@ -69,6 +71,7 @@ if (process.platform === 'darwin') {
     electron_1.app.commandLine.appendSwitch('enable-features', 'MacSckSystemAudioLoopbackCapture,MacCatapSystemAudioLoopbackCapture');
 }
 global.isQuitting = false;
+electron_1.app.setPath('userData', (0, dataPath_1.getDataPath)());
 let mainWindow = null;
 const audioRecorder = new simpleAudioRecorder_1.SimpleAudioRecorder();
 const systemAudioService = new systemAudioService_1.SystemAudioService();
@@ -83,14 +86,30 @@ let geminiService = null;
 let notionService = null;
 let slackService = null;
 let agentService = null;
+function formatAiCredentialsError() {
+    return configService.getAiProvider() === 'codex'
+        ? 'Codex OAuth is not configured. Sign in with Codex OAuth or switch back to Gemini.'
+        : 'Gemini API key not configured.';
+}
 function getAgentService() {
     if (agentService)
         return agentService;
-    const apiKey = configService.getGeminiApiKey();
-    if (!apiKey)
+    if (!configService.hasAiAuth())
         return null;
     agentService = new agentService_1.AgentService({
-        apiKey,
+        provider: configService.getAiProvider(),
+        apiKey: configService.getGeminiApiKey(),
+        codexOAuth: configService.getCodexOAuth(),
+        // Only persist refreshed tokens when the credentials originated in config.json.
+        // Env-only credentials must stay ephemeral -- writing refreshed tokens to disk
+        // would leak ephemeral env creds into the persistent store.
+        onCodexOAuthUpdate: configService.hasStoredCodexOAuth()
+            ? (credentials) => {
+                configService.setCodexOAuth(credentials);
+                broadcastConfigChanged();
+            }
+            : undefined,
+        codexModel: configService.getCodexModel(),
         dataPath: electron_1.app.getPath('userData'),
         configService,
     });
@@ -134,14 +153,25 @@ function trackFinalize(work) {
     pendingFinalize = pendingFinalize.then(() => work).catch(() => { });
 }
 function createGeminiService() {
-    const apiKey = configService.getGeminiApiKey();
-    if (!apiKey)
+    if (!configService.hasAiAuth())
         return null;
     return new geminiService_1.GeminiService({
-        apiKey,
+        provider: configService.getAiProvider(),
+        apiKey: configService.getGeminiApiKey(),
+        codexOAuth: configService.getCodexOAuth(),
+        // See note in getAgentService(): persist refreshed tokens only for stored creds.
+        onCodexOAuthUpdate: configService.hasStoredCodexOAuth()
+            ? (credentials) => {
+                configService.setCodexOAuth(credentials);
+                broadcastConfigChanged();
+            }
+            : undefined,
         knownWords: configService.getKnownWords(),
         proModel: configService.getGeminiModel(),
         flashModel: configService.getGeminiFlashModel(),
+        codexModel: configService.getCodexModel(),
+        codexTranscriptionModel: configService.getCodexTranscriptionModel(),
+        dataPath: electron_1.app.getPath('userData'),
     });
 }
 function registerGlobalShortcut() {
@@ -827,9 +857,8 @@ electron_1.ipcMain.handle('merge-recordings', async (_, opts) => {
             resolvedInputs.push(resolved);
         }
         if (!geminiService) {
-            const apiKey = configService.getGeminiApiKey();
-            if (!apiKey) {
-                return { success: false, error: 'Gemini API key not configured' };
+            if (!configService.hasAiAuth()) {
+                return { success: false, error: formatAiCredentialsError() };
             }
             geminiService = createGeminiService();
         }
@@ -1075,9 +1104,13 @@ electron_1.ipcMain.handle('abort-recording', async () => {
 // IPC and the agent-chat flow when set_config mutations land.
 function applyConfigSideEffects(changed) {
     if (changed.knownWords !== undefined ||
+        changed.aiProvider !== undefined ||
         changed.geminiApiKey !== undefined ||
         changed.geminiModel !== undefined ||
-        changed.geminiFlashModel !== undefined) {
+        changed.geminiFlashModel !== undefined ||
+        changed.codexOAuth !== undefined ||
+        changed.codexModel !== undefined ||
+        changed.codexTranscriptionModel !== undefined) {
         geminiService = createGeminiService();
         agentService = null;
     }
@@ -1169,6 +1202,38 @@ electron_1.ipcMain.handle('save-config', async (_, config) => {
 electron_1.ipcMain.handle('get-config', async () => {
     return configService.getAllConfig();
 });
+electron_1.ipcMain.handle('codex-oauth-login', async () => {
+    try {
+        const credentials = await (0, codexOAuth_1.loginCodexOAuth)({
+            openUrl: (url) => electron_1.shell.openExternal(url),
+            onPrompt: async (_prompt) => {
+                throw new Error('Codex OAuth manual callback is only supported from the CLI. Run `listener codex login` if browser sign-in does not complete.');
+            },
+            onProgress: (message) => console.log(`Codex OAuth: ${message}`),
+        });
+        configService.setCodexOAuth(credentials);
+        configService.setAiProvider('codex');
+        applyConfigSideEffects({ aiProvider: 'codex', codexOAuth: credentials });
+        broadcastConfigChanged();
+        return { success: true, config: configService.getAllConfig() };
+    }
+    catch (error) {
+        console.error('Codex OAuth login failed:', error);
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
+electron_1.ipcMain.handle('codex-oauth-clear', async () => {
+    try {
+        configService.clearCodexOAuth();
+        applyConfigSideEffects({ aiProvider: configService.getAiProvider() });
+        broadcastConfigChanged();
+        return { success: true, config: configService.getAllConfig() };
+    }
+    catch (error) {
+        console.error('Codex OAuth clear failed:', error);
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
 electron_1.ipcMain.handle('get-all-releases', async () => {
     console.log('Release list IPC: get-all-releases invoked');
     const results = await (0, releaseNotesService_1.fetchAllReleases)();
@@ -1191,6 +1256,9 @@ electron_1.ipcMain.handle('update:simulate', async (_, event, data) => {
 electron_1.ipcMain.handle('check-config', async () => {
     return {
         hasConfig: configService.hasRequiredConfig(),
+        hasAiAuth: configService.hasAiAuth(),
+        aiProvider: configService.getAiProvider(),
+        codexOAuthConfigured: configService.hasCodexOAuth(),
         missing: configService.getMissingConfigs(),
     };
 });
@@ -1241,15 +1309,14 @@ electron_1.ipcMain.handle('transcribe-audio', async (_, filePath, liveNotesRaw)
         if (mainWindow) {
             mainWindow.webContents.send('transcription-progress', {
                 percent: 0,
-                message: 'Initializing Gemini service...',
+                message: 'Initializing AI service...',
             });
         }
-        // Initialize Gemini service if not already initialized
+        // Initialize AI service if not already initialized
         if (!geminiService) {
-            const apiKey = configService.getGeminiApiKey();
-            console.log('API key configured:', !!apiKey);
-            if (!apiKey) {
-                return { success: false, error: 'Gemini API key not configured' };
+            console.log('AI credentials configured:', configService.hasAiAuth());
+            if (!configService.hasAiAuth()) {
+                return { success: false, error: formatAiCredentialsError() };
             }
             geminiService = createGeminiService();
         }
@@ -1667,7 +1734,7 @@ electron_1.ipcMain.handle('agent-chat', async (_event, opts) => {
     try {
         const agent = getAgentService();
         if (!agent) {
-            return { success: false, error: 'Gemini API key not configured.' };
+            return { success: false, error: formatAiCredentialsError() };
         }
         const question = (opts?.question ?? '').trim();
         if (!question)