@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-77I6G4CO.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-77I6G4CO.js.map

package/dist/chunk-7DJ6SQH3.js

@@ -0,0 +1,510 @@
+import {
+  estimateCatalogTokenCostUsd
+} from "./chunk-EJ4LUU5Y.js";
+
+// src/core/providers/model-update/schema.ts
+import { z } from "zod";
+
+// src/core/providers/model-update/prompts.ts
+var TRUSTED_DOMAINS = [
+  // Anthropic
+  "anthropic.com",
+  // OpenAI
+  "openai.com",
+  // Google - multiple official domains used for announcements and documentation
+  "ai.google.dev",
+  "cloud.google.com",
+  "blog.google",
+  "deepmind.google",
+  "deepmind.com",
+  // Separate domain from deepmind.google
+  "developers.googleblog.com",
+  // Google developer announcements (not a subdomain of blog.google)
+  "developers.google.com",
+  // Google developer documentation
+  // xAI
+  "x.ai",
+  // OpenRouter
+  "openrouter.ai",
+  // GitHub (for Copilot announcements)
+  "github.com",
+  "docs.github.com",
+  // GLM (Zhipu AI)
+  "zhipuai.cn",
+  "open.bigmodel.cn",
+  // Model registries and hubs (commonly cited by LLMs)
+  "huggingface.co",
+  // Model cards frequently referenced
+  // Mistral AI
+  "mistral.ai",
+  "docs.mistral.ai",
+  // Cohere
+  "cohere.com",
+  "docs.cohere.com"
+];
+var DOMAIN_ALLOWLIST_STRING = TRUSTED_DOMAINS.join(", ");
+var PROVIDER_CONTEXT = {
+  claude: `
+Anthropic Claude models. Look for:
+- Model IDs like: claude-opus-4-5, claude-sonnet-4-5, claude-haiku-4-5, claude-3.x-*
+- Full versioned names: claude-opus-4-5-20251101
+- Check anthropic.com/news for announcements
+- Check docs.anthropic.com for model documentation`,
+  openai: `
+OpenAI GPT models. Look for:
+- GPT series: gpt-5, gpt-5.4, gpt-5.5, gpt-5-mini, gpt-5-pro
+- Reasoning series: o3, o3-mini, o4-mini
+- Codex models: gpt-5.5, gpt-5.4-mini, gpt-5-codex
+- Check openai.com/index for announcements
+- Check platform.openai.com/docs/models for API names`,
+  gemini: `
+Google Gemini models. Look for:
+- Gemini 3.x: gemini-3-pro, gemini-3-flash (NEWEST as of Dec 2025)
+- Gemini 2.5.x: gemini-2.5-pro, gemini-2.5-flash
+- Check blog.google for announcements
+- Check ai.google.dev/models for official list`,
+  xai: `
+xAI Grok models. Look for:
+- Grok series: grok-3, grok-3-mini, grok-4, grok-4-fast
+- Check x.ai for announcements`,
+  openrouter: `
+OpenRouter aggregates models from multiple providers.
+- Check openrouter.ai/docs/models for the full list
+- Model IDs are prefixed: anthropic/claude-*, openai/gpt-*, google/gemini-*
+- Include free tier models (suffix :free)
+- Note: Build fetches OpenRouter via direct API; return an empty list here`
+};
+var PROVIDER_SEED_URLS = {
+  claude: ["https://docs.anthropic.com/en/docs/about-claude/models", "https://anthropic.com/news"],
+  openai: ["https://platform.openai.com/docs/models", "https://openai.com/index"],
+  gemini: ["https://ai.google.dev/models", "https://blog.google/technology/ai/"],
+  xai: ["https://x.ai", "https://x.ai/blog"],
+  openrouter: ["https://openrouter.ai/docs/models"]
+};
+function generateModelUpdatePrompt(asOfDate) {
+  const isoDate = asOfDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `Find the LATEST AI models from major providers as of ${isoDate}.
+
+## Instructions
+
+1. **Trusted Sources Only**: ${DOMAIN_ALLOWLIST_STRING}
+2. **Model IDs must be exact API identifiers** (e.g., "claude-opus-4-5", not "Claude Opus")
+3. **Per-model source URLs required** - provide the specific URL where each model was found
+4. **Limit**: Max 15 models per provider, prefer newest/most important
+5. **Skip OpenRouter** - set openrouter to empty array (fetched via API)
+
+## Starting URLs
+
+${Object.entries(PROVIDER_SEED_URLS).map(([provider, urls]) => `- ${provider.toUpperCase()}: ${urls.join(" \u2022 ")}`).join("\n")}
+
+## Provider Hints
+
+${Object.entries(PROVIDER_CONTEXT).map(
+    ([provider, context]) => `**${provider.toUpperCase()}**: ${context.trim().split("\n").slice(1, 3).join(" ")}`
+  ).join("\n")}
+
+## Output Format (JSON only, no markdown)
+
+{
+  "providers": {
+    "claude": [{"id": "claude-opus-4-5", "displayName": "Claude Opus 4.5", "provider": "claude", "sources": ["https://anthropic.com/news/..."], "capabilities": ["code", "reasoning"], "contextWindow": 200000, "maxOutputTokens": 32000, "fullVersionedName": "claude-opus-4-5-20251101", "thinkingSupported": true, "confidence": "high"}],
+    "openai": [...],
+    "gemini": [...],
+    "xai": [...],
+    "openrouter": []
+  },
+  "discoveredAt": "${isoDate}T00:00:00Z"
+}
+
+## Required Fields
+- **id**: Exact API identifier
+- **displayName**: Human-readable name
+- **provider**: claude|openai|gemini|xai|openrouter
+- **sources**: URLs where found (min 1)
+- **confidence**: "high" (official docs), "medium" (news), "low" (inferred)
+
+## Optional Fields
+- **capabilities**: Array of tags (code, reasoning, vision, etc.)
+- **contextWindow**: Max tokens if confirmed
+- **maxOutputTokens**: Max output tokens if confirmed
+- **fullVersionedName**: Full dated model name when available
+- **thinkingSupported**: true when extended reasoning/thinking mode is available
+- **releaseDate**: ISO date or YYYY-MM
+
+Focus on current/default models and newest releases. Skip deprecated models.`;
+}
+var MODEL_UPDATE_TOKEN_USAGE = { inputTokens: 2e3, outputTokens: 3e3 };
+function estimateModelUpdateCost(cliId) {
+  return estimateCatalogTokenCostUsd(cliId, MODEL_UPDATE_TOKEN_USAGE);
+}
+
+// src/core/providers/model-update/schema.ts
+var ConfidenceLevel = z.enum(["high", "medium", "low"]);
+var VerificationStatus = z.enum(["verified", "unverified", "failed"]);
+var ExistenceVerificationStatus = z.enum(["verified", "high-confidence", "unverified"]);
+var ModelUpdateModelSchema = z.object({
+  // Required fields
+  id: z.string().min(1).regex(
+    /^[a-z0-9._@:/-]+$/i,
+    "Model ID must be alphanumeric with dots, underscores, hyphens, @, colons, forward slashes"
+  ),
+  displayName: z.string().min(1).optional(),
+  // Optional for deprecated models
+  provider: z.enum(["claude", "openai", "gemini", "xai", "openrouter"]),
+  sources: z.array(z.string().url()).min(1, "At least one source URL is required per model"),
+  // Optional but important fields
+  capabilities: z.array(z.string()).optional(),
+  contextWindow: z.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
+  reasoningEffortLevels: z.array(z.string()).optional(),
+  fullVersionedName: z.string().min(1).optional(),
+  thinkingSupported: z.boolean().optional(),
+  factSource: z.enum(["official", "community"]).optional(),
+  fieldSources: z.record(z.string(), z.enum(["official", "community", "native"])).optional(),
+  canonicalId: z.string().optional(),
+  lineage: z.string().optional(),
+  lifecycle: z.record(z.string(), z.unknown()).optional(),
+  thinking: z.object({
+    supported: z.boolean().optional(),
+    adaptive: z.boolean().optional(),
+    budget_tokens_supported: z.boolean().optional(),
+    min_budget_tokens: z.number().int().optional(),
+    default_budget_tokens: z.number().int().optional(),
+    max_budget_tokens: z.number().int().optional()
+  }).optional(),
+  releaseDate: z.string().optional(),
+  // ISO date string or "2025-12" format
+  availabilityNotes: z.string().optional(),
+  // Free-form notes about regional/account availability
+  // Confidence tracking
+  confidence: ConfidenceLevel.default("medium"),
+  // Pricing - NOTE: Only populated if verified from official source
+  // LLM-suggested pricing goes to pricingNotes, not here
+  pricing: z.object({
+    inputPer1M: z.number().nonnegative(),
+    outputPer1M: z.number().nonnegative(),
+    cachedInputPer1M: z.number().nonnegative().optional()
+  }).optional(),
+  // If pricing couldn't be verified, store LLM suggestion here (advisory only)
+  pricingNotes: z.string().optional(),
+  // Delta mode fields
+  deprecated: z.boolean().optional(),
+  // Announced deprecation, not confirmed retirement
+  previousId: z.string().optional()
+  // if renamed, the old model ID
+}).refine(
+  (model) => model.deprecated === true || model.displayName && model.displayName.length > 0,
+  { message: "displayName is required unless model is deprecated" }
+);
+var ModelEnrichmentMetadataSchema = z.object({
+  maxInputTokens: z.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
+  contextWindow: z.number().int().positive().optional(),
+  maxCompletionTokens: z.number().int().positive().optional(),
+  features: z.record(z.string(), z.boolean()).optional()
+});
+var ModelUpdateResponseSchema = z.object({
+  providers: z.object({
+    claude: z.array(ModelUpdateModelSchema).optional(),
+    openai: z.array(ModelUpdateModelSchema).optional(),
+    gemini: z.array(ModelUpdateModelSchema).optional(),
+    xai: z.array(ModelUpdateModelSchema).optional(),
+    openrouter: z.array(ModelUpdateModelSchema).optional()
+  }),
+  discoveredAt: z.string(),
+  // ISO timestamp
+  globalSources: z.array(z.string().url()).optional()
+  // Additional sources not tied to specific models
+});
+var ChangeType = z.enum(["add", "update", "deprecate"]);
+var ProposedChangeSchema = z.object({
+  type: ChangeType,
+  provider: z.string(),
+  modelId: z.string(),
+  model: ModelUpdateModelSchema.optional(),
+  // Present for add/update
+  previousModel: z.any().optional(),
+  // Present for update (existing config)
+  verificationStatus: VerificationStatus,
+  reason: z.string(),
+  // Human-readable explanation
+  // Existence verification from programmatic sources (OpenRouter + LiteLLM)
+  existenceVerification: ExistenceVerificationStatus.optional(),
+  verifiedSources: z.array(z.enum(["openrouter", "litellm"])).optional(),
+  enrichmentMetadata: ModelEnrichmentMetadataSchema.optional()
+});
+var ProposedChangesSchema = z.object({
+  changes: z.array(ProposedChangeSchema),
+  summary: z.object({
+    added: z.number(),
+    updated: z.number(),
+    deprecated: z.number(),
+    unverifiedCount: z.number(),
+    // Existence verification breakdown
+    existenceVerified: z.number().optional(),
+    // Found in both OpenRouter AND LiteLLM
+    existenceHighConfidence: z.number().optional(),
+    // Found in one source
+    existenceUnverified: z.number().optional()
+    // Not found in programmatic sources
+  }),
+  modelUpdateProvider: z.string(),
+  // Which CLI produced the update (claude, gemini, ...)
+  discoveredAt: z.string(),
+  estimatedCost: z.number().optional()
+  // Estimated cost of model update call
+});
+var ModelMetadataSchema = z.object({
+  firstSeenAt: z.string().optional(),
+  // ISO timestamp
+  lastSeenAt: z.string().optional(),
+  // ISO timestamp
+  updatedVia: z.string().optional(),
+  // e.g., "claude-web-search", "openrouter-api"
+  verificationStatus: VerificationStatus.optional(),
+  missedUpdateCount: z.number().int().nonnegative().optional(),
+  deprecated: z.boolean().optional()
+});
+var KNOWN_PROVIDER_KEYS = ["claude", "openai", "gemini", "xai", "openrouter"];
+function looksLikeProviderData(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const record = obj;
+  return KNOWN_PROVIDER_KEYS.some((key) => key in record && Array.isArray(record[key]));
+}
+var WRAPPER_KEYS = ["data", "response", "result", "output", "content"];
+function tryUnwrapValue(value) {
+  if (!value) return null;
+  if (typeof value === "string") {
+    const extracted = extractJsonFromResponse(value);
+    return extracted ?? null;
+  }
+  if (typeof value === "object") {
+    return value;
+  }
+  return null;
+}
+function normalizeModelUpdateResponse(raw) {
+  if (!raw) return raw;
+  if (Array.isArray(raw)) {
+    let bestCandidate = null;
+    for (const item of raw) {
+      if (item && typeof item === "object") {
+        const normalized = normalizeModelUpdateResponse(item);
+        if (normalized && typeof normalized === "object") {
+          const record2 = normalized;
+          if ("providers" in record2 || looksLikeProviderData(record2)) {
+            bestCandidate = normalized;
+          }
+        }
+      }
+    }
+    return bestCandidate ?? raw;
+  }
+  if (typeof raw !== "object") return raw;
+  const record = raw;
+  if ("providers" in record) {
+    return {
+      ...record,
+      discoveredAt: record.discoveredAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  for (const wrapperKey of WRAPPER_KEYS) {
+    if (!(wrapperKey in record)) continue;
+    const wrapperValue = record[wrapperKey];
+    const unwrapped = tryUnwrapValue(wrapperValue);
+    if (unwrapped && typeof unwrapped === "object") {
+      const unwrappedRecord = unwrapped;
+      if ("providers" in unwrappedRecord || looksLikeProviderData(unwrappedRecord)) {
+        return normalizeModelUpdateResponse(unwrapped);
+      }
+      const normalized = normalizeModelUpdateResponse(unwrapped);
+      if (normalized !== unwrapped) {
+        return normalized;
+      }
+    }
+  }
+  if (looksLikeProviderData(record)) {
+    const providers = {};
+    for (const key of KNOWN_PROVIDER_KEYS) {
+      if (key in record && Array.isArray(record[key])) {
+        providers[key] = record[key];
+      }
+    }
+    const discoveredAt = typeof record.discoveredAt === "string" ? record.discoveredAt : (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      providers,
+      discoveredAt,
+      globalSources: record.globalSources
+    };
+  }
+  return raw;
+}
+function parseModelUpdateResponse(raw) {
+  const normalized = normalizeModelUpdateResponse(raw);
+  const result = ModelUpdateResponseSchema.safeParse(normalized);
+  if (!result.success) {
+    console.error("[ModelUpdate] Invalid response schema:", result.error.format());
+    if (raw !== normalized) {
+      console.error(
+        "[ModelUpdate] Original structure was normalized from:",
+        typeof raw === "object" ? Object.keys(raw) : typeof raw
+      );
+    }
+    return null;
+  }
+  for (const models of Object.values(result.data.providers)) {
+    for (const model of models ?? []) {
+      delete model.factSource;
+      delete model.fieldSources;
+    }
+  }
+  return result.data;
+}
+function normalizeModelId(id) {
+  return id.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9._@:/-]/g, "");
+}
+function isJsonWrapperStart(char) {
+  return char === "{" || char === "[";
+}
+function isJsonWrapperEnd(char) {
+  return char === "}" || char === "]";
+}
+function wrappersMatch(start, end) {
+  return start === "{" && end === "}" || start === "[" && end === "]";
+}
+function extractFirstParsableJsonSubstring(text) {
+  for (let startIndex = 0; startIndex < text.length; startIndex++) {
+    const startChar = text[startIndex];
+    if (!startChar || !isJsonWrapperStart(startChar)) continue;
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    for (let i = startIndex; i < text.length; i++) {
+      const char = text[i];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        continue;
+      }
+      if (isJsonWrapperStart(char)) {
+        stack.push(char);
+        continue;
+      }
+      if (isJsonWrapperEnd(char)) {
+        const last = stack.pop();
+        if (!last || !wrappersMatch(last, char)) {
+          break;
+        }
+        if (stack.length === 0) {
+          const candidate = text.slice(startIndex, i + 1);
+          try {
+            JSON.parse(candidate);
+            return candidate;
+          } catch {
+            break;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function extractJsonFromResponse(response, options = {}) {
+  const trimmed = response.trim();
+  if (options.strict) {
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const codeBlockRegex = /```(?:json|jsonc)?\s*([\s\S]*?)```/gi;
+  for (const match of response.matchAll(codeBlockRegex)) {
+    const block = match[1]?.trim();
+    if (!block) continue;
+    try {
+      return JSON.parse(block);
+    } catch {
+      const extracted2 = extractFirstParsableJsonSubstring(block);
+      if (extracted2) {
+        try {
+          return JSON.parse(extracted2);
+        } catch {
+        }
+      }
+    }
+  }
+  const extracted = extractFirstParsableJsonSubstring(response);
+  if (extracted) {
+    try {
+      return JSON.parse(extracted);
+    } catch {
+    }
+  }
+  return null;
+}
+function isValidAllowlistedUrl(source) {
+  if (typeof source !== "string") return false;
+  try {
+    const url = new URL(source);
+    return TRUSTED_DOMAINS.some(
+      (domain) => url.hostname === domain || url.hostname.endsWith(`.${domain}`)
+    );
+  } catch {
+    return false;
+  }
+}
+var V1_PROVIDERS = ["claude", "openai", "gemini", "xai", "openrouter"];
+var PROVIDER_ID_MAP = {
+  claude: "claude",
+  openai: "codex",
+  // Maps to our internal 'codex' provider
+  gemini: "gemini",
+  // Vendor V1 discovery key stays 'xai'; canonical YAML/provider id is 'grok'
+  xai: "grok",
+  openrouter: "openrouter"
+};
+var YAML_TO_V1_PROVIDER = {
+  claude: "claude",
+  codex: "openai",
+  // YAML 'codex' maps to schema 'openai'
+  gemini: "gemini",
+  // Canonical YAML key 'grok' maps back to vendor discovery key 'xai'
+  grok: "xai",
+  openrouter: "openrouter"
+};
+
+export {
+  TRUSTED_DOMAINS,
+  generateModelUpdatePrompt,
+  estimateModelUpdateCost,
+  ModelUpdateModelSchema,
+  parseModelUpdateResponse,
+  normalizeModelId,
+  extractJsonFromResponse,
+  isValidAllowlistedUrl,
+  V1_PROVIDERS,
+  PROVIDER_ID_MAP,
+  YAML_TO_V1_PROVIDER
+};
+//# sourceMappingURL=chunk-7DJ6SQH3.js.map