@corbat-tech/coco 2.25.9 → 2.25.10

package/dist/cli/index.js

@@ -121,6 +121,7 @@ function createDefaultConfigObject(projectName, language = "typescript") {
       temperature: 0,
       timeout: 12e4
     },
+    providerModels: {},
     quality: {
       minScore: 85,
       minCoverage: 80,
@@ -300,6 +301,7 @@ var init_schema = __esm({
         temperature: 0,
         timeout: 12e4
       }),
+      providerModels: z.record(z.string(), z.string()).optional(),
       quality: QualityConfigSchema.default({
         minScore: 85,
         minCoverage: 80,
@@ -597,6 +599,7 @@ function deepMergeConfig(base, override) {
     ...override,
     project: { ...base.project, ...override.project },
     provider: { ...base.provider, ...override.provider },
+    providerModels: { ...base.providerModels, ...override.providerModels },
     quality: { ...base.quality, ...override.quality },
     persistence: { ...base.persistence, ...override.persistence },
     // Merge optional sections only if present in either base or override
@@ -2588,6 +2591,10 @@ async function getLastUsedProvider() {
 async function getLastUsedModel(provider) {
   try {
     const config = await loadConfig(CONFIG_PATHS.config);
+    const perProviderModel = normalizeConfiguredModel(config.providerModels?.[provider]);
+    if (perProviderModel) {
+      return perProviderModel;
+    }
     if (config.provider.type === provider) {
       return normalizeConfiguredModel(config.provider.model);
     }
@@ -2627,6 +2634,11 @@ async function saveProviderPreference(provider, model) {
   }
   config.provider.type = provider;
   const normalizedModel = normalizeConfiguredModel(model);
+  const persistedModel = normalizedModel ?? getDefaultModel(provider);
+  config.providerModels = {
+    ...config.providerModels,
+    [provider]: persistedModel
+  };
   if (normalizedModel) {
     config.provider.model = normalizedModel;
   } else {
@@ -2725,11 +2737,25 @@ async function migrateOldPreferences() {
     }
     if (oldPrefs.provider && VALID_PROVIDERS.includes(oldPrefs.provider)) {
       config.provider.type = oldPrefs.provider;
+      config.providerModels = {
+        ...config.providerModels
+      };
+      for (const [providerName, modelName] of Object.entries(oldPrefs.models ?? {})) {
+        if (VALID_PROVIDERS.includes(providerName)) {
+          const normalized = normalizeConfiguredModel(modelName);
+          if (normalized) {
+            config.providerModels[providerName] = normalized;
+          }
+        }
+      }
       const modelForProvider = oldPrefs.provider ? oldPrefs.models?.[oldPrefs.provider] : void 0;
-      if (modelForProvider) {
-        config.provider.model = modelForProvider;
+      const normalizedMigratedModel = normalizeConfiguredModel(modelForProvider);
+      if (normalizedMigratedModel) {
+        config.provider.model = normalizedMigratedModel;
+        config.providerModels[oldPrefs.provider] = normalizedMigratedModel;
       } else {
         config.provider.model = getDefaultModel(oldPrefs.provider);
+        config.providerModels[oldPrefs.provider] = config.provider.model;
       }
       await saveConfig(config, void 0, true);
     }
@@ -34614,8 +34640,9 @@ ${newProvider.emoji} ${newProvider.name} is not configured.`));
       newApiKeyForSaving = key;
     }
   }
+  const rememberedModel = await getLastUsedModel(newProvider.id);
   const recommendedModel = getRecommendedModel(newProvider.id);
-  const newModel = recommendedModel?.id || newProvider.models[0]?.id || "";
+  const newModel = rememberedModel || recommendedModel?.id || newProvider.models[0]?.id || "";
   const spinner18 = p26.spinner();
   spinner18.start(`Connecting to ${newProvider.name}...`);
   try {
@@ -53074,6 +53101,8 @@ async function startRepl(options = {}) {
     );
   }
   let mcpManager = null;
+  let configuredMcpServers = [];
+  const registeredMcpServers = /* @__PURE__ */ new Set();
   const logger2 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
   try {
     const { getMCPServerManager: getMCPServerManager2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
@@ -53090,6 +53119,7 @@ async function startRepl(options = {}) {
       cocoConfigServers.filter((s) => s.enabled !== false),
       projectServers.filter((s) => s.enabled !== false)
     );
+    configuredMcpServers = enabledServers;
     if (enabledServers.length > 0) {
       mcpManager = getMCPServerManager2();
       let connections;
@@ -53109,6 +53139,7 @@ async function startRepl(options = {}) {
       for (const connection of connections.values()) {
         try {
           const wrapped = await registerMCPTools2(toolRegistry, connection.name, connection.client);
+          registeredMcpServers.add(connection.name);
           if (wrapped.length === 0) {
             logger2.warn(
               `[MCP] Server '${connection.name}' connected but exposed 0 tools (check server auth/scopes).`
@@ -53137,6 +53168,42 @@ async function startRepl(options = {}) {
       `[MCP] Initialization failed: ${mcpError instanceof Error ? mcpError.message : String(mcpError)}`
     );
   }
+  async function ensureRequestedMcpConnections(message) {
+    if (!mcpManager || configuredMcpServers.length === 0) return;
+    const normalizedMessage = message.toLowerCase();
+    const explicitlyRequestsMcp = /\bmcp\b/.test(normalizedMessage) || /\b(use|using|usa|usar|utiliza|utilizar)\b.{0,24}\bmcp\b/.test(normalizedMessage);
+    const matchingServers = configuredMcpServers.filter((server) => {
+      if (mcpManager?.getConnection(server.name)) return false;
+      if (explicitlyRequestsMcp) return true;
+      const loweredName = server.name.toLowerCase();
+      if (normalizedMessage.includes(loweredName)) return true;
+      if (loweredName.includes("atlassian")) {
+        return /\b(atlassian|jira|confluence)\b/.test(normalizedMessage);
+      }
+      return false;
+    });
+    for (const server of matchingServers) {
+      try {
+        const connection = await mcpManager.startServer(server);
+        if (!registeredMcpServers.has(connection.name)) {
+          await (await Promise.resolve().then(() => (init_tools(), tools_exports))).registerMCPTools(
+            toolRegistry,
+            connection.name,
+            connection.client
+          );
+          registeredMcpServers.add(connection.name);
+        }
+      } catch (error) {
+        logger2.warn(
+          `[MCP] On-demand connect failed for '${server.name}': ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  function extractMessageText(content) {
+    if (typeof content === "string") return content;
+    return content.filter((block) => block.type === "text").map((block) => block.text).join(" ");
+  }
   let hookRegistry;
   let hookExecutor;
   try {
@@ -53584,6 +53651,7 @@ ${imagePrompts}`.trim() : imagePrompts;
       let streamStarted = false;
       let llmCallCount = 0;
       let lastToolGroup = null;
+      await ensureRequestedMcpConnections(extractMessageText(effectiveMessage));
       const result = await executeAgentTurn(session, effectiveMessage, provider, toolRegistry, {
         onStream: (chunk) => {
           if (!streamStarted) {