@kody-ade/kody-engine 0.4.287 → 0.4.288

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.287",
+      version: "0.4.288",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -671,11 +671,51 @@ function parseProviderModel(s) {
   }
   return { provider: s.slice(0, slash), model: s.slice(slash + 1) };
 }
+function optionalRuntimeString(raw, key) {
+  const value = raw[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function parseModelRuntimeConfig(modelSpec, rawConfig) {
+  const fallback = parseProviderModel(modelSpec);
+  const raw = rawConfig?.trim();
+  if (!raw) return fallback;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`KODY_MODEL_CONFIG is invalid JSON: ${msg}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("KODY_MODEL_CONFIG must be a JSON object");
+  }
+  const record2 = parsed;
+  const modelName = optionalRuntimeString(record2, "modelName");
+  if (!modelName) {
+    throw new Error("KODY_MODEL_CONFIG.modelName is required");
+  }
+  const protocol = optionalRuntimeString(record2, "protocol");
+  const baseURL = optionalRuntimeString(record2, "baseURL");
+  const apiKeyEnvVar = optionalRuntimeString(record2, "apiKeyEnvVar");
+  const spec = optionalRuntimeString(record2, "spec");
+  const provider = optionalRuntimeString(record2, "provider") ?? fallback.provider;
+  const out = {
+    provider,
+    model: modelName
+  };
+  if (protocol) out.protocol = protocol;
+  if (baseURL) out.baseURL = baseURL;
+  if (apiKeyEnvVar) out.apiKeyEnvVar = apiKeyEnvVar;
+  if (spec) out.spec = spec;
+  if (protocol === "openai") out.litellmProvider = "openai";
+  return out;
+}
 function providerApiKeyEnvVar(provider) {
   if (provider === "anthropic" || provider === "claude") return "ANTHROPIC_API_KEY";
   return `${provider.toUpperCase()}_API_KEY`;
 }
 function needsLitellmProxy(model) {
+  if (model.protocol === "anthropic") return false;
   return model.provider !== "claude" && model.provider !== "anthropic";
 }
 function loadConfig(projectDir = process.cwd()) {
@@ -2441,14 +2481,50 @@ function listRepairCandidates(repoSlug) {
 function dispatchVerb(workflowFile, repoSlug, capability, prNumber) {
   return dispatchWorkflow(workflowFile, capability, prNumber, repoSlug);
 }
-function postRecommendation(prNumber, mention, message, capabilitySlug) {
+function capabilityMarker(slug2) {
+  return `<!-- kody-capability: ${slug2} -->`;
+}
+function normalizeRecommendationIntent(body) {
+  const marker = body.match(/<!--\s*kody-intent:\s*([\s\S]*?)-->/i);
+  if (marker?.[1]) return marker[1].trim().replace(/\s+/g, " ").toLowerCase();
+  const legacy = body.match(/(?:^|\n)\s*(?:kody-cmd:\s*|@kody\s+)([a-z][\w-]*(?:\s+--pr\s+\d+)?)/i);
+  if (legacy?.[1]) return legacy[1].trim().replace(/\s+/g, " ").toLowerCase();
+  return null;
+}
+function containsExecutableKodyCommand(body) {
+  return /@kody\b/i.test(body) || /\bkody-cmd\s*:/i.test(body);
+}
+function recommendationAlreadyExists(repoSlug, prNumber, body, capabilitySlug) {
+  const requestedIntent = normalizeRecommendationIntent(body);
+  const requestedText = body.trim().replace(/\s+/g, " ");
+  const raw = gh(["issue", "view", String(prNumber), "-R", repoSlug, "--json", "comments"]);
+  const parsed = JSON.parse(raw);
+  return (parsed.comments ?? []).some((comment) => {
+    const existing = comment.body ?? "";
+    if (capabilitySlug && !existing.includes(capabilityMarker(capabilitySlug))) return false;
+    const existingIntent = normalizeRecommendationIntent(existing);
+    if (requestedIntent && existingIntent) return requestedIntent === existingIntent;
+    if (capabilitySlug && requestedIntent) return true;
+    return existing.trim().replace(/\s+/g, " ").includes(requestedText);
+  });
+}
+function postRecommendation(repoSlug, prNumber, mention, message, capabilitySlug) {
+  if (containsExecutableKodyCommand(message)) {
+    return {
+      ok: false,
+      error: "recommendation body contains executable Kody command text; use inert kody-intent metadata"
+    };
+  }
   const mentioned = mention ? `${mention} ${message}` : message;
   const body = capabilitySlug ? `${mentioned}
 
-<!-- kody-capability: ${capabilitySlug} -->` : mentioned;
+${capabilityMarker(capabilitySlug)}` : mentioned;
   try {
-    gh(["pr", "comment", String(prNumber), "--body", body]);
-    return { ok: true };
+    if (recommendationAlreadyExists(repoSlug, prNumber, body, capabilitySlug)) {
+      return { ok: true, posted: false };
+    }
+    gh(["issue", "comment", String(prNumber), "-R", repoSlug, "--body-file", "-"], { input: body });
+    return { ok: true, posted: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
@@ -2689,8 +2765,8 @@ function capabilityToolDefinitions(opts) {
     handler: async (args) => {
       const pr = Number(args.pr);
       const body = String(args.body ?? "");
-      const result = postRecommendation(pr, opts.operatorMention, body, opts.capabilitySlug);
-      const text = result.ok ? `Recommendation posted on PR #${pr}.` : `Recommendation failed on PR #${pr}: ${result.error}`;
+      const result = postRecommendation(opts.repoSlug, pr, opts.operatorMention, body, opts.capabilitySlug);
+      const text = result.ok ? result.posted ? `Recommendation posted on PR #${pr}.` : `Recommendation already exists on PR #${pr}; skipped.` : `Recommendation failed on PR #${pr}: ${result.error}`;
       return { content: [{ type: "text", text }] };
     }
   };
@@ -5854,13 +5930,16 @@ function resolveLitellmTimeoutMs() {
   return DEFAULT_LITELLM_STARTUP_TIMEOUT_SEC * 1e3;
 }
 function generateLitellmConfigYaml(model) {
-  const apiKeyVar = providerApiKeyEnvVar(model.provider);
+  const apiKeyVar = model.apiKeyEnvVar ?? providerApiKeyEnvVar(model.provider);
+  const litellmProvider = model.litellmProvider ?? model.provider;
+  const providerParams = model.baseURL ? [["api_base", model.baseURL]] : [];
   return [
     "model_list:",
     `  - model_name: ${model.model}`,
     `    litellm_params:`,
-    `      model: ${model.provider}/${model.model}`,
+    `      model: ${litellmProvider}/${model.model}`,
     `      api_key: os.environ/${apiKeyVar}`,
+    ...providerParams.map(([key, value]) => `      ${key}: ${value}`),
     "",
     "litellm_settings:",
     "  drop_params: true",
@@ -19385,6 +19464,16 @@ var CHAT_SYSTEM_PROMPT = [
   "Do not invent file paths, commit SHAs, line numbers, or command output. If you",
   "cite something concrete, you must have just read or run it in this session."
 ].join("\n");
+var OPENAI_CHAT_SYSTEM_PROMPT = [
+  "You are Kody, an AI assistant for the Kody Operations Dashboard. Reply to the",
+  "user's latest message using the full conversation below as context. Keep replies",
+  "short and simple. Use plain terms, not jargon.",
+  "",
+  "This chat is running through an OpenAI-compatible model endpoint. Answer directly",
+  "from the conversation and provided context. Do not claim to run shell commands,",
+  "edit files, inspect the repository, or use tools unless the user has supplied",
+  "the relevant content in the chat."
+].join("\n");
 var CROSS_REPO_PROMPT = [
   "# Working across repositories",
   "You are NOT limited to the repository at your current working directory. You",
@@ -19446,7 +19535,7 @@ async function runChatTurn(opts) {
     return { exitCode: 64, error };
   }
   const { turns: promptTurns, imagePaths } = prepareAttachments(turns, opts.cwd, opts.sessionId);
-  const basePrompt = opts.systemPrompt ?? CHAT_SYSTEM_PROMPT;
+  const basePrompt = opts.systemPrompt ?? (opts.model.protocol === "openai" ? OPENAI_CHAT_SYSTEM_PROMPT : CHAT_SYSTEM_PROMPT);
   const catalog = buildExecutableCatalog();
   const taskArtifactsPaths = prepareTaskArtifactsDir(opts.cwd, opts.sessionId);
   const artifactAddendum = taskArtifactsPromptAddendum({
@@ -19480,6 +19569,14 @@ async function runChatTurn(opts) {
     artifactAddendum
   ].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
   const prompt = buildPrompt(promptTurns);
+  if (opts.model.protocol === "openai" && opts.litellmUrl) {
+    return runOpenAIChatTurn({
+      opts,
+      turns: promptTurns,
+      systemPrompt,
+      sessionFile: opts.sessionFile
+    });
+  }
   let progressSeq = 0;
   const invoke = opts.invokeAgent ?? ((p) => runAgent({
     prompt: p,
@@ -19582,6 +19679,74 @@ async function runChatTurn(opts) {
   }
   return { exitCode: 0, reply };
 }
+async function runOpenAIChatTurn(args) {
+  const { opts, turns, systemPrompt, sessionFile } = args;
+  const doFetch = opts.fetchImpl ?? fetch;
+  const url = `${opts.litellmUrl.replace(/\/+$/, "")}/v1/chat/completions`;
+  try {
+    const response = await doFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts.model.model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          ...turns.map((turn) => ({
+            role: turn.role,
+            content: turn.content
+          }))
+        ],
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      const error = `OpenAI-compatible model request failed ${response.status}${text ? `: ${text.slice(0, 500)}` : ""}`;
+      await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+      return { exitCode: 99, error };
+    }
+    const payload = await response.json();
+    const reply = extractOpenAIReply(payload).trim();
+    if (!reply) {
+      const error = typeof payload.error?.message === "string" ? payload.error.message : "OpenAI-compatible model completed without producing a reply";
+      await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+      return { exitCode: 99, error };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    appendTurn(sessionFile, {
+      role: "assistant",
+      content: reply,
+      timestamp: now
+    });
+    await emit(opts.sink, "chat.message", opts.sessionId, "message", {
+      sessionId: opts.sessionId,
+      role: "assistant",
+      content: reply,
+      timestamp: now
+    });
+    await emit(opts.sink, "chat.done", opts.sessionId, "done", { sessionId: opts.sessionId });
+    return { exitCode: 0, reply };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 99, error };
+  }
+}
+function extractOpenAIReply(payload) {
+  const content = payload.choices?.[0]?.message?.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (part && typeof part === "object" && "text" in part) {
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+}
 function buildPrompt(turns) {
   const body = turns.map((t) => `${t.role === "user" ? "User" : "Assistant"}: ${t.content}`).join("\n\n");
   return `${body}
@@ -21424,7 +21589,10 @@ async function brainServe(opts) {
   }
   const apiKey = getApiKey();
   const port = Number(process.env.PORT ?? DEFAULT_PORT);
-  const model = parseProviderModel(process.env.MODEL?.trim() || "claude/claude-haiku-4-5-20251001");
+  const model = parseModelRuntimeConfig(
+    process.env.MODEL?.trim() || "claude/claude-haiku-4-5-20251001",
+    process.env.KODY_MODEL_CONFIG
+  );
   const usesProxy = needsLitellmProxy(model);
   let handle = null;
   if (usesProxy) {

package/package.json

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