@jmanuelcorral/openteam 0.1.0

package/dist/index.js

@@ -0,0 +1,1199 @@
+// src/index.ts
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// 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/config/load.ts
+function loadOpenTeamConfig(raw) {
+  return OpenTeamConfigSchema.parse(raw ?? {});
+}
+
+// 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/plugin/availability.ts
+function modelKey(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function compareAvailableModels(left, right) {
+  const kindOrder = Number(left.kind === "frontier") - Number(right.kind === "frontier");
+  if (kindOrder !== 0) {
+    return kindOrder;
+  }
+  return modelKey(left).localeCompare(modelKey(right));
+}
+function uniqueSelections(models) {
+  const byKey = new Map;
+  for (const model of models) {
+    byKey.set(modelKey(model), model);
+  }
+  return [...byKey.values()].sort((left, right) => modelKey(left).localeCompare(modelKey(right)));
+}
+function frontierBaselines(config) {
+  const baselines = [];
+  if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
+    baselines.push(config.baseline.pinnedModel);
+  }
+  baselines.push(config.baseline.hardDefault);
+  return uniqueSelections(baselines);
+}
+function defaultLocalModels(config) {
+  const enabledDefaults = config.local.runtimes.filter((runtime) => runtime.enabled).map((runtime) => runtime.defaultModel);
+  return uniqueSelections(enabledDefaults.length > 0 ? enabledDefaults : [config.router.localDefault]);
+}
+function cloneAvailableModels(models) {
+  return models.map((model) => ({ ...model }));
+}
+function defaultAvailableModels(config) {
+  return [
+    ...defaultLocalModels(config).map((model) => ({
+      ...model,
+      kind: "local",
+      available: true
+    })),
+    ...frontierBaselines(config).map((model) => ({
+      ...model,
+      kind: "frontier",
+      available: true
+    }))
+  ].sort(compareAvailableModels);
+}
+function toAvailableModels(snapshots, config) {
+  const localModels = snapshots.flatMap((snapshot) => snapshot.models.map((model) => {
+    const availableModel = {
+      providerID: snapshot.id,
+      modelID: model.modelID,
+      kind: "local",
+      available: snapshot.reachable
+    };
+    if (model.supportsTools !== "unknown") {
+      availableModel.supportsTools = model.supportsTools;
+    }
+    if (model.contextWindow !== undefined) {
+      availableModel.contextWindow = model.contextWindow;
+    }
+    return availableModel;
+  }));
+  const frontierModels = frontierBaselines(config).map((model) => ({
+    ...model,
+    kind: "frontier",
+    available: true
+  }));
+  return [...localModels, ...frontierModels].sort(compareAvailableModels);
+}
+function createAvailabilityCache(options) {
+  let cached = defaultAvailableModels(options.config);
+  let inFlight;
+  async function refreshNow() {
+    try {
+      const snapshots = await options.registry.probe(options.config.local.runtimes);
+      cached = toAvailableModels(snapshots, options.config);
+    } catch (error) {
+      options.onRefreshError?.(error);
+    }
+  }
+  return {
+    get: () => cloneAvailableModels(cached),
+    refresh: () => {
+      inFlight ??= refreshNow().finally(() => {
+        inFlight = undefined;
+      });
+      return inFlight;
+    }
+  };
+}
+
+// src/capabilities/budget.ts
+var WARNING_UTILIZATION = 0.8;
+function projectedSpend(current, estimatedCostUSD) {
+  return Math.max(0, current) + Math.max(0, estimatedCostUSD);
+}
+function budgetExceeded(projected, limit) {
+  return limit !== undefined && projected >= limit;
+}
+function budgetNearLimit(projected, limit) {
+  return limit !== undefined && projected >= limit * WARNING_UTILIZATION && projected < limit;
+}
+function exhaustedDecision(budgets, reason) {
+  return {
+    action: budgets.hardStopOnBudgetExhaustion ? "blockFrontier" : "forceLocal",
+    reason
+  };
+}
+function evaluateBudget(state, estimatedCostUSD, budgets) {
+  const projectedSessionUSD = projectedSpend(state.sessionUSD, estimatedCostUSD);
+  const projectedMonthlyUSD = budgets.monthlyUSD === undefined ? undefined : projectedSpend(state.monthlyUSD ?? 0, estimatedCostUSD);
+  if (budgetExceeded(projectedSessionUSD, budgets.sessionUSD)) {
+    return exhaustedDecision(budgets, "session-budget-exhausted");
+  }
+  if (budgetExceeded(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
+    return exhaustedDecision(budgets, "monthly-budget-exhausted");
+  }
+  if (state.frontierTokens !== undefined && budgets.frontierTokensPerSession !== undefined && state.frontierTokens >= budgets.frontierTokensPerSession) {
+    return exhaustedDecision(budgets, "frontier-token-budget-exhausted");
+  }
+  if (budgetNearLimit(projectedSessionUSD, budgets.sessionUSD)) {
+    return { action: "warn", reason: "session-budget-near-limit" };
+  }
+  if (budgetNearLimit(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
+    return { action: "warn", reason: "monthly-budget-near-limit" };
+  }
+  return { action: "ok" };
+}
+
+// src/capabilities/classify.ts
+var hardKeywords = [
+  "security",
+  "auth",
+  "authentication",
+  "authorization",
+  "concurrency",
+  "race condition",
+  "architecture",
+  "refactor",
+  "migration",
+  "debug",
+  "root cause"
+];
+function scoreOverride(override) {
+  if (override === "alwaysFrontier") {
+    return 30;
+  }
+  if (override === "alwaysLocal") {
+    return -20;
+  }
+  return 0;
+}
+function tierFromScore(score) {
+  if (score <= 15) {
+    return "trivial";
+  }
+  if (score <= 35) {
+    return "simple";
+  }
+  if (score <= 65) {
+    return "moderate";
+  }
+  return "hard";
+}
+function confidenceFromScore(score) {
+  if (score >= 75 || score <= 10) {
+    return 0.9;
+  }
+  if (score >= 30 && score <= 70) {
+    return 0.58;
+  }
+  return 0.72;
+}
+function addScore(condition, amount, reason, state) {
+  if (condition) {
+    state.score += amount;
+    state.reasons.push(reason);
+  }
+}
+function classifyHeuristic(task) {
+  const state = { score: scoreOverride(task.explicitOverride), reasons: [] };
+  const prompt = task.prompt?.toLowerCase() ?? "";
+  const estimatedTokens = (task.estimatedInputTokens ?? 0) + (task.estimatedOutputTokens ?? 0);
+  addScore(task.promptChars <= 80 && !task.hasCode && task.requiresTools !== true, -5, "short-text-prompt", state);
+  addScore(task.promptChars > 1500 || estimatedTokens > 700, 10, "large-prompt", state);
+  addScore(task.promptChars > 5000 || estimatedTokens > 3000, 15, "very-large-context", state);
+  addScore(task.hasCode, 15, "code-present", state);
+  addScore(task.requiresTools === true, 15, "tools-required", state);
+  addScore(task.requiresVision === true, 15, "vision-required", state);
+  addScore((task.fileCount ?? 0) > 1, 20, "multi-file-task", state);
+  addScore((task.diffHunks ?? 0) > 2, 15, "multi-hunk-diff", state);
+  addScore(hardKeywords.some((keyword) => prompt.includes(keyword)), 25, "hard-keyword", state);
+  addScore(task.userAskedForQuality === true, 20, "quality-requested", state);
+  addScore(task.privacySensitive === true, 10, "privacy-sensitive", state);
+  const normalizedScore = Math.max(0, Math.min(100, state.score));
+  return {
+    tier: tierFromScore(normalizedScore),
+    confidence: confidenceFromScore(normalizedScore),
+    reasons: state.reasons.length > 0 ? state.reasons : ["no-hard-signals"],
+    ambiguous: normalizedScore >= 30 && normalizedScore <= 70
+  };
+}
+
+// src/capabilities/select.ts
+var BLENDED_COST_INPUT_WEIGHT = 0.75;
+var BLENDED_COST_OUTPUT_WEIGHT = 1 - BLENDED_COST_INPUT_WEIGHT;
+var availabilityRank = {
+  available: 0,
+  degraded: 1,
+  unavailable: 2
+};
+var tierRequirements = {
+  trivial: { reasoning: 0, code: 1, context: 8000 },
+  simple: { reasoning: 1, code: 2, context: 16000 },
+  moderate: { reasoning: 3, code: 3, context: 32000 },
+  hard: { reasoning: 4, code: 5, context: 64000 }
+};
+function deriveRequirement(tier, task) {
+  const base = tierRequirements[tier];
+  const estimatedContext = (task.estimatedInputTokens ?? 0) + (task.estimatedOutputTokens ?? 0);
+  const contextFromPrompt = Math.ceil(task.promptChars / 4);
+  const minContextWindow = Math.max(base.context, estimatedContext, contextFromPrompt);
+  const codeBump = task.hasCode ? 1 : 0;
+  return {
+    minReasoningTier: base.reasoning,
+    minCodeQualityTier: Math.min(5, base.code + codeBump),
+    minContextWindow,
+    needsTools: task.requiresTools === true,
+    needsVision: task.requiresVision === true
+  };
+}
+function blendedCostPer1M(profile) {
+  return profile.costPer1M.inputUSD * BLENDED_COST_INPUT_WEIGHT + profile.costPer1M.outputUSD * BLENDED_COST_OUTPUT_WEIGHT;
+}
+function modelKey2(profile) {
+  return `${profile.ref.providerID}/${profile.ref.modelID}`;
+}
+function compareCapableFrontier(req, left, right) {
+  const costDelta = blendedCostPer1M(left) - blendedCostPer1M(right);
+  if (costDelta !== 0) {
+    return costDelta;
+  }
+  const availabilityDelta = availabilityRank[left.availability] - availabilityRank[right.availability];
+  if (availabilityDelta !== 0) {
+    return availabilityDelta;
+  }
+  const reasoningWasteDelta = left.reasoningTier - req.minReasoningTier - (right.reasoningTier - req.minReasoningTier);
+  if (reasoningWasteDelta !== 0) {
+    return reasoningWasteDelta;
+  }
+  return modelKey2(left).localeCompare(modelKey2(right));
+}
+function satisfiesRequirement(req, profile) {
+  return profile.kind === "frontier" && profile.availability !== "unavailable" && profile.contextWindow >= req.minContextWindow && profile.reasoningTier >= req.minReasoningTier && profile.codeQualityTier >= req.minCodeQualityTier && (!req.needsTools || profile.supportsToolCalling) && (!req.needsVision || profile.supportsVision);
+}
+function selectCheapestCapableFrontier(req, profiles) {
+  const selected = profiles.filter((profile) => satisfiesRequirement(req, profile)).sort((left, right) => compareCapableFrontier(req, left, right))[0];
+  return selected?.ref ?? null;
+}
+
+// src/router/chooseModel.ts
+function resolveConfiguredFrontierBaseline(config) {
+  if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
+    return config.baseline.pinnedModel;
+  }
+  return config.baseline.hardDefault;
+}
+function resolveFrontierBaseline(input, tier) {
+  if (input.config.baseline.mode === "pinned" && input.config.baseline.pinnedModel !== null) {
+    return { model: input.config.baseline.pinnedModel, rationale: [] };
+  }
+  if (input.profiles !== undefined) {
+    const selected = selectCheapestCapableFrontier(deriveRequirement(tier, input.task), input.profiles);
+    if (selected !== null) {
+      return {
+        model: selected,
+        rationale: ["auto-cheapest-capable-frontier"]
+      };
+    }
+    return {
+      model: input.config.baseline.hardDefault,
+      rationale: ["auto-cheapest-capable-unavailable-hard-default"]
+    };
+  }
+  return { model: input.config.baseline.hardDefault, rationale: [] };
+}
+function localDefault(config) {
+  return config.local.runtimes.find((runtime) => runtime.enabled)?.defaultModel ?? config.router.localDefault;
+}
+function modelKey3(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function sameModel(left, right) {
+  return left.providerID === right.providerID && left.modelID === right.modelID;
+}
+function compareModels(left, right) {
+  return modelKey3(left).localeCompare(modelKey3(right));
+}
+function uniqueModelSelections(models) {
+  const byKey = new Map;
+  for (const model of models) {
+    byKey.set(modelKey3(model), model);
+  }
+  return [...byKey.values()].sort(compareModels);
+}
+function defaultAvailableModels2(config) {
+  return [
+    {
+      ...localDefault(config),
+      kind: "local",
+      available: true
+    },
+    {
+      ...resolveConfiguredFrontierBaseline(config),
+      kind: "frontier",
+      available: true
+    }
+  ].sort(compareAvailableModels2);
+}
+function compareAvailableModels2(left, right) {
+  return compareModels(left, right);
+}
+function availableModels(input) {
+  return (input.availableModels ?? defaultAvailableModels2(input.config)).slice().sort(compareAvailableModels2);
+}
+function listedModel(input, model) {
+  return availableModels(input).find((candidate) => sameModel(candidate, model));
+}
+function localStatus(input, model) {
+  const listed = listedModel(input, model);
+  return {
+    available: input.availableModels === undefined ? listed?.available !== false : listed?.available === true,
+    missingTools: input.task.requiresTools === true && listed?.supportsTools === false
+  };
+}
+function frontierAvailable(input, model) {
+  return listedModel(input, model)?.available !== false;
+}
+function localCandidateIsUsable(input, model) {
+  return model.kind === "local" && model.available && !(input.task.requiresTools === true && model.supportsTools === false);
+}
+function availableLocalFallbacks(input, selected) {
+  return uniqueModelSelections(availableModels(input).filter((model) => localCandidateIsUsable(input, model)).filter((model) => !sameModel(model, selected)).map((model) => ({
+    providerID: model.providerID,
+    modelID: model.modelID
+  })));
+}
+function buildFallbackChain(input, selected, frontier, allowFrontier) {
+  const chain = availableLocalFallbacks(input, selected);
+  if (allowFrontier && !sameModel(frontier, selected) && frontierAvailable(input, frontier)) {
+    chain.push(frontier);
+  }
+  return chain;
+}
+function inferRouteKind(config, selected, listed) {
+  if (listed !== undefined) {
+    return listed.kind;
+  }
+  return config.local.runtimes.some((runtime) => sameModel(runtime.defaultModel, selected)) ? "local" : "frontier";
+}
+function localFallbackReason(status) {
+  return status.missingTools ? "local-missing-tools-fallback" : "local-unavailable-fallback";
+}
+function decision(selected, routeKind, rationale, fallbackChain) {
+  return {
+    selected,
+    routeKind,
+    rationale,
+    fallbackChain
+  };
+}
+function resolveLocalPrimary(input, primary, frontier, options) {
+  const status = localStatus(input, primary);
+  if (status.available && !status.missingTools) {
+    return decision(primary, "local", options.baseRationale, buildFallbackChain(input, primary, frontier, options.allowFrontier));
+  }
+  const fallbackReason = localFallbackReason(status);
+  const nextLocal = availableLocalFallbacks(input, primary)[0];
+  if (nextLocal !== undefined) {
+    return decision(nextLocal, "local", [...options.baseRationale, fallbackReason], buildFallbackChain(input, nextLocal, frontier, options.allowFrontier));
+  }
+  if (!options.allowFrontier) {
+    return decision(primary, "local", [...options.baseRationale, fallbackReason, options.noLocalRationale], []);
+  }
+  if (frontierAvailable(input, frontier)) {
+    return decision(frontier, "frontier", [...options.baseRationale, fallbackReason, "no-local-available-frontier"], []);
+  }
+  return decision(primary, "local", [...options.baseRationale, fallbackReason, "frontier-unavailable"], []);
+}
+function resolveFrontierPrimary(input, frontier, rationale) {
+  if (frontierAvailable(input, frontier)) {
+    return decision(frontier, "frontier", rationale, []);
+  }
+  const nextLocal = availableLocalFallbacks(input, frontier)[0];
+  if (nextLocal !== undefined) {
+    return decision(nextLocal, "local", [...rationale, "frontier-unavailable-fallback"], buildFallbackChain(input, nextLocal, frontier, false));
+  }
+  return decision(frontier, "frontier", [...rationale, "frontier-unavailable"], []);
+}
+function tierForInput(input) {
+  return input.tier ?? classifyHeuristic(input.task).tier;
+}
+function modelProfile(input, model) {
+  return input.profiles?.find((profile) => sameModel(profile.ref, model));
+}
+function estimatedCostUSD(input, model) {
+  const profile = modelProfile(input, model);
+  if (profile === undefined) {
+    return 0;
+  }
+  const inputTokens = input.task.estimatedInputTokens ?? 0;
+  const outputTokens = input.task.estimatedOutputTokens ?? 0;
+  return inputTokens / 1e6 * profile.costPer1M.inputUSD + outputTokens / 1e6 * profile.costPer1M.outputUSD;
+}
+function roundUSD(value) {
+  return Math.round(value * 1000000000000) / 1000000000000;
+}
+function finalizeDecision(input, tier, frontier, budgetAction, core) {
+  const selectedCostUSD = estimatedCostUSD(input, core.selected);
+  const baselineCostUSD = estimatedCostUSD(input, frontier.model);
+  const savingsUSD = core.routeKind === "frontier" && sameModel(core.selected, frontier.model) ? 0 : baselineCostUSD - selectedCostUSD;
+  return {
+    ...core,
+    tier,
+    rationale: [...frontier.rationale, ...core.rationale],
+    estimatedCostUSD: roundUSD(selectedCostUSD),
+    baselineCostUSD: roundUSD(baselineCostUSD),
+    estimatedSavingsUSD: roundUSD(savingsUSD),
+    budgetAction
+  };
+}
+function chooseModel(input) {
+  const tier = tierForInput(input);
+  const local = localDefault(input.config);
+  const frontier = resolveFrontierBaseline(input, tier);
+  const frontierCostUSD = estimatedCostUSD(input, frontier.model);
+  const budgetAction = input.budgetState === undefined ? { action: "ok" } : evaluateBudget(input.budgetState, frontierCostUSD, input.config.budgets);
+  const override = input.task.explicitOverride;
+  if (input.task.privacySensitive === true && input.config.privacyMode === "forceLocalOnSensitive") {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: ["privacy-force-local"],
+      allowFrontier: false,
+      noLocalRationale: "privacy-force-local-unavailable"
+    }));
+  }
+  if (budgetAction.action === "forceLocal" || budgetAction.action === "blockFrontier") {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: [`budget-${budgetAction.action}`],
+      allowFrontier: false,
+      noLocalRationale: "budget-local-unavailable"
+    }));
+  }
+  if (typeof override === "object") {
+    return finalizeDecision(input, tier, frontier, budgetAction, decision(override, inferRouteKind(input.config, override, listedModel(input, override)), ["explicit-model-override"], buildFallbackChain(input, override, frontier.model, true)));
+  }
+  if (override === "alwaysLocal") {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: ["explicit-always-local"],
+      allowFrontier: false,
+      noLocalRationale: "forced-local-unavailable"
+    }));
+  }
+  if (override === "alwaysFrontier") {
+    return finalizeDecision(input, tier, frontier, budgetAction, decision(frontier.model, "frontier", ["explicit-always-frontier"], []));
+  }
+  const shortEnoughForLocal = input.task.promptChars <= input.config.router.trivialPromptMaxChars;
+  const largeEnoughForFrontier = input.task.promptChars >= input.config.router.frontierPromptMinChars;
+  if (!input.task.hasCode && shortEnoughForLocal && !largeEnoughForFrontier) {
+    return finalizeDecision(input, tier, frontier, budgetAction, resolveLocalPrimary(input, local, frontier.model, {
+      baseRationale: ["trivial-short-no-code"],
+      allowFrontier: true,
+      noLocalRationale: "forced-local-unavailable"
+    }));
+  }
+  return finalizeDecision(input, tier, frontier, budgetAction, resolveFrontierPrimary(input, frontier.model, [
+    input.task.hasCode ? "code-detected" : "large-or-nontrivial-prompt"
+  ]));
+}
+
+// src/telemetry/cost.ts
+function routeKind(decision2) {
+  return decision2.routeKind === "local" ? "local" : "frontier";
+}
+function budgetAction(decision2) {
+  const reason = decision2.budgetAction.reason;
+  return reason === undefined ? decision2.budgetAction.action : `${decision2.budgetAction.action}:${reason}`;
+}
+function toCostRecord(decision2, context) {
+  const record = {
+    ts: context.ts,
+    promptHash: context.promptHash,
+    promptChars: context.promptChars,
+    tier: decision2.tier,
+    routeKind: routeKind(decision2),
+    selected: decision2.selected,
+    rationale: decision2.rationale.join(","),
+    estimatedCostUSD: decision2.estimatedCostUSD,
+    baselineCostUSD: decision2.baselineCostUSD,
+    estimatedSavingsUSD: decision2.estimatedSavingsUSD,
+    budgetAction: budgetAction(decision2)
+  };
+  if (context.sessionID !== undefined) {
+    record.sessionID = context.sessionID;
+  }
+  if (context.tokensIn !== undefined) {
+    record.tokensIn = context.tokensIn;
+  }
+  if (context.tokensOut !== undefined) {
+    record.tokensOut = context.tokensOut;
+  }
+  return record;
+}
+
+// src/telemetry/hash.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+function hashPrompt(prompt) {
+  let hash = FNV_OFFSET_BASIS;
+  for (let index = 0;index < prompt.length; index += 1) {
+    hash ^= prompt.charCodeAt(index);
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+// 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/sink.ts
+function createJsonlSink(deps) {
+  return {
+    record: async (record) => {
+      try {
+        const parsed = CostRecordSchema.parse(record);
+        await deps.append(`${JSON.stringify(parsed)}
+`);
+      } catch (error) {
+        deps.onError?.(error);
+      }
+    }
+  };
+}
+function createNullSink() {
+  return {
+    record: () => {}
+  };
+}
+
+// src/plugin/hooks.ts
+var codeSignals = [
+  "```",
+  "function ",
+  "class ",
+  "const ",
+  "let ",
+  "import ",
+  "export ",
+  "diff --git"
+];
+var sensitiveSignals = [
+  "api key",
+  "apikey",
+  "token",
+  "password",
+  "secret",
+  "private key",
+  "confidential"
+];
+function partText(part) {
+  return part.type === "text" && typeof part.text === "string" ? part.text : "";
+}
+function partRequiresTools(part) {
+  return typeof part.type === "string" && part.type.toLowerCase().includes("tool");
+}
+function promptText(output) {
+  return output.parts.map(partText).join(`
+`);
+}
+function emitTelemetry(sink, record) {
+  Promise.resolve().then(() => sink.record(record)).catch(() => {});
+}
+function deriveTaskSignals(input, output) {
+  const prompt = promptText(output);
+  const lowerPrompt = prompt.toLowerCase();
+  const signals = {
+    promptChars: prompt.length,
+    hasCode: codeSignals.some((signal) => lowerPrompt.includes(signal))
+  };
+  if (sensitiveSignals.some((signal) => lowerPrompt.includes(signal))) {
+    signals.privacySensitive = true;
+  }
+  if (output.parts.some(partRequiresTools)) {
+    signals.requiresTools = true;
+  }
+  if (input.model !== undefined) {
+    signals.explicitOverride = input.model;
+  }
+  return signals;
+}
+function createChatMessageHook(config, getAvailable, options = {}) {
+  const sink = options.sink ?? createNullSink();
+  const now = options.now ?? Date.now;
+  return async (input, output) => {
+    const signals = deriveTaskSignals(input, output);
+    const decision2 = chooseModel({
+      config,
+      task: signals,
+      availableModels: getAvailable()
+    });
+    output.message.model = decision2.selected;
+    const telemetryContext = {
+      ts: now(),
+      promptHash: hashPrompt(promptText(output)),
+      promptChars: signals.promptChars,
+      sessionID: input.sessionID ?? output.message.sessionID
+    };
+    if (signals.estimatedInputTokens !== undefined) {
+      telemetryContext.tokensIn = signals.estimatedInputTokens;
+    }
+    if (signals.estimatedOutputTokens !== undefined) {
+      telemetryContext.tokensOut = signals.estimatedOutputTokens;
+    }
+    emitTelemetry(sink, toCostRecord(decision2, telemetryContext));
+  };
+}
+function createHooks(config, getAvailable, options = {}) {
+  return {
+    "chat.message": createChatMessageHook(config, getAvailable, options)
+  };
+}
+
+// src/index.ts
+var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
+function createShellExec($) {
+  return async (command, args) => {
+    const output = await $`${command} ${[...args]}`.nothrow().quiet();
+    return {
+      exitCode: output.exitCode,
+      stdout: output.stdout.toString(),
+      stderr: output.stderr.toString()
+    };
+  };
+}
+function logAvailabilityRefreshError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[openteam] availability refresh failed: ${message}`);
+}
+function logTelemetryError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[openteam] telemetry write failed: ${message}`);
+}
+function telemetryOptions(rawOptions) {
+  const telemetry = rawOptions !== null && typeof rawOptions === "object" && "telemetry" in rawOptions && rawOptions.telemetry !== null && typeof rawOptions.telemetry === "object" ? rawOptions.telemetry : {};
+  const enabled = !("enabled" in telemetry) || telemetry.enabled !== false;
+  const configuredPath = "path" in telemetry && typeof telemetry.path === "string" ? telemetry.path : DEFAULT_TELEMETRY_PATH;
+  return {
+    enabled,
+    path: configuredPath
+  };
+}
+function createFileAppender(filePath, deps = {}) {
+  const mkdirFn = deps.mkdir ?? mkdir;
+  const appendFileFn = deps.appendFile ?? appendFile;
+  return async (line) => {
+    await mkdirFn(dirname(filePath), { recursive: true });
+    await appendFileFn(filePath, line, "utf8");
+  };
+}
+function createTelemetrySink(rawOptions) {
+  const options = telemetryOptions(rawOptions);
+  if (!options.enabled) {
+    return createNullSink();
+  }
+  return createJsonlSink({
+    append: createFileAppender(options.path),
+    onError: logTelemetryError
+  });
+}
+var server = async (ctx, rawOptions) => {
+  const config = loadOpenTeamConfig(rawOptions ?? {});
+  const registry = new RuntimeRegistry({
+    fetch: globalThis.fetch,
+    clock: () => new Date().toISOString(),
+    foundryDiscovery: foundryDiscoveryFromExec(createShellExec(ctx.$))
+  });
+  const cache = createAvailabilityCache({
+    config,
+    registry,
+    onRefreshError: logAvailabilityRefreshError
+  });
+  cache.refresh();
+  const hooks = createHooks(config, cache.get, {
+    sink: createTelemetrySink(rawOptions)
+  });
+  return {
+    ...hooks,
+    event: async ({ event }) => {
+      if (event.type === "session.created" || event.type === "session.idle") {
+        cache.refresh();
+      }
+    }
+  };
+};
+var plugin = {
+  id: "openteam",
+  server
+};
+var src_default = plugin;
+export {
+  server,
+  logTelemetryError,
+  logAvailabilityRefreshError,
+  src_default as default,
+  createFileAppender
+};