@illuma-ai/agents 1.3.0 → 1.3.1

package/dist/cjs/main.cjs

@@ -62,6 +62,7 @@ var contextPressure = require('./utils/contextPressure.cjs');
 var toolDiscoveryCache = require('./utils/toolDiscoveryCache.cjs');
 var pruneCalibration = require('./utils/pruneCalibration.cjs');
 var fileManifest = require('./utils/fileManifest.cjs');
+var errors = require('./utils/errors.cjs');
 var index$1 = require('./llm/openai/index.cjs');
 var index = require('./llm/openrouter/index.cjs');
 var providers = require('./llm/providers.cjs');
@@ -425,6 +426,9 @@ exports.createPruneCalibration = pruneCalibration.createPruneCalibration;
 exports.updatePruneCalibration = pruneCalibration.updatePruneCalibration;
 exports.FILE_MANIFEST_PREFIX = fileManifest.FILE_MANIFEST_PREFIX;
 exports.buildFileManifestBlock = fileManifest.buildFileManifestBlock;
+exports.extractErrorMessage = errors.extractErrorMessage;
+exports.isContextOverflowError = errors.isContextOverflowError;
+exports.isLikelyContextOverflowError = errors.isLikelyContextOverflowError;
 exports.CustomOpenAIClient = index$1.CustomOpenAIClient;
 exports.ChatOpenRouter = index.ChatOpenRouter;
 exports.getChatModelClass = providers.getChatModelClass;

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/utils/errors.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+/**
+ * Context-overflow error detection helpers.
+ *
+ * Provider error messages vary — Anthropic returns "prompt is too long",
+ * OpenAI returns "context_length_exceeded", Bedrock returns "Input is too
+ * long", Google returns a size-limit phrase. This module centralises the
+ * phrase list so the agent graph's emergency-prune retry can classify
+ * errors consistently instead of duplicating inline substring matches at
+ * each call site.
+ *
+ * The strict check (`isContextOverflowError`) matches only known phrases.
+ * The loose check (`isLikelyContextOverflowError`) also matches a heuristic
+ * regex for providers we haven't explicitly catalogued. Both filter out
+ * false positives (rate-limit, auth, quota, billing) that might otherwise
+ * trigger an unnecessary prune retry.
+ */
+const CONTEXT_OVERFLOW_PHRASES = [
+    'request_too_large',
+    'context length exceeded',
+    'maximum context length',
+    'prompt is too long',
+    'exceeds model context window',
+    'exceeds the model',
+    'too large for model',
+    'context_length_exceeded',
+    'max_tokens',
+    'token limit',
+    'input too long',
+    'input is too long',
+    'payload too large',
+    'content_too_large',
+];
+const CONTEXT_OVERFLOW_HINT_RE = /413|too large|too long|context.*exceed|exceed.*context|token.*limit|limit.*token|prompt.*size|size.*limit|maximum.*length|length.*maximum/i;
+const FALSE_POSITIVE_RE = /rate.?limit|too many requests|quota|billing|auth|permission|forbidden/i;
+/**
+ * Extracts a human-readable error message from an unknown error value.
+ * Walks common shapes: strings, Error instances, `{ message }`,
+ * `{ error: string }`, `{ error: { message } }`. Falls back to
+ * JSON.stringify or String() so callers never have to null-check.
+ */
+function extractErrorMessage(error) {
+    if (error == null) {
+        return '';
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'object') {
+        const record = error;
+        if (typeof record.message === 'string') {
+            return record.message;
+        }
+        if (typeof record.error === 'string') {
+            return record.error;
+        }
+        if (typeof record.error === 'object' &&
+            record.error != null &&
+            typeof record.error.message === 'string') {
+            return record.error.message;
+        }
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+/**
+ * Strict check: returns true only for known, unambiguous context-overflow
+ * phrases. Use when the recovery action is expensive (full prune + retry)
+ * and false positives are undesirable.
+ */
+function isContextOverflowError(errorMessage) {
+    if (!errorMessage) {
+        return false;
+    }
+    const lower = errorMessage.toLowerCase();
+    if (FALSE_POSITIVE_RE.test(lower)) {
+        return false;
+    }
+    return CONTEXT_OVERFLOW_PHRASES.some((phrase) => lower.includes(phrase));
+}
+/**
+ * Loose check: returns true for known phrases OR heuristic regex matches.
+ * Preferred by the graph's emergency-prune retry because the cost of a
+ * false positive is one extra retry with a smaller context, while the
+ * cost of a false negative is an opaque provider failure surfaced to
+ * the user.
+ */
+function isLikelyContextOverflowError(errorMessage) {
+    if (!errorMessage) {
+        return false;
+    }
+    if (isContextOverflowError(errorMessage)) {
+        return true;
+    }
+    const lower = errorMessage.toLowerCase();
+    if (FALSE_POSITIVE_RE.test(lower)) {
+        return false;
+    }
+    return CONTEXT_OVERFLOW_HINT_RE.test(lower);
+}
+
+exports.extractErrorMessage = extractErrorMessage;
+exports.isContextOverflowError = isContextOverflowError;
+exports.isLikelyContextOverflowError = isLikelyContextOverflowError;
+//# sourceMappingURL=errors.cjs.map

package/dist/cjs/utils/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","sources":["../../../src/utils/errors.ts"],"sourcesContent":["/**\n * Context-overflow error detection helpers.\n *\n * Provider error messages vary — Anthropic returns \"prompt is too long\",\n * OpenAI returns \"context_length_exceeded\", Bedrock returns \"Input is too\n * long\", Google returns a size-limit phrase. This module centralises the\n * phrase list so the agent graph's emergency-prune retry can classify\n * errors consistently instead of duplicating inline substring matches at\n * each call site.\n *\n * The strict check (`isContextOverflowError`) matches only known phrases.\n * The loose check (`isLikelyContextOverflowError`) also matches a heuristic\n * regex for providers we haven't explicitly catalogued. Both filter out\n * false positives (rate-limit, auth, quota, billing) that might otherwise\n * trigger an unnecessary prune retry.\n */\n\nconst CONTEXT_OVERFLOW_PHRASES = [\n  'request_too_large',\n  'context length exceeded',\n  'maximum context length',\n  'prompt is too long',\n  'exceeds model context window',\n  'exceeds the model',\n  'too large for model',\n  'context_length_exceeded',\n  'max_tokens',\n  'token limit',\n  'input too long',\n  'input is too long',\n  'payload too large',\n  'content_too_large',\n] as const;\n\nconst CONTEXT_OVERFLOW_HINT_RE =\n  /413|too large|too long|context.*exceed|exceed.*context|token.*limit|limit.*token|prompt.*size|size.*limit|maximum.*length|length.*maximum/i;\n\nconst FALSE_POSITIVE_RE =\n  /rate.?limit|too many requests|quota|billing|auth|permission|forbidden/i;\n\n/**\n * Extracts a human-readable error message from an unknown error value.\n * Walks common shapes: strings, Error instances, `{ message }`,\n * `{ error: string }`, `{ error: { message } }`. Falls back to\n * JSON.stringify or String() so callers never have to null-check.\n */\nexport function extractErrorMessage(error: unknown): string {\n  if (error == null) {\n    return '';\n  }\n  if (typeof error === 'string') {\n    return error;\n  }\n  if (error instanceof Error) {\n    return error.message;\n  }\n  if (typeof error === 'object') {\n    const record = error as Record<string, unknown>;\n    if (typeof record.message === 'string') {\n      return record.message;\n    }\n    if (typeof record.error === 'string') {\n      return record.error;\n    }\n    if (\n      typeof record.error === 'object' &&\n      record.error != null &&\n      typeof (record.error as Record<string, unknown>).message === 'string'\n    ) {\n      return (record.error as Record<string, unknown>).message as string;\n    }\n  }\n  try {\n    return JSON.stringify(error);\n  } catch {\n    return String(error);\n  }\n}\n\n/**\n * Strict check: returns true only for known, unambiguous context-overflow\n * phrases. Use when the recovery action is expensive (full prune + retry)\n * and false positives are undesirable.\n */\nexport function isContextOverflowError(errorMessage?: string): boolean {\n  if (!errorMessage) {\n    return false;\n  }\n  const lower = errorMessage.toLowerCase();\n  if (FALSE_POSITIVE_RE.test(lower)) {\n    return false;\n  }\n  return CONTEXT_OVERFLOW_PHRASES.some((phrase) => lower.includes(phrase));\n}\n\n/**\n * Loose check: returns true for known phrases OR heuristic regex matches.\n * Preferred by the graph's emergency-prune retry because the cost of a\n * false positive is one extra retry with a smaller context, while the\n * cost of a false negative is an opaque provider failure surfaced to\n * the user.\n */\nexport function isLikelyContextOverflowError(errorMessage?: string): boolean {\n  if (!errorMessage) {\n    return false;\n  }\n  if (isContextOverflowError(errorMessage)) {\n    return true;\n  }\n  const lower = errorMessage.toLowerCase();\n  if (FALSE_POSITIVE_RE.test(lower)) {\n    return false;\n  }\n  return CONTEXT_OVERFLOW_HINT_RE.test(lower);\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;AAeG;AAEH,MAAM,wBAAwB,GAAG;IAC/B,mBAAmB;IACnB,yBAAyB;IACzB,wBAAwB;IACxB,oBAAoB;IACpB,8BAA8B;IAC9B,mBAAmB;IACnB,qBAAqB;IACrB,yBAAyB;IACzB,YAAY;IACZ,aAAa;IACb,gBAAgB;IAChB,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;CACX;AAEV,MAAM,wBAAwB,GAC5B,4IAA4I;AAE9I,MAAM,iBAAiB,GACrB,wEAAwE;AAE1E;;;;;AAKG;AACG,SAAU,mBAAmB,CAAC,KAAc,EAAA;AAChD,IAAA,IAAI,KAAK,IAAI,IAAI,EAAE;AACjB,QAAA,OAAO,EAAE;IACX;AACA,IAAA,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AAC7B,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IAAI,KAAK,YAAY,KAAK,EAAE;QAC1B,OAAO,KAAK,CAAC,OAAO;IACtB;AACA,IAAA,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,MAAM,MAAM,GAAG,KAAgC;AAC/C,QAAA,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,EAAE;YACtC,OAAO,MAAM,CAAC,OAAO;QACvB;AACA,QAAA,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,EAAE;YACpC,OAAO,MAAM,CAAC,KAAK;QACrB;AACA,QAAA,IACE,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ;YAChC,MAAM,CAAC,KAAK,IAAI,IAAI;YACpB,OAAQ,MAAM,CAAC,KAAiC,CAAC,OAAO,KAAK,QAAQ,EACrE;AACA,YAAA,OAAQ,MAAM,CAAC,KAAiC,CAAC,OAAiB;QACpE;IACF;AACA,IAAA,IAAI;AACF,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;IAC9B;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB;AACF;AAEA;;;;AAIG;AACG,SAAU,sBAAsB,CAAC,YAAqB,EAAA;IAC1D,IAAI,CAAC,YAAY,EAAE;AACjB,QAAA,OAAO,KAAK;IACd;AACA,IAAA,MAAM,KAAK,GAAG,YAAY,CAAC,WAAW,EAAE;AACxC,IAAA,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AACjC,QAAA,OAAO,KAAK;IACd;AACA,IAAA,OAAO,wBAAwB,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC1E;AAEA;;;;;;AAMG;AACG,SAAU,4BAA4B,CAAC,YAAqB,EAAA;IAChE,IAAI,CAAC,YAAY,EAAE;AACjB,QAAA,OAAO,KAAK;IACd;AACA,IAAA,IAAI,sBAAsB,CAAC,YAAY,CAAC,EAAE;AACxC,QAAA,OAAO,IAAI;IACb;AACA,IAAA,MAAM,KAAK,GAAG,YAAY,CAAC,WAAW,EAAE;AACxC,IAAA,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;AACjC,QAAA,OAAO,KAAK;IACd;AACA,IAAA,OAAO,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC;AAC7C;;;;;;"}

package/dist/esm/graphs/Graph.mjs

@@ -27,6 +27,7 @@ import { hasTaskTool, buildPostPruneNote, detectDocuments, shouldInjectMultiDocH
 import { ToolDiscoveryCache } from '../utils/toolDiscoveryCache.mjs';
 import { createPruneCalibration, applyCalibration, updatePruneCalibration } from '../utils/pruneCalibration.mjs';
 import { buildFileManifestBlock } from '../utils/fileManifest.mjs';
+import { isLikelyContextOverflowError } from '../utils/errors.mjs';
 import { getChatModelClass, manualToolStreamProviders } from '../llm/providers.mjs';
 import { ToolNode, toolsCondition } from '../tools/ToolNode.mjs';
 import { ChatOpenAI, AzureChatOpenAI } from '../llm/openai/index.mjs';
@@ -1548,14 +1549,8 @@ class StandardGraph extends Graph {
                 }, config);
             }
             catch (primaryError) {
-                // Check if this is a "input too long" error from Bedrock/Anthropic
-                const errorMessage = primaryError.message.toLowerCase();
-                const isInputTooLongError = errorMessage.includes('too long') ||
-                    errorMessage.includes('input is too long') ||
-                    errorMessage.includes('context length') ||
-                    errorMessage.includes('maximum context') ||
-                    errorMessage.includes('validationexception') ||
-                    errorMessage.includes('prompt is too long');
+                const errorMessage = primaryError.message;
+                const isInputTooLongError = isLikelyContextOverflowError(errorMessage);
                 // Log when we detect the error
                 if (isInputTooLongError) {
                     mwarn('[Graph] Detected input too long error:', errorMessage.substring(0, 200));
@@ -1659,10 +1654,8 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                             console.info(`[Graph] ✅ Retry successful at ${reductionFactor * 100}% with ${reducedMessages.length} messages (reduced from ${finalMessages.length})`);
                         }
                         catch (retryError) {
-                            const retryErrorMsg = retryError.message.toLowerCase();
-                            const stillTooLong = retryErrorMsg.includes('too long') ||
-                                retryErrorMsg.includes('context length') ||
-                                retryErrorMsg.includes('validationexception');
+                            const retryErrorMsg = retryError.message;
+                            const stillTooLong = isLikelyContextOverflowError(retryErrorMsg);
                             if (stillTooLong && reductionFactor > 0.1) {
                                 mwarn(`[Graph] Still too long at ${reductionFactor * 100}%, trying more aggressive pruning...`);
                             }