create-quorum-router 0.1.5

package/templates/basic/src/provider_registry.ts

@@ -0,0 +1,254 @@
+import type { ModelInventoryEntry } from "./schema.ts";
+import { readRouterEnv } from "./env.ts";
+
+export type ProviderSpec = {
+  provider: string;
+  model: string;
+  model_id: string;
+  auth_mode: "oauth" | "session" | "env";
+  source: "wrapper" | "oauth_session" | "local_cli" | "env_fallback";
+  command?: string;
+  args_template?: string[];
+  list_models_args?: string[];
+  list_blocked_reason?: string;
+  notes: string[];
+};
+
+export type ProviderSelectionRequest = {
+  providerLabel?: string;
+  model?: string;
+};
+
+export function normalizeSelectionValue(
+  value: string | undefined,
+): string | undefined {
+  const trimmed = value?.trim().toLowerCase();
+  return trimmed ? trimmed : undefined;
+}
+
+export function readProviderSelectionRequest(): ProviderSelectionRequest {
+  return {
+    providerLabel: readRouterEnv("QUORUM_ROUTER_PROVIDER_LABEL")?.trim() ||
+      readRouterEnv("QUORUM_ROUTER_WRAPPER_PROVIDER_LABEL")?.trim() ||
+      undefined,
+    model: readRouterEnv("QUORUM_ROUTER_PROVIDER_MODEL")?.trim() ||
+      readRouterEnv("QUORUM_ROUTER_WRAPPER_PROVIDER_MODEL")?.trim() ||
+      undefined,
+  };
+}
+
+function aliasSet(values: Array<string | undefined>): string[] {
+  return [
+    ...new Set(
+      values.map(normalizeSelectionValue).filter((value) =>
+        Boolean(value)
+      ) as string[],
+    ),
+  ];
+}
+
+export function providerAliasesForCommand(
+  provider: string,
+  model: string,
+  modelId: string,
+  _source: string,
+  command?: string,
+): string[] {
+  const commandAliases: Record<string, string[]> = {
+    grok: ["grok", "grok-cli", "xai", "xai-cli"],
+    codex: ["openai", "codex", "codex-cli", "openai-codex"],
+    claude: ["anthropic", "claude", "claude-code"],
+    gemini: ["google", "gemini", "gemini-cli"],
+    devin: ["cognition", "devin", "devin-cli"],
+    qwen: ["alibaba", "qwen", "qwen-cli"],
+  };
+  const providerAliases: Record<string, string[]> = {
+    xai: ["grok", "grok-cli", "xai", "xai-cli"],
+    openai: ["openai", "codex", "codex-cli", "openai-codex"],
+    anthropic: ["anthropic", "claude", "claude-code"],
+    google: ["google", "gemini", "gemini-cli"],
+    cognition: ["cognition", "devin", "devin-cli"],
+    alibaba: ["alibaba", "qwen", "qwen-cli"],
+  };
+  const normalizedProvider = normalizeSelectionValue(provider);
+  return aliasSet([
+    provider,
+    model,
+    modelId,
+    command,
+    ...(command ? commandAliases[command] ?? [] : []),
+    ...(normalizedProvider ? providerAliases[normalizedProvider] ?? [] : []),
+  ]);
+}
+
+export function providerSelectionMatches(
+  entry: {
+    provider: string;
+    model: string;
+    model_id: string;
+    source: string;
+    command?: string;
+  },
+  requestedProviderLabel: string | undefined,
+): boolean {
+  const requested = normalizeSelectionValue(requestedProviderLabel);
+  if (!requested) return true;
+  return providerAliasesForCommand(
+    entry.provider,
+    entry.model,
+    entry.model_id,
+    entry.source,
+    entry.command,
+  ).includes(requested);
+}
+
+export function modelSelectionMatches(
+  entry: {
+    provider?: string;
+    model: string;
+    model_id: string;
+    listed_models?: string[];
+  },
+  requestedModel: string | undefined,
+): boolean {
+  const requested = normalizeSelectionValue(requestedModel);
+  if (!requested) return true;
+  const providerPrefix = normalizeSelectionValue(entry.provider)?.replace(
+    /[^a-z0-9]+/g,
+    "",
+  );
+  const listedModels = entry.listed_models ?? [];
+  return aliasSet([
+    entry.model,
+    entry.model_id,
+    ...listedModels,
+    ...(providerPrefix
+      ? listedModels.map((model) => `${providerPrefix}/${model}`)
+      : []),
+  ]).includes(requested);
+}
+
+export const LOCAL_PROVIDER_SPECS: ProviderSpec[] = [
+  {
+    provider: "OpenAI",
+    model: "codex-cli",
+    model_id: "openai/codex-cli",
+    auth_mode: "oauth",
+    source: "oauth_session",
+    command: "codex",
+    args_template: [
+      "exec",
+      "--sandbox",
+      "read-only",
+      "--skip-git-repo-check",
+      "--cd",
+      "__CWD__",
+      "--output-last-message",
+      "__OUT__",
+      "__PROMPT__",
+    ],
+    list_blocked_reason:
+      "codex models is tty/stdin dependent in this environment; model catalog listing is unavailable from non-interactive Deno.",
+    notes: [
+      "Uses existing Codex CLI OAuth/session; command presence and invocation are verified separately.",
+    ],
+  },
+  {
+    provider: "Anthropic",
+    model: "claude-code",
+    model_id: "anthropic/claude-code",
+    auth_mode: "oauth",
+    source: "oauth_session",
+    command: "claude",
+    args_template: ["-p", "__PROMPT__"],
+    list_blocked_reason:
+      "Claude Code model listing is blocked by organization policy / disabled subscription access in this environment.",
+    notes: [
+      "Uses existing Claude Code session; do not trigger login from dogfood runner.",
+    ],
+  },
+  {
+    provider: "Google",
+    model: "gemini-cli",
+    model_id: "google/gemini-cli",
+    auth_mode: "oauth",
+    source: "oauth_session",
+    command: "gemini",
+    args_template: ["-p", "__PROMPT__"],
+    list_blocked_reason:
+      "Gemini CLI list/invoke paths require a trusted directory in non-interactive runs unless the user opts into the trust setting.",
+    notes: [
+      "Gemini CLI can require workspace trust; inventory does not trigger login or trust flows.",
+    ],
+  },
+  {
+    provider: "xAI",
+    model: "grok-cli",
+    model_id: "xai/grok-cli",
+    auth_mode: "session",
+    source: "oauth_session",
+    command: "grok",
+    args_template: [
+      "-p",
+      "__PROMPT__",
+      "--output-format",
+      "plain",
+      "--permission-mode",
+      "plan",
+      "--disable-web-search",
+    ],
+    list_models_args: ["models"],
+    notes: [
+      "Uses existing Grok CLI session; `grok models` is safe list-only discovery.",
+    ],
+  },
+  {
+    provider: "Cognition",
+    model: "devin-cli",
+    model_id: "cognition/devin-cli",
+    auth_mode: "session",
+    source: "local_cli",
+    command: "devin",
+    args_template: ["-p", "__PROMPT__"],
+    list_blocked_reason:
+      "Devin CLI does not expose a models subcommand in this environment.",
+    notes: ["Uses existing Devin CLI session."],
+  },
+  {
+    provider: "Alibaba",
+    model: "qwen-cli",
+    model_id: "alibaba/qwen-cli",
+    auth_mode: "session",
+    source: "local_cli",
+    command: "qwen",
+    args_template: ["-p", "__PROMPT__"],
+    list_blocked_reason:
+      "Qwen CLI model listing path is stdin/API-key dependent in this environment.",
+    notes: ["Uses existing local Qwen CLI session."],
+  },
+];
+
+export function envFallbackEntry(configured: boolean): ModelInventoryEntry {
+  const label = readRouterEnv("QUORUM_ROUTER_PROVIDER_LABEL")?.trim() ||
+    "OpenAI-compatible env fallback";
+  const model = readRouterEnv("QUORUM_ROUTER_PROVIDER_MODEL")?.trim() ||
+    "missing-model";
+  return {
+    provider: label,
+    auth_mode: "env",
+    model,
+    model_id: `env/${model}`,
+    source: "env_fallback",
+    available: configured,
+    blocked_reason: configured
+      ? undefined
+      : "missing explicit private env fallback configuration",
+    can_list_models: false,
+    list_blocked_reason:
+      "Generic env fallback uses a single user-selected model and does not perform provider catalog discovery.",
+    can_invoke: configured,
+    notes: [
+      "Env fallback is explicit-only and is not the preferred public dogfood path.",
+    ],
+  };
+}

package/templates/basic/src/redact.ts

@@ -0,0 +1,65 @@
+const REDACTION_PATTERNS: RegExp[] = [
+  /Bearer\s+[A-Za-z0-9._~+\/-]+=*/gi,
+  /session[_-]?id\s*[=:]\s*[0-9a-f]{8,}(?:-[0-9a-f]{4,})*/gi,
+  /["']?authorization["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+  /["']?refresh[_-]?token["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+  /["']?access[_-]?token["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+  /["']?api[_-]?key["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+  /["']?session(?:\s+|[_-]?)id["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+  /["']?cookie["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+  /["']?password["']?\s*[:=]\s*["']?[^"'\n\r,}]+["']?/gi,
+];
+
+const SENSITIVE_ENV = [
+  "QUORUM_ROUTER_PROVIDER_API_KEY",
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "XAI_API_KEY",
+  "GROK_API_KEY",
+  "GLM_API_KEY",
+  "ZHIPUAI_API_KEY",
+  "BIGMODEL_API_KEY",
+];
+
+export function knownSecretValues(): string[] {
+  return SENSITIVE_ENV.flatMap((name) => {
+    const value = Deno.env.get(name);
+    return value && value.length >= 8 ? [value] : [];
+  });
+}
+
+export function redact(text: string, extraSecrets: string[] = []): string {
+  let safe = text;
+  for (
+    const secret of [...knownSecretValues(), ...extraSecrets].filter(Boolean)
+      .sort((a, b) => b.length - a.length)
+  ) {
+    safe = safe.split(secret).join("[REDACTED]");
+  }
+  for (const pattern of REDACTION_PATTERNS) {
+    safe = safe.replace(pattern, "[REDACTED]");
+  }
+  return safe;
+}
+
+export function summarize(text: string, max = 500): string {
+  const collapsed = redact(text).replace(/\s+/g, " ").trim();
+  return collapsed.length > max ? `${collapsed.slice(0, max)}…` : collapsed;
+}
+
+export function redactionOk(value: unknown): boolean {
+  const text = JSON.stringify(value);
+  const unescaped = text.replace(/\\"/g, '"');
+  const unsafeKeyPattern =
+    /["']?(authorization|refresh[_-]?token|access[_-]?token|cookie|password|session(?:\s+|[_-]?)id|api[_-]?key)["']?\s*[:=]/i;
+  if (unsafeKeyPattern.test(text) || unsafeKeyPattern.test(unescaped)) {
+    return false;
+  }
+  if (redact(text) !== text || redact(unescaped) !== unescaped) {
+    return false;
+  }
+  for (const secret of knownSecretValues()) {
+    if (secret && text.includes(secret)) return false;
+  }
+  return true;
+}

package/templates/basic/src/schema.ts

@@ -0,0 +1,138 @@
+export type AuthMode = "auto" | "wrapper" | "oauth" | "session" | "env";
+export type InventorySource =
+  | "wrapper"
+  | "oauth_session"
+  | "local_cli"
+  | "env_fallback"
+  | "static_config";
+
+export type ModelInventoryEntry = {
+  provider: string;
+  auth_mode: AuthMode | "session" | "oauth" | "env";
+  model: string;
+  model_id: string;
+  source: InventorySource;
+  available: boolean;
+  blocked_reason?: string;
+  can_list_models: boolean;
+  listed_models?: string[];
+  list_blocked_reason?: string;
+  can_invoke: boolean;
+  notes: string[];
+  command?: string;
+  args_template?: string[];
+  invocation_model?: string;
+};
+
+export type ModelInventory = {
+  generated_at: string;
+  auth_mode: AuthMode;
+  entries: ModelInventoryEntry[];
+  available_count: number;
+  blocked_count: number;
+  env_fallback_configured: boolean;
+  env_fallback_used: boolean;
+};
+
+export type ProviderResult = {
+  provider: string;
+  model: string;
+  model_id?: string;
+  source?: string;
+  command?: string;
+  listed_models?: string[];
+  response_received: boolean;
+  schema_valid: boolean;
+  response_summary: string;
+  raw_content: string;
+  error?: string;
+};
+
+export type ScoreRow = {
+  provider: string;
+  model: string;
+  schema_valid: boolean;
+  response_received: boolean;
+  clarity: number;
+  completeness: number;
+  risk: number;
+  instruction_fit: number;
+  final_score: number;
+};
+
+export type AgentChatTurn = {
+  round: number;
+  provider: string;
+  model: string;
+  reply_to?: { provider: string; model: string; round: number };
+  content: string;
+};
+
+export type PromptContextTrace = {
+  prompt_has_context: boolean;
+  original_prompt_chars: number;
+  effective_prompt_chars: number;
+  prompt_truncated: boolean;
+  context_chars: number;
+  github_repo?: string;
+  github_default_branch?: string;
+  files_included: string[];
+  files_considered: number;
+  tree_truncated: boolean;
+  context_fetch_error?: string;
+};
+
+export type DogfoodTrace = {
+  run_id: string;
+  timestamp: string;
+  command: string;
+  mode: "route_once" | "best_route" | "agent_chat" | "health";
+  auth_mode: AuthMode;
+  provider?: string;
+  model?: string;
+  requested_provider_label?: string;
+  requested_model?: string;
+  selected_provider?: string;
+  selected_model?: string;
+  provider_selection_honored: boolean;
+  fallback_used: boolean;
+  prompt_hash?: string;
+  prompt_summary?: string;
+  prompt_context?: PromptContextTrace;
+  response_summary?: string;
+  schema_valid: boolean;
+  redaction_ok: boolean;
+  credential_value_present: boolean;
+  sensitive_value_present: boolean;
+  selected_route?: { provider: string; model: string; final_score?: number };
+  score_table?: ScoreRow[];
+  agent_chat_turns?: AgentChatTurn[];
+  errors: string[];
+  boundaries: string[];
+};
+
+export function parseAuthMode(value: string | undefined): AuthMode {
+  const mode = (value ?? "auto").trim().toLowerCase();
+  if (["auto", "wrapper", "oauth", "session", "env"].includes(mode)) {
+    return mode as AuthMode;
+  }
+  throw new Error(
+    `QuorumRouter blocked: invalid QUORUM_ROUTER_AUTH_MODE '${mode}'`,
+  );
+}
+
+export function assertOptIn(): void {
+  if (Deno.env.get("RUN_EXTERNAL_MODEL_DOGFOOD") !== "1") {
+    throw new Error(
+      "QuorumRouter external dogfood blocked: set RUN_EXTERNAL_MODEL_DOGFOOD=1 to invoke real providers",
+    );
+  }
+}
+
+export function assertAgentChatOptIn(): void {
+  if (Deno.env.get("RUN_EXPERIMENTAL_AGENT_CHAT") !== "1") {
+    throw new Error(
+      "agent_chat blocked: set RUN_EXPERIMENTAL_AGENT_CHAT=1; live multi-model dialogue is explicit opt-in",
+    );
+  }
+}

package/templates/basic/src/trace.ts

@@ -0,0 +1,140 @@
+import type {
+  AgentChatTurn,
+  AuthMode,
+  DogfoodTrace,
+  PromptContextTrace,
+  ProviderResult,
+  ScoreRow,
+} from "./schema.ts";
+import { redactionOk, summarize } from "./redact.ts";
+
+export const OUT_DIR = "out";
+
+export function boundaries(agentChat = false): string[] {
+  return [
+    "deno task intake is the first real setup command before launch",
+    "deno task smoke is fixture-only and not real provider dogfood",
+    "Best Route/direct remains production-ready best-answer routing",
+    agentChat
+      ? "live multi-model agent_chat is explicit opt-in and requires two working identities"
+      : "agent_chat remains explicit opt-in",
+    "SafeLoop-backed production repository execution requires explicit external configuration and distinct approval",
+    "no live Supabase Agent Bus runtime writes",
+    "no service-role runtime",
+  ];
+}
+
+export async function promptHash(prompt: string): Promise<string> {
+  const bytes = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(prompt),
+  );
+  return Array.from(new Uint8Array(bytes)).map((b) =>
+    b.toString(16).padStart(2, "0")
+  ).join("");
+}
+
+export function score(result: ProviderResult): ScoreRow {
+  const text = result.response_summary;
+  const clarity = text.length > 20 ? 4 : 2;
+  const completeness = text.length > 120 ? 4 : 3;
+  const risk =
+    /secret|token|password|launch now|production autonomous/i.test(text)
+      ? 1
+      : 5;
+  const instruction_fit = result.schema_valid && result.response_received
+    ? 4
+    : 1;
+  const final_score = clarity + completeness + risk + instruction_fit;
+  return {
+    provider: result.provider,
+    model: result.model,
+    schema_valid: result.schema_valid,
+    response_received: result.response_received,
+    clarity,
+    completeness,
+    risk,
+    instruction_fit,
+    final_score,
+  };
+}
+
+export async function buildTrace(args: {
+  command: string;
+  mode: DogfoodTrace["mode"];
+  authMode: AuthMode;
+  prompt?: string;
+  promptContext?: PromptContextTrace;
+  results?: ProviderResult[];
+  selected?: ScoreRow;
+  scores?: ScoreRow[];
+  errors?: string[];
+  agentChat?: boolean;
+  requestedProviderLabel?: string;
+  requestedModel?: string;
+  providerSelectionHonored?: boolean;
+  fallbackUsed?: boolean;
+  agentChatTurns?: AgentChatTurn[];
+}): Promise<DogfoodTrace> {
+  const responseSummary = args.results?.map((r) =>
+    `[${r.provider}/${r.model}] ${r.response_summary}`
+  ).join("\n");
+  const trace: DogfoodTrace = {
+    run_id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    command: args.command,
+    mode: args.mode,
+    auth_mode: args.authMode,
+    provider: args.selected?.provider ?? args.results?.[0]?.provider,
+    model: args.selected?.model ?? args.results?.[0]?.model,
+    requested_provider_label: args.requestedProviderLabel,
+    requested_model: args.requestedModel,
+    selected_provider: args.selected?.provider ?? args.results?.[0]?.provider,
+    selected_model: args.selected?.model ?? args.results?.[0]?.model,
+    provider_selection_honored: args.providerSelectionHonored ?? true,
+    fallback_used: args.fallbackUsed ?? false,
+    prompt_hash: args.prompt ? await promptHash(args.prompt) : undefined,
+    prompt_summary: args.prompt ? summarize(args.prompt, 160) : undefined,
+    prompt_context: args.promptContext,
+    response_summary: responseSummary
+      ? summarize(responseSummary, 800)
+      : undefined,
+    schema_valid: args.results
+      ? args.results.every((r) => r.schema_valid)
+      : true,
+    redaction_ok: false,
+    credential_value_present: false,
+    sensitive_value_present: false,
+    selected_route: args.selected
+      ? {
+        provider: args.selected.provider,
+        model: args.selected.model,
+        final_score: args.selected.final_score,
+      }
+      : undefined,
+    score_table: args.scores,
+    agent_chat_turns: args.agentChatTurns,
+    errors: args.errors ?? [],
+    boundaries: boundaries(args.agentChat),
+  };
+  trace.redaction_ok = redactionOk(trace);
+  return trace;
+}
+
+export async function writeTrace(
+  name: string,
+  trace: DogfoodTrace,
+): Promise<string> {
+  if (!trace.redaction_ok || !redactionOk(trace)) {
+    throw new Error(
+      "QuorumRouter blocked: refusing to write trace that failed redaction checks",
+    );
+  }
+  await Deno.mkdir(OUT_DIR, { recursive: true });
+  const path = `${OUT_DIR}/${name}.json`;
+  await Deno.writeTextFile(path, `${JSON.stringify(trace, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  await Deno.chmod(path, 0o600).catch(() => undefined);
+  return path;
+}