ollama-agent-router 0.1.0

package/dist/cli.js

@@ -0,0 +1,1725 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFile as readFile4 } from "fs/promises";
+import { Command } from "commander";
+
+// src/config.ts
+import { existsSync } from "fs";
+import { access, readFile, writeFile, mkdir } from "fs/promises";
+import { dirname, resolve } from "path";
+import { homedir } from "os";
+import YAML from "yaml";
+import { z } from "zod";
+
+// src/types.ts
+var taskTypes = [
+  "triage",
+  "simple_chat",
+  "summarize",
+  "code_generate",
+  "code_review",
+  "code_fix",
+  "agentic_reasoning",
+  "large_context",
+  "tool_use",
+  "unknown"
+];
+
+// src/config.ts
+var taskTypeSchema = z.enum(taskTypes);
+var optionalStringSchema = z.preprocess((value) => value === null ? void 0 : value, z.string().min(1).optional());
+var modelSpecSchema = z.object({
+  name: z.string().min(1),
+  sizeGb: z.number().positive(),
+  purpose: z.array(z.string()).default([]),
+  priority: z.number().default(50),
+  maxConcurrent: z.number().int().positive(),
+  defaultContext: z.number().int().positive(),
+  maxContext: z.number().int().positive(),
+  timeoutMs: z.number().int().positive(),
+  costClass: z.enum(["low", "medium", "high"]).default("medium"),
+  exclusive: z.boolean().default(false),
+  allowWhenBusy: z.boolean().default(false),
+  tags: z.array(z.string()).default([])
+});
+var appConfigSchema = z.object({
+  server: z.object({
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65535),
+    basePath: z.string().min(1).default("/"),
+    requestBodyLimit: z.string().min(1),
+    https: z.object({
+      enabled: z.boolean().default(false),
+      certPath: optionalStringSchema,
+      keyPath: optionalStringSchema,
+      caPath: optionalStringSchema
+    }).default({ enabled: false })
+  }),
+  ollama: z.object({
+    baseUrl: z.string().url(),
+    openAiCompatiblePath: z.string().min(1).default("/v1/chat/completions"),
+    nativeApiBasePath: z.string().min(1).default("/api"),
+    keepAlive: z.string().default("5m"),
+    requestTimeoutMs: z.number().int().positive()
+  }),
+  gpu: z.object({
+    provider: z.enum(["none", "nvidia"]).default("none"),
+    name: z.string().optional(),
+    vramTotalMb: z.number().nonnegative(),
+    vramSafetyReserveMb: z.number().nonnegative(),
+    maxGpuUtilizationPct: z.number().min(1).max(100),
+    requireGpuOnlyByDefault: z.boolean().default(false),
+    monitor: z.object({
+      enabled: z.boolean().default(false),
+      intervalMs: z.number().int().positive(),
+      nvidiaSmiPath: z.string().min(1).default("nvidia-smi")
+    })
+  }),
+  router: z.object({
+    defaultMode: z.enum(["auto", "sync", "async"]).default("auto"),
+    syncMaxQueueTimeMs: z.number().int().nonnegative(),
+    heavyLoadQueueDepth: z.number().int().nonnegative(),
+    heavyLoadGpuFreeMbThreshold: z.number().int().nonnegative(),
+    defaultTaskType: taskTypeSchema.default("unknown"),
+    classification: z.object({
+      mode: z.enum(["heuristic", "model"]).default("heuristic"),
+      optionalClassifierModel: z.string().optional(),
+      classifierTimeoutMs: z.number().int().positive()
+    })
+  }),
+  jobs: z.object({
+    store: z.literal("memory").default("memory"),
+    resultTtlSeconds: z.number().int().positive(),
+    maxAttempts: z.number().int().positive(),
+    cleanupIntervalMs: z.number().int().positive()
+  }),
+  models: z.array(modelSpecSchema).min(1),
+  routes: z.record(z.string(), z.array(z.string())),
+  queue: z.object({
+    globalMaxConcurrent: z.number().int().positive(),
+    globalMaxQueued: z.number().int().nonnegative(),
+    perUserMaxQueued: z.number().int().nonnegative(),
+    defaultPriority: z.enum(["low", "normal", "high"]).default("normal"),
+    timeoutMs: z.number().int().positive()
+  })
+});
+var configLookupOrder = (explicitPath) => {
+  const paths = [
+    "./ollama-agent-router.yaml",
+    `${homedir()}/.config/ollama-agent-router/config.yaml`,
+    "/etc/ollama-agent-router/config.yaml"
+  ];
+  return explicitPath ? [explicitPath, ...paths] : paths;
+};
+async function findConfigPath(explicitPath) {
+  for (const candidate of configLookupOrder(explicitPath)) {
+    const path = resolve(candidate);
+    try {
+      await access(path);
+      return path;
+    } catch {
+    }
+  }
+  throw new Error(`No config file found. Tried: ${configLookupOrder(explicitPath).join(", ")}`);
+}
+async function loadConfig(explicitPath) {
+  const path = await findConfigPath(explicitPath);
+  const raw = await readFile(path, "utf8");
+  return { path, config: parseConfig(raw) };
+}
+function parseConfig(raw) {
+  const parsed = YAML.parse(raw);
+  const config = appConfigSchema.parse(parsed);
+  if (config.server.https.enabled && (!config.server.https.certPath || !config.server.https.keyPath)) {
+    throw new Error("server.https.certPath and server.https.keyPath are required when HTTPS is enabled");
+  }
+  const modelNames = new Set(config.models.map((model) => model.name));
+  const missingRoutes = Object.entries(config.routes).flatMap(([taskType, names]) => (names ?? []).map((name) => ({ taskType, name }))).filter(({ name }) => !modelNames.has(name));
+  if (missingRoutes.length > 0) {
+    const formatted = missingRoutes.map((route) => `${route.taskType}:${route.name}`).join(", ");
+    throw new Error(`Routes reference unknown models: ${formatted}`);
+  }
+  return config;
+}
+async function writeDefaultConfig(path) {
+  const target = resolve(path);
+  if (existsSync(target)) {
+    throw new Error(`Refusing to overwrite existing config: ${target}`);
+  }
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, defaultConfigYaml, "utf8");
+}
+var defaultConfigYaml = `server:
+  host: 127.0.0.1
+  port: 11435
+  basePath: /
+  requestBodyLimit: 4mb
+  https:
+    enabled: false
+    certPath:
+    keyPath:
+    caPath:
+ollama:
+  baseUrl: http://127.0.0.1:11434
+  openAiCompatiblePath: /v1/chat/completions
+  nativeApiBasePath: /api
+  keepAlive: 5m
+  requestTimeoutMs: 120000
+gpu:
+  provider: none
+  name: Local GPU
+  vramTotalMb: 0
+  vramSafetyReserveMb: 1024
+  maxGpuUtilizationPct: 95
+  requireGpuOnlyByDefault: false
+  monitor:
+    enabled: false
+    intervalMs: 5000
+    nvidiaSmiPath: nvidia-smi
+router:
+  defaultMode: auto
+  syncMaxQueueTimeMs: 250
+  heavyLoadQueueDepth: 4
+  heavyLoadGpuFreeMbThreshold: 2048
+  defaultTaskType: unknown
+  classification:
+    mode: heuristic
+    optionalClassifierModel:
+    classifierTimeoutMs: 1500
+jobs:
+  store: memory
+  resultTtlSeconds: 86400
+  maxAttempts: 2
+  cleanupIntervalMs: 60000
+models:
+  - name: llama3.2:3b
+    sizeGb: 2.0
+    purpose: [simple_chat, summarize, triage]
+    priority: 50
+    maxConcurrent: 1
+    defaultContext: 4096
+    maxContext: 8192
+    timeoutMs: 120000
+    costClass: low
+    exclusive: false
+    allowWhenBusy: true
+    tags: [general]
+routes:
+  triage: [llama3.2:3b]
+  simple_chat: [llama3.2:3b]
+  summarize: [llama3.2:3b]
+  code_generate: [llama3.2:3b]
+  code_review: [llama3.2:3b]
+  code_fix: [llama3.2:3b]
+  agentic_reasoning: [llama3.2:3b]
+  large_context: [llama3.2:3b]
+  tool_use: [llama3.2:3b]
+  unknown: [llama3.2:3b]
+queue:
+  globalMaxConcurrent: 2
+  globalMaxQueued: 100
+  perUserMaxQueued: 20
+  defaultPriority: normal
+  timeoutMs: 120000
+`;
+
+// src/configurator.ts
+import { access as access2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { constants } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import os from "os";
+import YAML2 from "yaml";
+import { z as z2 } from "zod";
+
+// src/gpu.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var StaticGpuMonitor = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async snapshot() {
+    if (this.config.provider === "none") return void 0;
+    return {
+      name: this.config.name ?? "Configured GPU",
+      vramTotalMb: this.config.vramTotalMb,
+      vramUsedMb: 0,
+      vramFreeMb: this.config.vramTotalMb,
+      utilizationPct: 0
+    };
+  }
+};
+var NvidiaGpuMonitor = class {
+  constructor(config, commandRunner = defaultCommandRunner) {
+    this.config = config;
+    this.commandRunner = commandRunner;
+  }
+  config;
+  commandRunner;
+  async snapshot() {
+    if (!this.config.monitor.enabled || this.config.provider !== "nvidia") {
+      return new StaticGpuMonitor(this.config).snapshot();
+    }
+    const args = [
+      "--query-gpu=name,memory.total,memory.used,memory.free,utilization.gpu",
+      "--format=csv,noheader,nounits"
+    ];
+    const { stdout } = await this.commandRunner(this.config.monitor.nvidiaSmiPath, args);
+    return parseNvidiaSmi(stdout)[0];
+  }
+};
+function parseNvidiaSmi(output2) {
+  return output2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [name, total, used, free, utilization] = line.split(",").map((part) => part.trim());
+    return {
+      name,
+      vramTotalMb: Number(total),
+      vramUsedMb: Number(used),
+      vramFreeMb: Number(free),
+      utilizationPct: Number(utilization)
+    };
+  }).filter((gpu) => gpu.name && Number.isFinite(gpu.vramTotalMb));
+}
+async function defaultCommandRunner(command, args) {
+  const { stdout } = await execFileAsync(command, args, { timeout: 5e3 });
+  return { stdout };
+}
+
+// src/ollama.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var HttpOllamaClient = class {
+  constructor(config, commandRunner = defaultCommandRunner2) {
+    this.config = config;
+    this.commandRunner = commandRunner;
+  }
+  config;
+  commandRunner;
+  async chat(request, model, timeoutMs = this.config.requestTimeoutMs) {
+    const url = new URL(this.config.openAiCompatiblePath, this.config.baseUrl);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const body = { ...request, model };
+    delete body.router;
+    if (!("stream" in body)) body.stream = false;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const payload = await safeJson(response);
+      if (!response.ok) {
+        throw new OllamaHttpError(response.status, payload);
+      }
+      return payload;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async tags() {
+    const response = await fetch(new URL(`${this.config.nativeApiBasePath}/tags`, this.config.baseUrl));
+    const payload = await safeJson(response);
+    if (!response.ok) throw new OllamaHttpError(response.status, payload);
+    return payload;
+  }
+  async ps() {
+    try {
+      const { stdout } = await this.commandRunner("ollama", ["ps"]);
+      return parseOllamaPs(stdout);
+    } catch {
+      return [];
+    }
+  }
+};
+var OllamaHttpError = class extends Error {
+  constructor(statusCode, payload) {
+    super(`Ollama HTTP request failed with status ${statusCode}`);
+    this.statusCode = statusCode;
+    this.payload = payload;
+  }
+  statusCode;
+  payload;
+};
+function parseOllamaPs(output2) {
+  const lines = output2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length <= 1) return [];
+  return lines.slice(1).map((line) => {
+    const parts = line.split(/\s{2,}/).filter(Boolean);
+    if (parts.length >= 5) {
+      return {
+        name: parts[0],
+        id: parts[1],
+        size: parts[2],
+        processor: parts[3],
+        until: parts.slice(4).join(" ")
+      };
+    }
+    const fallback = line.match(/^(\S+)\s+(\S+)\s+(.+?)\s+((?:\d+%\s+)?(?:GPU|CPU)(?:\/GPU)?)\s+(.+)$/i);
+    if (fallback) {
+      return {
+        name: fallback[1],
+        id: fallback[2],
+        size: fallback[3].trim(),
+        processor: fallback[4].trim(),
+        until: fallback[5].trim()
+      };
+    }
+    return { name: parts[0] ?? line };
+  });
+}
+async function safeJson(response) {
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+async function defaultCommandRunner2(command, args) {
+  const { stdout } = await execFileAsync2(command, args, { timeout: 5e3 });
+  return { stdout };
+}
+
+// src/configurator.ts
+var execFileAsync3 = promisify3(execFile3);
+var answersSchema = z2.object({
+  server: z2.record(z2.unknown()).optional(),
+  ollama: z2.record(z2.unknown()).optional(),
+  gpu: z2.record(z2.unknown()).optional(),
+  router: z2.record(z2.unknown()).optional(),
+  jobs: z2.record(z2.unknown()).optional(),
+  queue: z2.record(z2.unknown()).optional(),
+  models: z2.object({
+    mode: z2.enum(["detected", "manual"]).optional(),
+    items: z2.array(z2.record(z2.unknown())).optional()
+  }).optional(),
+  routes: z2.record(z2.array(z2.string())).optional()
+});
+var coreTaskTypes = [
+  "triage",
+  "simple_chat",
+  "summarize",
+  "code_generate",
+  "code_review",
+  "code_fix",
+  "agentic_reasoning",
+  "large_context",
+  "tool_use",
+  "unknown"
+];
+async function runConfigure(options) {
+  const detection = await detectEnvironment(options);
+  if (options.detectOnly) {
+    emit(options, `${formatDetectionSummary(detection)}
+`);
+    return;
+  }
+  const answers = options.answersPath ? await loadAnswers(options.answersPath) : {};
+  const config = options.nonInteractive ? generateConfigFromDetection(detection, answers) : await promptForConfig(detection, answers, options);
+  const yaml = serializeConfig(config);
+  parseConfig(yaml);
+  emit(options, `${formatConfigSummary(config, detection, options.outputPath)}
+`);
+  if (options.dryRun) {
+    emit(options, `${yaml}
+`);
+    return;
+  }
+  if (!options.overwrite && await fileExists(options.outputPath)) {
+    throw new Error(`Refusing to overwrite existing config: ${options.outputPath}`);
+  }
+  await mkdir2(dirname2(resolve2(options.outputPath)), { recursive: true });
+  await writeFile2(options.outputPath, yaml, "utf8");
+  emit(options, `Wrote ${options.outputPath}
+`);
+}
+async function detectEnvironment(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const env = options.env ?? process.env;
+  const commandRunner = options.commandRunner ?? defaultCommandRunner3;
+  const pathLookup = options.pathLookup ?? findExecutable;
+  const machine = detectMachine(platform, arch, options);
+  const ollamaBinary = await detectOllamaBinary(platform, env, pathLookup);
+  const ollamaBaseUrl = detectOllamaBaseUrl(env);
+  const ollamaReachable = await detectOllamaReachable(ollamaBaseUrl.value, options.fetchImpl ?? fetch);
+  const ollamaModels = await detectOllamaModels(ollamaBinary.value, commandRunner);
+  const loadedModels = await detectLoadedModels(ollamaBinary.value, commandRunner);
+  const nvidiaSmiPath = platform === "darwin" ? notFound("nvidia-smi is normally unavailable on macOS") : await detectNvidiaSmi(platform, env, pathLookup);
+  const gpu = await detectGpu(platform, arch, nvidiaSmiPath.value, commandRunner);
+  return {
+    ollamaBinary,
+    ollamaBaseUrl,
+    ollamaReachable,
+    ollamaModels,
+    loadedModels,
+    nvidiaSmiPath,
+    gpu,
+    machine
+  };
+}
+function generateConfigFromDetection(detection, answers = {}) {
+  const machine = detection.machine.value ?? detectMachine(process.platform, process.arch, {}).value;
+  const gpu = mergeGpu(detection.gpu.value ?? defaultGpuForPlatform(machine.platform, machine.arch), answers.gpu);
+  const cpuOnly = gpu.provider === "none";
+  const detectedModels = detection.ollamaModels.value ?? [];
+  const models = buildModels(detectedModels, answers.models, cpuOnly);
+  if (models.length === 0) {
+    throw new Error("No models detected or provided. Add at least one model to generate a config.");
+  }
+  const routes = ensureCoreRoutes({ ...generateRoutes(models), ...answers.routes ?? {} }, models);
+  const queue = {
+    ...defaultQueue(machine, models, cpuOnly),
+    ...answers.queue ?? {}
+  };
+  const httpsAnswer = answers.server?.https;
+  const serverHttps = typeof httpsAnswer === "boolean" ? { enabled: httpsAnswer } : { enabled: false, ...httpsAnswer ?? {} };
+  const config = {
+    server: {
+      host: "127.0.0.1",
+      port: 11435,
+      basePath: "/",
+      requestBodyLimit: "8mb",
+      https: serverHttps,
+      ...omit(answers.server ?? {}, ["https"])
+    },
+    ollama: {
+      baseUrl: detection.ollamaBaseUrl.value ?? "http://127.0.0.1:11434",
+      openAiCompatiblePath: "/v1/chat/completions",
+      nativeApiBasePath: "/api",
+      keepAlive: "10m",
+      requestTimeoutMs: 18e4,
+      ...answers.ollama ?? {}
+    },
+    gpu,
+    router: {
+      defaultMode: "auto",
+      syncMaxQueueTimeMs: cpuOnly ? 100 : 250,
+      heavyLoadQueueDepth: cpuOnly ? 1 : models.some((model) => model.exclusive) ? 3 : 4,
+      heavyLoadGpuFreeMbThreshold: gpu.provider === "nvidia" ? Math.max(2048, gpu.vramSafetyReserveMb * 2) : 1024,
+      defaultTaskType: "unknown",
+      classification: {
+        mode: "heuristic",
+        optionalClassifierModel: models.find((model) => model.costClass === "low")?.name,
+        classifierTimeoutMs: 1500
+      },
+      ...answers.router ?? {}
+    },
+    jobs: {
+      store: "memory",
+      resultTtlSeconds: 86400,
+      maxAttempts: 2,
+      cleanupIntervalMs: 6e4,
+      ...answers.jobs ?? {}
+    },
+    models,
+    routes,
+    queue
+  };
+  return parseConfig(serializeConfig(config));
+}
+function parseOllamaList(outputText) {
+  const lines = outputText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length <= 1) return [];
+  return lines.slice(1).map((line) => {
+    const wideParts = line.split(/\s{2,}/).filter(Boolean);
+    const parts = wideParts.length >= 3 ? wideParts : line.split(/\s+/).filter(Boolean);
+    const [name, id] = parts;
+    const size = wideParts.length >= 3 ? parts[2] : [parts[2], parts[3]].filter(Boolean).join(" ");
+    const modified = wideParts.length >= 3 ? parts[3] : parts.slice(4).join(" ");
+    return {
+      name: name ?? line,
+      id,
+      size,
+      sizeGb: parseSizeGb(size),
+      modified: modified || void 0
+    };
+  });
+}
+function inferModelRole(model) {
+  const name = model.name.toLowerCase();
+  if (name.includes("review")) return "review";
+  if (name.includes("coder") || name.includes("code") || name.includes("deepseek") || name.includes("qwen")) return "code";
+  if ((model.sizeGb ?? 0) >= 12 || name.includes("gpt-oss") || name.includes("reason")) return "heavy";
+  if (name.includes("tool")) return "tool";
+  return "fast";
+}
+function serializeConfig(config) {
+  return YAML2.stringify(config, { lineWidth: 0 });
+}
+function formatDetectionSummary(detection) {
+  const machine = detection.machine.value;
+  const gpu = detection.gpu.value;
+  return [
+    "Detected environment",
+    "",
+    "Ollama:",
+    `  binary: ${detection.ollamaBinary.value ?? "not found"} (${detection.ollamaBinary.source}, ${detection.ollamaBinary.confidence})`,
+    `  base URL: ${detection.ollamaBaseUrl.value ?? "not detected"} (${detection.ollamaBaseUrl.source})`,
+    `  reachable: ${detection.ollamaReachable.value === true ? "yes" : "no"}`,
+    `  models: ${detection.ollamaModels.value?.length ?? 0} found`,
+    "",
+    "GPU:",
+    `  provider: ${gpu?.provider ?? "none"}`,
+    `  name: ${gpu?.name ?? "not detected"}`,
+    `  VRAM: ${gpu?.vramTotalMb ?? 0} MB`,
+    `  monitor: ${gpu?.monitor.enabled ? `enabled through ${gpu.monitor.nvidiaSmiPath}` : "disabled"}`,
+    "",
+    "Machine:",
+    `  OS: ${machine?.platform ?? process.platform} ${machine?.arch ?? process.arch}`,
+    `  CPU cores: ${machine?.cpuCores ?? os.cpus().length}`,
+    `  RAM: ${machine?.totalMemoryMb ?? Math.round(os.totalmem() / 1024 / 1024)} MB`
+  ].join("\n");
+}
+function formatConfigSummary(config, detection, outputPath) {
+  const protocol = config.server.https.enabled ? "https" : "http";
+  const basePath = config.server.basePath === "/" ? "/" : config.server.basePath;
+  return [
+    "",
+    "Configuration summary",
+    "",
+    `Output: ${outputPath}`,
+    `Server: ${protocol}://${config.server.host}:${config.server.port}${basePath}`,
+    `Ollama: ${config.ollama.baseUrl}`,
+    `GPU: ${config.gpu.provider}${config.gpu.name ? `, ${config.gpu.name}` : ""}, ${config.gpu.vramTotalMb} MB VRAM`,
+    `Models: ${config.models.length} configured`,
+    `Heavy model: ${config.models.find((model) => model.exclusive)?.name ?? "none"}`,
+    `Queue: global concurrency ${config.queue.globalMaxConcurrent}, max queued ${config.queue.globalMaxQueued}`,
+    `Jobs: ${config.jobs.store} store, result TTL ${config.jobs.resultTtlSeconds}s`,
+    "",
+    "Detected:",
+    `  Ollama models: ${detection.ollamaModels.value?.length ?? 0}`,
+    `  Machine: ${detection.machine.value?.platform ?? process.platform} ${detection.machine.value?.arch ?? process.arch}`,
+    ""
+  ].join("\n");
+}
+async function promptForConfig(detection, answers, options) {
+  const rl = createInterface({ input, output });
+  try {
+    output.write(`${formatDetectionSummary(detection)}
+
+`);
+    const useDetected = options.assumeYes || await confirm(rl, "Use these detected values?", true);
+    let mergedAnswers = answers;
+    if (!useDetected) {
+      mergedAnswers = await promptCorrections(rl, detection, answers);
+    }
+    const config = generateConfigFromDetection(detection, mergedAnswers);
+    if (!options.assumeYes && !await confirm(rl, "Write this config?", true)) {
+      throw new Error("Configuration cancelled");
+    }
+    return config;
+  } finally {
+    rl.close();
+  }
+}
+async function promptCorrections(rl, detection, answers) {
+  const baseUrl = await ask(rl, "Ollama base URL", detection.ollamaBaseUrl.value ?? "http://127.0.0.1:11434");
+  const host = await ask(rl, "Server host", "127.0.0.1");
+  const port = Number(await ask(rl, "Server port", "11435"));
+  const basePath = await ask(rl, "Server base path", "/");
+  const gpu = detection.gpu.value ?? defaultGpuForPlatform(process.platform, process.arch);
+  const vramTotalMb = Number(await ask(rl, "GPU VRAM total MB", String(gpu.vramTotalMb)));
+  const models = detection.ollamaModels.value?.length ? void 0 : {
+    mode: "manual",
+    items: [
+      {
+        name: await ask(rl, "First Ollama model name", "llama3.2:3b"),
+        role: "fast",
+        sizeGb: Number(await ask(rl, "First model size GB", "2"))
+      }
+    ]
+  };
+  return {
+    ...answers,
+    server: { ...answers.server ?? {}, host, port, basePath },
+    ollama: { ...answers.ollama ?? {}, baseUrl },
+    gpu: { ...answers.gpu ?? {}, vramTotalMb },
+    models: answers.models ?? models
+  };
+}
+async function loadAnswers(path) {
+  const raw = await readFile2(path, "utf8");
+  const parsed = answersSchema.parse(YAML2.parse(raw));
+  return parsed;
+}
+async function detectOllamaBinary(platform, env, pathLookup) {
+  const pathResult = await pathLookup("ollama", platform, env);
+  if (pathResult) return { value: pathResult, source: "command", confidence: "high" };
+  const candidates = platform === "darwin" ? ["/opt/homebrew/bin/ollama", "/usr/local/bin/ollama", "/Applications/Ollama.app/Contents/Resources/ollama"] : ["/usr/bin/ollama", "/usr/local/bin/ollama", "/snap/bin/ollama"];
+  for (const candidate of candidates) {
+    if (await executableExists(candidate)) return { value: candidate, source: "command", confidence: "medium" };
+  }
+  return notFound("ollama binary not found");
+}
+function detectOllamaBaseUrl(env) {
+  if (env.OLLAMA_HOST) return { value: normalizeOllamaHost(env.OLLAMA_HOST), source: "env", confidence: "high" };
+  return { value: "http://127.0.0.1:11434", source: "default", confidence: "medium" };
+}
+async function detectOllamaReachable(baseUrl, fetchImpl) {
+  if (!baseUrl) return notFound("ollama base URL is unknown");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 700);
+  try {
+    const response = await fetchImpl(new URL("/api/tags", baseUrl), { signal: controller.signal });
+    return { value: response.ok, source: "command", confidence: response.ok ? "high" : "low" };
+  } catch {
+    return { value: false, source: "not_found", confidence: "low", message: "Ollama API did not respond" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function detectOllamaModels(ollamaBinary, commandRunner) {
+  if (!ollamaBinary) return notFound("ollama binary not found");
+  try {
+    const { stdout } = await commandRunner(ollamaBinary, ["list"]);
+    return { value: parseOllamaList(stdout), source: "command", confidence: "high" };
+  } catch {
+    return { value: [], source: "not_found", confidence: "low", message: "ollama list failed" };
+  }
+}
+async function detectLoadedModels(ollamaBinary, commandRunner) {
+  if (!ollamaBinary) return notFound("ollama binary not found");
+  try {
+    const { stdout } = await commandRunner(ollamaBinary, ["ps"]);
+    return { value: parseOllamaPs(stdout), source: "command", confidence: "high" };
+  } catch {
+    return { value: [], source: "not_found", confidence: "low", message: "ollama ps failed" };
+  }
+}
+async function detectNvidiaSmi(platform, env, pathLookup) {
+  const found = await pathLookup("nvidia-smi", platform, env);
+  return found ? { value: found, source: "command", confidence: "high" } : notFound("nvidia-smi not found");
+}
+async function detectGpu(platform, arch, nvidiaSmiPath, commandRunner) {
+  if (platform === "darwin") {
+    return { value: defaultGpuForPlatform(platform, arch), source: "default", confidence: arch === "arm64" ? "medium" : "low" };
+  }
+  if (!nvidiaSmiPath) {
+    return { value: defaultGpuForPlatform(platform, arch), source: "not_found", confidence: "medium" };
+  }
+  try {
+    const { stdout } = await commandRunner(nvidiaSmiPath, [
+      "--query-gpu=name,memory.total,memory.used,memory.free,utilization.gpu",
+      "--format=csv,noheader,nounits"
+    ]);
+    const gpu = parseNvidiaSmi(stdout)[0];
+    if (!gpu) return { value: defaultGpuForPlatform(platform, arch), source: "not_found", confidence: "low" };
+    return {
+      value: {
+        provider: "nvidia",
+        name: gpu.name,
+        vramTotalMb: gpu.vramTotalMb,
+        vramSafetyReserveMb: safetyReserveMb(gpu.vramTotalMb),
+        maxGpuUtilizationPct: 92,
+        requireGpuOnlyByDefault: true,
+        monitor: {
+          enabled: true,
+          intervalMs: 5e3,
+          nvidiaSmiPath
+        }
+      },
+      source: "command",
+      confidence: "high"
+    };
+  } catch {
+    return { value: defaultGpuForPlatform(platform, arch), source: "not_found", confidence: "low" };
+  }
+}
+function detectMachine(platform, arch, options) {
+  const totalMemoryMb = options.totalMemoryMb ?? Math.round(os.totalmem() / 1024 / 1024);
+  const cpuCores = options.cpuCores ?? os.cpus().length;
+  return {
+    value: {
+      platform,
+      arch,
+      cpuCores,
+      totalMemoryMb,
+      class: totalMemoryMb < 16384 || cpuCores < 4 ? "small" : totalMemoryMb > 65536 || cpuCores > 16 ? "large" : "medium"
+    },
+    source: "command",
+    confidence: "high"
+  };
+}
+function buildModels(detectedModels, answers, cpuOnly = false) {
+  const source = answers?.mode === "manual" ? answers.items ?? [] : answers?.items ?? detectedModels;
+  return source.filter((model) => Boolean(model.name)).map(
+    (model) => buildModelSpec(
+      model.name,
+      model.role ?? inferModelRole(model),
+      Number(model.sizeGb ?? 2),
+      cpuOnly
+    )
+  );
+}
+function buildModelSpec(name, role, sizeGb, cpuOnly) {
+  const heavy = role === "heavy";
+  const code = role === "code" || role === "review" || role === "tool";
+  const naturalMaxConcurrent = heavy ? 1 : role === "fast" ? 2 : 1;
+  return {
+    name,
+    sizeGb,
+    purpose: purposesForRole(role),
+    priority: heavy ? 95 : code ? 70 : 50,
+    maxConcurrent: cpuOnly ? 1 : naturalMaxConcurrent,
+    defaultContext: heavy ? 16384 : code ? 8192 : 4096,
+    maxContext: heavy ? 65536 : code ? 32768 : 8192,
+    timeoutMs: heavy ? 3e5 : code ? 18e4 : 9e4,
+    costClass: heavy ? "high" : code ? "medium" : "low",
+    exclusive: heavy,
+    allowWhenBusy: !heavy,
+    tags: tagsForRole(role)
+  };
+}
+function purposesForRole(role) {
+  switch (role) {
+    case "code":
+      return ["code_generate", "code_fix", "tool_use"];
+    case "review":
+      return ["code_review", "code_generate", "code_fix"];
+    case "heavy":
+      return ["agentic_reasoning", "large_context", "planning", "tool_use"];
+    case "tool":
+      return ["tool_use", "code_generate"];
+    case "fast":
+    default:
+      return ["triage", "simple_chat", "summarize"];
+  }
+}
+function tagsForRole(role) {
+  switch (role) {
+    case "code":
+      return ["code", "fallback"];
+    case "review":
+      return ["code", "review"];
+    case "heavy":
+      return ["reasoning", "large_context"];
+    case "tool":
+      return ["tool_use"];
+    case "fast":
+    default:
+      return ["fast", "chat"];
+  }
+}
+function generateRoutes(models) {
+  const fast = models.filter((model) => model.costClass === "low").map((model) => model.name);
+  const code = models.filter((model) => model.purpose.includes("code_generate")).map((model) => model.name);
+  const review = models.filter((model) => model.purpose.includes("code_review")).map((model) => model.name);
+  const heavy = models.filter((model) => model.exclusive || model.costClass === "high").map((model) => model.name);
+  const tool = models.filter((model) => model.purpose.includes("tool_use")).map((model) => model.name);
+  const fallback = [...fast, ...code, ...models.map((model) => model.name)];
+  return {
+    triage: firstNonEmpty(fast, fallback),
+    simple_chat: firstNonEmpty(fast, fallback),
+    summarize: firstNonEmpty(fast, fallback),
+    code_generate: firstNonEmpty(code, fallback),
+    code_review: firstNonEmpty(review, code, fallback),
+    code_fix: firstNonEmpty(code, review, fallback),
+    agentic_reasoning: firstNonEmpty(heavy, code, fallback),
+    large_context: firstNonEmpty(heavy, code, fallback),
+    tool_use: firstNonEmpty(tool, code, heavy, fallback),
+    unknown: firstNonEmpty(fast, code, fallback)
+  };
+}
+function ensureCoreRoutes(routes, models) {
+  const fallback = [models[0].name];
+  return Object.fromEntries(coreTaskTypes.map((taskType) => [taskType, routes[taskType]?.length ? routes[taskType] : fallback]));
+}
+function defaultQueue(machine, models, cpuOnly = false) {
+  const maxByModels = models.reduce((sum, model) => sum + model.maxConcurrent, 0);
+  const suggested = cpuOnly ? 1 : machine.class === "small" ? 1 : machine.class === "large" ? 4 : 3;
+  return {
+    globalMaxConcurrent: Math.max(1, Math.min(maxByModels, suggested)),
+    globalMaxQueued: cpuOnly || machine.class === "small" ? 50 : 100,
+    perUserMaxQueued: cpuOnly || machine.class === "small" ? 10 : 20,
+    defaultPriority: "normal",
+    timeoutMs: 18e4
+  };
+}
+function mergeGpu(base, override) {
+  return {
+    ...base,
+    ...override ?? {},
+    monitor: {
+      ...base.monitor,
+      ...override?.monitor ?? {}
+    }
+  };
+}
+function defaultGpuForPlatform(platform, arch) {
+  const mac = platform === "darwin";
+  return {
+    provider: "none",
+    name: mac && arch === "arm64" ? "Apple Silicon / macOS GPU" : mac ? "macOS GPU" : "No NVIDIA GPU detected",
+    vramTotalMb: 0,
+    vramSafetyReserveMb: 1024,
+    maxGpuUtilizationPct: 95,
+    requireGpuOnlyByDefault: false,
+    monitor: {
+      enabled: false,
+      intervalMs: 5e3,
+      nvidiaSmiPath: "nvidia-smi"
+    }
+  };
+}
+function safetyReserveMb(totalMb) {
+  if (totalMb < 8192) return 1024;
+  if (totalMb <= 24576) return 1536;
+  return 2048;
+}
+function firstNonEmpty(...lists) {
+  return lists.find((list) => list.length > 0) ?? [];
+}
+function parseSizeGb(size) {
+  if (!size) return void 0;
+  const match = size.match(/([\d.]+)\s*([kmgt]i?b|[kmgt]b)?/i);
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  const unit = (match[2] ?? "GB").toLowerCase();
+  if (!Number.isFinite(value)) return void 0;
+  if (unit.startsWith("m")) return value / 1024;
+  if (unit.startsWith("k")) return value / 1024 / 1024;
+  if (unit.startsWith("t")) return value * 1024;
+  return value;
+}
+function normalizeOllamaHost(host) {
+  if (host.startsWith("http://") || host.startsWith("https://")) return host;
+  return `http://${host}`;
+}
+async function findExecutable(command, _platform, env) {
+  const pathValue = env.PATH ?? "";
+  for (const entry of pathValue.split(":").filter(Boolean)) {
+    const candidate = resolve2(entry, command);
+    if (await executableExists(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function executableExists(path) {
+  try {
+    await access2(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultCommandRunner3(command, args) {
+  const { stdout, stderr } = await execFileAsync3(command, args, { timeout: 5e3 });
+  return { stdout, stderr };
+}
+function notFound(message) {
+  return { source: "not_found", confidence: "low", message };
+}
+async function confirm(rl, question, defaultValue) {
+  const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+  const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+  if (!answer) return defaultValue;
+  return answer === "y" || answer === "yes";
+}
+async function ask(rl, question, defaultValue) {
+  const answer = await rl.question(`${question} (${defaultValue}): `);
+  return answer.trim() || defaultValue;
+}
+function omit(value, keys) {
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !keys.includes(key)));
+}
+function emit(options, text) {
+  if (!options.silent) output.write(text);
+}
+async function fileExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/job-store.ts
+import { nanoid } from "nanoid";
+var InMemoryJobStore = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  jobs = /* @__PURE__ */ new Map();
+  create(input2) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: `job_${nanoid(16)}`,
+      status: "queued",
+      task_type: input2.taskType,
+      selected_model: input2.selectedModel,
+      request_json: JSON.stringify(input2.request),
+      result_json: null,
+      error_json: null,
+      attempts: 0,
+      priority: input2.priority,
+      created_at: now.toISOString(),
+      started_at: null,
+      finished_at: null,
+      expires_at: new Date(now.getTime() + this.config.resultTtlSeconds * 1e3).toISOString()
+    };
+    this.jobs.set(record.id, record);
+    return { ...record };
+  }
+  get(id) {
+    const job = this.jobs.get(id);
+    return job ? { ...job } : void 0;
+  }
+  list(limit = 50) {
+    return [...this.jobs.values()].sort((a, b) => b.created_at.localeCompare(a.created_at)).slice(0, limit).map((job) => ({ ...job }));
+  }
+  markRunning(id) {
+    const job = this.jobs.get(id);
+    if (!job || job.status !== "queued" && job.status !== "running") return this.get(id);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    job.status = "running";
+    job.started_at ??= now;
+    job.attempts += 1;
+    return this.get(id);
+  }
+  markSucceeded(id, result) {
+    this.finish(id, "succeeded", JSON.stringify(result), null);
+    return this.get(id);
+  }
+  markFailed(id, error) {
+    this.finish(id, "failed", null, JSON.stringify(normalizeError(error)));
+    return this.get(id);
+  }
+  cancel(id) {
+    const job = this.jobs.get(id);
+    if (!job) return void 0;
+    if (job.status === "queued" || job.status === "running") {
+      job.status = "cancelled";
+      job.finished_at = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return this.get(id);
+  }
+  cleanupExpired(now = /* @__PURE__ */ new Date()) {
+    let changed = 0;
+    for (const job of this.jobs.values()) {
+      if (job.expires_at && job.expires_at < now.toISOString() && ["queued", "running", "succeeded", "failed"].includes(job.status)) {
+        job.status = "expired";
+        changed += 1;
+      }
+    }
+    return changed;
+  }
+  close() {
+    this.jobs.clear();
+  }
+  finish(id, status, resultJson, errorJson) {
+    const job = this.jobs.get(id);
+    if (!job || job.status !== "queued" && job.status !== "running") return;
+    job.status = status;
+    job.result_json = resultJson;
+    job.error_json = errorJson;
+    job.finished_at = (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+function parseJobResult(job) {
+  if (!job.result_json) return void 0;
+  return JSON.parse(job.result_json);
+}
+function parseJobError(job) {
+  if (!job.error_json) return void 0;
+  return JSON.parse(job.error_json);
+}
+function normalizeError(error) {
+  if (error instanceof Error) {
+    return { message: error.message, name: error.name, stack: error.stack };
+  }
+  return { message: String(error), value: error };
+}
+
+// src/queue-manager.ts
+import PQueue from "p-queue";
+var QueueManager = class {
+  constructor(config, ollama, jobs) {
+    this.config = config;
+    this.ollama = ollama;
+    this.jobs = jobs;
+    for (const model of config.models) {
+      this.queues.set(model.name, new PQueue({ concurrency: model.maxConcurrent }));
+    }
+  }
+  config;
+  ollama;
+  jobs;
+  queues = /* @__PURE__ */ new Map();
+  async runSync(input2) {
+    this.ensureQueueCapacity();
+    const queuedAt = Date.now();
+    const result = await this.queueFor(input2.model.name).add(
+      async () => {
+        const startedAt = Date.now();
+        const result2 = await this.ollama.chat(input2.request, input2.model.name, Math.min(input2.timeoutMs, input2.model.timeoutMs));
+        return { result: result2, queueTimeMs: startedAt - queuedAt, executionTimeMs: Date.now() - startedAt };
+      },
+      { priority: input2.priority, timeout: input2.timeoutMs, throwOnTimeout: true }
+    );
+    return result;
+  }
+  enqueueAsync(input2) {
+    this.ensureQueueCapacity();
+    const job = this.jobs.create({
+      taskType: input2.classification.taskType,
+      selectedModel: input2.model.name,
+      request: input2.request,
+      priority: input2.priority
+    });
+    const queue = this.queueFor(input2.model.name);
+    const position = queue.size + 1;
+    void queue.add(() => this.runJob(job.id), {
+      priority: input2.priority,
+      timeout: input2.model.timeoutMs,
+      throwOnTimeout: true
+    });
+    return { id: job.id, position };
+  }
+  snapshot() {
+    const byModel = [...this.queues.entries()].map(([model, queue]) => ({
+      model,
+      queued: queue.size,
+      running: queue.pending,
+      concurrency: this.config.models.find((spec) => spec.name === model)?.maxConcurrent ?? 1
+    }));
+    return {
+      globalQueued: byModel.reduce((sum, item) => sum + item.queued, 0),
+      globalRunning: byModel.reduce((sum, item) => sum + item.running, 0),
+      byModel
+    };
+  }
+  queueDepthByModel() {
+    return new Map([...this.queues.entries()].map(([model, queue]) => [model, queue.size]));
+  }
+  runningByModel() {
+    return new Map([...this.queues.entries()].map(([model, queue]) => [model, queue.pending]));
+  }
+  async runJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status === "cancelled") return;
+    const modelName = job.selected_model;
+    const model = this.config.models.find((spec) => spec.name === modelName);
+    if (!model) {
+      this.jobs.markFailed(jobId, new Error(`Configured model disappeared: ${modelName}`));
+      return;
+    }
+    this.jobs.markRunning(jobId);
+    try {
+      const request = JSON.parse(job.request_json);
+      const result = await this.ollama.chat(request, model.name, model.timeoutMs);
+      this.jobs.markSucceeded(jobId, result);
+    } catch (error) {
+      const latest = this.jobs.get(jobId);
+      if (latest && latest.attempts < this.config.jobs.maxAttempts && latest.status !== "cancelled") {
+        const queue = this.queueFor(model.name);
+        void queue.add(() => this.runJob(jobId), {
+          priority: latest.priority,
+          timeout: model.timeoutMs,
+          throwOnTimeout: true
+        });
+      } else {
+        this.jobs.markFailed(jobId, error);
+      }
+    }
+  }
+  ensureQueueCapacity() {
+    const snapshot = this.snapshot();
+    if (snapshot.globalQueued >= this.config.queue.globalMaxQueued) {
+      throw new Error(`Global queue limit exceeded: ${this.config.queue.globalMaxQueued}`);
+    }
+  }
+  queueFor(model) {
+    const queue = this.queues.get(model);
+    if (!queue) throw new Error(`No queue configured for model: ${model}`);
+    return queue;
+  }
+};
+
+// src/server.ts
+import http from "http";
+import https from "https";
+import { readFile as readFile3 } from "fs/promises";
+import express from "express";
+import { pinoHttp } from "pino-http";
+import { z as z3 } from "zod";
+
+// src/classifier.ts
+var codeMarkers = [
+  "typescript",
+  "javascript",
+  "node.js",
+  "python",
+  "function",
+  "class ",
+  "stack trace",
+  "exception",
+  "compile",
+  "refactor",
+  "pull request",
+  "diff --git",
+  "```"
+];
+var toolMarkers = ["tool", "function call", "json schema", "api call", "webhook", "bash", "shell command"];
+var reasoningMarkers = ["plan", "architecture", "design", "debug", "investigate", "root cause", "step by step"];
+var summarizeMarkers = ["summarize", "summary", "tl;dr", "extract key points"];
+var reviewMarkers = ["review", "audit", "risks", "find bugs", "code review"];
+var fixMarkers = ["fix", "bug", "failing test", "patch", "regression"];
+var generateMarkers = ["write", "implement", "create", "generate", "build"];
+function classifyTask(request, explicitTaskType) {
+  if (explicitTaskType && explicitTaskType !== "auto") {
+    return {
+      taskType: explicitTaskType,
+      complexity: explicitTaskType === "agentic_reasoning" || explicitTaskType === "large_context" ? "heavy" : "medium",
+      requiresLargeContext: explicitTaskType === "large_context",
+      requiresToolUse: explicitTaskType === "tool_use",
+      confidence: 1
+    };
+  }
+  const text = extractMessageText(request).toLowerCase();
+  const tokenEstimate = Math.ceil(text.length / 4);
+  const hasCode = containsAny(text, codeMarkers);
+  const requiresToolUse = containsAny(text, toolMarkers);
+  const requiresLargeContext = tokenEstimate > 12e3 || text.includes("large context") || text.includes("entire repository");
+  let taskType = "simple_chat";
+  let confidence = 0.55;
+  if (requiresLargeContext) {
+    taskType = "large_context";
+    confidence = 0.8;
+  } else if (requiresToolUse) {
+    taskType = "tool_use";
+    confidence = 0.75;
+  } else if (containsAny(text, reviewMarkers) && hasCode) {
+    taskType = "code_review";
+    confidence = 0.82;
+  } else if (containsAny(text, fixMarkers) && hasCode) {
+    taskType = "code_fix";
+    confidence = 0.8;
+  } else if (containsAny(text, generateMarkers) && hasCode) {
+    taskType = "code_generate";
+    confidence = 0.78;
+  } else if (containsAny(text, summarizeMarkers)) {
+    taskType = "summarize";
+    confidence = 0.86;
+  } else if (containsAny(text, reasoningMarkers) && (text.length > 1200 || text.includes("multi-step"))) {
+    taskType = "agentic_reasoning";
+    confidence = 0.72;
+  } else if (text.length < 180 && (text.includes("classify") || text.includes("route") || text.includes("triage"))) {
+    taskType = "triage";
+    confidence = 0.7;
+  }
+  const complexity = classifyComplexity(text, taskType, tokenEstimate);
+  return { taskType, complexity, requiresLargeContext, requiresToolUse, confidence };
+}
+function extractMessageText(request) {
+  return request.messages.map((message) => {
+    if (typeof message.content === "string") return message.content;
+    if (Array.isArray(message.content)) {
+      return message.content.map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part) return String(part.text ?? "");
+        return "";
+      }).join("\n");
+    }
+    return JSON.stringify(message.content ?? "");
+  }).join("\n");
+}
+function classifyComplexity(text, taskType, tokenEstimate) {
+  if (taskType === "large_context" || taskType === "agentic_reasoning" || tokenEstimate > 12e3) return "heavy";
+  if (tokenEstimate > 3e3 || text.includes("architecture") || text.includes("debug")) return "medium";
+  if (taskType.startsWith("code_") || taskType === "tool_use") return "medium";
+  return "light";
+}
+function containsAny(text, markers) {
+  return markers.some((marker) => text.includes(marker));
+}
+
+// src/router-engine.ts
+var priorityWeights = {
+  low: 10,
+  normal: 50,
+  high: 90
+};
+function normalizeRouterMetadata(config, metadata = {}) {
+  return {
+    mode: metadata.mode ?? config.router.defaultMode,
+    allowAsync: metadata.allowAsync ?? true,
+    taskType: metadata.taskType ?? "auto",
+    priority: metadata.priority ?? config.queue.defaultPriority,
+    preferredModels: metadata.preferredModels ?? [],
+    forbiddenModels: metadata.forbiddenModels ?? [],
+    maxQueueTimeMs: metadata.maxQueueTimeMs ?? config.router.syncMaxQueueTimeMs,
+    maxExecutionTimeMs: metadata.maxExecutionTimeMs ?? config.queue.timeoutMs,
+    requireGpuOnly: metadata.requireGpuOnly ?? config.gpu.requireGpuOnlyByDefault
+  };
+}
+var RoutingEngine = class {
+  constructor(config) {
+    this.config = config;
+    this.modelsByName = new Map(config.models.map((model) => [model.name, model]));
+  }
+  config;
+  modelsByName;
+  decide(context) {
+    const candidates = this.getCandidates(context);
+    if (candidates.length === 0) {
+      return { type: "reject", statusCode: 503, reason: "No configured model can satisfy this request" };
+    }
+    const blocked = candidates.map((model) => ({ model, blockReason: this.blockReason(model, context) })).filter((entry) => entry.blockReason);
+    const available = candidates.filter((model) => !this.blockReason(model, context));
+    const scoredAvailable = available.map((model) => this.score(model, context)).sort((a, b) => b.score - a.score);
+    const fallbackModels = candidates.map((model) => model.name);
+    if (context.router.mode === "async") {
+      const model = scoredAvailable[0]?.model ?? candidates[0];
+      return {
+        type: "async",
+        model,
+        fallbackModels,
+        reason: "Request explicitly requested async mode",
+        score: scoredAvailable[0]?.score ?? 0,
+        position: (context.queueDepthByModel.get(model.name) ?? 0) + 1
+      };
+    }
+    const preferredBusy = this.preferredBusyModel(candidates, context);
+    const totalQueueDepth = [...context.queueDepthByModel.values()].reduce((sum, depth) => sum + depth, 0);
+    const gpuHeavy = Boolean(
+      context.gpu && context.gpu.vramFreeMb < this.config.router.heavyLoadGpuFreeMbThreshold
+    );
+    const heavyLoad = totalQueueDepth >= this.config.router.heavyLoadQueueDepth || gpuHeavy;
+    if (context.router.mode !== "sync" && context.router.allowAsync && (heavyLoad || preferredBusy)) {
+      const model = preferredBusy ?? scoredAvailable[0]?.model ?? candidates[0];
+      return {
+        type: "async",
+        model,
+        fallbackModels,
+        reason: preferredBusy ? "Preferred model is busy; accepted for async processing" : "Heavy load detected",
+        score: this.score(model, context).score,
+        position: (context.queueDepthByModel.get(model.name) ?? 0) + 1
+      };
+    }
+    if (scoredAvailable.length > 0) {
+      return {
+        type: "sync",
+        model: scoredAvailable[0].model,
+        fallbackModels,
+        reason: scoredAvailable[0].reason,
+        score: scoredAvailable[0].score
+      };
+    }
+    if (blocked.some((entry) => entry.blockReason === "busy") && context.router.allowAsync && context.router.mode !== "sync") {
+      const model = blocked[0].model;
+      return {
+        type: "async",
+        model,
+        fallbackModels,
+        reason: "Selected model is busy; accepted for async processing",
+        score: 0,
+        position: (context.queueDepthByModel.get(model.name) ?? 0) + 1
+      };
+    }
+    const reason = blocked.map((entry) => `${entry.model.name}: ${entry.blockReason}`).join("; ");
+    return { type: "reject", statusCode: 503, reason: reason || "No model available" };
+  }
+  score(model, context) {
+    const route = this.config.routes[context.classification.taskType] ?? this.config.routes.unknown ?? [];
+    const routeIndex = route.indexOf(model.name);
+    const loaded = context.loadedModels.some((loadedModel) => loadedModel.name === model.name);
+    const queueDepth = context.queueDepthByModel.get(model.name) ?? 0;
+    const running = context.runningByModel.get(model.name) ?? 0;
+    const preferredIndex = context.router.preferredModels.indexOf(model.name);
+    const freeMb = context.gpu?.vramFreeMb ?? this.config.gpu.vramTotalMb;
+    const requiredMb = model.sizeGb * 1024 + this.config.gpu.vramSafetyReserveMb;
+    let score = 100;
+    score += Math.max(0, 50 - routeIndex * 8);
+    score += model.priority;
+    if (model.purpose.includes(context.classification.taskType)) score += 25;
+    if (model.tags.includes(context.classification.taskType)) score += 15;
+    if (preferredIndex >= 0) score += 80 - preferredIndex * 10;
+    if (loaded) score += 20;
+    if (context.classification.complexity === "heavy" && model.costClass === "high") score += 20;
+    if (context.classification.complexity === "light" && model.costClass === "low") score += 15;
+    if (freeMb > requiredMb) score += Math.min(25, (freeMb - requiredMb) / 512);
+    if (freeMb < requiredMb) score -= 60;
+    score -= queueDepth * 18;
+    score -= running * 25;
+    if (model.exclusive) score -= running * 80;
+    return {
+      model,
+      score,
+      reason: `Selected ${model.name} for ${context.classification.taskType} with score ${score.toFixed(1)}`
+    };
+  }
+  getCandidates(context) {
+    const routeNames = this.config.routes[context.classification.taskType] ?? this.config.routes.unknown ?? [];
+    const names = /* @__PURE__ */ new Set();
+    for (const name of context.router.preferredModels) names.add(name);
+    for (const name of routeNames) names.add(name);
+    for (const model of this.config.models) {
+      if (model.purpose.includes(context.classification.taskType) || model.tags.includes(context.classification.taskType)) {
+        names.add(model.name);
+      }
+    }
+    return [...names].map((name) => this.modelsByName.get(name)).filter((model) => Boolean(model)).filter((model) => !context.router.forbiddenModels.includes(model.name));
+  }
+  blockReason(model, context) {
+    const loaded = context.loadedModels.find((loadedModel) => loadedModel.name === model.name);
+    const processor = loaded?.processor?.toLowerCase() ?? "";
+    if (context.router.requireGpuOnly) {
+      if (!context.gpu && this.config.gpu.vramTotalMb <= 0) return "gpu_only";
+      if (processor.includes("cpu") && !processor.includes("100% gpu")) return "gpu_only";
+      const freeMb = context.gpu?.vramFreeMb ?? this.config.gpu.vramTotalMb;
+      if (model.sizeGb * 1024 + this.config.gpu.vramSafetyReserveMb > freeMb && !loaded) return "gpu_only";
+    }
+    const running = context.runningByModel.get(model.name) ?? 0;
+    if (model.exclusive && running > 0 || !model.allowWhenBusy && running >= model.maxConcurrent) {
+      return "busy";
+    }
+    return void 0;
+  }
+  preferredBusyModel(candidates, context) {
+    const preferredNames = new Set(context.router.preferredModels);
+    const ordered = preferredNames.size > 0 ? candidates.filter((model) => preferredNames.has(model.name)) : candidates.slice(0, 1);
+    return ordered.find((model) => this.blockReason(model, context) === "busy");
+  }
+};
+
+// src/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: process.env.LOG_LEVEL ?? "info"
+});
+
+// src/server.ts
+var chatRequestSchema = z3.object({
+  model: z3.string().optional(),
+  messages: z3.array(z3.object({ role: z3.string(), content: z3.unknown() })).min(1),
+  stream: z3.boolean().optional(),
+  router: z3.object({
+    mode: z3.enum(["auto", "sync", "async"]).optional(),
+    allowAsync: z3.boolean().optional(),
+    taskType: z3.string().optional(),
+    priority: z3.enum(["low", "normal", "high"]).optional(),
+    preferredModels: z3.array(z3.string()).optional(),
+    forbiddenModels: z3.array(z3.string()).optional(),
+    maxQueueTimeMs: z3.number().int().nonnegative().optional(),
+    maxExecutionTimeMs: z3.number().int().positive().optional(),
+    requireGpuOnly: z3.boolean().optional()
+  }).optional()
+}).passthrough();
+function createApp(config, deps) {
+  const app = express();
+  const api = express.Router();
+  const routing = new RoutingEngine(config);
+  if (process.env.NODE_ENV !== "test") {
+    app.use(pinoHttp({ logger }));
+  }
+  app.use(express.json({ limit: config.server.requestBodyLimit }));
+  api.get("/health", (_req, res) => {
+    res.json({ status: "ok", service: "ollama-agent-router" });
+  });
+  api.get("/metrics", (_req, res) => {
+    const snapshot = deps.queue.snapshot();
+    res.type("text/plain").send(
+      [
+        `oar_queue_global_queued ${snapshot.globalQueued}`,
+        `oar_queue_global_running ${snapshot.globalRunning}`,
+        ...snapshot.byModel.flatMap((item) => [
+          `oar_model_queue_depth{model="${escapeMetricLabel(item.model)}"} ${item.queued}`,
+          `oar_model_running{model="${escapeMetricLabel(item.model)}"} ${item.running}`
+        ])
+      ].join("\n")
+    );
+  });
+  api.get("/v1/router/status", async (_req, res, next) => {
+    try {
+      res.json({
+        service: "ollama-agent-router",
+        queue: deps.queue.snapshot(),
+        gpu: await safeGpu(deps.gpu),
+        loadedModels: await safeLoadedModels(deps.ollama),
+        config: {
+          models: config.models.length,
+          routes: Object.keys(config.routes),
+          basePath: normalizeBasePath(config.server.basePath),
+          protocol: config.server.https.enabled ? "https" : "http"
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+  api.get("/v1/router/models", async (_req, res, next) => {
+    try {
+      res.json({
+        configured: config.models,
+        ollama: await deps.ollama.tags(),
+        loaded: await safeLoadedModels(deps.ollama)
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+  api.get("/v1/router/gpu", async (_req, res, next) => {
+    try {
+      res.json(await safeGpu(deps.gpu) ?? { provider: config.gpu.provider, available: false });
+    } catch (error) {
+      next(error);
+    }
+  });
+  api.get("/v1/jobs", (_req, res) => {
+    res.json({ jobs: deps.jobs.list() });
+  });
+  api.get("/v1/jobs/:jobId", (req, res) => {
+    const job = deps.jobs.get(req.params.jobId);
+    if (!job) return res.status(404).json({ error: { message: "Job not found" } });
+    return res.json(job);
+  });
+  api.get("/v1/jobs/:jobId/result", (req, res) => {
+    const job = deps.jobs.get(req.params.jobId);
+    if (!job) return res.status(404).json({ error: { message: "Job not found" } });
+    if (job.status === "failed") return res.status(500).json({ status: job.status, error: parseJobError(job) });
+    if (job.status !== "succeeded") return res.status(202).json({ status: job.status });
+    return res.json(parseJobResult(job));
+  });
+  api.delete("/v1/jobs/:jobId", (req, res) => {
+    const job = deps.jobs.cancel(req.params.jobId);
+    if (!job) return res.status(404).json({ error: { message: "Job not found" } });
+    return res.json(job);
+  });
+  api.post("/v1/chat/completions", async (req, res, next) => {
+    try {
+      const request = chatRequestSchema.parse(req.body);
+      if (request.stream) {
+        return res.status(400).json({ error: { message: "Streaming is not supported by ollama-agent-router v1" } });
+      }
+      const router = normalizeRouterMetadata(config, request.router);
+      const classification = classifyTask(request, router.taskType);
+      const loadedModels = await safeLoadedModels(deps.ollama);
+      const gpu = await safeGpu(deps.gpu);
+      const decision = routing.decide({
+        request,
+        router,
+        classification,
+        loadedModels,
+        gpu,
+        queueDepthByModel: deps.queue.queueDepthByModel(),
+        runningByModel: deps.queue.runningByModel()
+      });
+      if (decision.type === "reject") {
+        return res.status(decision.statusCode).json({ error: { message: decision.reason } });
+      }
+      const priority = priorityWeights[router.priority];
+      if (decision.type === "async") {
+        const job = deps.queue.enqueueAsync({
+          model: decision.model,
+          request,
+          classification,
+          priority
+        });
+        return res.status(202).json({
+          id: job.id,
+          object: "router.job",
+          status: "queued",
+          message: "Heavy load. Job accepted for asynchronous processing.",
+          router: {
+            mode: "async",
+            taskType: classification.taskType,
+            preferredModel: decision.model.name,
+            position: job.position,
+            estimatedClass: classification.complexity
+          }
+        });
+      }
+      const output2 = await deps.queue.runSync({
+        model: decision.model,
+        request,
+        priority,
+        timeoutMs: router.maxExecutionTimeMs
+      });
+      return res.json(
+        withRouterMetadata(output2.result, {
+          mode: "sync",
+          taskType: classification.taskType,
+          selectedModel: decision.model.name,
+          fallbackModels: decision.fallbackModels.filter((name) => name !== decision.model.name),
+          queueTimeMs: output2.queueTimeMs,
+          executionTimeMs: output2.executionTimeMs,
+          decisionReason: decision.reason
+        })
+      );
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.use(normalizeBasePath(config.server.basePath), api);
+  app.use((error, _req, res, _next) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = error instanceof z3.ZodError ? 400 : 500;
+    res.status(status).json({ error: { message } });
+  });
+  return app;
+}
+async function startServer(config, deps) {
+  const app = createApp(config, deps);
+  const server = await createHttpServer(config, app);
+  server.listen(config.server.port, config.server.host);
+  await new Promise((resolve3) => server.once("listening", resolve3));
+  logger.info(
+    {
+      host: config.server.host,
+      port: config.server.port,
+      basePath: normalizeBasePath(config.server.basePath),
+      protocol: config.server.https.enabled ? "https" : "http"
+    },
+    "ollama-agent-router listening"
+  );
+  return {
+    close: () => new Promise((resolve3, reject) => {
+      server.close((error) => error ? reject(error) : resolve3());
+    })
+  };
+}
+function normalizeBasePath(basePath) {
+  const trimmed = basePath.trim();
+  if (!trimmed || trimmed === "/") return "/";
+  return `/${trimmed.replace(/^\/+|\/+$/g, "")}`;
+}
+async function createHttpServer(config, app) {
+  if (!config.server.https.enabled) {
+    return http.createServer(app);
+  }
+  if (!config.server.https.certPath || !config.server.https.keyPath) {
+    throw new Error("server.https.certPath and server.https.keyPath are required when HTTPS is enabled");
+  }
+  return https.createServer(
+    {
+      cert: await readFile3(config.server.https.certPath),
+      key: await readFile3(config.server.https.keyPath),
+      ca: config.server.https.caPath ? await readFile3(config.server.https.caPath) : void 0
+    },
+    app
+  );
+}
+function withRouterMetadata(result, router) {
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    return { ...result, router };
+  }
+  return { result, router };
+}
+async function safeLoadedModels(ollama) {
+  try {
+    return await ollama.ps();
+  } catch {
+    return [];
+  }
+}
+async function safeGpu(gpu) {
+  try {
+    return await gpu.snapshot();
+  } catch {
+    return void 0;
+  }
+}
+function escapeMetricLabel(label) {
+  return label.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("ollama-agent-router").alias("oar").description("Intelligent HTTP/CLI router for Ollama").option("-c, --config <path>", "config file path").option("-u, --url <url>", "router URL for client commands", "http://127.0.0.1:11435").option("--base-path <path>", "router API base path for client commands", "/");
+program.command("serve").description("start the router server").option("-c, --config <path>", "config file path").action(async (options) => {
+  const { config, path } = await loadConfig(options.config ?? program.opts().config);
+  const jobs = new InMemoryJobStore(config.jobs);
+  const ollama = new HttpOllamaClient(config.ollama);
+  const gpu = new NvidiaGpuMonitor(config.gpu);
+  const queue = new QueueManager(config, ollama, jobs);
+  const cleanup = setInterval(() => jobs.cleanupExpired(), config.jobs.cleanupIntervalMs);
+  const server = await startServer(config, { ollama, gpu, jobs, queue });
+  logger.info({ configPath: path }, "loaded config");
+  const shutdown = async () => {
+    clearInterval(cleanup);
+    await server.close();
+    jobs.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+});
+program.command("init").description("write a starter config").option("-o, --output <path>", "output path", "./ollama-agent-router.yaml").option("--wizard", "run the detect-first configuration wizard").action(async (options) => {
+  if (options.wizard) {
+    await runConfigure({ outputPath: options.output });
+    return;
+  }
+  await writeDefaultConfig(options.output);
+  console.log(`Wrote ${options.output}`);
+});
+program.command("configure").description("run the detect-first configuration wizard").option("-o, --output <path>", "output path", "./ollama-agent-router.yaml").option("--answers <path>", "answers YAML for non-interactive mode").option("--non-interactive", "generate config without interactive prompts").option("--detect", "print detected environment and exit").option("--dry-run", "print generated YAML without writing").option("--overwrite", "overwrite output if it already exists").option("-y, --yes", "accept detected values and write without confirmation").action(async (options) => {
+  await runConfigure({
+    outputPath: options.output,
+    answersPath: options.answers,
+    nonInteractive: options.nonInteractive || options.yes,
+    detectOnly: options.detect,
+    dryRun: options.dryRun,
+    overwrite: options.overwrite,
+    assumeYes: options.yes
+  });
+});
+program.command("validate-config").description("validate YAML configuration").option("-c, --config <path>", "config file path").action(async (options) => {
+  const path = options.config ?? program.opts().config;
+  if (path) {
+    parseConfig(await readFile4(path, "utf8"));
+    console.log(`Config is valid: ${path}`);
+    return;
+  }
+  const found = await loadConfig();
+  console.log(`Config is valid: ${found.path}`);
+});
+program.command("status").description("show router status").action(() => printJson("/v1/router/status"));
+program.command("models").description("show configured and Ollama models").action(() => printJson("/v1/router/models"));
+program.command("gpu").description("show GPU state").action(() => printJson("/v1/router/gpu"));
+program.command("jobs").description("list jobs").action(() => printJson("/v1/jobs"));
+program.command("job <jobId>").description("show job").action((jobId) => printJson(`/v1/jobs/${jobId}`));
+program.command("result <jobId>").description("show job result").action((jobId) => printJson(`/v1/jobs/${jobId}/result`));
+program.command("cancel <jobId>").description("cancel a job").action((jobId) => printJson(`/v1/jobs/${jobId}`, { method: "DELETE" }));
+program.parseAsync().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+async function printJson(path, init) {
+  const response = await fetch(buildClientUrl(path), init);
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(text || `HTTP ${response.status}`);
+  }
+  try {
+    console.log(JSON.stringify(JSON.parse(text), null, 2));
+  } catch {
+    console.log(text);
+  }
+}
+function buildClientUrl(path) {
+  const options = program.opts();
+  const url = new URL(options.url);
+  const basePath = normalizeBasePath2(options.basePath);
+  const pieces = [url.pathname, basePath, path].map((piece) => piece.replace(/^\/+|\/+$/g, "")).filter(Boolean);
+  url.pathname = `/${pieces.join("/")}`;
+  return url;
+}
+function normalizeBasePath2(basePath) {
+  const trimmed = basePath.trim();
+  if (!trimmed || trimmed === "/") return "/";
+  return `/${trimmed.replace(/^\/+|\/+$/g, "")}`;
+}
+//# sourceMappingURL=cli.js.map