review: Tighten CallbackManager detection + drop changelog entry

Address review feedback on PR #20849:

- `isCallbackManager`: in addition to duck-typing `addHandler`/`copy`,
  walk the prototype chain and require `constructor.name === 'CallbackManager'`
  (mirroring `packages/cloudflare/src/utils/isCloudflareClass.ts`). Filters out
  unrelated objects that coincidentally expose the same shape; the prototype
  walk keeps subclasses working.
- Drop the changelog entry — release process generates the changelog manually.

Two new test cases lock the behavior in: rejects lookalike duck-typed
objects, and recognizes subclasses via the prototype walk (16/16).

Author: mdnanocom

CHANGELOG.md

@@ -2,7 +2,6 @@
 
 ## Unreleased
 
-- fix(node): Preserve `CallbackManager` children when augmenting LangChain callbacks
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
 ## 10.53.1

packages/core/src/tracing/langgraph/utils.ts

@@ -335,7 +335,13 @@ export function setResponseAttributes(span: Span, inputMessages: LangChainMessag
   }
 }
 
-/** Duck-types a LangChain `CallbackManager` — `instanceof` is unreliable when `@langchain/core` is bundled or deduped. */
+/**
+ * Detects a LangChain `CallbackManager` (or subclass) without depending on `instanceof`.
+ * `@langchain/core` is frequently bundled or deduped, so the imported constructor doesn't
+ * necessarily match the one at the user's call site. We walk the prototype chain looking
+ * for the class name, then confirm the shape — the constructor-name check rules out
+ * unrelated objects that happen to expose `addHandler`/`copy`.
+ */
 function isCallbackManager(value: unknown): value is {
   addHandler: (handler: unknown, inherit?: boolean) => void;
   copy: () => unknown;
@@ -345,8 +351,16 @@ function isCallbackManager(value: unknown): value is {
   if (!value || typeof value !== 'object') {
     return false;
   }
-  const candidate = value as { addHandler?: unknown; copy?: unknown };
-  return typeof candidate.addHandler === 'function' && typeof candidate.copy === 'function';
+
+  let proto: object | null = Object.getPrototypeOf(value);
+  while (proto) {
+    if ((proto as { constructor?: { name?: string } }).constructor?.name === 'CallbackManager') {
+      const candidate = value as { addHandler?: unknown; copy?: unknown };
+      return typeof candidate.addHandler === 'function' && typeof candidate.copy === 'function';
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
 }
 
 /**

packages/core/test/lib/utils/langgraph-utils.test.ts

@@ -56,20 +56,24 @@ describe('mergeSentryCallback', () => {
    * test against a degenerate shape that bypasses `addHandler`.
    */
   function makeFakeCallbackManager(existingHandlers: unknown[] = [], existingInheritableHandlers?: unknown[]) {
-    const manager = {
-      handlers: [...existingHandlers],
-      inheritableHandlers: [...(existingInheritableHandlers ?? existingHandlers)],
-      addHandler: vi.fn(function (this: any, handler: unknown, inherit?: boolean) {
+    // Use a class so `Object.getPrototypeOf(instance).constructor.name === 'CallbackManager'`,
+    // which is how the production detector identifies a real LangChain CallbackManager.
+    class CallbackManager {
+      public handlers: unknown[];
+      public inheritableHandlers: unknown[];
+      public addHandler = vi.fn((handler: unknown, inherit?: boolean) => {
         this.handlers.push(handler);
         if (inherit !== false) {
           this.inheritableHandlers.push(handler);
         }
-      }),
-      copy: vi.fn(function (this: any) {
-        return makeFakeCallbackManager(this.handlers, this.inheritableHandlers);
-      }),
-    };
-    return manager;
+      });
+      public copy = vi.fn(() => makeFakeCallbackManager(this.handlers, this.inheritableHandlers));
+      constructor(initialHandlers: unknown[], initialInheritableHandlers: unknown[]) {
+        this.handlers = [...initialHandlers];
+        this.inheritableHandlers = [...initialInheritableHandlers];
+      }
+    }
+    return new CallbackManager(existingHandlers, existingInheritableHandlers ?? existingHandlers);
   }
 
   it('returns a fresh array when no existing callbacks are present', () => {
@@ -159,4 +163,34 @@ describe('mergeSentryCallback', () => {
     const opaque = { name: 'NotAManager' };
     expect(mergeSentryCallback(opaque, sentryHandler)).toBe(opaque);
   });
+
+  it('does not treat a coincidentally duck-typed object as a CallbackManager', () => {
+    // A plain object that happens to expose `addHandler`/`copy` shouldn't be
+    // mistaken for a real LangChain CallbackManager — the constructor-name
+    // check guards against false positives.
+    const lookalike = { addHandler: vi.fn(), copy: vi.fn(), handlers: [] };
+    expect(mergeSentryCallback(lookalike, sentryHandler)).toBe(lookalike);
+    expect(lookalike.addHandler).not.toHaveBeenCalled();
+    expect(lookalike.copy).not.toHaveBeenCalled();
+  });
+
+  it('recognizes subclasses of CallbackManager via the prototype walk', () => {
+    class CallbackManager {
+      public handlers: unknown[] = [];
+      public inheritableHandlers: unknown[] = [];
+      public addHandler = vi.fn((handler: unknown, inherit?: boolean) => {
+        this.handlers.push(handler);
+        if (inherit !== false) {
+          this.inheritableHandlers.push(handler);
+        }
+      });
+      public copy = vi.fn(() => new CallbackManager());
+    }
+    class CustomCallbackManager extends CallbackManager {}
+    const subclass = new CustomCallbackManager();
+    const result = mergeSentryCallback(subclass, sentryHandler) as {
+      addHandler: ReturnType<typeof vi.fn>;
+    };
+    expect(result.addHandler).toHaveBeenCalledWith(sentryHandler, true);
+  });
 });