0sec-cli 0.15.0 → 0.18.0

package/chunks/chunk-N7BOUYEV.js

@@ -0,0 +1,852 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  LlmApiRuntime
+} from "./chunk-UR4ELX2Y.js";
+import {
+  ProcessRuntime
+} from "./chunk-ATATQACO.js";
+
+// packages/core/dist/runtime/cli-native.js
+import { spawn } from "node:child_process";
+var CliNativeRuntime = class {
+  type;
+  config;
+  command;
+  /** Populated from the first turn's stream-json `system` event. */
+  sessionId;
+  constructor(config) {
+    if (config.type === "api") {
+      throw new Error("CliNativeRuntime does not support type=api. Use LlmApiRuntime instead.");
+    }
+    this.type = config.type;
+    this.config = config;
+    this.command = config.type;
+  }
+  /**
+   * Reset the cached session id so the next call starts a brand-new
+   * Claude Code session. The native loop uses this between scans.
+   */
+  resetSession() {
+    this.sessionId = void 0;
+  }
+  async isAvailable() {
+    return new Promise((resolve) => {
+      const proc = spawn(this.command, ["--version"], {
+        cwd: this.config.cwd ?? process.cwd(),
+        env: { ...process.env, ...this.config.env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timer = setTimeout(() => {
+        proc.kill();
+        resolve(false);
+      }, 5e3);
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        resolve(code === 0);
+      });
+      proc.on("error", () => {
+        clearTimeout(timer);
+        resolve(false);
+      });
+    });
+  }
+  async executeNative(system, messages, _tools, callbacks) {
+    const start = Date.now();
+    if (this.type !== "claude") {
+      return {
+        content: [{ type: "text", text: "" }],
+        stopReason: "error",
+        durationMs: Date.now() - start,
+        error: `Native multi-turn agent loop is only supported for the 'claude' CLI runtime. '${this.type}' does not yet expose a stable session-resume protocol \u2014 use --runtime claude (with 'claude login') for subscription auth, or set ANTHROPIC_API_KEY / OPENROUTER_API_KEY / OPENAI_API_KEY for --runtime api.`
+      };
+    }
+    const promptText = buildClaudePromptFromLastUser(messages);
+    if (!promptText) {
+      return {
+        content: [{ type: "text", text: "" }],
+        stopReason: "error",
+        durationMs: Date.now() - start,
+        error: "CliNativeRuntime: last message was not a user turn (cannot prompt Claude Code)."
+      };
+    }
+    const args = ["-p", promptText, "--verbose", "--output-format", "stream-json"];
+    if (this.sessionId) {
+      args.push("--resume", this.sessionId);
+    } else if (system && system.trim().length > 0) {
+      args.push("--system-prompt", system);
+    }
+    return new Promise((resolve) => {
+      let stdoutBuf = "";
+      let stderrBuf = "";
+      let timedOut = false;
+      const content = [];
+      let stopReason = "end_turn";
+      let usage;
+      let sawAssistantEnd = false;
+      const proc = spawn(this.command, args, {
+        cwd: this.config.cwd ?? process.cwd(),
+        env: { ...process.env, ...this.config.env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      proc.stdout?.on("data", (chunk) => {
+        stdoutBuf += chunk.toString("utf-8");
+        let nl = stdoutBuf.indexOf("\n");
+        while (nl >= 0) {
+          const line = stdoutBuf.slice(0, nl).trim();
+          stdoutBuf = stdoutBuf.slice(nl + 1);
+          nl = stdoutBuf.indexOf("\n");
+          if (!line)
+            continue;
+          const event = tryParseJson(line);
+          if (!event)
+            continue;
+          if (typeof event.session_id === "string" && !this.sessionId) {
+            this.sessionId = event.session_id;
+          }
+          if (event.type === "assistant" && event.message && Array.isArray(event.message.content)) {
+            for (const block of event.message.content) {
+              if (block?.type === "text" && typeof block.text === "string") {
+                content.push({ type: "text", text: block.text });
+                if (block.text.trim())
+                  callbacks?.onThinking?.(block.text);
+              } else if (block?.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+                content.push({
+                  type: "tool_use",
+                  id: block.id,
+                  name: block.name,
+                  input: block.input && typeof block.input === "object" ? block.input : {}
+                });
+              }
+            }
+            const u = event.message?.usage;
+            if (u) {
+              const partial = readUsage(u);
+              if (partial)
+                callbacks?.onUsage?.(partial);
+            }
+          }
+          if (event.type === "result") {
+            sawAssistantEnd = true;
+            stopReason = mapClaudeStopReason(event.stop_reason ?? event.subtype);
+            const u = event.usage;
+            if (u)
+              usage = readUsage(u) ?? usage;
+          }
+        }
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderrBuf += chunk.toString("utf-8");
+      });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+        setTimeout(() => proc.kill("SIGKILL"), 5e3).unref();
+      }, this.config.timeout || 6e5);
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        this.sessionId = void 0;
+        resolve({
+          content: [{ type: "text", text: "" }],
+          stopReason: "error",
+          durationMs: Date.now() - start,
+          error: `claude CLI spawn failed: ${err.message}`
+        });
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        if (timedOut) {
+          this.sessionId = void 0;
+          resolve({
+            content: content.length > 0 ? content : [{ type: "text", text: "" }],
+            stopReason: "error",
+            usage,
+            durationMs: Date.now() - start,
+            error: `claude CLI timed out after ${this.config.timeout}ms`
+          });
+          return;
+        }
+        if (code !== 0 && !sawAssistantEnd) {
+          const hint = extractAuthHint(stderrBuf);
+          this.sessionId = void 0;
+          resolve({
+            content: [{ type: "text", text: "" }],
+            stopReason: "error",
+            usage,
+            durationMs: Date.now() - start,
+            error: `claude CLI exited ${code}` + (hint ? ` \u2014 ${hint}` : "") + (stderrBuf.trim() ? `
+stderr: ${stderrBuf.trim().slice(0, 500)}` : "")
+          });
+          return;
+        }
+        resolve({
+          content: content.length > 0 ? content : [{ type: "text", text: "" }],
+          stopReason,
+          usage,
+          durationMs: Date.now() - start
+        });
+      });
+    });
+  }
+};
+function buildClaudePromptFromLastUser(messages) {
+  let last;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      last = messages[i];
+      break;
+    }
+  }
+  if (!last)
+    return "";
+  const toolResults = [];
+  const textParts = [];
+  for (const block of last.content) {
+    if (block.type === "tool_result") {
+      toolResults.push({
+        tool_use_id: block.tool_use_id,
+        content: block.content,
+        ...block.is_error ? { is_error: true } : {}
+      });
+    } else if (block.type === "text") {
+      textParts.push(block.text);
+    }
+  }
+  const parts = [];
+  if (toolResults.length > 0) {
+    parts.push(`[0sec:tool_results]
+${JSON.stringify(toolResults, null, 2)}`);
+  }
+  if (textParts.length > 0) {
+    parts.push(textParts.join("\n").trim());
+  }
+  return parts.filter((p) => p.length > 0).join("\n\n").trim();
+}
+function mapClaudeStopReason(raw) {
+  if (!raw)
+    return "end_turn";
+  switch (raw) {
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+    case "success_max_turns":
+      return "max_tokens";
+    case "end_turn":
+    case "success":
+    case "stop_sequence":
+      return "end_turn";
+    case "error":
+    case "error_max_turns":
+    case "error_during_execution":
+      return "error";
+    default:
+      return "end_turn";
+  }
+}
+function tryParseJson(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function readUsage(u) {
+  const input = num(u.input_tokens) ?? num(u.prompt_tokens);
+  const output = num(u.output_tokens) ?? num(u.completion_tokens);
+  if (input === void 0 && output === void 0)
+    return void 0;
+  return { inputTokens: input ?? 0, outputTokens: output ?? 0 };
+}
+function num(v) {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "string" && /^\d+$/.test(v))
+    return Number(v);
+  return void 0;
+}
+function extractAuthHint(stderr) {
+  if (!stderr)
+    return void 0;
+  if (/please\s+run\s+claude\s+login/i.test(stderr)) {
+    return "run `claude login` to authenticate the CLI with your subscription";
+  }
+  if (/not\s+(?:logged|authenticated)/i.test(stderr)) {
+    return "Claude Code reports the user is not authenticated \u2014 run `claude login`";
+  }
+  if (/session\s+expired/i.test(stderr)) {
+    return "Claude Code session expired \u2014 run `claude login` again";
+  }
+  return void 0;
+}
+
+// packages/core/dist/runtime/openrouter.js
+var DEFAULT_ENSEMBLE_MODELS = [
+  "anthropic/claude-sonnet-4.6",
+  "google/gemini-2.5-pro",
+  "openai/o3",
+  "deepseek/deepseek-chat",
+  "meta-llama/llama-4-maverick",
+  "qwen/qwen3-235b-a22b"
+];
+function scoreResult(result) {
+  let score = 0;
+  if (result.stopReason === "error")
+    return -1;
+  if (result.stopReason === "end_turn")
+    score += 100;
+  if (result.stopReason === "tool_use")
+    score += 80;
+  for (const block of result.content) {
+    if (block.type === "text") {
+      score += Math.min(block.text.length / 100, 50);
+    }
+    if (block.type === "tool_use") {
+      score += 20;
+    }
+  }
+  return score;
+}
+var OpenRouterRuntime = class _OpenRouterRuntime {
+  type = "api";
+  config;
+  apiKey;
+  singleRuntime = null;
+  ensembleRuntimes = [];
+  constructor(config = {}) {
+    this.config = config;
+    this.apiKey = config.apiKey ?? process.env.OPENROUTER_API_KEY ?? "";
+    if (config.ensembleModels && config.ensembleModels.length > 0) {
+      for (const model of config.ensembleModels) {
+        this.ensembleRuntimes.push({
+          model,
+          runtime: this.createModelRuntime(model)
+        });
+      }
+    } else {
+      const model = config.model ?? process.env["0SEC_MODEL"] ?? "anthropic/claude-sonnet-4.6";
+      this.singleRuntime = this.createModelRuntime(model);
+    }
+  }
+  createModelRuntime(model) {
+    const runtimeConfig = {
+      type: "api",
+      timeout: this.config.timeout ?? 12e4,
+      model,
+      apiKey: this.apiKey
+    };
+    return new LlmApiRuntime(runtimeConfig);
+  }
+  /** Get the model name(s) this runtime is configured for. */
+  get models() {
+    if (this.ensembleRuntimes.length > 0) {
+      return this.ensembleRuntimes.map((e) => e.model);
+    }
+    return [this.config.model ?? process.env["0SEC_MODEL"] ?? "anthropic/claude-sonnet-4.6"];
+  }
+  /** Whether this runtime is in ensemble mode. */
+  get isEnsemble() {
+    return this.ensembleRuntimes.length > 0;
+  }
+  /**
+   * Execute a single native call. In ensemble mode, runs all models in
+   * parallel (up to maxConcurrency) and returns the best result.
+   */
+  async executeNative(system, messages, tools, callbacks) {
+    if (this.singleRuntime) {
+      return this.singleRuntime.executeNative(system, messages, tools, callbacks);
+    }
+    const maxConcurrency = this.config.maxConcurrency ?? 3;
+    const results = [];
+    const pending = [...this.ensembleRuntimes];
+    while (pending.length > 0) {
+      const batch = pending.splice(0, maxConcurrency);
+      const batchResults = await Promise.allSettled(batch.map(async ({ model, runtime }) => {
+        const result = await runtime.executeNative(system, messages, tools, callbacks);
+        return { model, result };
+      }));
+      for (const settled of batchResults) {
+        if (settled.status === "fulfilled") {
+          results.push(settled.value);
+        }
+      }
+    }
+    if (results.length === 0) {
+      return {
+        content: [{ type: "text", text: "" }],
+        stopReason: "error",
+        durationMs: 0,
+        error: "All ensemble models failed"
+      };
+    }
+    let best = results[0];
+    let bestScore = scoreResult(best.result);
+    for (let i = 1; i < results.length; i++) {
+      const s = scoreResult(results[i].result);
+      if (s > bestScore) {
+        best = results[i];
+        bestScore = s;
+      }
+    }
+    return best.result;
+  }
+  /**
+   * Run ensemble and return ALL results (not just the best).
+   * Useful for the benchmark runner which may want to evaluate each model separately.
+   */
+  async executeEnsemble(system, messages, tools) {
+    const runtimes = this.ensembleRuntimes.length > 0 ? this.ensembleRuntimes : [{ model: this.config.model ?? "default", runtime: this.singleRuntime }];
+    const maxConcurrency = this.config.maxConcurrency ?? 3;
+    const results = [];
+    const pending = [...runtimes];
+    while (pending.length > 0) {
+      const batch = pending.splice(0, maxConcurrency);
+      const batchResults = await Promise.allSettled(batch.map(async ({ model, runtime }) => {
+        const result = await runtime.executeNative(system, messages, tools);
+        return { model, result };
+      }));
+      for (const settled of batchResults) {
+        if (settled.status === "fulfilled") {
+          results.push(settled.value);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Create a new OpenRouterRuntime for a specific model from this ensemble.
+   * Useful for model rotation on retries.
+   */
+  forModel(model) {
+    return new _OpenRouterRuntime({
+      ...this.config,
+      model,
+      ensembleModels: void 0
+    });
+  }
+  /**
+   * Get the next model to try for retry-based rotation.
+   * Cycles through ensemble models based on the attempt number.
+   */
+  getModelForAttempt(attempt) {
+    const models = this.ensembleRuntimes.length > 0 ? this.ensembleRuntimes.map((e) => e.model) : DEFAULT_ENSEMBLE_MODELS;
+    return models[attempt % models.length];
+  }
+  async isAvailable() {
+    return !!this.apiKey;
+  }
+};
+
+// packages/core/dist/runtime/ollama.js
+var DEFAULT_HOST = "http://localhost:11434";
+function resolveHost(explicit) {
+  const fromEnv = process.env.OLLAMA_HOST?.trim();
+  return (explicit && explicit.length > 0 ? explicit : fromEnv) || DEFAULT_HOST;
+}
+function toOllamaMessages(system, messages) {
+  const out = [];
+  if (system)
+    out.push({ role: "system", content: system });
+  for (const msg of messages) {
+    const textParts = [];
+    for (const block of msg.content) {
+      if (block.type === "text")
+        textParts.push(block.text);
+      else if (block.type === "tool_use") {
+        textParts.push(`[tool_call name=${block.name} input=${JSON.stringify(block.input)}]`);
+      } else if (block.type === "tool_result") {
+        out.push({
+          role: "tool",
+          content: block.content,
+          tool_call_id: block.tool_use_id
+        });
+      }
+    }
+    if (textParts.length > 0) {
+      out.push({ role: msg.role, content: textParts.join("\n") });
+    }
+  }
+  return out;
+}
+function toOllamaTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.input_schema
+    }
+  }));
+}
+function parseToolCalls(calls) {
+  if (!calls || calls.length === 0)
+    return [];
+  const blocks = [];
+  for (let i = 0; i < calls.length; i++) {
+    const c = calls[i];
+    let input;
+    if (typeof c.function.arguments === "string") {
+      try {
+        input = JSON.parse(c.function.arguments);
+      } catch {
+        input = { _raw: c.function.arguments };
+      }
+    } else {
+      input = c.function.arguments;
+    }
+    blocks.push({
+      type: "tool_use",
+      // Ollama doesn't return a per-call id, so synthesise one stable
+      // within this turn. Agent dispatch only needs uniqueness per turn.
+      id: `ollama_${Date.now()}_${i}`,
+      name: c.function.name,
+      input
+    });
+  }
+  return blocks;
+}
+var OllamaRuntime = class {
+  type = "ollama";
+  host;
+  model;
+  timeout;
+  temperature;
+  fetchImpl;
+  stream;
+  constructor(opts) {
+    if (!opts.model) {
+      throw new Error("OllamaRuntime requires a model (e.g. 'gemma4:27b').");
+    }
+    this.host = resolveHost(opts.host);
+    this.model = opts.model;
+    this.timeout = opts.timeout;
+    this.temperature = opts.temperature ?? 0.6;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.stream = opts.stream ?? true;
+  }
+  /** Cheap health probe — `/api/tags` is the canonical Ollama liveness check. */
+  async isAvailable() {
+    try {
+      const ctl = new AbortController();
+      const t = setTimeout(() => ctl.abort(), 2e3);
+      const res = await this.fetchImpl(`${this.host}/api/tags`, { signal: ctl.signal });
+      clearTimeout(t);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  /** Legacy text-in/text-out path. Used by stages that haven't migrated to NativeRuntime. */
+  async execute(prompt, _context) {
+    const start = Date.now();
+    try {
+      const body = {
+        model: this.model,
+        messages: [{ role: "user", content: prompt }],
+        stream: false,
+        options: { temperature: this.temperature }
+      };
+      const res = await this.postChat(body);
+      const usage = readUsage2(res);
+      return {
+        output: res.message.content,
+        exitCode: 0,
+        timedOut: false,
+        durationMs: Date.now() - start,
+        usage
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        output: "",
+        exitCode: 1,
+        timedOut: msg.includes("AbortError"),
+        durationMs: Date.now() - start,
+        error: msg
+      };
+    }
+  }
+  async executeNative(system, messages, tools, callbacks) {
+    const start = Date.now();
+    const useStream = this.stream;
+    try {
+      const body = {
+        model: this.model,
+        messages: toOllamaMessages(system, messages),
+        tools: tools.length > 0 ? toOllamaTools(tools) : void 0,
+        stream: useStream,
+        options: { temperature: this.temperature }
+      };
+      const aggregate = useStream ? await this.streamChat(body, callbacks) : await this.postChat(body);
+      const usage = readUsage2(aggregate);
+      if (callbacks?.onUsage && usage)
+        callbacks.onUsage(usage);
+      const content = [];
+      if (aggregate.message.content && aggregate.message.content.trim()) {
+        content.push({ type: "text", text: aggregate.message.content });
+      }
+      const toolBlocks = parseToolCalls(aggregate.message.tool_calls);
+      content.push(...toolBlocks);
+      let stopReason;
+      if (toolBlocks.length > 0)
+        stopReason = "tool_use";
+      else if (aggregate.done_reason === "length")
+        stopReason = "max_tokens";
+      else
+        stopReason = "end_turn";
+      return {
+        content,
+        stopReason,
+        usage,
+        durationMs: Date.now() - start
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: "" }],
+        stopReason: "error",
+        durationMs: Date.now() - start,
+        error: msg
+      };
+    }
+  }
+  async postChat(body) {
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), this.timeout);
+    try {
+      const res = await this.fetchImpl(`${this.host}/api/chat`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: ctl.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Ollama /api/chat returned ${res.status}: ${text.slice(0, 200)}`);
+      }
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Consume Ollama's ND-JSON stream from `/api/chat?stream=true`.
+   *
+   * Behaviour:
+   *  - Each non-terminal frame's `message.content` is treated as a delta and
+   *    forwarded to `callbacks.onDelta("assistant_response", delta)` exactly
+   *    once (no accumulation passed to the callback — 0sec's contract is
+   *    "incremental fragment only", see types.ts:88).
+   *  - The terminal frame (`done: true`) is taken as authoritative for
+   *    `tool_calls`, `done_reason`, and usage stats. Tool-call shape across
+   *    intermediate frames in current Ollama builds is empty/absent, so we
+   *    don't try to stitch partials — we just trust the final frame.
+   *  - The aggregated `message.content` (full assistant text) is returned in
+   *    the synthetic `OllamaChatResponse` so the rest of `executeNative`
+   *    can keep its non-streaming-shape codepath.
+   */
+  async streamChat(body, callbacks) {
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), this.timeout);
+    try {
+      const res = await this.fetchImpl(`${this.host}/api/chat`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: ctl.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Ollama /api/chat returned ${res.status}: ${text.slice(0, 200)}`);
+      }
+      if (!res.body) {
+        return await res.json();
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let aggregateContent = "";
+      let lastModel = "";
+      let lastCreatedAt = "";
+      let finalToolCalls;
+      let doneReason;
+      let promptEvalCount;
+      let evalCount;
+      let totalDuration;
+      let sawDone = false;
+      const processLine = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+          return;
+        let frame;
+        try {
+          frame = JSON.parse(trimmed);
+        } catch {
+          return;
+        }
+        if (frame.model)
+          lastModel = frame.model;
+        if (frame.created_at)
+          lastCreatedAt = frame.created_at;
+        const msg = frame.message;
+        if (msg) {
+          if (typeof msg.content === "string" && msg.content.length > 0) {
+            aggregateContent += msg.content;
+            callbacks?.onDelta?.("assistant_response", msg.content);
+          }
+          if (msg.tool_calls && msg.tool_calls.length > 0) {
+            finalToolCalls = msg.tool_calls;
+          }
+        }
+        if (frame.done) {
+          sawDone = true;
+          if (frame.done_reason)
+            doneReason = frame.done_reason;
+          if (typeof frame.prompt_eval_count === "number")
+            promptEvalCount = frame.prompt_eval_count;
+          if (typeof frame.eval_count === "number")
+            evalCount = frame.eval_count;
+          if (typeof frame.total_duration === "number")
+            totalDuration = frame.total_duration;
+        }
+      };
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        let nl = buffer.indexOf("\n");
+        while (nl !== -1) {
+          const line = buffer.slice(0, nl);
+          buffer = buffer.slice(nl + 1);
+          processLine(line);
+          nl = buffer.indexOf("\n");
+        }
+      }
+      if (buffer.length > 0)
+        processLine(buffer);
+      return {
+        model: lastModel,
+        created_at: lastCreatedAt,
+        message: {
+          role: "assistant",
+          content: aggregateContent,
+          tool_calls: finalToolCalls
+        },
+        done: sawDone,
+        done_reason: doneReason,
+        total_duration: totalDuration,
+        prompt_eval_count: promptEvalCount,
+        eval_count: evalCount
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function readUsage2(res) {
+  const inp = res.prompt_eval_count;
+  const out = res.eval_count;
+  if (typeof inp !== "number" || typeof out !== "number")
+    return void 0;
+  return { inputTokens: inp, outputTokens: out };
+}
+
+// packages/core/dist/runtime/registry.js
+var RUNTIME_REGISTRY = [
+  {
+    type: "claude",
+    command: "claude",
+    description: "Claude Code CLI \u2014 supported local adapter for live target scanning, MCP tool use, and deep analysis",
+    strengths: ["attack", "source-analysis", "report"],
+    supportsSystemPrompt: true
+  },
+  {
+    type: "codex",
+    command: "codex",
+    description: "Codex CLI / direct ChatGPT Codex provider \u2014 full parity across web scans, package audits (npm/pypi/cargo/oci), and source code review (incl. linux-kernel). Set 0SEC_CHATGPT_OAUTH_REFRESH_TOKEN to enable subscription auth without the local CLI binary (#402).",
+    strengths: ["verify", "source-analysis", "discovery"],
+    supportsSystemPrompt: false
+  },
+  {
+    type: "gemini",
+    command: "gemini",
+    description: "Gemini CLI (experimental) \u2014 large context window, good for source analysis and reports",
+    strengths: ["source-analysis", "report", "discovery"],
+    supportsSystemPrompt: false
+  },
+  {
+    type: "ollama",
+    // No external binary — health-checked over HTTP. Field is informational
+    // so detection tools that key off `command` don't crash; the registry
+    // uses `isAvailable()` not `which(command)` for ollama.
+    command: "ollama",
+    description: "Ollama (local) \u2014 Gemma 4 27B via /api/chat with native function-calling. Pairs with `--seed-findings` for full-local hunts. See 0sec#369.",
+    strengths: ["source-analysis", "discovery"],
+    supportsSystemPrompt: true
+  }
+];
+var STAGE_PREFERENCES = {
+  "discovery": ["claude", "codex", "gemini"],
+  "source-analysis": ["claude", "gemini", "codex"],
+  "attack": ["claude", "codex", "gemini"],
+  "verify": ["codex", "claude", "gemini"],
+  "report": ["claude", "gemini", "codex"]
+};
+function pickRuntimeForStage(stage, availableRuntimes) {
+  const prefs = STAGE_PREFERENCES[stage];
+  for (const rt of prefs) {
+    if (availableRuntimes.has(rt))
+      return rt;
+  }
+  const first = availableRuntimes.values().next();
+  return first.done ? "claude" : first.value;
+}
+async function detectAvailableRuntimes() {
+  const { ProcessRuntime: ProcessRuntime2 } = await import("./process-LQRCS5OY.js");
+  const available = /* @__PURE__ */ new Set();
+  const checks = RUNTIME_REGISTRY.map(async (info) => {
+    const rt = new ProcessRuntime2({ type: info.type, timeout: 5e3 });
+    if (await rt.isAvailable()) {
+      available.add(info.type);
+    }
+  });
+  await Promise.all(checks);
+  return available;
+}
+function getRuntimeInfo(type) {
+  return RUNTIME_REGISTRY.find((r) => r.type === type);
+}
+
+// packages/core/dist/runtime/index.js
+function createRuntime(config) {
+  switch (config.type) {
+    case "api":
+      return new LlmApiRuntime(config);
+    case "claude":
+    case "codex":
+    case "gemini":
+      return new ProcessRuntime(config);
+    case "ollama":
+      return new OllamaRuntime({
+        model: config.model ?? process.env["0SEC_OLLAMA_MODEL"] ?? "gemma4:27b",
+        timeout: config.timeout,
+        host: process.env.OLLAMA_HOST
+      });
+  }
+}
+
+export {
+  CliNativeRuntime,
+  DEFAULT_ENSEMBLE_MODELS,
+  OpenRouterRuntime,
+  OllamaRuntime,
+  RUNTIME_REGISTRY,
+  pickRuntimeForStage,
+  detectAvailableRuntimes,
+  getRuntimeInfo,
+  createRuntime
+};