@xortex/xcode 3.0.0

package/utils/model/agent.ts

@@ -0,0 +1,157 @@
+import type { PermissionMode } from '../permissions/PermissionMode.js'
+import { capitalize } from '../stringUtils.js'
+import { MODEL_ALIASES, type ModelAlias } from './aliases.js'
+import { applyBedrockRegionPrefix, getBedrockRegionPrefix } from './bedrock.js'
+import {
+  getCanonicalName,
+  getRuntimeMainLoopModel,
+  parseUserSpecifiedModel,
+} from './model.js'
+import { getAPIProvider } from './providers.js'
+
+export const AGENT_MODEL_OPTIONS = [...MODEL_ALIASES, 'inherit'] as const
+export type AgentModelAlias = (typeof AGENT_MODEL_OPTIONS)[number]
+
+export type AgentModelOption = {
+  value: AgentModelAlias
+  label: string
+  description: string
+}
+
+/**
+ * Get the default subagent model. Returns 'inherit' so subagents inherit
+ * the model from the parent thread.
+ */
+export function getDefaultSubagentModel(): string {
+  return 'inherit'
+}
+
+/**
+ * Get the effective model string for an agent.
+ *
+ * For Bedrock, if the parent model uses a cross-region inference prefix (e.g., "eu.", "us."),
+ * that prefix is inherited by subagents using alias models (e.g., "sonnet", "haiku", "opus").
+ * This ensures subagents use the same region as the parent, which is necessary when
+ * IAM permissions are scoped to specific cross-region inference profiles.
+ */
+export function getAgentModel(
+  agentModel: string | undefined,
+  parentModel: string,
+  toolSpecifiedModel?: ModelAlias,
+  permissionMode?: PermissionMode,
+): string {
+  if (process.env.CLAUDE_CODE_SUBAGENT_MODEL) {
+    return parseUserSpecifiedModel(process.env.CLAUDE_CODE_SUBAGENT_MODEL)
+  }
+
+  // Extract Bedrock region prefix from parent model to inherit for subagents.
+  // This ensures subagents use the same cross-region inference profile (e.g., "eu.", "us.")
+  // as the parent, which is required when IAM permissions only allow specific regions.
+  const parentRegionPrefix = getBedrockRegionPrefix(parentModel)
+
+  // Helper to apply parent region prefix for Bedrock models.
+  // `originalSpec` is the raw model string before resolution (alias or full ID).
+  // If the user explicitly specified a full model ID that already carries its own
+  // region prefix (e.g., "eu.anthropic.…"), we preserve it instead of overwriting
+  // with the parent's prefix. This prevents silent data-residency violations when
+  // an agent config intentionally pins to a different region than the parent.
+  const applyParentRegionPrefix = (
+    resolvedModel: string,
+    originalSpec: string,
+  ): string => {
+    if (parentRegionPrefix && getAPIProvider() === 'bedrock') {
+      if (getBedrockRegionPrefix(originalSpec)) return resolvedModel
+      return applyBedrockRegionPrefix(resolvedModel, parentRegionPrefix)
+    }
+    return resolvedModel
+  }
+
+  // Prioritize tool-specified model if provided
+  if (toolSpecifiedModel) {
+    if (aliasMatchesParentTier(toolSpecifiedModel, parentModel)) {
+      return parentModel
+    }
+    const model = parseUserSpecifiedModel(toolSpecifiedModel)
+    return applyParentRegionPrefix(model, toolSpecifiedModel)
+  }
+
+  const agentModelWithExp = agentModel ?? getDefaultSubagentModel()
+
+  if (agentModelWithExp === 'inherit') {
+    // Apply runtime model resolution for inherit to get the effective model
+    // This ensures agents using 'inherit' get opusplan→Opus resolution in plan mode
+    return getRuntimeMainLoopModel({
+      permissionMode: permissionMode ?? 'default',
+      mainLoopModel: parentModel,
+      exceeds200kTokens: false,
+    })
+  }
+
+  if (aliasMatchesParentTier(agentModelWithExp, parentModel)) {
+    return parentModel
+  }
+  const model = parseUserSpecifiedModel(agentModelWithExp)
+  return applyParentRegionPrefix(model, agentModelWithExp)
+}
+
+/**
+ * Check if a bare family alias (opus/sonnet/haiku) matches the parent model's
+ * tier. When it does, the subagent inherits the parent's exact model string
+ * instead of resolving the alias to a provider default.
+ *
+ * Prevents surprising downgrades: a Vertex user on Opus 4.6 (via /model) who
+ * spawns a subagent with `model: opus` should get Opus 4.6, not whatever
+ * getDefaultOpusModel() returns for 3P.
+ * See https://github.com/anthropics/claude-code/issues/30815.
+ *
+ * Only bare family aliases match. `opus[1m]`, `best`, `opusplan` fall through
+ * since they carry semantics beyond "same tier as parent".
+ */
+function aliasMatchesParentTier(alias: string, parentModel: string): boolean {
+  const canonical = getCanonicalName(parentModel)
+  switch (alias.toLowerCase()) {
+    case 'opus':
+      return canonical.includes('opus')
+    case 'sonnet':
+      return canonical.includes('sonnet')
+    case 'haiku':
+      return canonical.includes('haiku')
+    default:
+      return false
+  }
+}
+
+export function getAgentModelDisplay(model: string | undefined): string {
+  // When model is omitted, getDefaultSubagentModel() returns 'inherit' at runtime
+  if (!model) return 'Inherit from parent (default)'
+  if (model === 'inherit') return 'Inherit from parent'
+  return capitalize(model)
+}
+
+/**
+ * Get available model options for agents
+ */
+export function getAgentModelOptions(): AgentModelOption[] {
+  return [
+    {
+      value: 'sonnet',
+      label: 'Sonnet',
+      description: 'Balanced performance - best for most agents',
+    },
+    {
+      value: 'opus',
+      label: 'Opus',
+      description: 'Most capable for complex reasoning tasks',
+    },
+    {
+      value: 'haiku',
+      label: 'Haiku',
+      description: 'Fast and efficient for simple tasks',
+    },
+    {
+      value: 'inherit',
+      label: 'Inherit from parent',
+      description: 'Use the same model as the main conversation',
+    },
+  ]
+}

package/utils/model/aliases.ts

@@ -0,0 +1,35 @@
+export const MODEL_ALIASES = [
+  'sonnet',
+  'opus',
+  'haiku',
+  'best',
+  'sonnet[1m]',
+  'opus[1m]',
+  'opusplan',
+  // OpenRouter model aliases
+  'kimi',
+  'kimi2.5',
+  'kimi-k2.5',
+  'deepseek',
+  'deepseek-v3.2',
+  'gemini',
+  'gemini-pro',
+  'gemini-2.5',
+  'gemini-2.5-pro',
+] as const
+export type ModelAlias = (typeof MODEL_ALIASES)[number]
+
+export function isModelAlias(modelInput: string): modelInput is ModelAlias {
+  return MODEL_ALIASES.includes(modelInput as ModelAlias)
+}
+
+/**
+ * Bare model family aliases that act as wildcards in the availableModels allowlist.
+ * When "opus" is in the allowlist, ANY opus model is allowed (opus 4.5, 4.6, etc.).
+ * When a specific model ID is in the allowlist, only that exact version is allowed.
+ */
+export const MODEL_FAMILY_ALIASES = ['sonnet', 'opus', 'haiku', 'kimi', 'deepseek', 'gemini'] as const
+
+export function isModelFamilyAlias(model: string): boolean {
+  return (MODEL_FAMILY_ALIASES as readonly string[]).includes(model)
+}

package/utils/model/antModels.ts

@@ -0,0 +1,64 @@
+import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js'
+import type { EffortLevel } from '../effort.js'
+
+export type AntModel = {
+  alias: string
+  model: string
+  label: string
+  description?: string
+  defaultEffortValue?: number
+  defaultEffortLevel?: EffortLevel
+  contextWindow?: number
+  defaultMaxTokens?: number
+  upperMaxTokensLimit?: number
+  /** Model defaults to adaptive thinking and rejects `thinking: { type: 'disabled' }`. */
+  alwaysOnThinking?: boolean
+}
+
+export type AntModelSwitchCalloutConfig = {
+  modelAlias?: string
+  description: string
+  version: string
+}
+
+export type AntModelOverrideConfig = {
+  defaultModel?: string
+  defaultModelEffortLevel?: EffortLevel
+  defaultSystemPromptSuffix?: string
+  antModels?: AntModel[]
+  switchCallout?: AntModelSwitchCalloutConfig
+}
+
+// @[MODEL LAUNCH]: Update tengu_ant_model_override with new ant-only models
+// @[MODEL LAUNCH]: Add the codename to scripts/excluded-strings.txt to prevent it from leaking to external builds.
+export function getAntModelOverrideConfig(): AntModelOverrideConfig | null {
+  if (process.env.USER_TYPE !== 'ant') {
+    return null
+  }
+  return getFeatureValue_CACHED_MAY_BE_STALE<AntModelOverrideConfig | null>(
+    'tengu_ant_model_override',
+    null,
+  )
+}
+
+export function getAntModels(): AntModel[] {
+  if (process.env.USER_TYPE !== 'ant') {
+    return []
+  }
+  return getAntModelOverrideConfig()?.antModels ?? []
+}
+
+export function resolveAntModel(
+  model: string | undefined,
+): AntModel | undefined {
+  if (process.env.USER_TYPE !== 'ant') {
+    return undefined
+  }
+  if (model === undefined) {
+    return undefined
+  }
+  const lower = model.toLowerCase()
+  return getAntModels().find(
+    m => m.alias === model || lower.includes(m.model.toLowerCase()),
+  )
+}

package/utils/model/bedrock.ts

@@ -0,0 +1,265 @@
+import memoize from 'lodash-es/memoize.js'
+import { refreshAndGetAwsCredentials } from '../auth.js'
+import { getAWSRegion, isEnvTruthy } from '../envUtils.js'
+import { logError } from '../log.js'
+import { getAWSClientProxyConfig } from '../proxy.js'
+
+export const getBedrockInferenceProfiles = memoize(async function (): Promise<
+  string[]
+> {
+  const [client, { ListInferenceProfilesCommand }] = await Promise.all([
+    createBedrockClient(),
+    import('@aws-sdk/client-bedrock'),
+  ])
+  const allProfiles = []
+  let nextToken: string | undefined
+
+  try {
+    do {
+      const command = new ListInferenceProfilesCommand({
+        ...(nextToken && { nextToken }),
+        typeEquals: 'SYSTEM_DEFINED',
+      })
+      const response = await client.send(command)
+
+      if (response.inferenceProfileSummaries) {
+        allProfiles.push(...response.inferenceProfileSummaries)
+      }
+
+      nextToken = response.nextToken
+    } while (nextToken)
+
+    // Filter for Anthropic models (SYSTEM_DEFINED filtering handled in query)
+    return allProfiles
+      .filter(profile => profile.inferenceProfileId?.includes('anthropic'))
+      .map(profile => profile.inferenceProfileId)
+      .filter(Boolean) as string[]
+  } catch (error) {
+    logError(error as Error)
+    throw error
+  }
+})
+
+export function findFirstMatch(
+  profiles: string[],
+  substring: string,
+): string | null {
+  return profiles.find(p => p.includes(substring)) ?? null
+}
+
+async function createBedrockClient() {
+  const { BedrockClient } = await import('@aws-sdk/client-bedrock')
+  // Match the Anthropic Bedrock SDK's region behavior exactly:
+  // - Reads AWS_REGION or AWS_DEFAULT_REGION env vars (not AWS config files)
+  // - Falls back to 'us-east-1' if neither is set
+  // This ensures we query profiles from the same region the client will use
+  const region = getAWSRegion()
+
+  const skipAuth = isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)
+
+  const clientConfig: ConstructorParameters<typeof BedrockClient>[0] = {
+    region,
+    ...(process.env.ANTHROPIC_BEDROCK_BASE_URL && {
+      endpoint: process.env.ANTHROPIC_BEDROCK_BASE_URL,
+    }),
+    ...(await getAWSClientProxyConfig()),
+    ...(skipAuth && {
+      requestHandler: new (
+        await import('@smithy/node-http-handler')
+      ).NodeHttpHandler(),
+      httpAuthSchemes: [
+        {
+          schemeId: 'smithy.api#noAuth',
+          identityProvider: () => async () => ({}),
+          signer: new (await import('@smithy/core')).NoAuthSigner(),
+        },
+      ],
+      httpAuthSchemeProvider: () => [{ schemeId: 'smithy.api#noAuth' }],
+    }),
+  }
+
+  if (!skipAuth && !process.env.AWS_BEARER_TOKEN_BEDROCK) {
+    // Only refresh credentials if not using API key authentication
+    const cachedCredentials = await refreshAndGetAwsCredentials()
+    if (cachedCredentials) {
+      clientConfig.credentials = {
+        accessKeyId: cachedCredentials.accessKeyId,
+        secretAccessKey: cachedCredentials.secretAccessKey,
+        sessionToken: cachedCredentials.sessionToken,
+      }
+    }
+  }
+
+  return new BedrockClient(clientConfig)
+}
+
+export async function createBedrockRuntimeClient() {
+  const { BedrockRuntimeClient } = await import(
+    '@aws-sdk/client-bedrock-runtime'
+  )
+  const region = getAWSRegion()
+  const skipAuth = isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)
+
+  const clientConfig: ConstructorParameters<typeof BedrockRuntimeClient>[0] = {
+    region,
+    ...(process.env.ANTHROPIC_BEDROCK_BASE_URL && {
+      endpoint: process.env.ANTHROPIC_BEDROCK_BASE_URL,
+    }),
+    ...(await getAWSClientProxyConfig()),
+    ...(skipAuth && {
+      // BedrockRuntimeClient defaults to HTTP/2 without fallback
+      // proxy servers may not support this, so we explicitly force HTTP/1.1
+      requestHandler: new (
+        await import('@smithy/node-http-handler')
+      ).NodeHttpHandler(),
+      httpAuthSchemes: [
+        {
+          schemeId: 'smithy.api#noAuth',
+          identityProvider: () => async () => ({}),
+          signer: new (await import('@smithy/core')).NoAuthSigner(),
+        },
+      ],
+      httpAuthSchemeProvider: () => [{ schemeId: 'smithy.api#noAuth' }],
+    }),
+  }
+
+  if (!skipAuth && !process.env.AWS_BEARER_TOKEN_BEDROCK) {
+    // Only refresh credentials if not using API key authentication
+    const cachedCredentials = await refreshAndGetAwsCredentials()
+    if (cachedCredentials) {
+      clientConfig.credentials = {
+        accessKeyId: cachedCredentials.accessKeyId,
+        secretAccessKey: cachedCredentials.secretAccessKey,
+        sessionToken: cachedCredentials.sessionToken,
+      }
+    }
+  }
+
+  return new BedrockRuntimeClient(clientConfig)
+}
+
+export const getInferenceProfileBackingModel = memoize(async function (
+  profileId: string,
+): Promise<string | null> {
+  try {
+    const [client, { GetInferenceProfileCommand }] = await Promise.all([
+      createBedrockClient(),
+      import('@aws-sdk/client-bedrock'),
+    ])
+    const command = new GetInferenceProfileCommand({
+      inferenceProfileIdentifier: profileId,
+    })
+    const response = await client.send(command)
+
+    if (!response.models || response.models.length === 0) {
+      return null
+    }
+
+    // Use the first model as the primary backing model for cost calculation
+    // In practice, application inference profiles typically load balance between
+    // similar models with the same cost structure
+    const primaryModel = response.models[0]
+    if (!primaryModel?.modelArn) {
+      return null
+    }
+
+    // Extract model name from ARN
+    // ARN format: arn:aws:bedrock:region:account:foundation-model/model-name
+    const lastSlashIndex = primaryModel.modelArn.lastIndexOf('/')
+    return lastSlashIndex >= 0
+      ? primaryModel.modelArn.substring(lastSlashIndex + 1)
+      : primaryModel.modelArn
+  } catch (error) {
+    logError(error as Error)
+    return null
+  }
+})
+
+/**
+ * Check if a model ID is a foundation model (e.g., "anthropic.claude-sonnet-4-5-20250929-v1:0")
+ */
+export function isFoundationModel(modelId: string): boolean {
+  return modelId.startsWith('anthropic.')
+}
+
+/**
+ * Cross-region inference profile prefixes for Bedrock.
+ * These prefixes allow routing requests to models in specific regions.
+ */
+const BEDROCK_REGION_PREFIXES = ['us', 'eu', 'apac', 'global'] as const
+
+/**
+ * Extract the model/inference profile ID from a Bedrock ARN.
+ * If the input is not an ARN, returns it unchanged.
+ *
+ * ARN format: arn:aws:bedrock:<region>:<account>:inference-profile/<profile-id>
+ * Also handles: arn:aws:bedrock:<region>:<account>:application-inference-profile/<profile-id>
+ * And foundation model ARNs: arn:aws:bedrock:<region>::foundation-model/<model-id>
+ */
+export function extractModelIdFromArn(modelId: string): string {
+  if (!modelId.startsWith('arn:')) {
+    return modelId
+  }
+  const lastSlashIndex = modelId.lastIndexOf('/')
+  if (lastSlashIndex === -1) {
+    return modelId
+  }
+  return modelId.substring(lastSlashIndex + 1)
+}
+
+export type BedrockRegionPrefix = (typeof BEDROCK_REGION_PREFIXES)[number]
+
+/**
+ * Extract the region prefix from a Bedrock cross-region inference model ID.
+ * Handles both plain model IDs and full ARN format.
+ * For example:
+ * - "eu.anthropic.claude-sonnet-4-5-20250929-v1:0" → "eu"
+ * - "us.anthropic.claude-3-7-sonnet-20250219-v1:0" → "us"
+ * - "arn:aws:bedrock:ap-northeast-2:123:inference-profile/global.anthropic.claude-opus-4-6-v1" → "global"
+ * - "anthropic.claude-3-5-sonnet-20241022-v2:0" → undefined (foundation model)
+ * - "claude-sonnet-4-5-20250929" → undefined (first-party format)
+ */
+export function getBedrockRegionPrefix(
+  modelId: string,
+): BedrockRegionPrefix | undefined {
+  // Extract the inference profile ID from ARN format if present
+  // ARN format: arn:aws:bedrock:<region>:<account>:inference-profile/<profile-id>
+  const effectiveModelId = extractModelIdFromArn(modelId)
+
+  for (const prefix of BEDROCK_REGION_PREFIXES) {
+    if (effectiveModelId.startsWith(`${prefix}.anthropic.`)) {
+      return prefix
+    }
+  }
+  return undefined
+}
+
+/**
+ * Apply a region prefix to a Bedrock model ID.
+ * If the model already has a different region prefix, it will be replaced.
+ * If the model is a foundation model (anthropic.*), the prefix will be added.
+ * If the model is not a Bedrock model, it will be returned as-is.
+ *
+ * For example:
+ * - applyBedrockRegionPrefix("us.anthropic.claude-sonnet-4-5-v1:0", "eu") → "eu.anthropic.claude-sonnet-4-5-v1:0"
+ * - applyBedrockRegionPrefix("anthropic.claude-sonnet-4-5-v1:0", "eu") → "eu.anthropic.claude-sonnet-4-5-v1:0"
+ * - applyBedrockRegionPrefix("claude-sonnet-4-5-20250929", "eu") → "claude-sonnet-4-5-20250929" (not a Bedrock model)
+ */
+export function applyBedrockRegionPrefix(
+  modelId: string,
+  prefix: BedrockRegionPrefix,
+): string {
+  // Check if it already has a region prefix and replace it
+  const existingPrefix = getBedrockRegionPrefix(modelId)
+  if (existingPrefix) {
+    return modelId.replace(`${existingPrefix}.`, `${prefix}.`)
+  }
+
+  // Check if it's a foundation model (anthropic.*) and add the prefix
+  if (isFoundationModel(modelId)) {
+    return `${prefix}.${modelId}`
+  }
+
+  // Not a Bedrock model format, return as-is
+  return modelId
+}

package/utils/model/check1mAccess.ts

@@ -0,0 +1,72 @@
+import type { OverageDisabledReason } from 'src/services/claudeAiLimits.js'
+import { isClaudeAISubscriber } from '../auth.js'
+import { getGlobalConfig } from '../config.js'
+import { is1mContextDisabled } from '../context.js'
+
+/**
+ * Check if extra usage is enabled based on the cached disabled reason.
+ * Extra usage is considered enabled if there's no disabled reason,
+ * or if the disabled reason indicates it's provisioned but temporarily unavailable.
+ */
+function isExtraUsageEnabled(): boolean {
+  const reason = getGlobalConfig().cachedExtraUsageDisabledReason
+  // undefined = no cache yet, treat as not enabled (conservative)
+  if (reason === undefined) {
+    return false
+  }
+  // null = no disabled reason from API, extra usage is enabled
+  if (reason === null) {
+    return true
+  }
+  // Check which disabled reasons still mean "provisioned"
+  switch (reason as OverageDisabledReason) {
+    // Provisioned but credits depleted — still counts as enabled
+    case 'out_of_credits':
+      return true
+    // Not provisioned or actively disabled
+    case 'overage_not_provisioned':
+    case 'org_level_disabled':
+    case 'org_level_disabled_until':
+    case 'seat_tier_level_disabled':
+    case 'member_level_disabled':
+    case 'seat_tier_zero_credit_limit':
+    case 'group_zero_credit_limit':
+    case 'member_zero_credit_limit':
+    case 'org_service_level_disabled':
+    case 'org_service_zero_credit_limit':
+    case 'no_limits_configured':
+    case 'unknown':
+      return false
+    default:
+      return false
+  }
+}
+
+// @[MODEL LAUNCH]: Add check if the new model supports 1M context
+export function checkOpus1mAccess(): boolean {
+  if (is1mContextDisabled()) {
+    return false
+  }
+
+  if (isClaudeAISubscriber()) {
+    // Subscribers have access if extra usage is enabled for their account
+    return isExtraUsageEnabled()
+  }
+
+  // Non-subscribers (API/PAYG) have access
+  return true
+}
+
+export function checkSonnet1mAccess(): boolean {
+  if (is1mContextDisabled()) {
+    return false
+  }
+
+  if (isClaudeAISubscriber()) {
+    // Subscribers have access if extra usage is enabled for their account
+    return isExtraUsageEnabled()
+  }
+
+  // Non-subscribers (API/PAYG) have access
+  return true
+}