@kal-elsam/kairo-runtime 0.4.3 → 0.5.0

package/src/global/intelligence/backends/opencode-runtime.js

@@ -0,0 +1,242 @@
+import {
+  BACKEND_IDS,
+  COST_CLASSES,
+  PRIVACY_CLASSES,
+  TRANSPORT_KINDS,
+  createModelDescriptor
+} from "../types.js";
+import {
+  listRegisteredModelIds,
+  normalizeModelId,
+  resolveRuntimeProduct,
+  toRuntimeModelRef
+} from "../transport-registry.js";
+import { CAPABILITY_STATES } from "../../capability-states.js";
+import { isExecutableAvailable } from "../../cli-probe.js";
+import { parseOpencodeJsonEvents, runOpencodeJson, sanitizeCliStderr } from "./opencode-cli.js";
+import {
+  BILLING_MODELS,
+  ENTITLEMENT_STATES,
+  collectOpencodeCliEvidence
+} from "./opencode-evidence.js";
+
+const PREAMBLE =
+  "Answer with analysis only. Do not modify files, run mutating tools, or change the workspace.";
+
+/** Non-mutating OpenCode CLI runtime. Override-only; never auto-routed; never reads auth.json. */
+export function createOpencodeRuntimeBackend({
+  env = process.env,
+  spawnImpl,
+  whichImpl = isExecutableAvailable,
+  collectCliEvidence = collectOpencodeCliEvidence
+} = {}) {
+  return {
+    id: BACKEND_IDS.OPENCODE,
+    label: "OpenCode CLI",
+    local: false,
+
+    async detect() {
+      const cli = collectCliEvidence({ env, whichImpl });
+      if (!cli.cliInstalled) {
+        return baseDetect({
+          state: CAPABILITY_STATES.UNKNOWN,
+          detected: false,
+          available: false,
+          configured: false,
+          entitlement: ENTITLEMENT_STATES.UNKNOWN,
+          evidence: evidence(false),
+          recommendation:
+            "Install and authenticate the OpenCode CLI to use Anthropic/Google models via runtime transport (Kairo does not read OpenCode auth files)."
+        });
+      }
+      const configured = cli.authProviders.length > 0;
+      return baseDetect({
+        state: CAPABILITY_STATES.DETECTED,
+        detected: true,
+        available: true,
+        configured,
+        entitlement: configured
+          ? ENTITLEMENT_STATES.UNVERIFIED
+          : ENTITLEMENT_STATES.UNKNOWN,
+        evidence: evidence(true, cli),
+        error: cli.error,
+        recommendation: configured
+          ? `OpenCode CLI configured providers: ${cli.authProviders.join(", ")}. Entitlement remains ${ENTITLEMENT_STATES.UNVERIFIED}. Runtime invoke needs --cloud-consent --yes.`
+          : "OpenCode CLI detected but auth list reported no providers. Run `opencode auth login` (Kairo never reads auth.json)."
+      });
+    },
+
+    async listModels() {
+      const models = listRegisteredModelIds("zen", { runtimeOnly: true })
+        .map((modelId) => runtimeModel("zen", modelId));
+      for (const modelId of listRegisteredModelIds("go", { runtimeOnly: true })) {
+        if (models.some((entry) => normalizeModelId(entry.modelId) === modelId)) continue;
+        models.push(runtimeModel("go", modelId));
+      }
+      return models;
+    },
+
+    async capabilities() {
+      const d = await this.detect();
+      return {
+        id: BACKEND_IDS.OPENCODE,
+        local: false,
+        cloud: true,
+        requiresApiKey: false,
+        requiresConsent: true,
+        streaming: false,
+        tools: false,
+        runtime: true,
+        transports: [TRANSPORT_KINDS.RUNTIME],
+        billingModel: d.billingModel,
+        entitlement: d.entitlement,
+        configured: d.configured,
+        authenticated: false,
+        state: d.state,
+        hasApiKey: false,
+        mutating: false
+      };
+    },
+
+    async invoke(contextPack, request = {}) {
+      const detection = await this.detect();
+      if (!detection.available) return fail(detection.recommendation);
+      const modelRef = resolveModelRef(request.modelId);
+      if (!modelRef) {
+        return fail(
+          "Runtime invoke requires --model <provider/model> (e.g. opencode/claude-haiku-4-5)."
+        );
+      }
+      const timeoutMs = request.timeoutMs ?? 120_000;
+      try {
+        const result = await runOpencodeJson({
+          modelRef,
+          prompt: buildPrompt(contextPack, request),
+          cwd: request.cwd ?? contextPack?.workspaceRoot ?? process.cwd(),
+          env,
+          spawnImpl,
+          timeoutMs,
+          terminationGraceMs: request.terminationGraceMs,
+          killGraceMs: request.killGraceMs
+        });
+        const failure = describeRuntimeFailure(result, timeoutMs);
+        if (failure) return fail(failure);
+
+        const parsed = parseOpencodeJsonEvents(result.stdout);
+        if (parsed.error) return fail(parsed.error);
+        if (!parsed.content) {
+          const detail = sanitizeCliStderr(result.stderr) || "no content";
+          return fail(`OpenCode CLI produced no text output (${detail}).`);
+        }
+        return {
+          ok: true,
+          backendId: BACKEND_IDS.OPENCODE,
+          model: modelRef,
+          content: parsed.content,
+          usage: {
+            ...parsed.usage,
+            model: modelRef,
+            backendId: BACKEND_IDS.OPENCODE,
+            fallbackUsed: false
+          },
+          raw: {
+            events: parsed.events,
+            status: result.status,
+            signal: result.signal
+          }
+        };
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return fail(
+            "OpenCode CLI is not installed. Install OpenCode, authenticate it, then retry with --backend opencode."
+          );
+        }
+        return fail(error?.message ?? String(error));
+      }
+    }
+  };
+}
+
+function describeRuntimeFailure(result, timeoutMs) {
+  if (result.terminationFailed) {
+    return `OpenCode CLI process did not terminate after timeout (${timeoutMs}ms SIGTERM/SIGKILL).`;
+  }
+  if (result.timedOut) {
+    return `OpenCode CLI timed out after ${timeoutMs}ms.`;
+  }
+  if (result.status !== 0) {
+    const exitPart = result.status == null
+      ? (result.signal ? `signal ${result.signal}` : "exit null")
+      : `exit ${result.status}`;
+    const detail = sanitizeCliStderr(result.stderr);
+    return detail
+      ? `OpenCode CLI failed (${exitPart}): ${detail}`
+      : `OpenCode CLI failed (${exitPart}).`;
+  }
+  return null;
+}
+function evidence(cliInstalled, cli = null) {
+  return {
+    hasApiKey: false,
+    cliInstalled,
+    authListOk: cli?.authListOk ?? false,
+    authProviders: cli?.authProviders ?? [],
+    modelsHttpStatus: null
+  };
+}
+
+function baseDetect(fields) {
+  return {
+    id: BACKEND_IDS.OPENCODE,
+    label: "OpenCode CLI",
+    hasApiKey: false,
+    cloud: true,
+    runtime: true,
+    authenticated: false,
+    billingModel: BILLING_MODELS.CLI_RUNTIME,
+    error: null,
+    ...fields
+  };
+}
+
+function runtimeModel(product, modelId) {
+  return createModelDescriptor({
+    provider: BACKEND_IDS.OPENCODE,
+    modelId: toRuntimeModelRef(product, modelId),
+    local: false,
+    costClass: COST_CLASSES.PAID,
+    privacyClass: PRIVACY_CLASSES.CLOUD,
+    transport: TRANSPORT_KINDS.RUNTIME
+  });
+}
+
+function resolveModelRef(modelId) {
+  if (!modelId) return null;
+  const raw = String(modelId).trim();
+  if (raw.includes("/")) return raw;
+  const product = resolveRuntimeProduct(raw);
+  return product ? toRuntimeModelRef(product, raw) : null;
+}
+
+function buildPrompt(contextPack, request) {
+  const chunks = [PREAMBLE];
+  if (contextPack?.systemPrompt) chunks.push(contextPack.systemPrompt);
+  if (request.prompt) chunks.push(request.prompt);
+  else if (Array.isArray(request.messages)) {
+    for (const message of request.messages) {
+      if (message?.content) chunks.push(String(message.content));
+    }
+  }
+  return chunks.join("\n\n");
+}
+
+function fail(message) {
+  return {
+    ok: false,
+    backendId: BACKEND_IDS.OPENCODE,
+    model: null,
+    content: null,
+    error: message,
+    usage: null
+  };
+}

package/src/global/intelligence/context-compiler.js

@@ -30,6 +30,7 @@ const STABLE_DOC_CANDIDATES = [
 
 const DEFAULT_STABLE_BUDGET = 6000;
 const DEFAULT_REQUEST_BUDGET = 4000;
+const TRUNCATION_MARKER = "\n…[truncated]";
 
 export async function compileContextPack({
   workspaceRoot,
@@ -44,29 +45,54 @@ export async function compileContextPack({
   const project = await detectProject(root);
   const evidence = [];
 
-  const agentsMd = await readEvidenceFile(
-    root,
-    workspaceRealRoot,
-    "AGENTS.md",
-    evidence,
-    2000,
-    { includePrivate }
-  );
-  const stableDocs = await collectStableDocs(root, workspaceRealRoot, evidence, stableBudgetTokens, includePrivate);
+  const stableBudget = createBudget(stableBudgetTokens);
+  let agentsMd = null;
+  const stableDocs = [];
+
+  for (const candidate of STABLE_DOC_CANDIDATES) {
+    const content = await readEvidenceFile(
+      root,
+      workspaceRealRoot,
+      candidate,
+      evidence,
+      stableBudget,
+      { includePrivate, category: "stable" }
+    );
+    if (!content) continue;
+    if (candidate === "AGENTS.md") {
+      agentsMd = content;
+    } else {
+      stableDocs.push({ path: candidate, content: content.text, truncated: content.truncated });
+    }
+  }
+
   const skills = await listSkillIds(root, evidence);
   const graphify = await detectGraphify(root, evidence);
   const engram = await detectEngramHints(root, evidence);
 
+  const requestBudget = createBudget(requestBudgetTokens);
   const requestFiles = [];
+  const seenPaths = new Set();
+
   for (const filePath of relevantPaths) {
-    const rel = relative(root, resolve(root, filePath));
+    const rel = relative(root, resolve(root, filePath)).replace(/\\/g, "/") || ".";
+    if (seenPaths.has(rel)) {
+      evidence.push({
+        kind: "deduped_path",
+        path: rel,
+        reason: "Duplicate path skipped"
+      });
+      continue;
+    }
+    seenPaths.add(rel);
+
     const content = await readEvidenceFile(
       root,
       workspaceRealRoot,
       rel,
       evidence,
-      requestBudgetTokens,
-      { includePrivate }
+      requestBudget,
+      { includePrivate, category: "request" }
     );
     if (content) {
       requestFiles.push({ path: rel, content: content.text, truncated: content.truncated });
@@ -92,11 +118,7 @@ export async function compileContextPack({
     engram
   };
 
-  const perRequest = {
-    task,
-    files: requestFiles
-  };
-
+  const perRequest = { task, files: requestFiles };
   const systemPrompt = buildSystemPrompt(stable, perRequest);
   const estimatedTokens = estimateTokens(systemPrompt);
 
@@ -110,7 +132,9 @@ export async function compileContextPack({
     estimatedTokens,
     budgets: {
       stableBudgetTokens,
-      requestBudgetTokens
+      requestBudgetTokens,
+      stableUsedTokens: stableBudget.used,
+      requestUsedTokens: requestBudget.used
     },
     privacy: {
       includePrivate,
@@ -131,28 +155,17 @@ export function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 
-async function collectStableDocs(root, workspaceRealRoot, evidence, budgetTokens, includePrivate) {
-  const docs = [];
-  let used = 0;
-
-  for (const candidate of STABLE_DOC_CANDIDATES) {
-    if (candidate === "AGENTS.md") continue;
-    const remaining = Math.max(500, budgetTokens - used);
-    const content = await readEvidenceFile(
-      root,
-      workspaceRealRoot,
-      candidate,
-      evidence,
-      remaining,
-      { includePrivate }
-    );
-    if (!content) continue;
-    docs.push({ path: candidate, content: content.text, truncated: content.truncated });
-    used += estimateTokens(content.text);
-    if (used >= budgetTokens) break;
-  }
-
-  return docs;
+function createBudget(limitTokens) {
+  return {
+    limit: Math.max(0, Number(limitTokens) || 0),
+    used: 0,
+    remaining() {
+      return Math.max(0, this.limit - this.used);
+    },
+    consume(tokens) {
+      this.used += tokens;
+    }
+  };
 }
 
 async function listSkillIds(root, evidence) {
@@ -204,11 +217,11 @@ async function readEvidenceFile(
   workspaceRealRoot,
   relativePath,
   evidence,
-  maxTokens = 2000,
-  { includePrivate = false } = {}
+  budget,
+  { includePrivate = false, category = "request" } = {}
 ) {
   const requested = resolve(root, relativePath);
-  const requestedRelative = relative(root, requested) || ".";
+  const requestedRelative = relative(root, requested).replace(/\\/g, "/") || ".";
   if (!isPathInside(root, requested)) {
     evidence.push({
       kind: "rejected_outside_workspace",
@@ -220,6 +233,17 @@ async function readEvidenceFile(
 
   if (!existsSync(requested)) return null;
 
+  const remaining = budget.remaining();
+  if (remaining <= 0) {
+    evidence.push({
+      kind: "excluded_budget",
+      path: requestedRelative,
+      reason: `${category} budget exhausted`,
+      tokens: 0
+    });
+    return null;
+  }
+
   let target;
   try {
     target = await realpath(requested);
@@ -237,7 +261,7 @@ async function readEvidenceFile(
     return null;
   }
 
-  const targetRelative = relative(workspaceRealRoot, target) || ".";
+  const targetRelative = relative(workspaceRealRoot, target).replace(/\\/g, "/") || ".";
   if ((isPrivatePath(requestedRelative) || isPrivatePath(targetRelative)) && !includePrivate) {
     evidence.push({
       kind: "excluded_private",
@@ -249,22 +273,43 @@ async function readEvidenceFile(
 
   try {
     const raw = await readFile(target, "utf8");
-    const maxChars = maxTokens * 4;
-    const truncated = raw.length > maxChars;
-    const text = truncated ? `${raw.slice(0, maxChars)}\n…[truncated]` : raw;
+    const clipped = clipToTokenBudget(raw, remaining);
+    budget.consume(clipped.tokens);
     evidence.push({
       kind: "file",
       path: requestedRelative,
-      truncated,
-      chars: text.length
+      truncated: clipped.truncated,
+      chars: clipped.text.length,
+      tokens: clipped.tokens
     });
-    return { text, truncated };
+    return { text: clipped.text, truncated: clipped.truncated, tokens: clipped.tokens };
   } catch {
     evidence.push({ kind: "unreadable", path: requestedRelative });
     return null;
   }
 }
 
+function clipToTokenBudget(raw, maxTokens) {
+  const maxChars = Math.max(0, maxTokens) * 4;
+  if (raw.length <= maxChars) {
+    return { text: raw, truncated: false, tokens: estimateTokens(raw) };
+  }
+
+  const marker = TRUNCATION_MARKER;
+  if (marker.length >= maxChars) {
+    const text = marker.slice(0, maxChars);
+    return { text, truncated: true, tokens: estimateTokens(text) };
+  }
+
+  const bodyChars = maxChars - marker.length;
+  const text = `${raw.slice(0, bodyChars)}${marker}`;
+  return {
+    text,
+    truncated: true,
+    tokens: estimateTokens(text)
+  };
+}
+
 async function resolveWorkspaceRoot(root) {
   try {
     return await realpath(root);

package/src/global/intelligence/index.js

@@ -3,16 +3,52 @@ export {
   COST_CLASSES,
   PRIVACY_CLASSES,
   ROUTING_MODES,
+  TRANSPORT_KINDS,
   OPENROUTER_FREE_MODEL,
+  OPENCODE_API_KEY_ENV,
+  OPENCODE_GO_BASE_URL,
+  OPENCODE_ZEN_BASE_URL,
+  OPENCODE_GO_DEFAULT_MODEL,
+  OPENCODE_ZEN_DEFAULT_FREE_MODEL,
   DEFAULT_OLLAMA_HOST,
   createModelDescriptor,
   createRoutingDecision,
   createUsageTelemetry
 } from "./types.js";
 
+export {
+  resolveOpencodeTransport,
+  isDirectTransport,
+  listRegisteredModelIds,
+  normalizeModelId,
+  toRuntimeModelRef,
+  resolveRuntimeProduct,
+  OPENCODE_GO_TRANSPORTS,
+  OPENCODE_ZEN_TRANSPORTS
+} from "./transport-registry.js";
+
+export {
+  ENTITLEMENT_STATES,
+  BILLING_MODELS,
+  parseAuthListProviders,
+  collectOpencodeCliEvidence
+} from "./backends/opencode-evidence.js";
+
 export { createOllamaBackend } from "./backends/ollama.js";
 export { createOpenRouterBackend } from "./backends/openrouter.js";
 export { createCustomHttpBackend } from "./backends/custom-http.js";
+export {
+  createOpencodeGoBackend,
+  createOpencodeZenBackend
+} from "./backends/opencode-providers.js";
+
+export { createOpencodeRuntimeBackend } from "./backends/opencode-runtime.js";
+
+export {
+  runOpencodeJson,
+  parseOpencodeJsonEvents,
+  sanitizeCliStderr
+} from "./backends/opencode-cli.js";
 
 export {
   createDefaultBackends,
@@ -29,7 +65,8 @@ export {
 
 export {
   resolveRoutingDecision,
-  classifyTaskWeight
+  classifyTaskWeight,
+  isDirectProviderEligible
 } from "./router.js";
 
 export {

package/src/global/intelligence/orchestrate.js

@@ -19,7 +19,8 @@ export async function runIntelligenceRequest({
   env = process.env,
   fetchImpl = globalThis.fetch,
   backends = null,
-  tokenBudget = null
+  tokenBudget = null,
+  sessionOverride = null
 } = {}) {
   const customProviders = Array.isArray(profile.customProviders) ? profile.customProviders : [];
   const backendInstances = backends ?? createDefaultBackends({ env, fetchImpl, customProviders });
@@ -46,7 +47,8 @@ export async function runIntelligenceRequest({
     contextPack,
     task: task ?? prompt,
     cloudConsent: Boolean(cloudConsent),
-    tokenBudget: tokenBudget ?? profile.tokenBudget ?? null
+    tokenBudget: tokenBudget ?? profile.tokenBudget ?? null,
+    sessionOverride
   });
 
   const explanation = explainRouting(routing, contextPack, inspections);

package/src/global/intelligence/registry.js

@@ -2,16 +2,39 @@ import { BACKEND_IDS } from "./types.js";
 import { createOllamaBackend } from "./backends/ollama.js";
 import { createOpenRouterBackend } from "./backends/openrouter.js";
 import { createCustomHttpBackend } from "./backends/custom-http.js";
+import {
+  createOpencodeGoBackend,
+  createOpencodeZenBackend
+} from "./backends/opencode-providers.js";
+import { createOpencodeRuntimeBackend } from "./backends/opencode-runtime.js";
+import { collectOpencodeCliEvidence } from "./backends/opencode-evidence.js";
 import { CAPABILITY_STATES } from "../capability-states.js";
 
 export function createDefaultBackends({
   env = process.env,
   fetchImpl = globalThis.fetch,
-  customProviders = []
+  customProviders = [],
+  whichImpl,
+  collectCliEvidence,
+  spawnImpl
 } = {}) {
+  const sharedCliEvidence = createSharedCliEvidenceCollector({
+    env,
+    whichImpl,
+    collectCliEvidence
+  });
+
   const backends = [
     createOllamaBackend({ env, fetchImpl }),
-    createOpenRouterBackend({ env, fetchImpl })
+    createOpencodeGoBackend({ env, fetchImpl, collectCliEvidence: sharedCliEvidence }),
+    createOpencodeZenBackend({ env, fetchImpl, collectCliEvidence: sharedCliEvidence }),
+    createOpenRouterBackend({ env, fetchImpl }),
+    createOpencodeRuntimeBackend({
+      env,
+      whichImpl,
+      spawnImpl,
+      collectCliEvidence: sharedCliEvidence
+    })
   ];
 
   for (const provider of customProviders) {
@@ -29,9 +52,19 @@ export async function inspectIntelligenceBackends({
   env = process.env,
   fetchImpl = globalThis.fetch,
   customProviders = [],
-  backends = null
+  backends = null,
+  whichImpl,
+  collectCliEvidence,
+  spawnImpl
 } = {}) {
-  const resolved = backends ?? createDefaultBackends({ env, fetchImpl, customProviders });
+  const resolved = backends ?? createDefaultBackends({
+    env,
+    fetchImpl,
+    customProviders,
+    whichImpl,
+    collectCliEvidence,
+    spawnImpl
+  });
   return Promise.all(resolved.map(async (backend) => {
     const detection = await backend.detect();
     const models = detection.detected || detection.available
@@ -59,15 +92,25 @@ export function summarizeIntelligenceBackends(inspections) {
     }
   }
 
+  const go = inspections.find((entry) => entry.id === BACKEND_IDS.OPENCODE_GO);
+  const zen = inspections.find((entry) => entry.id === BACKEND_IDS.OPENCODE_ZEN);
+  const openrouter = inspections.find((entry) => entry.id === BACKEND_IDS.OPENROUTER);
+
   return {
     total: inspections.length,
     available: inspections.filter((entry) => entry.available).length,
     localAvailable: inspections.some(
       (entry) => entry.id === BACKEND_IDS.OLLAMA && entry.available
     ),
-    cloudAuthenticated: inspections.some(
-      (entry) => entry.id === BACKEND_IDS.OPENROUTER && entry.hasApiKey
+    cloudConfigured: Boolean(go?.configured || zen?.configured || openrouter?.hasApiKey),
+    /** OpenRouter stays key-based; Go/Zen use proven authenticated evidence. */
+    cloudAuthenticated: Boolean(
+      go?.authenticated || zen?.authenticated || openrouter?.hasApiKey
     ),
+    opencodeGoConfigured: Boolean(go?.configured),
+    opencodeZenConfigured: Boolean(zen?.configured),
+    opencodeGoAuthenticated: Boolean(go?.authenticated),
+    opencodeZenAuthenticated: Boolean(zen?.authenticated),
     byState
   };
 }
@@ -75,3 +118,16 @@ export function summarizeIntelligenceBackends(inspections) {
 export function resolveBackendById(backends, backendId) {
   return backends.find((backend) => backend.id === backendId) ?? null;
 }
+
+function createSharedCliEvidenceCollector({
+  env,
+  whichImpl,
+  collectCliEvidence
+}) {
+  let cached = null;
+  const collector = collectCliEvidence ?? collectOpencodeCliEvidence;
+  return () => {
+    if (!cached) cached = collector({ env, whichImpl });
+    return cached;
+  };
+}