@jmanuelcorral/openteam 0.1.1 → 0.1.3

package/dist/cli.js

@@ -0,0 +1,883 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { execFile } from "node:child_process";
+import { readFile as readFile2 } from "node:fs/promises";
+import { promisify } from "node:util";
+
+// src/config/schema.ts
+import { z } from "zod";
+var ModelRefSchema = z.object({
+  providerID: z.string().min(1),
+  modelID: z.string().min(1)
+});
+var RouterModeSchema = z.enum(["economy", "balanced", "quality"]);
+var PrivacyModeSchema = z.enum([
+  "forceLocalOnSensitive",
+  "consentBeforeFrontier",
+  "off"
+]);
+var BaselineModeSchema = z.enum(["auto", "pinned"]);
+var defaultLocalModel = {
+  providerID: "ollama",
+  modelID: "qwen3:8b"
+};
+var defaultFrontierModel = {
+  providerID: "anthropic",
+  modelID: "claude-sonnet-4-5"
+};
+var LocalRuntimeSchema = z.object({
+  id: z.enum(["ollama", "lmstudio", "foundry-local"]),
+  enabled: z.boolean().default(true),
+  baseURL: z.string().url().optional(),
+  discovery: z.enum(["cli", "sdk", "manual"]).optional(),
+  defaultModel: ModelRefSchema
+});
+var OpenTeamConfigSchema = z.object({
+  baseline: z.object({
+    mode: BaselineModeSchema.default("auto"),
+    pinnedModel: ModelRefSchema.nullable().default(null),
+    hardDefault: ModelRefSchema.default(defaultFrontierModel)
+  }).default({
+    mode: "auto",
+    pinnedModel: null,
+    hardDefault: defaultFrontierModel
+  }),
+  router: z.object({
+    mode: RouterModeSchema.default("balanced"),
+    localDefault: ModelRefSchema.default(defaultLocalModel),
+    trivialPromptMaxChars: z.number().int().positive().default(280),
+    frontierPromptMinChars: z.number().int().positive().default(2000)
+  }).default({
+    mode: "balanced",
+    localDefault: defaultLocalModel,
+    trivialPromptMaxChars: 280,
+    frontierPromptMinChars: 2000
+  }),
+  local: z.object({
+    runtimes: z.array(LocalRuntimeSchema).min(1).default([
+      {
+        id: "ollama",
+        enabled: true,
+        baseURL: "http://localhost:11434/v1",
+        defaultModel: { providerID: "ollama", modelID: "qwen3:8b" }
+      }
+    ])
+  }).default({
+    runtimes: [
+      {
+        id: "ollama",
+        enabled: true,
+        baseURL: "http://localhost:11434/v1",
+        defaultModel: defaultLocalModel
+      }
+    ]
+  }),
+  budgets: z.object({
+    sessionUSD: z.number().positive().optional(),
+    monthlyUSD: z.number().positive().optional(),
+    frontierTokensPerSession: z.number().int().positive().optional(),
+    hardStopOnBudgetExhaustion: z.boolean().default(false)
+  }).default({ hardStopOnBudgetExhaustion: false }),
+  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive")
+});
+
+// src/commands/baseline.ts
+function formatRef(ref) {
+  return ref === null ? "—" : `${ref.providerID}/${ref.modelID}`;
+}
+function effectiveBaseline(config) {
+  if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
+    return `${formatRef(config.baseline.pinnedModel)} (pinned)`;
+  }
+  return "cheapest-capable (auto)";
+}
+function parseModelRef(input) {
+  const trimmed = input.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash <= 0 || slash === trimmed.length - 1) {
+    throw new Error(`Modelo inválido "${input}". Usa el formato provider/model, p.ej. anthropic/claude-sonnet-4-5.`);
+  }
+  return ModelRefSchema.parse({
+    providerID: trimmed.slice(0, slash),
+    modelID: trimmed.slice(slash + 1)
+  });
+}
+function showBaseline(config) {
+  const lines = [
+    "openteam baseline:",
+    `  modo:      ${config.baseline.mode}`,
+    `  pinned:    ${formatRef(config.baseline.pinnedModel)}`,
+    `  hardDefault: ${formatRef(config.baseline.hardDefault)}`,
+    `  efectivo:  ${effectiveBaseline(config)}`
+  ];
+  return { message: lines.join(`
+`) };
+}
+function setBaseline(config, ref) {
+  const next = {
+    ...config,
+    baseline: {
+      ...config.baseline,
+      mode: "pinned",
+      pinnedModel: ref
+    }
+  };
+  return {
+    config: next,
+    message: `Baseline fijado a ${formatRef(ref)} (modo pinned).`
+  };
+}
+function autoBaseline(config) {
+  const next = {
+    ...config,
+    baseline: {
+      ...config.baseline,
+      mode: "auto",
+      pinnedModel: null
+    }
+  };
+  return {
+    config: next,
+    message: "Baseline en modo auto (cheapest-capable)."
+  };
+}
+
+// src/commands/doctor.ts
+function runtimeLine(snapshot) {
+  const mark = snapshot.reachable ? "✓" : "✗";
+  const detail = snapshot.reachable ? `${snapshot.models.length} modelo(s)` : snapshot.error ?? "inalcanzable";
+  return `  ${mark} ${snapshot.id.padEnd(14)} ${snapshot.baseURL || "(sin baseURL)"} — ${detail}`;
+}
+function renderDoctor(input) {
+  const enabledRuntimes = input.config.local.runtimes.filter((r) => r.enabled);
+  const reachable = input.snapshots.filter((s) => s.reachable).length;
+  const lines = [
+    "openteam doctor:",
+    `  baseline:  ${input.config.baseline.mode}` + (input.config.baseline.mode === "pinned" && input.config.baseline.pinnedModel !== null ? ` (${input.config.baseline.pinnedModel.providerID}/${input.config.baseline.pinnedModel.modelID})` : ""),
+    `  privacidad: ${input.config.privacyMode}`,
+    `  runtimes locales (${reachable}/${enabledRuntimes.length} alcanzables):`
+  ];
+  if (input.snapshots.length === 0) {
+    lines.push("    (ningún runtime habilitado)");
+  } else {
+    for (const snapshot of input.snapshots) {
+      lines.push(runtimeLine(snapshot));
+    }
+  }
+  lines.push(`  telemetría: ${input.telemetryPath} — ${input.telemetryRecords} registro(s)`);
+  if (reachable === 0) {
+    lines.push("  ⚠ Ningún runtime local alcanzable: todo el tráfico irá a frontier.");
+  }
+  return lines.join(`
+`);
+}
+
+// src/commands/report.ts
+var TIERS = [
+  "trivial",
+  "simple",
+  "moderate",
+  "hard"
+];
+function emptyTierSummary() {
+  return {
+    trivial: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
+    simple: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
+    moderate: { count: 0, estimatedUSD: 0, savingsUSD: 0 },
+    hard: { count: 0, estimatedUSD: 0, savingsUSD: 0 }
+  };
+}
+function summarizeCostRecords(records) {
+  const report = {
+    count: 0,
+    localCount: 0,
+    frontierCount: 0,
+    totalEstimatedUSD: 0,
+    totalBaselineUSD: 0,
+    totalSavingsUSD: 0,
+    savingsPct: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    byTier: emptyTierSummary()
+  };
+  for (const record of records) {
+    report.count += 1;
+    if (record.routeKind === "local") {
+      report.localCount += 1;
+    } else {
+      report.frontierCount += 1;
+    }
+    report.totalEstimatedUSD += record.estimatedCostUSD;
+    report.totalBaselineUSD += record.baselineCostUSD;
+    report.totalSavingsUSD += record.estimatedSavingsUSD;
+    report.tokensIn += record.tokensIn ?? 0;
+    report.tokensOut += record.tokensOut ?? 0;
+    const tier = report.byTier[record.tier];
+    tier.count += 1;
+    tier.estimatedUSD += record.estimatedCostUSD;
+    tier.savingsUSD += record.estimatedSavingsUSD;
+  }
+  report.savingsPct = report.totalBaselineUSD > 0 ? report.totalSavingsUSD / report.totalBaselineUSD * 100 : 0;
+  return report;
+}
+function usd(value) {
+  return `$${value.toFixed(5)}`;
+}
+function renderReport(report) {
+  if (report.count === 0) {
+    return "openteam report: sin registros de telemetría todavía.";
+  }
+  const lines = [
+    "openteam report:",
+    `  decisiones:   ${report.count} (local ${report.localCount} · frontier ${report.frontierCount})`,
+    `  coste real:   ${usd(report.totalEstimatedUSD)}`,
+    `  baseline:     ${usd(report.totalBaselineUSD)}`,
+    `  ahorro:       ${usd(report.totalSavingsUSD)} (${report.savingsPct.toFixed(2)}%)`,
+    `  tokens:       in ${report.tokensIn} · out ${report.tokensOut}`,
+    "  por tier:"
+  ];
+  for (const tier of TIERS) {
+    const summary = report.byTier[tier];
+    lines.push(`    ${tier.padEnd(9)} ${summary.count} · coste ${usd(summary.estimatedUSD)} · ahorro ${usd(summary.savingsUSD)}`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/commands/dispatch.ts
+var HELP = [
+  "openteam — comandos runtime",
+  "",
+  "Uso:",
+  "  openteam baseline show            Muestra el baseline efectivo",
+  "  openteam baseline set <p/model>   Fija el baseline (modo pinned)",
+  "  openteam baseline auto            Baseline cheapest-capable (modo auto)",
+  "  openteam doctor                   Diagnóstico de runtimes y config",
+  "  openteam report                   Resumen de coste/ahorro (telemetría)",
+  "",
+  "Opciones:",
+  "  --config <path>      Ruta de .opencode/openteam.json",
+  "  --telemetry <path>   Ruta del JSONL de telemetría"
+].join(`
+`);
+function parseArgs(argv) {
+  const positionals = [];
+  const result = { positionals };
+  for (let i = 0;i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--config") {
+      const value = argv[i + 1];
+      if (value !== undefined) {
+        result.configPath = value;
+      }
+      i += 1;
+    } else if (arg === "--telemetry") {
+      const value = argv[i + 1];
+      if (value !== undefined) {
+        result.telemetryPath = value;
+      }
+      i += 1;
+    } else if (arg !== undefined) {
+      positionals.push(arg);
+    }
+  }
+  return result;
+}
+async function runBaseline(positionals, deps, configPath) {
+  const sub = positionals[1];
+  if (sub === "show" || sub === undefined) {
+    const config = await deps.loadConfig(configPath);
+    return { exitCode: 0, stdout: showBaseline(config).message };
+  }
+  if (sub === "auto") {
+    const config = await deps.loadConfig(configPath);
+    const outcome = autoBaseline(config);
+    if (outcome.config !== undefined) {
+      await deps.saveConfig(outcome.config, configPath);
+    }
+    return { exitCode: 0, stdout: outcome.message };
+  }
+  if (sub === "set") {
+    const target = positionals[2];
+    if (target === undefined) {
+      return {
+        exitCode: 1,
+        stdout: "Falta el modelo. Uso: openteam baseline set <provider/model>"
+      };
+    }
+    const config = await deps.loadConfig(configPath);
+    const outcome = setBaseline(config, parseModelRef(target));
+    if (outcome.config !== undefined) {
+      await deps.saveConfig(outcome.config, configPath);
+    }
+    return { exitCode: 0, stdout: outcome.message };
+  }
+  return {
+    exitCode: 1,
+    stdout: `Subcomando de baseline desconocido: ${sub}
+
+${HELP}`
+  };
+}
+async function runCli(argv, deps) {
+  const parsed = parseArgs(argv);
+  const command = parsed.positionals[0];
+  const configPath = parsed.configPath ?? deps.configPath;
+  const telemetryPath = parsed.telemetryPath ?? deps.telemetryPath;
+  try {
+    if (command === "baseline") {
+      return await runBaseline(parsed.positionals, deps, configPath);
+    }
+    if (command === "doctor") {
+      const config = await deps.loadConfig(configPath);
+      const [snapshots, records] = await Promise.all([
+        deps.probe(config),
+        deps.readTelemetry(telemetryPath)
+      ]);
+      return {
+        exitCode: 0,
+        stdout: renderDoctor({
+          config,
+          snapshots,
+          telemetryPath,
+          telemetryRecords: records.length
+        })
+      };
+    }
+    if (command === "report") {
+      const records = await deps.readTelemetry(telemetryPath);
+      return {
+        exitCode: 0,
+        stdout: renderReport(summarizeCostRecords(records))
+      };
+    }
+    if (command === undefined || command === "help" || command === "--help") {
+      return { exitCode: 0, stdout: HELP };
+    }
+    return {
+      exitCode: 1,
+      stdout: `Comando desconocido: ${command}
+
+${HELP}`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 1, stdout: `Error: ${message}` };
+  }
+}
+
+// src/config/load.ts
+function loadOpenTeamConfig(raw) {
+  return OpenTeamConfigSchema.parse(raw ?? {});
+}
+
+// src/config/persist.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+var DEFAULT_CONFIG_PATH = ".opencode/openteam.json";
+function serializeOpenTeamConfig(config) {
+  const validated = OpenTeamConfigSchema.parse(config);
+  return `${JSON.stringify(validated, null, 2)}
+`;
+}
+async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, deps = {}) {
+  const mkdirFn = deps.mkdir ?? mkdir;
+  const writeFileFn = deps.writeFile ?? writeFile;
+  await mkdirFn(dirname(path), { recursive: true });
+  await writeFileFn(path, serializeOpenTeamConfig(config), "utf8");
+}
+
+// src/local/openai-compatible.ts
+function normalizeBaseURL(baseURL) {
+  return baseURL.replace(/\/+$/, "");
+}
+function modelsEndpoint(baseURL) {
+  return `${normalizeBaseURL(baseURL)}/models`;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function listOpenAICompatibleModels(baseURL, fetch) {
+  const response = await fetch(modelsEndpoint(baseURL), {
+    method: "GET",
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`GET /models failed with HTTP ${response.status}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (error) {
+    throw new Error(`Malformed JSON from /models: ${errorMessage(error)}`);
+  }
+  return parseOpenAIModels(payload);
+}
+function parseOpenAIModels(payload) {
+  if (!isObject(payload) || !Array.isArray(payload.data)) {
+    throw new Error("Malformed /models response: expected data array");
+  }
+  return payload.data.map(parseOpenAIModel);
+}
+function unavailableSnapshot(input) {
+  return {
+    id: input.id,
+    baseURL: input.baseURL,
+    reachable: false,
+    models: [],
+    probedAt: input.probedAt,
+    error: errorMessage(input.error)
+  };
+}
+async function probeOpenAICompatibleRuntime(input) {
+  const normalizedBaseURL = normalizeBaseURL(input.baseURL);
+  try {
+    return {
+      id: input.id,
+      baseURL: normalizedBaseURL,
+      reachable: true,
+      models: await listOpenAICompatibleModels(normalizedBaseURL, input.fetch),
+      probedAt: input.probedAt
+    };
+  } catch (error) {
+    return unavailableSnapshot({
+      id: input.id,
+      baseURL: normalizedBaseURL,
+      probedAt: input.probedAt,
+      error
+    });
+  }
+}
+function parseOpenAIModel(value) {
+  if (!isObject(value) || typeof value.id !== "string" || value.id.length === 0) {
+    throw new Error("Malformed /models response: model id must be a string");
+  }
+  const contextWindow = readContextWindow(value);
+  const model = {
+    modelID: value.id,
+    supportsTools: readSupportsTools(value)
+  };
+  if (contextWindow !== undefined) {
+    model.contextWindow = contextWindow;
+  }
+  return model;
+}
+function readSupportsTools(model) {
+  const direct = readBoolean(model, [
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "supportsToolCalling",
+    "supports_tools",
+    "supportsTools"
+  ]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  const capabilities = readCapabilityBoolean(model.capabilities);
+  if (capabilities !== undefined) {
+    return capabilities;
+  }
+  const features = readCapabilityBoolean(model.features);
+  if (features !== undefined) {
+    return features;
+  }
+  return "unknown";
+}
+function readCapabilityBoolean(value) {
+  if (Array.isArray(value)) {
+    if (value.some((entry) => typeof entry === "string" && ["tools", "tool_call", "tool-calling", "function_calling"].includes(entry))) {
+      return true;
+    }
+    return;
+  }
+  if (!isObject(value)) {
+    return;
+  }
+  return readBoolean(value, [
+    "tools",
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "function_calling",
+    "supportsToolCalling"
+  ]);
+}
+function readContextWindow(model) {
+  const direct = readPositiveInteger(model, [
+    "contextWindow",
+    "context_window",
+    "context_length",
+    "max_context_length",
+    "n_ctx"
+  ]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  if (isObject(model.limit)) {
+    return readPositiveInteger(model.limit, ["context"]);
+  }
+  return;
+}
+function readBoolean(object, keys) {
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return;
+}
+function readPositiveInteger(object, keys) {
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/local/foundry-local.ts
+async function discoverFoundryLocalBaseURL(input) {
+  const result = await input.exec(input.command ?? "foundry", [
+    ...input.args ?? ["service", "status"]
+  ]);
+  if (result.exitCode !== 0) {
+    throw new Error(`Foundry Local discovery failed with exit code ${result.exitCode}: ${result.stderr || result.stdout}`);
+  }
+  const endpoint = parseFoundryEndpoint(`${result.stdout}
+${result.stderr}`);
+  if (endpoint === undefined) {
+    throw new Error("Foundry Local discovery did not return an endpoint");
+  }
+  return endpoint;
+}
+function createFoundryLocalAdapter() {
+  return {
+    id: "foundry-local",
+    listModels: async (options) => {
+      const baseURL = await resolveFoundryBaseURL(options);
+      return listOpenAICompatibleModels(baseURL, options.fetch);
+    },
+    probe: async (options) => {
+      let baseURL = options.baseURL ?? "";
+      try {
+        baseURL = await resolveFoundryBaseURL(options);
+      } catch (error) {
+        return unavailableSnapshot({
+          id: "foundry-local",
+          baseURL,
+          probedAt: options.probedAt,
+          error
+        });
+      }
+      return probeOpenAICompatibleRuntime({
+        id: "foundry-local",
+        baseURL,
+        fetch: options.fetch,
+        probedAt: options.probedAt
+      });
+    }
+  };
+}
+async function resolveFoundryBaseURL(options) {
+  if (options.baseURL !== undefined) {
+    return normalizeBaseURL(options.baseURL);
+  }
+  if (options.discovery === undefined) {
+    throw new Error("Foundry Local discovery is required when baseURL is absent");
+  }
+  return normalizeFoundryDiscovery(await options.discovery());
+}
+function normalizeFoundryDiscovery(discovery) {
+  if (typeof discovery === "string") {
+    return ensureFoundryV1BaseURL(discovery);
+  }
+  if ("baseURL" in discovery) {
+    return ensureFoundryV1BaseURL(discovery.baseURL);
+  }
+  const host = discovery.host ?? "localhost";
+  const protocol = discovery.protocol ?? "http";
+  return `${protocol}://${host}:${discovery.port}/v1`;
+}
+function foundryDiscoveryFromExec(exec) {
+  return () => discoverFoundryLocalBaseURL({ exec });
+}
+function parseFoundryEndpoint(output) {
+  const explicitURL = output.match(/https?:\/\/[^\s"'<>),]+/u)?.[0];
+  if (explicitURL !== undefined) {
+    return ensureFoundryV1BaseURL(explicitURL);
+  }
+  const localhostPort = output.match(/(?:localhost|127\.0\.0\.1|\[::1\])\s*:\s*(\d{2,5})/u);
+  const port = localhostPort?.[1];
+  if (port !== undefined) {
+    return `http://localhost:${port}/v1`;
+  }
+  return;
+}
+function ensureFoundryV1BaseURL(endpoint) {
+  const normalizedEndpoint = endpoint.trim().replace(/[),.;]+$/u, "");
+  const withProtocol = /^[a-z]+:\/\//iu.test(normalizedEndpoint) ? normalizedEndpoint : `http://${normalizedEndpoint}`;
+  try {
+    const url = new URL(withProtocol);
+    const path = normalizeBaseURL(url.pathname);
+    if (path.endsWith("/v1")) {
+      return normalizeBaseURL(url.toString());
+    }
+    return `${url.origin}/v1`;
+  } catch (error) {
+    throw new Error(`Invalid Foundry Local endpoint: ${errorMessage(error)}`);
+  }
+}
+
+// src/local/lmstudio.ts
+var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
+function createLMStudioAdapter() {
+  return {
+    id: "lmstudio",
+    defaultBaseURL: LMSTUDIO_DEFAULT_BASE_URL,
+    listModels(options) {
+      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? LMSTUDIO_DEFAULT_BASE_URL), options.fetch);
+    },
+    probe(options) {
+      return probeOpenAICompatibleRuntime({
+        id: "lmstudio",
+        baseURL: options.baseURL ?? LMSTUDIO_DEFAULT_BASE_URL,
+        fetch: options.fetch,
+        probedAt: options.probedAt
+      });
+    }
+  };
+}
+
+// src/local/ollama.ts
+var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
+function createOllamaAdapter() {
+  return {
+    id: "ollama",
+    defaultBaseURL: OLLAMA_DEFAULT_BASE_URL,
+    listModels(options) {
+      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? OLLAMA_DEFAULT_BASE_URL), options.fetch);
+    },
+    probe(options) {
+      return probeOpenAICompatibleRuntime({
+        id: "ollama",
+        baseURL: options.baseURL ?? OLLAMA_DEFAULT_BASE_URL,
+        fetch: options.fetch,
+        probedAt: options.probedAt
+      });
+    }
+  };
+}
+
+// src/local/registry.ts
+class RuntimeRegistry {
+  adapters;
+  clock;
+  fetch;
+  foundryDiscovery;
+  constructor(options) {
+    this.adapters = {
+      ollama: createOllamaAdapter(),
+      lmstudio: createLMStudioAdapter(),
+      "foundry-local": createFoundryLocalAdapter(),
+      ...options.adapters
+    };
+    this.clock = options.clock;
+    this.fetch = options.fetch;
+    this.foundryDiscovery = options.foundryDiscovery;
+  }
+  async probe(runtimes) {
+    const snapshots = [];
+    for (const runtime of runtimes) {
+      if (!runtime.enabled) {
+        continue;
+      }
+      const probedAt = this.clock();
+      const adapter = this.adapters[runtime.id];
+      const options = this.createProbeOptions(runtime, probedAt);
+      try {
+        snapshots.push(await adapter.probe(options));
+      } catch (error) {
+        snapshots.push(unavailableSnapshot({
+          id: runtime.id,
+          baseURL: runtime.baseURL ?? adapter.defaultBaseURL ?? "",
+          probedAt,
+          error: `Adapter threw unexpectedly: ${errorMessage(error)}`
+        }));
+      }
+    }
+    return snapshots;
+  }
+  createProbeOptions(runtime, probedAt) {
+    const options = {
+      fetch: this.fetch,
+      probedAt
+    };
+    if (runtime.baseURL !== undefined) {
+      options.baseURL = runtime.baseURL;
+    }
+    if (runtime.id === "foundry-local" && runtime.discovery !== "manual" && this.foundryDiscovery !== undefined) {
+      options.discovery = this.foundryDiscovery;
+    }
+    return options;
+  }
+}
+
+// src/telemetry/read.ts
+import { readFile } from "node:fs/promises";
+
+// src/telemetry/types.ts
+import { z as z3 } from "zod";
+
+// src/capabilities/types.ts
+import { z as z2 } from "zod";
+var CapabilityTierSchema = z2.union([
+  z2.literal(0),
+  z2.literal(1),
+  z2.literal(2),
+  z2.literal(3),
+  z2.literal(4),
+  z2.literal(5)
+]);
+var ComplexityTierSchema = z2.enum([
+  "trivial",
+  "simple",
+  "moderate",
+  "hard"
+]);
+var ModelCapabilityProfileSchema = z2.object({
+  ref: z2.object({
+    providerID: z2.string().min(1),
+    modelID: z2.string().min(1)
+  }),
+  kind: z2.enum(["local", "frontier", "router"]),
+  contextWindow: z2.number().int().positive(),
+  maxOutputTokens: z2.number().int().positive(),
+  supportsToolCalling: z2.boolean(),
+  supportsVision: z2.boolean(),
+  reasoningTier: CapabilityTierSchema,
+  codeQualityTier: CapabilityTierSchema,
+  costPer1M: z2.object({
+    inputUSD: z2.number().min(0),
+    outputUSD: z2.number().min(0)
+  }),
+  availability: z2.enum(["available", "degraded", "unavailable"])
+});
+
+// src/telemetry/types.ts
+var CostRecordSchema = z3.object({
+  ts: z3.number().finite(),
+  sessionID: z3.string().min(1).optional(),
+  promptHash: z3.string().min(1),
+  promptChars: z3.number().int().min(0),
+  tier: ComplexityTierSchema,
+  routeKind: z3.enum(["local", "frontier"]),
+  selected: ModelRefSchema,
+  rationale: z3.string(),
+  estimatedCostUSD: z3.number().finite().min(0),
+  baselineCostUSD: z3.number().finite().min(0),
+  estimatedSavingsUSD: z3.number().finite(),
+  budgetAction: z3.string().min(1),
+  tokensIn: z3.number().int().min(0).optional(),
+  tokensOut: z3.number().int().min(0).optional()
+});
+
+// src/telemetry/read.ts
+var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
+function parseCostRecordsJsonl(text) {
+  const records = [];
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    let candidate;
+    try {
+      candidate = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const parsed = CostRecordSchema.safeParse(candidate);
+    if (parsed.success) {
+      records.push(parsed.data);
+    }
+  }
+  return records;
+}
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readCostRecords(path, deps = {}) {
+  const readFileFn = deps.readFile ?? readFile;
+  try {
+    const content = await readFileFn(path, "utf8");
+    return parseCostRecordsJsonl(content);
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+// src/cli.ts
+var execFileAsync = promisify(execFile);
+function isMissingFile2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var nodeExec = async (command, args) => {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, [...args]);
+    return { exitCode: 0, stdout, stderr };
+  } catch (error) {
+    const err = error;
+    return {
+      exitCode: typeof err.code === "number" ? err.code : 1,
+      stdout: err.stdout ?? "",
+      stderr: err.stderr ?? String(error)
+    };
+  }
+};
+async function loadConfig(path) {
+  try {
+    const content = await readFile2(path, "utf8");
+    return loadOpenTeamConfig(JSON.parse(content));
+  } catch (error) {
+    if (isMissingFile2(error)) {
+      return loadOpenTeamConfig({});
+    }
+    throw error;
+  }
+}
+var deps = {
+  loadConfig,
+  saveConfig: (config, path) => writeOpenTeamConfigFile(config, path),
+  probe: (config) => {
+    const registry = new RuntimeRegistry({
+      fetch: globalThis.fetch,
+      clock: () => new Date().toISOString(),
+      foundryDiscovery: foundryDiscoveryFromExec(nodeExec)
+    });
+    return registry.probe(config.local.runtimes);
+  },
+  readTelemetry: (path) => readCostRecords(path),
+  configPath: DEFAULT_CONFIG_PATH,
+  telemetryPath: DEFAULT_TELEMETRY_PATH
+};
+async function main() {
+  const result = await runCli(process.argv.slice(2), deps);
+  process.stdout.write(`${result.stdout}
+`);
+  process.exitCode = result.exitCode;
+}
+main();