talon-agent 1.6.1 → 1.7.0

package/src/backend/claude-sdk/models.ts

@@ -12,61 +12,386 @@ import { registerModels, clearModelsByProvider } from "../../core/models.js";
 import type { ModelInfo } from "../../core/models.js";
 import { log, logError } from "../../util/log.js";
 
+type SdkModelInfo = {
+  value: string;
+  displayName: string;
+  description: string;
+};
+
+type ParsedModelIdentity = {
+  family: string | null;
+  version: string | null;
+  claudeId: string | null;
+  isOneMillion: boolean;
+};
+
+type SdkModelRecord = SdkModelInfo & {
+  index: number;
+  identity: ParsedModelIdentity;
+  familyKey: string | null;
+  variantKey: string | null;
+};
+
 // ── Tier / fallback inference ───────────────────────────────────────────────
 
-/** Infer tier from model ID. */
-function inferTier(modelId: string): ModelInfo["tier"] {
-  if (modelId.includes("opus")) return "premium";
-  if (modelId.includes("haiku")) return "economy";
+const FAMILY_VERSION_PATTERN = /\b([A-Za-z][A-Za-z-]*)\s+(\d+(?:\.\d+)*)\b/;
+const FAMILY_ONLY_PATTERN = /^\s*([A-Za-z][A-Za-z-]*)\b/;
+
+function normalizeFamilyName(family: string): string {
+  return family.trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+function stripOneMillionSuffix(value: string): string {
+  return value.endsWith("[1m]") ? value.slice(0, -4) : value;
+}
+
+function toDashVersion(version: string): string {
+  return version.replace(/\./g, "-");
+}
+
+function parseFamilyAndVersionFromTexts(
+  texts: readonly string[],
+): Pick<ParsedModelIdentity, "family" | "version"> {
+  for (const text of texts) {
+    const match = text.match(FAMILY_VERSION_PATTERN);
+    if (!match) continue;
+    return {
+      family: normalizeFamilyName(match[1]),
+      version: match[2],
+    };
+  }
+
+  for (const text of texts) {
+    const match = text.match(FAMILY_ONLY_PATTERN);
+    if (!match) continue;
+    const family = normalizeFamilyName(match[1]);
+    if (family === "default") continue;
+    return { family, version: null };
+  }
+
+  return { family: null, version: null };
+}
+
+function parseClaudeId(
+  value: string,
+): Pick<ParsedModelIdentity, "family" | "version" | "claudeId"> {
+  const claudeId = stripOneMillionSuffix(value);
+  if (!claudeId.startsWith("claude-")) {
+    return { family: null, version: null, claudeId: null };
+  }
+
+  const tokens = claudeId.slice("claude-".length).split("-");
+  let boundary = tokens.length;
+  while (boundary > 0 && /^\d+$/.test(tokens[boundary - 1] ?? "")) {
+    boundary -= 1;
+  }
+
+  const familyTokens = tokens.slice(0, boundary);
+  const versionTokens = tokens.slice(boundary);
+
+  return {
+    family:
+      familyTokens.length > 0
+        ? normalizeFamilyName(familyTokens.join("-"))
+        : null,
+    version: versionTokens.length > 0 ? versionTokens.join(".") : null,
+    claudeId,
+  };
+}
+
+function describeSdkModel(model: SdkModelInfo): ParsedModelIdentity {
+  const textIdentity = parseFamilyAndVersionFromTexts([
+    model.description,
+    model.displayName,
+    model.value,
+  ]);
+  const claudeIdentity = parseClaudeId(model.value);
+  const family = textIdentity.family ?? claudeIdentity.family;
+  const version = textIdentity.version ?? claudeIdentity.version;
+
+  return {
+    family,
+    version,
+    claudeId:
+      claudeIdentity.claudeId ??
+      (family && version ? `claude-${family}-${toDashVersion(version)}` : null),
+    isOneMillion: model.value.endsWith("[1m]"),
+  };
+}
+
+function buildFamilyKey(identity: ParsedModelIdentity): string | null {
+  return identity.family
+    ? `${identity.family}:${identity.version ?? "*"}`
+    : null;
+}
+
+function buildVariantKey(identity: ParsedModelIdentity): string | null {
+  const familyKey = buildFamilyKey(identity);
+  return familyKey
+    ? `${familyKey}:${identity.isOneMillion ? "1m" : "base"}`
+    : null;
+}
+
+function appendOneMillionSuffix(alias: string, isOneMillion: boolean): string {
+  return isOneMillion ? `${alias}[1m]` : alias;
+}
+
+function buildGeneratedAliases(identity: ParsedModelIdentity): string[] {
+  if (!identity.family) return [];
+
+  const aliases = [
+    appendOneMillionSuffix(identity.family, identity.isOneMillion),
+  ];
+
+  if (identity.version) {
+    aliases.push(
+      appendOneMillionSuffix(
+        `${identity.family}-${identity.version}`,
+        identity.isOneMillion,
+      ),
+      appendOneMillionSuffix(
+        `${identity.family}-${toDashVersion(identity.version)}`,
+        identity.isOneMillion,
+      ),
+    );
+  }
+
+  if (identity.claudeId) {
+    aliases.push(
+      appendOneMillionSuffix(identity.claudeId, identity.isOneMillion),
+    );
+  }
+
+  return aliases;
+}
+
+function inferTierFromText(searchableText: string): ModelInfo["tier"] {
+  const lower = searchableText.toLowerCase();
+  if (
+    lower.includes("most capable") ||
+    lower.includes("smartest") ||
+    lower.includes("complex work")
+  ) {
+    return "premium";
+  }
+  if (
+    lower.includes("fastest") ||
+    lower.includes("quick answers") ||
+    lower.includes("cheapest")
+  ) {
+    return "economy";
+  }
   return "balanced";
 }
 
-/** Build short aliases from a model ID like "claude-sonnet-4-6". */
-function buildAliases(modelId: string): string[] {
+function getPreferredModelPriority(value: string): number {
+  if (value === "default") return 0;
+  if (!value.startsWith("claude-")) return 1;
+  return 2;
+}
+
+function buildSdkModelRecords(sdkModels: SdkModelInfo[]): SdkModelRecord[] {
+  return sdkModels.map((model, index) => {
+    const identity = describeSdkModel(model);
+    return {
+      ...model,
+      index,
+      identity,
+      familyKey: buildFamilyKey(identity),
+      variantKey: buildVariantKey(identity),
+    };
+  });
+}
+
+function buildPreferredCanonicalIds(
+  records: readonly SdkModelRecord[],
+): Map<string, string> {
+  const grouped = new Map<string, SdkModelRecord[]>();
+
+  for (const record of records) {
+    if (!record.variantKey) continue;
+    const variants = grouped.get(record.variantKey) ?? [];
+    variants.push(record);
+    grouped.set(record.variantKey, variants);
+  }
+
+  const preferred = new Map<string, string>();
+  for (const [variantKey, variants] of grouped) {
+    const canonical = [...variants].sort((left, right) => {
+      const priorityDelta =
+        getPreferredModelPriority(left.value) -
+        getPreferredModelPriority(right.value);
+      if (priorityDelta !== 0) return priorityDelta;
+      return left.index - right.index;
+    })[0];
+    if (canonical) preferred.set(variantKey, canonical.value);
+  }
+
+  return preferred;
+}
+
+function mergeAliases(...lists: readonly string[][]): string[] {
+  const seen = new Set<string>();
   const aliases: string[] = [];
-  const match = modelId.match(/claude-(\w+)-(.+)/);
-  if (match) {
-    const family = match[1];
-    const version = match[2];
-    aliases.push(family);
-    aliases.push(`${family}-${version}`);
-    aliases.push(`${family}-${version.replace(/-/g, ".")}`);
+
+  for (const list of lists) {
+    for (const alias of list) {
+      const key = alias.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      aliases.push(alias);
+    }
   }
+
   return aliases;
 }
 
+function buildHiddenModelAliases(
+  records: readonly SdkModelRecord[],
+  preferredCanonicalIds: ReadonlyMap<string, string>,
+): Map<string, string[]> {
+  const hiddenAliases = new Map<string, string[]>();
+
+  for (const record of records) {
+    if (!record.variantKey) continue;
+    const preferredId = preferredCanonicalIds.get(record.variantKey);
+    if (!preferredId || preferredId === record.value) continue;
+
+    hiddenAliases.set(
+      preferredId,
+      mergeAliases(
+        hiddenAliases.get(preferredId) ?? [],
+        [record.value],
+        buildGeneratedAliases(record.identity),
+      ),
+    );
+  }
+
+  return hiddenAliases;
+}
+
+function buildOneMillionContextVariants(
+  records: readonly SdkModelRecord[],
+  preferredCanonicalIds: ReadonlyMap<string, string>,
+): Map<string, string> {
+  const variants = new Map<string, string>();
+
+  for (const record of records) {
+    if (
+      !record.identity.isOneMillion ||
+      !record.familyKey ||
+      !record.variantKey
+    ) {
+      continue;
+    }
+
+    const preferredId = preferredCanonicalIds.get(record.variantKey);
+    if (preferredId && preferredId !== record.value) continue;
+
+    variants.set(record.familyKey, record.value);
+  }
+
+  return variants;
+}
+
+function buildTierByFamily(
+  records: readonly SdkModelRecord[],
+): Map<string, ModelInfo["tier"]> {
+  const textsByFamily = new Map<string, string[]>();
+
+  for (const record of records) {
+    if (!record.familyKey) continue;
+    const texts = textsByFamily.get(record.familyKey) ?? [];
+    texts.push(record.displayName, record.description, record.value);
+    textsByFamily.set(record.familyKey, texts);
+  }
+
+  const tiers = new Map<string, ModelInfo["tier"]>();
+  for (const [familyKey, texts] of textsByFamily) {
+    tiers.set(familyKey, inferTierFromText(texts.join(" ")));
+  }
+
+  return tiers;
+}
+
 // ── SDK → registry conversion ───────────────────────────────────────────────
 
 /**
  * Convert SDK ModelInfo to our registry format.
- * Sorts by tier and builds fallback chains automatically.
+ * Keeps SDK model IDs/display names intact while deriving compatibility aliases
+ * and duplicate collapsing from the SDK metadata instead of hardcoded versions.
  */
-function convertSdkModels(
-  sdkModels: Array<{
-    value: string;
-    displayName: string;
-    description: string;
-  }>,
-): ModelInfo[] {
-  // Filter out SDK artifacts:
-  // - [1m] variants: we add this suffix ourselves in options.ts
-  // - "default" pseudo-model: not a real model, just an alias for the default
-  // - any model that doesn't start with "claude-": not an Anthropic model
-  const filtered = sdkModels.filter(
-    (m) => m.value.startsWith("claude-") && !m.value.includes("["),
+function convertSdkModels(sdkModels: SdkModelInfo[]): ModelInfo[] {
+  const records = buildSdkModelRecords(sdkModels);
+  const preferredCanonicalIds = buildPreferredCanonicalIds(records);
+  const hiddenModelAliases = buildHiddenModelAliases(
+    records,
+    preferredCanonicalIds,
   );
+  const oneMillionContextVariants = buildOneMillionContextVariants(
+    records,
+    preferredCanonicalIds,
+  );
+  const tierByFamily = buildTierByFamily(records);
+  const hiddenModels = new Set(
+    records
+      .filter(
+        (record) =>
+          !!record.variantKey &&
+          preferredCanonicalIds.get(record.variantKey) !== undefined &&
+          preferredCanonicalIds.get(record.variantKey) !== record.value,
+      )
+      .map((record) => record.value),
+  );
+
+  const usedKeys = new Set<string>();
+  const models: ModelInfo[] = [];
 
-  const models: ModelInfo[] = filtered.map((m) => ({
-    id: m.value,
-    displayName: m.displayName,
-    description: m.description,
-    aliases: buildAliases(m.value),
-    provider: "anthropic",
-    capabilities: {
-      supports1mContext: !m.value.includes("haiku"),
-    },
-    tier: inferTier(m.value),
-  }));
+  for (const record of records) {
+    if (hiddenModels.has(record.value)) continue;
+
+    const canonicalKey = record.value.toLowerCase();
+    if (usedKeys.has(canonicalKey)) continue;
+
+    const aliases = mergeAliases(
+      buildGeneratedAliases(record.identity),
+      hiddenModelAliases.get(record.value) ?? [],
+    )
+      .filter((alias) => alias.toLowerCase() !== canonicalKey)
+      .filter((alias) => !usedKeys.has(alias.toLowerCase()));
+
+    usedKeys.add(canonicalKey);
+    for (const alias of aliases) {
+      usedKeys.add(alias.toLowerCase());
+    }
+
+    const oneMillionContextModelId = record.identity.isOneMillion
+      ? undefined
+      : record.familyKey
+        ? oneMillionContextVariants.get(record.familyKey)
+        : undefined;
+
+    models.push({
+      id: record.value,
+      displayName: record.displayName,
+      description: record.description,
+      aliases,
+      provider: "anthropic",
+      capabilities: {
+        supports1mContext:
+          record.identity.isOneMillion ||
+          oneMillionContextModelId !== undefined,
+        ...(oneMillionContextModelId !== undefined
+          ? { oneMillionContextModelId }
+          : {}),
+      },
+      tier:
+        (record.familyKey ? tierByFamily.get(record.familyKey) : undefined) ??
+        inferTierFromText(
+          `${record.value} ${record.displayName} ${record.description}`,
+        ),
+    });
+  }
 
   const tierOrder = { premium: 0, balanced: 1, economy: 2 };
   models.sort((a, b) => tierOrder[a.tier] - tierOrder[b.tier]);
@@ -137,11 +462,7 @@ export async function registerClaudeModels(sdkOptions: {
       );
     });
 
-    let sdkModels: Array<{
-      value: string;
-      displayName: string;
-      description: string;
-    }>;
+    let sdkModels: SdkModelInfo[];
     try {
       sdkModels = await Promise.race([q.supportedModels(), timeout]);
     } finally {
@@ -183,34 +504,30 @@ export function registerClaudeModelsStatic(models: ModelInfo[]): void {
 }
 
 /** Default model definitions for CLI setup wizard and tests. */
-export const CLAUDE_MODELS_STATIC: ModelInfo[] = [
+export const CLAUDE_MODELS_STATIC: ModelInfo[] = convertSdkModels([
+  {
+    value: "default",
+    displayName: "Default (recommended)",
+    description: "Sonnet · Best for everyday tasks",
+  },
+  {
+    value: "sonnet[1m]",
+    displayName: "Sonnet (1M context)",
+    description: "Sonnet with 1M context · Large context window",
+  },
   {
-    id: "claude-opus-4-6",
-    displayName: "Opus 4.6",
-    description: "smartest",
-    aliases: ["opus", "opus-4.6", "opus-4-6"],
-    provider: "anthropic",
-    capabilities: { supports1mContext: true },
-    tier: "premium",
-    fallback: "claude-sonnet-4-6",
+    value: "opus",
+    displayName: "Opus",
+    description: "Opus · Most capable for complex work",
   },
   {
-    id: "claude-sonnet-4-6",
-    displayName: "Sonnet 4.6",
-    description: "fast, balanced",
-    aliases: ["sonnet", "sonnet-4.6", "sonnet-4-6"],
-    provider: "anthropic",
-    capabilities: { supports1mContext: true },
-    tier: "balanced",
-    fallback: "claude-haiku-4-5",
+    value: "opus[1m]",
+    displayName: "Opus (1M context)",
+    description: "Opus with 1M context · Large context window",
   },
   {
-    id: "claude-haiku-4-5",
-    displayName: "Haiku 4.5",
-    description: "fastest, cheapest",
-    aliases: ["haiku", "haiku-4.5", "haiku-4-5"],
-    provider: "anthropic",
-    capabilities: { supports1mContext: false },
-    tier: "economy",
+    value: "haiku",
+    displayName: "Haiku",
+    description: "Haiku · Fastest for quick answers",
   },
-];
+]);

package/src/backend/claude-sdk/options.ts

@@ -10,7 +10,7 @@ import type { Options } from "@anthropic-ai/claude-agent-sdk";
 import { getSession } from "../../storage/sessions.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import { getPluginMcpServers } from "../../core/plugin.js";
-import { supports1mContext } from "../../core/models.js";
+import { get1mContextModelId, resolveModelId } from "../../core/models.js";
 import { getConfig, getBridgePort } from "./state.js";
 import { DISALLOWED_TOOLS_CHAT, EFFORT_MAP } from "./constants.js";
 
@@ -96,14 +96,16 @@ export function buildSdkOptions(chatId: string): BuildSdkOptionsResult {
   const chatSettings = getChatSettings(chatId);
   const activeModel = chatSettings.model ?? config.model;
   const activeEffort = chatSettings.effort ?? "adaptive";
+  const resolvedActiveModel = resolveModelId(activeModel);
 
   const thinkingConfig = EFFORT_MAP[activeEffort] ?? {
     thinking: { type: "adaptive" as const },
   };
 
-  const canUse1m =
-    supports1mContext(activeModel) && !activeModel.includes("[1m]");
-  const sdkModel = canUse1m ? `${activeModel}[1m]` : activeModel;
+  const oneMillionContextModelId = resolvedActiveModel.endsWith("[1m]")
+    ? null
+    : get1mContextModelId(resolvedActiveModel);
+  const sdkModel = oneMillionContextModelId ?? resolvedActiveModel;
 
   const session = getSession(chatId);
 

package/src/backend/claude-sdk/stream.ts

@@ -193,7 +193,7 @@ export function processResultMessage(
   }
 
   // Read token counts from the ACTIVE model's usage only.
-  // modelUsage is keyed by the exact SDK model string (e.g. "claude-sonnet-4-6[1m]")
+  // modelUsage is keyed by the exact SDK model string (e.g. "sonnet[1m]")
   // and contains cumulative session totals per model — summing all entries
   // double-counts when switching models mid-session.
   const modelUsage: Record<string, ModelUsage> = msg.modelUsage;

package/src/cli.ts

@@ -60,7 +60,7 @@ type Config = {
 
 const DEFAULTS: Config = {
   frontend: "telegram",
-  model: "claude-sonnet-4-6",
+  model: "default",
   concurrency: 1,
   pulse: true,
   pulseIntervalMs: 300000,

package/src/core/models.ts

@@ -14,10 +14,12 @@ export type ModelTier = "premium" | "balanced" | "economy";
 export type ModelCapabilities = {
   /** Whether the model supports the 1M token context window. */
   supports1mContext: boolean;
+  /** Exact model ID to use for the 1M token context window, if available. */
+  oneMillionContextModelId?: string;
 };
 
 export type ModelInfo = {
-  /** Canonical model ID (e.g. "claude-sonnet-4-6"). */
+  /** Canonical SDK model ID (e.g. "default", "opus", "sonnet[1m]"). */
   id: string;
   /** Human-readable display name for UIs (e.g. "Sonnet 4.6"). */
   displayName: string;
@@ -48,6 +50,34 @@ const TIER_ORDER: Record<ModelTier, number> = {
 const models = new Map<string, ModelInfo>();
 const aliasIndex = new Map<string, string>();
 
+function resolveGenericFamilyAlias(input: string): string | null {
+  const trimmed = input.trim().toLowerCase();
+  if (!trimmed) return null;
+
+  const isOneMillion = trimmed.endsWith("[1m]");
+  let base = isOneMillion ? trimmed.slice(0, -4) : trimmed;
+  if (base.startsWith("claude-")) {
+    base = base.slice("claude-".length);
+  }
+
+  const tokens = base.replace(/\./g, "-").split("-").filter(Boolean);
+  if (tokens.length === 0) return null;
+
+  let boundary = tokens.length;
+  while (boundary > 0 && /^\d+$/.test(tokens[boundary - 1] ?? "")) {
+    boundary -= 1;
+  }
+
+  const family = tokens.slice(
+    0,
+    boundary === tokens.length ? tokens.length : boundary,
+  );
+  if (family.length === 0) return null;
+
+  const alias = family.join("-");
+  return isOneMillion ? `${alias}[1m]` : alias;
+}
+
 // ── Registration ────────────────────────────────────────────────────────────
 
 /** Register one or more models. Idempotent — re-registration overwrites. */
@@ -93,7 +123,16 @@ export function getModels(provider?: string): ModelInfo[] {
  */
 export function resolveModelId(input: string): string {
   const lower = input.trim().toLowerCase();
-  return aliasIndex.get(lower) ?? input.trim();
+  const direct = aliasIndex.get(lower);
+  if (direct) return direct;
+
+  const genericAlias = resolveGenericFamilyAlias(input);
+  if (genericAlias) {
+    const resolved = aliasIndex.get(genericAlias);
+    if (resolved) return resolved;
+  }
+
+  return input.trim();
 }
 
 /**
@@ -106,16 +145,21 @@ export function resolveModel(input: string): ModelInfo | undefined {
 
 /** Get the fallback model ID for a given model, or null if none configured. */
 export function getFallbackModel(modelId: string): string | null {
-  return models.get(modelId)?.fallback ?? null;
+  return resolveModel(modelId)?.fallback ?? null;
 }
 
 /** Check whether a model supports the 1M token context window. */
 export function supports1mContext(modelId: string): boolean {
-  const info = models.get(modelId);
+  const info = resolveModel(modelId);
   // Default to true for unknown models (don't restrict capabilities we can't check)
   return info?.capabilities.supports1mContext ?? true;
 }
 
+/** Resolve the exact 1M-context model ID for a given model, if one exists. */
+export function get1mContextModelId(modelId: string): string | null {
+  return resolveModel(modelId)?.capabilities.oneMillionContextModelId ?? null;
+}
+
 /**
  * Get the default model for a given tier. Returns the first registered model
  * matching the tier, or the first model overall, or the hardcoded fallback.
@@ -125,7 +169,7 @@ export function getDefaultModel(tier: ModelTier = "balanced"): string {
   if (byTier) return byTier.id;
   const first = models.values().next();
   if (!first.done) return first.value.id;
-  return "claude-sonnet-4-6"; // ultimate fallback if registry is empty
+  return "default"; // ultimate fallback if the registry is still empty
 }
 
 // ── Provider-scoped clearing ────────────────────────────────────────────────