@alfe.ai/gateway 0.9.14 → 0.9.16

package/dist/health.js

@@ -23484,6 +23484,51 @@ function createLogger(component, additionalData) {
 		component
 	});
 }
+/**
+* Strict profile for the HIGH-VOLUME, LOW-SIGNAL families: MCP
+* `tool-result-error` and the plugin `[ERROR] alfe-tool … result-error:` line.
+* These are the NORMAL model-facing error path — a model omitting a required
+* argument produces one every turn — so a single agent can hold an issue open
+* indefinitely at the default budget.
+*
+* We keep sending them (continued visibility is the point); we just send far
+* fewer. Numbers and why:
+*
+* - `dedupeWindowMs: 6h` — a repeating fingerprint reports at most 4×/day per
+*   agent instead of the default 144×/day. This is the lever that actually
+*   collapses the observed burn, because the noisy issues repeat one message
+*   shape over and over.
+* - `errorCapturesMax: 2` per `errorCapturesWindowMs: 1h` — the family ceiling
+*   drops from 720 events/day/agent (5 per 10 min) to 48. An hourly window,
+*   rather than folding the budget into the 6h dedupe, keeps a NEWLY-failing
+*   tool visible within the hour instead of behind a 6h blackout.
+* - `dedupeMapMaxKeys: 200` — the dedupe map must now retain keys 36× longer,
+*   so 50 slots would evict still-live entries on a wide tool surface and let
+*   them re-fire. 200 covers every tool an agent realistically exposes.
+*
+* These are PER-DAEMON-PROCESS (i.e. per agent VM) budgets; fleet-wide volume
+* scales with agent count and is unbounded from here.
+*
+* Suppression is not silent, but it is COARSE: for the error family,
+* `errorsSuppressed` is one counter per throttle INSTANCE, incremented across
+* every fingerprint and reset on each allowed capture (see
+* {@link CaptureThrottle.allowErrorCapture}). The tag therefore reads "error
+* events this instance suppressed since its last allowed error capture",
+* landing on whichever issue happened to be the one let through — it is NOT
+* that issue's own occurrence count. Use it as a family noise-level signal,
+* not as per-issue volume.
+*
+* The crash family is accounted SEPARATELY via `crashesSuppressed`
+* ({@link CaptureThrottle.allowCrashCapture}). A suppressed error never
+* contributes to the next allowed crash capture, or vice versa, even on a
+* shared instance.
+*/
+const STRICT_ERROR_CAPTURE_PROFILE = Object.freeze({
+	errorCapturesMax: 2,
+	errorCapturesWindowMs: 60 * 6e4,
+	dedupeWindowMs: 360 * 6e4,
+	dedupeMapMaxKeys: 200
+});
 const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
 function stripAnsi(line) {
 	return line.replace(ANSI_RE, "");
@@ -23595,8 +23640,32 @@ var ErrorLineDetector = class {
 	}
 };
 /**
-* Bounds Sentry quota per RuntimeProcess. Worst case per agent:
+* Exact shape emitted by `installToolErrorCapture` in
+* `@alfe.ai/agent-api-client` for a tool that RETURNED an error result:
+*
+*   [ERROR] alfe-tool plugin=<plugin> tool=<name> result-error: <msg>
+*
+* `plugin` / `tool` are `safeToken`-sanitised there (`[A-Za-z0-9_.@/-]`), so
+* they never contain whitespace. Deliberately anchored and `result-error`-only:
+* the sibling `thrown:` kind is a genuine unhandled exception and keeps the
+* default budget, as does any other `[ERROR]` line or runtime stack trace.
+*/
+const ALFE_TOOL_RESULT_ERROR_LINE = /^\[ERROR\] alfe-tool plugin=[A-Za-z0-9_.@/-]+ tool=[A-Za-z0-9_.@/-]+ result-error:/;
+/**
+* True for the plugin tool-`result-error` line above — the runtime-side twin of
+* MCP's `tool-result-error`, i.e. the NORMAL model-facing failure path rather
+* than a runtime fault. Callers route these to a strict
+* {@link STRICT_ERROR_CAPTURE_PROFILE} throttle so genuine crashes and stderr
+* keep the default budget.
+*/
+function isPluginToolResultErrorLine(line) {
+	return ALFE_TOOL_RESULT_ERROR_LINE.test(stripAnsi(line));
+}
+/**
+* Bounds Sentry quota per instance. Worst case at the default limits:
 * ≤ `ERROR_CAPTURES_MAX` output events + ≤ 1 crash event per 10-minute window.
+* Pass {@link CaptureThrottleOptions} (e.g. {@link STRICT_ERROR_CAPTURE_PROFILE})
+* to give a noisier family its own, tighter budget.
 */
 var CaptureThrottle = class {
 	windowStart = 0;
@@ -23606,16 +23675,24 @@ var CaptureThrottle = class {
 	lastCrashCaptureAt = 0;
 	hasCapturedCrash = false;
 	crashesSuppressed = 0;
-	constructor(stableUptimeMs) {
+	errorCapturesMax;
+	errorCapturesWindowMs;
+	dedupeWindowMs;
+	dedupeMapMaxKeys;
+	constructor(stableUptimeMs, options = {}) {
 		this.stableUptimeMs = stableUptimeMs;
+		this.errorCapturesMax = options.errorCapturesMax ?? 5;
+		this.errorCapturesWindowMs = options.errorCapturesWindowMs ?? 6e5;
+		this.dedupeWindowMs = options.dedupeWindowMs ?? 6e5;
+		this.dedupeMapMaxKeys = options.dedupeMapMaxKeys ?? 50;
 	}
 	allowErrorCapture(fingerprintKey, now = Date.now()) {
-		if (now - this.windowStart >= 6e5) {
+		if (now - this.windowStart >= this.errorCapturesWindowMs) {
 			this.windowStart = now;
 			this.windowCount = 0;
 		}
 		const lastSent = this.lastSentByKey.get(fingerprintKey);
-		if (lastSent !== void 0 && now - lastSent < 6e5 || this.windowCount >= 5) {
+		if (lastSent !== void 0 && now - lastSent < this.dedupeWindowMs || this.windowCount >= this.errorCapturesMax) {
 			this.errorsSuppressed++;
 			return {
 				allow: false,
@@ -23624,7 +23701,7 @@ var CaptureThrottle = class {
 		}
 		this.windowCount++;
 		this.lastSentByKey.set(fingerprintKey, now);
-		if (this.lastSentByKey.size > 50) {
+		if (this.lastSentByKey.size > this.dedupeMapMaxKeys) {
 			const oldest = this.lastSentByKey.keys().next().value;
 			if (oldest !== void 0) this.lastSentByKey.delete(oldest);
 		}
@@ -23687,6 +23764,7 @@ var RuntimeProcess = class {
 	ringBuffer = new OutputRingBuffer();
 	detector = new ErrorLineDetector();
 	throttle = new CaptureThrottle(STABLE_UPTIME_MS);
+	toolResultErrorThrottle = new CaptureThrottle(STABLE_UPTIME_MS, STRICT_ERROR_CAPTURE_PROFILE);
 	detectorFlushTimer = null;
 	turnActivityProbe = null;
 	constructor(options) {
@@ -23871,7 +23949,7 @@ var RuntimeProcess = class {
 	/** Report a completed error block to Sentry, throttle permitting. */
 	emitErrorBlock(block) {
 		if (!block) return;
-		const { allow, suppressedCount } = this.throttle.allowErrorCapture(block.fingerprintKey);
+		const { allow, suppressedCount } = (isPluginToolResultErrorLine(block.lines[0]) ? this.toolResultErrorThrottle : this.throttle).allowErrorCapture(block.fingerprintKey);
 		if (!allow) {
 			log$3.debug({
 				runtime: this.options.runtime,
@@ -24597,7 +24675,7 @@ const log = createLogger("McpErrorCapture");
 /** Quiet-period flush for a pending multi-line stderr block. */
 const MCP_STDERR_FLUSH_DEBOUNCE_MS = 1500;
 function createMcpErrorHooks() {
-	const resultErrorThrottle = new CaptureThrottle(6e4);
+	const resultErrorThrottle = new CaptureThrottle(6e4, STRICT_ERROR_CAPTURE_PROFILE);
 	const errorThrottle = new CaptureThrottle(6e4);
 	const crashThrottle = new CaptureThrottle(6e4);
 	const throttleFor = (kind) => kind === "tool-result-error" ? resultErrorThrottle : kind === "server-crash" ? crashThrottle : errorThrottle;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.9.14",
+  "version": "0.9.16",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
     "pino-roll": "^1.2.0",
     "smol-toml": ">=1.6.1",
     "ws": "^8.18.0",
-    "@alfe.ai/agent-api-client": "^0.17.1",
+    "@alfe.ai/agent-api-client": "^0.18.0",
     "@alfe.ai/ai-proxy-local": "^0.0.17",
     "@alfe.ai/config": "^0.4.1",
     "@alfe.ai/integration-manifest": "^0.4.0",