fix(error_classifier): keep token-rate throttles out of the context-length rule, re-add token-qualified "exceeds the maximum"

Follow-up to cubic's review of 8b0084a:

- "too many tokens per minute" style throttles matched the new "too many
  tokens" context keyword. The rate-limit rule (which runs first) now also
  matches "tokens per minute", "tokens per min" and "(tpm)", so token-rate
  limits stay retryable and never trigger chunking.
- The bare "exceeds the maximum" wording from the old token_utils list is
  back as a compiled pattern that requires "token(s)" within 40 chars, so
  "9000 tokens exceeds the maximum of 8192" chunks while "file exceeds the
  maximum upload size" does not. Rules may now hold regex patterns next to
  substrings; _keyword_matches searches them.
- Bedrock's "Input is too long for requested model" is recognised.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011V8PghiyLvfhK5meqkU4QQ

Author: kevincolten

open_notebook/utils/error_classifier.py

@@ -19,17 +19,30 @@
     RateLimitError,
 )
 
-# Classification rules: (keywords, exception_class, user_message or None to pass through)
-_CLASSIFICATION_RULES: list[tuple[list[str], type[OpenNotebookError], str | None]] = [
+# Classification rules: (keywords, exception_class, user_message or None to pass through).
+# A keyword is a lowercase substring, an HTTP status code (matched as a standalone
+# number) or a compiled regex for wordings a substring can't pin down.
+_Keyword = str | re.Pattern[str]
+_CLASSIFICATION_RULES: list[tuple[list[_Keyword], type[OpenNotebookError], str | None]] = [
     # Authentication errors
     (
         ["authentication", "unauthorized", "invalid api key", "invalid_api_key", "401"],
         AuthenticationError,
         "Authentication failed. Please check your API key in Settings -> Credentials.",
     ),
-    # Rate limit errors
+    # Rate limit errors. Token-rate throttles ("tokens per minute") must be
+    # caught here, before the context-length rule below sees "tokens".
     (
-        ["rate limit", "rate_limit", "429", "too many requests", "quota exceeded"],
+        [
+            "rate limit",
+            "rate_limit",
+            "429",
+            "too many requests",
+            "quota exceeded",
+            "tokens per minute",
+            "tokens per min",
+            "(tpm)",
+        ],
         RateLimitError,
         "Rate limit exceeded. Please wait a moment and try again.",
     ),
@@ -68,8 +81,12 @@
             "max_tokens",
             "too many tokens",
             "input too long",
+            "input is too long",  # Bedrock: "Input is too long for requested model"
             "prompt is too long",
             "input token count",
+            # "exceeds the maximum" only when tokens are what's being counted —
+            # the bare phrase also describes upload sizes and request counts.
+            re.compile(r"tokens?\b.{0,40}\bexceeds? the maximum|exceeds? the maximum\b.{0,40}\btokens?"),
         ],
         ContextLengthExceededError,
         "Content too large for the selected model. Try using a smaller selection or a model with a larger context window.",
@@ -116,15 +133,17 @@ def classify_error(exception: BaseException) -> tuple[type[OpenNotebookError], s
     return ExternalServiceError, f"AI service error: {_truncate(str(exception))}"
 
 
-def _keyword_matches(keyword: str, text: str) -> bool:
+def _keyword_matches(keyword: _Keyword, text: str) -> bool:
     """Substring match, except HTTP status codes ("401", "429", "500", ...)
-    must appear as a standalone number.
+    must appear as a standalone number, and compiled patterns are searched.
 
     Provider messages carry token counts ("142900 tokens > 200000 maximum"),
     and a plain substring check would read "429" out of that count and
     classify a context-length rejection as a rate limit — which then gets
     retried by the worker instead of triggering chunking (cf. #1303 for the
     same bug in the connection test)."""
+    if isinstance(keyword, re.Pattern):
+        return keyword.search(text) is not None
     if keyword.isdigit():
         return re.search(rf"(?<!\d){keyword}(?!\d)", text) is not None
     return keyword in text

tests/test_context_length_no_retry.py

@@ -90,6 +90,11 @@ def test_still_an_external_service_error(self):
             "400 The input token count (250012) exceeds the maximum number of tokens allowed (131072).",
             # OpenAI
             "This model's maximum context length is 8192 tokens. However, your messages resulted in 10500 tokens.",
+            # Bedrock
+            "ValidationException: Input is too long for requested model.",
+            # Generic "exceeds the maximum", qualified by tokens
+            "Prompt of 9000 tokens exceeds the maximum of 8192.",
+            "Request exceeds the maximum allowed tokens for this model.",
         ],
     )
     def test_provider_wordings_are_context_length(self, message):
@@ -102,6 +107,10 @@ def test_provider_wordings_are_context_length(self, message):
         [
             ("Rate limit exceeded. Please wait a moment.", RateLimitError),
             ("Error code: 429 - too many requests", RateLimitError),
+            # Token-rate throttles mention tokens but are transient, not a
+            # context window: they must stay retryable and must not chunk.
+            ("Too many tokens per minute for this model, slow down.", RateLimitError),
+            ("Request too large for model on tokens per min (TPM): Limit 6000", RateLimitError),
             ("Error code: 401 - invalid api key", AuthenticationError),
             ("Error code: 503 - service unavailable", ExternalServiceError),
         ],
@@ -111,6 +120,14 @@ def test_status_codes_still_match_as_standalone_numbers(self, message, expected)
 
         assert exc_class is expected
 
+    def test_bare_exceeds_the_maximum_is_not_context_length(self):
+        """Upload/request-size wording shares the phrase but isn't a token window."""
+        exc_class, _ = classify_error(
+            Exception("File exceeds the maximum upload size of 100 MB")
+        )
+
+        assert not issubclass(exc_class, ContextLengthExceededError)
+
     def test_status_code_inside_a_larger_number_does_not_match(self):
         """"4290 items" must not read as HTTP 429; unknown wording falls through
         to the generic external error."""