feat: add model-specific context limits via modelLimits

Introduce toolSettings.modelLimits to allow per-model context limits as absolute token values or percentages. Update schema validation, config merging/cloning, and context limit resolution so model-specific values override the global contextLimit when available.

Example:
```json
{
  "toolSettings": {
    "contextLimit": "60%",
    "modelLimits": {
      "opencode/dax-1": "40%",
      "opencode/zen-3": 120000,
      "ollama/*": "25%",
      "*dcp*": 125000
    }
  }
}
```

Author: tobwen

dcp.schema.json

@@ -121,6 +121,21 @@
                                     "pattern": "^\\d+(?:\\.\\d+)?%$"
                                 }
                             ]
+                        },
+                        "modelLimits": {
+                            "description": "Model-specific context limits with optional wildcard patterns (exact match first, then most specific wildcard). Examples: \"openai/gpt-5\", \"*/zen-1\", \"ollama/*\", \"*sonnet*\"",
+                            "type": "object",
+                            "additionalProperties": {
+                                "oneOf": [
+                                    {
+                                        "type": "number"
+                                    },
+                                    {
+                                        "type": "string",
+                                        "pattern": "^\\d+(?:\\.\\d+)?%$"
+                                    }
+                                ]
+                            }
                         }
                     }
                 },

lib/config.ts

@@ -28,6 +28,7 @@ export interface ToolSettings {
     nudgeFrequency: number
     protectedTools: string[]
     contextLimit: number | `${number}%`
+    modelLimits?: Record<string, number | `${number}%`>
 }
 
 export interface Tools {
@@ -107,6 +108,7 @@ export const VALID_CONFIG_KEYS = new Set([
     "tools.settings.nudgeFrequency",
     "tools.settings.protectedTools",
     "tools.settings.contextLimit",
+    "tools.settings.modelLimits",
     "tools.distill",
     "tools.distill.permission",
     "tools.distill.showDistillation",
@@ -136,6 +138,12 @@ function getConfigKeyPaths(obj: Record<string, any>, prefix = ""): string[] {
     for (const key of Object.keys(obj)) {
         const fullKey = prefix ? `${prefix}.${key}` : key
         keys.push(fullKey)
+
+        // modelLimits is a dynamic map keyed by model ID; do not recurse into arbitrary IDs.
+        if (fullKey === "tools.settings.modelLimits") {
+            continue
+        }
+
         if (obj[key] && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
             keys.push(...getConfigKeyPaths(obj[key], fullKey))
         }
@@ -156,7 +164,7 @@ interface ValidationError {
     actual: string
 }
 
-function validateConfigTypes(config: Record<string, any>): ValidationError[] {
+export function validateConfigTypes(config: Record<string, any>): ValidationError[] {
     const errors: ValidationError[] = []
 
     // Top-level validators
@@ -303,9 +311,32 @@ function validateConfigTypes(config: Record<string, any>): ValidationError[] {
                     })
                 }
             }
-        }
-        if (tools.distill) {
-            if (tools.distill.permission !== undefined) {
+            if (tools.settings.modelLimits !== undefined) {
+                if (
+                    typeof tools.settings.modelLimits !== "object" ||
+                    Array.isArray(tools.settings.modelLimits)
+                ) {
+                    errors.push({
+                        key: "tools.settings.modelLimits",
+                        expected: "Record<string, number | ${number}%>",
+                        actual: typeof tools.settings.modelLimits,
+                    })
+                } else {
+                    for (const [modelId, limit] of Object.entries(tools.settings.modelLimits)) {
+                        const isValidNumber = typeof limit === "number"
+                        const isPercentString =
+                            typeof limit === "string" && /^\d+(?:\.\d+)?%$/.test(limit)
+                        if (!isValidNumber && !isPercentString) {
+                            errors.push({
+                                key: `tools.settings.modelLimits.${modelId}`,
+                                expected: 'number | "${number}%"',
+                                actual: JSON.stringify(limit),
+                            })
+                        }
+                    }
+                }
+            }
+            if (tools.distill?.permission !== undefined) {
                 const validValues = ["ask", "allow", "deny"]
                 if (!validValues.includes(tools.distill.permission)) {
                     errors.push({
@@ -316,7 +347,7 @@ function validateConfigTypes(config: Record<string, any>): ValidationError[] {
                 }
             }
             if (
-                tools.distill.showDistillation !== undefined &&
+                tools.distill?.showDistillation !== undefined &&
                 typeof tools.distill.showDistillation !== "boolean"
             ) {
                 errors.push({
@@ -684,6 +715,7 @@ function mergeTools(
                 ]),
             ],
             contextLimit: override.settings?.contextLimit ?? base.settings.contextLimit,
+            modelLimits: override.settings?.modelLimits ?? base.settings.modelLimits,
         },
         distill: {
             permission: override.distill?.permission ?? base.distill.permission,
@@ -724,6 +756,7 @@ function deepCloneConfig(config: PluginConfig): PluginConfig {
             settings: {
                 ...config.tools.settings,
                 protectedTools: [...config.tools.settings.protectedTools],
+                modelLimits: { ...config.tools.settings.modelLimits },
             },
             distill: { ...config.tools.distill },
             compress: { ...config.tools.compress },

lib/messages/inject.ts

@@ -27,6 +27,48 @@ function parsePercentageString(value: string, total: number): number | undefined
     return Math.round((clampedPercent / 100) * total)
 }
 
+const escapeRegex = (value: string): string => {
+    return value.replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+}
+
+const wildcardPatternToRegex = (pattern: string): RegExp => {
+    const escapedPattern = escapeRegex(pattern)
+    const regexPattern = escapedPattern.replace(/\*/g, ".*")
+    return new RegExp(`^${regexPattern}$`)
+}
+
+const wildcardSpecificity = (pattern: string): number => {
+    return pattern.replace(/\*/g, "").length
+}
+
+export const findModelLimit = (
+    modelId: string,
+    modelLimits: Record<string, number | `${number}%`>,
+): number | `${number}%` | undefined => {
+    const exactMatch = modelLimits[modelId]
+    if (exactMatch !== undefined) {
+        return exactMatch
+    }
+
+    const wildcardMatches = Object.entries(modelLimits)
+        .filter(([pattern]) => pattern.includes("*"))
+        .filter(([pattern]) => wildcardPatternToRegex(pattern).test(modelId))
+
+    if (wildcardMatches.length === 0) {
+        return undefined
+    }
+
+    wildcardMatches.sort(([leftPattern], [rightPattern]) => {
+        const specificityDiff = wildcardSpecificity(rightPattern) - wildcardSpecificity(leftPattern)
+        if (specificityDiff !== 0) {
+            return specificityDiff
+        }
+        return leftPattern.localeCompare(rightPattern)
+    })
+
+    return wildcardMatches[0][1]
+}
+
 // XML wrappers
 export const wrapPrunableTools = (content: string): string => {
     return `<prunable-tools>
@@ -66,21 +108,41 @@ Context management was just performed. Do NOT use the ${toolName} again. A fresh
 </context-info>`
 }
 
-const resolveContextLimit = (config: PluginConfig, state: SessionState): number | undefined => {
-    const configLimit = config.tools.settings.contextLimit
+const resolveContextLimit = (
+    config: PluginConfig,
+    state: SessionState,
+    messages: WithParts[],
+): number | undefined => {
+    const { settings } = config.tools
+    const { modelLimits, contextLimit } = settings
+
+    if (modelLimits) {
+        const userMsg = getLastUserMessage(messages)
+        const modelId = userMsg ? (userMsg.info as UserMessage).model.modelID : undefined
+        const limit = modelId !== undefined ? findModelLimit(modelId, modelLimits) : undefined
+
+        if (limit !== undefined) {
+            if (typeof limit === "string" && limit.endsWith("%")) {
+                if (state.modelContextLimit === undefined) {
+                    return undefined
+                }
+                return parsePercentageString(limit, state.modelContextLimit)
+            }
+            return typeof limit === "number" ? limit : undefined
+        }
+    }
 
-    if (typeof configLimit === "string") {
-        if (configLimit.endsWith("%")) {
+    if (typeof contextLimit === "string") {
+        if (contextLimit.endsWith("%")) {
             if (state.modelContextLimit === undefined) {
                 return undefined
             }
-            return parsePercentageString(configLimit, state.modelContextLimit)
+            return parsePercentageString(contextLimit, state.modelContextLimit)
         }
-
         return undefined
     }
 
-    return configLimit
+    return contextLimit
 }
 
 const shouldInjectCompressNudge = (
@@ -92,7 +154,7 @@ const shouldInjectCompressNudge = (
         return false
     }
 
-    const contextLimit = resolveContextLimit(config, state)
+    const contextLimit = resolveContextLimit(config, state, messages)
     if (contextLimit === undefined) {
         return false
     }