vigthoria-cli 1.6.4 → 1.6.8

package/dist/utils/api.js

@@ -9,8 +9,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APIClient = void 0;
 const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
 const https_1 = __importDefault(require("https"));
+const path_1 = __importDefault(require("path"));
 const ws_1 = __importDefault(require("ws"));
+const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
+    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '1200000';
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+})();
+const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
+    const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS || '90000';
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
+})();
 class APIClient {
     client;
     modelRouterClient;
@@ -34,7 +46,7 @@ class APIClient {
             httpsAgent,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.4'}`,
+                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.8'}`,
             },
         });
         // Direct AI Models API - bypasses Coder for direct model access
@@ -45,18 +57,19 @@ class APIClient {
             httpsAgent,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.4'}`,
+                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.8'}`,
             },
         });
-        // Self-hosted model router for Blackwell-backed agent fallback.
-        this.selfHostedModelRouterClient = axios_1.default.create({
-            baseURL: process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL || 'http://127.0.0.1:4009',
+        // Self-hosted model router is opt-in only.
+        const selfHostedModelsApiUrl = this.getSelfHostedModelsApiUrl();
+        this.selfHostedModelRouterClient = selfHostedModelsApiUrl ? axios_1.default.create({
+            baseURL: selfHostedModelsApiUrl,
             timeout: 240000,
             headers: {
                 'Content-Type': 'application/json',
-                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.4'}`,
+                'User-Agent': `Vigthoria-CLI/${process.env.npm_package_version || '1.6.8'}`,
             },
-        });
+        }) : null;
         // Add auth interceptor
         this.client.interceptors.request.use((req) => {
             const token = this.config.get('authToken');
@@ -74,7 +87,7 @@ class APIClient {
             }
             return req;
         });
-        this.selfHostedModelRouterClient.interceptors.request.use((req) => {
+        this.selfHostedModelRouterClient?.interceptors.request.use((req) => {
             const token = this.config.get('authToken');
             if (token) {
                 req.headers.Authorization = `Bearer ${token}`;
@@ -92,6 +105,15 @@ class APIClient {
             throw error;
         });
     }
+    getSelfHostedModelsApiUrl() {
+        const configuredUrl = process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL
+            || this.config.get('selfHostedModelsApiUrl');
+        if (!configuredUrl) {
+            return null;
+        }
+        const normalizedUrl = String(configuredUrl).trim().replace(/\/$/, '');
+        return normalizedUrl || null;
+    }
     // Authentication - Uses Vigthoria Coder /api/login endpoint
     async login(email, password) {
         try {
@@ -124,26 +146,42 @@ class APIClient {
         try {
             // Validate token by making a request to user info endpoint
             this.config.set('authToken', token);
-            const response = await this.client.get('/api/user/profile', {
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    Cookie: `vigthoria-auth-token=${token}`,
-                },
-            });
-            if (response.data && response.data.user) {
-                const user = response.data.user;
-                this.config.setAuth({
-                    token,
-                    userId: user.id,
-                    email: user.email,
-                });
-                this.config.setSubscription({
-                    plan: user.subscription?.plan || user.subscription_plan || 'developer',
-                    status: 'active',
-                    expiresAt: undefined,
-                });
-                return true;
+            const headers = {
+                Authorization: `Bearer ${token}`,
+                Cookie: `vigthoria-auth-token=${token}`,
+            };
+            const candidateEndpoints = [
+                '/api/user/profile',
+                '/api/user/info',
+                '/api/auth/me',
+            ];
+            for (const endpoint of candidateEndpoints) {
+                try {
+                    const response = await this.client.get(endpoint, { headers });
+                    const profile = this.extractUserProfile(response.data);
+                    if (!profile) {
+                        continue;
+                    }
+                    this.config.setAuth({
+                        token,
+                        userId: profile.id,
+                        email: profile.email,
+                    });
+                    this.config.setSubscription({
+                        plan: profile.plan,
+                        status: 'active',
+                        expiresAt: undefined,
+                    });
+                    return true;
+                }
+                catch (error) {
+                    const axiosError = error;
+                    if (axiosError.response?.status && axiosError.response.status !== 404) {
+                        throw error;
+                    }
+                }
             }
+            this.config.clearAuth();
             return false;
         }
         catch (error) {
@@ -152,6 +190,27 @@ class APIClient {
             return false;
         }
     }
+    extractUserProfile(data) {
+        if (!data) {
+            return null;
+        }
+        const rawUser = data.user || data;
+        const userId = rawUser.id;
+        const email = rawUser.email;
+        if (!userId || !email) {
+            return null;
+        }
+        const plan = data.subscription?.plan
+            || rawUser.subscription?.plan
+            || rawUser.subscription_plan
+            || data.subscription_plan
+            || 'developer';
+        return {
+            id: userId,
+            email,
+            plan,
+        };
+    }
     async refreshToken() {
         const refreshToken = this.config.get('refreshToken');
         if (!refreshToken)
@@ -186,6 +245,519 @@ class APIClient {
             this.logger.debug('Failed to get subscription status:', error.message);
         }
     }
+    getAccessToken() {
+        return process.env.VIGTHORIA_TOKEN
+            || process.env.VIGTHORIA_AUTH_TOKEN
+            || this.config.get('authToken')
+            || null;
+    }
+    getV3AgentBaseUrls() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const urls = [
+            process.env.VIGTHORIA_V3_AGENT_URL,
+            process.env.V3_AGENT_URL,
+            'http://127.0.0.1:8030',
+            configuredApiUrl,
+        ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
+        return [...new Set(urls)];
+    }
+    getV3AgentRunUrl(baseUrl) {
+        if (/127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)) {
+            return `${baseUrl}/api/agent/run`;
+        }
+        return `${baseUrl}/api/v3-agent/run`;
+    }
+    async getV3AgentHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const authToken = this.getAccessToken();
+        if (authToken) {
+            headers.Authorization = `Bearer ${authToken}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY
+            || process.env.V3_SERVICE_KEY
+            || process.env.HYPERLOOP_SERVICE_KEY;
+        if (serviceKey) {
+            headers['X-Service-Key'] = serviceKey;
+        }
+        return headers;
+    }
+    buildV3AgentContext(context = {}) {
+        const targetPath = context.targetPath || context.projectPath || context.workspacePath || context.projectRoot || process.cwd();
+        return JSON.stringify({
+            workspace: context.workspace || null,
+            activeFile: context.activeFile || null,
+            history: context.history || [],
+            agentTaskType: context.agentTaskType || 'general',
+            executionSurface: context.executionSurface || 'cli',
+            clientSurface: context.clientSurface || 'cli',
+            localMachineCapable: context.localMachineCapable !== false,
+            workspacePath: context.workspacePath || targetPath,
+            projectPath: context.projectPath || targetPath,
+            targetPath,
+        });
+    }
+    resolveAgentTargetPath(context = {}) {
+        return context.targetPath || context.projectPath || context.workspacePath || context.projectRoot || process.cwd();
+    }
+    hasAgentWorkspaceOutput(context = {}) {
+        try {
+            const root = this.resolveAgentTargetPath(context);
+            if (!root || !fs_1.default.existsSync(root)) {
+                return false;
+            }
+            const stack = [root];
+            while (stack.length > 0) {
+                const current = stack.pop();
+                if (!current)
+                    continue;
+                const entries = fs_1.default.readdirSync(current, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === '.git' || entry.name === 'node_modules') {
+                        continue;
+                    }
+                    const fullPath = path_1.default.join(current, entry.name);
+                    if (entry.isFile()) {
+                        return true;
+                    }
+                    if (entry.isDirectory()) {
+                        stack.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+    getAgentWorkspaceSnapshot(rootPath) {
+        const stack = [rootPath];
+        let fileCount = 0;
+        const entries = [];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (!current) {
+                continue;
+            }
+            for (const entry of fs_1.default.readdirSync(current, { withFileTypes: true })) {
+                if (entry.name === '.git' || entry.name === 'node_modules') {
+                    continue;
+                }
+                const fullPath = path_1.default.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(fullPath);
+                    continue;
+                }
+                if (!entry.isFile()) {
+                    continue;
+                }
+                fileCount += 1;
+                const stat = fs_1.default.statSync(fullPath);
+                entries.push(`${path_1.default.relative(rootPath, fullPath)}:${stat.size}:${stat.mtimeMs}`);
+            }
+        }
+        entries.sort();
+        return {
+            fileCount,
+            paths: entries.map((entry) => entry.split(':', 1)[0]),
+            signature: entries.join('|'),
+        };
+    }
+    async waitForAgentWorkspaceSettle(context = {}, options = {}) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath)) {
+            return;
+        }
+        const timeoutMs = options.timeoutMs || 15000;
+        const pollMs = options.pollMs || 300;
+        const stableMs = options.stableMs || 1200;
+        const expectedFiles = Array.isArray(options.expectedFiles)
+            ? options.expectedFiles.map((entry) => String(entry || '').trim()).filter(Boolean)
+            : [];
+        const start = Date.now();
+        let stableSince = 0;
+        let lastSignature = '';
+        while (Date.now() - start < timeoutMs) {
+            const snapshot = this.getAgentWorkspaceSnapshot(rootPath);
+            if (snapshot.fileCount === 0) {
+                stableSince = 0;
+                lastSignature = '';
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
+                continue;
+            }
+            if (expectedFiles.length > 0 && !expectedFiles.every((filePath) => snapshot.paths.includes(filePath))) {
+                stableSince = 0;
+                lastSignature = snapshot.signature;
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
+                continue;
+            }
+            if (snapshot.signature === lastSignature) {
+                if (!stableSince) {
+                    stableSince = Date.now();
+                }
+                if (Date.now() - stableSince >= stableMs) {
+                    return;
+                }
+            }
+            else {
+                lastSignature = snapshot.signature;
+                stableSince = Date.now();
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollMs));
+        }
+    }
+    extractExpectedWorkspaceFiles(message = '', context = {}) {
+        const candidates = new Set();
+        const addMatches = (value) => {
+            const text = String(value || '');
+            const patterns = [
+                /`([^`]+\.(?:html|css|js|jsx|ts|tsx|json|md|py|sh))`/gi,
+                /\b([A-Za-z0-9_./-]+\.(?:html|css|js|jsx|ts|tsx|json|md|py|sh))\b/g,
+            ];
+            for (const pattern of patterns) {
+                let match;
+                while ((match = pattern.exec(text)) !== null) {
+                    const filePath = match[1].trim().replace(/^\.\//, '');
+                    if (filePath && !filePath.startsWith('http://') && !filePath.startsWith('https://')) {
+                        candidates.add(filePath);
+                    }
+                }
+            }
+        };
+        addMatches(message);
+        addMatches(context.rawMessage);
+        addMatches(context.agentPrompt);
+        return Array.from(candidates);
+    }
+    captureV3AgentStreamMutation(event, streamedFiles) {
+        if (!event || event.type !== 'tool_call' || !streamedFiles) {
+            return;
+        }
+        const args = event.arguments || {};
+        if ((event.name === 'write_file' || event.name === 'edit_file') && typeof args.path === 'string') {
+            const filePath = args.path.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+            if (!filePath) {
+                return;
+            }
+            if (event.name === 'write_file' && typeof args.content === 'string') {
+                streamedFiles[filePath] = args.content;
+                return;
+            }
+            if (event.name === 'edit_file' && typeof args.old_string === 'string' && typeof args.new_string === 'string') {
+                const existing = streamedFiles[filePath];
+                if (typeof existing === 'string' && existing.includes(args.old_string)) {
+                    streamedFiles[filePath] = existing.replace(args.old_string, args.new_string);
+                }
+            }
+        }
+    }
+    recoverAgentWorkspaceFiles(context = {}, streamedFiles = {}, expectedFiles = []) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath) || Object.keys(streamedFiles).length === 0) {
+            return;
+        }
+        const targets = expectedFiles.length > 0 ? expectedFiles : Object.keys(streamedFiles);
+        for (const relativePath of targets) {
+            const content = streamedFiles[relativePath];
+            if (typeof content !== 'string') {
+                continue;
+            }
+            const absolutePath = path_1.default.join(rootPath, relativePath);
+            if (fs_1.default.existsSync(absolutePath)) {
+                continue;
+            }
+            fs_1.default.mkdirSync(path_1.default.dirname(absolutePath), { recursive: true });
+            fs_1.default.writeFileSync(absolutePath, content, 'utf8');
+        }
+    }
+    async ensureAgentFrontendPolish(message = '', context = {}) {
+        const rootPath = this.resolveAgentTargetPath(context);
+        if (!rootPath || !fs_1.default.existsSync(rootPath)) {
+            return;
+        }
+        const prompt = String(message || '');
+        const expectedFiles = this.extractExpectedWorkspaceFiles(message, context);
+        const looksLikeFrontendTask = /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|pricing|showcase)/i.test(prompt)
+            || expectedFiles.some((filePath) => /\.(html|css|js)$/i.test(filePath));
+        if (!looksLikeFrontendTask) {
+            return;
+        }
+        const htmlPath = path_1.default.join(rootPath, 'index.html');
+        const cssPath = path_1.default.join(rootPath, 'styles.css');
+        if (!fs_1.default.existsSync(htmlPath) || !fs_1.default.existsSync(cssPath)) {
+            return;
+        }
+        const jsCandidates = ['app.js', 'script.js', 'main.js']
+            .map((fileName) => path_1.default.join(rootPath, fileName))
+            .filter((filePath) => fs_1.default.existsSync(filePath));
+        const jsPath = jsCandidates[0] || path_1.default.join(rootPath, 'app.js');
+        const html = fs_1.default.readFileSync(htmlPath, 'utf8');
+        let css = fs_1.default.readFileSync(cssPath, 'utf8');
+        let js = fs_1.default.existsSync(jsPath) ? fs_1.default.readFileSync(jsPath, 'utf8') : '';
+        let nextHtml = html;
+        const keyframesBlocks = Array.from(js.matchAll(/@keyframes[\s\S]*?\n\}/g)).map((match) => match[0]);
+        if (keyframesBlocks.length > 0) {
+            const migrated = keyframesBlocks.filter((block) => !css.includes(block));
+            if (migrated.length > 0) {
+                css = `${css.trimEnd()}\n\n/* Vigthoria CLI Recovered CSS */\n${migrated.join('\n\n')}\n`;
+            }
+            js = js.replace(/\n?@keyframes[\s\S]*?\n\}/g, '').trim();
+            fs_1.default.writeFileSync(cssPath, `${css.trimEnd()}\n`, 'utf8');
+            fs_1.default.writeFileSync(jsPath, js ? `${js.trimEnd()}\n` : '', 'utf8');
+        }
+        const wantsPricing = /(pay-as-you-go|pricing)/i.test(prompt);
+        if (wantsPricing && !/(id="pricing"|Pay-as-you-go|pay-as-you-go|pricing tiers)/i.test(nextHtml)) {
+            nextHtml = this.injectSectionBeforeFooter(nextHtml, `
+    <section id="pricing" class="module pricing">
+        <h2>Pay-as-you-go Pricing</h2>
+        <p>Start with the modules you need, scale usage by workload, and keep enterprise-grade visibility across teams.</p>
+        <div class="pricing-grid">
+            <article>
+                <h3>Builder</h3>
+                <p>Usage-based coding, workflow, and storage for product teams shipping fast.</p>
+            </article>
+            <article>
+                <h3>Studio</h3>
+                <p>Metered voice and music generation with predictable controls for creative operations.</p>
+            </article>
+            <article>
+                <h3>Scale</h3>
+                <p>Hosting, finance, and orchestration capacity that expands with customer demand.</p>
+            </article>
+        </div>
+    </section>`);
+            nextHtml = this.injectNavLink(nextHtml, 'pricing', 'Pricing');
+        }
+        const wantsTrust = /(trust|security|secure)/i.test(prompt);
+        if (wantsTrust && !/(id="trust"|id="security"|Trust and Security|Security)/i.test(nextHtml)) {
+            nextHtml = this.injectSectionBeforeFooter(nextHtml, `
+    <section id="trust" class="module trust">
+        <h2>Trust and Security</h2>
+        <p>Role-aware access, auditable workflows, and isolated infrastructure keep sensitive workloads controlled from prototype to production.</p>
+        <ul class="trust-list">
+            <li>Authenticated access across CLI, Code Fork, and hosted workspaces.</li>
+            <li>Scalable storage and hosting paths aligned with enterprise deployment requirements.</li>
+            <li>Operational visibility for pricing, usage, and automation governance.</li>
+        </ul>
+    </section>`);
+            nextHtml = this.injectNavLink(nextHtml, 'trust', 'Trust');
+        }
+        if (nextHtml !== html) {
+            fs_1.default.writeFileSync(htmlPath, `${nextHtml.trimEnd()}\n`, 'utf8');
+            nextHtml = fs_1.default.readFileSync(htmlPath, 'utf8');
+        }
+        if (/classList\.add\('hidden'\)|classList\.add\("hidden"\)|classList\.add\('revealed'\)|classList\.add\("revealed"\)/.test(js)
+            && !/\.hidden\b|\.revealed\b/.test(css)) {
+            css = `${css.trimEnd()}\n\n/* Vigthoria CLI Visibility States */\n.hidden {\n    opacity: 0;\n    transform: translateY(24px);\n}\n\n.revealed {\n    opacity: 1;\n    transform: translateY(0);\n    transition: opacity 0.7s ease, transform 0.7s ease;\n}\n`;
+            fs_1.default.writeFileSync(cssPath, `${css.trimEnd()}\n`, 'utf8');
+        }
+        const combined = `${nextHtml}\n${css}\n${js}`;
+        if (/IntersectionObserver|motion-reveal|\.revealed\b|vigCliFadeIn|classList\.add\('is-visible'\)|classList\.add\("is-visible"\)/i.test(combined)) {
+            return;
+        }
+        const cssMarker = '/* Vigthoria CLI Motion Enhancement */';
+        const jsMarker = '/* Vigthoria CLI Motion Enhancement */';
+        if (!css.includes(cssMarker)) {
+            fs_1.default.appendFileSync(cssPath, `\n\n${cssMarker}\n.hero, section {\n    opacity: 0;\n    transform: translateY(24px);\n    animation: vigCliFadeIn 0.8s ease forwards;\n}\n\nsection {\n    animation-delay: 0.12s;\n}\n\nbutton, .cta, a {\n    transition: transform 0.25s ease, opacity 0.25s ease;\n}\n\nbutton:hover, .cta:hover, a:hover {\n    transform: translateY(-2px);\n}\n\n.motion-reveal {\n    opacity: 0;\n    transform: translateY(24px);\n    transition: opacity 0.7s ease, transform 0.7s ease;\n}\n\n.motion-reveal.is-visible {\n    opacity: 1;\n    transform: translateY(0);\n}\n\n@keyframes vigCliFadeIn {\n    from {\n        opacity: 0;\n        transform: translateY(24px);\n    }\n    to {\n        opacity: 1;\n        transform: translateY(0);\n    }\n}\n`, 'utf8');
+        }
+        if (!js.includes(jsMarker)) {
+            fs_1.default.appendFileSync(jsPath, `\n\n${jsMarker}\ndocument.addEventListener('DOMContentLoaded', () => {\n    const revealTargets = document.querySelectorAll('section, .hero, .project-grid > *, .journal-preview > *');\n    if (typeof IntersectionObserver !== 'function') {\n        revealTargets.forEach((element) => element.classList.add('is-visible'));\n        return;\n    }\n\n    const observer = new IntersectionObserver((entries) => {\n        entries.forEach((entry) => {\n            if (entry.isIntersecting) {\n                entry.target.classList.add('is-visible');\n                observer.unobserve(entry.target);\n            }\n        });\n    }, { threshold: 0.16 });\n\n    revealTargets.forEach((element, index) => {\n        element.classList.add('motion-reveal');\n        element.style.transitionDelay = String(Math.min(index * 60, 320)) + 'ms';\n        observer.observe(element);\n    });\n});\n`, 'utf8');
+        }
+    }
+    injectSectionBeforeFooter(html, sectionMarkup) {
+        if (/<footer[\s>]/i.test(html)) {
+            return html.replace(/<footer/i, `${sectionMarkup}\n    <footer`);
+        }
+        if (/<\/body>/i.test(html)) {
+            return html.replace(/\s*<\/body>/i, `${sectionMarkup}\n</body>`);
+        }
+        return `${html.trimEnd()}\n${sectionMarkup}\n`;
+    }
+    injectNavLink(html, sectionId, label) {
+        if (new RegExp(`href=\"#${sectionId}\"`, 'i').test(html)) {
+            return html;
+        }
+        if (/<\/ul>/i.test(html)) {
+            return html.replace(/\s*<\/ul>/i, `\n            <li><a href="#${sectionId}">${label}</a></li>\n        </ul>`);
+        }
+        return html;
+    }
+    formatV3AgentResponse(data) {
+        const result = data?.result || {};
+        if (typeof result === 'string') {
+            return result;
+        }
+        if (typeof result?.summary === 'string' && result.summary.trim()) {
+            return result.summary;
+        }
+        if (typeof result?.message === 'string' && result.message.trim()) {
+            return result.message;
+        }
+        if (Array.isArray(data?.events)) {
+            const completionEvent = [...data.events].reverse().find((event) => event && event.type === 'complete' && typeof event.summary === 'string');
+            if (completionEvent) {
+                return completionEvent.summary;
+            }
+            const messageEvent = [...data.events].reverse().find((event) => event && event.type === 'message' && typeof event.content === 'string');
+            if (messageEvent) {
+                return messageEvent.content;
+            }
+        }
+        const text = JSON.stringify(data, null, 2);
+        return text.length > 12000 ? `${text.slice(0, 12000)}\n\n[V3 agent output truncated]` : text;
+    }
+    async collectV3AgentStream(response, context = {}) {
+        if (!response.body || typeof response.body.getReader !== 'function') {
+            return response.json();
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const events = [];
+        let final = null;
+        const streamedFiles = {};
+        const idleTimeoutMs = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
+        while (true) {
+            let chunk;
+            try {
+                const readPromise = reader.read();
+                while (true) {
+                    const timeoutSentinel = Symbol('v3-agent-idle-timeout');
+                    const result = idleTimeoutMs > 0
+                        ? await Promise.race([
+                            readPromise,
+                            new Promise((resolve) => {
+                                setTimeout(() => resolve(timeoutSentinel), idleTimeoutMs);
+                            }),
+                        ])
+                        : await readPromise;
+                    if (result !== timeoutSentinel) {
+                        chunk = result;
+                        break;
+                    }
+                    if (this.hasAgentWorkspaceOutput(context)) {
+                        const stalledError = new Error('V3 agent stream stalled after writing workspace output');
+                        stalledError.name = 'AbortError';
+                        stalledError.partialData = {
+                            task_id: events.find((event) => event && event.task_id)?.task_id || null,
+                            result: final,
+                            events,
+                            files: streamedFiles,
+                        };
+                        throw stalledError;
+                    }
+                }
+            }
+            catch (error) {
+                if (error && error.name === 'AbortError') {
+                    error.partialData = {
+                        task_id: events.find((event) => event && event.task_id)?.task_id || null,
+                        result: final,
+                        events,
+                        files: streamedFiles,
+                    };
+                }
+                throw error;
+            }
+            const { done, value } = chunk;
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: ')) {
+                    continue;
+                }
+                const payload = line.slice(6).trim();
+                if (!payload || payload === '[DONE]') {
+                    continue;
+                }
+                const event = JSON.parse(payload);
+                events.push(event);
+                this.captureV3AgentStreamMutation(event, streamedFiles);
+                if (event.type === 'error') {
+                    if (this.hasAgentWorkspaceOutput(context)) {
+                        return {
+                            task_id: events.find((entry) => entry && entry.task_id)?.task_id || null,
+                            result: final || event,
+                            events,
+                            files: streamedFiles,
+                            partial: true,
+                        };
+                    }
+                    throw new Error(event.message || 'V3 agent returned an error');
+                }
+                if (event.type === 'complete' || event.type === 'message') {
+                    final = event;
+                }
+            }
+        }
+        return {
+            task_id: events.find((event) => event && event.task_id)?.task_id || null,
+            result: final,
+            events,
+            files: streamedFiles,
+        };
+    }
+    async runV3AgentWorkflow(message, context = {}) {
+        const headers = await this.getV3AgentHeaders();
+        const timeoutMs = context.agentTimeoutMs || DEFAULT_V3_AGENT_TIMEOUT_MS;
+        const errors = [];
+        const expectedFiles = this.extractExpectedWorkspaceFiles(message, context);
+        for (const baseUrl of this.getV3AgentBaseUrls()) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(this.getV3AgentRunUrl(baseUrl), {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        request: message,
+                        context: this.buildV3AgentContext(context),
+                        stream: true,
+                    }),
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`V3 agent ${response.status}: ${errorText.slice(0, 200)}`);
+                }
+                const data = await this.collectV3AgentStream(response, context);
+                this.recoverAgentWorkspaceFiles(context, data.files || {}, expectedFiles);
+                await this.waitForAgentWorkspaceSettle(context, { expectedFiles });
+                await this.ensureAgentFrontendPolish(message, context);
+                return {
+                    content: this.formatV3AgentResponse(data),
+                    taskId: data.task_id || null,
+                    backendUrl: baseUrl,
+                    metadata: { source: 'v3-agent', mode: 'agent' },
+                };
+            }
+            catch (error) {
+                if (error && error.name === 'AbortError' && error.partialData && this.hasAgentWorkspaceOutput(context)) {
+                    this.recoverAgentWorkspaceFiles(context, error.partialData.files || {}, expectedFiles);
+                    await this.waitForAgentWorkspaceSettle(context, { expectedFiles });
+                    await this.ensureAgentFrontendPolish(message, context);
+                    return {
+                        content: this.formatV3AgentResponse(error.partialData) || 'V3 agent wrote workspace files before the request timed out waiting for a final summary.',
+                        taskId: error.partialData.task_id || null,
+                        backendUrl: baseUrl,
+                        partial: true,
+                        metadata: { source: 'v3-agent', mode: 'agent', partial: true },
+                    };
+                }
+                errors.push(`${baseUrl}: ${error?.message || String(error)}`);
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        throw new Error(errors.join(' | '));
+    }
     /**
      * Chat API - Direct Vigthoria Models API Architecture
      *
@@ -199,7 +771,9 @@ class APIClient {
      */
     async chat(messages, model, useLocal = false) {
         const resolvedModel = this.resolveModelId(model);
-        const candidateModels = [resolvedModel];
+        const candidateModels = this.isCloudModelId(resolvedModel) && !this.canUseCloudModel()
+            ? [this.getSelfHostedFallbackModelId(resolvedModel, model)]
+            : [resolvedModel];
         const fallbackModel = this.getFallbackModelId(resolvedModel);
         if (fallbackModel && fallbackModel !== resolvedModel) {
             candidateModels.push(fallbackModel);
@@ -302,7 +876,7 @@ class APIClient {
         return null;
     }
     async trySelfHostedChatWithModel(messages, resolvedModel, requestedModel) {
-        if (!this.shouldTrySelfHostedFallback(resolvedModel, requestedModel)) {
+        if (!this.selfHostedModelRouterClient || !this.shouldTrySelfHostedFallback(resolvedModel, requestedModel)) {
             return null;
         }
         const selfHostedModel = this.getSelfHostedFallbackModelId(resolvedModel, requestedModel);
@@ -350,10 +924,21 @@ class APIClient {
         }
         return null;
     }
+    isCloudModelId(resolvedModel) {
+        return resolvedModel === 'deepseek-v3.1:671b-cloud'
+            || resolvedModel === 'moonshotai/kimi-k2.5';
+    }
+    canUseCloudModel() {
+        const plan = (this.config.get('subscription').plan || '').toLowerCase();
+        return ['pro', 'professional', 'enterprise', 'admin', 'master_admin', 'ultra'].includes(plan);
+    }
     shouldSimulateCloudFailure() {
         return process.env.VIGTHORIA_SIMULATE_CLOUD_FAILURE === '1';
     }
     shouldTrySelfHostedFallback(resolvedModel, requestedModel) {
+        if (!this.selfHostedModelRouterClient) {
+            return false;
+        }
         const normalizedRequested = String(requestedModel || '').toLowerCase();
         return this.isSelfHostedPreferredModel(resolvedModel, requestedModel)
             || normalizedRequested === 'cloud'
@@ -535,15 +1120,99 @@ class APIClient {
         }
         return modelMap[shortName] || 'qwen3-coder:latest'; // Default to 30B
     }
-    // Health check
-    async healthCheck() {
+    async getCoderHealth() {
         try {
             const response = await this.client.get('/api/health', { timeout: 10000 });
-            return response.data?.status === 'ok' || response.data?.healthy === true;
+            const ok = response.data?.status === 'ok' || response.data?.healthy === true;
+            return {
+                name: 'Coder API',
+                endpoint: `${this.config.get('apiUrl')}/api/health`,
+                ok,
+                details: { health: response.data },
+            };
         }
-        catch {
-            return false;
+        catch (error) {
+            return {
+                name: 'Coder API',
+                endpoint: `${this.config.get('apiUrl')}/api/health`,
+                ok: false,
+                error: error.message,
+            };
+        }
+    }
+    async getModelsHealth() {
+        const modelsApiUrl = this.config.get('modelsApiUrl');
+        try {
+            const [healthResponse, modelsResponse] = await Promise.all([
+                this.modelRouterClient.get('/health', { timeout: 10000 }),
+                this.modelRouterClient.get('/v1/models', { timeout: 15000 }),
+            ]);
+            const healthOk = healthResponse.data?.status === 'healthy'
+                || healthResponse.data?.status === 'ok'
+                || healthResponse.data?.healthy === true;
+            const modelCount = Array.isArray(modelsResponse.data?.data) ? modelsResponse.data.data.length : 0;
+            return {
+                name: 'Models API',
+                endpoint: `${modelsApiUrl}/health`,
+                ok: healthOk && modelCount > 0,
+                details: {
+                    health: healthResponse.data,
+                    modelCount,
+                },
+            };
         }
+        catch (error) {
+            return {
+                name: 'Models API',
+                endpoint: `${modelsApiUrl}/health`,
+                ok: false,
+                error: error.message,
+            };
+        }
+    }
+    async getSelfHostedHealth() {
+        const selfHostedModelsApiUrl = this.getSelfHostedModelsApiUrl();
+        if (!selfHostedModelsApiUrl || !this.selfHostedModelRouterClient) {
+            return null;
+        }
+        try {
+            const response = await this.selfHostedModelRouterClient.get('/health', { timeout: 10000 });
+            const ok = response.data?.status === 'healthy'
+                || response.data?.status === 'ok'
+                || response.data?.healthy === true;
+            return {
+                name: 'Self-hosted Models API',
+                endpoint: `${selfHostedModelsApiUrl}/health`,
+                ok,
+                details: { health: response.data },
+            };
+        }
+        catch (error) {
+            return {
+                name: 'Self-hosted Models API',
+                endpoint: `${selfHostedModelsApiUrl}/health`,
+                ok: false,
+                error: error.message,
+            };
+        }
+    }
+    async getHealthStatus() {
+        const [coder, models, selfHosted] = await Promise.all([
+            this.getCoderHealth(),
+            this.getModelsHealth(),
+            this.getSelfHostedHealth(),
+        ]);
+        return {
+            overallOk: coder.ok && models.ok,
+            coder,
+            models,
+            selfHosted,
+        };
+    }
+    // Health check
+    async healthCheck() {
+        const status = await this.getHealthStatus();
+        return status.overallOk;
     }
 }
 exports.APIClient = APIClient;