@iaforged/context-code 1.2.9 → 1.2.10

package/dist/src/core/providers/cliAdapter.js

@@ -0,0 +1,39 @@
+import { getSecureStorage } from '../../utils/secureStorage/index.js';
+import { getProviderProfile } from '../../utils/model/providerProfiles.js';
+export const cliCredentialProvider = async (provider, profileId) => {
+    const storage = getSecureStorage().read() ?? {};
+    const profile = getProviderProfile(profileId);
+    let result = { kind: 'none', token: null, baseUrl: profile?.baseUrl };
+    // Buscar en API keys de perfil
+    const profileApiKey = storage.providerProfileApiKeys?.[profileId];
+    if (profileApiKey?.trim()) {
+        result = { kind: 'api-key', token: profileApiKey.trim() };
+    }
+    else {
+        // Buscar en OAuth de perfil
+        const profileOauth = storage.providerProfileOauth?.[profileId]?.accessToken;
+        if (profileOauth?.trim()) {
+            result = { kind: 'oauth', token: profileOauth.trim() };
+        }
+        else {
+            // Buscar en API keys de proveedor (fallback)
+            const providerApiKey = storage.providerApiKeys?.[provider];
+            if (providerApiKey?.trim()) {
+                result = { kind: 'api-key', token: providerApiKey.trim() };
+            }
+            else {
+                // Fallback final a variables de entorno
+                const envKey = process.env[`${String(provider).toUpperCase().replace(/-/g, '_')}_API_KEY`];
+                if (envKey?.trim()) {
+                    result = { kind: 'api-key', token: envKey.trim() };
+                }
+            }
+        }
+    }
+    // Debug log (omit token for security)
+    try {
+        fs.appendFileSync('d:/Documents/GitHub/Claude/claude-code_V1/Context_Code_V1/CLI/scratch_auth_log.txt', `[${new Date().toISOString()}] provider=${provider} profileId=${profileId} found=${result.kind !== 'none'}\n`);
+    }
+    catch (e) { }
+    return result;
+};

package/dist/src/core/providers/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/providers/index.js

@@ -0,0 +1,3 @@
+export * from './contracts.js';
+export * from './providerCore.js';
+export * from './providerModelCompatibility.js';

package/dist/src/core/providers/llmCore.js

@@ -0,0 +1,123 @@
+export class CoreLlmClient {
+    credentialProvider;
+    constructor(credentialProvider) {
+        this.credentialProvider = credentialProvider;
+    }
+    async chat(request) {
+        const credential = await this.credentialProvider(request.provider, request.profileId);
+        const baseUrl = credential.baseUrl || this.resolveBaseUrl(request.provider, request.profileId);
+        // Heuristica: si el provider es Claude O el baseUrl contiene 'anthropic', usar protocolo Anthropic
+        const isAnthropicProtocol = request.provider === 'claude' ||
+            baseUrl.toLowerCase().includes('anthropic');
+        if (isAnthropicProtocol) {
+            return this.callAnthropic(request, credential, baseUrl);
+        }
+        return this.callOpenAICompatible(request, credential, baseUrl);
+    }
+    async callOpenAICompatible(request, credential) {
+        const baseUrl = this.resolveBaseUrl(request.provider);
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (credential.token) {
+            headers['Authorization'] = `Bearer ${credential.token}`;
+        }
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                model: request.model,
+                messages: request.messages,
+                tools: request.tools,
+                temperature: request.temperature ?? 0.2
+            })
+        });
+        if (!response.ok) {
+            const err = await response.text();
+            throw new Error(`LLM Error (${response.status}): ${err}`);
+        }
+        const data = await response.json();
+        return {
+            content: data.choices?.[0]?.message?.content ?? null,
+            toolCalls: data.choices?.[0]?.message?.tool_calls?.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                arguments: tc.function.arguments
+            })),
+            usage: {
+                promptTokens: data.usage?.prompt_tokens ?? 0,
+                completionTokens: data.usage?.completion_tokens ?? 0
+            }
+        };
+    }
+    async callAnthropic(request, credential, baseUrl) {
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': credential.token || '',
+        };
+        if (request.provider === 'claude') {
+            headers['anthropic-version'] = '2023-06-01';
+        }
+        const systemMessage = request.messages.find(m => m.role === 'system')?.content;
+        const messages = request.messages.filter(m => m.role !== 'system').map(m => ({
+            role: m.role === 'assistant' ? 'assistant' : 'user',
+            content: m.content
+        }));
+        const body = {
+            model: request.model,
+            max_tokens: request.maxTokens ?? 4096,
+            messages,
+            system: systemMessage,
+            tools: request.tools?.map(t => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.parameters
+            })),
+            temperature: request.temperature ?? 0.2
+        };
+        // Si el baseUrl ya termina en /messages o similar, lo usamos. 
+        // Si no, construimos el endpoint de Anthropic estandar.
+        const endpoint = baseUrl.endsWith('/messages') ? baseUrl : `${baseUrl.replace(/\/+$/, '')}/v1/messages`;
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            const err = await response.text();
+            throw new Error(`Anthropic Error (${response.status}): ${err}`);
+        }
+        const data = await response.json();
+        const content = data.content.find((c) => c.type === 'text')?.text ?? null;
+        const toolCalls = data.content
+            .filter((c) => c.type === 'tool_use')
+            .map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            arguments: JSON.stringify(tc.input)
+        }));
+        return {
+            content,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage: {
+                promptTokens: data.usage?.input_tokens ?? 0,
+                completionTokens: data.usage?.output_tokens ?? 0
+            }
+        };
+    }
+    resolveBaseUrl(provider, profileId) {
+        const storage = this.credentialProvider ? {} : {}; // Placeholder, logic below
+        // Note: We need a way to get the baseUrl from storage without duplicating logic.
+        // For now, we'll assume the credentialProvider can also provide the baseUrl if we extend it.
+        const defaults = {
+            claude: 'https://api.anthropic.com',
+            openai: 'https://api.openai.com/v1',
+            openrouter: 'https://openrouter.ai/api/v1',
+            ollama: 'http://localhost:11434/v1',
+            'gemini-api': 'https://generativelanguage.googleapis.com/v1beta/openai',
+            zai: 'https://api.z.ai/api/coding/paas/v4',
+            minimax: 'https://api.minimax.chat/v1'
+        };
+        return defaults[provider] || defaults.openai;
+    }
+}

package/dist/src/core/providers/providerCore.js

@@ -0,0 +1,141 @@
+import { getVisibleProvider, VISIBLE_PROVIDERS, } from '../../utils/model/providerCatalog.js';
+import { getActiveProviderProfile, getLastUsedProviderProfile, isProfiledProvider, listProviderProfiles, setActiveProfileForProvider, } from '../../utils/model/providerProfiles.js';
+import { switchProviderPreference } from '../../utils/model/providerSwitch.js';
+import { hasStoredProviderApiKey, hasStoredProviderOAuthTokens, } from '../../utils/auth.js';
+export function isCoreProviderEnabled() {
+    return process.env.CORE_PROVIDER_ENABLED === '1';
+}
+export function listCoreProviders() {
+    return VISIBLE_PROVIDERS.map(item => ({
+        id: item.id,
+        label: item.label,
+        implemented: item.implemented,
+    }));
+}
+export function normalizeCoreProviderInput(rawProvider) {
+    if (!rawProvider) {
+        return undefined;
+    }
+    switch (rawProvider.trim().toLowerCase()) {
+        case 'z.ai':
+        case 'z-ai':
+            return 'zai';
+        case 'open-router':
+            return 'openrouter';
+        case 'ollama-cloud':
+        case 'ollama_cloud':
+        case 'ollamacloud':
+            return 'ollama-cloud';
+        case 'gemini':
+        case 'gemini-api-key':
+        case 'google-ai':
+        case 'google-ai-studio':
+            return 'gemini-api';
+        case 'gemini-google':
+        case 'google':
+        case 'google-oauth':
+            return 'gemini-google';
+        default:
+            return rawProvider.trim().toLowerCase();
+    }
+}
+export function getCoreProviderLabel(provider) {
+    return getVisibleProvider(provider).label;
+}
+export function listCoreProviderProfiles() {
+    const allProfiles = listProviderProfiles();
+    const activeProfile = getActiveProviderProfile();
+    const grouped = allProfiles.reduce((acc, profile) => {
+        const provider = profile.provider;
+        if (!acc[provider]) {
+            acc[provider] = [];
+        }
+        acc[provider].push({
+            id: profile.id,
+            name: profile.name,
+            provider,
+            baseUrl: profile.baseUrl,
+            isActive: profile.id === activeProfile?.id,
+            isAuthenticated: isProviderProfileAuthenticated(provider, profile.id),
+        });
+        return acc;
+    }, {});
+    return {
+        activeProfile: activeProfile
+            ? {
+                id: activeProfile.id,
+                name: activeProfile.name,
+                provider: activeProfile.provider,
+                baseUrl: activeProfile.baseUrl,
+            }
+            : null,
+        providers: grouped,
+    };
+}
+export function getCoreCurrentProviderProfile() {
+    const activeProfile = getActiveProviderProfile();
+    if (!activeProfile) {
+        return { activeProfile: null };
+    }
+    return {
+        activeProfile: {
+            id: activeProfile.id,
+            name: activeProfile.name,
+            provider: activeProfile.provider,
+            baseUrl: activeProfile.baseUrl,
+        },
+    };
+}
+export function setCoreActiveProfile(provider, profileName) {
+    if (!isProfiledProvider(provider)) {
+        return;
+    }
+    setActiveProfileForProvider(provider, profileName);
+}
+export function isCoreSelectedProfileReady(provider, profileName) {
+    if (!profileName || !isProfiledProvider(provider)) {
+        return true;
+    }
+    const profile = getLastUsedProviderProfile(provider);
+    if (!profile) {
+        return false;
+    }
+    return isProviderProfileAuthenticated(provider, profile.id);
+}
+export function switchCoreProvider(input) {
+    const restoredModel = switchProviderPreference({
+        currentModel: input.currentModel,
+        currentProvider: input.currentProvider,
+        targetProvider: input.targetProvider,
+        targetProfileName: input.targetProfileName,
+    });
+    const profile = isProfiledProvider(input.targetProvider)
+        ? getLastUsedProviderProfile(input.targetProvider)
+        : null;
+    return {
+        restoredModel,
+        activeProfileName: profile?.name,
+    };
+}
+function isProviderProfileAuthenticated(provider, profileId) {
+    if (provider === 'claude') {
+        return hasStoredProviderOAuthTokens('claude', profileId);
+    }
+    if (provider === 'openai') {
+        return hasStoredProviderOAuthTokens('openai', profileId);
+    }
+    if (provider === 'openrouter' ||
+        provider === 'gemini-api' ||
+        provider === 'zai' ||
+        provider === 'minimax' ||
+        provider === 'nvidia') {
+        return hasStoredProviderApiKey(provider, profileId);
+    }
+    if (provider === 'ollama' || provider === 'ollama-cloud') {
+        return true;
+    }
+    if (provider === 'gemini-google') {
+        return true;
+    }
+    return true;
+}

package/dist/src/core/providers/providerModelCompatibility.js

@@ -0,0 +1,98 @@
+/**
+ * Single-source compatibility samples used by smoke/parity checks.
+ * Keep this in sync with validateProviderModelCompatibility rules.
+ */
+export const PROVIDER_COMPATIBILITY_SAMPLES = {
+    claude: {
+        accepts: ['claude-sonnet-4-5'],
+        rejects: ['gpt-4o'],
+    },
+    openai: {
+        accepts: ['gpt-4.1', 'o3', 'codex-mini-latest'],
+        rejects: ['claude-sonnet-4-5'],
+    },
+    'gemini-api': {
+        accepts: ['gemini-2.5-pro'],
+        rejects: ['gpt-4o'],
+    },
+    'gemini-google': {
+        accepts: ['gemini-2.5-flash'],
+        rejects: ['claude-sonnet-4-5'],
+    },
+    openrouter: {
+        accepts: ['anthropic/claude-sonnet-4'],
+        rejects: [],
+    },
+    ollama: {
+        accepts: ['llama3.1:8b'],
+        rejects: [],
+    },
+    'ollama-cloud': {
+        accepts: ['llama3.3:70b-instruct-q8_0'],
+        rejects: [],
+    },
+    zai: {
+        accepts: ['glm-4.5'],
+        rejects: [],
+    },
+    minimax: {
+        accepts: ['MiniMax-M2.7'],
+        rejects: [],
+    },
+    nvidia: {
+        accepts: ['meta/llama-3.1-70b-instruct'],
+        rejects: [],
+    },
+};
+/**
+ * Canonical, no-network compatibility pre-check shared by CLI/Desktop adapters.
+ * Dynamic catalogs (OpenRouter/Ollama/ZAI/etc.) are treated as compatible when
+ * the model string is non-empty; strict validation is delegated to runtime APIs.
+ */
+export function validateProviderModelCompatibility(provider, model) {
+    const normalizedModel = (model ?? '').trim();
+    if (!normalizedModel) {
+        return {
+            provider,
+            model: '',
+            compatible: false,
+            reason: 'empty-model',
+        };
+    }
+    const m = normalizedModel.toLowerCase();
+    if (provider === 'claude') {
+        return {
+            provider,
+            model: normalizedModel,
+            compatible: m.startsWith('claude-'),
+            reason: 'claude-prefix',
+        };
+    }
+    if (provider === 'openai') {
+        const compatible = m.startsWith('gpt-') ||
+            m.startsWith('o1') ||
+            m.startsWith('o3') ||
+            m.startsWith('o4') ||
+            m.startsWith('codex-');
+        return {
+            provider,
+            model: normalizedModel,
+            compatible,
+            reason: 'openai-family',
+        };
+    }
+    if (provider === 'gemini-api' || provider === 'gemini-google') {
+        return {
+            provider,
+            model: normalizedModel,
+            compatible: m.startsWith('gemini-'),
+            reason: 'gemini-prefix',
+        };
+    }
+    return {
+        provider,
+        model: normalizedModel,
+        compatible: true,
+        reason: 'dynamic-catalog',
+    };
+}

package/dist/src/core/providers/providerParitySmoke.js

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import { VISIBLE_PROVIDERS } from '../../utils/model/providerCatalog.js';
+import { listCoreProviders, normalizeCoreProviderInput, } from './providerCore.js';
+import { PROVIDER_COMPATIBILITY_SAMPLES, validateProviderModelCompatibility, } from './providerModelCompatibility.js';
+function normalizeLegacyProviderInput(rawProvider) {
+    if (!rawProvider) {
+        return undefined;
+    }
+    switch (rawProvider.trim().toLowerCase()) {
+        case 'z.ai':
+        case 'z-ai':
+            return 'zai';
+        case 'open-router':
+            return 'openrouter';
+        case 'ollama-cloud':
+        case 'ollama_cloud':
+        case 'ollamacloud':
+            return 'ollama-cloud';
+        case 'gemini':
+        case 'gemini-api-key':
+        case 'google-ai':
+        case 'google-ai-studio':
+            return 'gemini-api';
+        case 'gemini-google':
+        case 'google':
+        case 'google-oauth':
+            return 'gemini-google';
+        default:
+            return rawProvider.trim().toLowerCase();
+    }
+}
+function runProviderNormalizationParity() {
+    const cases = [
+        { input: 'z.ai', expected: 'zai' },
+        { input: 'open-router', expected: 'openrouter' },
+        { input: 'ollama_cloud', expected: 'ollama-cloud' },
+        { input: 'gemini', expected: 'gemini-api' },
+        { input: 'google', expected: 'gemini-google' },
+        { input: 'CLAUDE', expected: 'claude' },
+        { input: 'OpenAI', expected: 'openai' },
+    ];
+    for (const c of cases) {
+        const core = normalizeCoreProviderInput(c.input);
+        const legacy = normalizeLegacyProviderInput(c.input);
+        assert.equal(core, c.expected);
+        assert.equal(legacy, c.expected);
+        assert.equal(core, legacy);
+    }
+}
+function runProviderCatalogParity() {
+    const coreIds = listCoreProviders().map(p => p.id).sort();
+    const legacyIds = VISIBLE_PROVIDERS.map(p => p.id).sort();
+    assert.deepEqual(coreIds, legacyIds);
+}
+function runCompatibilityChecks() {
+    const coreIds = listCoreProviders().map(p => p.id).sort();
+    const sampleIds = Object.keys(PROVIDER_COMPATIBILITY_SAMPLES).sort();
+    assert.deepEqual(sampleIds, coreIds);
+    for (const provider of coreIds) {
+        const sample = PROVIDER_COMPATIBILITY_SAMPLES[provider];
+        for (const model of sample.accepts) {
+            const result = validateProviderModelCompatibility(provider, model);
+            assert.equal(result.compatible, true);
+        }
+        for (const model of sample.rejects) {
+            const result = validateProviderModelCompatibility(provider, model);
+            assert.equal(result.compatible, false);
+        }
+        const empty = validateProviderModelCompatibility(provider, '');
+        assert.equal(empty.compatible, false);
+        assert.equal(empty.reason, 'empty-model');
+    }
+}
+export function runProviderParitySmoke() {
+    runProviderNormalizationParity();
+    runProviderCatalogParity();
+    runCompatibilityChecks();
+}
+const isDirectRun = process.argv[1]?.endsWith('providerParitySmoke.js');
+if (isDirectRun) {
+    runProviderParitySmoke();
+    console.log('provider parity smoke: ok');
+}

package/dist/src/core/providers/providerProfileModelSmoke.js

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { enableConfigs } from '../../utils/config.js';
+async function runProviderProfileModelSmoke() {
+    const tempConfigDir = mkdtempSync(join(tmpdir(), 'context-core-provider-smoke-'));
+    process.env.CONTEXT_CONFIG_DIR = tempConfigDir;
+    process.env.CORE_PROVIDER_ENABLED = '1';
+    enableConfigs();
+    try {
+        const config = await import('../../utils/config.js');
+        config.enableConfigs();
+        const providerProfiles = await import('../../utils/model/providerProfiles.js');
+        const providerSwitch = await import('../../utils/model/providerSwitch.js');
+        const providerDb = await import('../../utils/model/providerProfilesDb.js');
+        const providerCore = await import('./providerCore.js');
+        providerProfiles.clearAllProviderProfiles();
+        providerProfiles.createProviderProfile({
+            provider: 'claude',
+            name: 'main',
+            agentName: 'claude-main',
+        });
+        providerProfiles.createProviderProfile({
+            provider: 'openai',
+            name: 'work',
+            agentName: 'openai-work',
+        });
+        providerProfiles.setActiveProfileForProvider('openai', 'work');
+        providerProfiles.setProviderProfileLastModelByName('openai', 'work', 'gpt-4.1');
+        const switched = providerCore.switchCoreProvider({
+            currentModel: 'sonnet',
+            currentProvider: 'claude',
+            targetProvider: 'openai',
+            targetProfileName: 'work',
+        });
+        assert.equal(switched.activeProfileName, 'work');
+        assert.equal(switched.restoredModel, 'gpt-4.1');
+        const activeProvider = providerDb.getStoredActiveProviderPreference();
+        assert.equal(activeProvider, 'openai');
+        const normalized = providerCore.normalizeCoreProviderInput('google-oauth');
+        assert.equal(normalized, 'gemini-google');
+        const current = providerCore.getCoreCurrentProviderProfile();
+        assert.equal(current.activeProfile?.provider, 'openai');
+        assert.equal(current.activeProfile?.name, 'work');
+        const list = providerCore.listCoreProviderProfiles();
+        const openaiProfiles = list.providers.openai ?? [];
+        assert.ok(openaiProfiles.some((p) => p.name === 'work'));
+        // Validate compatibility helper remains aligned with provider IDs.
+        const compatibility = await import('./providerModelCompatibility.js');
+        const providerIds = providerCore.listCoreProviders().map((p) => p.id);
+        for (const providerId of providerIds) {
+            const sample = compatibility.PROVIDER_COMPATIBILITY_SAMPLES[providerId];
+            assert.ok(sample);
+            assert.equal(compatibility.validateProviderModelCompatibility(providerId, sample.accepts[0]).compatible, true);
+        }
+        // Legacy route should also restore model for active profiled provider.
+        const restoredLegacy = providerSwitch.switchProviderPreference({
+            currentModel: 'claude-legacy',
+            currentProvider: 'claude',
+            targetProvider: 'openai',
+            targetProfileName: 'work',
+        });
+        assert.equal(restoredLegacy, 'gpt-4.1');
+    }
+    finally {
+        try {
+            rmSync(tempConfigDir, { recursive: true, force: true });
+        }
+        catch {
+            // Windows can keep sqlite handles alive briefly; cleanup is best-effort.
+        }
+    }
+}
+const isDirectRun = process.argv[1]?.endsWith('providerProfileModelSmoke.js');
+if (isDirectRun) {
+    await runProviderProfileModelSmoke();
+    console.log('provider/profile/model smoke: ok');
+}
+export { runProviderProfileModelSmoke };

package/dist/src/core/query/contracts.js

@@ -0,0 +1 @@
+export {};