@airoom/nextmin-node 2.0.1 → 2.0.3

package/dist/services/OpenAIService.js

@@ -0,0 +1,586 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Logger_1 = __importDefault(require("../utils/Logger"));
+/**
+ * Helper to fetch with retry on HTTP 429 (Rate Limit).
+ * Dynamically parses the wait time from OpenAI's error messages.
+ */
+async function fetchWithRetry(url, options, retries = 5, baseDelay = 2000) {
+    const response = await fetch(url, options);
+    if (response.status === 429 && retries > 0) {
+        const responseText = await response.clone().text();
+        let waitTime = baseDelay;
+        try {
+            const errObj = JSON.parse(responseText);
+            const msg = errObj?.error?.message;
+            // OpenAI message format: "please slow down and try again after 43.912857 seconds"
+            const match = msg?.match(/try again after (\d+\.?\d*) seconds/i);
+            if (match && match[1]) {
+                waitTime = (parseFloat(match[1]) + 1.5) * 1000; // convert to ms + 1.5s safety buffer
+            }
+        }
+        catch { }
+        const seconds = Math.ceil(waitTime / 1000);
+        console.log(`[OpenAIService] Rate limit exceeded. Waiting ${seconds} seconds before retrying (Remaining retries: ${retries})...`);
+        await new Promise(resolve => setTimeout(resolve, waitTime));
+        return fetchWithRetry(url, options, retries - 1, baseDelay * 2);
+    }
+    return response;
+}
+class OpenAIService {
+    static getConfigPath() {
+        return path_1.default.join(process.cwd(), '.nextmin', 'config.json');
+    }
+    static readOpenAIMetadata() {
+        const p = this.getConfigPath();
+        if (!fs_1.default.existsSync(p))
+            return {};
+        try {
+            const content = JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+            return content.openai || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    static writeOpenAIMetadata(metadata) {
+        const p = this.getConfigPath();
+        try {
+            let config = {};
+            if (fs_1.default.existsSync(p)) {
+                try {
+                    config = JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+                }
+                catch { }
+            }
+            config.openai = {
+                ...(config.openai || {}),
+                ...metadata
+            };
+            fs_1.default.writeFileSync(p, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (err) {
+            Logger_1.default.error('OpenAIService', 'Failed to write OpenAI metadata to config.json', err);
+        }
+    }
+    /**
+     * Syncs local scraped text files to the OpenAI Vector Store.
+     * Uses parallel file uploads and batch attachments to optimize speed.
+     */
+    async syncFilesToVectorStore(force = false) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            Logger_1.default.warn('OpenAIService', 'OPENAI_API_KEY not found in environment. Skipping OpenAI sync.');
+            return;
+        }
+        const metadata = OpenAIService.readOpenAIMetadata();
+        let vectorStoreId = metadata.vectorStoreId;
+        const fileIds = metadata.fileIds || {};
+        const fileHashes = metadata.fileHashes || {};
+        // If force is true, reset and delete the existing vector store
+        if (force && vectorStoreId) {
+            Logger_1.default.info('OpenAIService', `Force rebuild requested. Deleting old OpenAI vector store: ${vectorStoreId}`);
+            try {
+                await fetchWithRetry(`https://api.openai.com/v1/vector_stores/${vectorStoreId}`, {
+                    method: 'DELETE',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'OpenAI-Beta': 'assistants=v2'
+                    }
+                });
+            }
+            catch (err) {
+                Logger_1.default.warn('OpenAIService', `Failed to delete old vector store ${vectorStoreId}`, err);
+            }
+            // Also delete all existing files in metadata from OpenAI
+            const existingFileIds = Object.values(fileIds);
+            if (existingFileIds.length > 0) {
+                Logger_1.default.info('OpenAIService', `Deleting ${existingFileIds.length} existing files from OpenAI...`);
+                const fileDeletePromises = existingFileIds.map(async (fileId) => {
+                    try {
+                        await fetchWithRetry(`https://api.openai.com/v1/files/${fileId}`, {
+                            method: 'DELETE',
+                            headers: {
+                                'Authorization': `Bearer ${apiKey}`
+                            }
+                        });
+                    }
+                    catch (err) {
+                        // ignore
+                    }
+                });
+                await Promise.all(fileDeletePromises);
+            }
+            vectorStoreId = '';
+            // Reset in-memory maps
+            for (const key of Object.keys(fileIds))
+                delete fileIds[key];
+            for (const key of Object.keys(fileHashes))
+                delete fileHashes[key];
+            // Save the cleared state to disk immediately
+            OpenAIService.writeOpenAIMetadata({ vectorStoreId: '', fileIds: {}, fileHashes: {} });
+        }
+        const manifestPath = path_1.default.join(process.cwd(), '.nextmin', 'indexing-manifest.json');
+        if (!fs_1.default.existsSync(manifestPath)) {
+            Logger_1.default.warn('OpenAIService', 'indexing-manifest.json not found. Skipping file sync.');
+            return;
+        }
+        let manifest = {};
+        try {
+            manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch {
+            Logger_1.default.error('OpenAIService', 'Failed to parse indexing-manifest.json');
+            return;
+        }
+        const currentHashes = manifest.hashes || {};
+        const scrappedPagesDir = path_1.default.join(process.cwd(), '.nextmin', 'scraped-pages');
+        // 1. Create Vector Store if it doesn't exist
+        if (!vectorStoreId) {
+            Logger_1.default.info('OpenAIService', 'Creating OpenAI vector store...');
+            try {
+                const vsRes = await fetchWithRetry('https://api.openai.com/v1/vector_stores', {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                        'OpenAI-Beta': 'assistants=v2'
+                    },
+                    body: JSON.stringify({ name: 'NextMin Scraped Pages Store' })
+                });
+                if (!vsRes.ok) {
+                    const errBody = await vsRes.text();
+                    throw new Error(`Failed to create OpenAI vector store: ${vsRes.statusText}. Response: ${errBody}`);
+                }
+                const vsData = await vsRes.json();
+                vectorStoreId = vsData.id;
+                Logger_1.default.info('OpenAIService', `Created OpenAI vector store: ${vectorStoreId}`);
+                OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+            }
+            catch (err) {
+                Logger_1.default.error('OpenAIService', 'Failed to initialize OpenAI vector store', err);
+                throw err;
+            }
+        }
+        // Auto-Recovery: If fileIds is empty, but we have a vectorStoreId,
+        // fetch all files from OpenAI (paginated) and reconstruct the local config mapping.
+        if (Object.keys(fileIds).length === 0) {
+            Logger_1.default.info('OpenAIService', 'Local file mappings are empty. Fetching uploaded files from OpenAI to reconstruct configuration...');
+            try {
+                let hasMore = true;
+                let after = '';
+                let restoredCount = 0;
+                const totalToFind = Object.keys(currentHashes).length;
+                let page = 1;
+                while (hasMore) {
+                    Logger_1.default.info('OpenAIService', `Fetching page ${page} of files from OpenAI...`);
+                    const url = 'https://api.openai.com/v1/files?limit=10000' + (after ? `&after=${after}` : '');
+                    const filesRes = await fetchWithRetry(url, {
+                        method: 'GET',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`
+                        }
+                    });
+                    if (!filesRes.ok) {
+                        const errBody = await filesRes.text();
+                        throw new Error(`Failed to list files from OpenAI: ${filesRes.statusText}. Response: ${errBody}`);
+                    }
+                    const filesData = await filesRes.json();
+                    const openAIFiles = filesData.data || [];
+                    if (openAIFiles.length === 0)
+                        break;
+                    for (const file of openAIFiles) {
+                        if (file.filename && file.filename.startsWith('page-') && file.filename.endsWith('.txt')) {
+                            const key = file.filename.slice(0, -4); // Remove .txt
+                            // Restoring only if the file is present in our current local manifest and not already mapped
+                            if (currentHashes[key] && !fileIds[key]) {
+                                fileIds[key] = file.id;
+                                fileHashes[key] = currentHashes[key]; // Assume contents match for now
+                                restoredCount++;
+                            }
+                        }
+                    }
+                    // If we have successfully recovered mappings for all local files, we can stop early
+                    if (Object.keys(fileIds).length >= totalToFind) {
+                        Logger_1.default.info('OpenAIService', 'All local file mappings have been recovered. Stopping search early.');
+                        break;
+                    }
+                    hasMore = filesData.has_more;
+                    if (hasMore && openAIFiles.length > 0) {
+                        after = openAIFiles[openAIFiles.length - 1].id;
+                        page++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (restoredCount > 0) {
+                    Logger_1.default.info('OpenAIService', `Successfully restored ${restoredCount} file mappings from OpenAI.`);
+                    OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+                }
+            }
+            catch (err) {
+                Logger_1.default.error('OpenAIService', 'Failed to auto-recover file mappings from OpenAI. Aborting sync to prevent file duplication.', err);
+                throw err;
+            }
+        }
+        // 2. Identify files to delete/prune
+        const deletePromises = [];
+        const keysToDelete = [];
+        for (const key of Object.keys(fileIds)) {
+            const localHash = currentHashes[key];
+            const openAIHash = fileHashes[key];
+            const fileId = fileIds[key];
+            if (!localHash || localHash !== openAIHash) {
+                Logger_1.default.info('OpenAIService', `Queuing pruning of outdated/deleted file on OpenAI: ${key} (${fileId})`);
+                keysToDelete.push(key);
+                const deleteProc = (async () => {
+                    try {
+                        // Delete from vector store
+                        await fetchWithRetry(`https://api.openai.com/v1/vector_stores/${vectorStoreId}/files/${fileId}`, {
+                            method: 'DELETE',
+                            headers: {
+                                'Authorization': `Bearer ${apiKey}`,
+                                'OpenAI-Beta': 'assistants=v2'
+                            }
+                        });
+                        // Delete the file itself
+                        await fetchWithRetry(`https://api.openai.com/v1/files/${fileId}`, {
+                            method: 'DELETE',
+                            headers: {
+                                'Authorization': `Bearer ${apiKey}`
+                            }
+                        });
+                    }
+                    catch (err) {
+                        Logger_1.default.warn('OpenAIService', `Failed to delete file ${fileId} from OpenAI`, err);
+                    }
+                })();
+                deletePromises.push(deleteProc);
+            }
+        }
+        // Wait for all deletions to finish in parallel
+        if (deletePromises.length > 0) {
+            await Promise.all(deletePromises);
+            for (const key of keysToDelete) {
+                delete fileIds[key];
+                delete fileHashes[key];
+            }
+            OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+        }
+        // 3. Identify files to upload
+        const keysToUpload = [];
+        for (const [key, localHash] of Object.entries(currentHashes)) {
+            if (!fileIds[key]) {
+                keysToUpload.push(key);
+            }
+        }
+        if (keysToUpload.length > 0) {
+            Logger_1.default.info('OpenAIService', `Uploading and syncing ${keysToUpload.length} files to OpenAI...`);
+            const totalFiles = keysToUpload.length;
+            let uploadedCount = 0;
+            const BATCH_SIZE = 1500;
+            const CONCURRENCY_LIMIT = 15;
+            for (let i = 0; i < keysToUpload.length; i += BATCH_SIZE) {
+                const batchKeys = keysToUpload.slice(i, i + BATCH_SIZE);
+                const batchFileIds = [];
+                const batchSuccessfulKeys = [];
+                // Upload the batch files in parallel (up to CONCURRENCY_LIMIT concurrently)
+                for (let j = 0; j < batchKeys.length; j += CONCURRENCY_LIMIT) {
+                    const subBatchKeys = batchKeys.slice(j, j + CONCURRENCY_LIMIT);
+                    const uploadPromises = subBatchKeys.map(async (key) => {
+                        const filePath = path_1.default.join(scrappedPagesDir, `${key}.txt`);
+                        if (!fs_1.default.existsSync(filePath)) {
+                            Logger_1.default.warn('OpenAIService', `Scraped file not found locally: ${filePath}`);
+                            return;
+                        }
+                        const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                        try {
+                            const formData = new FormData();
+                            formData.append('purpose', 'assistants');
+                            const blob = new Blob([content], { type: 'text/plain' });
+                            formData.append('file', blob, `${key}.txt`);
+                            const uploadRes = await fetchWithRetry('https://api.openai.com/v1/files', {
+                                method: 'POST',
+                                headers: {
+                                    'Authorization': `Bearer ${apiKey}`
+                                },
+                                body: formData
+                            });
+                            if (!uploadRes.ok) {
+                                const errBody = await uploadRes.text();
+                                throw new Error(`Upload failed: ${uploadRes.statusText}. Response: ${errBody}`);
+                            }
+                            const uploadData = await uploadRes.json();
+                            batchFileIds.push(uploadData.id);
+                            batchSuccessfulKeys.push(key);
+                            // Map in memory
+                            fileIds[key] = uploadData.id;
+                            fileHashes[key] = currentHashes[key];
+                        }
+                        catch (err) {
+                            Logger_1.default.error('OpenAIService', `Failed to upload file ${key} to OpenAI`, err);
+                        }
+                        finally {
+                            uploadedCount++;
+                            if (uploadedCount % 25 === 0 || uploadedCount === totalFiles) {
+                                const pct = ((uploadedCount / totalFiles) * 100).toFixed(1);
+                                console.log(`[OpenAIService] Sync Progress: ${uploadedCount}/${totalFiles} files (${pct}%)...`);
+                            }
+                        }
+                    });
+                    await Promise.all(uploadPromises);
+                }
+                // Attach this chunk to the vector store immediately
+                if (batchFileIds.length > 0) {
+                    Logger_1.default.info('OpenAIService', `Attaching chunk of ${batchFileIds.length} files to Vector Store...`);
+                    try {
+                        const batchRes = await fetchWithRetry(`https://api.openai.com/v1/vector_stores/${vectorStoreId}/file_batches`, {
+                            method: 'POST',
+                            headers: {
+                                'Authorization': `Bearer ${apiKey}`,
+                                'Content-Type': 'application/json',
+                                'OpenAI-Beta': 'assistants=v2'
+                            },
+                            body: JSON.stringify({ file_ids: batchFileIds })
+                        });
+                        if (!batchRes.ok) {
+                            const errBody = await batchRes.clone().text();
+                            let isNotFoundError = false;
+                            try {
+                                const errObj = JSON.parse(errBody);
+                                if (errObj?.error?.message?.includes('No vector store found')) {
+                                    isNotFoundError = true;
+                                }
+                            }
+                            catch { }
+                            if (isNotFoundError || batchRes.status === 404) {
+                                Logger_1.default.warn('OpenAIService', `Vector store ${vectorStoreId} was not found on OpenAI. Recreating one...`);
+                                const vsRes = await fetchWithRetry('https://api.openai.com/v1/vector_stores', {
+                                    method: 'POST',
+                                    headers: {
+                                        'Authorization': `Bearer ${apiKey}`,
+                                        'Content-Type': 'application/json',
+                                        'OpenAI-Beta': 'assistants=v2'
+                                    },
+                                    body: JSON.stringify({ name: 'NextMin Scraped Pages Store' })
+                                });
+                                if (vsRes.ok) {
+                                    const vsData = await vsRes.json();
+                                    vectorStoreId = vsData.id;
+                                    Logger_1.default.info('OpenAIService', `Recreated missing OpenAI vector store: ${vectorStoreId}`);
+                                    OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+                                    // Retry the attachment
+                                    const retryRes = await fetchWithRetry(`https://api.openai.com/v1/vector_stores/${vectorStoreId}/file_batches`, {
+                                        method: 'POST',
+                                        headers: {
+                                            'Authorization': `Bearer ${apiKey}`,
+                                            'Content-Type': 'application/json',
+                                            'OpenAI-Beta': 'assistants=v2'
+                                        },
+                                        body: JSON.stringify({ file_ids: batchFileIds })
+                                    });
+                                    if (retryRes.ok) {
+                                        Logger_1.default.info('OpenAIService', `Batch of ${batchFileIds.length} files attached successfully on retry.`);
+                                        OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+                                        continue; // Chunk attached successfully!
+                                    }
+                                    else {
+                                        const retryErrBody = await retryRes.text();
+                                        throw new Error(`Batch attach retry failed: ${retryRes.statusText}. Response: ${retryErrBody}`);
+                                    }
+                                }
+                                else {
+                                    const vsErrBody = await vsRes.text();
+                                    throw new Error(`Failed to recreate OpenAI vector store: ${vsRes.statusText}. Response: ${vsErrBody}`);
+                                }
+                            }
+                            throw new Error(`Batch attach failed: ${batchRes.statusText}. Response: ${errBody}`);
+                        }
+                        Logger_1.default.info('OpenAIService', `Batch of ${batchFileIds.length} files attached successfully.`);
+                        // Save state progressively to config.json
+                        OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+                    }
+                    catch (err) {
+                        Logger_1.default.error('OpenAIService', `Failed to attach file batch chunk to Vector Store. Deleting successfully uploaded files from OpenAI to prevent orphans.`, err);
+                        // Delete the files from OpenAI that were uploaded in this batch to prevent orphans
+                        const rollbackPromises = batchSuccessfulKeys.map(async (key) => {
+                            const fileId = fileIds[key];
+                            if (fileId) {
+                                try {
+                                    await fetchWithRetry(`https://api.openai.com/v1/files/${fileId}`, {
+                                        method: 'DELETE',
+                                        headers: {
+                                            'Authorization': `Bearer ${apiKey}`
+                                        }
+                                    });
+                                }
+                                catch (deleteErr) {
+                                    Logger_1.default.warn('OpenAIService', `Failed to delete orphaned file ${fileId} from OpenAI during rollback`, deleteErr);
+                                }
+                            }
+                            delete fileIds[key];
+                            delete fileHashes[key];
+                        });
+                        await Promise.all(rollbackPromises);
+                        OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+                    }
+                }
+            }
+        }
+        // Save final metadata state
+        OpenAIService.writeOpenAIMetadata({ vectorStoreId, fileIds, fileHashes });
+        Logger_1.default.info('OpenAIService', 'OpenAI Vector Store sync complete.');
+    }
+    /**
+     * Generates a streaming answer from OpenAI Responses API.
+     * Note: For user chat queries, we DO NOT retry on 429 because we want to fail-fast
+     * and fall back to the local Gemma offline model immediately without blocking.
+     */
+    async generateAnswerStream(localThreadId, message, systemPrompt, onTextChunk, disableFileSearch = false) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error('OPENAI_API_KEY is not defined.');
+        }
+        const metadata = OpenAIService.readOpenAIMetadata();
+        const vectorStoreId = metadata.vectorStoreId;
+        const threadMappings = metadata.threadMappings || {};
+        const latestResponseId = threadMappings[localThreadId] || null;
+        Logger_1.default.info('OpenAIService', `Sending question to OpenAI Responses API. Thread: ${localThreadId}, PrevResponseId: ${latestResponseId}`);
+        const tools = [];
+        if (vectorStoreId && !disableFileSearch) {
+            tools.push({
+                type: 'file_search',
+                vector_store_ids: [vectorStoreId]
+            });
+        }
+        else {
+            Logger_1.default.info('OpenAIService', `Generating response without file_search. Reason: ${disableFileSearch ? 'disabled for page context' : 'no vectorStoreId found'}`);
+        }
+        const payload = {
+            model: process.env.OPENAI_MODEL || 'gpt-5.6-luna',
+            input: message,
+            tools: tools.length > 0 ? tools : undefined,
+            previous_response_id: latestResponseId,
+            instructions: systemPrompt,
+            stream: true
+        };
+        // No retry on chat generation for immediate offline fallback
+        const response = await fetch('https://api.openai.com/v1/responses', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'OpenAI-Beta': 'assistants=v2'
+            },
+            body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+            const errBody = await response.text();
+            let isPrevResponseError = false;
+            let isVectorStoreError = false;
+            try {
+                const errObj = JSON.parse(errBody);
+                if (errObj?.error?.code === 'previous_response_not_found' ||
+                    errObj?.error?.message?.includes('previous_response_id')) {
+                    isPrevResponseError = true;
+                }
+                const errMsg = errObj?.error?.message || '';
+                if (errMsg.includes('Vector store') && (errMsg.includes('not found') || errMsg.includes('missing') || errMsg.includes('vs_'))) {
+                    isVectorStoreError = true;
+                }
+            }
+            catch { }
+            if (isVectorStoreError && vectorStoreId) {
+                Logger_1.default.warn('OpenAIService', `Vector store ${vectorStoreId} not found on OpenAI. Clearing vectorStoreId and retrying without file_search.`);
+                const currentMetadata = OpenAIService.readOpenAIMetadata();
+                delete currentMetadata.vectorStoreId;
+                OpenAIService.writeOpenAIMetadata(currentMetadata);
+                return this.generateAnswerStream(localThreadId, message, systemPrompt, onTextChunk, disableFileSearch);
+            }
+            if (isPrevResponseError && latestResponseId) {
+                Logger_1.default.warn('OpenAIService', `Previous response ID ${latestResponseId} expired or not found. Retrying without previous_response_id.`);
+                delete threadMappings[localThreadId];
+                OpenAIService.writeOpenAIMetadata({ threadMappings });
+                return this.generateAnswerStream(localThreadId, message, systemPrompt, onTextChunk, disableFileSearch);
+            }
+            throw new Error(`OpenAI Responses API call failed with status ${response.status}: ${errBody}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body reader is not available');
+        }
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        let fullAnswer = '';
+        let newResponseId = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    if (trimmed.startsWith('data:')) {
+                        const dataStr = trimmed.slice(5).trim();
+                        if (dataStr === '[DONE]')
+                            continue;
+                        try {
+                            const data = JSON.parse(dataStr);
+                            const dataType = data.type;
+                            if (dataType === 'response.failed') {
+                                const errMsg = data.response?.error?.message || '';
+                                const errCode = data.response?.error?.code || '';
+                                if (errMsg.includes('Vector store') || errCode === 'invalid_vector_store_ids') {
+                                    Logger_1.default.warn('OpenAIService', `Vector store was not found or invalid: ${errMsg}. Clearing vectorStoreId.`);
+                                    const currentMetadata = OpenAIService.readOpenAIMetadata();
+                                    delete currentMetadata.vectorStoreId;
+                                    OpenAIService.writeOpenAIMetadata(currentMetadata);
+                                    throw new Error('VECTOR_STORE_NOT_FOUND');
+                                }
+                                throw new Error(`OpenAI response failed: ${errMsg}`);
+                            }
+                            if ((dataType === 'response.created' || dataType === 'response.completed') && data.response?.id) {
+                                newResponseId = data.response.id;
+                            }
+                            if (dataType === 'response.output_text.delta' && data.delta) {
+                                onTextChunk(data.delta);
+                                fullAnswer += data.delta;
+                            }
+                        }
+                        catch (e) {
+                            if (e instanceof Error && (e.message === 'VECTOR_STORE_NOT_FOUND' || e.message.startsWith('OpenAI response failed:'))) {
+                                throw e;
+                            }
+                            // Ignore other parsing errors for partial/non-JSON data lines
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err.message === 'VECTOR_STORE_NOT_FOUND') {
+                Logger_1.default.info('OpenAIService', 'Retrying OpenAI Responses completion without invalid vector store ID...');
+                return this.generateAnswerStream(localThreadId, message, systemPrompt, onTextChunk, disableFileSearch);
+            }
+            throw err;
+        }
+        if (newResponseId) {
+            threadMappings[localThreadId] = newResponseId;
+            OpenAIService.writeOpenAIMetadata({ threadMappings });
+        }
+        return fullAnswer;
+    }
+}
+exports.OpenAIService = OpenAIService;

package/dist/utils/Events.js

@@ -21,7 +21,7 @@ class NextMinEvents extends events_1.EventEmitter {
      * Typed emit to provide better DX (Developer Experience)
      */
     emitEvent(event, payload) {
-        Logger_1.default.info('NextMinEvents', `Emitting event: ${event}`);
+        Logger_1.default.debug('NextMinEvents', `Emitting event: ${event}`);
         this.emit(event, payload);
     }
 }

package/dist/utils/Logger.d.ts

@@ -1,8 +1,9 @@
 export declare class Logger {
-    private isDevelopment;
+    private get isDevelopment();
     constructor();
     private getCallerInfo;
     private formatMessage;
+    debug(label: string, ...messages: any[]): void;
     log(label: string, ...messages: any[]): void;
     info(label: string, ...messages: any[]): void;
     warn(label: string, ...messages: any[]): void;

package/dist/utils/Logger.js

@@ -8,9 +8,11 @@ const kleur_1 = __importDefault(require("kleur"));
 const util_1 = require("util");
 const path_1 = __importDefault(require("path"));
 class Logger {
-    constructor() {
-        this.isDevelopment = process.env.APP_MODE !== 'production' && process.env.NODE_ENV !== 'production';
+    get isDevelopment() {
+        return (process.env.APP_MODE?.toLowerCase() !== 'production' &&
+            process.env.NODE_ENV?.toLowerCase() !== 'production');
     }
+    constructor() { }
     getCallerInfo() {
         const originalPrepareStackTrace = Error.prepareStackTrace;
         Error.prepareStackTrace = (err, stack) => stack;
@@ -45,12 +47,21 @@ class Logger {
             case 'ERROR':
                 formattedLabel = kleur_1.default.red(`[ERROR] ${label} (${callerInfo}):`);
                 break;
+            case 'DEBUG':
+                formattedLabel = kleur_1.default.magenta(`[DEBUG] ${label} (${callerInfo}):`);
+                break;
             default:
                 formattedLabel = `[${level}] ${label} (${callerInfo}):`;
         }
         const formattedMessage = (0, util_1.format)(...messages);
         return `${formattedLabel} ${formattedMessage}`;
     }
+    debug(label, ...messages) {
+        if (this.isDevelopment) {
+            const formatted = this.formatMessage('DEBUG', label, messages);
+            console.debug(formatted);
+        }
+    }
     log(label, ...messages) {
         if (this.isDevelopment) {
             const formatted = this.formatMessage('LOG', label, messages);
@@ -70,10 +81,8 @@ class Logger {
         }
     }
     error(label, ...messages) {
-        if (this.isDevelopment) {
-            const formatted = this.formatMessage('ERROR', label, messages);
-            console.error(formatted);
-        }
+        const formatted = this.formatMessage('ERROR', label, messages);
+        console.error(formatted);
     }
 }
 exports.Logger = Logger;

package/dist/utils/SchemaLoader.d.ts

@@ -17,7 +17,7 @@ export declare class SchemaLoader {
     schemas: {
         [key: string]: Schema;
     };
-    private isDevelopment;
+    private get isDevelopment();
     private nonOverridableSchemas;
     private userSchemasDir;
     private packageSchemasDir;
@@ -46,7 +46,7 @@ export declare class SchemaLoader {
      *  We only shallow-clone values to avoid leaking references.
      */
     private sanitizeAttributes;
-    closeWatcher(): void;
+    closeWatcher(): Promise<void>;
     private coerceIndexDir;
     /** Build desired single-field indexes per model from schemas.
      *  - respects attribute.index (true|1|-1|'asc'|'desc')