fix: align modelLimits with reviewer feedback

Author: tobwen

README.md

@@ -108,6 +108,13 @@ DCP uses its own config file:
 >             // to keep the model in the "smart zone" (not a hard limit)
 >             // Accepts: number or "X%" (percentage of model's context window)
 >             "contextLimit": 100000,
+>             // Optional per-model overrides by exact providerID/modelID
+>             // Accepts: number or "X%"
+>             // Example:
+>             // "modelLimits": {
+>             //     "openai/gpt-5": 120000,
+>             //     "anthropic/claude-3-7-sonnet": "80%"
+>             // },
 >             // Additional tools to protect from pruning
 >             "protectedTools": [],
 >         },

dcp.schema.json

@@ -123,7 +123,7 @@
                             ]
                         },
                         "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*\"",
+                            "description": "Model-specific context limits by exact provider/model key. Examples: \"openai/gpt-5\", \"anthropic/claude-3-7-sonnet\", \"ollama/llama3.1\"",
                             "type": "object",
                             "additionalProperties": {
                                 "oneOf": [

lib/config.ts

@@ -139,7 +139,7 @@ function getConfigKeyPaths(obj: Record<string, any>, prefix = ""): string[] {
         const fullKey = prefix ? `${prefix}.${key}` : key
         keys.push(fullKey)
 
-        // modelLimits is a dynamic map keyed by model ID; do not recurse into arbitrary IDs.
+        // modelLimits is a dynamic map keyed by providerID/modelID; do not recurse into arbitrary IDs.
         if (fullKey === "tools.settings.modelLimits") {
             continue
         }
@@ -322,40 +322,44 @@ export function validateConfigTypes(config: Record<string, any>): ValidationErro
                         actual: typeof tools.settings.modelLimits,
                     })
                 } else {
-                    for (const [modelId, limit] of Object.entries(tools.settings.modelLimits)) {
+                    for (const [providerModelKey, 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}`,
+                                key: `tools.settings.modelLimits.${providerModelKey}`,
                                 expected: 'number | "${number}%"',
                                 actual: JSON.stringify(limit),
                             })
                         }
                     }
                 }
             }
-            if (tools.distill?.permission !== undefined) {
-                const validValues = ["ask", "allow", "deny"]
-                if (!validValues.includes(tools.distill.permission)) {
+            if (tools.distill) {
+                if (tools.distill.permission !== undefined) {
+                    const validValues = ["ask", "allow", "deny"]
+                    if (!validValues.includes(tools.distill.permission)) {
+                        errors.push({
+                            key: "tools.distill.permission",
+                            expected: '"ask" | "allow" | "deny"',
+                            actual: JSON.stringify(tools.distill.permission),
+                        })
+                    }
+                }
+                if (
+                    tools.distill.showDistillation !== undefined &&
+                    typeof tools.distill.showDistillation !== "boolean"
+                ) {
                     errors.push({
-                        key: "tools.distill.permission",
-                        expected: '"ask" | "allow" | "deny"',
-                        actual: JSON.stringify(tools.distill.permission),
+                        key: "tools.distill.showDistillation",
+                        expected: "boolean",
+                        actual: typeof tools.distill.showDistillation,
                     })
                 }
             }
-            if (
-                tools.distill?.showDistillation !== undefined &&
-                typeof tools.distill.showDistillation !== "boolean"
-            ) {
-                errors.push({
-                    key: "tools.distill.showDistillation",
-                    expected: "boolean",
-                    actual: typeof tools.distill.showDistillation,
-                })
-            }
         }
         if (tools.compress) {
             if (tools.compress.permission !== undefined) {

lib/messages/inject.ts

@@ -27,13 +27,6 @@ function parsePercentageString(value: string, total: number): number | undefined
     return Math.round((clampedPercent / 100) * total)
 }
 
-export const findModelLimit = (
-    modelId: string,
-    modelLimits: Record<string, number | `${number}%`>,
-): number | `${number}%` | undefined => {
-    return modelLimits[modelId]
-}
-
 // XML wrappers
 export const wrapPrunableTools = (content: string): string => {
     return `<prunable-tools>
@@ -76,15 +69,18 @@ Context management was just performed. Do NOT use the ${toolName} again. A fresh
 const resolveContextLimit = (
     config: PluginConfig,
     state: SessionState,
-    messages: WithParts[],
+    providerId: string | undefined,
+    modelId: string | undefined,
 ): number | undefined => {
-    const { settings } = config.tools
-    const { modelLimits, contextLimit } = settings
+    const modelLimits = config.tools.settings.modelLimits
+    const contextLimit = config.tools.settings.contextLimit
 
     if (modelLimits) {
-        const userMsg = getLastUserMessage(messages)
-        const modelId = userMsg ? (userMsg.info as UserMessage).model.modelID : undefined
-        const limit = modelId !== undefined ? findModelLimit(modelId, modelLimits) : undefined
+        const providerModelId =
+            providerId !== undefined && modelId !== undefined
+                ? `${providerId}/${modelId}`
+                : undefined
+        const limit = providerModelId !== undefined ? modelLimits[providerModelId] : undefined
 
         if (limit !== undefined) {
             if (typeof limit === "string" && limit.endsWith("%")) {
@@ -114,12 +110,14 @@ const shouldInjectCompressNudge = (
     config: PluginConfig,
     state: SessionState,
     messages: WithParts[],
+    providerId: string | undefined,
+    modelId: string | undefined,
 ): boolean => {
     if (config.tools.compress.permission === "deny") {
         return false
     }
 
-    const contextLimit = resolveContextLimit(config, state, messages)
+    const contextLimit = resolveContextLimit(config, state, providerId, modelId)
     if (contextLimit === undefined) {
         return false
     }
@@ -226,6 +224,13 @@ export const insertPruneToolContext = (
 
     const pruneOrDistillEnabled = pruneEnabled || distillEnabled
     const contentParts: string[] = []
+    const lastUserMessage = getLastUserMessage(messages)
+    const providerId = lastUserMessage
+        ? (lastUserMessage.info as UserMessage).model.providerID
+        : undefined
+    const modelId = lastUserMessage
+        ? (lastUserMessage.info as UserMessage).model.modelID
+        : undefined
 
     if (state.lastToolPrune) {
         logger.debug("Last tool was prune - injecting cooldown message")
@@ -245,7 +250,7 @@ export const insertPruneToolContext = (
             contentParts.push(compressContext)
         }
 
-        if (shouldInjectCompressNudge(config, state, messages)) {
+        if (shouldInjectCompressNudge(config, state, messages, providerId, modelId)) {
             logger.info("Inserting compress nudge - token usage exceeds contextLimit")
             contentParts.push(renderCompressNudge())
         } else if (
@@ -263,7 +268,6 @@ export const insertPruneToolContext = (
 
     const combinedContent = contentParts.join("\n")
 
-    const lastUserMessage = getLastUserMessage(messages)
     if (!lastUserMessage) {
         return
     }