@cat-factory/observability-langfuse 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Igor Savin
+
+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,41 @@
+# @cat-factory/observability-langfuse
+
+Opt-in [Langfuse](https://langfuse.com) trace sink for the Agent Architecture Board.
+
+It implements the runtime-neutral `LlmTraceSink` port from `@cat-factory/kernel`, so
+when wired into a facade every LLM call — container-agent calls (through the LLM proxy)
+**and** inline calls (requirements review, document planner, fragment selector, inline
+agent) — surfaces in Langfuse as a generation grouped under its run's trace, plus
+optional container tool spans.
+
+## Why fetch-only
+
+The sink talks to Langfuse's public **ingestion API** (`POST /api/public/ingestion`,
+HTTP Basic auth, batched JSON events) using only the global `fetch` / `crypto` /
+`btoa`. It deliberately does **not** depend on the official `langfuse` Node SDK or any
+`@opentelemetry/*` package — those rely on Node-only APIs that are unavailable on the
+Cloudflare Worker runtime (workerd). Using the raw ingestion API keeps the sink
+byte-for-byte identical on both the Worker and Node facades.
+
+## Behaviour
+
+- Never throws into the caller: every flush swallows its own errors (logging at most a
+  warning). Observability must never break agent work.
+- Honours the same `LLM_RECORD_PROMPTS` privacy switch as the local metric store: when
+  prompt recording is off, generations carry usage/timing/metadata but no prompt or
+  response bodies.
+
+## Usage
+
+```ts
+import { createLangfuseSink } from '@cat-factory/observability-langfuse'
+
+const sink = createLangfuseSink({
+  publicKey: env.LANGFUSE_PUBLIC_KEY,
+  secretKey: env.LANGFUSE_SECRET_KEY,
+  baseUrl: env.LANGFUSE_BASE_URL, // optional; defaults to Langfuse Cloud
+})
+```
+
+Wired into a facade via its container's `selectLangfuseSink(config)`; absent config ⇒
+the sink is never built and there is no external emission or behaviour change.

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import type { LlmGenerationEvent, LlmToolSpan, LlmToolSpanContext, LlmTraceSink } from '@cat-factory/kernel';
+/** Minimal structured logger (pino-compatible); optional. */
+export interface LangfuseLogger {
+    warn(obj: Record<string, unknown>, msg?: string): void;
+}
+export interface LangfuseSinkConfig {
+    /** Langfuse public key (`pk-lf-…`). */
+    publicKey: string;
+    /** Langfuse secret key (`sk-lf-…`). */
+    secretKey: string;
+    /** Host of the Langfuse instance. Default: Langfuse Cloud (`https://cloud.langfuse.com`). */
+    baseUrl?: string;
+    /** Optional logger for swallowed errors. */
+    logger?: LangfuseLogger;
+    /** Injectable fetch (tests); defaults to the global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+export declare class LangfuseTraceSink implements LlmTraceSink {
+    private readonly endpoint;
+    private readonly authorization;
+    private readonly logger?;
+    private readonly fetchImpl;
+    constructor(config: LangfuseSinkConfig);
+    recordGeneration(event: LlmGenerationEvent): Promise<void>;
+    recordToolSpans(context: LlmToolSpanContext, spans: LlmToolSpan[]): Promise<void>;
+    private send;
+}
+/** Build a {@link LangfuseTraceSink}. Returns the opt-in sink wired into a facade. */
+export declare function createLangfuseSink(config: LangfuseSinkConfig): LangfuseTraceSink;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,kBAAkB,EAClB,YAAY,EACb,MAAM,qBAAqB,CAAA;AAkD5B,6DAA6D;AAC7D,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACvD;AAED,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAA;IACjB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,gEAAgE;IAChE,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CACzB;AAkBD,qBAAa,iBAAkB,YAAW,YAAY;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;IAExC,YAAY,MAAM,EAAE,kBAAkB,EAMrC;IAEK,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD/D;IAEK,eAAe,CAAC,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBtF;YAEa,IAAI;CA4BnB;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,iBAAiB,CAEhF"}

package/dist/index.js

@@ -0,0 +1,168 @@
+// A fetch-based Langfuse trace sink. It speaks Langfuse's public **ingestion API**
+// (`POST /api/public/ingestion`, HTTP Basic auth = public:secret key, batched JSON
+// events) using only the global `fetch`/`crypto`/`btoa` — NO `langfuse` Node SDK and
+// NO `@opentelemetry/*`, both of which depend on Node-only APIs that are unavailable on
+// the Cloudflare Worker runtime (workerd). This keeps the sink byte-for-byte identical
+// across the Worker and Node facades, which is the whole reason it exists as its own
+// package: see `LlmTraceSink` in `@cat-factory/kernel`.
+//
+// Observability must never break the product, so every method swallows its own errors
+// (logging at most a warning) and the caller additionally schedules the call off the
+// response path. A failed flush drops that batch; it never propagates.
+//
+// Each `recordGeneration` posts its own small ingestion batch rather than buffering
+// across calls. This is deliberate: the Worker runtime is stateless per request (there
+// is no durable cross-request buffer to flush, and a `waitUntil`-scheduled POST can't
+// outlive its request), so a per-call POST is the only shape that stays identical across
+// the Worker and Node facades. Tool spans, which the backend already accumulates per
+// poll, ARE sent as one batch. Langfuse's ingestion API is built for this volume.
+//
+// IMPACT ANALYSIS — why per-call POST is safe for the execution hot path:
+//   - NOT on the hot path. The proxied feeder runs under `executionCtx.waitUntil`
+//     (`LlmProxyController`), scheduled AFTER the container's chat-completion response
+//     is returned (on Node `waitUntil` is a plain fire-and-forget); the inline feeder
+//     (`InstrumentedModelProvider`) dispatches AFTER `generateText` resolves. Inside
+//     `LlmObservabilityService.record` the POST is then dispatched detached (not
+//     awaited), so even the `waitUntil` window never blocks on the Langfuse round trip.
+//     The only synchronous cost added to any path is one object build + `JSON.stringify`
+//     — microseconds, never the network call.
+//   - NOT a source of execution brittleness. Every error is swallowed + logged, the
+//     fetch is bounded by SEND_TIMEOUT_MS, and nothing in the run lifecycle reads the
+//     sink's result — a Langfuse outage / slowness / 4xx drops a batch and nothing else.
+//   - The costs that DO exist are telemetry-side, not run-side: +1 detached subrequest
+//     per proxy invocation (~2 of the Worker's 1000-subrequest budget), negligible
+//     `waitUntil` CPU (I/O-bound, timeout-capped), and N calls ⇒ N POSTs — a very chatty
+//     run could brush Langfuse ingestion rate limits and drop some batches, degrading
+//     telemetry COMPLETENESS only, never the run. (Tool spans are batched per poll, so
+//     they don't multiply.)
+const DEFAULT_BASE_URL = 'https://cloud.langfuse.com';
+/**
+ * Hard ceiling on a single ingestion POST. Observability must never tie up the LLM
+ * path: the proxied feeder records under the platform's `waitUntil` budget and the
+ * inline feeder dispatches without awaiting, so a hung Langfuse endpoint must abort
+ * rather than dangle. A dropped batch is the documented best-effort worst case.
+ */
+const SEND_TIMEOUT_MS = 10_000;
+function iso(ms) {
+    return new Date(ms).toISOString();
+}
+function basicAuth(publicKey, secretKey) {
+    return `Basic ${btoa(`${publicKey}:${secretKey}`)}`;
+}
+export class LangfuseTraceSink {
+    endpoint;
+    authorization;
+    logger;
+    fetchImpl;
+    constructor(config) {
+        const base = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.endpoint = `${base}/api/public/ingestion`;
+        this.authorization = basicAuth(config.publicKey, config.secretKey);
+        this.logger = config.logger;
+        this.fetchImpl = config.fetchImpl ?? fetch;
+    }
+    async recordGeneration(event) {
+        // Group every call of a run under one trace (keyed by the execution id); inline
+        // single-shot calls (no execution) become their own standalone trace.
+        const traceId = event.executionId ?? crypto.randomUUID();
+        const generation = {
+            id: crypto.randomUUID(),
+            traceId,
+            name: event.agentKind,
+            startTime: iso(event.startedAt),
+            endTime: iso(event.endedAt),
+            model: event.model,
+            usage: {
+                input: event.promptTokens,
+                output: event.completionTokens,
+                total: event.totalTokens,
+                unit: 'TOKENS',
+            },
+            level: event.ok ? 'DEFAULT' : 'ERROR',
+            metadata: {
+                provider: event.provider,
+                agentKind: event.agentKind,
+                finishReason: event.finishReason,
+                workspaceId: event.workspaceId,
+            },
+        };
+        // Prompt/response bodies are present only when prompt recording is on (the same
+        // `LLM_RECORD_PROMPTS` switch the local store honours): omit empty bodies entirely.
+        if (event.input)
+            generation.input = event.input;
+        if (event.output)
+            generation.output = event.output;
+        if (event.errorMessage)
+            generation.statusMessage = event.errorMessage;
+        await this.send([
+            {
+                id: crypto.randomUUID(),
+                type: 'trace-create',
+                timestamp: iso(event.endedAt),
+                body: {
+                    id: traceId,
+                    // A run trace is upserted by every call it groups, so keep the trace body
+                    // stable across them: the per-call agent kind lives on each generation
+                    // (its `name` + metadata), NOT as a trace tag that the next call would clobber.
+                    name: event.executionId ? `run ${event.executionId}` : event.agentKind,
+                    metadata: { workspaceId: event.workspaceId },
+                },
+            },
+            {
+                id: crypto.randomUUID(),
+                type: 'generation-create',
+                timestamp: iso(event.endedAt),
+                body: generation,
+            },
+        ]);
+    }
+    async recordToolSpans(context, spans) {
+        // Tool spans are only meaningful as children of a run's trace.
+        if (!context.executionId || spans.length === 0)
+            return;
+        const traceId = context.executionId;
+        const batch = spans.map((span) => ({
+            id: crypto.randomUUID(),
+            type: 'span-create',
+            timestamp: iso(span.endedAt),
+            body: {
+                id: crypto.randomUUID(),
+                traceId,
+                name: span.tool,
+                startTime: iso(span.startedAt),
+                endTime: iso(span.endedAt),
+                level: span.ok ? 'DEFAULT' : 'ERROR',
+                metadata: { agentKind: context.agentKind },
+            },
+        }));
+        await this.send(batch);
+    }
+    async send(batch) {
+        try {
+            const res = await this.fetchImpl(this.endpoint, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.authorization,
+                },
+                body: JSON.stringify({ batch }),
+                // Bound the request so a hung endpoint can't tie up the caller's waitUntil
+                // budget; an abort lands in the catch below and drops the batch (best-effort).
+                signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+            });
+            // 207 = partial success (per-event errors in the body); anything else non-2xx is
+            // a hard failure. Either way we only log — observability never breaks the caller.
+            if (!res.ok && res.status !== 207) {
+                this.logger?.warn({ scope: 'langfuse', status: res.status }, 'langfuse: ingestion rejected batch');
+            }
+        }
+        catch (err) {
+            this.logger?.warn({ scope: 'langfuse', err: err instanceof Error ? err.message : String(err) }, 'langfuse: failed to post ingestion batch');
+        }
+    }
+}
+/** Build a {@link LangfuseTraceSink}. Returns the opt-in sink wired into a facade. */
+export function createLangfuseSink(config) {
+    return new LangfuseTraceSink(config);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@cat-factory/observability-langfuse",
+  "version": "0.6.0",
+  "description": "Opt-in Langfuse trace sink for the Agent Architecture Board. A fetch-based LlmTraceSink that streams LLM generations (and container tool spans) to Langfuse's ingestion API — runs unchanged on both the Cloudflare Worker (workerd) and Node facades.",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@cat-factory/kernel": "0.6.0"
+  },
+  "devDependencies": {
+    "typescript": "7.0.1-rc",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:run": "vitest run"
+  }
+}