feat(KB-159): complete Step 4 — update frontend for streaming display

packages/engine/src/transient-error-detector.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect } from "vitest";
+import {
+  isTransientError,
+  classifyError,
+  TRANSIENT_ERROR_PATTERNS,
+} from "./transient-error-detector.js";
+import { isUsageLimitError } from "./usage-limit-detector.js";
+
+describe("Transient Error Detector", () => {
+  describe("isTransientError", () => {
+    // Core error messages from the task description
+    it("matches the full upstream connect error message", () => {
+      const message =
+        "upstream connect error or disconnect/reset before headers. retried and the latest reset reason: remote connection failure, transport failure reason: delayed connect error: Connection refused";
+      expect(isTransientError(message)).toBe(true);
+    });
+
+    it("matches 'upstream connect error'", () => {
+      expect(isTransientError("upstream connect error")).toBe(true);
+      expect(isTransientError("Upstream Connect Error")).toBe(true);
+      expect(isTransientError("UPSTREAM CONNECT ERROR")).toBe(true);
+    });
+
+    it("matches 'disconnect/reset before headers'", () => {
+      expect(isTransientError("disconnect/reset before headers")).toBe(true);
+      expect(isTransientError("Disconnect/Reset Before Headers")).toBe(true);
+    });
+
+    it("matches 'retried and the latest reset reason'", () => {
+      expect(isTransientError("retried and the latest reset reason: timeout")).toBe(true);
+      expect(isTransientError("Retried And The Latest Reset Reason")).toBe(true);
+    });
+
+    it("matches 'remote connection failure'", () => {
+      expect(isTransientError("remote connection failure")).toBe(true);
+      expect(isTransientError("Remote Connection Failure")).toBe(true);
+    });
+
+    it("matches 'transport failure reason'", () => {
+      expect(isTransientError("transport failure reason: connection reset")).toBe(true);
+      expect(isTransientError("Transport Failure Reason")).toBe(true);
+    });
+
+    it("matches 'delayed connect error'", () => {
+      expect(isTransientError("delayed connect error: Connection refused")).toBe(true);
+      expect(isTransientError("Delayed Connect Error")).toBe(true);
+    });
+
+    it("matches 'Connection refused'", () => {
+      expect(isTransientError("Connection refused")).toBe(true);
+      expect(isTransientError("connection refused")).toBe(true);
+      expect(isTransientError("CONNECTION REFUSED")).toBe(true);
+    });
+
+    it("matches 'connection reset'", () => {
+      expect(isTransientError("connection reset by peer")).toBe(true);
+      expect(isTransientError("Connection Reset")).toBe(true);
+    });
+
+    it("matches 'ECONNREFUSED'", () => {
+      expect(isTransientError("ECONNREFUSED")).toBe(true);
+      expect(isTransientError("Error: ECONNREFUSED")).toBe(true);
+    });
+
+    it("matches 'ETIMEDOUT'", () => {
+      expect(isTransientError("ETIMEDOUT")).toBe(true);
+      expect(isTransientError("Error: ETIMEDOUT")).toBe(true);
+    });
+
+    it("matches 'socket hang up'", () => {
+      expect(isTransientError("socket hang up")).toBe(true);
+      expect(isTransientError("Socket Hang Up")).toBe(true);
+      expect(isTransientError("Error: socket hang up")).toBe(true);
+    });
+
+    it("matches connection timeout patterns", () => {
+      expect(isTransientError("connection timeout")).toBe(true);
+      expect(isTransientError("timeout connection to server")).toBe(true);
+    });
+
+    // Edge cases
+    it("returns false for empty string", () => {
+      expect(isTransientError("")).toBe(false);
+    });
+
+    it("returns false for null", () => {
+      expect(isTransientError(null as unknown as string)).toBe(false);
+    });
+
+    it("returns false for undefined", () => {
+      expect(isTransientError(undefined as unknown as string)).toBe(false);
+    });
+
+    it("returns false for non-string values", () => {
+      expect(isTransientError(123 as unknown as string)).toBe(false);
+      expect(isTransientError({} as unknown as string)).toBe(false);
+      expect(isTransientError([] as unknown as string)).toBe(false);
+    });
+
+    // Should NOT match non-transient errors
+    it("returns false for code errors", () => {
+      expect(isTransientError("SyntaxError: Unexpected token")).toBe(false);
+      expect(isTransientError("TypeError: Cannot read property")).toBe(false);
+      expect(isTransientError("ReferenceError: foo is not defined")).toBe(false);
+    });
+
+    it("returns false for test failures", () => {
+      expect(isTransientError("Assertion failed: expected 1 to be 2")).toBe(false);
+      expect(isTransientError("Test timeout of 5000ms exceeded")).toBe(false);
+    });
+
+    it("returns false for usage limit errors", () => {
+      expect(isTransientError("rate limit exceeded")).toBe(false);
+      expect(isTransientError("429 Too Many Requests")).toBe(false);
+      expect(isTransientError("API quota exceeded")).toBe(false);
+    });
+
+    // Partial matches should not trigger false positives
+    it("handles partial matches correctly", () => {
+      // Should not match just "error" or "timeout" without connection context
+      expect(isTransientError("An error occurred")).toBe(false);
+      // "timeout" alone is not in the patterns (only connection timeouts)
+      expect(isTransientError("timeout")).toBe(false);
+      expect(isTransientError("Request timeout")).toBe(false);
+    });
+  });
+
+  describe("classifyError", () => {
+    it("classifies usage limit errors as 'usage-limit'", () => {
+      expect(classifyError("rate limit exceeded")).toBe("usage-limit");
+      expect(classifyError("429 Too Many Requests")).toBe("usage-limit");
+      expect(classifyError("API overloaded")).toBe("usage-limit");
+      expect(classifyError("quota exceeded")).toBe("usage-limit");
+      expect(classifyError("billing issue")).toBe("usage-limit");
+    });
+
+    it("classifies transient errors as 'transient'", () => {
+      expect(classifyError("upstream connect error")).toBe("transient");
+      expect(classifyError("ECONNREFUSED")).toBe("transient");
+      expect(classifyError("socket hang up")).toBe("transient");
+      expect(classifyError("Connection refused")).toBe("transient");
+    });
+
+    it("classifies all other errors as 'permanent'", () => {
+      expect(classifyError("SyntaxError: Unexpected token")).toBe("permanent");
+      expect(classifyError("Test failed")).toBe("permanent");
+      expect(classifyError("Build error")).toBe("permanent");
+    });
+
+    // Priority: usage limit > transient > permanent
+    it("prioritizes usage limits over transient errors", () => {
+      // Usage limit patterns should take precedence
+      const usageLimitMsg = "rate limit exceeded while connecting";
+      expect(isUsageLimitError(usageLimitMsg)).toBe(true);
+      expect(classifyError(usageLimitMsg)).toBe("usage-limit");
+    });
+
+    it("handles empty/invalid input as 'permanent'", () => {
+      expect(classifyError("")).toBe("permanent");
+      expect(classifyError(null as unknown as string)).toBe("permanent");
+      expect(classifyError(undefined as unknown as string)).toBe("permanent");
+    });
+
+    it("classifies the full complex error message correctly", () => {
+      const message =
+        "upstream connect error or disconnect/reset before headers. retried and the latest reset reason: remote connection failure, transport failure reason: delayed connect error: Connection refused";
+      expect(classifyError(message)).toBe("transient");
+    });
+  });
+
+  describe("TRANSIENT_ERROR_PATTERNS", () => {
+    it("exports the patterns array", () => {
+      expect(Array.isArray(TRANSIENT_ERROR_PATTERNS)).toBe(true);
+      expect(TRANSIENT_ERROR_PATTERNS.length).toBeGreaterThan(0);
+      // All patterns should be RegExp
+      TRANSIENT_ERROR_PATTERNS.forEach((pattern) => {
+        expect(pattern).toBeInstanceOf(RegExp);
+      });
+    });
+
+    it("all patterns have case-insensitive flag", () => {
+      TRANSIENT_ERROR_PATTERNS.forEach((pattern) => {
+        expect(pattern.flags).toContain("i");
+      });
+    });
+  });
+});