@amaster.ai/dsh-langfuse 0.1.24 → 0.1.25

package/README.md

@@ -134,7 +134,7 @@ Tool hooks should include the execution's `callId` in both records. The plugin m
 
 `hook/result.outcome` describes process execution independently of `decision`: `success` is normal completion, `failed` is execution failure, `timed-out` is deadline termination, and `cancelled` is cancellation. The producer maps its process semantics to these values; an exit code expressing a policy denial can still be a successful execution. Optional `exitCode` and `signal` preserve process details. Failed/timed-out executions receive ERROR observations, cancellation receives WARNING, and successful executions retain decision-based warnings. Records without an explicit outcome preserve the legacy exit-code interpretation (0/2 are non-error). The plugin records `durationMs` and never infers a timeout or cancellation from a missing exit code.
 
-For records admitted by the session, runs with `invocationId` retain correlation after `turn/end` and a subsequent `turn/start`; a late result ends the original hook span without attaching it to the new turn. Invocations arriving outside their originating turn receive a separate root with `detachedHook: true` and the original turn number; their result ends both hook and root so they export without waiting for another turn. These detached hook roots do not consume `langfuse/context` queued for the next turn. Detached producers must finish reporting before the session is disposed. Session disposal/plugin unload closes unfinished runs with `hook result not observed`; this means missing telemetry, not proof of execution failure. Legacy records without `invocationId` still close at turn boundaries.
+For records admitted by the session, runs with `invocationId` retain correlation after `turn/end` and a subsequent `turn/start`; a late result ends the original hook span without attaching it to the new turn. Delayed invocations, including `UserCancel`, reuse their originating turn's parent span even after the next turn starts. The plugin retains the latest 128 completed-turn associations across all sessions, clearing a session's associations on disposal and all associations on unload. Reporting never reopens the ended root or changes its end time or final status; each hook records its own duration. When the originating parent is unavailable or evicted, the invocation receives a separate root with `detachedHook: true` and the original turn number; its result ends both hook and fallback root. Neither path consumes `langfuse/context` queued for the next turn. Detached producers must finish reporting before the session is disposed. Session disposal/plugin unload closes unfinished runs with `hook result not observed`; this means missing telemetry, not proof of execution failure. Legacy records without `invocationId` still close at turn boundaries.
 
 Custom names, hook input, parsed results and raw process output follow `captureContent`; credentials and `redactFields` are masked by the existing reporter. New outcomes, correlation IDs, dialect, point, duration and process metadata remain available with content capture disabled. The event writer does not sanitize the session log itself: application producers remain responsible for what they persist. Applications must explicitly replace any private hook events with this standard producer path, reuse the same `invocationId`, and report the actual outcome; installing/upgrading the plugin does not adapt an application bridge or repair historical Trace overview IO (Issue #59).
 
@@ -146,6 +146,8 @@ Run `pnpm test:sdk` at the repository root for a secrets-free check using the re
 
 The independent `dsh-langfuse.tool-hooks` E2E leg boots the packed plugin in the real headless profile, asks the model to read a marker file, and executes BeforeTool/AfterTool scripts through an E2E-only producer. It requires both gateway and Langfuse credentials, then polls the real Observations API to verify named hooks, tool-call parenting, enclosing tool timestamps, script input and parsed output, credential masking, and stdout truncation. The existing `dsh-langfuse.hook` leg continues to check the upstream Codex UserPromptSubmit bridge; the new fixture verifies the shared event contract and does not substitute for the application's Gemini bridge integration.
 
+The `dsh-langfuse.cancel-hook` E2E leg cancels a real agent at a tool boundary, queues its next turn, and asynchronously runs a UserCancel process after that turn starts. Real Langfuse API read-back must show the hook under the cancelled turn's root and trace ID, with the root still aborted and ended before the hook's own duration. It requires the existing gateway and Langfuse secrets in `integration.yml`.
+
 ### Trace overview compatibility
 
 Overall input/output belongs to the `dsh-turn` root observation. The root is exported when the turn ends; while a long turn is running, child observations can already be visible before the root appears. After completion, allow asynchronous ingestion to settle.

package/lib/index.js

@@ -204,6 +204,17 @@ export function apply(ctx, config) {
     const reporter = new LangfuseReporter(config);
     const sessions = new Map();
     const children = new Map();
+    const completedTurns = new Map();
+    function rememberTurn(sessionId, turn, parent, turnTrace) {
+        if (!parent)
+            return;
+        const key = JSON.stringify([sessionId, turn]);
+        completedTurns.delete(key);
+        completedTurns.set(key, { sessionId, parent, turnTrace });
+        // Bound retained SDK handles across all sessions; older hooks use the standalone fallback.
+        if (completedTurns.size > 128)
+            completedTurns.delete(completedTurns.keys().next().value);
+    }
     /** Per-session stack of currently open tool pipeline spans (for subagent parenting). */
     const openToolSpans = new Map();
     const toolCalls = new Map();
@@ -397,7 +408,10 @@ export function apply(ctx, config) {
                 reporter.endSpan(previous.root, { level: 'WARNING' });
             const child = children.get(sessionId);
             const inTurn = child ? child.turn === data.turn : sessions.get(sessionId)?.turn === data.turn;
-            const root = data.invocationId && !inTurn
+            const completed = data.invocationId && !inTurn
+                ? completedTurns.get(JSON.stringify([sessionId, data.turn]))
+                : undefined;
+            const root = data.invocationId && !inTurn && !completed
                 ? // A late hook must not consume context queued for the next turn.
                     reporter.openTrace({
                         name: config.traceName,
@@ -407,7 +421,12 @@ export function apply(ctx, config) {
                 : undefined;
             const tool = data.callId ? toolCalls.get(sessionId)?.get(data.callId) : undefined;
             const hookName = config.captureContent ? reporter.mask({ name: data.name }).name : undefined;
-            const span = reporter.startSpan(root === undefined ? (tool?.turn === data.turn ? tool.span : parentFor(sessionId)) : root, {
+            const span = reporter.startSpan(completed?.parent ??
+                (root === undefined
+                    ? tool?.turn === data.turn
+                        ? tool.span
+                        : parentFor(sessionId)
+                    : root), {
                 name: `hook:${data.point}${hookName ? `:${hookName}` : ''}`,
                 input: config.captureContent ? data.input : undefined,
                 metadata: {
@@ -429,7 +448,11 @@ export function apply(ctx, config) {
                 handlerId: data.handlerId,
                 persistent: !!data.invocationId,
                 callId: data.callId,
-                turnTrace: root === undefined ? (child?.turnTrace ?? sessions.get(sessionId)?.trace) : undefined,
+                turnTrace: completed
+                    ? completed.turnTrace
+                    : root === undefined
+                        ? (child?.turnTrace ?? sessions.get(sessionId)?.trace)
+                        : undefined,
             });
             openHooks.set(sessionId, pending);
             return;
@@ -500,8 +523,10 @@ export function apply(ctx, config) {
         if (child) {
             if (event.type === 'turn/start')
                 child.turn = event.data.turn;
-            if (event.type === 'turn/end')
+            if (event.type === 'turn/end') {
+                rememberTurn(sessionId, event.data.turn, child.span, child.turnTrace ?? null);
                 child.turn = undefined;
+            }
             // The delegated prompt (the child's first user/message) is the
             // subagent span's input; the descriptor enriches the span name.
             if (event.type === 'user/message' && !child.hasInput && config.captureContent) {
@@ -553,6 +578,7 @@ export function apply(ctx, config) {
                 const state = sessions.get(sessionId);
                 if (state) {
                     sessions.delete(sessionId);
+                    rememberTurn(sessionId, event.data.turn, state.trace, state.trace);
                     // The turn's final answer becomes the trace's output; ending the
                     // root span is what exports the trace (v5 exports spans on end).
                     afterMedia(state.trace, (endedAt) => reporter.endSpan(state.trace, {
@@ -585,6 +611,10 @@ export function apply(ctx, config) {
         const state = sessions.get(sessionId);
         sessions.delete(sessionId);
         traceContexts.delete(sessionId);
+        for (const [key, completed] of completedTurns) {
+            if (completed.sessionId === sessionId)
+                completedTurns.delete(key);
+        }
         openToolSpans.delete(sessionId);
         toolCalls.delete(sessionId);
         // End an abandoned root (crash-orphaned turn or between-turns one-off
@@ -894,6 +924,7 @@ export function apply(ctx, config) {
             for (const child of children.values())
                 reporter.endSpan(child.span, {}, endedAt);
             sessions.clear();
+            completedTurns.clear();
             traceContexts.clear();
             children.clear();
             openToolSpans.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-langfuse",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Langfuse observability plugin for DeepSeek Harness: one generation per LLM call with a nested llm-request span, one span per tool call, one trace per session turn, subagent child sessions nested under the parent's tree.",
   "type": "module",
   "main": "lib/index.js",