darwin-langgraph 0.1.0-alpha.1 → 0.2.0-alpha.1

package/CHANGELOG.md

@@ -3,6 +3,107 @@
 All notable changes to `darwin-langgraph` are documented here.
 The project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.2.0-alpha.1] — 2026-05-25
+
+### Added — three new surfaces (V0.1 roadmap → LIVE)
+
+- **Surface 4: `DarwinCallbackHandler`** — LangChain-native replacement
+  for `withDarwinEvolution`. Subclass of `BaseCallbackHandler` from
+  `@langchain/core/callbacks/base`. Pass via
+  `graph.invoke(input, { callbacks: [new DarwinCallbackHandler({ nodeMap,
+  onTrajectory }) ] })`. No monkey-patching of `invoke` / `stream`,
+  no `Set<symbol>` race-fix needed, no `streamMode` warn — works
+  identically across `invoke`, `stream` (any `streamMode`), and
+  `streamEvents`. Uses `metadata.langgraph_node` as the primary
+  node-name source (live-verified against `@langchain/langgraph@1.3.x`)
+  with the `runName` parameter as fallback for non-LangGraph chains.
+- **Surface 5: `toOtelAttributes(trajectory, opts?)` +
+  `toolCallToOtelAttributes(call, opts?)`** — pure mappers from Darwin's
+  `ExecutionTrace` to flat `Record<string, string|number|boolean>` keyed
+  by [OpenTelemetry GenAI Semantic Conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/).
+  Spec-compliant cache attribute names
+  (`gen_ai.usage.cache_read.input_tokens` /
+  `gen_ai.usage.cache_creation.input_tokens`). MCP tools correctly map
+  to `gen_ai.tool.type = "extension"` (server-side, calls external APIs)
+  vs `"function"` for builtins. Sensitive `arguments` / `result` fields
+  are opt-in per OTEL spec. NaN/Infinity values dropped from output
+  (OTEL exporter compliance).
+- **Surface 6: `darwinMessagesAnnotation(extra?)`** — variant of
+  `darwinAnnotation` that also includes LangGraph's canonical `messages`
+  channel (`messagesStateReducer`). Use it when your graph mixes Darwin
+  agents with `createReactAgent` / `MessagesAnnotation`-based prebuilt
+  agents. Power-user escape hatch `getMessagesChannelSpec()` exposed
+  for manual `Annotation.Root` composition.
+
+### Changed
+
+- **`withDarwinEvolution` is `@deprecated` since v0.2.0** — JSDoc tag
+  plus a one-shot `console.warn` on first call (process-level, never
+  spam). Will be **removed in v1.0.0**. Migration is two lines (see
+  README "Migration from v0.1.x to v0.2.x").
+- **VERSION constant bumped** to `0.2.0-alpha.1` in both `package.json`
+  and `src/index.ts` (verified by `prepublishOnly` script).
+
+### Fixed (R1 + R2 V0.2 code-review findings, all in-place pre-publish)
+
+The 3-Agent code-review loop ran twice on V0.2. R1 surfaced 10 findings,
+R2 caught 1 HIGH that R1 missed. All addressed before this release.
+
+**R1 — 6 MUST-FIX (S1185):**
+
+1. **CRITICAL (Critic 1):** `firedRuns: Set<string>` in
+   `DarwinCallbackHandler` was an unbounded memory leak for long-lived
+   handlers (e.g. server singletons). Removed — `runIdToName.delete` is
+   the sole dedup and LangGraph guarantees one `handleChainEnd` per
+   `runId`.
+2. **HIGH (Critic 2):** `isExecutionTrace` only checked `version === 1`
+   — a malformed trajectory could pass and crash downstream
+   `toOtelAttributes(trajectory.toolCalls.length)`. Guard now also
+   requires `Array.isArray(toolCalls)` + `Array.isArray(errors)`.
+   `toOtelAttributes` got defensive fallbacks too.
+3. **HIGH (Critic 3 + 7):** `typeof === "number"` passed `NaN` and
+   `Infinity` through to OTEL exporters (silent span drop). All numeric
+   attributes (token usage, durationMs, turn, textBlockCount, turnCount,
+   mcpInvocations) now use `Number.isFinite`.
+4. **HIGH (Research 1):** OTEL spec uses
+   `gen_ai.usage.cache_read.input_tokens` /
+   `cache_creation.input_tokens` per the official attribute registry,
+   not the short `cache_*_tokens` form we initially emitted. Fixed
+   pre-release (zero-cost rename in alpha).
+5. **HIGH (Research 3):** MCP tools execute server-side and call
+   external APIs — `gen_ai.tool.type` must be `"extension"`, not
+   `"function"`. Adapter now routes on the existing `is_mcp` heuristic.
+6. **MED (Critic 5):** `swallow(err)` used `if (warned || !err)` which
+   silently dropped falsy throws (`throw null` etc). Fixed in
+   `DarwinCallbackHandler.swallow`.
+
+**R2 — 1 HIGH (caught what R1 missed, S1185):**
+
+7. **HIGH (R2 Critic R2-1):** R1's fix #6 was applied to
+   `DarwinCallbackHandler.swallow` but NOT to the parallel `swallow`
+   inside `withDarwinEvolution`. Both now consistent.
+
+### Known limitations carried to V0.3
+
+- **`withDarwinEvolution` module-level deprecation flag** is not reset
+  across tests in the same process (R2 Critic R2-2). Acceptable for
+  one-shot warn semantics; testing the contract requires
+  `vi.resetModules()`.
+- **Double-wrapping `withDarwinEvolution` on the same graph instance**
+  is unsupported and produces no clear error (R2 Critic R2-3). Use
+  `DarwinCallbackHandler` instead — composable by default.
+- **Parent-run propagation** on `DarwinTrajectoryEvent` not exposed
+  yet (R1 Research 5). Planned for V0.3 — needs use-case validation.
+
+### Test coverage
+
+- **116/116 vitest tests green** (was 63 in V0.1).
+- New test files: `tests/darwin-callback-handler.test.ts` (14),
+  `tests/to-otel-attributes.test.ts` (18),
+  `tests/darwin-messages-annotation.test.ts` (7),
+  `tests/r2-v02-fixes.test.ts` (10 R1+R2 regression).
+- tsc strict + examples typecheck + version-sync + build all clean.
+
 ## [0.1.0-alpha.1] — 2026-05-24
 
 ### Added
@@ -37,9 +138,12 @@ controls the installed versions and the adapter never pins them.
 
 - Released under the `alpha` npm dist-tag in parallel with
   `darwin-agents@0.5.0-alpha.1` (the first release that ships
-  `ExecutionTrace` capture). Default `npm install darwin-langgraph`
-  refuses to resolve until `0.1.0` final ships — explicit opt-in via
-  `npm install darwin-langgraph@alpha`.
+  `ExecutionTrace` capture). Because `0.1.0-alpha.1` is the very
+  first publish of this package, npm assigns BOTH `alpha` and
+  `latest` to it (npm rule: `latest` always exists), so
+  `npm install darwin-langgraph` resolves to the alpha version
+  until `0.1.0` final ships. Prefer the explicit
+  `npm install darwin-langgraph@alpha` form for clarity.
 - The adapter never touches `ANTHROPIC_API_KEY`. If you run Darwin on a
   Claude Max subscription via the Claude Code CLI, set `delete
   process.env.ANTHROPIC_API_KEY` in your own bootstrap.

package/README.md

@@ -202,26 +202,59 @@ The [`examples/`](./examples/) directory ships three runnable scripts:
 
 | `darwin-langgraph` | `darwin-agents` | `@langchain/langgraph` | Status |
 |---|---|---|---|
-| `0.1.0-alpha.x` | `^0.5.0-alpha.1` | `^1.3.0` | alpha (this release) |
+| `0.2.0-alpha.x` | `^0.5.0-alpha.1` | `^1.3.0` | alpha (this release) |
+| `0.1.0-alpha.x` | `^0.5.0-alpha.1` | `^1.3.0` | superseded |
 
 The peer-dep range `darwin-agents: "^0.5.0-alpha.1"` follows npm's
 prerelease semver rules — `0.5.0-alpha.N` and `0.5.0` final satisfy it,
 but `0.5.1-alpha.0` does NOT. A patch release of this adapter will be
 required when `darwin-agents` bumps past `0.5.x`.
 
-## Known limitations (will be addressed in v0.2)
+## V0.2 — new surfaces (LIVE this release)
+
+V0.2 ships the three items from the V0.1 V0.2-roadmap, plus runtime
+deprecation warnings on the legacy wrapper:
+
+- **`DarwinCallbackHandler`** — LangChain-native replacement for
+  `withDarwinEvolution`. Pass it via `graph.invoke(input, { callbacks:
+  [new DarwinCallbackHandler({ nodeMap, onTrajectory }) ] })`. No more
+  monkey-patching `invoke`/`stream`, no more `Set<symbol>` race-fix,
+  no more `streamMode` gymnastics. Works identically with `invoke`,
+  `stream` (any `streamMode`), and `streamEvents` because LangChain's
+  callback mechanism fires regardless of how the consumer iterates.
+- **`toOtelAttributes(trajectory, opts?)` + `toolCallToOtelAttributes(call, opts?)`** —
+  pure mappers from Darwin's `ExecutionTrace` to flat
+  `Record<string, string|number|boolean>` keyed by
+  [OpenTelemetry GenAI Semantic Conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/)
+  (`gen_ai.operation.name`, `gen_ai.usage.input_tokens`, etc.) plus
+  Darwin-namespaced custom attrs. Drop straight into Langfuse,
+  Braintrust, Honeycomb, Datadog. Sensitive `arguments` / `result`
+  fields are opt-in per OTEL spec.
+- **`darwinMessagesAnnotation(extra?)`** — variant of `darwinAnnotation`
+  that also includes LangGraph's canonical `messages` channel
+  (`messagesStateReducer`). Use it when your graph mixes Darwin agents
+  with `createReactAgent` / `MessagesAnnotation`-based prebuilt agents.
+- **Runtime deprecation warning on `withDarwinEvolution`** — fires once
+  per process on first call. The function still works identically for
+  back-compat; it will be removed in v1.0. Migrate to
+  `DarwinCallbackHandler`.
+
+## Migration from v0.1.x to v0.2.x
+
+Two lines:
+
+```diff
+- import { withDarwinEvolution } from "darwin-langgraph";
++ import { DarwinCallbackHandler } from "darwin-langgraph";
+- const graph = withDarwinEvolution(compiledGraph, { nodeMap, onTrajectory });
+- const result = await graph.invoke(input);
++ const handler = new DarwinCallbackHandler({ nodeMap, onTrajectory });
++ const result = await compiledGraph.invoke(input, { callbacks: [handler] });
+```
 
-- **`withDarwinEvolution` monkey-patches `invoke`/`stream`** — V0.2
-  will migrate to a `DarwinCallbackHandler` you pass via
-  `graph.invoke(input, { callbacks: [...] })`, which is the canonical
-  LangChain pattern (matches Langfuse, Braintrust, LangSmith handlers).
-- **No `gen_ai.*` OTEL attribute helper** — V0.2 will ship
-  `toOtelAttributes(trajectory)` so traces forward to Langfuse /
-  Braintrust / Datadog with OpenTelemetry GenAI Semantic Conventions.
-- **No bundled `messages` channel** — V0.2 will add
-  `darwinMessagesAnnotation()` for graphs that mix `createReactAgent`
-  with `createDarwinNode`. Until then, you can pass
-  `darwinAnnotation({ ...MessagesAnnotation.spec })` manually.
+`DarwinEvolutionOptions`, `DarwinNodeMapEntry`, and the
+`DarwinTrajectoryEvent` shape passed to `onTrajectory` are 100% identical
+between both APIs — no other code changes required.
 
 The adapter releases follow `darwin-agents` major bumps. When
 `@langchain/langgraph` 2.x lands, the adapter ships a new major within
@@ -267,9 +300,20 @@ delete process.env.ANTHROPIC_API_KEY; // enforce Max-Plan subscription
 ## Versioning
 
 Released under the `alpha` npm dist-tag in parallel with
-`darwin-agents@0.5.0-alpha.1`. Default `npm install darwin-langgraph`
-will NOT resolve until `0.1.0` final ships. Explicit opt-in via
-`npm install darwin-langgraph@alpha`.
+`darwin-agents@0.5.0-alpha.1`. Because `0.1.0-alpha.1` is the FIRST
+publish, npm assigns BOTH `alpha` and `latest` to it (npm rule: a
+package must always have a `latest` tag) — so `npm install
+darwin-langgraph` and `npm install darwin-langgraph@alpha` resolve to
+the same version right now. Once `0.1.0` final ships, `latest` will
+point to the stable release and `alpha` will continue to track
+pre-releases.
+
+For maximum clarity in alpha-stage projects, prefer the explicit
+opt-in form:
+
+```bash
+npm install darwin-langgraph@alpha @langchain/langgraph darwin-agents@alpha
+```
 
 ## License
 

package/dist/darwin-callback-handler.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Surface 4 (V0.2) — `DarwinCallbackHandler`.
+ *
+ * Drop-in replacement for {@link withDarwinEvolution} that uses
+ * LangChain's canonical `BaseCallbackHandler` mechanism instead of
+ * monkey-patching `graph.invoke` / `graph.stream`. The same trajectory
+ * hook fires, the same `nodeMap` routing applies, but the integration
+ * is now LangGraph-native — no method overwrites, no concurrent-invoke
+ * Set<symbol> dance, no streamMode gymnastics.
+ *
+ * Usage:
+ * ```ts
+ * import { DarwinCallbackHandler } from "darwin-langgraph";
+ *
+ * const handler = new DarwinCallbackHandler({
+ *   nodeMap: { research: "researcher" },
+ *   onTrajectory: (event) => {
+ *     console.log(event.nodeName, event.trajectory.toolCalls.length);
+ *   },
+ * });
+ *
+ * const result = await graph.invoke(
+ *   { task: "What is GEPA?" },
+ *   { callbacks: [handler] },
+ * );
+ * ```
+ *
+ * Design notes (S1185 V0.2):
+ *   - **runId → runName mapping.** LangChain invokes `handleChainStart`
+ *     with the `runName` arg (the node name in LangGraph's case) and
+ *     a unique `runId`. We cache that mapping. On `handleChainEnd` we
+ *     look up the name, find the matching `nodeMap` entry, and dispatch
+ *     `onTrajectory`.
+ *   - **Fire-and-forget.** Like the v0.1 monkey-patch wrapper, hook
+ *     errors are swallowed with one warn-once per handler instance.
+ *   - **No mutation of LangGraph internals.** This handler never touches
+ *     `graph.invoke` or `graph.stream` — registering it via the standard
+ *     `{ callbacks: [...] }` option is the only side effect, which is
+ *     LangChain's documented integration point (matches Langfuse,
+ *     Braintrust, LangSmith handler patterns).
+ *   - **Stream-mode-agnostic.** Works identically with `invoke`,
+ *     `stream` (any streamMode), and `streamEvents` because the chain
+ *     callbacks fire regardless of how the consumer iterates.
+ *   - **Concurrent runs work natively.** LangChain's runId is unique
+ *     per call — no shared-counter race condition is possible.
+ *   - **Backwards compat.** `withDarwinEvolution` from v0.1 still works
+ *     (marked `@deprecated`) and produces the same `DarwinTrajectoryEvent`
+ *     payload shape. Migration is one line: replace
+ *     `withDarwinEvolution(graph, opts)` with
+ *     `graph.invoke(input, { callbacks: [new DarwinCallbackHandler(opts)] })`.
+ */
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import type { ChainValues } from "@langchain/core/utils/types";
+import type { DarwinEvolutionOptions } from "./with-darwin-evolution.js";
+/**
+ * LangChain `BaseCallbackHandler` that listens for LangGraph node-chain
+ * events and dispatches Darwin trajectory hooks. Pass it via the
+ * standard `{ callbacks: [...] }` option to any `invoke`/`stream`/`streamEvents`
+ * call on a compiled `StateGraph`.
+ */
+export declare class DarwinCallbackHandler extends BaseCallbackHandler {
+    readonly name = "DarwinCallbackHandler";
+    readonly awaitHandlers = false;
+    private readonly resolved;
+    private readonly onTrajectory;
+    private readonly runIdToName;
+    private warned;
+    constructor(opts: DarwinEvolutionOptions);
+    /**
+     * Capture the run-id → node-name mapping.
+     *
+     * Implementation note (S1185 V0.2 — live-debug against @langchain/langgraph@1.3.x):
+     * `metadata.langgraph_node` is the stable, reliable source for the
+     * StateGraph node name. LangGraph populates it on every node-chain
+     * invocation. The `runName` parameter slot in `@langchain/core`'s
+     * `BaseCallbackHandler` d.ts is undefined for LangGraph chains at
+     * runtime — we keep it as a fallback for non-LangGraph chains.
+     */
+    handleChainStart(_chain: unknown, _inputs: ChainValues, runId: string, _runType?: string, _tags?: string[], metadata?: Record<string, unknown>, runName?: string, _parentRunId?: string, _extra?: Record<string, unknown>): void;
+    /**
+     * When a node-chain finishes, look up its name, locate the matching
+     * trajectory in `outputs`, and dispatch onTrajectory.
+     *
+     * `outputs` carries the state update the node returned — which may be
+     * a partial state (just the new keys). When the node was wrapped via
+     * {@link createDarwinNode}, the trajectoryKey lives directly on that
+     * partial state under its configured name.
+     */
+    handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], _kwargs?: {
+        inputs?: ChainValues;
+    }): void;
+    /**
+     * Forget the in-flight runId when a chain errors out. We don't fire
+     * the hook on error — the trajectory is by definition incomplete.
+     */
+    handleChainError(_err: Error, runId: string, _parentRunId?: string): void;
+    private swallow;
+    /**
+     * Helper for tests + debug introspection — returns how many in-flight
+     * chain runs we are currently tracking. Should be 0 between
+     * top-level invocations.
+     */
+    getInFlightCount(): number;
+}
+//# sourceMappingURL=darwin-callback-handler.d.ts.map

package/dist/darwin-callback-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"darwin-callback-handler.d.ts","sourceRoot":"","sources":["../src/darwin-callback-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI/D,OAAO,KAAK,EACV,sBAAsB,EAGvB,MAAM,4BAA4B,CAAC;AAqDpC;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,mBAAmB;IAC5D,SAAyB,IAAI,2BAA2B;IACxD,SAAyB,aAAa,SAAS;IAE/C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyC;IACtE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;IAC9D,OAAO,CAAC,MAAM,CAAS;gBAEX,IAAI,EAAE,sBAAsB;IAYxC;;;;;;;;;OASG;IACM,gBAAgB,CACvB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,OAAO,CAAC,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,IAAI;IAoBP;;;;;;;;OAQG;IACM,cAAc,CACrB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,EACrB,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,IAAI;IAmCP;;;OAGG;IACM,gBAAgB,CACvB,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI;IAIP,OAAO,CAAC,OAAO;IAaf;;;;OAIG;IACI,gBAAgB,IAAI,MAAM;CAGlC"}

package/dist/darwin-callback-handler.js

@@ -0,0 +1,211 @@
+/**
+ * Surface 4 (V0.2) — `DarwinCallbackHandler`.
+ *
+ * Drop-in replacement for {@link withDarwinEvolution} that uses
+ * LangChain's canonical `BaseCallbackHandler` mechanism instead of
+ * monkey-patching `graph.invoke` / `graph.stream`. The same trajectory
+ * hook fires, the same `nodeMap` routing applies, but the integration
+ * is now LangGraph-native — no method overwrites, no concurrent-invoke
+ * Set<symbol> dance, no streamMode gymnastics.
+ *
+ * Usage:
+ * ```ts
+ * import { DarwinCallbackHandler } from "darwin-langgraph";
+ *
+ * const handler = new DarwinCallbackHandler({
+ *   nodeMap: { research: "researcher" },
+ *   onTrajectory: (event) => {
+ *     console.log(event.nodeName, event.trajectory.toolCalls.length);
+ *   },
+ * });
+ *
+ * const result = await graph.invoke(
+ *   { task: "What is GEPA?" },
+ *   { callbacks: [handler] },
+ * );
+ * ```
+ *
+ * Design notes (S1185 V0.2):
+ *   - **runId → runName mapping.** LangChain invokes `handleChainStart`
+ *     with the `runName` arg (the node name in LangGraph's case) and
+ *     a unique `runId`. We cache that mapping. On `handleChainEnd` we
+ *     look up the name, find the matching `nodeMap` entry, and dispatch
+ *     `onTrajectory`.
+ *   - **Fire-and-forget.** Like the v0.1 monkey-patch wrapper, hook
+ *     errors are swallowed with one warn-once per handler instance.
+ *   - **No mutation of LangGraph internals.** This handler never touches
+ *     `graph.invoke` or `graph.stream` — registering it via the standard
+ *     `{ callbacks: [...] }` option is the only side effect, which is
+ *     LangChain's documented integration point (matches Langfuse,
+ *     Braintrust, LangSmith handler patterns).
+ *   - **Stream-mode-agnostic.** Works identically with `invoke`,
+ *     `stream` (any streamMode), and `streamEvents` because the chain
+ *     callbacks fire regardless of how the consumer iterates.
+ *   - **Concurrent runs work natively.** LangChain's runId is unique
+ *     per call — no shared-counter race condition is possible.
+ *   - **Backwards compat.** `withDarwinEvolution` from v0.1 still works
+ *     (marked `@deprecated`) and produces the same `DarwinTrajectoryEvent`
+ *     payload shape. Migration is one line: replace
+ *     `withDarwinEvolution(graph, opts)` with
+ *     `graph.invoke(input, { callbacks: [new DarwinCallbackHandler(opts)] })`.
+ */
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { DarwinEvolutionHookError } from "./errors.js";
+function isExecutionTrace(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    // R1 V0.2 Critic Finding 2 (S1185): require shape-tightness, not just
+    // version. Downstream consumers (e.g. toOtelAttributes) read
+    // `toolCalls.length` directly — a malformed trace with missing arrays
+    // would crash there. Guard explicitly.
+    return (v.version === 1 &&
+        Array.isArray(v.toolCalls) &&
+        Array.isArray(v.errors));
+}
+function normaliseNodeMap(nodeMap, defaultKey) {
+    const resolved = new Map();
+    for (const [nodeName, entry] of Object.entries(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(`DarwinCallbackHandler: nodeMap entry for "${nodeName}" must be a string or ` +
+                `{ agentName, trajectoryKey }, got ${typeof entry}.`);
+        }
+    }
+    return resolved;
+}
+/**
+ * LangChain `BaseCallbackHandler` that listens for LangGraph node-chain
+ * events and dispatches Darwin trajectory hooks. Pass it via the
+ * standard `{ callbacks: [...] }` option to any `invoke`/`stream`/`streamEvents`
+ * call on a compiled `StateGraph`.
+ */
+export class DarwinCallbackHandler extends BaseCallbackHandler {
+    name = "DarwinCallbackHandler";
+    awaitHandlers = false;
+    resolved;
+    onTrajectory;
+    runIdToName = new Map();
+    warned = false;
+    constructor(opts) {
+        super();
+        if (!opts || !opts.nodeMap || Object.keys(opts.nodeMap).length === 0) {
+            throw new DarwinEvolutionHookError("DarwinCallbackHandler: opts.nodeMap is required and must contain at least one entry.");
+        }
+        const defaultKey = opts.defaultTrajectoryKey ?? "darwinTrajectory";
+        this.resolved = normaliseNodeMap(opts.nodeMap, defaultKey);
+        this.onTrajectory = opts.onTrajectory;
+    }
+    /**
+     * Capture the run-id → node-name mapping.
+     *
+     * Implementation note (S1185 V0.2 — live-debug against @langchain/langgraph@1.3.x):
+     * `metadata.langgraph_node` is the stable, reliable source for the
+     * StateGraph node name. LangGraph populates it on every node-chain
+     * invocation. The `runName` parameter slot in `@langchain/core`'s
+     * `BaseCallbackHandler` d.ts is undefined for LangGraph chains at
+     * runtime — we keep it as a fallback for non-LangGraph chains.
+     */
+    handleChainStart(_chain, _inputs, runId, _runType, _tags, metadata, runName, _parentRunId, _extra) {
+        // Primary source: metadata.langgraph_node (set by LangGraph internals).
+        let nodeName;
+        if (metadata && typeof metadata === "object") {
+            const m = metadata;
+            if (typeof m["langgraph_node"] === "string") {
+                nodeName = m["langgraph_node"];
+            }
+        }
+        // Fallback: runName parameter (for non-LangGraph integrations).
+        if (!nodeName && typeof runName === "string" && runName.length > 0) {
+            nodeName = runName;
+        }
+        if (!nodeName)
+            return;
+        // Only track names that map to a known node. Reduces memory and
+        // makes lookup in handleChainEnd a simple `.has()` check.
+        if (!this.resolved.has(nodeName))
+            return;
+        this.runIdToName.set(runId, nodeName);
+    }
+    /**
+     * When a node-chain finishes, look up its name, locate the matching
+     * trajectory in `outputs`, and dispatch onTrajectory.
+     *
+     * `outputs` carries the state update the node returned — which may be
+     * a partial state (just the new keys). When the node was wrapped via
+     * {@link createDarwinNode}, the trajectoryKey lives directly on that
+     * partial state under its configured name.
+     */
+    handleChainEnd(outputs, runId, _parentRunId, _tags, _kwargs) {
+        const runName = this.runIdToName.get(runId);
+        if (!runName)
+            return;
+        // One-shot cleanup of the mapping so completed runs don't leak.
+        // R1 V0.2 Critic Finding 1 (S1185): the `runIdToName.delete` here
+        // is the ONLY dedup we need — LangGraph guarantees `handleChainEnd`
+        // fires exactly once per `runId`, and after deletion any second
+        // call returns early at `if (!runName)`. The pre-V0.2 `firedRuns`
+        // Set was redundant AND leaked unbounded — removed.
+        this.runIdToName.delete(runId);
+        if (!this.onTrajectory)
+            return;
+        const entry = this.resolved.get(runName);
+        if (!entry)
+            return;
+        if (outputs === null || typeof outputs !== "object")
+            return;
+        const trajectory = outputs[entry.trajectoryKey];
+        if (!isExecutionTrace(trajectory))
+            return;
+        const frozen = Object.freeze({ ...outputs });
+        const event = {
+            nodeName: runName,
+            agentName: entry.agentName,
+            trajectory,
+            finalState: frozen,
+        };
+        // Fire-and-forget. The handler base class supports async returns
+        // but we don't want to block the chain end on slow user callbacks.
+        void Promise.resolve()
+            .then(() => this.onTrajectory(event))
+            .catch((err) => this.swallow(err));
+    }
+    /**
+     * Forget the in-flight runId when a chain errors out. We don't fire
+     * the hook on error — the trajectory is by definition incomplete.
+     */
+    handleChainError(_err, runId, _parentRunId) {
+        this.runIdToName.delete(runId);
+    }
+    swallow(err) {
+        // R1 V0.2 Critic Finding 5 (S1185): do NOT short-circuit on falsy
+        // `err` — `throw 0` / `throw ""` / `throw null` from user callbacks
+        // should still surface in logs (silent-failure is worse than noisy).
+        if (this.warned)
+            return;
+        this.warned = true;
+        console.warn(`[darwin-langgraph] DarwinCallbackHandler.onTrajectory threw — swallowed. ` +
+            `Subsequent throws will be silent. Original error: ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    /**
+     * Helper for tests + debug introspection — returns how many in-flight
+     * chain runs we are currently tracking. Should be 0 between
+     * top-level invocations.
+     */
+    getInFlightCount() {
+        return this.runIdToName.size;
+    }
+}
+//# sourceMappingURL=darwin-callback-handler.js.map

package/dist/darwin-callback-handler.js.map

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

package/dist/darwin-messages-annotation.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Surface 6 (V0.2) — `darwinMessagesAnnotation(extra?)`.
+ *
+ * Variant of {@link darwinAnnotation} that also includes LangGraph's
+ * canonical `messages` channel (using `messagesStateReducer` from
+ * `@langchain/langgraph`). Use this when your graph mixes Darwin agents
+ * with `createReactAgent` / `MessagesAnnotation`-based prebuilt agents
+ * — they all read and write the same `messages` channel without
+ * channel-name conflicts.
+ *
+ * Layered channels:
+ *   - `task` (string, last-write-wins) — Darwin agent task input
+ *   - `output` (string, last-write-wins) — Darwin agent text output
+ *   - `darwinTrajectory` (ExecutionTrace | undefined) — captured trace
+ *   - `messages` (BaseMessage[], `messagesStateReducer`) — chat history
+ *
+ * Composable: any `extra` channels merge in.
+ *
+ * @example
+ * ```ts
+ * import { darwinMessagesAnnotation, createDarwinNode } from "darwin-langgraph";
+ * import { StateGraph } from "@langchain/langgraph";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ * import { ChatAnthropic } from "@langchain/anthropic";
+ *
+ * const State = darwinMessagesAnnotation();
+ *
+ * const planner = createReactAgent({
+ *   llm: new ChatAnthropic({ model: "claude-haiku-4-5" }),
+ *   tools: [],
+ * });
+ *
+ * const graph = new StateGraph(State)
+ *   .addNode("plan", planner)                        // writes to messages
+ *   .addNode("execute", createDarwinNode(myAgent))   // writes to output
+ *   .addEdge("__start__", "plan")
+ *   .addEdge("plan", "execute")
+ *   .compile();
+ * ```
+ *
+ * Design notes:
+ *   - **Same inference quirk as `darwinAnnotation`.** Return type is
+ *     inferred from `Annotation.Root`; the internal `LastValue` vs
+ *     `BaseChannel` union is opaque to it. Hand-typing triggers TS2741.
+ *   - **`messages` default is `[]`** — graphs that don't seed messages
+ *     in `invoke({ task: "..." })` still work.
+ */
+import type { BaseMessage } from "@langchain/core/messages";
+/**
+ * Spec for the `messages` channel — re-exported for power-users who want
+ * to spread it into their own `Annotation.Root` call manually.
+ *
+ * Return type inferred (same `LastValue<T>` vs `BaseChannel<T>` quirk
+ * documented on `getDarwinChannelSpec` — hand-typing triggers TS2741).
+ */
+export declare function getMessagesChannelSpec(): {
+    messages: import("@langchain/langgraph").BaseChannel<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[] | import("@langchain/langgraph").OverwriteValue<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[]>, unknown>;
+};
+/**
+ * Build an `Annotation.Root` with the three Darwin channels PLUS the
+ * canonical `messages` channel for interop with `createReactAgent` /
+ * `MessagesAnnotation`-based prebuilt agents.
+ */
+export declare function darwinMessagesAnnotation<Extra extends Record<string, any> = {}>(extra?: Extra): import("@langchain/langgraph").AnnotationRoot<{
+    messages: import("@langchain/langgraph").BaseChannel<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[] | import("@langchain/langgraph").OverwriteValue<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[]>, unknown>;
+    task: import("@langchain/langgraph").LastValue<string>;
+    output: import("@langchain/langgraph").LastValue<string>;
+    darwinTrajectory: import("@langchain/langgraph").BaseChannel<import("darwin-agents").ExecutionTrace | undefined, import("darwin-agents").ExecutionTrace | import("@langchain/langgraph").OverwriteValue<import("darwin-agents").ExecutionTrace | undefined> | undefined, unknown>;
+} & Extra>;
+//# sourceMappingURL=darwin-messages-annotation.d.ts.map

package/dist/darwin-messages-annotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"darwin-messages-annotation.d.ts","sourceRoot":"","sources":["../src/darwin-messages-annotation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAI5D;;;;;;GAMG;AACH,wBAAgB,sBAAsB;;EAOrC;AAED;;;;GAIG;AAEH,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,EAC7E,KAAK,CAAC,EAAE,KAAK;;;;;WAOd"}

package/dist/darwin-messages-annotation.js

@@ -0,0 +1,78 @@
+/**
+ * Surface 6 (V0.2) — `darwinMessagesAnnotation(extra?)`.
+ *
+ * Variant of {@link darwinAnnotation} that also includes LangGraph's
+ * canonical `messages` channel (using `messagesStateReducer` from
+ * `@langchain/langgraph`). Use this when your graph mixes Darwin agents
+ * with `createReactAgent` / `MessagesAnnotation`-based prebuilt agents
+ * — they all read and write the same `messages` channel without
+ * channel-name conflicts.
+ *
+ * Layered channels:
+ *   - `task` (string, last-write-wins) — Darwin agent task input
+ *   - `output` (string, last-write-wins) — Darwin agent text output
+ *   - `darwinTrajectory` (ExecutionTrace | undefined) — captured trace
+ *   - `messages` (BaseMessage[], `messagesStateReducer`) — chat history
+ *
+ * Composable: any `extra` channels merge in.
+ *
+ * @example
+ * ```ts
+ * import { darwinMessagesAnnotation, createDarwinNode } from "darwin-langgraph";
+ * import { StateGraph } from "@langchain/langgraph";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ * import { ChatAnthropic } from "@langchain/anthropic";
+ *
+ * const State = darwinMessagesAnnotation();
+ *
+ * const planner = createReactAgent({
+ *   llm: new ChatAnthropic({ model: "claude-haiku-4-5" }),
+ *   tools: [],
+ * });
+ *
+ * const graph = new StateGraph(State)
+ *   .addNode("plan", planner)                        // writes to messages
+ *   .addNode("execute", createDarwinNode(myAgent))   // writes to output
+ *   .addEdge("__start__", "plan")
+ *   .addEdge("plan", "execute")
+ *   .compile();
+ * ```
+ *
+ * Design notes:
+ *   - **Same inference quirk as `darwinAnnotation`.** Return type is
+ *     inferred from `Annotation.Root`; the internal `LastValue` vs
+ *     `BaseChannel` union is opaque to it. Hand-typing triggers TS2741.
+ *   - **`messages` default is `[]`** — graphs that don't seed messages
+ *     in `invoke({ task: "..." })` still work.
+ */
+import { Annotation, messagesStateReducer, } from "@langchain/langgraph";
+import { getDarwinChannelSpec } from "./darwin-annotation.js";
+/**
+ * Spec for the `messages` channel — re-exported for power-users who want
+ * to spread it into their own `Annotation.Root` call manually.
+ *
+ * Return type inferred (same `LastValue<T>` vs `BaseChannel<T>` quirk
+ * documented on `getDarwinChannelSpec` — hand-typing triggers TS2741).
+ */
+export function getMessagesChannelSpec() {
+    return {
+        messages: Annotation({
+            reducer: messagesStateReducer,
+            default: () => [],
+        }),
+    };
+}
+/**
+ * Build an `Annotation.Root` with the three Darwin channels PLUS the
+ * canonical `messages` channel for interop with `createReactAgent` /
+ * `MessagesAnnotation`-based prebuilt agents.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function darwinMessagesAnnotation(extra) {
+    return Annotation.Root({
+        ...getDarwinChannelSpec(),
+        ...getMessagesChannelSpec(),
+        ...(extra ?? {}),
+    });
+}
+//# sourceMappingURL=darwin-messages-annotation.js.map

package/dist/darwin-messages-annotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"darwin-messages-annotation.js","sourceRoot":"","sources":["../src/darwin-messages-annotation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,EACL,UAAU,EACV,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,QAAQ,EAAE,UAAU,CAAgB;YAClC,OAAO,EAAE,oBAAoB;YAC7B,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;SAClB,CAAC;KACH,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,8DAA8D;AAC9D,MAAM,UAAU,wBAAwB,CACtC,KAAa;IAEb,OAAO,UAAU,CAAC,IAAI,CAAC;QACrB,GAAG,oBAAoB,EAAE;QACzB,GAAG,sBAAsB,EAAE;QAC3B,GAAG,CAAC,KAAK,IAAK,EAAY,CAAC;KAC5B,CAAC,CAAC;AACL,CAAC"}

package/dist/index.d.ts

@@ -37,11 +37,14 @@
  * console.log(result.output);
  * ```
  */
-export { createDarwinNode, type CreateDarwinNodeOptions, type DarwinNodeFn, } from "./create-darwin-node.js";
+export { createDarwinNode, type CreateDarwinNodeOptions, type DarwinNodeFn, type DarwinRunOptionsPassthrough, } from "./create-darwin-node.js";
 export { darwinAnnotation, getDarwinChannelSpec, lastWriteWinsTrajectoryReducer, } from "./darwin-annotation.js";
 export { withDarwinEvolution, type DarwinEvolutionOptions, type DarwinNodeMapEntry, type DarwinTrajectoryEvent, } from "./with-darwin-evolution.js";
+export { DarwinCallbackHandler } from "./darwin-callback-handler.js";
+export { toOtelAttributes, toolCallToOtelAttributes, type OtelAttributes, type ToOtelAttributesOptions, type ToolCallOtelOptions, } from "./to-otel-attributes.js";
+export { darwinMessagesAnnotation, getMessagesChannelSpec, } from "./darwin-messages-annotation.js";
 export { DarwinNodeError, DarwinEvolutionHookError } from "./errors.js";
 export type { AgentDefinition, DarwinExperiment, ExecutionTrace, MemoryProvider, RunResult, TraceToolCall, TraceTokenUsage, TraceTurnError, } from "./types.js";
 /** Adapter version — sync with `package.json` on every release. */
-export declare const VERSION = "0.1.0-alpha.1";
+export declare const VERSION = "0.2.0-alpha.1";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,8BAA8B,GAC/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,GAC3B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAExE,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,SAAS,EACT,aAAa,EACb,eAAe,EACf,cAAc,GACf,MAAM,YAAY,CAAC;AAEpB,mEAAmE;AACnE,eAAO,MAAM,OAAO,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,KAAK,2BAA2B,GACjC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,8BAA8B,GAC/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,GAC3B,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,GACzB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAExE,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,SAAS,EACT,aAAa,EACb,eAAe,EACf,cAAc,GACf,MAAM,YAAY,CAAC;AAEpB,mEAAmE;AACnE,eAAO,MAAM,OAAO,kBAAkB,CAAC"}

package/dist/index.js

@@ -40,7 +40,13 @@
 export { createDarwinNode, } from "./create-darwin-node.js";
 export { darwinAnnotation, getDarwinChannelSpec, lastWriteWinsTrajectoryReducer, } from "./darwin-annotation.js";
 export { withDarwinEvolution, } from "./with-darwin-evolution.js";
+// V0.2 — LangChain-native callback handler (preferred over `withDarwinEvolution`)
+export { DarwinCallbackHandler } from "./darwin-callback-handler.js";
+// V0.2 — OTEL GenAI Semantic Conventions mapping
+export { toOtelAttributes, toolCallToOtelAttributes, } from "./to-otel-attributes.js";
+// V0.2 — MessagesAnnotation interop for graphs mixing createReactAgent + createDarwinNode
+export { darwinMessagesAnnotation, getMessagesChannelSpec, } from "./darwin-messages-annotation.js";
 export { DarwinNodeError, DarwinEvolutionHookError } from "./errors.js";
 /** Adapter version — sync with `package.json` on every release. */
-export const VERSION = "0.1.0-alpha.1";
+export const VERSION = "0.2.0-alpha.1";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EACL,gBAAgB,GAGjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,8BAA8B,GAC/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,mBAAmB,GAIpB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAaxE,mEAAmE;AACnE,MAAM,CAAC,MAAM,OAAO,GAAG,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EACL,gBAAgB,GAIjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,8BAA8B,GAC/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,mBAAmB,GAIpB,MAAM,4BAA4B,CAAC;AAEpC,kFAAkF;AAClF,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,iDAAiD;AACjD,OAAO,EACL,gBAAgB,EAChB,wBAAwB,GAIzB,MAAM,yBAAyB,CAAC;AAEjC,0FAA0F;AAC1F,OAAO,EACL,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAaxE,mEAAmE;AACnE,MAAM,CAAC,MAAM,OAAO,GAAG,eAAe,CAAC"}

package/dist/to-otel-attributes.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Surface 5 (V0.2) — `toOtelAttributes(trajectory, opts?)`.
+ *
+ * Pure mapper from Darwin's `ExecutionTrace` to a flat
+ * `Record<string, string | number | boolean>` keyed by
+ * [OpenTelemetry GenAI Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-spans.md)
+ * attribute names — so any OTEL-compatible exporter (Langfuse,
+ * Braintrust, Honeycomb, Datadog, New Relic, Grafana) picks up the
+ * trace data without further mapping.
+ *
+ * Coverage:
+ *   - `gen_ai.operation.name` = `"invoke_agent"` (constant per OTEL
+ *     GenAI spec for agent-level operations).
+ *   - `gen_ai.agent.name` = `opts.agentName` (callers passes the
+ *     agent's logical name).
+ *   - `gen_ai.agent.id` = `opts.agentId` (optional UUID/run id).
+ *   - `gen_ai.usage.input_tokens` / `output_tokens` / `cache_read_tokens` /
+ *     `cache_creation_tokens` — only emitted when the upstream
+ *     trajectory captured token usage (i.e. provider reported it).
+ *   - `darwin.trajectory.tool_calls.count` (custom, non-OTEL — namespaced
+ *     under `darwin.*` to avoid colliding with future OTEL fields).
+ *   - `darwin.trajectory.text_blocks` / `turns` / `mcp_invocations` /
+ *     `errors.count` — same custom namespace.
+ *   - `darwin.trajectory.captured_at` — ISO string for traceability.
+ *
+ * Per OTEL GenAI spec we DO NOT emit `gen_ai.tool.call.arguments` /
+ * `gen_ai.tool.call.result` here — those are span-level attributes
+ * meant to be attached to per-tool-call spans, not the aggregate
+ * trajectory. Callers who need them should iterate `trajectory.toolCalls`
+ * and emit one child span per call.
+ *
+ * Design notes:
+ *   - **Sparse output.** Undefined fields stay out of the result rather
+ *     than appearing as `null` — keeps OTEL exporters from over-counting
+ *     missing-data buckets.
+ *   - **No allocation on hot path.** The function builds a single
+ *     object literal incrementally; no Map / Set / array intermediates.
+ *   - **Pure.** No side effects, no I/O, no Date.now() — fully
+ *     testable with deterministic inputs.
+ */
+import type { ExecutionTrace } from "darwin-agents";
+/** Options accepted by {@link toOtelAttributes}. */
+export interface ToOtelAttributesOptions {
+    /** Logical agent name. Maps to `gen_ai.agent.name`. */
+    agentName?: string;
+    /** Optional agent id (e.g. uuid or experiment id). Maps to `gen_ai.agent.id`. */
+    agentId?: string;
+    /**
+     * Custom namespace for Darwin-specific attributes that have no OTEL
+     * equivalent. Default: `"darwin"` → emits `darwin.trajectory.*`.
+     * Override for organisation-wide naming conventions (e.g. `"company.darwin"`).
+     */
+    customNamespace?: string;
+}
+/** Flat attribute bag matching OTEL's primitive-only attribute types. */
+export type OtelAttributes = Record<string, string | number | boolean>;
+/**
+ * Build the OTEL attribute bag for an `ExecutionTrace`.
+ *
+ * @example
+ * ```ts
+ * import { toOtelAttributes } from "darwin-langgraph";
+ *
+ * const attrs = toOtelAttributes(event.trajectory, {
+ *   agentName: event.agentName,
+ *   agentId: someExperimentId,
+ * });
+ * // attrs = {
+ * //   "gen_ai.operation.name": "invoke_agent",
+ * //   "gen_ai.agent.name": "researcher",
+ * //   "gen_ai.agent.id": "exp-2026-05-25-001",
+ * //   "gen_ai.usage.input_tokens": 1200,
+ * //   "gen_ai.usage.output_tokens": 340,
+ * //   "darwin.trajectory.tool_calls.count": 3,
+ * //   "darwin.trajectory.text_blocks": 2,
+ * //   "darwin.trajectory.turns": 4,
+ * //   "darwin.trajectory.mcp_invocations": 2,
+ * //   "darwin.trajectory.errors.count": 0,
+ * //   "darwin.trajectory.captured_at": "2026-05-25T08:00:00.000Z",
+ * // }
+ *
+ * // OTEL exporter usage (any tracer):
+ * span.setAttributes(attrs);
+ * ```
+ */
+export declare function toOtelAttributes(trajectory: ExecutionTrace, opts?: ToOtelAttributesOptions): OtelAttributes;
+/**
+ * Build per-tool-call OTEL attributes for each entry in
+ * `trajectory.toolCalls`. Use this to emit one child span per tool call
+ * under the parent agent span.
+ *
+ * Coverage:
+ *   - `gen_ai.operation.name` = `"execute_tool"` (OTEL spec).
+ *   - `gen_ai.tool.name` (OTEL spec).
+ *   - `gen_ai.tool.call.id` (OTEL spec).
+ *   - `gen_ai.tool.type` = `"function"` (default for MCP + builtins).
+ *   - `darwin.tool.outcome` = `"success" | "error"` (custom).
+ *   - `darwin.tool.duration_ms` (custom).
+ *   - `darwin.tool.turn` (custom).
+ *   - `darwin.tool.is_mcp` (boolean, custom).
+ *   - `gen_ai.tool.call.arguments` (JSON-stringified) — opt-in via
+ *     `opts.includeArguments`. Per OTEL spec this is OPT-IN because args
+ *     can contain sensitive data.
+ *   - `gen_ai.tool.call.result` — opt-in via `opts.includeResults` for
+ *     the same reason.
+ *   - `error.type` = `trajectory.toolCalls[i].errorClass` (when outcome=error).
+ */
+export interface ToolCallOtelOptions {
+    customNamespace?: string;
+    /** Emit `gen_ai.tool.call.arguments` (OPT-IN, may contain PII). */
+    includeArguments?: boolean;
+    /** Emit `gen_ai.tool.call.result` (OPT-IN, may contain PII). */
+    includeResults?: boolean;
+}
+export declare function toolCallToOtelAttributes(call: ExecutionTrace["toolCalls"][number], opts?: ToolCallOtelOptions): OtelAttributes;
+//# sourceMappingURL=to-otel-attributes.d.ts.map

package/dist/to-otel-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-otel-attributes.d.ts","sourceRoot":"","sources":["../src/to-otel-attributes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,oDAAoD;AACpD,MAAM,WAAW,uBAAuB;IACtC,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,yEAAyE;AACzE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,cAAc,EAC1B,IAAI,GAAE,uBAA4B,GACjC,cAAc,CAmEhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,EACzC,IAAI,GAAE,mBAAwB,GAC7B,cAAc,CAoDhB"}

package/dist/to-otel-attributes.js

@@ -0,0 +1,178 @@
+/**
+ * Surface 5 (V0.2) — `toOtelAttributes(trajectory, opts?)`.
+ *
+ * Pure mapper from Darwin's `ExecutionTrace` to a flat
+ * `Record<string, string | number | boolean>` keyed by
+ * [OpenTelemetry GenAI Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-spans.md)
+ * attribute names — so any OTEL-compatible exporter (Langfuse,
+ * Braintrust, Honeycomb, Datadog, New Relic, Grafana) picks up the
+ * trace data without further mapping.
+ *
+ * Coverage:
+ *   - `gen_ai.operation.name` = `"invoke_agent"` (constant per OTEL
+ *     GenAI spec for agent-level operations).
+ *   - `gen_ai.agent.name` = `opts.agentName` (callers passes the
+ *     agent's logical name).
+ *   - `gen_ai.agent.id` = `opts.agentId` (optional UUID/run id).
+ *   - `gen_ai.usage.input_tokens` / `output_tokens` / `cache_read_tokens` /
+ *     `cache_creation_tokens` — only emitted when the upstream
+ *     trajectory captured token usage (i.e. provider reported it).
+ *   - `darwin.trajectory.tool_calls.count` (custom, non-OTEL — namespaced
+ *     under `darwin.*` to avoid colliding with future OTEL fields).
+ *   - `darwin.trajectory.text_blocks` / `turns` / `mcp_invocations` /
+ *     `errors.count` — same custom namespace.
+ *   - `darwin.trajectory.captured_at` — ISO string for traceability.
+ *
+ * Per OTEL GenAI spec we DO NOT emit `gen_ai.tool.call.arguments` /
+ * `gen_ai.tool.call.result` here — those are span-level attributes
+ * meant to be attached to per-tool-call spans, not the aggregate
+ * trajectory. Callers who need them should iterate `trajectory.toolCalls`
+ * and emit one child span per call.
+ *
+ * Design notes:
+ *   - **Sparse output.** Undefined fields stay out of the result rather
+ *     than appearing as `null` — keeps OTEL exporters from over-counting
+ *     missing-data buckets.
+ *   - **No allocation on hot path.** The function builds a single
+ *     object literal incrementally; no Map / Set / array intermediates.
+ *   - **Pure.** No side effects, no I/O, no Date.now() — fully
+ *     testable with deterministic inputs.
+ */
+/**
+ * Build the OTEL attribute bag for an `ExecutionTrace`.
+ *
+ * @example
+ * ```ts
+ * import { toOtelAttributes } from "darwin-langgraph";
+ *
+ * const attrs = toOtelAttributes(event.trajectory, {
+ *   agentName: event.agentName,
+ *   agentId: someExperimentId,
+ * });
+ * // attrs = {
+ * //   "gen_ai.operation.name": "invoke_agent",
+ * //   "gen_ai.agent.name": "researcher",
+ * //   "gen_ai.agent.id": "exp-2026-05-25-001",
+ * //   "gen_ai.usage.input_tokens": 1200,
+ * //   "gen_ai.usage.output_tokens": 340,
+ * //   "darwin.trajectory.tool_calls.count": 3,
+ * //   "darwin.trajectory.text_blocks": 2,
+ * //   "darwin.trajectory.turns": 4,
+ * //   "darwin.trajectory.mcp_invocations": 2,
+ * //   "darwin.trajectory.errors.count": 0,
+ * //   "darwin.trajectory.captured_at": "2026-05-25T08:00:00.000Z",
+ * // }
+ *
+ * // OTEL exporter usage (any tracer):
+ * span.setAttributes(attrs);
+ * ```
+ */
+export function toOtelAttributes(trajectory, opts = {}) {
+    if (!trajectory || typeof trajectory !== "object" || trajectory.version !== 1) {
+        throw new TypeError(`toOtelAttributes: trajectory must be an ExecutionTrace with version=1, got ${trajectory === null ? "null" : typeof trajectory}`);
+    }
+    const ns = opts.customNamespace ?? "darwin";
+    const attrs = {
+        // OTEL GenAI required-style attributes
+        "gen_ai.operation.name": "invoke_agent",
+    };
+    if (opts.agentName)
+        attrs["gen_ai.agent.name"] = opts.agentName;
+    if (opts.agentId)
+        attrs["gen_ai.agent.id"] = opts.agentId;
+    // Token usage — only emit when provider reported FINITE numbers. NaN
+    // and Infinity pass `typeof === "number"` but OTEL exporters drop
+    // spans with non-finite numeric attrs silently (R1 V0.2 Critic
+    // Finding 3 + Finding 7, S1185).
+    //
+    // OTEL GenAI spec attribute names (R1 V0.2 Research Finding 1, S1185):
+    // cache fields are `gen_ai.usage.cache_read.input_tokens` /
+    // `cache_creation.input_tokens` per the official registry, NOT the
+    // shorter `cache_read_tokens` / `cache_creation_tokens` we had pre-fix.
+    const usage = trajectory.tokenUsage;
+    if (usage) {
+        if (typeof usage.inputTokens === "number" && Number.isFinite(usage.inputTokens)) {
+            attrs["gen_ai.usage.input_tokens"] = usage.inputTokens;
+        }
+        if (typeof usage.outputTokens === "number" && Number.isFinite(usage.outputTokens)) {
+            attrs["gen_ai.usage.output_tokens"] = usage.outputTokens;
+        }
+        if (typeof usage.cacheReadTokens === "number" && Number.isFinite(usage.cacheReadTokens)) {
+            attrs["gen_ai.usage.cache_read.input_tokens"] = usage.cacheReadTokens;
+        }
+        if (typeof usage.cacheCreationTokens === "number" &&
+            Number.isFinite(usage.cacheCreationTokens)) {
+            attrs["gen_ai.usage.cache_creation.input_tokens"] = usage.cacheCreationTokens;
+        }
+    }
+    // Darwin-namespaced aggregates (always emitted, even when 0, so
+    // dashboards can graph deltas correctly). Defensive `?? 0` fallback
+    // in case a future darwin-agents version makes a field optional.
+    const toolCallsCount = Array.isArray(trajectory.toolCalls)
+        ? trajectory.toolCalls.length
+        : 0;
+    const errorsCount = Array.isArray(trajectory.errors) ? trajectory.errors.length : 0;
+    attrs[`${ns}.trajectory.tool_calls.count`] = toolCallsCount;
+    attrs[`${ns}.trajectory.text_blocks`] =
+        Number.isFinite(trajectory.textBlockCount) ? trajectory.textBlockCount : 0;
+    attrs[`${ns}.trajectory.turns`] =
+        Number.isFinite(trajectory.turnCount) ? trajectory.turnCount : 0;
+    attrs[`${ns}.trajectory.mcp_invocations`] =
+        Number.isFinite(trajectory.mcpInvocations) ? trajectory.mcpInvocations : 0;
+    attrs[`${ns}.trajectory.errors.count`] = errorsCount;
+    if (typeof trajectory.capturedAt === "string" && trajectory.capturedAt.length > 0) {
+        attrs[`${ns}.trajectory.captured_at`] = trajectory.capturedAt;
+    }
+    return attrs;
+}
+export function toolCallToOtelAttributes(call, opts = {}) {
+    const ns = opts.customNamespace ?? "darwin";
+    // R1 V0.2 Research Finding 3 (S1185): per OTEL GenAI spec, `gen_ai.tool.type`
+    // takes one of `function` (client-side, agent generates params),
+    // `extension` (agent-side, calls external APIs), or `datastore`. MCP
+    // tools execute server-side via the agent and call external APIs —
+    // they map to `"extension"`, not `"function"`. We route on the
+    // existing `mcp__` prefix heuristic.
+    const isMcp = call.tool.startsWith("mcp__");
+    const toolType = isMcp ? "extension" : "function";
+    const attrs = {
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": call.tool,
+        "gen_ai.tool.type": toolType,
+        [`${ns}.tool.outcome`]: call.outcome,
+        [`${ns}.tool.duration_ms`]: Number.isFinite(call.durationMs) ? call.durationMs : 0,
+        [`${ns}.tool.turn`]: Number.isFinite(call.turn) ? call.turn : 0,
+        [`${ns}.tool.is_mcp`]: isMcp,
+    };
+    // `call.id` is optional on TraceToolCall — only emit when present so
+    // OTEL exporters don't see empty-string ids.
+    if (typeof call.id === "string" && call.id.length > 0) {
+        attrs["gen_ai.tool.call.id"] = call.id;
+    }
+    if (call.outcome === "error") {
+        if (typeof call.errorClass === "string" && call.errorClass.length > 0) {
+            attrs["error.type"] = call.errorClass;
+        }
+        if (typeof call.errorMessage === "string" && call.errorMessage.length > 0) {
+            attrs[`${ns}.tool.error.message`] = call.errorMessage;
+        }
+    }
+    if (typeof call.retryCount === "number" && call.retryCount > 0) {
+        attrs[`${ns}.tool.retry_count`] = call.retryCount;
+    }
+    if (opts.includeArguments && call.args !== undefined) {
+        try {
+            attrs["gen_ai.tool.call.arguments"] = JSON.stringify(call.args);
+        }
+        catch {
+            attrs["gen_ai.tool.call.arguments"] = "<unserialisable>";
+        }
+    }
+    if (opts.includeResults &&
+        typeof call.resultSummary === "string" &&
+        call.resultSummary.length > 0) {
+        attrs["gen_ai.tool.call.result"] = call.resultSummary;
+    }
+    return attrs;
+}
+//# sourceMappingURL=to-otel-attributes.js.map

package/dist/to-otel-attributes.js.map

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

package/dist/with-darwin-evolution.d.ts

@@ -80,13 +80,6 @@ interface InvokableGraph {
     invoke(input: unknown, config?: unknown): Promise<unknown>;
     stream(input: unknown, config?: unknown): Promise<AsyncIterable<unknown>>;
 }
-/**
- * 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 declare function withDarwinEvolution<G extends InvokableGraph>(graph: G, opts: DarwinEvolutionOptions): G;
 export {};
 //# sourceMappingURL=with-darwin-evolution.d.ts.map

package/dist/with-darwin-evolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-darwin-evolution.d.ts","sourceRoot":"","sources":["../src/with-darwin-evolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAIpD,gFAAgF;AAChF,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,UAAU,EAAE,cAAc,CAAC;IAC3B;;;;;;OAMG;IACH,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC/C;AAED,+CAA+C;AAC/C,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC5C;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,mGAAmG;IACnG,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,yEAAyE;AACzE,UAAU,cAAc;IACtB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;CAC3E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,cAAc,EAC1D,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,sBAAsB,GAC3B,CAAC,CA+OH"}
+{"version":3,"file":"with-darwin-evolution.d.ts","sourceRoot":"","sources":["../src/with-darwin-evolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAIpD,gFAAgF;AAChF,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,UAAU,EAAE,cAAc,CAAC;IAC3B;;;;;;OAMG;IACH,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC/C;AAED,+CAA+C;AAC/C,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC5C;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,mGAAmG;IACnG,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,yEAAyE;AACzE,UAAU,cAAc;IACtB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;CAC3E;AAkCD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,cAAc,EAC1D,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,sBAAsB,GAC3B,CAAC,CA2PH"}

package/dist/with-darwin-evolution.js

@@ -34,9 +34,39 @@ import { DarwinEvolutionHookError } from "./errors.js";
  * fires for each node listed in `nodeMap` after every `invoke` / `stream`
  * run. Returns the same graph instance for chaining.
  *
+ * @deprecated Since v0.2.0 — prefer {@link DarwinCallbackHandler} which uses
+ *   LangChain's canonical callback mechanism instead of monkey-patching
+ *   `graph.invoke` / `graph.stream`. This wrapper continues to work
+ *   identically for back-compat but will be removed in v1.0. Migration:
+ *
+ *   ```ts
+ *   // Before (v0.1):
+ *   const graph = withDarwinEvolution(compiledGraph, { nodeMap, onTrajectory });
+ *   const r = await graph.invoke(input);
+ *
+ *   // After (v0.2 — recommended):
+ *   const handler = new DarwinCallbackHandler({ nodeMap, onTrajectory });
+ *   const r = await compiledGraph.invoke(input, { callbacks: [handler] });
+ *   ```
+ *
  * @throws {DarwinEvolutionHookError} when `nodeMap` is empty or missing.
  */
+/**
+ * Process-wide deprecation warning flag for `withDarwinEvolution`. We
+ * emit one `console.warn` on the first call so CI runs (no IDE for
+ * `@deprecated` strikethrough) still see the migration hint. After the
+ * first warn we go silent — never spam.
+ *
+ * R1 V0.2 Research Finding 7 + Analyst Observation 2 (S1185).
+ */
+let withDarwinEvolutionDeprecationWarned = false;
 export function withDarwinEvolution(graph, opts) {
+    if (!withDarwinEvolutionDeprecationWarned) {
+        withDarwinEvolutionDeprecationWarned = true;
+        console.warn("[darwin-langgraph] withDarwinEvolution() is deprecated since v0.2.0 " +
+            "and will be removed in v1.0.0. Migrate to DarwinCallbackHandler — " +
+            "see https://github.com/studiomeyer-io/darwin-langgraph#migration");
+    }
     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.");
     }
@@ -65,12 +95,16 @@ export function withDarwinEvolution(graph, opts) {
     }
     let warned = false;
     const swallow = (err) => {
-        if (warned || !err)
+        // R2 V0.2 Critic Finding R2-1 (S1185): do NOT short-circuit on
+        // falsy `err` — `throw 0` / `throw null` / `throw ""` from user
+        // callbacks must still surface in logs. Diverged from
+        // DarwinCallbackHandler.swallow until R2 caught it.
+        if (warned)
             return;
         warned = true;
         console.warn(`[darwin-langgraph] onTrajectory callback threw — swallowed. ` +
             `Subsequent throws will be silent. Original error: ` +
-            `${err?.message ?? String(err)}`);
+            `${err instanceof Error ? err.message : String(err)}`);
     };
     const fireHook = async (finalState) => {
         if (!callback)

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "darwin-langgraph",
-  "version": "0.1.0-alpha.1",
+  "version": "0.2.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",