darwin-langgraph 0.1.0-alpha.1

package/dist/with-darwin-evolution.js

@@ -0,0 +1,256 @@
+/**
+ * Surface 3 — `withDarwinEvolution(graph, opts)`.
+ *
+ * Wraps a compiled `StateGraph` with a fire-and-forget post-run hook
+ * that mirrors Darwin's closed-loop evolution pattern (see
+ * `agents/lib/darwin-hook.ts` for the in-tree Nex implementation):
+ *
+ *   1. After `graph.invoke(...)` resolves, we extract trajectories from
+ *      the final state and dispatch them to `opts.onTrajectory` per
+ *      mapped node.
+ *   2. The same applies to `graph.stream(...)` — we wrap the async
+ *      iterator and replay the final-state chunk to the hook once the
+ *      consumer finishes iterating.
+ *
+ * Design notes (S1185):
+ *   - **Never throws inside the hook.** Caller logic that fails inside
+ *     `onTrajectory` is logged once per process and otherwise swallowed.
+ *     The graph result the consumer sees is identical with or without
+ *     the wrap.
+ *   - **No mutation of `graph` if it doesn't expose `invoke`/`stream`
+ *     as own properties.** We bind via `Object.defineProperty` and fall
+ *     back to a no-op wrap if the graph is frozen. This means future
+ *     LangGraph internals that move `invoke` to a hidden prototype slot
+ *     won't crash — at worst, the hook silently never fires (the test
+ *     suite catches that case).
+ *   - **`nodeMap` shape:** either `string` (treated as
+ *     `{ agentName: string, trajectoryKey: defaultKey }`) or an object
+ *     with explicit `trajectoryKey`. Supports both ergonomic one-liner
+ *     and per-node trajectory routing in the same graph.
+ */
+import { DarwinEvolutionHookError } from "./errors.js";
+/**
+ * Wraps a compiled LangGraph so the supplied `onTrajectory` callback
+ * fires for each node listed in `nodeMap` after every `invoke` / `stream`
+ * run. Returns the same graph instance for chaining.
+ *
+ * @throws {DarwinEvolutionHookError} when `nodeMap` is empty or missing.
+ */
+export function withDarwinEvolution(graph, opts) {
+    if (!opts || !opts.nodeMap || Object.keys(opts.nodeMap).length === 0) {
+        throw new DarwinEvolutionHookError("withDarwinEvolution: opts.nodeMap is required and must contain at least one entry.");
+    }
+    const defaultKey = opts.defaultTrajectoryKey ?? "darwinTrajectory";
+    const callback = opts.onTrajectory;
+    // Normalise nodeMap once. Each entry knows its trajectoryKey so the
+    // hot path doesn't re-resolve defaults per invocation.
+    const resolved = new Map();
+    for (const [nodeName, entry] of Object.entries(opts.nodeMap)) {
+        if (typeof entry === "string") {
+            resolved.set(nodeName, { agentName: entry, trajectoryKey: defaultKey });
+        }
+        else if (entry !== null &&
+            typeof entry === "object" &&
+            typeof entry.agentName === "string" &&
+            typeof entry.trajectoryKey === "string") {
+            resolved.set(nodeName, {
+                agentName: entry.agentName,
+                trajectoryKey: entry.trajectoryKey,
+            });
+        }
+        else {
+            throw new DarwinEvolutionHookError(`withDarwinEvolution: nodeMap entry for "${nodeName}" must be a string or ` +
+                `{ agentName, trajectoryKey }, got ${typeof entry}.`);
+        }
+    }
+    let warned = false;
+    const swallow = (err) => {
+        if (warned || !err)
+            return;
+        warned = true;
+        console.warn(`[darwin-langgraph] onTrajectory callback threw — swallowed. ` +
+            `Subsequent throws will be silent. Original error: ` +
+            `${err?.message ?? String(err)}`);
+    };
+    const fireHook = async (finalState) => {
+        if (!callback)
+            return;
+        if (finalState === null || typeof finalState !== "object")
+            return;
+        const stateObj = finalState;
+        const frozen = Object.freeze({ ...stateObj });
+        for (const [nodeName, { agentName, trajectoryKey }] of resolved) {
+            const trajectory = stateObj[trajectoryKey];
+            if (!trajectory || typeof trajectory !== "object" || trajectory.version !== 1) {
+                continue;
+            }
+            try {
+                await callback({
+                    nodeName,
+                    agentName,
+                    trajectory,
+                    finalState: frozen,
+                });
+            }
+            catch (err) {
+                swallow(err);
+            }
+        }
+    };
+    // Bind originals once. We keep references so consumer re-binds via
+    // a second `withDarwinEvolution` call still work (the second wrap
+    // chains on top of the first wrap's wrapped methods).
+    const originalInvoke = graph.invoke.bind(graph);
+    const originalStream = graph.stream.bind(graph);
+    /**
+     * `graph.invoke` is internally implemented on top of `graph.stream` in
+     * `@langchain/langgraph@1.x`. If we naively wrap both, every `invoke`
+     * call fires the hook TWICE — once from the wrapped stream that invoke
+     * consumed, once from the wrapped invoke itself. We tag each in-flight
+     * `invoke` with a unique `Symbol` stored in a `Set` and the wrapped
+     * `stream` checks `set.size > 0` to know it was called from inside an
+     * invoke (in which case the outer invoke handles the hook).
+     *
+     * R1 Critic Finding 1 fix (S1185): replaced the prior shared-counter
+     * with a `Set<symbol>`. JS is single-threaded, so `Set.add` followed by
+     * `Set.size` in another microtask cannot interleave at the byte level
+     * — concurrent invokes both increment the set BEFORE either stream sees
+     * `size > 0`, so both streams correctly suppress and both invokes
+     * correctly fire the hook exactly once each. The prior `let
+     * invokesInFlight = 0` had a race window where two concurrent invokes
+     * could both read `0` and both fire from invoke AND stream.
+     */
+    const activeInvokeMarkers = new Set();
+    const wrappedInvoke = async (input, config) => {
+        const marker = Symbol("darwin-langgraph:invoke");
+        activeInvokeMarkers.add(marker);
+        try {
+            const result = await originalInvoke(input, config);
+            // Fire-and-forget — don't await the hook from the caller's perspective.
+            void fireHook(result).catch(swallow);
+            return result;
+        }
+        finally {
+            activeInvokeMarkers.delete(marker);
+        }
+    };
+    /**
+     * R1 Critic Finding 2 fix (S1185): warn once if the consumer calls
+     * `stream()` with a `streamMode` other than `"values"`. The hook is
+     * shape-tolerant but for `"updates"` / `"messages"` modes the last
+     * chunk is a node-update dict, NOT the final state — the trajectory
+     * lookup silently misses. Users hit this constantly because
+     * `streamMode: "updates"` is the implicit default.
+     */
+    let streamModeWarned = false;
+    const warnStreamMode = (mode) => {
+        if (streamModeWarned)
+            return;
+        streamModeWarned = true;
+        console.warn(`[darwin-langgraph] withDarwinEvolution: stream() called with streamMode=` +
+            `${typeof mode === "string" ? `"${mode}"` : String(mode)}. ` +
+            `The trajectory hook reliably fires only when streamMode="values" ` +
+            `(default for invoke()). For "updates"/"messages"/multi-mode streams, ` +
+            `the last chunk is not the final state and the hook may silently skip. ` +
+            `Subsequent calls will be silent.`);
+    };
+    const wrappedStream = async (input, config) => {
+        // R2 Critic Finding R2-3: compute `suppressHook` BEFORE awaiting
+        // `originalStream` to make the ordering guarantee explicit.
+        //
+        // Ordering invariant: `wrappedInvoke` calls `activeInvokeMarkers.add()`
+        // SYNCHRONOUSLY before its `await originalInvoke()` yields. Inside
+        // `originalInvoke`, LangGraph calls the UNWRAPPED `graph.stream`
+        // (which our wrapper's `originalStream.bind(graph)` points to), so
+        // this wrapper IS NOT re-entered from invoke's stream call. The only
+        // way control reaches `wrappedStream` is via a direct user call to
+        // `graph.stream()`. The Set check therefore correctly tells us:
+        // "is some OTHER invoke currently in-flight?". If yes, this stream
+        // is parallel work whose hook the invoke side will handle — suppress.
+        // If no, this is a top-level stream call — fire the hook ourselves.
+        const suppressHook = activeInvokeMarkers.size > 0;
+        const iter = await originalStream(input, config);
+        if (suppressHook) {
+            return iter;
+        }
+        // R1 Critic Finding 2: warn if caller asked for a non-"values" stream
+        // mode so the silent-skip case at least surfaces in logs.
+        if (config !== null &&
+            typeof config === "object" &&
+            "streamMode" in config) {
+            const mode = config.streamMode;
+            if (mode !== "values" && !(Array.isArray(mode) && mode.includes("values"))) {
+                warnStreamMode(mode);
+            }
+        }
+        // Wrap the async iterator so we can capture the final chunk for the hook.
+        let lastChunk = undefined;
+        let hookFired = false;
+        const fireOnce = (chunk) => {
+            if (hookFired)
+                return;
+            hookFired = true;
+            void fireHook(chunk).catch(swallow);
+        };
+        const wrapped = {
+            [Symbol.asyncIterator]() {
+                const inner = iter[Symbol.asyncIterator]();
+                return {
+                    async next() {
+                        const res = await inner.next();
+                        if (res.done) {
+                            // Fire hook with the last chunk we saw. For `streamMode: "values"`
+                            // the last chunk IS the final state. For other modes it may be
+                            // a node-update — the hook tolerates both via shape sniffing.
+                            fireOnce(lastChunk);
+                        }
+                        else {
+                            lastChunk = res.value;
+                        }
+                        return res;
+                    },
+                    async return(value) {
+                        // Consumer broke early — still fire the hook with what we have.
+                        fireOnce(lastChunk);
+                        if (typeof inner.return === "function") {
+                            return inner.return(value);
+                        }
+                        return { value: undefined, done: true };
+                    },
+                    async throw(err) {
+                        // No hook on throw — graph state is by definition incomplete.
+                        if (typeof inner.throw === "function") {
+                            return inner.throw(err);
+                        }
+                        throw err;
+                    },
+                };
+            },
+        };
+        return wrapped;
+    };
+    // Try to overwrite as own properties. If the graph is frozen, fall
+    // back to wrapping the prototype-bound methods (best-effort, but
+    // tests will catch any regression).
+    try {
+        Object.defineProperty(graph, "invoke", {
+            value: wrappedInvoke,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+        Object.defineProperty(graph, "stream", {
+            value: wrappedStream,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
+    catch (err) {
+        throw new DarwinEvolutionHookError("withDarwinEvolution: could not wrap graph.invoke / graph.stream " +
+            "(graph instance is frozen or non-configurable). Consider wrapping the " +
+            "graph at compile time instead.", { cause: err });
+    }
+    return graph;
+}
+//# sourceMappingURL=with-darwin-evolution.js.map

package/dist/with-darwin-evolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-darwin-evolution.js","sourceRoot":"","sources":["../src/with-darwin-evolution.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "darwin-langgraph",
+  "version": "0.1.0-alpha.1",
+  "description": "LangGraph.js adapter for darwin-agents — wrap self-evolving Darwin agents as StateGraph nodes with zero hard deps.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "examples:check": "tsc --noEmit --project tsconfig.examples.json",
+    "verify:version-sync": "node -e \"const p=JSON.parse(require('fs').readFileSync('./package.json','utf8'));const s=require('fs').readFileSync('./src/index.ts','utf8');const m=s.match(/VERSION = \\\"([^\\\"]+)\\\"/);if(!m){console.error('VERSION not found in src/index.ts');process.exit(1)}if(m[1]!==p.version){console.error('VERSION mismatch: package.json='+p.version+', src/index.ts='+m[1]);process.exit(1)}console.log('VERSION sync OK: '+m[1])\"",
+    "prepublishOnly": "npm run verify:version-sync && npm run typecheck && npm run test && npm run build"
+  },
+  "keywords": [
+    "langgraph",
+    "langchain",
+    "darwin-agents",
+    "ai-agents",
+    "agent-orchestration",
+    "self-evolving-agents",
+    "stategraph",
+    "multi-agent",
+    "ab-testing",
+    "trajectory-capture",
+    "gepa"
+  ],
+  "author": "StudioMeyer <hello@studiomeyer.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/studiomeyer-io/darwin-langgraph.git"
+  },
+  "bugs": {
+    "url": "https://github.com/studiomeyer-io/darwin-langgraph/issues"
+  },
+  "homepage": "https://github.com/studiomeyer-io/darwin-langgraph#readme",
+  "peerDependencies": {
+    "@langchain/langgraph": "^1.3.0",
+    "darwin-agents": "^0.5.0-alpha.1"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/langgraph": {
+      "optional": false
+    },
+    "darwin-agents": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@langchain/langgraph": "^1.3.2",
+    "@types/node": "^22.10.0",
+    "darwin-agents": "^0.5.0-alpha.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  }
+}