@kody-ade/kody-engine 0.4.595 → 0.4.597

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.595",
+      version: "0.4.597",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -4180,7 +4180,6 @@ async function runAgent(opts) {
     env.ANTHROPIC_BASE_URL = opts.litellmUrl;
     env.ANTHROPIC_API_KEY = getAnthropicApiKeyOrDummy();
   }
-  if (opts.stopOnRateLimit) env.CLAUDE_CODE_MAX_RETRIES = "0";
   const startedAt = Date.now();
   const turnTimeoutMs = resolveTurnTimeoutMs(opts);
   const completionGuard = typeof opts.deadlineAtMs === "number" ? createCompletionToolGuard(
@@ -4229,7 +4228,7 @@ async function runAgent(opts) {
     }
     try {
       const queryOptions = {
-        model: opts.litellmUrl ? litellmModelGroup(opts.model) : opts.model.model,
+        model: opts.litellmUrl ? opts.litellmModelGroupOverride ?? litellmModelGroup(opts.model) : opts.model.model,
         cwd: opts.cwd,
         // Fresh array (never mutate the shared DEFAULT_ALLOWED_TOOLS const) so
         // opt-in tools like fetch_repo can be appended below.
@@ -7851,6 +7850,43 @@ function generateLitellmConfigYaml(model) {
   ]);
   return ["model_list:", ...modelEntries, "", "litellm_settings:", "  drop_params: true", ""].join("\n");
 }
+function modelEntry(modelName, model) {
+  const apiKeyVar = model.apiKeyEnvVar ?? providerApiKeyEnvVar(model.provider);
+  const litellmProvider = model.litellmProvider ?? model.provider;
+  return [
+    `  - model_name: ${modelName}`,
+    `    litellm_params:`,
+    `      model: ${litellmProvider}/${model.model}`,
+    `      api_key: os.environ/${apiKeyVar}`,
+    ...model.baseURL ? [`      api_base: ${model.baseURL}`] : []
+  ];
+}
+function generateAutomaticLitellmConfigYaml(models) {
+  if (models.length < 2) throw new Error("Automatic LiteLLM requires at least two models");
+  const groups = models.map((_, index) => `kody-automatic-${index}`);
+  const entries = models.flatMap((model, index) => modelEntry(groups[index], model));
+  for (const alias of CLAUDE_CODE_PROXY_MODEL_ALIASES) entries.push(...modelEntry(alias, models[0]));
+  const fallbackSources = [groups[0], ...CLAUDE_CODE_PROXY_MODEL_ALIASES, ...groups.slice(1, -1)];
+  const fallbacks = fallbackSources.map((source) => {
+    const sourceIndex = source.startsWith("kody-automatic-") ? Number(source.slice("kody-automatic-".length)) : 0;
+    return `    - ${source}: [${groups.slice(sourceIndex + 1).join(", ")}]`;
+  });
+  return [
+    "model_list:",
+    ...entries,
+    "",
+    "litellm_settings:",
+    "  drop_params: true",
+    "",
+    "router_settings:",
+    "  num_retries: 0",
+    "  allowed_fails: 0",
+    "  disable_cooldowns: true",
+    "  fallbacks:",
+    ...fallbacks,
+    ""
+  ].join("\n");
+}
 function litellmModelGroups(model) {
   const primary = litellmModelGroup(model);
   return Array.from(/* @__PURE__ */ new Set([primary, ...CLAUDE_CODE_PROXY_MODEL_ALIASES]));
@@ -7923,9 +7959,29 @@ function resolveLitellmCommand() {
 }
 async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL, runtimeEnvironment = {}) {
   if (!needsLitellmProxy(model)) return null;
+  return startLitellmProxy({
+    projectDir,
+    url,
+    runtimeEnvironment,
+    configYaml: generateLitellmConfigYaml(model),
+    requiredModelGroups: litellmModelGroups(model)
+  });
+}
+async function startAutomaticLitellm(models, projectDir, runtimeEnvironment = {}, url = LITELLM_DEFAULT_URL) {
+  const handle = await startLitellmProxy({
+    projectDir,
+    url,
+    runtimeEnvironment,
+    configYaml: generateAutomaticLitellmConfigYaml(models),
+    requiredModelGroups: [AUTOMATIC_LITELLM_MODEL_GROUP, ...CLAUDE_CODE_PROXY_MODEL_ALIASES]
+  });
+  return { ...handle, modelGroup: AUTOMATIC_LITELLM_MODEL_GROUP };
+}
+async function startLitellmProxy(input) {
+  const { projectDir, runtimeEnvironment } = input;
   const cmd = resolveLitellmCommand();
-  let activeUrl = url.replace(/\/+$/, "");
-  const modelGroups = litellmModelGroups(model);
+  let activeUrl = input.url.replace(/\/+$/, "");
+  const modelGroups = input.requiredModelGroups;
   const childEnv = stripBlockingEnv({
     ...process.env,
     ...readDotenvApiKeys(projectDir),
@@ -7937,7 +7993,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
     const portMatch = activeUrl.match(/:(\d+)/);
     const port = portMatch ? portMatch[1] : "4000";
     const configPath = path27.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
-    fs28.writeFileSync(configPath, generateLitellmConfigYaml(model));
+    fs28.writeFileSync(configPath, input.configYaml);
     const args = ["--config", configPath, "--port", port];
     const nextLogPath = path27.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
     const outFd = fs28.openSync(nextLogPath, "w");
@@ -8063,7 +8119,7 @@ function stripBlockingEnv(env) {
   delete out.AI_BASE_URL;
   return out;
 }
-var LITELLM_PIP_PACKAGES, DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC, LITELLM_HEALTH_POLL_INTERVAL_MS, CLAUDE_CODE_PROXY_MODEL_ALIASES;
+var LITELLM_PIP_PACKAGES, DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC, LITELLM_HEALTH_POLL_INTERVAL_MS, CLAUDE_CODE_PROXY_MODEL_ALIASES, AUTOMATIC_LITELLM_MODEL_GROUP;
 var init_litellm = __esm({
   "src/litellm.ts"() {
     "use strict";
@@ -8072,6 +8128,7 @@ var init_litellm = __esm({
     DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC = 150;
     LITELLM_HEALTH_POLL_INTERVAL_MS = 2e3;
     CLAUDE_CODE_PROXY_MODEL_ALIASES = ["claude-haiku-4-5-20251001", "haiku"];
+    AUTOMATIC_LITELLM_MODEL_GROUP = "kody-automatic-0";
   }
 });
 
@@ -22455,6 +22512,19 @@ async function runImplementation(profileName, input) {
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
+    if (modelSpec === "automatic") {
+      const automaticEnvironment = {};
+      for (const candidate of modelCandidates) {
+        const resolved2 = await resolveRuntimeModelEnvironment(candidate, ctx);
+        Object.assign(automaticEnvironment, resolved2.environment);
+        for (const warning of resolved2.warnings) process.stderr.write(`\u26A0 ${warning}
+`);
+      }
+      const lm = await startAutomaticLitellm(modelCandidates, input.cwd, automaticEnvironment);
+      activeLiteLLM.add(lm);
+      const result = await invokeModel(modelCandidates[0], lm, automaticEnvironment, lm.modelGroup);
+      return result;
+    }
     let finalResult;
     for (let candidateIndex = 0; candidateIndex < modelCandidates.length; candidateIndex++) {
       const candidate = modelCandidates[candidateIndex];
@@ -22474,7 +22544,24 @@ async function runImplementation(profileName, input) {
       }
       ctx.data.jobModelProvider = candidate.provider;
       ctx.data.jobModelName = candidate.model;
-      const result = await runAgent({
+      const result = await invokeModel(candidate, lm, runtimeModelEnvironment);
+      finalResult = result;
+      const next = modelCandidates[candidateIndex + 1];
+      if (!next || result.outcome !== "failed" || result.outcomeKind !== "rate_limit" || result.safeToReplay !== true) {
+        return result;
+      }
+      process.stderr.write(
+        `[kody agent] ${candidate.spec ?? candidate.model} is rate limited; continuing with ${next.spec ?? next.model}
+`
+      );
+      if (lm) {
+        lm.kill();
+        activeLiteLLM.delete(lm);
+      }
+    }
+    return finalResult;
+    async function invokeModel(candidate, lm, runtimeModelEnvironment, litellmModelGroupOverride) {
+      return runAgent({
         prompt,
         model: candidate,
         cwd: input.cwd,
@@ -22483,6 +22570,7 @@ async function runImplementation(profileName, input) {
           ...runtimeModelEnvironment
         },
         litellmUrl: lm?.url ?? null,
+        litellmModelGroupOverride,
         // On a connection drop mid-run, restart the (possibly crashed) proxy
         // before the agent retries. No-op for direct-Anthropic runs (lm null).
         ensureBackend: lm ? () => lm.ensureHealthy().then(() => void 0) : void 0,
@@ -22492,7 +22580,7 @@ async function runImplementation(profileName, input) {
         verbose: input.verbose,
         quiet: input.quiet,
         abortController: input.abortController,
-        stopOnRateLimit: candidateIndex < modelCandidates.length - 1,
+        stopOnRateLimit: false,
         deadlineAtMs: input.deadlineAtMs,
         ndjsonDir,
         additionalDirectories: agentTaskArtifacts ? [agentTaskArtifacts.absDir] : void 0,
@@ -22542,21 +22630,7 @@ async function runImplementation(profileName, input) {
           schema: ctx.data.capabilityOutputSchema
         } : void 0
       });
-      finalResult = result;
-      const next = modelCandidates[candidateIndex + 1];
-      if (!next || result.outcome !== "failed" || result.outcomeKind !== "rate_limit" || result.safeToReplay !== true) {
-        return result;
-      }
-      process.stderr.write(
-        `[kody agent] ${candidate.spec ?? candidate.model} is rate limited; continuing with ${next.spec ?? next.model}
-`
-      );
-      if (lm) {
-        lm.kill();
-        activeLiteLLM.delete(lm);
-      }
     }
-    return finalResult;
   };
   ctx.data.__invokeAgent = invokeAgent;
   const cc = profile.claudeCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.595",
+  "version": "0.4.597",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
   "license": "MIT",
   "type": "module",