Harden task error-forwarder listener method reads

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

currentState.md

@@ -206,6 +206,9 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Hardened frame-graph debug artifact capture in agent loop:
   - `writeFrameGraphSnapshot()` now guards trap-prone frame-manager `setDebug` calls and still proceeds with frame graph serialization.
   - Added regression coverage to ensure debug-setter traps do not downgrade into "Failed to write frame graph" failures.
+- Hardened task error-forwarder listener registration:
+  - `HyperAgent` now resolves `errorEmitter.on`/`off` methods through trap-safe, receiver-bound helpers before invoking task-scoped forwarding hooks.
+  - Added regression coverage proving async task execution still succeeds (with sanitized warnings) when `errorEmitter.on` getter traps.
 - Refreshed remaining staged-flow wording in the CDP deep dive around OOPIF discovery to describe current execution-context sync progression without stale "Need Phase 4" phrasing.
 - Hardened CDP command dispatch in Playwright session adapter:
   - `PlaywrightSessionAdapter.send()` now guards trap-prone `session.send` method reads and wraps sync send failures with sanitized/diagnostic context.

src/agent/__tests__/hyperagent-constructor.test.ts

@@ -1011,6 +1011,72 @@ describe("HyperAgent constructor and task controls", () => {
     }
   });
 
+  it("continues async task execution when errorEmitter.on getter traps", async () => {
+    const mockedRunAgentTask = jest.mocked(runAgentTask);
+    mockedRunAgentTask.mockImplementation(async (_, state) => ({
+      taskId: state.id,
+      status: TaskStatus.COMPLETED,
+      steps: [],
+      output: "done",
+      actionCache: {
+        taskId: state.id,
+        createdAt: new Date().toISOString(),
+        status: TaskStatus.COMPLETED,
+        steps: [],
+      },
+    }));
+
+    const agent = new HyperAgent({
+      llm: createMockLLM(),
+      debug: true,
+    });
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const internalAgent = agent as unknown as {
+      errorEmitter: {
+        listenerCount: (event: string) => number;
+      };
+      taskErrorForwarders: Map<string, (error: Error) => void>;
+    };
+    const baseEmitter = internalAgent.errorEmitter;
+    internalAgent.errorEmitter = new Proxy(baseEmitter as object, {
+      get: (target, property, receiver) => {
+        if (property === "on") {
+          throw new Error(`errorEmitter on trap\u0000\n${"x".repeat(10_000)}`);
+        }
+        const value = Reflect.get(target, property, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      },
+    }) as unknown as typeof internalAgent.errorEmitter;
+
+    const fakePage = {} as unknown as Page;
+    try {
+      const task = await agent.executeTaskAsync(
+        "on getter trap task",
+        undefined,
+        fakePage
+      );
+      await expect(task.result).resolves.toMatchObject({
+        status: TaskStatus.COMPLETED,
+      });
+      expect(internalAgent.taskErrorForwarders.size).toBe(0);
+
+      const warningLine = warnSpy.mock.calls
+        .map((call) => String(call[0] ?? ""))
+        .find((line) =>
+          line.includes("Failed to register task-scoped error listener")
+        );
+      expect(warningLine).toBeDefined();
+      expect(warningLine).toContain("[truncated");
+      expect(warningLine).not.toContain("\u0000");
+      expect(warningLine).not.toContain("\n");
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
   it("surfaces HyperagentTaskError without requiring error listeners", async () => {
     const mockedRunAgentTask = jest.mocked(runAgentTask);
     mockedRunAgentTask.mockRejectedValue(new Error("boom without listeners"));

src/agent/index.ts

@@ -494,6 +494,34 @@ export class HyperAgent<T extends BrowserProviders = "Local"> {
     return createdPage as Page;
   }
 
+  private readErrorEmitterMethodOrThrow(
+    methodName: "on" | "off"
+  ): (this: ErrorEmitter, eventName: string, listener: (error: Error) => void) => void {
+    let method: unknown;
+    try {
+      method = (
+        this.errorEmitter as ErrorEmitter & {
+          on?: unknown;
+          off?: unknown;
+        }
+      )[methodName];
+    } catch (error) {
+      throw new Error(
+        `failed to read errorEmitter.${methodName}: ${this.formatLifecycleDiagnostic(
+          error
+        )}`
+      );
+    }
+    if (typeof method !== "function") {
+      throw new Error(`errorEmitter.${methodName} is unavailable`);
+    }
+    return method as (
+      this: ErrorEmitter,
+      eventName: string,
+      listener: (error: Error) => void
+    ) => void;
+  }
+
   private async startBrowserProvider(): Promise<Browser> {
     const startMethod = this.safeReadField(this.browserProvider, "start");
     if (typeof startMethod !== "function") {
@@ -741,7 +769,8 @@ export class HyperAgent<T extends BrowserProviders = "Local"> {
       return;
     }
     try {
-      this.errorEmitter.off("error", forwarder);
+      const offMethod = this.readErrorEmitterMethodOrThrow("off");
+      offMethod.call(this.errorEmitter, "error", forwarder);
     } catch {
       // no-op
     }
@@ -1768,13 +1797,15 @@ export class HyperAgent<T extends BrowserProviders = "Local"> {
     };
     let listenerAttached = false;
     try {
-      this.errorEmitter.on("error", onTaskError);
+      const onMethod = this.readErrorEmitterMethodOrThrow("on");
+      onMethod.call(this.errorEmitter, "error", onTaskError);
       listenerAttached = true;
       this.taskErrorForwarders.set(taskId, onTaskError);
     } catch (error) {
       if (listenerAttached) {
         try {
-          this.errorEmitter.off("error", onTaskError);
+          const offMethod = this.readErrorEmitterMethodOrThrow("off");
+          offMethod.call(this.errorEmitter, "error", onTaskError);
         } catch {
           // no-op
         }