skyloom 1.12.0 → 1.13.0

package/src/core/arbitrate.ts

@@ -1,162 +1,162 @@
-/**
- * 多Agent冲突仲裁 — majority voting, quality scoring, tie-breaking.
- *
- * When multiple agents produce conflicting outputs on the same task
- * (or when a reviewer disagrees with an executor), this module
- * provides structured conflict resolution.
- */
-
-import type { TaskExecutionResult } from "./factory";
-
-/* ═══════════════════════════════════════
-   Conflict detection
-   ═══════════════════════════════════════ */
-export interface Conflict {
-  taskId: string;
-  results: TaskExecutionResult[];
-  description: string;
-  severity: "low" | "medium" | "high";
-}
-
-/** Detect if two results conflict based on success status and content overlap. */
-export function detectConflicts(results: TaskExecutionResult[]): Conflict[] {
-  const byTask = new Map<string, TaskExecutionResult[]>();
-  for (const r of results) { const id = r.id; if (!byTask.has(id)) byTask.set(id, []); byTask.get(id)!.push(r); }
-
-  const conflicts: Conflict[] = [];
-  for (const [id, items] of byTask) {
-    if (items.length < 2) continue;
-
-    const successes = items.filter(r => r.success);
-    const failures = items.filter(r => !r.success);
-
-    // All succeeded — check content divergence
-    if (successes.length >= 2) {
-      const contents = successes.map(r => (r.content || "").toLowerCase());
-      const similarity = pairwiseSimilarity(contents);
-      if (similarity < 0.3) {
-        conflicts.push({ taskId: id, results: successes, description: "Multiple agents produced divergent successful outputs", severity: "medium" });
-      }
-    }
-
-    // Mix of success and failure
-    if (successes.length > 0 && failures.length > 0) {
-      conflicts.push({ taskId: id, results: items, description: `${successes.length} succeeded, ${failures.length} failed — need tiebreaker`, severity: "medium" });
-    }
-
-    // All failed
-    if (failures.length >= 2 && successes.length === 0) {
-      conflicts.push({ taskId: id, results: failures, description: "All agents failed on this task", severity: "high" });
-    }
-  }
-
-  return conflicts;
-}
-
-/* ═══════════════════════════════════════
-   Content similarity (n-gram Jaccard)
-   ═══════════════════════════════════════ */
-function pairwiseSimilarity(texts: string[]): number {
-  if (texts.length < 2) return 1.0;
-  let total = 0;
-  let count = 0;
-  for (let i = 0; i < texts.length; i++) {
-    for (let j = i + 1; j < texts.length; j++) {
-      total += ngramJaccard(texts[i], texts[j], 3);
-      count++;
-    }
-  }
-  return count === 0 ? 0 : total / count;
-}
-
-function ngramJaccard(a: string, b: string, n: number): number {
-  const as = ngrams(a, n), bs = ngrams(b, n);
-  if (as.size === 0 && bs.size === 0) return 1;
-  let intersection = 0;
-  for (const g of as) { if (bs.has(g)) intersection++; }
-  const union = as.size + bs.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-function ngrams(s: string, n: number): Set<string> {
-  const out = new Set<string>();
-  for (let i = 0; i <= s.length - n; i++) out.add(s.slice(i, i + n));
-  return out;
-}
-
-/* ═══════════════════════════════════════
-   Majority voting / arbitration
-   ═══════════════════════════════════════ */
-export interface ArbitrationResult {
-  winner: TaskExecutionResult;
-  method: "unanimous" | "majority" | "tiebreaker" | "single";
-  confidence: number; // 0-1
-  reasoning: string;
-}
-
-/** Pick the best result from conflicting ones via majority vote. */
-export function arbitrate(results: TaskExecutionResult[]): ArbitrationResult {
-  if (results.length === 0) throw new Error("No results to arbitrate");
-  if (results.length === 1) return { winner: results[0], method: "single", confidence: 0.8, reasoning: "Only one result available" };
-
-  const success = results.filter(r => r.success);
-  const fail = results.filter(r => !r.success);
-
-  // All agree (success)
-  if (success.length === results.length) {
-    const longest = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
-    return { winner: longest, method: "unanimous", confidence: 0.95, reasoning: `${results.length}/${results.length} agents agreed` };
-  }
-
-  // Majority success
-  if (success.length > fail.length) {
-    // Pick the longest successful content (most detailed)
-    const best = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
-    return { winner: best, method: "majority", confidence: success.length / results.length, reasoning: `${success.length}/${results.length} succeeded, selected most detailed` };
-  }
-
-  // Majority failure — pick the "closest to success" (longest content)
-  if (fail.length > success.length) {
-    const best = fail.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
-    return { winner: best, method: "majority", confidence: 0.3, reasoning: `Majority failed (${fail.length}/${results.length}), best-effort from partial output` };
-  }
-
-  // Tie — prefer success, or longest content
-  const tie = success.length > 0 ? success[0] : fail[0];
-  return { winner: tie, method: "tiebreaker", confidence: 0.5, reasoning: `Tie — selected ${tie.success ? "success" : "longest"} result` };
-}
-
-/* ═══════════════════════════════════════
-   Quality scoring for individual results
-   ═══════════════════════════════════════ */
-export interface QualityScore {
-  score: number;         // 0-100
-  completeness: number;  // how much of the task was addressed
-  richness: number;      // detail level of the output
-  correctness: number;   // did it match expectations (requires ground truth)
-}
-
-export function scoreQuality(result: TaskExecutionResult): QualityScore {
-  const content = result.content || "";
-
-  // Completeness: length is a weak proxy but useful
-  const completeness = content.length > 500 ? 80 : content.length > 100 ? 50 : content.length > 0 ? 20 : 0;
-
-  // Richness: code blocks, structured output, bullet points
-  let richness = 50;
-  if (/```/.test(content)) richness += 20;
-  if (/\|.*\|.*\|/.test(content)) richness += 15; // tables
-  if (/^[-*] /.test(content)) richness += 10;      // bullets
-  if (/\d+\./.test(content)) richness += 10;        // numbered lists
-  richness = Math.min(100, richness);
-
-  // Correctness: basic sanity checks
-  let correctness = 70;
-  if (content.includes("Error") || content.includes("error")) correctness -= 20;
-  if (content.includes("[REDACTED]")) correctness -= 10;
-  if (content.includes("truncated")) correctness -= 15;
-  correctness = Math.max(0, correctness);
-
-  const score = Math.round((completeness * 0.3 + richness * 0.3 + correctness * 0.4));
-  return { score, completeness, richness, correctness };
-}
+/**
+ * 多Agent冲突仲裁 — majority voting, quality scoring, tie-breaking.
+ *
+ * When multiple agents produce conflicting outputs on the same task
+ * (or when a reviewer disagrees with an executor), this module
+ * provides structured conflict resolution.
+ */
+
+import type { TaskExecutionResult } from "./factory";
+
+/* ═══════════════════════════════════════
+   Conflict detection
+   ═══════════════════════════════════════ */
+export interface Conflict {
+  taskId: string;
+  results: TaskExecutionResult[];
+  description: string;
+  severity: "low" | "medium" | "high";
+}
+
+/** Detect if two results conflict based on success status and content overlap. */
+export function detectConflicts(results: TaskExecutionResult[]): Conflict[] {
+  const byTask = new Map<string, TaskExecutionResult[]>();
+  for (const r of results) { const id = r.id; if (!byTask.has(id)) byTask.set(id, []); byTask.get(id)!.push(r); }
+
+  const conflicts: Conflict[] = [];
+  for (const [id, items] of byTask) {
+    if (items.length < 2) continue;
+
+    const successes = items.filter(r => r.success);
+    const failures = items.filter(r => !r.success);
+
+    // All succeeded — check content divergence
+    if (successes.length >= 2) {
+      const contents = successes.map(r => (r.content || "").toLowerCase());
+      const similarity = pairwiseSimilarity(contents);
+      if (similarity < 0.3) {
+        conflicts.push({ taskId: id, results: successes, description: "Multiple agents produced divergent successful outputs", severity: "medium" });
+      }
+    }
+
+    // Mix of success and failure
+    if (successes.length > 0 && failures.length > 0) {
+      conflicts.push({ taskId: id, results: items, description: `${successes.length} succeeded, ${failures.length} failed — need tiebreaker`, severity: "medium" });
+    }
+
+    // All failed
+    if (failures.length >= 2 && successes.length === 0) {
+      conflicts.push({ taskId: id, results: failures, description: "All agents failed on this task", severity: "high" });
+    }
+  }
+
+  return conflicts;
+}
+
+/* ═══════════════════════════════════════
+   Content similarity (n-gram Jaccard)
+   ═══════════════════════════════════════ */
+function pairwiseSimilarity(texts: string[]): number {
+  if (texts.length < 2) return 1.0;
+  let total = 0;
+  let count = 0;
+  for (let i = 0; i < texts.length; i++) {
+    for (let j = i + 1; j < texts.length; j++) {
+      total += ngramJaccard(texts[i], texts[j], 3);
+      count++;
+    }
+  }
+  return count === 0 ? 0 : total / count;
+}
+
+function ngramJaccard(a: string, b: string, n: number): number {
+  const as = ngrams(a, n), bs = ngrams(b, n);
+  if (as.size === 0 && bs.size === 0) return 1;
+  let intersection = 0;
+  for (const g of as) { if (bs.has(g)) intersection++; }
+  const union = as.size + bs.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function ngrams(s: string, n: number): Set<string> {
+  const out = new Set<string>();
+  for (let i = 0; i <= s.length - n; i++) out.add(s.slice(i, i + n));
+  return out;
+}
+
+/* ═══════════════════════════════════════
+   Majority voting / arbitration
+   ═══════════════════════════════════════ */
+export interface ArbitrationResult {
+  winner: TaskExecutionResult;
+  method: "unanimous" | "majority" | "tiebreaker" | "single";
+  confidence: number; // 0-1
+  reasoning: string;
+}
+
+/** Pick the best result from conflicting ones via majority vote. */
+export function arbitrate(results: TaskExecutionResult[]): ArbitrationResult {
+  if (results.length === 0) throw new Error("No results to arbitrate");
+  if (results.length === 1) return { winner: results[0], method: "single", confidence: 0.8, reasoning: "Only one result available" };
+
+  const success = results.filter(r => r.success);
+  const fail = results.filter(r => !r.success);
+
+  // All agree (success)
+  if (success.length === results.length) {
+    const longest = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
+    return { winner: longest, method: "unanimous", confidence: 0.95, reasoning: `${results.length}/${results.length} agents agreed` };
+  }
+
+  // Majority success
+  if (success.length > fail.length) {
+    // Pick the longest successful content (most detailed)
+    const best = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
+    return { winner: best, method: "majority", confidence: success.length / results.length, reasoning: `${success.length}/${results.length} succeeded, selected most detailed` };
+  }
+
+  // Majority failure — pick the "closest to success" (longest content)
+  if (fail.length > success.length) {
+    const best = fail.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
+    return { winner: best, method: "majority", confidence: 0.3, reasoning: `Majority failed (${fail.length}/${results.length}), best-effort from partial output` };
+  }
+
+  // Tie — prefer success, or longest content
+  const tie = success.length > 0 ? success[0] : fail[0];
+  return { winner: tie, method: "tiebreaker", confidence: 0.5, reasoning: `Tie — selected ${tie.success ? "success" : "longest"} result` };
+}
+
+/* ═══════════════════════════════════════
+   Quality scoring for individual results
+   ═══════════════════════════════════════ */
+export interface QualityScore {
+  score: number;         // 0-100
+  completeness: number;  // how much of the task was addressed
+  richness: number;      // detail level of the output
+  correctness: number;   // did it match expectations (requires ground truth)
+}
+
+export function scoreQuality(result: TaskExecutionResult): QualityScore {
+  const content = result.content || "";
+
+  // Completeness: length is a weak proxy but useful
+  const completeness = content.length > 500 ? 80 : content.length > 100 ? 50 : content.length > 0 ? 20 : 0;
+
+  // Richness: code blocks, structured output, bullet points
+  let richness = 50;
+  if (/```/.test(content)) richness += 20;
+  if (/\|.*\|.*\|/.test(content)) richness += 15; // tables
+  if (/^[-*] /.test(content)) richness += 10;      // bullets
+  if (/\d+\./.test(content)) richness += 10;        // numbered lists
+  richness = Math.min(100, richness);
+
+  // Correctness: basic sanity checks
+  let correctness = 70;
+  if (content.includes("Error") || content.includes("error")) correctness -= 20;
+  if (content.includes("[REDACTED]")) correctness -= 10;
+  if (content.includes("truncated")) correctness -= 15;
+  correctness = Math.max(0, correctness);
+
+  const score = Math.round((completeness * 0.3 + richness * 0.3 + correctness * 0.4));
+  return { score, completeness, richness, correctness };
+}

package/src/core/catalog.ts

@@ -0,0 +1,178 @@
+/**
+ * Model & Provider Catalog — single source of truth.
+ *
+ * Replaces the three drifting copies of model data (config/models.yaml,
+ * the hardcoded setup-wizard list in cli/main.ts, and the README table)
+ * with one typed, validated catalog loaded from config/models.yaml.
+ *
+ * Every model exposed here is intended to be directly callable. Fictional
+ * or unreleased models must not appear in models.yaml.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+import { CONFIG_DIR } from "./config";
+import { getLogger } from "./logger";
+
+const log = getLogger("catalog");
+
+/** A single callable model. Costs are USD per 1M tokens. */
+export interface ModelInfo {
+  /** Model id as passed to the provider (e.g. "gpt-4o", "openai/gpt-4.1"). */
+  id: string;
+  /** Catalog provider key (e.g. "openai", "deepseek"). */
+  provider: string;
+  /** Context window in tokens. */
+  context: number;
+  /** Input cost, USD per 1M tokens. */
+  costIn: number;
+  /** Output cost, USD per 1M tokens. */
+  costOut: number;
+  /** Short human description. */
+  desc: string;
+  /** True for local/free providers (ollama, zero-cost). */
+  local: boolean;
+}
+
+/** Display + ordering metadata for a provider in setup/UI. */
+export interface ProviderMeta {
+  id: string;
+  /** Human label shown in the setup wizard. */
+  name: string;
+  /** Env var that supplies the API key (when applicable). */
+  envVar?: string;
+  /** Sort order in the wizard. */
+  order: number;
+}
+
+/**
+ * Provider display metadata. Ordering matches the setup wizard.
+ * Provider *ids* match the keys used in config/models.yaml.
+ */
+export const PROVIDER_META: Record<string, ProviderMeta> = {
+  deepseek: { id: "deepseek", name: "DeepSeek", envVar: "DEEPSEEK_API_KEY", order: 1 },
+  openai: { id: "openai", name: "OpenAI", envVar: "OPENAI_API_KEY", order: 2 },
+  anthropic: { id: "anthropic", name: "Anthropic", envVar: "ANTHROPIC_API_KEY", order: 3 },
+  google: { id: "google", name: "Google Gemini", envVar: "GEMINI_API_KEY", order: 4 },
+  groq: { id: "groq", name: "Groq", envVar: "GROQ_API_KEY", order: 5 },
+  openrouter: { id: "openrouter", name: "OpenRouter (多模型)", envVar: "OPENROUTER_API_KEY", order: 6 },
+  mistral: { id: "mistral", name: "Mistral", envVar: "MISTRAL_API_KEY", order: 7 },
+  xai: { id: "xai", name: "xAI (Grok)", envVar: "XAI_API_KEY", order: 8 },
+  ollama: { id: "ollama", name: "Ollama 本地", order: 9 },
+};
+
+/** Raw shape of an entry in config/models.yaml. */
+interface RawModelEntry {
+  name: string;
+  context?: number;
+  cost_in?: number;
+  cost_out?: number;
+  desc?: string;
+}
+
+let catalogCache: Map<string, ModelInfo[]> | null = null;
+
+function readModelsYaml(): Record<string, RawModelEntry[]> {
+  const modelPath = path.join(CONFIG_DIR, "models.yaml");
+  try {
+    if (!fs.existsSync(modelPath)) {
+      log.warn("models_yaml_missing", { path: modelPath });
+      return {};
+    }
+    const data = yaml.parse(fs.readFileSync(modelPath, "utf-8"));
+    return (data && typeof data === "object" ? data : {}) as Record<string, RawModelEntry[]>;
+  } catch (e) {
+    log.error("models_yaml_parse_failed", { error: String(e) });
+    return {};
+  }
+}
+
+/** Load (and cache) the full catalog as provider -> models. */
+export function loadCatalog(): Map<string, ModelInfo[]> {
+  if (catalogCache) return catalogCache;
+
+  const raw = readModelsYaml();
+  const catalog = new Map<string, ModelInfo[]>();
+
+  for (const [provider, entries] of Object.entries(raw)) {
+    if (!Array.isArray(entries)) continue;
+    const models: ModelInfo[] = [];
+    for (const e of entries) {
+      if (!e || typeof e.name !== "string") continue;
+      const costIn = e.cost_in ?? 0;
+      const costOut = e.cost_out ?? 0;
+      models.push({
+        id: e.name,
+        provider,
+        context: e.context ?? 0,
+        costIn,
+        costOut,
+        desc: e.desc ?? "",
+        local: provider === "ollama" || (costIn === 0 && costOut === 0),
+      });
+    }
+    if (models.length > 0) catalog.set(provider, models);
+  }
+
+  catalogCache = catalog;
+  return catalog;
+}
+
+/** Clear the cache (used by tests). */
+export function resetCatalogCache(): void {
+  catalogCache = null;
+}
+
+/** All provider ids present in the catalog, in wizard order. */
+export function listProviders(): string[] {
+  const present = [...loadCatalog().keys()];
+  return present.sort((a, b) => (PROVIDER_META[a]?.order ?? 99) - (PROVIDER_META[b]?.order ?? 99));
+}
+
+/** Models for a provider (empty array if unknown). */
+export function modelsFor(provider: string): ModelInfo[] {
+  return loadCatalog().get(provider) ?? [];
+}
+
+/** Flat list of every callable model across providers. */
+export function allModels(): ModelInfo[] {
+  return [...loadCatalog().values()].flat();
+}
+
+/**
+ * Look up a model by id. Matching is tolerant of a "provider/" prefix
+ * (e.g. "openai/gpt-4o" resolves to the "gpt-4o" entry under openai).
+ */
+export function getModelInfo(modelId: string): ModelInfo | null {
+  const all = allModels();
+  const exact = all.find((m) => m.id === modelId);
+  if (exact) return exact;
+  // tolerate provider/ prefix on either side
+  const stripped = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : modelId;
+  return all.find((m) => m.id === stripped || m.id.split("/").slice(1).join("/") === modelId) ?? null;
+}
+
+/** Whether a model id is a known, callable model in the catalog. */
+export function isKnownModel(modelId: string): boolean {
+  return getModelInfo(modelId) !== null;
+}
+
+/** Provider display label (falls back to the raw id). */
+export function providerLabel(provider: string): string {
+  return PROVIDER_META[provider]?.name ?? provider;
+}
+
+/**
+ * Validate that a configured default model is callable. Returns a short
+ * list of suggested model ids when it is not, so callers can fail loudly
+ * instead of 404-ing at request time.
+ */
+export function validateModel(modelId: string | undefined): { ok: boolean; suggestions: string[] } {
+  if (modelId && isKnownModel(modelId)) return { ok: true, suggestions: [] };
+  const suggestions = allModels()
+    .filter((m) => !m.local)
+    .slice(0, 6)
+    .map((m) => m.id);
+  return { ok: false, suggestions };
+}