@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-H3HGMISG.js

@@ -0,0 +1,483 @@
+import {
+  isFamilyAlias
+} from "./chunk-FAZBRHGG.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+
+// src/core/providers/claude/model-resolver.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+
+// src/core/providers/claude/config.ts
+var CLAUDE_MODELS = {
+  // Current models
+  OPUS: "opus",
+  SONNET: "sonnet",
+  HAIKU: "haiku",
+  FABLE: "fable",
+  // The Claude CLI accepts both the `fable` alias and the `claude-fable-5`
+  // full id, per its own --help. error-parser.ts surfaces a "temporarily
+  // unavailable" message when upstream availability is absent, so treat this
+  // entry as an id mapping rather than a guarantee that the caller's account
+  // can invoke it.
+  CLAUDE_FABLE_5: "claude-fable-5",
+  CLAUDE_FABLE_5_1: "claude-fable-5-1",
+  // 5-series. Opus 5 reports a 200000-token window unsuffixed and 1000000 with
+  // `[1m]`; Sonnet 5 reports 1000000 either way, having no 200K variant. See
+  // CLAUDE_CONTEXT_SUFFIXES, and providers.yaml for the sourced catalog entry.
+  CLAUDE_OPUS_5: "claude-opus-5",
+  CLAUDE_OPUS_5_5: "claude-opus-5-5",
+  CLAUDE_SONNET_5: "claude-sonnet-5",
+  CLAUDE_SONNET_5_5: "claude-sonnet-5-5",
+  // Legacy canonical IDs retained for compatibility with existing callers/tests.
+  SONNET_3_5: "claude-3-5-sonnet-latest",
+  OPUS_3: "claude-3-opus-latest",
+  HAIKU_3: "claude-3-haiku-latest",
+  CLAUDE_OPUS_4_8: "claude-opus-4-8",
+  CLAUDE_OPUS_4_7: "claude-opus-4-7",
+  CLAUDE_OPUS_4_6: "claude-opus-4-6",
+  CLAUDE_OPUS_4_5: "claude-opus-4-5",
+  CLAUDE_SONNET_4_6: "claude-sonnet-4-6",
+  CLAUDE_SONNET_4_5: "claude-sonnet-4-5",
+  CLAUDE_HAIKU_4_5: "claude-haiku-4-5"
+};
+var CLAUDE_BEDROCK_MODELS = {
+  // claude-opus-4-7 uses the bare (undated) base id. Verified live 2026-06-14
+  // via bedrock list-inference-profiles + bedrock-runtime converse: the
+  // global/us/eu/jp `anthropic.claude-opus-4-7` profiles all invoke OK. The
+  // primary source of truth is the providers.yaml routes (which also pin each
+  // regional profile and intentionally omit apac, since
+  // apac.anthropic.claude-opus-4-7 is NOT invokable); this flat entry is the
+  // registry-miss fallback that mirrors that base id.
+  // claude-fable-5 is VERIFIED (2026-07-25): `claude -p --model claude-fable-5`
+  // succeeds, and `aws bedrock list-inference-profiles` returns both
+  // global.anthropic.claude-fable-5 and us.anthropic.claude-fable-5.
+  // claude-opus-5 / claude-sonnet-5 are VERIFIED (2026-07-26): both invoke on
+  // Bedrock and their global./us. inference profiles are enumerated.
+  "claude-opus-5": "anthropic.claude-opus-5",
+  // claude-opus-5-5: the global inference profile was observed live
+  // 2026-09-27 as the served model id of a Claude Code session on Bedrock.
+  "claude-opus-5-5": "anthropic.claude-opus-5-5",
+  "claude-sonnet-5": "anthropic.claude-sonnet-5",
+  // claude-fable-5-1: the global inference profile was observed live
+  // 2026-09-15 as the served model id of a Claude Code session on Bedrock.
+  "claude-fable-5-1": "anthropic.claude-fable-5-1",
+  "claude-fable-5": "anthropic.claude-fable-5",
+  "claude-opus-4-8": "anthropic.claude-opus-4-8",
+  "claude-opus-4-7": "anthropic.claude-opus-4-7",
+  "claude-opus-4-6": "anthropic.claude-opus-4-6-v1",
+  "claude-opus-4-5": "anthropic.claude-opus-4-5-20251101-v1:0",
+  "claude-sonnet-4-6": "anthropic.claude-sonnet-4-6",
+  "claude-sonnet-4-5": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "claude-haiku-4-5": "anthropic.claude-haiku-4-5-20251001-v1:0"
+};
+var CLAUDE_ALIAS_TO_MODEL_ID = {
+  // EXPLICIT PINS ONLY. The bare family aliases (`opus`, `sonnet`, `haiku`,
+  // `fable`) are deliberately ABSENT: the Claude CLI resolves a family itself,
+  // per backend and per account entitlement, and the operator can redirect it
+  // with ANTHROPIC_DEFAULT_{OPUS,SONNET,HAIKU,FABLE}_MODEL. A Build row saying
+  // what a family currently means goes stale silently and overrides that — bare
+  // `opus` was pinned here to claude-opus-4-8 while the CLI (2.1.266, clean
+  // config) resolved `opus` on Bedrock to claude-opus-5 (verified 2026-09-09).
+  // Family membership is registry data (`models.family_aliases`); pass-through
+  // lives in execution/family-alias-passthrough.ts. Do NOT re-add a family row.
+  //
+  // A version shorthand below is an explicit pin and keeps its full id: the
+  // caller named one version, so nothing floats and Build still owns the
+  // Bedrock/Vertex translation for it.
+  "fable-5-1": CLAUDE_MODELS.CLAUDE_FABLE_5_1,
+  "fable-5.1": CLAUDE_MODELS.CLAUDE_FABLE_5_1,
+  "fable-5": CLAUDE_MODELS.CLAUDE_FABLE_5,
+  // Version-pinned shorthands → exact version
+  "opus-5-5": CLAUDE_MODELS.CLAUDE_OPUS_5_5,
+  "opus-5.5": CLAUDE_MODELS.CLAUDE_OPUS_5_5,
+  "opus-5": CLAUDE_MODELS.CLAUDE_OPUS_5,
+  "opus.5": CLAUDE_MODELS.CLAUDE_OPUS_5,
+  "sonnet-5": CLAUDE_MODELS.CLAUDE_SONNET_5,
+  "sonnet-5-5": CLAUDE_MODELS.CLAUDE_SONNET_5_5,
+  "sonnet-5.5": CLAUDE_MODELS.CLAUDE_SONNET_5_5,
+  "sonnet.5": CLAUDE_MODELS.CLAUDE_SONNET_5,
+  "sonnet-4-6": CLAUDE_MODELS.CLAUDE_SONNET_4_6,
+  "sonnet-4.6": CLAUDE_MODELS.CLAUDE_SONNET_4_6,
+  "sonnet-4-5": CLAUDE_MODELS.CLAUDE_SONNET_4_5,
+  "sonnet-4.5": CLAUDE_MODELS.CLAUDE_SONNET_4_5,
+  "opus-4-8": CLAUDE_MODELS.CLAUDE_OPUS_4_8,
+  "opus-4.8": CLAUDE_MODELS.CLAUDE_OPUS_4_8,
+  "opus-4-7": CLAUDE_MODELS.CLAUDE_OPUS_4_7,
+  "opus-4.7": CLAUDE_MODELS.CLAUDE_OPUS_4_7,
+  "opus-4-6": CLAUDE_MODELS.CLAUDE_OPUS_4_6,
+  "opus-4.6": CLAUDE_MODELS.CLAUDE_OPUS_4_6,
+  "opus-4-5": CLAUDE_MODELS.CLAUDE_OPUS_4_5,
+  "opus-4.5": CLAUDE_MODELS.CLAUDE_OPUS_4_5,
+  "haiku-4-5": CLAUDE_MODELS.CLAUDE_HAIKU_4_5,
+  "haiku-4.5": CLAUDE_MODELS.CLAUDE_HAIKU_4_5
+};
+var CLAUDE_CONTEXT_SUFFIXES = /* @__PURE__ */ new Set(["[1m]"]);
+var CLAUDE_DISABLE_1M_CONTEXT_ENV = "CLAUDE_CODE_DISABLE_1M_CONTEXT";
+function is1MContextDisabled(env) {
+  const raw = (env ?? process.env)[CLAUDE_DISABLE_1M_CONTEXT_ENV];
+  if (typeof raw !== "string") {
+    return false;
+  }
+  const normalized = raw.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+function splitClaudeModelContextSuffix(model) {
+  const match = model.match(/^(.*?)(\[[^\]]*\])\s*$/);
+  if (!match || match[1] === void 0 || match[2] === void 0) {
+    return { base: model, suffix: "" };
+  }
+  const suffix = match[2].toLowerCase();
+  if (!CLAUDE_CONTEXT_SUFFIXES.has(suffix)) {
+    return { base: model, suffix: "" };
+  }
+  return { base: match[1].trim(), suffix };
+}
+function getClaudeModelContextSuffixWarning(model) {
+  const trimmed = model.trim();
+  const match = trimmed.match(/^(.*?)(\[[^\]]*\])\s*$/);
+  if (!match || match[2] === void 0) {
+    return void 0;
+  }
+  const suffix = match[2].toLowerCase();
+  if (CLAUDE_CONTEXT_SUFFIXES.has(suffix)) {
+    return void 0;
+  }
+  return `Claude model '${model}' has unrecognized trailing context suffix '${match[2]}'; supported suffixes: ${Array.from(CLAUDE_CONTEXT_SUFFIXES).join(", ")}`;
+}
+var CLAUDE_FAMILY_TOKENS = ["opus", "sonnet", "haiku", "fable", "mythos"];
+var CLAUDE_FAMILY_LIKE_PIN_PATTERN = new RegExp(
+  `^(${CLAUDE_FAMILY_TOKENS.join("|")})(?:[-.]\\d+)?$`
+);
+var CLAUDE_SPECIFIC_PIN_PATTERN = new RegExp(
+  `^(?:${CLAUDE_FAMILY_TOKENS.join("|")})(?:[-.]\\d+){2,}$`
+);
+function isSpecificClaudeVersionPin(model) {
+  const normalized = model.trim().toLowerCase();
+  if (normalized === "") return false;
+  return CLAUDE_SPECIFIC_PIN_PATTERN.test(normalized);
+}
+function extractClaudeFamilyToken(model) {
+  const match = model.trim().toLowerCase().match(CLAUDE_FAMILY_LIKE_PIN_PATTERN);
+  return match?.[1];
+}
+function resolveModel(model) {
+  if (!model) {
+    return void 0;
+  }
+  const trimmed = model.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  const { base, suffix } = splitClaudeModelContextSuffix(trimmed);
+  if (base === "") {
+    return void 0;
+  }
+  const resolvedBase = resolveModelBase(base);
+  if (resolvedBase === void 0) {
+    return void 0;
+  }
+  return suffix ? `${resolvedBase}${suffix}` : resolvedBase;
+}
+var CLAUDE_CLI_ONLY_LEGACY_ALIASES = {
+  "opus-4-1": "claude-opus-4-1",
+  "opus-4.1": "claude-opus-4-1"
+};
+function resolveModelBase(base) {
+  const trimmed = base;
+  const normalized = trimmed.toLowerCase();
+  const claudeValues = Object.values(CLAUDE_MODELS);
+  const knownClaudeModel = claudeValues.find((value) => value.toLowerCase() === normalized);
+  if (knownClaudeModel) {
+    return knownClaudeModel;
+  }
+  if (!normalized.includes("[") && isFamilyAlias("claude", normalized)) {
+    return normalized;
+  }
+  const mapped = CLAUDE_ALIAS_TO_MODEL_ID[normalized] ?? CLAUDE_CLI_ONLY_LEGACY_ALIASES[normalized];
+  if (mapped) {
+    return mapped;
+  }
+  try {
+    const catalogModel = ProviderRegistry.getProviderConfig("claude").models.available.find(
+      (entry) => entry.id === `claude-${normalized}`
+    );
+    if (catalogModel) return catalogModel.id;
+  } catch {
+  }
+  if (normalized.startsWith("claude-")) {
+    return normalized;
+  }
+  if (normalized.startsWith("anthropic.claude-") || normalized.includes(".anthropic.claude-")) {
+    return trimmed;
+  }
+  return void 0;
+}
+function resolveClaudeJudgeModelRole(role, fallbackRole) {
+  try {
+    return ProviderRegistry.getModelForRole("claude", role) ?? (fallbackRole ? ProviderRegistry.getModelForRole("claude", fallbackRole) : void 0) ?? ProviderRegistry.getDefaultModel("claude") ?? CLAUDE_MODELS.SONNET;
+  } catch {
+    switch (role) {
+      case "fast":
+        return CLAUDE_MODELS.HAIKU;
+      default:
+        return fallbackRole ?? CLAUDE_MODELS.SONNET;
+    }
+  }
+}
+var CLAUDE_JUDGE_SONNET = resolveClaudeJudgeModelRole("judge_primary");
+var CLAUDE_JUDGE_OPUS = resolveClaudeJudgeModelRole("judge_primary");
+var CLAUDE_JUDGE_HAIKU = resolveClaudeJudgeModelRole("fast");
+
+// src/core/providers/claude/model-resolver.ts
+function toCanonicalClaudeFamilyId(modelId) {
+  return modelId.replace(/^claude-/, "");
+}
+var FLOATING_CLAUDE_IDENTITIES = /* @__PURE__ */ new Set([
+  CLAUDE_MODELS.FABLE,
+  CLAUDE_MODELS.OPUS,
+  CLAUDE_MODELS.SONNET,
+  CLAUDE_MODELS.HAIKU
+]);
+var LEGACY_CLAUDE_MODEL_ALIASES = {
+  "claude-opus-4-1": CLAUDE_MODELS.OPUS,
+  "claude-opus-4.1": CLAUDE_MODELS.OPUS,
+  "opus-4-1": CLAUDE_MODELS.OPUS,
+  "opus-4.1": CLAUDE_MODELS.OPUS
+};
+function buildClaudeModelAliases() {
+  const aliases = {};
+  for (const [alias, modelId] of Object.entries(CLAUDE_ALIAS_TO_MODEL_ID)) {
+    if (FLOATING_CLAUDE_IDENTITIES.has(alias)) continue;
+    const canonical = toCanonicalClaudeFamilyId(modelId);
+    aliases[alias] = canonical;
+    aliases[modelId.toLowerCase()] = canonical;
+    aliases[`claude-${alias}`] = canonical;
+  }
+  return { ...aliases, ...LEGACY_CLAUDE_MODEL_ALIASES };
+}
+var CLAUDE_MODEL_ALIASES = buildClaudeModelAliases();
+var CANONICAL_MODELS = [
+  .../* @__PURE__ */ new Set([
+    ...FLOATING_CLAUDE_IDENTITIES,
+    ...Object.values(CLAUDE_ALIAS_TO_MODEL_ID).map(toCanonicalClaudeFamilyId)
+  ])
+];
+function normalizeClaudeBackend(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "anthropic" || normalized === "bedrock" || normalized === "vertex" || normalized === "foundry") {
+    return normalized;
+  }
+  return void 0;
+}
+function resolveBackendFromClaudeEnv(env) {
+  if (env.CLAUDE_CODE_USE_BEDROCK === "1") return "bedrock";
+  if (env.CLAUDE_CODE_USE_VERTEX === "1") return "vertex";
+  if (env.CLAUDE_CODE_USE_FOUNDRY === "1") return "foundry";
+  return void 0;
+}
+function resolveTrustedClaudeCredentialBackend(env = process.env) {
+  const configuredBackend = normalizeClaudeBackend(env.BUILD_CLAUDE_BACKEND);
+  if (configuredBackend) return configuredBackend;
+  const envBackend = resolveBackendFromClaudeEnv(env);
+  if (envBackend) return envBackend;
+  return "anthropic";
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readClaudeSettingsEnv(settingsPath) {
+  if (!existsSync(settingsPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (!isPlainRecord(parsed) || !isPlainRecord(parsed.env)) {
+      return void 0;
+    }
+    const env = {};
+    for (const [key, value] of Object.entries(parsed.env)) {
+      if (typeof value === "string") {
+        env[key] = value;
+      }
+    }
+    return env;
+  } catch {
+    return void 0;
+  }
+}
+function claudeSettingsPaths(env, workingDir) {
+  const paths = [];
+  const addSettingsFiles = (dir) => {
+    const trimmed = dir?.trim();
+    if (!trimmed) return;
+    paths.push(path.join(trimmed, "settings.local.json"));
+    paths.push(path.join(trimmed, "settings.json"));
+  };
+  const projectDir = workingDir?.trim();
+  if (projectDir && path.isAbsolute(projectDir)) {
+    addSettingsFiles(path.join(projectDir, ".claude"));
+  }
+  addSettingsFiles(env.CLAUDE_CONFIG_DIR);
+  if (!env.CLAUDE_CONFIG_DIR) {
+    const home = env.HOME?.trim();
+    addSettingsFiles(home ? path.join(home, ".claude") : void 0);
+  }
+  return paths;
+}
+function resolveVertexProject(env) {
+  return env.ANTHROPIC_VERTEX_PROJECT_ID ?? env.GCLOUD_PROJECT ?? env.GOOGLE_CLOUD_PROJECT;
+}
+function resolveClaudeBackend(env = process.env, workingDir) {
+  const configuredBackend = normalizeClaudeBackend(env.BUILD_CLAUDE_BACKEND);
+  if (configuredBackend) return configuredBackend;
+  const envBackend = resolveBackendFromClaudeEnv(resolveClaudeEnvWithSettings(env, workingDir));
+  if (envBackend) return envBackend;
+  return "anthropic";
+}
+var CLAUDE_BACKEND_SETTINGS_KEYS = [
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "AWS_REGION",
+  "AWS_DEFAULT_REGION",
+  "AWS_PROFILE",
+  "CLOUD_ML_REGION",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "GCLOUD_PROJECT",
+  "GOOGLE_CLOUD_PROJECT",
+  "ANTHROPIC_FOUNDRY_RESOURCE",
+  "ANTHROPIC_FOUNDRY_BASE_URL"
+];
+function resolveClaudeEnvWithSettings(env = process.env, workingDir) {
+  const layered = {};
+  for (const settingsPath of [...claudeSettingsPaths(env, workingDir)].reverse()) {
+    Object.assign(layered, readClaudeSettingsEnv(settingsPath) ?? {});
+  }
+  const resolved = { ...layered, ...env };
+  for (const key of CLAUDE_BACKEND_SETTINGS_KEYS) {
+    if (layered[key] !== void 0) resolved[key] = layered[key];
+  }
+  return resolved;
+}
+function buildClaudeBackendEnvOverrides(backend) {
+  return {
+    BUILD_CLAUDE_BACKEND: backend,
+    CLAUDE_CODE_USE_BEDROCK: backend === "bedrock" ? "1" : void 0,
+    CLAUDE_CODE_USE_VERTEX: backend === "vertex" ? "1" : void 0,
+    CLAUDE_CODE_USE_FOUNDRY: backend === "foundry" ? "1" : void 0
+  };
+}
+function synthesizeClaudeBackendEnv(env = process.env, backend = resolveClaudeBackend(env)) {
+  return {
+    ...env,
+    ...buildClaudeBackendEnvOverrides(backend)
+  };
+}
+function detectClaudeProvider(env = process.env, workingDir) {
+  const backend = resolveClaudeBackend(env, workingDir);
+  const connectionEnv = resolveClaudeEnvWithSettings(env, workingDir);
+  if (backend === "bedrock") {
+    const awsRegion = connectionEnv.AWS_REGION ?? connectionEnv.AWS_DEFAULT_REGION;
+    const awsProfile = connectionEnv.AWS_PROFILE;
+    return {
+      provider: "bedrock",
+      ...awsRegion ? { region: awsRegion } : {},
+      ...awsProfile ? { profile: awsProfile } : {}
+    };
+  }
+  if (backend === "vertex") {
+    const region = connectionEnv.CLOUD_ML_REGION;
+    const project = resolveVertexProject(connectionEnv);
+    return {
+      provider: "vertex",
+      ...region ? { region } : {},
+      ...project ? { project } : {}
+    };
+  }
+  if (backend === "foundry") {
+    const resource = connectionEnv.ANTHROPIC_FOUNDRY_RESOURCE;
+    const baseUrl = connectionEnv.ANTHROPIC_FOUNDRY_BASE_URL;
+    return {
+      provider: "foundry",
+      ...resource ? { resource } : {},
+      ...baseUrl ? { baseUrl } : {}
+    };
+  }
+  return { provider: "anthropic" };
+}
+function normalizeCanonicalModel(model) {
+  const raw = model?.trim();
+  if (!raw) {
+    return { warnings: [] };
+  }
+  const lower = splitClaudeModelContextSuffix(raw).base.trim().toLowerCase();
+  const alias = CLAUDE_MODEL_ALIASES[lower];
+  if (alias) {
+    return {
+      canonical: alias,
+      warnings: [`Normalized Claude model "${raw}" to canonical "${alias}"`],
+      raw
+    };
+  }
+  const canonicalValues = CANONICAL_MODELS;
+  const directMatch = canonicalValues.find((value) => value === lower || value === raw);
+  if (directMatch) {
+    return { canonical: directMatch, warnings: [], raw };
+  }
+  const isExpandedClaudeId = lower.startsWith("claude-") || lower.startsWith("anthropic.claude-") || lower.includes(".anthropic.claude-");
+  if (isExpandedClaudeId) {
+    const longestFirst = [...canonicalValues].sort((a, b) => b.length - a.length);
+    const inferredFromExpandedId = longestFirst.find((value) => lower.includes(value));
+    if (inferredFromExpandedId) {
+      return { canonical: inferredFromExpandedId, warnings: [], raw };
+    }
+  }
+  return {
+    warnings: [`Claude model "${raw}" is not recognized; expected claude-* identifiers.`],
+    raw
+  };
+}
+function resolveClaudeModelId(model, env = process.env) {
+  const { canonical, warnings, raw } = normalizeCanonicalModel(model);
+  if (!canonical) {
+    if (env.BUILD_DEBUG === "1") {
+      console.debug(
+        `[Claude model resolver] input=${raw ?? "undefined"} resolved=undefined warnings=${warnings.join(
+          "; "
+        )}`
+      );
+    }
+    return { model: void 0, canonical: void 0, warnings };
+  }
+  if (env.BUILD_DEBUG === "1") {
+    console.debug(
+      `[Claude model resolver] canonical=${canonical} resolved=${canonical} warnings=${warnings.join(
+        "; "
+      )}`
+    );
+  }
+  return { model: canonical, canonical, warnings };
+}
+
+export {
+  CLAUDE_MODELS,
+  CLAUDE_BEDROCK_MODELS,
+  CLAUDE_ALIAS_TO_MODEL_ID,
+  CLAUDE_DISABLE_1M_CONTEXT_ENV,
+  is1MContextDisabled,
+  splitClaudeModelContextSuffix,
+  getClaudeModelContextSuffixWarning,
+  isSpecificClaudeVersionPin,
+  extractClaudeFamilyToken,
+  resolveModel,
+  resolveTrustedClaudeCredentialBackend,
+  resolveClaudeBackend,
+  resolveClaudeEnvWithSettings,
+  synthesizeClaudeBackendEnv,
+  detectClaudeProvider,
+  resolveClaudeModelId
+};
+//# sourceMappingURL=chunk-H3HGMISG.js.map