@tea-agent/loop-agent 0.40.0-next.10 → 0.40.0-next.12

package/dist/shared/pi-context-pressure/compaction-policy.js

@@ -0,0 +1,151 @@
+import { parseBoundedNumber, readContextPressureMode, } from "./env.js";
+export const PI_DEFAULT_RESERVE_TOKENS = 16_384;
+export const DEFAULT_TRAILING_BUDGET_TOKENS = 8_192;
+export const DEFAULT_SAFETY_MARGIN_TOKENS = 4_096;
+export const DEFAULT_MINIMUM_WORKING_SET = 32_768;
+export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;
+export function parseCompactionPolicy(env = process.env) {
+    const diagnostics = [];
+    const modeResult = readContextPressureMode(env);
+    if (modeResult.diagnostic)
+        diagnostics.push(modeResult.diagnostic);
+    const k = parseBoundedNumber(env.HARNESS_CONTEXT_GATEWAY_K, 1, 1, 8);
+    if (k.diagnostic)
+        diagnostics.push(k.diagnostic);
+    const trailing = parseBoundedNumber(env.HARNESS_CONTEXT_TRAILING_BUDGET_TOKENS, DEFAULT_TRAILING_BUDGET_TOKENS, 256, 128_000);
+    if (trailing.diagnostic)
+        diagnostics.push(trailing.diagnostic);
+    const safety = parseBoundedNumber(env.HARNESS_CONTEXT_SAFETY_MARGIN_TOKENS, DEFAULT_SAFETY_MARGIN_TOKENS, 0, 64_000);
+    if (safety.diagnostic)
+        diagnostics.push(safety.diagnostic);
+    const explicit = env.HARNESS_COMPACTION_RESERVE_TOKENS;
+    const explicitReserve = explicit === undefined || explicit.trim() === ""
+        ? undefined
+        : parseBoundedNumber(explicit, PI_DEFAULT_RESERVE_TOKENS, 1_024, 1_000_000);
+    if (explicitReserve?.diagnostic)
+        diagnostics.push(explicitReserve.diagnostic);
+    return {
+        mode: modeResult.mode,
+        k: k.value,
+        trailingBudgetTokens: trailing.value,
+        safetyMarginTokens: safety.value,
+        minimumWorkingSet: DEFAULT_MINIMUM_WORKING_SET,
+        ...(explicitReserve ? { explicitReserveTokens: explicitReserve.value } : {}),
+        diagnostics,
+    };
+}
+export function deriveEffectiveWindow(contextWindow, policy) {
+    const W = Math.floor(contextWindow);
+    if (!Number.isFinite(W) || W <= 0) {
+        return {
+            recommendedReserve: PI_DEFAULT_RESERVE_TOKENS,
+            triggerTokens: 0,
+            fallback: true,
+        };
+    }
+    if (policy.explicitReserveTokens !== undefined) {
+        const recommendedReserve = Math.min(Math.max(policy.explicitReserveTokens, 1), Math.max(1, W - 1));
+        return {
+            recommendedReserve,
+            triggerTokens: Math.max(0, W - recommendedReserve),
+            fallback: false,
+        };
+    }
+    const rawTrigger = Math.floor(W / policy.k) -
+        policy.trailingBudgetTokens -
+        policy.safetyMarginTokens;
+    const rawReserve = W - rawTrigger;
+    const maxReserve = Math.max(1, W - policy.minimumWorkingSet);
+    if (!Number.isFinite(rawTrigger) ||
+        !Number.isFinite(rawReserve) ||
+        maxReserve < PI_DEFAULT_RESERVE_TOKENS) {
+        const recommendedReserve = Math.min(PI_DEFAULT_RESERVE_TOKENS, Math.max(1, W - 1));
+        return {
+            recommendedReserve,
+            triggerTokens: Math.max(0, W - recommendedReserve),
+            fallback: true,
+        };
+    }
+    const recommendedReserve = Math.min(Math.max(PI_DEFAULT_RESERVE_TOKENS, rawReserve), maxReserve);
+    return {
+        recommendedReserve,
+        triggerTokens: Math.max(0, W - recommendedReserve),
+        fallback: false,
+    };
+}
+export function conservativeTokenEstimate(text, imageCount = 0) {
+    const chars = Array.from(text);
+    let cjk = 0;
+    let other = 0;
+    for (const char of chars) {
+        if (/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/u.test(char)) {
+            cjk += 1;
+        }
+        else {
+            other += 1;
+        }
+    }
+    const utf8 = Buffer.byteLength(text, "utf8");
+    const fromChars = cjk + Math.ceil(other / 2);
+    const fromBytes = Math.ceil(utf8 / 2);
+    return (Math.max(fromChars, fromBytes, Math.ceil(chars.length / 2)) +
+        Math.max(0, imageCount) * 1024);
+}
+export function projectPromptPressure(input) {
+    if (input.currentContextTokens === null ||
+        input.currentContextTokens === undefined ||
+        !Number.isFinite(input.currentContextTokens)) {
+        return { projected: 0, usageUnavailable: true };
+    }
+    return {
+        projected: Math.max(0, input.currentContextTokens) +
+            conservativeTokenEstimate(input.promptText, input.imageCount ?? 0),
+        usageUnavailable: false,
+    };
+}
+function isExplicitlyDisabled(manager) {
+    const project = manager.getProjectSettings?.()?.compaction?.enabled;
+    const global = manager.getGlobalSettings?.()?.compaction?.enabled;
+    return project === false || (project === undefined && global === false);
+}
+export function applyProcessCompactionOverride(manager, input) {
+    if (!manager?.applyOverrides || input.policy.mode === "off") {
+        return { applied: false };
+    }
+    const explicitOff = input.policy.mode === "safe" && isExplicitlyDisabled(manager);
+    const enabled = input.policy.mode === "strict" ? true : explicitOff ? false : true;
+    const window = typeof input.contextWindow === "number" && input.contextWindow > 0
+        ? deriveEffectiveWindow(input.contextWindow, input.policy)
+        : undefined;
+    const compaction = { enabled };
+    if (window && enabled) {
+        compaction.reserveTokens = window.recommendedReserve;
+        compaction.keepRecentTokens = DEFAULT_KEEP_RECENT_TOKENS;
+    }
+    manager.applyOverrides({ compaction });
+    return {
+        applied: true,
+        enabled,
+        ...(typeof compaction.reserveTokens === "number"
+            ? { reserveTokens: compaction.reserveTokens }
+            : {}),
+        ...(typeof compaction.keepRecentTokens === "number"
+            ? { keepRecentTokens: compaction.keepRecentTokens }
+            : {}),
+        ...(window?.fallback
+            ? { diagnostic: "small-or-invalid-window-fell-back-to-pi-default-reserve" }
+            : {}),
+    };
+}
+export function inMemoryCompactionSettings(policy) {
+    if (policy.mode === "off") {
+        return { enabled: true };
+    }
+    return {
+        enabled: true,
+        keepRecentTokens: DEFAULT_KEEP_RECENT_TOKENS,
+        ...(policy.explicitReserveTokens
+            ? { reserveTokens: policy.explicitReserveTokens }
+            : {}),
+    };
+}

package/dist/shared/pi-context-pressure/env.js

@@ -0,0 +1,58 @@
+const TRUTHY = new Set(["1", "true", "on"]);
+const FALSY = new Set(["0", "false", "off"]);
+export function parseEnabledFlag(raw, defaultEnabled) {
+    if (raw === undefined || raw.trim() === "") {
+        return { enabled: defaultEnabled };
+    }
+    const value = raw.trim().toLowerCase();
+    if (TRUTHY.has(value))
+        return { enabled: true };
+    if (FALSY.has(value))
+        return { enabled: false };
+    return {
+        enabled: defaultEnabled,
+        diagnostic: `invalid flag ${JSON.stringify(raw)}; clamped to default ${defaultEnabled}`,
+    };
+}
+export function parseContextPressureMode(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return { mode: "safe" };
+    const value = raw.trim().toLowerCase();
+    if (value === "off" || value === "safe" || value === "strict") {
+        return { mode: value };
+    }
+    return {
+        mode: "safe",
+        diagnostic: `invalid HARNESS_CONTEXT_PRESSURE_MODE ${JSON.stringify(raw)}; clamped to safe`,
+    };
+}
+export function parseBoundedNumber(raw, fallback, min, max) {
+    if (raw === undefined || raw.trim() === "") {
+        return { value: fallback };
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+        return {
+            value: fallback,
+            diagnostic: `invalid number ${JSON.stringify(raw)}; clamped to ${fallback}`,
+        };
+    }
+    const clamped = Math.min(max, Math.max(min, parsed));
+    if (clamped !== parsed) {
+        return {
+            value: clamped,
+            diagnostic: `number ${parsed} clamped to [${min}, ${max}] => ${clamped}`,
+        };
+    }
+    return { value: parsed };
+}
+/** Console/DAG sift: default ON; `0|false|off` disables. */
+export function isConsoleSiftEnabled(env = process.env) {
+    return parseEnabledFlag(env.HARNESS_CONSOLE_SIFT, true);
+}
+export function isDagSiftEnabled(env = process.env) {
+    return parseEnabledFlag(env.HARNESS_DAG_SIFT, true);
+}
+export function readContextPressureMode(env = process.env) {
+    return parseContextPressureMode(env.HARNESS_CONTEXT_PRESSURE_MODE);
+}

package/dist/shared/pi-context-pressure/extension.js

@@ -0,0 +1,100 @@
+import { buildOverflowCheckpoint } from "./checkpoint.js";
+import { shouldRewriteAssistantOverflow } from "./overflow.js";
+import { clearRetrieveBypass, compressProviderPayload, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, } from "./sift-bridge.js";
+import { emptyContextPressureCounters, incrementCounter, } from "./telemetry.js";
+export function createCompactionController() {
+    return {
+        proactiveCompaction: false,
+        counters: emptyContextPressureCounters(),
+    };
+}
+export function createContextPressureExtension(options) {
+    const l2 = options.policy.mode !== "off";
+    const l1 = Boolean(options.sift);
+    if (!l2 && !l1)
+        return undefined;
+    return {
+        name: options.name ?? "operator-chat-context-pressure",
+        hidden: true,
+        factory: (api) => {
+            if (l2) {
+                api.on("message_end", (event) => {
+                    const message = event.message;
+                    if (!message || typeof message !== "object")
+                        return undefined;
+                    const rec = message;
+                    if (typeof rec.errorMessage === "string") {
+                        options.controller.lastError = rec.errorMessage;
+                    }
+                    if (rec.role === "assistant") {
+                        clearRetrieveBypassIfPresent(options.sift);
+                    }
+                    const rewritten = shouldRewriteAssistantOverflow(message);
+                    if (!rewritten)
+                        return undefined;
+                    incrementCounter(options.controller.counters, "overflow");
+                    return {
+                        message: {
+                            ...rec,
+                            errorMessage: rewritten,
+                        },
+                    };
+                });
+                api.on("session_before_compact", (event) => {
+                    const reason = event.reason;
+                    if (reason === "overflow") {
+                        incrementCounter(options.controller.counters, "overflow");
+                    }
+                    if (reason === "manual") {
+                        incrementCounter(options.controller.counters, "manual");
+                    }
+                    const useCheckpoint = options.policy.mode === "strict" &&
+                        (reason === "overflow" ||
+                            (reason === "manual" && options.controller.proactiveCompaction));
+                    if (!useCheckpoint)
+                        return undefined;
+                    const checkpoint = buildOverflowCheckpoint({
+                        preparation: event.preparation,
+                        todos: options.controller.todos,
+                        lastError: options.controller.lastError,
+                    });
+                    if (!checkpoint)
+                        return undefined;
+                    return {
+                        compaction: {
+                            summary: checkpoint.summary,
+                            firstKeptEntryId: checkpoint.firstKeptEntryId,
+                            tokensBefore: checkpoint.tokensBefore,
+                        },
+                    };
+                });
+            }
+            if (l1 && options.sift) {
+                const sift = options.sift;
+                api.on("before_provider_request", (event) => {
+                    return compressProviderPayload(sift, event.payload);
+                });
+                api.on("message_end", (event) => {
+                    const message = event.message;
+                    if (message &&
+                        typeof message === "object" &&
+                        message.role === "assistant") {
+                        clearRetrieveBypass(sift);
+                    }
+                    return undefined;
+                });
+                try {
+                    api.registerTool?.(createSiftRetrieveToolDefinition(sift));
+                }
+                catch {
+                    sift.diagnostics.add("register-tool-failed");
+                }
+            }
+        },
+    };
+}
+function clearRetrieveBypassIfPresent(sift) {
+    if (sift)
+        clearRetrieveBypass(sift);
+}
+export { SIFT_RETRIEVE_TOOL_NAME };

package/dist/shared/pi-context-pressure/index.js

@@ -0,0 +1,7 @@
+export { isContextOverflow, CONTEXT_OVERFLOW_PHRASES, OVERFLOW_FIXTURES, NORMALIZED_OVERFLOW_PREFIX, shouldRewriteAssistantOverflow, normalizeOverflowErrorMessage, buildGeneratedOverflowClassifierSource, } from "./overflow.js";
+export { parseCompactionPolicy, deriveEffectiveWindow, conservativeTokenEstimate, projectPromptPressure, applyProcessCompactionOverride, inMemoryCompactionSettings, PI_DEFAULT_RESERVE_TOKENS, DEFAULT_KEEP_RECENT_TOKENS, } from "./compaction-policy.js";
+export { buildOverflowCheckpoint } from "./checkpoint.js";
+export { createContextPressureExtension, createCompactionController, } from "./extension.js";
+export { createSiftBridgeState, parseSiftBridgeConfig, compressProviderPayload, executeSiftRetrieve, housekeepSiftStash, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, SIFT_POLICY_VERSION, } from "./sift-bridge.js";
+export { isConsoleSiftEnabled, isDagSiftEnabled, readContextPressureMode, parseEnabledFlag, parseContextPressureMode, } from "./env.js";
+export { emptyContextPressureCounters, projectSafeTelemetry, } from "./telemetry.js";

package/dist/shared/pi-context-pressure/overflow.js

@@ -0,0 +1,252 @@
+/**
+ * Unique overflow classifier for Console UI, SDK extensions, and generated
+ * client-recovery plugins. Phrase match wins; type/code never classify alone.
+ */
+export const CONTEXT_OVERFLOW_PHRASES = [
+    "请求上下文过大",
+    "上下文过大",
+    "上下文太大",
+    "上下文过长",
+    "上下文超限",
+    "context_length_exceeded",
+    "context overflow",
+    "context length overflow",
+    "too many tokens",
+    "maximum context",
+    "prompt is too long",
+    "prompt too long",
+    "request_too_large",
+    "reduce the length of the messages",
+    "context window",
+];
+const OVERFLOW_PATTERN = new RegExp(CONTEXT_OVERFLOW_PHRASES.map(escapeRegExpLiteral).join("|"), "i");
+const AUTH_STATUS = new Set([401, 403]);
+export const OVERFLOW_FIXTURES = {
+    positives: {
+        P1: `{"object":"error","message":"请求上下文过大","type":"BadRequestError","code":400}`,
+        P2: `data:{"object":"error","message":"请求上下文过大","type":"BadRequestError","code":400}`,
+        P3: `400 {"object":"error","message":"请求上下文过大","type":"BadRequestError","code":400}`,
+        P4: "请求上下文过大",
+        P5: "请求上下文过大 (BadRequestError 400)",
+        P6: "LLMRequestError: 请求上下文过大 (BadRequestError 400)",
+        P7: "LLM upstream returned an error payload in a 200 stream: 请求上下文过大 (BadRequestError 400)",
+        P8: "LLM upstream returned HTTP 400: 请求上下文过大",
+        P9: `{"object":"error","type":"BadRequestError","code":"200","message":"{\\"object\\":\\"error\\",\\"code\\":400,\\"type\\":\\"BadRequestError\\",\\"param\\":null,\\"message\\":\\"请求上下文过大\\"}"}`,
+        P10: {
+            stopReason: "error",
+            errorMessage: "请求上下文过大 (BadRequestError 400)",
+            errorCode: "stream_payload_error",
+            providerType: "BadRequestError",
+            providerCode: "400",
+        },
+        // P11/P12: 2026-08-27 真实企业网关捕获（openai-completions / wizard-local /
+        // aicoder-plus）。HTTP 状态行 + 换行 + `data:` SSE 前缀 + JSON + 尾部空行
+        // 同串组合；完整事件样本见 exec-plan §1.1 附录 A。
+        P11: "400\n data:{\"object\":\"error\",\"message\":\"请求上下文过大\",\"type\":\"BadRequestError\",\"code\":400}\n\n",
+        P12: {
+            message: {
+                role: "assistant",
+                content: [],
+                api: "openai-completions",
+                provider: "wizard-local",
+                model: "aicoder-plus",
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                stopReason: "error",
+                errorMessage: "400\n data:{\"object\":\"error\",\"message\":\"请求上下文过大\",\"type\":\"BadRequestError\",\"code\":400}\n\n",
+            },
+        },
+    },
+    negatives: {
+        N1: `{"object":"error","message":"认证错误!","type":"BadRequestError","code":401}`,
+        N2: "当前请求超时, 请重试 (BadRequestError 502)",
+        N2b: "LLMRequestError: 当前请求超时, 请重试 (BadRequestError 502)",
+        N3: "The requested resource was not found. (BadRequestError 404)",
+        N3b: "The requested resource was not found. (NotFoundError 404)",
+        N4: "LLMRequestError: (BadRequestError 400)",
+        N5: `{"object":"error","type":"BadRequestError","code":"200","message":"{\\"object\\":\\"error\\",\\"code\\":502,\\"type\\":\\"BadRequestError\\",\\"message\\":\\"当前请求超时, 请重试\\"}"}`,
+    },
+};
+export const NORMALIZED_OVERFLOW_PREFIX = "context_length_exceeded:";
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function asText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value == null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function tryParseJson(text) {
+    const trimmed = text.trim();
+    const candidates = [trimmed];
+    const dataPrefix = trimmed.match(/^data:\s*(\{[\s\S]*)$/i);
+    if (dataPrefix)
+        candidates.push(dataPrefix[1] ?? "");
+    const statusPrefix = trimmed.match(/^\d{3}\s+(\{[\s\S]*)$/);
+    if (statusPrefix)
+        candidates.push(statusPrefix[1] ?? "");
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start)
+        candidates.push(trimmed.slice(start, end + 1));
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // Keep scanning other envelopes.
+        }
+    }
+    return undefined;
+}
+function collectStringFields(value, depth, out) {
+    if (depth > 6 || value == null)
+        return;
+    if (typeof value === "string") {
+        if (value)
+            out.push(value);
+        const nested = tryParseJson(value);
+        if (nested !== undefined && nested !== value) {
+            collectStringFields(nested, depth + 1, out);
+        }
+        return;
+    }
+    if (typeof value !== "object")
+        return;
+    const record = value;
+    for (const key of ["message", "errorMessage", "error"]) {
+        if (key in record)
+            collectStringFields(record[key], depth + 1, out);
+    }
+}
+function extractStatus(text) {
+    const suffix = text.match(/\((?:BadRequestError|NotFoundError|AuthenticationError|RateLimitError)\s+(\d{3})\)/i);
+    if (suffix)
+        return Number(suffix[1]);
+    const http = text.match(/\bHTTP\s+(\d{3})\b/i);
+    if (http)
+        return Number(http[1]);
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+        const record = parsed;
+        const code = record.code ?? record.status ?? record.statusCode;
+        if (typeof code === "number" && Number.isFinite(code))
+            return code;
+        if (typeof code === "string" && /^\d{3}$/.test(code.trim())) {
+            return Number(code.trim());
+        }
+    }
+    return undefined;
+}
+export function collectOverflowHaystack(error) {
+    if (typeof error === "string")
+        return error;
+    if (!error || typeof error !== "object")
+        return asText(error);
+    const record = error;
+    const parts = [
+        asText(record.message),
+        asText(record.errorMessage),
+        asText(record.error),
+        asText(record.name),
+        asText(record.status),
+        asText(record.code),
+        asText(record.data),
+    ];
+    return parts.filter(Boolean).join("\n");
+}
+export function isContextOverflow(error) {
+    const haystack = collectOverflowHaystack(error);
+    const fields = [haystack];
+    collectStringFields(error, 0, fields);
+    collectStringFields(tryParseJson(haystack), 0, fields);
+    const combined = fields.join("\n");
+    if (!OVERFLOW_PATTERN.test(combined))
+        return false;
+    const status = extractStatus(combined);
+    if (status !== undefined && AUTH_STATUS.has(status))
+        return false;
+    return true;
+}
+export function normalizeOverflowErrorMessage(current) {
+    if (!current)
+        return undefined;
+    if (current.startsWith(NORMALIZED_OVERFLOW_PREFIX) ||
+        /context_length_exceeded/i.test(current)) {
+        return undefined;
+    }
+    if (!isContextOverflow(current))
+        return undefined;
+    const bounded = current.length <= 1500 ? current : `${current.slice(0, 1499)}…`;
+    return `${NORMALIZED_OVERFLOW_PREFIX} ${bounded}`;
+}
+export function shouldRewriteAssistantOverflow(message) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    const record = message;
+    if (record.role !== "assistant")
+        return undefined;
+    if (record.stopReason !== undefined && record.stopReason !== "error") {
+        return undefined;
+    }
+    const current = typeof record.errorMessage === "string" ? record.errorMessage : "";
+    if (!current)
+        return undefined;
+    return normalizeOverflowErrorMessage(current);
+}
+export function buildGeneratedOverflowClassifierSource() {
+    return `const CONTEXT_OVERFLOW_PHRASES = ${JSON.stringify([
+        ...CONTEXT_OVERFLOW_PHRASES,
+    ])};
+const OVERFLOW_PATTERN = new RegExp(
+  CONTEXT_OVERFLOW_PHRASES.map((phrase) =>
+    phrase.replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&"),
+  ).join("|"),
+  "i",
+);
+function tryParseJson(text) {
+  if (typeof text !== "string") return undefined;
+  const trimmed = text.trim();
+  const candidates = [trimmed];
+  const dataPrefix = trimmed.match(/^data:\\s*(\\{[\\s\\S]*)$/i);
+  if (dataPrefix) candidates.push(dataPrefix[1]);
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) candidates.push(trimmed.slice(start, end + 1));
+  for (const candidate of candidates) {
+    try { return JSON.parse(candidate); } catch {}
+  }
+  return undefined;
+}
+function collectFields(value, depth, out) {
+  if (depth > 6 || value == null) return;
+  if (typeof value === "string") {
+    if (value) out.push(value);
+    const nested = tryParseJson(value);
+    if (nested !== undefined && nested !== value) collectFields(nested, depth + 1, out);
+    return;
+  }
+  if (typeof value !== "object") return;
+  if (typeof value.message === "string") collectFields(value.message, depth + 1, out);
+  if (typeof value.errorMessage === "string") collectFields(value.errorMessage, depth + 1, out);
+  if (value.error) collectFields(value.error, depth + 1, out);
+}
+function isOverflowMessage(text) {
+  if (typeof text !== "string" || !text) return false;
+  const fields = [text];
+  collectFields(text, 0, fields);
+  collectFields(tryParseJson(text), 0, fields);
+  const combined = fields.join("\\n");
+  if (!OVERFLOW_PATTERN.test(combined)) return false;
+  if (/\\((?:BadRequestError|AuthenticationError)\\s+40[13]\\)/i.test(combined)) return false;
+  return true;
+}`;
+}