@iaforged/context-code 1.2.12 → 1.3.6

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

@@ -0,0 +1,69 @@
+export function persistCoreModelForActiveProvider(runtime, model) {
+    try {
+        const provider = runtime.toProviderPreference(runtime.getCurrentApiProvider());
+        if (runtime.isProfiledProvider(provider)) {
+            runtime.setProviderProfileLastModel(provider, model);
+        }
+        runtime.setStoredLastModelForProvider(provider, model);
+    }
+    catch {
+        // Model persistence failures should not block /model UX.
+    }
+}
+export function isCoreKnownAlias(runtime, model) {
+    return runtime.modelAliases.includes(model.toLowerCase().trim());
+}
+export function isCoreOpus1mUnavailable(runtime, model) {
+    const m = model.toLowerCase();
+    return (!runtime.checkOpus1mAccess() &&
+        !runtime.isOpus1mMergeEnabled() &&
+        m.includes('opus') &&
+        m.includes('[1m]'));
+}
+export function isCoreSonnet1mUnavailable(runtime, model) {
+    const m = model.toLowerCase();
+    return (!runtime.checkSonnet1mAccess() &&
+        (m.includes('sonnet[1m]') || m.includes('sonnet-4-6[1m]')));
+}
+export async function validateCoreModelSelection(runtime, model) {
+    if (!model) {
+        return { ok: true, model: null };
+    }
+    if (!runtime.isModelAllowed(model)) {
+        return {
+            ok: false,
+            error: `El modelo '${model}' no está disponible. ` +
+                'Tu organización restringe la selección de modelos.',
+        };
+    }
+    if (isCoreOpus1mUnavailable(runtime, model)) {
+        return {
+            ok: false,
+            error: 'Opus 4.6 con 1M de contexto no está disponible para tu cuenta. ' +
+                'Más información en: https://code.claude.com/docs/en/model-config#extended-context-with-1m',
+        };
+    }
+    if (isCoreSonnet1mUnavailable(runtime, model)) {
+        return {
+            ok: false,
+            error: 'Sonnet 4.6 con 1M de contexto no está disponible para tu cuenta. ' +
+                'Más información en: https://code.claude.com/docs/en/model-config#extended-context-with-1m',
+        };
+    }
+    if (isCoreKnownAlias(runtime, model)) {
+        return { ok: true, model };
+    }
+    try {
+        const { valid, error } = await runtime.validateModel(model);
+        if (!valid) {
+            return { ok: false, error: error || `Modelo '${model}' no encontrado` };
+        }
+        return { ok: true, model };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `Error al validar el modelo: ${err.message}`,
+        };
+    }
+}

package/dist/src/core/providers/modelCore.smoke.js

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import { isCoreKnownAlias, isCoreOpus1mUnavailable, isCoreSonnet1mUnavailable, persistCoreModelForActiveProvider, validateCoreModelSelection, } from './modelCore.js';
+const state = {
+    provider: 'openai',
+    model: null,
+};
+const runtime = {
+    modelAliases: ['sonnet', 'opus'],
+    getCurrentApiProvider: () => state.provider,
+    toProviderPreference: (provider) => provider,
+    isProfiledProvider: () => true,
+    setProviderProfileLastModel: (_provider, model) => {
+        state.model = model;
+    },
+    setStoredLastModelForProvider: (_provider, model) => {
+        state.model = model;
+    },
+    isModelAllowed: (model) => model !== 'forbidden',
+    checkOpus1mAccess: () => false,
+    isOpus1mMergeEnabled: () => false,
+    checkSonnet1mAccess: () => false,
+    validateModel: async (model) => ({ valid: model === 'gpt-4.1' }),
+};
+async function runModelCoreSmoke() {
+    assert.equal(isCoreKnownAlias(runtime, '  SONNET  '), true);
+    assert.equal(isCoreOpus1mUnavailable(runtime, 'opus[1m]'), true);
+    assert.equal(isCoreSonnet1mUnavailable(runtime, 'sonnet-4-6[1m]'), true);
+    persistCoreModelForActiveProvider(runtime, 'gpt-4.1');
+    assert.equal(state.model, 'gpt-4.1');
+    const ok = await validateCoreModelSelection(runtime, 'gpt-4.1');
+    assert.equal(ok.ok, true);
+    const forbidden = await validateCoreModelSelection(runtime, 'forbidden');
+    assert.equal(forbidden.ok, false);
+}
+const isDirectRun = process.argv[1]?.endsWith('modelCore.smoke.js');
+if (isDirectRun) {
+    await runModelCoreSmoke();
+    console.log('model core smoke: ok');
+}
+export { runModelCoreSmoke };

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

@@ -0,0 +1 @@
+export * from './legacy/modelIndexCliAdapter.impl.js';

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

@@ -0,0 +1,3 @@
+export function getModelCommandDescriptionCore(mainLoopModel, renderModelName) {
+    return `Establece el modelo de IA para Context Code (actualmente ${renderModelName(mainLoopModel)})`;
+}

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

@@ -0,0 +1 @@
+export * from './legacy/policyCliAdapter.impl.js';

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

@@ -0,0 +1,62 @@
+import { DEFAULT_SCORING_WEIGHTS, parseArguments, parseSelectionPolicy } from './policyCliAdapter.js';
+const MODES = ['manual', 'score', 'score-with-fallback', 'fallback-only'];
+const GOALS = ['balanced', 'cost', 'latency', 'quality', 'capability', 'resilience'];
+export function buildPolicyUsageCore() {
+    return [
+        'Uso:',
+        '/policy',
+        '/policy list',
+        '/policy show <mode[:goal]>',
+        '',
+        'Modos:',
+        ...MODES.map(mode => `- ${mode}`),
+        '',
+        'Objetivos:',
+        ...GOALS.map(goal => `- ${goal}`),
+        '',
+        'Ejemplo:',
+        '/policy show score-with-fallback:quality',
+    ].join('\n');
+}
+export function listPoliciesCore() {
+    return [
+        'Politicas disponibles:',
+        ...MODES.flatMap(mode => GOALS.map(goal => `- ${mode}:${goal}`)),
+        '',
+        'Uso operativo:',
+        '/run optimize <run-id> score-with-fallback:quality',
+        '/run assign <run-id> score:capability',
+        '/run fallback <run-id> <task-id> score-with-fallback:resilience',
+    ].join('\n');
+}
+export function showPolicyCore(policyRef) {
+    const policy = parseSelectionPolicy(policyRef);
+    const weights = DEFAULT_SCORING_WEIGHTS[policy.optimizationGoal];
+    return [
+        `Policy: ${policy.id}`,
+        `Nombre: ${policy.name}`,
+        `Modo: ${policy.mode}`,
+        `Objetivo: ${policy.optimizationGoal}`,
+        `Cross-provider fallback: ${policy.allowCrossProviderFallback ? 'si' : 'no'}`,
+        `Fallback depth: ${policy.maxFallbackDepth}`,
+        'Pesos:',
+        `- capability=${weights.capability}`,
+        `- quality=${weights.quality}`,
+        `- cost=${weights.cost}`,
+        `- latency=${weights.latency}`,
+        `- availability=${weights.availability}`,
+        `- resilience=${weights.resilience}`,
+    ].join('\n');
+}
+export function resolvePolicyResponseCore(args) {
+    const tokens = parseArguments(args.trim());
+    const subcommand = tokens[0]?.toLowerCase() ?? 'list';
+    switch (subcommand) {
+        case 'list':
+            return listPoliciesCore();
+        case 'show':
+            return tokens[1] ? showPolicyCore(tokens[1]) : buildPolicyUsageCore();
+        default:
+            return buildPolicyUsageCore();
+    }
+}

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

@@ -0,0 +1 @@
+export * from './legacy/profileCliAdapter.impl.js';

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

@@ -0,0 +1,169 @@
+function tokens(args) {
+    return args?.trim().split(/\s+/).filter(Boolean) ?? [];
+}
+export function parseCoreCreateArgs(runtime, args) {
+    const t = tokens(args);
+    if (t[0]?.toLowerCase() !== 'create')
+        return null;
+    const provider = runtime.normalizeProviderInput(t[1]);
+    if (!provider || !runtime.isProfiledProvider(provider))
+        return null;
+    const profileName = t.slice(2).join(' ').trim();
+    if (!profileName)
+        return null;
+    return { provider, profileName };
+}
+export function parseCoreUseArgs(runtime, args) {
+    const t = tokens(args);
+    if (t[0]?.toLowerCase() !== 'use')
+        return null;
+    const provider = runtime.normalizeProviderInput(t[1]);
+    if (!provider || !runtime.isProfiledProvider(provider))
+        return null;
+    const profileName = t.slice(2).join(' ').trim();
+    if (!profileName)
+        return null;
+    return { provider, profileName };
+}
+export function parseCoreRenameArgs(runtime, args) {
+    const t = tokens(args);
+    if (t[0]?.toLowerCase() !== 'rename')
+        return null;
+    const provider = runtime.normalizeProviderInput(t[1]);
+    if (!provider || !runtime.isProfiledProvider(provider))
+        return null;
+    const currentName = t[2]?.trim();
+    const nextName = t.slice(3).join(' ').trim();
+    if (!currentName || !nextName)
+        return null;
+    return { provider, currentName, nextName };
+}
+export function parseCoreRemoveArgs(runtime, args) {
+    const t = tokens(args);
+    if (t[0]?.toLowerCase() !== 'remove')
+        return null;
+    const provider = runtime.normalizeProviderInput(t[1]);
+    if (!provider || !runtime.isProfiledProvider(provider))
+        return null;
+    const profileName = t.slice(2).join(' ').trim();
+    if (!profileName)
+        return null;
+    return { provider, profileName };
+}
+export function parseCoreModelArgs(runtime, args) {
+    const t = tokens(args);
+    if (t[0]?.toLowerCase() !== 'model')
+        return null;
+    const provider = runtime.normalizeProviderInput(t[1]);
+    if (!provider || !runtime.isProfiledProvider(provider))
+        return null;
+    const profileName = t[2]?.trim();
+    const rawModel = t.slice(3).join(' ').trim();
+    if (!profileName || !rawModel)
+        return null;
+    const model = ['clear', 'default', 'reset', 'none'].includes(rawModel.toLowerCase())
+        ? null
+        : rawModel;
+    return { provider, profileName, model };
+}
+export function parseCoreAgentArgs(runtime, args) {
+    const t = tokens(args);
+    if (t[0]?.toLowerCase() !== 'agent')
+        return null;
+    const provider = runtime.normalizeProviderInput(t[1]);
+    if (!provider || !runtime.isProfiledProvider(provider))
+        return null;
+    const profileName = t[2]?.trim();
+    const agentName = t.slice(3).join(' ').trim();
+    if (!profileName || !agentName)
+        return null;
+    return { provider, profileName, agentName };
+}
+export function isCoreRemoveAllArgs(args) {
+    const t = tokens(args);
+    return t[0]?.toLowerCase() === 'remove' && t[1]?.toLowerCase() === 'all' && t.length === 2;
+}
+export function isCoreMigrateArgs(args) {
+    const normalized = args?.trim().toLowerCase() ?? '';
+    return (normalized === 'migrate' ||
+        normalized === 'migrar' ||
+        normalized === 'finalize-migration' ||
+        normalized === 'finalizar-migracion');
+}
+export function buildCoreProfileListMessage(runtime) {
+    const providers = [
+        'claude',
+        'openai',
+        'openrouter',
+        'ollama',
+        'ollama-cloud',
+        'gemini-api',
+        'gemini-google',
+        'zai',
+        'minimax',
+    ];
+    const lines = [];
+    const active = runtime.getActiveProviderProfile();
+    lines.push(active
+        ? `Perfil activo: ${active.provider}/${active.name} (${active.agentName})`
+        : 'Perfil activo: ninguno');
+    for (const provider of providers) {
+        const profiles = runtime.listProviderProfiles(provider);
+        lines.push('');
+        lines.push(`${runtime.getProviderLabel(provider)}:`);
+        if (profiles.length === 0) {
+            lines.push('- sin perfiles guardados');
+            continue;
+        }
+        const last = runtime.getLastUsedProviderProfile(provider);
+        for (const profile of profiles) {
+            const flags = [
+                active?.id === profile.id ? 'active' : null,
+                last?.id === profile.id ? 'last' : null,
+            ].filter(Boolean);
+            const suffix = flags.length > 0 ? ` [${flags.join(', ')}]` : '';
+            const details = [
+                `agent=${profile.agentName}`,
+                profile.baseUrl ? `url=${profile.baseUrl}` : null,
+                profile.lastModel ? `model=${profile.lastModel}` : null,
+            ]
+                .filter(Boolean)
+                .join(' | ');
+            lines.push(`- ${profile.provider}/${profile.name}${suffix}${details ? ` -> ${details}` : ''}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function buildCoreCurrentProfileMessage(runtime) {
+    const profile = runtime.getActiveProviderProfile();
+    if (!profile)
+        return 'No hay perfil activo.';
+    return [
+        `Proveedor: ${runtime.getProviderLabel(profile.provider)}`,
+        `Perfil: ${profile.name}`,
+        `AgentName: ${profile.agentName}`,
+        profile.baseUrl ? `Base URL: ${profile.baseUrl}` : null,
+        profile.lastModel ? `Ultimo modelo: ${profile.lastModel}` : null,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+export async function validateCoreProfileModelForProvider(runtime, provider, model) {
+    if (!model || provider === 'claude')
+        return { valid: true };
+    const options = await runtime.fetchProviderModels(provider);
+    if (options.length === 0) {
+        return {
+            valid: true,
+            warning: `No se pudo validar el catálogo de ${runtime.getProviderLabel(provider)}. El modelo se guardó sin validación remota.`,
+        };
+    }
+    const needle = model.toLowerCase();
+    const match = options.some((o) => o.value.toLowerCase() === needle || o.label.toLowerCase() === needle);
+    if (match)
+        return { valid: true };
+    return {
+        valid: false,
+        error: `El modelo '${model}' no pertenece al catálogo actual de ${runtime.getProviderLabel(provider)}.`,
+    };
+}

package/dist/src/core/providers/profileCore.smoke.js

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import { buildCoreCurrentProfileMessage, buildCoreProfileListMessage, isCoreMigrateArgs, isCoreRemoveAllArgs, parseCoreCreateArgs, parseCoreModelArgs, parseCoreRenameArgs, parseCoreUseArgs, validateCoreProfileModelForProvider, } from './profileCore.js';
+const profiles = [
+    { id: '1', provider: 'openai', name: 'work', agentName: 'openai-work', lastModel: 'gpt-4.1' },
+];
+const runtime = {
+    normalizeProviderInput: (raw) => raw?.toLowerCase(),
+    isProfiledProvider: () => true,
+    getProviderLabel: () => 'OpenAI',
+    listProviderProfiles: () => profiles,
+    getProviderProfile: () => profiles[0],
+    getActiveProviderProfile: () => profiles[0],
+    getLastUsedProviderProfile: () => profiles[0],
+    findProviderProfileByName: () => profiles[0],
+    createProviderProfile: ({ provider, name }) => ({ id: '2', provider, name, agentName: `${provider}-${name}` }),
+    renameProviderProfile: () => null,
+    removeProviderProfile: () => null,
+    setProviderProfileLastModelByName: () => null,
+    setProviderProfileAgentNameByName: () => null,
+    fetchProviderModels: async () => [{ value: 'gpt-4.1', label: 'GPT-4.1' }],
+};
+async function runProfileCoreSmoke() {
+    assert.deepEqual(parseCoreUseArgs(runtime, 'use openai work'), {
+        provider: 'openai',
+        profileName: 'work',
+    });
+    assert.deepEqual(parseCoreCreateArgs(runtime, 'create openai team'), {
+        provider: 'openai',
+        profileName: 'team',
+    });
+    assert.deepEqual(parseCoreRenameArgs(runtime, 'rename openai old new'), {
+        provider: 'openai',
+        currentName: 'old',
+        nextName: 'new',
+    });
+    assert.deepEqual(parseCoreModelArgs(runtime, 'model openai work clear'), {
+        provider: 'openai',
+        profileName: 'work',
+        model: null,
+    });
+    assert.equal(isCoreRemoveAllArgs('remove all'), true);
+    assert.equal(isCoreMigrateArgs('migrate'), true);
+    assert.match(buildCoreProfileListMessage(runtime), /Perfil activo:/);
+    assert.match(buildCoreCurrentProfileMessage(runtime), /Proveedor:/);
+    const valid = await validateCoreProfileModelForProvider(runtime, 'openai', 'gpt-4.1');
+    assert.equal(valid.valid, true);
+}
+const isDirectRun = process.argv[1]?.endsWith('profileCore.smoke.js');
+if (isDirectRun) {
+    await runProfileCoreSmoke();
+    console.log('profile core smoke: ok');
+}
+export { runProfileCoreSmoke };

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

@@ -0,0 +1,10 @@
+import { getAPIProvider, isGeminiApiProviderConfigured, isGeminiGoogleProviderConfigured, isMiniMaxProviderConfigured, isNvidiaProviderConfigured, isOllamaCloudProviderConfigured, isOpenAIProviderConfigured, isOpenRouterProviderConfigured, isZAIProviderConfigured, } from './legacy/utils/model/providers.js';
+import { clearProviderBaseUrl, getConfiguredProviderBaseUrl, getDefaultProviderBaseUrl, isProviderBaseUrlCustomized, setProviderBaseUrl, } from './legacy/utils/model/providerBaseUrls.js';
+import { getVisibleProvider, VISIBLE_PROVIDERS, } from './legacy/utils/model/providerCatalog.js';
+import { getActiveProviderProfile, getLastUsedProviderProfile, isProfiledProvider, listProviderProfiles, setActiveProfileForProvider, } from './legacy/utils/model/providerProfiles.js';
+import { switchProviderPreference } from './legacy/utils/model/providerSwitch.js';
+import { getStoredActiveProviderPreference } from './legacy/utils/model/providerProfilesDb.js';
+import { getStoredProviderOAuthTokens, hasStoredProviderApiKey, hasStoredProviderOAuthTokens, } from './legacy/utils/auth.js';
+import { useMainLoopModel } from './legacy/hooks/useMainLoopModel.js';
+import { useSetAppState } from './legacy/state/AppState.js';
+export { getAPIProvider, isGeminiApiProviderConfigured, isGeminiGoogleProviderConfigured, isMiniMaxProviderConfigured, isNvidiaProviderConfigured, isOllamaCloudProviderConfigured, isOpenAIProviderConfigured, isOpenRouterProviderConfigured, isZAIProviderConfigured, clearProviderBaseUrl, getConfiguredProviderBaseUrl, getDefaultProviderBaseUrl, isProviderBaseUrlCustomized, setProviderBaseUrl, getVisibleProvider, VISIBLE_PROVIDERS, getActiveProviderProfile, getLastUsedProviderProfile, isProfiledProvider, listProviderProfiles, setActiveProfileForProvider, switchProviderPreference, getStoredActiveProviderPreference, getStoredProviderOAuthTokens, hasStoredProviderApiKey, hasStoredProviderOAuthTokens, useMainLoopModel, useSetAppState, };

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

@@ -0,0 +1,129 @@
+import { getCoreProviderLabel, isCoreProviderEnabled, isCoreSelectedProfileReady, normalizeCoreProviderInput, switchCoreProvider, } from './providerCore.js';
+const CONFIGURABLE_BASE_URL_PROVIDERS = [
+    'openrouter',
+    'ollama',
+    'ollama-cloud',
+    'gemini-api',
+    'gemini-google',
+    'zai',
+    'minimax',
+    'nvidia',
+];
+export function isConfigurableBaseUrlProvider(provider) {
+    return CONFIGURABLE_BASE_URL_PROVIDERS.includes(provider);
+}
+export function normalizeProviderInput(rawProvider) {
+    if (isCoreProviderEnabled()) {
+        return 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 getProviderLabel(provider, getVisibleLabel) {
+    if (isCoreProviderEnabled()) {
+        return getCoreProviderLabel(provider);
+    }
+    return getVisibleLabel(provider);
+}
+export function isUrlLike(str) {
+    const s = str.toLowerCase();
+    if (s.startsWith('http://') || s.startsWith('https://') || s.startsWith('localhost')) {
+        return true;
+    }
+    return /\.[a-z]{2,}/i.test(s) || /:\d+/.test(s) || /^(\d{1,3}\.){3}\d{1,3}/.test(s);
+}
+export function parseBaseUrlUpdate(provider, args) {
+    if (!args || !isConfigurableBaseUrlProvider(provider)) {
+        return {};
+    }
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length < 2 || tokens[1]?.toLowerCase() === 'profile') {
+        return {};
+    }
+    const keyword = tokens[1]?.toLowerCase();
+    const hasKeyword = ['set', 'set-url', 'base-url', 'baseurl', 'url', 'endpoint'].includes(keyword);
+    const rawValue = (hasKeyword ? tokens.slice(2) : tokens.slice(1)).join(' ').trim();
+    if (!rawValue)
+        return {};
+    if (['clear', 'reset', 'default', 'restore'].includes(rawValue.toLowerCase())) {
+        return { clear: true };
+    }
+    if (!hasKeyword && !isUrlLike(rawValue)) {
+        return {};
+    }
+    return { baseUrl: rawValue };
+}
+export function parseProfileSelection(provider, args, isProfiled) {
+    if (!args || !isProfiled(provider))
+        return null;
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length < 2)
+        return null;
+    if (tokens[1]?.toLowerCase() === 'profile') {
+        const profileName = tokens.slice(2).join(' ').trim();
+        return profileName || null;
+    }
+    const secondToken = tokens[1];
+    const isUrlKeyword = ['set', 'set-url', 'base-url', 'baseurl', 'url', 'endpoint', 'clear', 'reset', 'default', 'restore'].includes(secondToken.toLowerCase());
+    if (!isUrlKeyword && !isUrlLike(secondToken)) {
+        return secondToken;
+    }
+    return null;
+}
+export function isSelectedProfileReady(provider, profileName, isProfiled, hasOAuth, hasApiKey, getLastProfile, isGeminiGoogleConfigured) {
+    if (isCoreProviderEnabled()) {
+        return isCoreSelectedProfileReady(provider, profileName);
+    }
+    if (!profileName || !isProfiled(provider))
+        return true;
+    const profile = getLastProfile(provider);
+    if (!profile)
+        return false;
+    if (provider === 'claude' || provider === 'openai')
+        return hasOAuth(provider, profile.id);
+    if (provider === 'openrouter' || provider === 'gemini-api' || provider === 'zai' || provider === 'minimax' || provider === 'nvidia') {
+        return hasApiKey(provider, profile.id);
+    }
+    if (provider === 'gemini-google')
+        return isGeminiGoogleConfigured();
+    return true;
+}
+export function switchProviderViaCoreOrLegacy(input) {
+    if (isCoreProviderEnabled()) {
+        return switchCoreProvider({
+            currentModel: input.currentModel,
+            currentProvider: input.currentProvider,
+            targetProvider: input.target,
+            targetProfileName: input.targetProfileName,
+        }).restoredModel;
+    }
+    return input.switchLegacy({
+        currentModel: input.currentModel,
+        currentProvider: input.currentProvider,
+        targetProvider: input.target,
+        targetProfileName: input.targetProfileName,
+    });
+}

package/dist/src/core/providers/providerCommandCore.smoke.js

@@ -0,0 +1,6 @@
+import assert from 'node:assert/strict';
+import { normalizeProviderInput, parseBaseUrlUpdate, parseProfileSelection, } from './providerCommandCore.js';
+assert.equal(normalizeProviderInput('z.ai'), 'zai');
+assert.deepEqual(parseBaseUrlUpdate('openrouter', 'openrouter https://x.test'), { baseUrl: 'https://x.test' });
+assert.equal(parseProfileSelection('openai', 'openai profile work', () => true), 'work');
+console.log('providers.providerCommandCore.smoke PASS');

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

@@ -0,0 +1 @@
+export * from './legacy/rateLimitOptionsCliAdapter.impl.js';

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

@@ -0,0 +1 @@
+export * from './legacy/btwCliAdapter.impl.js';

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

@@ -0,0 +1,43 @@
+export function stripInProgressAssistantMessageCore(messages) {
+    const last = messages.at(-1);
+    if (last?.type === 'assistant' && last.message.stop_reason === null) {
+        return messages.slice(0, -1);
+    }
+    return messages;
+}
+export async function buildBtwCacheSafeParamsCore(input) {
+    const { context, deps } = input;
+    const forkContextMessages = deps.getMessagesAfterCompactBoundary(stripInProgressAssistantMessageCore(context.messages));
+    const saved = deps.getLastCacheSafeParams();
+    if (saved) {
+        return {
+            systemPrompt: saved.systemPrompt,
+            userContext: saved.userContext,
+            systemContext: saved.systemContext,
+            toolUseContext: context,
+            forkContextMessages,
+        };
+    }
+    const [rawSystemPrompt, userContext, systemContext] = await Promise.all([
+        deps.getRawSystemPrompt(),
+        deps.getUserContext(),
+        deps.getSystemContext(),
+    ]);
+    return {
+        systemPrompt: deps.asSystemPrompt(rawSystemPrompt),
+        userContext,
+        systemContext,
+        toolUseContext: context,
+        forkContextMessages,
+    };
+}
+export async function executeBtwSideQuestionCore(input) {
+    const cacheSafeParams = await buildBtwCacheSafeParamsCore({
+        context: input.context,
+        deps: input.deps,
+    });
+    return input.deps.runSideQuestion({
+        question: input.question,
+        cacheSafeParams,
+    });
+}

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

@@ -0,0 +1 @@
+export * from './legacy/cliAdapter.impl.js';

package/dist/src/core/query/legacy/btwCliAdapter.impl.js

@@ -0,0 +1,37 @@
+import { getSystemPrompt } from '../../../constants/prompts.js';
+import { getSystemContext, getUserContext } from '../../../context.js';
+import { useModalOrTerminalSize } from './context/modalContext.js';
+import { useTerminalSize } from './hooks/useTerminalSize.js';
+import { createAbortController } from './utils/abortController.js';
+import { saveGlobalConfig } from './utils/config.js';
+import { errorMessage } from './utils/errors.js';
+import { getLastCacheSafeParams } from './utils/forkedAgent.js';
+import { getMessagesAfterCompactBoundary } from './utils/messages.js';
+import { runSideQuestion } from './utils/sideQuestion.js';
+import { asSystemPrompt } from './utils/systemPromptType.js';
+export function createBtwDepsCli(context) {
+    return {
+        getLastCacheSafeParams,
+        getMessagesAfterCompactBoundary,
+        getRawSystemPrompt: () => getSystemPrompt(context.options.tools, context.options.mainLoopModel, [], context.options.mcpClients),
+        getUserContext,
+        getSystemContext,
+        asSystemPrompt,
+        runSideQuestion,
+    };
+}
+export function bumpBtwUseCountCli() {
+    saveGlobalConfig(current => ({
+        ...current,
+        btwUseCount: current.btwUseCount + 1,
+    }));
+}
+export function useBtwViewportRowsCli() {
+    return useModalOrTerminalSize(useTerminalSize()).rows;
+}
+export function createBtwAbortControllerCli() {
+    return createAbortController();
+}
+export function toBtwErrorMessageCli(error) {
+    return errorMessage(error) || 'Failed to get response';
+}