@kody-ade/kody-engine-lite 0.1.58 → 0.1.60

package/dist/bin/cli.js

@@ -252,6 +252,17 @@ var init_logger = __esm({
 // src/config.ts
 import * as fs from "fs";
 import * as path from "path";
+function needsLitellmProxy(config) {
+  if (config.agent.litellmUrl) return true;
+  if (config.agent.provider && config.agent.provider !== "anthropic") return true;
+  return false;
+}
+function getLitellmUrl(config) {
+  return config.agent.litellmUrl ?? LITELLM_DEFAULT_URL;
+}
+function providerApiKeyEnvVar(provider) {
+  return `${provider.toUpperCase()}_API_KEY`;
+}
 function setConfigDir(dir) {
   _configDir = dir;
   _config = null;
@@ -279,7 +290,7 @@ function getProjectConfig() {
   }
   return _config;
 }
-var DEFAULT_CONFIG, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
+var DEFAULT_CONFIG, LITELLM_DEFAULT_PORT, LITELLM_DEFAULT_URL, TIER_TO_ANTHROPIC_IDS, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -313,6 +324,13 @@ var init_config = __esm({
         tokenBudget: 8e3
       }
     };
+    LITELLM_DEFAULT_PORT = 4e3;
+    LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
+    TIER_TO_ANTHROPIC_IDS = {
+      cheap: ["claude-haiku-4-5-20251001", "claude-haiku-4-5", "haiku"],
+      mid: ["claude-sonnet-4-6-20250514", "claude-sonnet-4-6", "sonnet"],
+      strong: ["claude-opus-4-6-20250514", "claude-opus-4-6", "opus"]
+    };
     VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
     FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
     _config = null;
@@ -1223,6 +1241,9 @@ function resolveModel(modelTier, stageName) {
   if (config.agent.usePerStageRouting && stageName) {
     return stageName;
   }
+  if (config.agent.provider && config.agent.provider !== "anthropic") {
+    return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
+  }
   const mapped = config.agent.modelMap[modelTier];
   if (mapped) return mapped;
   return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
@@ -1350,8 +1371,8 @@ async function executeAgentStage(ctx, def) {
   const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
   logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
   const extraEnv = {};
-  if (config.agent.litellmUrl) {
-    extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
+  if (needsLitellmProxy(config)) {
+    extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl(config);
   }
   const sessions = ctx.sessions ?? {};
   const sessionInfo = getSessionInfo(def.name, sessions);
@@ -3072,6 +3093,7 @@ var init_args = __esm({
 
 // src/cli/litellm.ts
 import * as fs19 from "fs";
+import * as os from "os";
 import * as path18 from "path";
 import { execFileSync as execFileSync10 } from "child_process";
 async function checkLitellmHealth(url) {
@@ -3082,10 +3104,31 @@ async function checkLitellmHealth(url) {
     return false;
   }
 }
-async function tryStartLitellm(url, projectDir) {
-  const configPath = path18.join(projectDir, "litellm-config.yaml");
-  if (!fs19.existsSync(configPath)) {
-    logger.warn("litellm-config.yaml not found \u2014 cannot start proxy");
+function generateLitellmConfig(provider, modelMap) {
+  const apiKeyVar = providerApiKeyEnvVar(provider);
+  const entries = ["model_list:"];
+  for (const [tier, providerModel] of Object.entries(modelMap)) {
+    const anthropicIds = TIER_TO_ANTHROPIC_IDS[tier];
+    if (!anthropicIds) continue;
+    for (const modelName of anthropicIds) {
+      entries.push(`  - model_name: ${modelName}`);
+      entries.push(`    litellm_params:`);
+      entries.push(`      model: ${provider}/${providerModel}`);
+      entries.push(`      api_key: os.environ/${apiKeyVar}`);
+    }
+  }
+  return entries.join("\n") + "\n";
+}
+async function tryStartLitellm(url, projectDir, generatedConfig) {
+  const manualConfigPath = path18.join(projectDir, "litellm-config.yaml");
+  let configPath;
+  if (fs19.existsSync(manualConfigPath)) {
+    configPath = manualConfigPath;
+  } else if (generatedConfig) {
+    configPath = path18.join(os.tmpdir(), "kody-litellm-config.yaml");
+    fs19.writeFileSync(configPath, generatedConfig);
+  } else {
+    logger.warn("litellm-config.yaml not found and no provider configured \u2014 cannot start proxy");
     return null;
   }
   const portMatch = url.match(/:(\d+)/);
@@ -3155,6 +3198,7 @@ var init_litellm = __esm({
   "src/cli/litellm.ts"() {
     "use strict";
     init_logger();
+    init_config();
   }
 });
 
@@ -3228,6 +3272,38 @@ var init_task_state = __esm({
 var entry_exports = {};
 import * as fs21 from "fs";
 import * as path20 from "path";
+async function ensureLitellmProxy(config, projectDir) {
+  if (!needsLitellmProxy(config)) return null;
+  const litellmUrl = getLitellmUrl(config);
+  const proxyRunning = await checkLitellmHealth(litellmUrl);
+  let litellmProcess = null;
+  if (!proxyRunning) {
+    if (config.agent.provider && config.agent.provider !== "anthropic") {
+      const keyVar = providerApiKeyEnvVar(config.agent.provider);
+      if (!process.env[keyVar]) {
+        logger.error(`Provider '${config.agent.provider}' requires ${keyVar} environment variable`);
+        process.exit(1);
+      }
+    }
+    let generatedConfig;
+    if (config.agent.provider && config.agent.provider !== "anthropic") {
+      generatedConfig = generateLitellmConfig(config.agent.provider, config.agent.modelMap);
+    }
+    litellmProcess = await tryStartLitellm(litellmUrl, projectDir, generatedConfig);
+    if (!litellmProcess) {
+      logger.error("LiteLLM is configured but could not be started. Install it with: pip install 'litellm[proxy]'");
+      process.exit(1);
+    }
+  } else {
+    logger.info(`LiteLLM proxy already running at ${litellmUrl}`);
+  }
+  process.env.ANTHROPIC_BASE_URL = litellmUrl;
+  logger.info(`ANTHROPIC_BASE_URL set to ${litellmUrl}`);
+  if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
+    process.env.ANTHROPIC_API_KEY = "sk-ant-api03-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
+  }
+  return litellmProcess;
+}
 async function main() {
   const input = parseArgs();
   const projectDir = input.cwd ? path20.resolve(input.cwd) : process.cwd();
@@ -3320,21 +3396,7 @@ async function main() {
       }
     }
     const config2 = getProjectConfig();
-    let litellmProcess2 = null;
-    if (config2.agent.litellmUrl) {
-      const proxyRunning = await checkLitellmHealth(config2.agent.litellmUrl);
-      if (!proxyRunning) {
-        litellmProcess2 = await tryStartLitellm(config2.agent.litellmUrl, projectDir);
-        if (!litellmProcess2) {
-          logger.error("LiteLLM is configured (litellmUrl) but could not be started. Install it with: pip install 'litellm[proxy]'");
-          process.exit(1);
-        }
-      }
-      process.env.ANTHROPIC_BASE_URL = config2.agent.litellmUrl;
-      if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
-        process.env.ANTHROPIC_API_KEY = "sk-ant-api03-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
-      }
-    }
+    const litellmProcess2 = await ensureLitellmProxy(config2, projectDir);
     const runners2 = createRunners(config2);
     const defaultRunnerName2 = config2.agent.defaultRunner ?? Object.keys(runners2)[0] ?? "claude";
     const defaultRunner2 = runners2[defaultRunnerName2];
@@ -3424,10 +3486,10 @@ ${input.feedback}` : reviewContext;
     }
   }
   const config = getProjectConfig();
-  let litellmProcess = null;
+  let litellmProcess = await ensureLitellmProxy(config, projectDir);
   const cleanupLitellm = () => {
     if (litellmProcess) {
-      litellmProcess.kill();
+      litellmProcess.kill?.();
       litellmProcess = null;
     }
   };
@@ -3440,23 +3502,6 @@ ${input.feedback}` : reviewContext;
     cleanupLitellm();
     process.exit(143);
   });
-  if (config.agent.litellmUrl) {
-    const proxyRunning = await checkLitellmHealth(config.agent.litellmUrl);
-    if (!proxyRunning) {
-      litellmProcess = await tryStartLitellm(config.agent.litellmUrl, projectDir);
-      if (!litellmProcess) {
-        logger.error("LiteLLM is configured (litellmUrl) but could not be started. Install it with: pip install 'litellm[proxy]'");
-        process.exit(1);
-      }
-    } else {
-      logger.info(`LiteLLM proxy already running at ${config.agent.litellmUrl}`);
-    }
-    process.env.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
-    logger.info(`ANTHROPIC_BASE_URL set to ${config.agent.litellmUrl}`);
-    if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
-      process.env.ANTHROPIC_API_KEY = "sk-ant-api03-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
-    }
-  }
   const runners = createRunners(config);
   const defaultRunnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
   const defaultRunner = runners[defaultRunnerName];
@@ -3548,6 +3593,7 @@ var init_entry = __esm({
     init_litellm();
     init_task_resolution();
     init_task_state();
+    init_config();
     main().catch(async (err) => {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(msg);

package/kody.config.schema.json

@@ -125,9 +125,14 @@
           },
           "additionalProperties": false
         },
+        "provider": {
+          "type": "string",
+          "description": "LLM provider name. When set (and not 'anthropic'), engine auto-starts LiteLLM proxy and routes model calls to this provider. modelMap values should be the provider's model names.",
+          "examples": ["anthropic", "minimax", "openai", "google"]
+        },
         "litellmUrl": {
           "type": "string",
-          "description": "LiteLLM proxy URL for using non-Anthropic models (e.g., 'http://localhost:4000'). Sets ANTHROPIC_BASE_URL for Claude Code.",
+          "description": "(Deprecated) Use 'provider' instead. LiteLLM proxy URL for manual setup.",
           "examples": ["http://localhost:4000"]
         },
         "usePerStageRouting": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.58",
+  "version": "0.1.60",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",