pokt-cli 1.0.8 → 1.0.9

package/dist/chat/mcp-from-text.js

@@ -0,0 +1,364 @@
+/**
+ * Fallback: alguns modelos emitem invocações MCP em blocos ```bash``` em vez de tool_calls.
+ * Extraímos linhas `mcp_* ...` e executamos contra os servidores MCP conectados.
+ */
+import { ui } from '../ui.js';
+import { callMcpTool, getMcpExposedToolNames, getMcpToolParameterKeys } from '../mcp/client.js';
+const BASH_BLOCK_RE = /```(?:bash|sh|shell|zsh|powershell|ps1|cmd)\s*\n([\s\S]*?)```/gi;
+function mcpBashFallbackVerbose() {
+    return process.env.POKT_VERBOSE_MCP === '1' || process.env.POKT_VERBOSE === '1';
+}
+/**
+ * Remove blocos ```bash``` que são só invocações MCP (às vezes `mcp_*` numa linha e JSON na seguinte).
+ */
+export function stripExecutedStyleMcpBashBlocks(content) {
+    const re = new RegExp(BASH_BLOCK_RE.source, BASH_BLOCK_RE.flags);
+    return content.replace(re, (full, body) => {
+        if (!/mcp_[A-Za-z0-9_-]+/i.test(body))
+            return full;
+        const lower = body.toLowerCase();
+        const shellish = /\b(if |then|\bfi\b|\bfor\b|\bdo\b|\bdone\b|\bwhile\b|curl |wget |\bgit\b|\bnpm\b|\bpnpm\b|\bcd |\bexport |\$\{)/.test(lower);
+        if (shellish)
+            return full;
+        const lines = body
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        if (lines.length === 0)
+            return full;
+        const mcpOrJsonLine = (l) => {
+            if (parseMcpShellLine(l) !== null)
+                return true;
+            const t = l.trim();
+            if (t.startsWith('{') && t.endsWith('}'))
+                return true;
+            if (t.startsWith('[') && t.endsWith(']'))
+                return true;
+            return false;
+        };
+        if (lines.every(mcpOrJsonLine))
+            return '\n';
+        return full;
+    });
+}
+function trunc(s, max) {
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, max)}\n\n… (${s.length - max} caracteres omitidos)`;
+}
+/** Uma linha tipo: mcp_Neon_run_sql "SELECT 1" ou mcp_Neon_list_projects */
+export function parseMcpShellLine(line) {
+    const m = line.trim().match(/^(mcp_[A-Za-z0-9_-]+)(?:\s+(.*))?$/);
+    if (!m)
+        return null;
+    return { tool: m[1], args: m[2] ?? '' };
+}
+function extractStringArg(raw) {
+    const t = raw.trim();
+    if (!t)
+        return null;
+    if (t.startsWith('"') && t.endsWith('"') && t.length >= 2) {
+        return t.slice(1, -1).replace(/\\"/g, '"');
+    }
+    if (t.startsWith("'") && t.endsWith("'") && t.length >= 2) {
+        return t.slice(1, -1).replace(/\\'/g, "'");
+    }
+    if (/^\s*(SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE|SHOW)\b/i.test(t)) {
+        return t;
+    }
+    if (/^[a-zA-Z0-9_.-]+$/.test(t))
+        return t;
+    return t;
+}
+/** neonctl / modelo: --project-id "x" --branch-id "y" --sql "SELECT 1" */
+function neonFlagNameToJsonKey(flagRaw) {
+    const f = flagRaw.toLowerCase();
+    if (f === 'project-id')
+        return 'projectId';
+    if (f === 'branch-id')
+        return 'branchId';
+    if (f === 'database-name' || f === 'database')
+        return 'databaseName';
+    return flagRaw.replace(/-([a-z])/gi, (_, c) => c.toUpperCase());
+}
+function readQuotedSegment(s, pos) {
+    const q = s[pos];
+    if (q !== '"' && q !== "'")
+        return null;
+    let j = pos + 1;
+    let buf = '';
+    while (j < s.length) {
+        if (s[j] === '\\' && j + 1 < s.length) {
+            buf += s[j + 1];
+            j += 2;
+            continue;
+        }
+        if (s[j] === q)
+            return { value: buf, next: j + 1 };
+        buf += s[j];
+        j++;
+    }
+    return { value: buf, next: j };
+}
+/**
+ * Extrai flags estilo CLI a partir de uma string (linha bash ou valor errado em `sql`).
+ */
+function parseNeonCtlStyleFlags(argsRaw) {
+    const s = argsRaw.trim();
+    if (!s || !/--[a-zA-Z]/.test(s))
+        return null;
+    const out = {};
+    let i = 0;
+    while (i < s.length) {
+        while (i < s.length && /\s/.test(s[i]))
+            i++;
+        if (i >= s.length)
+            break;
+        if (!s.startsWith('--', i))
+            break;
+        i += 2;
+        const nameStart = i;
+        while (i < s.length && /[a-zA-Z0-9-]/.test(s[i]))
+            i++;
+        const flagRaw = s.slice(nameStart, i);
+        if (!flagRaw)
+            break;
+        while (i < s.length && /\s/.test(s[i]))
+            i++;
+        let value = '';
+        if (i < s.length && s[i] === '=') {
+            i++;
+            while (i < s.length && /\s/.test(s[i]))
+                i++;
+        }
+        if (i >= s.length) {
+            out[neonFlagNameToJsonKey(flagRaw)] = value;
+            break;
+        }
+        const quoted = readQuotedSegment(s, i);
+        if (quoted) {
+            value = quoted.value;
+            i = quoted.next;
+        }
+        else {
+            const us = i;
+            while (i < s.length) {
+                if (/\s/.test(s[i]))
+                    break;
+                if (s.startsWith('--', i))
+                    break;
+                i++;
+            }
+            value = s.slice(us, i);
+        }
+        out[neonFlagNameToJsonKey(flagRaw)] = value;
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+function alignNeonRunSqlArgsToSchema(parsed, schemaKeys) {
+    const keys = new Set(schemaKeys);
+    const out = {};
+    const trySet = (schemaKey, val) => {
+        if (!val || val.trim() === '')
+            return;
+        if (keys.has(schemaKey))
+            out[schemaKey] = val;
+    };
+    trySet('projectId', parsed.projectId);
+    trySet('project_id', parsed.projectId);
+    trySet('branchId', parsed.branchId);
+    trySet('branch_id', parsed.branchId);
+    trySet('sql', parsed.sql);
+    trySet('query', parsed.query);
+    trySet('databaseName', parsed.databaseName);
+    trySet('database', parsed.databaseName);
+    return out;
+}
+function fixRunSqlJsonObject(resolvedTool, jo) {
+    if (!/_run_sql$/i.test(resolvedTool))
+        return null;
+    const sqlField = jo.sql;
+    if (typeof sqlField !== 'string' || !/--(project-id|branch-id)\b/.test(sqlField))
+        return null;
+    const merged = parseNeonCtlStyleFlags(sqlField.trim());
+    if (!merged || !merged.sql?.trim())
+        return null;
+    const schemaKeys = getMcpToolParameterKeys(resolvedTool);
+    const keySet = new Set(schemaKeys);
+    let aligned = alignNeonRunSqlArgsToSchema(merged, schemaKeys);
+    for (const [k, v] of Object.entries(jo)) {
+        if (k === 'sql')
+            continue;
+        if (typeof v === 'string' && v.trim() && keySet.has(k)) {
+            aligned = { ...aligned, [k]: v };
+        }
+    }
+    return Object.keys(aligned).length > 0 ? aligned : null;
+}
+function buildJsonArgsString(resolvedTool, argsRaw) {
+    const t = argsRaw.trim();
+    if (!t)
+        return '{}';
+    try {
+        const j = JSON.parse(t);
+        if (j !== null && typeof j === 'object' && !Array.isArray(j)) {
+            const jo = j;
+            const fixedObj = fixRunSqlJsonObject(resolvedTool, jo);
+            if (fixedObj)
+                return JSON.stringify(fixedObj);
+            return JSON.stringify(j);
+        }
+    }
+    catch {
+        // continua
+    }
+    if (/_run_sql$/i.test(resolvedTool)) {
+        const merged = parseNeonCtlStyleFlags(t);
+        if (merged) {
+            const keys = getMcpToolParameterKeys(resolvedTool);
+            const aligned = alignNeonRunSqlArgsToSchema(merged, keys);
+            if (Object.keys(aligned).length > 0)
+                return JSON.stringify(aligned);
+        }
+    }
+    const keys = getMcpToolParameterKeys(resolvedTool);
+    const unq = extractStringArg(t);
+    if (unq !== null) {
+        if (keys.includes('sql'))
+            return JSON.stringify({ sql: unq });
+        if (keys.includes('query'))
+            return JSON.stringify({ query: unq });
+        if (keys.includes('project_id'))
+            return JSON.stringify({ project_id: unq });
+        if (keys.includes('projectId'))
+            return JSON.stringify({ projectId: unq });
+        if (keys.length === 1)
+            return JSON.stringify({ [keys[0]]: unq });
+    }
+    return '{}';
+}
+function resolveToolName(requested, argsRaw, registered) {
+    if (registered.has(requested))
+        return requested;
+    const underscored = requested.replace(/-/g, '_');
+    if (registered.has(underscored))
+        return underscored;
+    const rl = requested.toLowerCase();
+    for (const n of registered) {
+        if (n.toLowerCase() === rl)
+            return n;
+        if (n.replace(/-/g, '_').toLowerCase() === underscored.toLowerCase())
+            return n;
+    }
+    const arg = extractStringArg(argsRaw);
+    const looksSql = arg !== null && /^\s*(SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE|SHOW)\b/i.test(arg);
+    if (looksSql || /neon.*postgres.*execute|postgres.*execute/i.test(requested)) {
+        const runSqls = [...registered].filter((n) => /_run_sql$/i.test(n));
+        if (runSqls.length === 1)
+            return runSqls[0];
+        if (runSqls.length > 1) {
+            const neon = runSqls.find((n) => /neon/i.test(n));
+            return neon ?? runSqls[0];
+        }
+    }
+    return null;
+}
+function collectInvocationsFromMarkdown(content) {
+    if (getMcpExposedToolNames().length === 0)
+        return [];
+    const out = [];
+    const seen = new Set();
+    let m;
+    const re = new RegExp(BASH_BLOCK_RE.source, BASH_BLOCK_RE.flags);
+    while ((m = re.exec(content)) !== null) {
+        const body = m[1] ?? '';
+        for (const line of body.split('\n')) {
+            const parsed = parseMcpShellLine(line);
+            if (!parsed)
+                continue;
+            const key = `${parsed.tool}|${parsed.args}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(parsed);
+        }
+    }
+    return out;
+}
+export async function runMcpFromBashMarkdown(content, options) {
+    const invocations = collectInvocationsFromMarkdown(content);
+    if (invocations.length === 0) {
+        return { invocationCount: 0, executedCount: 0, augmentedAssistantText: content };
+    }
+    const registered = new Set(getMcpExposedToolNames());
+    const sections = [];
+    let executedCount = 0;
+    const verbose = mcpBashFallbackVerbose();
+    for (const inv of invocations) {
+        const resolved = resolveToolName(inv.tool, inv.args, registered);
+        if (!resolved) {
+            sections.push(`\n### ${inv.tool}\n_Ferramenta não encontrada nos MCPs conectados._`);
+            continue;
+        }
+        const jsonArgs = buildJsonArgsString(resolved, inv.args);
+        if (verbose) {
+            console.log(ui.warn(`\n[MCP · texto/bash] ${resolved}`));
+            console.log(ui.dim(jsonArgs.length > 220 ? `${jsonArgs.slice(0, 220)}…` : jsonArgs));
+        }
+        else {
+            console.log(ui.dim(`[MCP] ${resolved} (fallback bash)`));
+        }
+        const result = await callMcpTool(resolved, jsonArgs);
+        executedCount++;
+        sections.push(`\n### ${resolved}\n\`\`\`text\n${trunc(result, 12000)}\n\`\`\``);
+    }
+    const appendixBody = sections.join('\n');
+    const alreadyHasMcpSection = options?.skipDuplicateAppendix === true &&
+        /\n##\s+Resultados\s+MCP\b/i.test(content);
+    const appendix = alreadyHasMcpSection
+        ? ''
+        : '\n\n---\n## Resultados MCP (fallback bash — Pokt CLI)\n' + appendixBody;
+    return {
+        invocationCount: invocations.length,
+        executedCount,
+        augmentedAssistantText: content + appendix,
+    };
+}
+function lastUserPlainText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'user')
+            continue;
+        const c = m.content;
+        if (typeof c === 'string')
+            return c;
+        if (Array.isArray(c)) {
+            return c
+                .map((part) => typeof part === 'object' && part != null && 'text' in part ? part.text : String(part))
+                .join('');
+        }
+    }
+    return '';
+}
+/**
+ * Quando o modelo devolve vazio e o pedido parece “listar bancos”, executa mcp_*_run_sql uma vez.
+ */
+export async function tryAutoMcpForListDatabases(messages) {
+    const text = lastUserPlainText(messages);
+    if (!/\b(bancos?\s+de\s+dados|banco\s+de\s+dados|listar.*bancos?|quais\s+bancos|databases?\b|postgresql|postgres|neon|\bmcp\b)\b/i.test(text)) {
+        return null;
+    }
+    const runSqls = getMcpExposedToolNames().filter((n) => /_run_sql$/i.test(n));
+    if (runSqls.length === 0)
+        return null;
+    const tool = runSqls.find((n) => /neon/i.test(n)) ?? runSqls[0];
+    const sql = 'SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY 1;';
+    if (mcpBashFallbackVerbose()) {
+        console.log(ui.warn(`\n[MCP · automático] ${tool} — listando bancos (modelo sem resposta útil)`));
+    }
+    else {
+        console.log(ui.dim(`[MCP] ${tool} (automático — listar bancos)`));
+    }
+    const out = await callMcpTool(tool, JSON.stringify({ sql }));
+    return `## Bancos de dados (Postgres)\n\n**Ferramenta:** \`${tool}\`\n\n\`\`\`text\n${trunc(out, 12000)}\n\`\`\`\n\n_A automação do Pokt executou esta consulta porque o pedido parecia listar bancos e o modelo não retornou conteúdo._`;
+}

package/dist/chat/slim-tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reduz o tamanho do array `tools` enviado à API (ex.: Pokt Controller com body limit baixo).
+ * Schemas MCP (Neon etc.) podem ter dezenas de KB por tool.
+ */
+import type { ChatCompletionTool } from 'openai/resources/chat/completions/completions.js';
+export declare function slimToolsForUpstreamPayload(tools: ChatCompletionTool[]): ChatCompletionTool[];

package/dist/chat/slim-tools.js

@@ -0,0 +1,65 @@
+const MAX_FUNCTION_DESCRIPTION_CHARS = 520;
+const MAX_SCHEMA_STRING_CHARS = 480;
+const MAX_TOOL_PARAMETERS_JSON_CHARS = 22_000;
+function deepTruncateStrings(obj, maxLen, depth = 0) {
+    if (depth > 14)
+        return obj;
+    if (typeof obj === 'string') {
+        if (obj.length <= maxLen)
+            return obj;
+        return `${obj.slice(0, Math.max(0, maxLen - 1))}…`;
+    }
+    if (Array.isArray(obj)) {
+        const cap = 80;
+        const arr = obj.length > cap ? obj.slice(0, cap) : obj;
+        return arr.map((x) => deepTruncateStrings(x, maxLen, depth + 1));
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const o = obj;
+        const out = {};
+        for (const k of Object.keys(o)) {
+            out[k] = deepTruncateStrings(o[k], maxLen, depth + 1);
+        }
+        return out;
+    }
+    return obj;
+}
+/** Último recurso: schema aberto (o modelo já vê nomes exatos no system prompt). */
+function fallbackOpenEndedParameters() {
+    return {
+        type: 'object',
+        additionalProperties: true,
+        description: 'JSON com os argumentos da tool MCP (ex.: projectId, branchId, sql).',
+    };
+}
+export function slimToolsForUpstreamPayload(tools) {
+    return tools.map((t) => {
+        if (t.type !== 'function' || !t.function)
+            return t;
+        const fn = t.function;
+        const rawDesc = fn.description ?? '';
+        const description = rawDesc.length <= MAX_FUNCTION_DESCRIPTION_CHARS
+            ? rawDesc
+            : `${rawDesc.slice(0, MAX_FUNCTION_DESCRIPTION_CHARS - 1)}…`;
+        let parameters = fn.parameters;
+        if (parameters && typeof parameters === 'object') {
+            parameters = deepTruncateStrings(parameters, MAX_SCHEMA_STRING_CHARS);
+        }
+        let jsonLen = JSON.stringify(parameters ?? {}).length;
+        if (jsonLen > MAX_TOOL_PARAMETERS_JSON_CHARS) {
+            parameters = deepTruncateStrings(parameters, 220);
+            jsonLen = JSON.stringify(parameters ?? {}).length;
+        }
+        if (jsonLen > MAX_TOOL_PARAMETERS_JSON_CHARS) {
+            parameters = fallbackOpenEndedParameters();
+        }
+        return {
+            type: 'function',
+            function: {
+                name: fn.name,
+                description,
+                parameters,
+            },
+        };
+    });
+}

package/dist/chat/tools.js

@@ -7,6 +7,29 @@ import * as diff from 'diff';
 const execAsync = promisify(exec);
 /** Máximo de linhas de diff exibidas; além disso mostra resumo para não imprimir arquivo inteiro */
 const MAX_DIFF_LINES = 45;
+function isGeneratedNoisePath(relPath) {
+    const base = path.basename(relPath);
+    return /^generated\.(text|json)$/i.test(base);
+}
+function looksLikeMcpJsonDump(s) {
+    const t = s.trim();
+    if (!t)
+        return false;
+    try {
+        const j = JSON.parse(t);
+        if (j !== null && typeof j === 'object' && !Array.isArray(j)) {
+            const o = j;
+            return 'success' in o && 'result' in o;
+        }
+        if (Array.isArray(j) && j.length > 0 && j.every((x) => x && typeof x === 'object')) {
+            return true;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return false;
+}
 function showDiff(filePath, oldContent, newContent) {
     const relativePath = path.relative(process.cwd(), filePath);
     console.log(chalk.blue.bold(`\n📝 Edit ${relativePath}:`));
@@ -170,7 +193,13 @@ export async function executeTool(name, argsStr) {
             const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, args.content, 'utf8');
-            showDiff(filePath, oldContent, args.content);
+            const rel = path.relative(process.cwd(), filePath);
+            if (isGeneratedNoisePath(rel) && looksLikeMcpJsonDump(args.content)) {
+                console.log(chalk.dim(`\n📝 ${rel} (omitido diff — parece resposta MCP/JSON; use tabela no texto do assistente)\n`));
+            }
+            else {
+                showDiff(filePath, oldContent, args.content);
+            }
             return `Successfully wrote to ${args.path}`;
         }
         if (name === 'run_command') {

package/dist/commands/chat.js

@@ -1,4 +1,4 @@
-import { config, getEffectiveActiveModel } from '../config.js';
+import { getEffectiveActiveModel, getOpenAIApiKey, getGrokApiKey, getOpenRouterToken, getGeminiApiKey, getPoktToken } from '../config.js';
 import { startChatLoop } from '../chat/loop.js';
 import { ui } from '../ui.js';
 export const chatCommand = {
@@ -11,16 +11,24 @@ export const chatCommand = {
             console.log(ui.error('No active model selected. Run: pokt models list then pokt models use -p <provider> -i <id>'));
             return;
         }
-        if (activeModel.provider === 'openrouter' && !config.get('openrouterToken')) {
+        if (activeModel.provider === 'openrouter' && !getOpenRouterToken()) {
             console.log(ui.error('OpenRouter token not set. Use: pokt config set-openrouter -v <token>'));
             return;
         }
-        if (activeModel.provider === 'gemini' && !config.get('geminiApiKey')) {
+        if (activeModel.provider === 'openai' && !getOpenAIApiKey()) {
+            console.log(ui.error('OpenAI API key not set. Use: pokt config set-openai -v <key>'));
+            return;
+        }
+        if (activeModel.provider === 'grok' && !getGrokApiKey()) {
+            console.log(ui.error('Grok (xAI) API key not set. Use: pokt config set-grok -v <key>'));
+            return;
+        }
+        if (activeModel.provider === 'gemini' && !getGeminiApiKey()) {
             console.log(ui.error('Gemini API key not set. Use: pokt config set-gemini -v <key>'));
             return;
         }
         if (activeModel.provider === 'controller') {
-            if (!config.get('poktToken')) {
+            if (!getPoktToken()) {
                 console.log(ui.error('Pokt token not set. Generate one at the panel and: pokt config set-pokt-token -v <token>'));
                 return;
             }

package/dist/commands/config.js

@@ -8,7 +8,7 @@ export const configCommand = {
         .positional('action', {
         describe: 'Action to perform',
         type: 'string',
-        choices: ['set-openrouter', 'set-ollama', 'set-ollama-cloud', 'set-gemini', 'set-pokt-token', 'clear-openrouter', 'show']
+        choices: ['set-openai', 'set-grok', 'set-openrouter', 'set-ollama', 'set-ollama-cloud', 'set-gemini', 'set-pokt-token', 'clear-openrouter', 'clear-openai', 'clear-grok', 'show']
     })
         .option('value', {
         describe: 'The value to set',
@@ -18,12 +18,16 @@ export const configCommand = {
     handler: (argv) => {
         const { action, value } = argv;
         if (action === 'show') {
+            const openai = config.get('openaiApiKey');
+            const grok = config.get('grokApiKey');
             const openrouter = config.get('openrouterToken');
             const gemini = config.get('geminiApiKey');
             const ollama = config.get('ollamaBaseUrl');
             const ollamaCloud = config.get('ollamaCloudApiKey');
             const poktToken = config.get('poktToken');
             console.log(chalk.blue('\nCurrent config (tokens masked):'));
+            console.log(ui.dim('  OpenAI API Key:'), openai ? openai.slice(0, 8) + '****' : '(not set)');
+            console.log(ui.dim('  Grok (xAI) API Key:'), grok ? grok.slice(0, 8) + '****' : '(not set)');
             console.log(ui.dim('  OpenRouter Token:'), openrouter ? openrouter.slice(0, 8) + '****' : '(not set)');
             console.log(ui.dim('  Gemini API Key:'), gemini ? gemini.slice(0, 8) + '****' : '(not set)');
             console.log(ui.dim('  Ollama Base URL (local):'), ollama || '(not set)');
@@ -38,7 +42,17 @@ export const configCommand = {
             console.log(ui.success('OpenRouter token cleared.'));
             return;
         }
-        if (action !== 'set-openrouter' && action !== 'set-ollama' && action !== 'set-ollama-cloud' && action !== 'set-gemini' && action !== 'set-pokt-token')
+        if (action === 'clear-openai') {
+            config.set('openaiApiKey', '');
+            console.log(ui.success('OpenAI API key cleared.'));
+            return;
+        }
+        if (action === 'clear-grok') {
+            config.set('grokApiKey', '');
+            console.log(ui.success('Grok (xAI) API key cleared.'));
+            return;
+        }
+        if (action !== 'set-openai' && action !== 'set-grok' && action !== 'set-openrouter' && action !== 'set-ollama' && action !== 'set-ollama-cloud' && action !== 'set-gemini' && action !== 'set-pokt-token')
             return;
         const raw = Array.isArray(value) ? value[0] : value;
         const strValue = typeof raw === 'string' ? raw : (raw != null ? String(raw) : '');
@@ -46,7 +60,15 @@ export const configCommand = {
             console.log(ui.error('Error: --value is required. Use: pokt config ' + action + ' -v <value>'));
             return;
         }
-        if (action === 'set-openrouter') {
+        if (action === 'set-openai') {
+            config.set('openaiApiKey', strValue);
+            console.log(ui.success('OpenAI API key saved successfully.'));
+        }
+        else if (action === 'set-grok') {
+            config.set('grokApiKey', strValue);
+            console.log(ui.success('Grok (xAI) API key saved successfully.'));
+        }
+        else if (action === 'set-openrouter') {
             config.set('openrouterToken', strValue);
             console.log(ui.success('OpenRouter token saved successfully.'));
         }

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import type * as Yargs from 'yargs';
+export declare const doctorCommand: Yargs.CommandModule;

package/dist/commands/doctor.js

@@ -0,0 +1,82 @@
+import ora from 'ora';
+import { ui } from '../ui.js';
+import { PROVIDER_LABELS, getEffectiveActiveModel, getOpenAIApiKey, getGrokApiKey, getOpenRouterToken, getGeminiApiKey, getOllamaBaseUrl, getOllamaCloudApiKey, getPoktToken, } from '../config.js';
+import { getClient } from '../chat/client.js';
+function mask(value) {
+    if (!value)
+        return '(not set)';
+    if (value.length <= 8)
+        return '****';
+    return value.slice(0, 4) + '****' + value.slice(-2);
+}
+async function checkModelsEndpoint(client) {
+    // OpenAI SDK chama GET /models; funciona na maioria dos OpenAI-compat.
+    const res = await client.models.list();
+    const data = Array.isArray(res?.data) ? res.data : [];
+    return data.length;
+}
+async function checkOllamaTags() {
+    const baseUrl = getOllamaBaseUrl().replace(/\/$/, '');
+    const url = `${baseUrl}/api/tags`;
+    const r = await fetch(url);
+    if (!r.ok)
+        throw new Error(`HTTP ${r.status}`);
+    const data = await r.json();
+    return Array.isArray(data?.models) ? data.models.length : 0;
+}
+export const doctorCommand = {
+    command: 'doctor',
+    describe: 'Diagnosticar credenciais e conectividade do provider/model atual',
+    handler: async () => {
+        const active = getEffectiveActiveModel();
+        if (!active) {
+            console.log(ui.error('Nenhum modelo ativo. Rode: pokt models list'));
+            return;
+        }
+        const label = PROVIDER_LABELS[active.provider] ?? active.provider;
+        console.log(ui.dim(`\nProvider ativo: ${label}`));
+        console.log(ui.dim(`Model ativo: ${active.id}\n`));
+        // 1) checar credenciais (env ou conf)
+        const required = {
+            controller: { name: 'POKT_TOKEN', value: getPoktToken(), hint: 'pokt config set-pokt-token -v <token>' },
+            openai: { name: 'OPENAI_API_KEY', value: getOpenAIApiKey(), hint: 'pokt config set-openai -v <key>' },
+            grok: { name: 'XAI_API_KEY', value: getGrokApiKey(), hint: 'pokt config set-grok -v <key>' },
+            openrouter: { name: 'OPENROUTER_API_KEY', value: getOpenRouterToken(), hint: 'pokt config set-openrouter -v <token>' },
+            gemini: { name: 'GEMINI_API_KEY', value: getGeminiApiKey(), hint: 'pokt config set-gemini -v <key>' },
+            'ollama-cloud': { name: 'OLLAMA_CLOUD_API_KEY', value: getOllamaCloudApiKey(), hint: 'pokt config set-ollama-cloud -v <key>' },
+            ollama: null,
+        };
+        const req = required[active.provider] ?? null;
+        if (req) {
+            if (!req.value) {
+                console.log(ui.error(`Faltando credencial: ${req.name}`));
+                if (req.hint)
+                    console.log(ui.dim(`Dica: ${req.hint}`));
+                return;
+            }
+            console.log(ui.success(`Credencial OK: ${req.name} = ${mask(req.value)}`));
+        }
+        else if (active.provider === 'ollama') {
+            console.log(ui.success(`Ollama (local) não precisa de chave. Base URL: ${getOllamaBaseUrl()}`));
+        }
+        // 2) checar conectividade
+        const spinner = ora('Testando conexão...').start();
+        try {
+            if (active.provider === 'ollama') {
+                const count = await checkOllamaTags();
+                spinner.succeed(ui.success(`Conexão OK (Ollama). Modelos encontrados: ${count}`));
+                return;
+            }
+            const client = await getClient(active);
+            const count = await checkModelsEndpoint(client);
+            spinner.succeed(ui.success(`Conexão OK (${label}). /models retornou ${count} modelos.`));
+        }
+        catch (e) {
+            spinner.fail(ui.error(`Falha ao testar conexão: ${e?.message ?? String(e)}`));
+            console.log(ui.warn('Sugestões:'));
+            console.log(ui.dim('- Verifique sua chave/token'));
+            console.log(ui.dim('- Verifique sua rede/proxy/firewall'));
+            console.log(ui.dim('- Rode: pokt config show'));
+        }
+    }
+};

package/dist/commands/mcp.d.ts

@@ -6,6 +6,8 @@ interface McpArgs {
     command?: string;
     args?: string;
     url?: string;
+    oauth?: boolean;
+    transport?: string;
 }
 export declare const mcpCommand: Yargs.CommandModule<{}, McpArgs>;
 export {};