@amaster.ai/dsh-langfuse 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-plugins contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @amaster.ai/dsh-langfuse
+
+![dsh-langfuse preview](preview.png)
+
+Langfuse observability for [DeepSeek Harness (dsh)](https://github.com/deepseek-ai/deepseek-harness):
+
+- one **generation** per LLM call (`llm/stream` waterfall), plus a nested `llm-request` span carrying the verbatim loop-built request
+- one **span** per tool call (`tools/execute` waterfall)
+- one **trace** per session turn (`session/event`) — in the v5 SDK the trace IS its root span, ended (and thereby exported) at `turn/end`
+- subagent child sessions nested under the parent's tree (`session/created` header link + `subagent/start` / `subagent/end`)
+
+## Install
+
+```sh
+dsh plugin --profile my-agent add @amaster.ai/dsh-langfuse \
+  @langfuse/tracing @langfuse/otel @opentelemetry/sdk-trace-node \
+  @opentelemetry/api @opentelemetry/exporter-trace-otlp-http
+```
+
+The Langfuse JS SDK v5 peers (`@langfuse/tracing`, `@langfuse/otel`, `@opentelemetry/sdk-trace-node`) are loaded via lazy dynamic `import()`, so an unused install costs nothing — but they must all be present at runtime (`dsh plugin add` does not auto-install peer trees, so the OTEL api/exporter packages `@langfuse/otel` itself peers on are listed explicitly).
+
+## Configuration
+
+Disabled by default. Configure via the profile's `cordis.patch.yml`:
+
+```yaml
+- insert:
+    - id: langfuse
+      name: '@amaster.ai/dsh-langfuse'
+      config:
+        enabled: true
+        publicKey: pk-lf-...
+        secretKey: sk-lf-...            # secret role
+        baseUrl: https://cloud.langfuse.com
+        traceName: dsh-turn
+        captureContent: true            # set false to record metadata only
+```
+
+Buffered spans drain on `session/flush(session)`; the exporter shuts down with the plugin fiber.
+
+Observability is a no-throw seam: backend errors are logged with a `[dsh-langfuse]` prefix and never escape into the agent loop.
+
+## Compatibility
+
+Pinned dsh/cordis versions live in the [root compat matrix](../../README.md#compatibility). Event payloads ride pre-release dsh APIs — check the `TODO(verify)` markers in `src/` before upgrading dsh.
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+# Inserts the dsh-langfuse plugin row; plugin config is the Config schema in
+# src/index.ts (overridable in the profile's own cordis.patch.yml).
+- insert:
+    - id: langfuse
+      name: '@amaster.ai/dsh-langfuse'

package/lib/client.js

@@ -0,0 +1,287 @@
+/**
+ * Langfuse reporter — thin synchronous wrapper over the Langfuse JS SDK v5's
+ * OpenTelemetry-based tracing API (`@langfuse/tracing` + `@langfuse/otel`),
+ * and the plugin's single no-throw seam: every method swallows SDK failures
+ * with a `[dsh-langfuse]` console.error so observability can never break the
+ * agent loop.
+ *
+ * v5's observations-first data model has no trace object: a trace is the root
+ * observation plus the correlating attributes every observation carries. So:
+ * - a "trace" here is a root `LangfuseSpan` created with {@link NO_PARENT} —
+ *   without it the SDK parents to whatever span is active in the host's
+ *   ambient OTEL context (e.g. an instrumented HTTP server around dsh),
+ *   smearing turn traces into foreign traces;
+ * - trace-level input/output/metadata live on that root span (the v5
+ *   replacement for the removed `trace.update()`), and the root must be
+ *   ENDED — spans only export on end, so an un-ended root never leaves the
+ *   process;
+ * - the correlating `session.id` attribute is stamped on every observation
+ *   via a handle-keyed WeakMap — the explicit-tree equivalent of v5's
+ *   context-scoped `propagateAttributes()`, which cannot wrap this plugin's
+ *   event-driven lifecycle.
+ *
+ * The SDK stack is a heavy optional peer set, so it loads via dynamic
+ * `import()` kicked off in the constructor — a disabled plugin never pays for
+ * it, and a missing or incompatible peer degrades the reporter to a no-op
+ * instead of breaking the plugin load. The exporter runs on an ISOLATED
+ * tracer provider (`setLangfuseTracerProvider`) rather than
+ * `provider.register()`: the process-global OTEL provider stays untouched and
+ * the host keeps its own tracing pipeline. {@link LangfuseReporter.ready}
+ * settles (never rejects) once the import+wiring finished: the plugin returns
+ * it from `apply()` so fiber readiness covers the import window, and
+ * {@link flush}/{@link shutdown} chain behind it. Observation calls landing
+ * before readiness are still dropped — a window that cannot exist once the
+ * plugin fiber has been awaited.
+ */
+/**
+ * OTEL's canonical invalid span context as a literal (a static
+ * `INVALID_SPAN_CONTEXT` import would load @opentelemetry/api eagerly, even
+ * for a disabled plugin): the SDK starts a fresh traceId for an invalid
+ * parent instead of adopting the ambient context's active span.
+ */
+const NO_PARENT = { traceId: '0'.repeat(32), spanId: '0'.repeat(16), traceFlags: 0 };
+/**
+ * Map dsh token accounting onto Langfuse's `usageDetails`, keeping every
+ * bucket mutually exclusive (Langfuse's flat-bucket rule: `input` excludes
+ * `input_*`, `output` excludes `output_*`, `total` is the bucket sum —
+ * overlapping buckets double-count usage and inferred cost). dsh reports
+ * uncached input, separate cache buckets, and provider-style output that
+ * INCLUDES reasoning (verified in dsh-llm-deepseek@0.1.0-rc.7:
+ * `outputTokens: usage.completion_tokens`, with reasoning split out of
+ * `completion_tokens_details`), so the `output` bucket subtracts
+ * `reasoningTokens` into `output_reasoning`. Only `usageDetails` is sent.
+ */
+export function usageOf(usage) {
+    // The dsh type marks the two primary fields required, but a non-conformant
+    // adapter emitting a partial usage chunk would otherwise turn every bucket
+    // NaN (serialized as null by the SDK — silently corrupting billed usage).
+    const input = (usage.inputTokens ?? 0) + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+    const output = usage.outputTokens ?? 0;
+    const total = input + output;
+    // Clamp reasoning at the provider's output count: reasoning is a subset of
+    // output, and only a broken adapter would report more — clamping keeps the
+    // buckets summing to total even then.
+    const reasoning = Math.min(usage.reasoningTokens ?? 0, output);
+    const usageDetails = {
+        input: usage.inputTokens ?? 0,
+        output: output - reasoning,
+        total,
+    };
+    if (usage.cacheReadTokens)
+        usageDetails.input_cache_read = usage.cacheReadTokens;
+    if (usage.cacheWriteTokens)
+        usageDetails.input_cache_creation = usage.cacheWriteTokens;
+    if (reasoning)
+        usageDetails.output_reasoning = reasoning;
+    return usageDetails;
+}
+export class LangfuseReporter {
+    config;
+    tracing = null;
+    provider = null;
+    /**
+     * Observation → its trace's correlating attributes; children inherit their
+     * parent's. Stamped on every observation (`session.id`,
+     * `langfuse.trace.name`): v5's observations-first model wants trace context
+     * on every span (the v4 migration doc: "copied to every span where the name
+     * must be queryable"), and older Langfuse servers derive the trace row from
+     * ANY span carrying these — a root-only stamp can lose to child-derived
+     * trace events depending on ingestion order. This is the explicit
+     * handle-tree equivalent of v5's context-scoped propagateAttributes, which
+     * cannot wrap this plugin's event-driven lifecycle.
+     */
+    traceContext = new WeakMap();
+    /** Trace roots (created by openTrace) — the spans that may carry trace-level IO. */
+    roots = new WeakSet();
+    /** Settles (never rejects) once the lazy SDK import+wiring finished. */
+    ready;
+    constructor(config) {
+        this.config = config;
+        this.ready = this.init();
+    }
+    /** Dynamically import the SDK and wire the isolated export pipeline. */
+    async init() {
+        try {
+            const [tracing, otel, sdkNode] = await Promise.all([
+                import('@langfuse/tracing'),
+                import('@langfuse/otel'),
+                import('@opentelemetry/sdk-trace-node'),
+            ]);
+            const processor = new otel.LangfuseSpanProcessor({
+                publicKey: this.config.publicKey,
+                secretKey: this.config.secretKey,
+                baseUrl: this.config.baseUrl,
+            });
+            this.provider = new sdkNode.NodeTracerProvider({ spanProcessors: [processor] });
+            // Isolated provider, not provider.register(): the process-global OTEL
+            // provider stays untouched. Set `tracing` last — observation methods
+            // gate on it, and it must never be visible before the provider is wired.
+            tracing.setLangfuseTracerProvider(this.provider);
+            this.tracing = tracing;
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] client init failed:', error);
+        }
+    }
+    /**
+     * Stamp the trace-correlating attributes on an observation and record them
+     * for future children. `session.id` = `LangfuseOtelSpanAttributes.TRACE_SESSION_ID`
+     * (the OTEL semconv key); `langfuse.trace.name` = `TRACE_NAME`.
+     */
+    stampTraceContext(observation, context) {
+        if (!context)
+            return;
+        observation.otelSpan.setAttribute('langfuse.trace.name', context.traceName);
+        if (context.sessionId)
+            observation.otelSpan.setAttribute('session.id', context.sessionId);
+        this.traceContext.set(observation, context);
+    }
+    /** Open a trace (one per agent turn, or one-off for session-less calls). */
+    openTrace(input) {
+        if (!this.tracing)
+            return null;
+        try {
+            const root = this.tracing.startObservation(input.name, { metadata: input.metadata }, { parentSpanContext: NO_PARENT });
+            this.stampTraceContext(root, { sessionId: input.sessionId, traceName: input.name });
+            this.roots.add(root);
+            return root;
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] trace creation failed:', error);
+            return null;
+        }
+    }
+    /** Open a generation (one per LLM call) under any observation parent. */
+    startGeneration(parent, input) {
+        if (!parent)
+            return null;
+        try {
+            const generation = parent.startObservation(input.name, {
+                model: input.model,
+                input: input.input,
+                modelParameters: input.modelParameters,
+                metadata: input.metadata,
+            }, { asType: 'generation' });
+            this.stampTraceContext(generation, this.traceContext.get(parent));
+            return generation;
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] generation creation failed:', error);
+            return null;
+        }
+    }
+    endGeneration(generation, update) {
+        if (!generation)
+            return;
+        try {
+            generation.update({
+                output: update.output,
+                usageDetails: update.usage ? usageOf(update.usage) : undefined,
+                completionStartTime: update.completionStartTime,
+                level: update.level,
+                statusMessage: update.statusMessage,
+                metadata: update.metadata,
+            });
+            // v5 observation attributes have no `name` — renames ride the OTEL span.
+            if (update.name)
+                generation.otelSpan.updateName(update.name);
+            generation.end();
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] generation end failed:', error);
+        }
+    }
+    /** Open a span (one per tool dispatch, or a nested detail span) under any observation parent. */
+    startSpan(parent, input) {
+        if (!parent)
+            return null;
+        try {
+            const span = parent.startObservation(input.name, {
+                input: input.input,
+                metadata: input.metadata,
+            });
+            this.stampTraceContext(span, this.traceContext.get(parent));
+            return span;
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] span creation failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Merge fields into an open span — subagent enrichment (label, provider),
+     * and the trace root's input (a v5 trace IS its root span, so trace-level
+     * updates are span updates; OTEL attributes merge per key, so partial
+     * updates compose). On trace roots the input/output also rides the
+     * deprecated `langfuse.trace.*` attributes (setTraceIO): older Langfuse
+     * servers derive the trace row's IO from exactly those keys.
+     */
+    updateSpan(span, update) {
+        if (!span)
+            return;
+        try {
+            span.update({ input: update.input, metadata: update.metadata });
+            if (update.name)
+                span.otelSpan.updateName(update.name);
+            if (update.input !== undefined && this.roots.has(span)) {
+                span.setTraceIO({ input: update.input });
+            }
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] span update failed:', error);
+        }
+    }
+    /**
+     * Close any span observation, trace roots included: final fields, then end —
+     * v5 spans only export on end, so an un-ended root never reaches Langfuse.
+     * On trace roots the output also rides the deprecated `langfuse.trace.*`
+     * attributes (setTraceIO) for older servers — same rule as updateSpan.
+     */
+    endSpan(span, update = {}) {
+        if (!span)
+            return;
+        try {
+            span.update(update);
+            if (update.output !== undefined && this.roots.has(span)) {
+                span.setTraceIO({ output: update.output });
+            }
+            span.end();
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] span end failed:', error);
+        }
+    }
+    /** Drain buffered spans (the `session/flush` checkpoint). */
+    async flush() {
+        await this.ready;
+        if (!this.provider)
+            return;
+        try {
+            await this.provider.forceFlush();
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] flush failed:', error);
+        }
+    }
+    /** Shut the exporter down at fiber unload (provider.shutdown flushes internally). */
+    async shutdown() {
+        await this.ready;
+        const provider = this.provider;
+        const tracing = this.tracing;
+        this.provider = null;
+        this.tracing = null;
+        if (!provider || !tracing)
+            return;
+        try {
+            await provider.shutdown();
+        }
+        catch (error) {
+            console.error('[dsh-langfuse] shutdown failed:', error);
+        }
+        finally {
+            // Release the module-global isolated-provider slot so a reloaded fiber
+            // starts clean — even when the shutdown flush failed.
+            tracing.setLangfuseTracerProvider(null);
+        }
+    }
+}

package/lib/index.js

@@ -0,0 +1,529 @@
+/**
+ * dsh-langfuse — Langfuse observability for DeepSeek Harness.
+ *
+ * Instruments the documented seams, with zero core patches:
+ *
+ * - `llm/stream` waterfall  → one Langfuse **generation** per LLM call
+ *   (input = full request; output, token usage and finish reason collected
+ *   from the chunk stream), plus a nested `llm-request` **span** holding the
+ *   verbatim loop-built request and the collected chunk stream (the rawest
+ *   request/response a plugin can observe — the provider HTTP body is
+ *   assembled inside the adapter).
+ * - `tools/execute` waterfall → one Langfuse **span** per tool dispatch
+ *   (routed to the session's trace via `exec.agent.id` — the agent/session
+ *   shared identity).
+ * - `session/event` emit    → one Langfuse **trace** per agent turn
+ *   (`turn/start` opens a root span — in the v5 SDK the root observation IS
+ *   the trace — the turn's first `user/message` sets the input, `turn/end`
+ *   stamps the end reason and ends the root, which is what exports it).
+ * - subagent child sessions (`session/created` with `header.parentSession`)
+ *   ride the parent's trace: a `subagent` **span** opened under the enclosing
+ *   delegation tool span, the child's generations/tool spans nested under it,
+ *   closed at `subagent/end` (enriched by `subagent/start` and the child's
+ *   `subagent/descriptor` event).
+ *
+ * Event/waterfall shapes verified against the installed
+ * @deepseek-ai/dsh-{llm,session,tools,agent,subagent}@0.1.0-rc.7 package sources
+ * (types for shapes; `lib/*.js` for the session/created ordering claim).
+ *
+ * @module dsh-langfuse
+ */
+import { isTokenDelta } from '@deepseek-ai/dsh-llm/message';
+import Schema from '@deepseek-ai/schemastery';
+import { LangfuseReporter } from './client.js';
+export const name = 'dsh-langfuse';
+/**
+ * Waterfall listeners only need the events to exist; no hard service
+ * dependency is declared so the plugin still loads in minimal compositions
+ * (it simply never observes anything). Add 'llm' / 'tools' to `inject` if you
+ * prefer fail-fast wiring.
+ */
+export const inject = [];
+export const Config = Schema.object({
+    enabled: Schema.boolean().default(false).description('master switch'),
+    publicKey: Schema.string().default('').description('Langfuse public key'),
+    secretKey: Schema.string().role('secret').default('').description('Langfuse secret key'),
+    baseUrl: Schema.string().default('https://cloud.langfuse.com'),
+    traceName: Schema.string().default('dsh-turn'),
+    /** Include full message/tool payloads in Langfuse IO. Disable to log metadata only. */
+    captureContent: Schema.boolean().default(true),
+});
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+ * Provider/tool error text can embed prompt fragments, paths, or credentials —
+ * it crosses to Langfuse only when `captureContent` allows content. Structural
+ * facts (levels, kinds, error codes) always do.
+ */
+const contentMessage = (config, text) => config.captureContent ? text : undefined;
+/** Trace input/output text: the message's text blocks, joined. */
+function messageText(message) {
+    const text = message.content.flatMap((block) => (block.type === 'text' ? [block.text] : []));
+    return text.length > 0 ? text.join('\n') : undefined;
+}
+/**
+ * Langfuse model parameters: only the request fields actually set, coerced to
+ * the v5 value type (`string | number` — the stop list serializes). Stop
+ * sequences are arbitrary request strings — content, not metadata — so under
+ * `captureContent: false` they collapse to a count.
+ */
+function modelParametersOf(options, captureContent) {
+    const params = Object.fromEntries(Object.entries({
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        stop: captureContent && options.stop ? JSON.stringify(options.stop) : undefined,
+        stopCount: captureContent ? undefined : options.stop?.length,
+        reasoningEffort: options.reasoningEffort,
+    }).filter(([, value]) => value !== undefined));
+    return Object.keys(params).length > 0 ? params : undefined;
+}
+/**
+ * The loop-built request as Langfuse input: verbatim (minus the AbortSignal,
+ * which is not JSON-safe) when content capture is on, counts-only otherwise.
+ */
+function requestBodyOf(options, captureContent) {
+    if (!captureContent) {
+        return {
+            messageCount: options.messages.length,
+            hasSystem: options.system !== undefined,
+            toolCount: options.tools?.length,
+        };
+    }
+    const { signal: _, ...body } = options;
+    return body;
+}
+/** Generation names carry the reply's first non-empty line (capped) for list readability. */
+function enhanceWithFirstLine(base, text) {
+    const firstLine = text
+        .split('\n')
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return undefined;
+    return `${base} [${firstLine.length > 80 ? `${firstLine.slice(0, 79)}…` : firstLine}]`;
+}
+/** Tool argument keys worth surfacing in a span name, in priority order. */
+const ARG_SUMMARY_KEYS = [
+    'path',
+    'file_path',
+    'filePath',
+    'command',
+    'description',
+    'query',
+    'name',
+    'url',
+    'instruction',
+];
+/** A short argument summary for span names: the first matching key's first line, trimmed and capped. */
+function toolCallSummary(args) {
+    if (args === null || typeof args !== 'object' || Array.isArray(args))
+        return undefined;
+    for (const key of ARG_SUMMARY_KEYS) {
+        const value = args[key];
+        if (typeof value !== 'string')
+            continue;
+        const first = value.split('\n', 1)[0].trim();
+        if (first.length > 0)
+            return first.slice(0, 80);
+    }
+    return undefined;
+}
+export function apply(ctx, config) {
+    if (!config.enabled || !config.publicKey || !config.secretKey)
+        return;
+    const reporter = new LangfuseReporter(config);
+    const sessions = new Map();
+    const children = new Map();
+    /** Per-session stack of currently open tools/execute spans (for subagent parenting). */
+    const openToolSpans = new Map();
+    /**
+     * The trace an observation for `sessionId` belongs to: the session's open
+     * turn trace, else a per-session one-off trace shared by that session's
+     * out-of-turn calls (between-turn maintenance like compaction, sessions
+     * that started before the plugin loaded) so those observations stay in one
+     * trace instead of fragmenting per call. The next `turn/start` replaces it.
+     * Session-less hand-built calls get one trace each — there is no key to
+     * cache under. Subagent child sessions resolve through their parent chain
+     * (a tree by construction) to the root trace.
+     */
+    function traceFor(sessionId) {
+        let id = sessionId;
+        while (id && children.has(id))
+            id = children.get(id)?.parentSessionId;
+        const existing = id ? sessions.get(id) : undefined;
+        if (existing)
+            return existing.trace;
+        const trace = reporter.openTrace({ name: config.traceName, sessionId: id });
+        // hasInput starts true: one-offs never take a turn's first-message input.
+        if (trace && id)
+            sessions.set(id, { trace, hasInput: true });
+        return trace;
+    }
+    /**
+     * The observation a generation/span for `sessionId` parents under: the
+     * child's own `subagent` span when there is one, else the turn trace.
+     */
+    function parentFor(sessionId) {
+        const child = sessionId ? children.get(sessionId) : undefined;
+        return child?.span ?? traceFor(sessionId);
+    }
+    // ------------------------------------------------------------------
+    // Subagent child sessions: session/created precedes both subagent/start
+    // and the child's first generation, and the durable header already links
+    // child → parent (verified against dsh-subagent@0.1.0-rc.7).
+    // ------------------------------------------------------------------
+    ctx.on('session/created', (session) => {
+        const parentSessionId = session.header.parentSession;
+        if (!parentSessionId)
+            return;
+        const childId = session.id;
+        // Parent under the enclosing delegation tool span when one is open
+        // (foreground runs execute inside the parent's tools/execute), else the
+        // parent's own subagent span (nested delegation), else the root trace.
+        const parentObservation = openToolSpans.get(parentSessionId)?.at(-1) ??
+            children.get(parentSessionId)?.span ??
+            traceFor(parentSessionId);
+        const span = reporter.startSpan(parentObservation, {
+            name: 'subagent',
+            metadata: {
+                childSessionId: childId,
+                delegationDepth: session.header.delegationDepth,
+            },
+        });
+        children.set(childId, { parentSessionId, span, hasInput: false });
+    });
+    ctx.on('subagent/start', (info) => {
+        const child = children.get(info.id);
+        if (!child)
+            return; // remote (ACP) runs have no local session — nothing to nest
+        reporter.updateSpan(child.span, { metadata: { provider: info.provider, local: info.local } });
+    });
+    ctx.on('subagent/end', (info) => {
+        const child = children.get(info.id);
+        if (!child)
+            return;
+        children.delete(info.id);
+        reporter.endSpan(child.span, {
+            output: {
+                stopReason: info.stopReason,
+                ...(config.captureContent ? { lastAssistantMessage: info.lastAssistantMessage } : {}),
+            },
+            level: info.stopReason === 'error'
+                ? 'ERROR'
+                : info.stopReason === 'aborted'
+                    ? 'WARNING'
+                    : 'DEFAULT',
+        });
+    });
+    // ------------------------------------------------------------------
+    // Trace lifecycle: one trace per turn (top-level sessions only — child
+    // sessions ride the parent's trace under their subagent span).
+    // ------------------------------------------------------------------
+    ctx.on('session/event', (session, event) => {
+        const sessionId = session.id;
+        const child = children.get(sessionId);
+        if (child) {
+            // 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) {
+                reporter.updateSpan(child.span, { input: messageText(event.data) });
+                child.hasInput = true;
+            }
+            else if (event.type === 'subagent/descriptor') {
+                // The label is the delegation's model-authored description — content.
+                reporter.updateSpan(child.span, {
+                    name: config.captureContent && event.data.label
+                        ? `subagent: ${event.data.label}`
+                        : 'subagent',
+                    metadata: { mode: event.data.mode, provider: event.data.provider },
+                });
+            }
+            return;
+        }
+        switch (event.type) {
+            case 'turn/start': {
+                // A leftover entry is either a between-turns one-off trace or a turn
+                // whose `turn/end` was never seen (crash-orphaned): end and replace
+                // it — v5 spans only export on end, so the stale root must close to
+                // keep what it already recorded.
+                const stale = sessions.get(sessionId);
+                if (stale)
+                    reporter.endSpan(stale.trace);
+                const trace = reporter.openTrace({
+                    name: config.traceName,
+                    sessionId,
+                    metadata: { turn: event.data.turn },
+                });
+                if (trace)
+                    sessions.set(sessionId, { trace, hasInput: false });
+                break;
+            }
+            case 'user/message': {
+                const state = sessions.get(sessionId);
+                if (state && !state.hasInput && config.captureContent) {
+                    reporter.updateSpan(state.trace, { input: messageText(event.data) });
+                    state.hasInput = true;
+                }
+                break;
+            }
+            case 'assistant/message': {
+                const state = sessions.get(sessionId);
+                if (state && config.captureContent) {
+                    state.lastAssistantText = messageText(event.data.message) ?? state.lastAssistantText;
+                }
+                break;
+            }
+            case 'turn/end': {
+                const state = sessions.get(sessionId);
+                if (state) {
+                    sessions.delete(sessionId);
+                    // The turn's final answer becomes the trace's output; ending the
+                    // root span is what exports the trace (v5 exports spans on end).
+                    reporter.endSpan(state.trace, {
+                        output: state.lastAssistantText,
+                        metadata: { turn: event.data.turn, endReason: event.data.reason.kind },
+                    });
+                }
+                break;
+            }
+        }
+    });
+    ctx.on('session/disposed', (session) => {
+        const sessionId = session.id;
+        const state = sessions.get(sessionId);
+        sessions.delete(sessionId);
+        openToolSpans.delete(sessionId);
+        // End an abandoned root (crash-orphaned turn or between-turns one-off
+        // trace) — v5 spans only export on end, so dropping it open would lose
+        // everything it recorded.
+        if (state)
+            reporter.endSpan(state.trace);
+        // Children: keep the entry — background/continuable subagents dispose
+        // their session BEFORE subagent/end fires, and the span's close must ride
+        // subagent/end (disposing first would either leak the span or close it
+        // with a bogus WARNING, the latter seen on a healthy run in a real
+        // trace). A crashed run leaves the span open — it never exports.
+    });
+    // ------------------------------------------------------------------
+    // Generation per LLM call. The waterfall is SYNCHRONOUS (cordis returns
+    // the outermost listener's return value as the stream), so the listener
+    // must not be async — it returns an async-generator tee instead.
+    // ------------------------------------------------------------------
+    ctx.on('llm/stream', (options, next) => {
+        const parent = parentFor(options.sessionId);
+        // A session-less call's trace root has no session lifecycle to close it
+        // (it is never cached in `sessions`), so it rides this call's: un-ended
+        // spans never export in v5 — end it when the call settles.
+        const oneOffRoot = options.sessionId ? null : parent;
+        const generationName = options.purpose ? `llm-call [${options.purpose}]` : 'llm-call';
+        const generation = reporter.startGeneration(parent, {
+            name: generationName,
+            model: options.model,
+            input: config.captureContent
+                ? { messages: options.messages, system: options.system, tools: options.tools }
+                : { messageCount: options.messages.length },
+            modelParameters: modelParametersOf(options, config.captureContent),
+            metadata: { purpose: options.purpose },
+        });
+        // The rawest request a plugin can observe: the loop-built GenerateOptions
+        // verbatim, pre-adapter (the provider HTTP body is assembled inside the
+        // adapter — dsh exposes no seam for it). Nested under the generation,
+        // closed alongside it with the same outcome; its output is the collected
+        // chunk stream (the raw response at this seam).
+        const requestSpan = reporter.startSpan(generation, {
+            name: 'llm-request',
+            input: requestBodyOf(options, config.captureContent),
+            metadata: { provider: options.provider },
+        });
+        const rawChunks = [];
+        const closeRequest = (level, statusMessage) => {
+            reporter.endSpan(requestSpan, {
+                output: config.captureContent ? rawChunks : undefined,
+                level,
+                statusMessage,
+                metadata: { chunkCount: rawChunks.length },
+            });
+        };
+        let stream;
+        try {
+            stream = next();
+        }
+        catch (error) {
+            const statusMessage = contentMessage(config, messageOf(error));
+            closeRequest('ERROR', statusMessage);
+            reporter.endGeneration(generation, { level: 'ERROR', statusMessage });
+            reporter.endSpan(oneOffRoot);
+            throw error;
+        }
+        // Tee the chunk stream: replay every chunk unchanged, then close the
+        // generation from the terminal `finish` chunk and accumulated content.
+        // Stream failures surface as a `finish` chunk with an error/aborted
+        // reason rather than throwing; the single close in `finally` also covers
+        // consumer abandonment and mid-stream throws.
+        return (async function* () {
+            let text = '';
+            const toolCalls = [];
+            let usage;
+            let finish;
+            let completionStartTime;
+            let thrownMessage;
+            const outputBody = () => config.captureContent
+                ? toolCalls.length > 0
+                    ? { text, toolCalls }
+                    : text || undefined
+                : undefined;
+            try {
+                for await (const chunk of stream) {
+                    rawChunks.push(chunk);
+                    // TTFT is the first real token — block boundaries, usage frames and
+                    // empty heartbeat deltas are not completions (dsh's shared predicate).
+                    if (completionStartTime === undefined && isTokenDelta(chunk)) {
+                        completionStartTime = new Date();
+                    }
+                    switch (chunk.type) {
+                        case 'text-delta':
+                            text += chunk.text;
+                            break;
+                        case 'block-end':
+                            if (chunk.block.type === 'tool-call') {
+                                toolCalls.push({ name: chunk.block.name, arguments: chunk.block.arguments });
+                            }
+                            break;
+                        case 'usage':
+                            usage = chunk.usage;
+                            break;
+                        case 'finish':
+                            finish = chunk.reason;
+                            break;
+                    }
+                    yield chunk;
+                }
+            }
+            catch (error) {
+                // The raw message stays local — redaction gates what crosses to
+                // Langfuse, and `undefined` (not an empty string) is the no-throw
+                // discriminator.
+                thrownMessage = messageOf(error);
+                throw error;
+            }
+            finally {
+                const failure = finish && (finish.kind === 'error' || finish.kind === 'aborted') ? finish : undefined;
+                // No terminal finish chunk (the consumer abandoned the stream or
+                // the adapter cut it short): the call's outcome is unknown — mark
+                // it instead of posing as a normal completion.
+                let level = 'DEFAULT';
+                let statusMessage;
+                if (thrownMessage !== undefined) {
+                    level = 'ERROR';
+                    statusMessage = contentMessage(config, thrownMessage);
+                }
+                else if (failure) {
+                    level = failure.kind === 'aborted' ? 'WARNING' : 'ERROR';
+                    // `failure` is contractually required on error/aborted finishes,
+                    // but a non-conformant adapter must never turn observability into
+                    // a generator-level TypeError escaping into the agent loop.
+                    statusMessage = contentMessage(config, failure.failure?.message ?? 'unknown failure');
+                }
+                else if (!finish) {
+                    level = 'WARNING';
+                    statusMessage = 'stream closed before the terminal finish chunk';
+                }
+                closeRequest(level, statusMessage);
+                // Partial progress counts on every path: whatever streamed is kept.
+                reporter.endGeneration(generation, {
+                    name: enhanceWithFirstLine(generationName, text),
+                    output: outputBody(),
+                    usage,
+                    completionStartTime,
+                    level,
+                    statusMessage,
+                    metadata: {
+                        finishReason: finish?.kind,
+                        errorCode: failure?.failure?.code,
+                        incomplete: finish ? undefined : true,
+                        toolCallCount: toolCalls.length > 0 ? toolCalls.length : undefined,
+                    },
+                });
+                reporter.endSpan(oneOffRoot);
+            }
+        })();
+    });
+    // ------------------------------------------------------------------
+    // Span per tool dispatch. This waterfall IS async: `next()` returns the
+    // normalized dispatch result promise. Open spans are tracked per session
+    // so a subagent span opened mid-dispatch (foreground delegation) parents
+    // under the enclosing tool span.
+    // ------------------------------------------------------------------
+    ctx.on('tools/execute', async (exec, next) => {
+        const sessionId = exec.agent?.id;
+        const parent = parentFor(sessionId);
+        // An agent-less dispatch's trace root has no session lifecycle to close
+        // it — it rides this dispatch's (same one-off rule as llm/stream).
+        const oneOffRoot = sessionId ? null : parent;
+        // Argument summaries are argument content — they ride captureContent.
+        const argSummary = config.captureContent ? toolCallSummary(exec.arguments) : undefined;
+        const span = reporter.startSpan(parent, {
+            name: `tool:${exec.name}${argSummary ? ` [${argSummary}]` : ''}`,
+            input: config.captureContent ? exec.arguments : undefined,
+            metadata: { callId: exec.callId, toolName: exec.name },
+        });
+        if (sessionId && span) {
+            openToolSpans.set(sessionId, [...(openToolSpans.get(sessionId) ?? []), span]);
+        }
+        try {
+            const result = await next();
+            reporter.endSpan(span, {
+                output: config.captureContent ? result.content : undefined,
+                level: result.isError ? 'ERROR' : 'DEFAULT',
+                statusMessage: result.isError ? contentMessage(config, result.error.message) : undefined,
+                metadata: { errorCode: result.isError ? result.error.info?.code : undefined },
+            });
+            return result;
+        }
+        catch (error) {
+            reporter.endSpan(span, {
+                level: 'ERROR',
+                statusMessage: contentMessage(config, messageOf(error)),
+            });
+            throw error;
+        }
+        finally {
+            reporter.endSpan(oneOffRoot);
+            if (sessionId && span) {
+                const remaining = (openToolSpans.get(sessionId) ?? []).filter((s) => s !== span);
+                if (remaining.length > 0)
+                    openToolSpans.set(sessionId, remaining);
+                else
+                    openToolSpans.delete(sessionId);
+            }
+        }
+    });
+    // Durability checkpoint: the store awaits every session/flush listener.
+    ctx.on('session/flush', () => reporter.flush());
+    // Lifecycle: this cordis fork has no ready/dispose events — cleanup rides
+    // the fiber unload via ctx.effect() (shutdown() chains behind the lazy
+    // import, so a still-importing SDK is never shut down mid-construction).
+    ctx.effect(() => {
+        return async () => {
+            // End every tracked observation still open before shutting the exporter
+            // down — v5 spans only export on end, so unloading mid-turn (profile
+            // reload) would otherwise silently drop them. (An in-flight generation
+            // isn't tracked; its own tee finally closes it if the stream settles.)
+            for (const state of sessions.values())
+                reporter.endSpan(state.trace);
+            for (const child of children.values())
+                reporter.endSpan(child.span);
+            for (const spans of openToolSpans.values()) {
+                for (const span of spans)
+                    reporter.endSpan(span);
+            }
+            sessions.clear();
+            children.clear();
+            openToolSpans.clear();
+            await reporter.shutdown();
+        };
+    });
+    // Returning the init promise folds the lazy SDK import into this fiber's
+    // load transition: cordis awaits a plugin callback's thenable, so a boot
+    // that awaits plugin readiness can never observe the import window.
+    return reporter.ready;
+}

package/lib/types/client.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Langfuse reporter — thin synchronous wrapper over the Langfuse JS SDK v5's
+ * OpenTelemetry-based tracing API (`@langfuse/tracing` + `@langfuse/otel`),
+ * and the plugin's single no-throw seam: every method swallows SDK failures
+ * with a `[dsh-langfuse]` console.error so observability can never break the
+ * agent loop.
+ *
+ * v5's observations-first data model has no trace object: a trace is the root
+ * observation plus the correlating attributes every observation carries. So:
+ * - a "trace" here is a root `LangfuseSpan` created with {@link NO_PARENT} —
+ *   without it the SDK parents to whatever span is active in the host's
+ *   ambient OTEL context (e.g. an instrumented HTTP server around dsh),
+ *   smearing turn traces into foreign traces;
+ * - trace-level input/output/metadata live on that root span (the v5
+ *   replacement for the removed `trace.update()`), and the root must be
+ *   ENDED — spans only export on end, so an un-ended root never leaves the
+ *   process;
+ * - the correlating `session.id` attribute is stamped on every observation
+ *   via a handle-keyed WeakMap — the explicit-tree equivalent of v5's
+ *   context-scoped `propagateAttributes()`, which cannot wrap this plugin's
+ *   event-driven lifecycle.
+ *
+ * The SDK stack is a heavy optional peer set, so it loads via dynamic
+ * `import()` kicked off in the constructor — a disabled plugin never pays for
+ * it, and a missing or incompatible peer degrades the reporter to a no-op
+ * instead of breaking the plugin load. The exporter runs on an ISOLATED
+ * tracer provider (`setLangfuseTracerProvider`) rather than
+ * `provider.register()`: the process-global OTEL provider stays untouched and
+ * the host keeps its own tracing pipeline. {@link LangfuseReporter.ready}
+ * settles (never rejects) once the import+wiring finished: the plugin returns
+ * it from `apply()` so fiber readiness covers the import window, and
+ * {@link flush}/{@link shutdown} chain behind it. Observation calls landing
+ * before readiness are still dropped — a window that cannot exist once the
+ * plugin fiber has been awaited.
+ */
+import type { TokenUsage } from '@deepseek-ai/dsh-llm';
+import type { LangfuseGeneration, LangfuseSpan } from '@langfuse/tracing';
+export interface LangfuseConnectionConfig {
+    publicKey: string;
+    secretKey: string;
+    baseUrl: string;
+}
+export type ObservationLevel = 'DEFAULT' | 'WARNING' | 'ERROR';
+/** Any observation that can parent a span (trace root span or nested span/generation). */
+type Observation = LangfuseSpan | LangfuseGeneration;
+/**
+ * Map dsh token accounting onto Langfuse's `usageDetails`, keeping every
+ * bucket mutually exclusive (Langfuse's flat-bucket rule: `input` excludes
+ * `input_*`, `output` excludes `output_*`, `total` is the bucket sum —
+ * overlapping buckets double-count usage and inferred cost). dsh reports
+ * uncached input, separate cache buckets, and provider-style output that
+ * INCLUDES reasoning (verified in dsh-llm-deepseek@0.1.0-rc.7:
+ * `outputTokens: usage.completion_tokens`, with reasoning split out of
+ * `completion_tokens_details`), so the `output` bucket subtracts
+ * `reasoningTokens` into `output_reasoning`. Only `usageDetails` is sent.
+ */
+export declare function usageOf(usage: TokenUsage): Record<string, number>;
+export declare class LangfuseReporter {
+    private config;
+    private tracing;
+    private provider;
+    /**
+     * Observation → its trace's correlating attributes; children inherit their
+     * parent's. Stamped on every observation (`session.id`,
+     * `langfuse.trace.name`): v5's observations-first model wants trace context
+     * on every span (the v4 migration doc: "copied to every span where the name
+     * must be queryable"), and older Langfuse servers derive the trace row from
+     * ANY span carrying these — a root-only stamp can lose to child-derived
+     * trace events depending on ingestion order. This is the explicit
+     * handle-tree equivalent of v5's context-scoped propagateAttributes, which
+     * cannot wrap this plugin's event-driven lifecycle.
+     */
+    private traceContext;
+    /** Trace roots (created by openTrace) — the spans that may carry trace-level IO. */
+    private roots;
+    /** Settles (never rejects) once the lazy SDK import+wiring finished. */
+    readonly ready: Promise<void>;
+    constructor(config: LangfuseConnectionConfig);
+    /** Dynamically import the SDK and wire the isolated export pipeline. */
+    private init;
+    /**
+     * Stamp the trace-correlating attributes on an observation and record them
+     * for future children. `session.id` = `LangfuseOtelSpanAttributes.TRACE_SESSION_ID`
+     * (the OTEL semconv key); `langfuse.trace.name` = `TRACE_NAME`.
+     */
+    private stampTraceContext;
+    /** Open a trace (one per agent turn, or one-off for session-less calls). */
+    openTrace(input: {
+        name: string;
+        sessionId?: string;
+        metadata?: Record<string, unknown>;
+    }): LangfuseSpan | null;
+    /** Open a generation (one per LLM call) under any observation parent. */
+    startGeneration(parent: Observation | null, input: {
+        name: string;
+        model?: string;
+        input?: unknown;
+        modelParameters?: Record<string, string | number>;
+        metadata?: Record<string, unknown>;
+    }): LangfuseGeneration | null;
+    endGeneration(generation: LangfuseGeneration | null, update: {
+        name?: string;
+        output?: unknown;
+        usage?: TokenUsage;
+        completionStartTime?: Date;
+        level?: ObservationLevel;
+        statusMessage?: string;
+        metadata?: Record<string, unknown>;
+    }): void;
+    /** Open a span (one per tool dispatch, or a nested detail span) under any observation parent. */
+    startSpan(parent: Observation | null, input: {
+        name: string;
+        input?: unknown;
+        metadata?: Record<string, unknown>;
+    }): LangfuseSpan | null;
+    /**
+     * Merge fields into an open span — subagent enrichment (label, provider),
+     * and the trace root's input (a v5 trace IS its root span, so trace-level
+     * updates are span updates; OTEL attributes merge per key, so partial
+     * updates compose). On trace roots the input/output also rides the
+     * deprecated `langfuse.trace.*` attributes (setTraceIO): older Langfuse
+     * servers derive the trace row's IO from exactly those keys.
+     */
+    updateSpan(span: LangfuseSpan | null, update: {
+        name?: string;
+        input?: unknown;
+        metadata?: Record<string, unknown>;
+    }): void;
+    /**
+     * Close any span observation, trace roots included: final fields, then end —
+     * v5 spans only export on end, so an un-ended root never reaches Langfuse.
+     * On trace roots the output also rides the deprecated `langfuse.trace.*`
+     * attributes (setTraceIO) for older servers — same rule as updateSpan.
+     */
+    endSpan(span: LangfuseSpan | null, update?: {
+        output?: unknown;
+        level?: ObservationLevel;
+        statusMessage?: string;
+        metadata?: Record<string, unknown>;
+    }): void;
+    /** Drain buffered spans (the `session/flush` checkpoint). */
+    flush(): Promise<void>;
+    /** Shut the exporter down at fiber unload (provider.shutdown flushes internally). */
+    shutdown(): Promise<void>;
+}
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * dsh-langfuse — Langfuse observability for DeepSeek Harness.
+ *
+ * Instruments the documented seams, with zero core patches:
+ *
+ * - `llm/stream` waterfall  → one Langfuse **generation** per LLM call
+ *   (input = full request; output, token usage and finish reason collected
+ *   from the chunk stream), plus a nested `llm-request` **span** holding the
+ *   verbatim loop-built request and the collected chunk stream (the rawest
+ *   request/response a plugin can observe — the provider HTTP body is
+ *   assembled inside the adapter).
+ * - `tools/execute` waterfall → one Langfuse **span** per tool dispatch
+ *   (routed to the session's trace via `exec.agent.id` — the agent/session
+ *   shared identity).
+ * - `session/event` emit    → one Langfuse **trace** per agent turn
+ *   (`turn/start` opens a root span — in the v5 SDK the root observation IS
+ *   the trace — the turn's first `user/message` sets the input, `turn/end`
+ *   stamps the end reason and ends the root, which is what exports it).
+ * - subagent child sessions (`session/created` with `header.parentSession`)
+ *   ride the parent's trace: a `subagent` **span** opened under the enclosing
+ *   delegation tool span, the child's generations/tool spans nested under it,
+ *   closed at `subagent/end` (enriched by `subagent/start` and the child's
+ *   `subagent/descriptor` event).
+ *
+ * Event/waterfall shapes verified against the installed
+ * @deepseek-ai/dsh-{llm,session,tools,agent,subagent}@0.1.0-rc.7 package sources
+ * (types for shapes; `lib/*.js` for the session/created ordering claim).
+ *
+ * @module dsh-langfuse
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+export declare const name = "dsh-langfuse";
+/**
+ * Waterfall listeners only need the events to exist; no hard service
+ * dependency is declared so the plugin still loads in minimal compositions
+ * (it simply never observes anything). Add 'llm' / 'tools' to `inject` if you
+ * prefer fail-fast wiring.
+ */
+export declare const inject: string[];
+export declare const Config: Schema<Schemastery.ObjectS<{
+    enabled: Schema<boolean, boolean>;
+    publicKey: Schema<string, string>;
+    secretKey: Schema<string, string>;
+    baseUrl: Schema<string, string>;
+    traceName: Schema<string, string>;
+    /** Include full message/tool payloads in Langfuse IO. Disable to log metadata only. */
+    captureContent: Schema<boolean, boolean>;
+}>, Schemastery.ObjectT<{
+    enabled: Schema<boolean, boolean>;
+    publicKey: Schema<string, string>;
+    secretKey: Schema<string, string>;
+    baseUrl: Schema<string, string>;
+    traceName: Schema<string, string>;
+    /** Include full message/tool payloads in Langfuse IO. Disable to log metadata only. */
+    captureContent: Schema<boolean, boolean>;
+}>>;
+export interface LangfusePluginConfig {
+    enabled: boolean;
+    publicKey: string;
+    secretKey: string;
+    baseUrl: string;
+    traceName: string;
+    captureContent: boolean;
+}
+export declare function apply(ctx: Context, config: LangfusePluginConfig): Promise<void> | void;

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@amaster.ai/dsh-langfuse",
+  "version": "0.1.0",
+  "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",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "preview.png"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TGYD-helige/dsh-plugins.git",
+    "directory": "packages/dsh-langfuse"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-subagent": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.7",
+    "@langfuse/otel": "^5.10.1",
+    "@langfuse/tracing": "^5.10.1",
+    "@opentelemetry/sdk-trace-node": "^2.10.0"
+  },
+  "peerDependenciesMeta": {
+    "@langfuse/otel": {
+      "optional": true
+    },
+    "@langfuse/tracing": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-node": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-subagent": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.7",
+    "@langfuse/otel": "5.10.1",
+    "@langfuse/tracing": "5.10.1",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/sdk-trace-node": "^2.10.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": "^20.19 || ^22.12 || >=24.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}