@narumitw/pi-langfuse 0.50.5 → 0.51.0

package/dist/public-api.d.ts

@@ -0,0 +1,4 @@
+import type { CreateLangfuseRuntimeOptions, LangfuseRuntime } from "./runtime-core.js";
+export { createPiLangfuseSession, type PiLangfuseSession, type PiLangfuseSessionOptions, } from "./pi-session.js";
+export type { CreateLangfuseRuntimeOptions, LangfuseRuntime, LangfuseRuntimeConfig, } from "./runtime-core.js";
+export declare function createLangfuseRuntime(options?: CreateLangfuseRuntimeOptions): Promise<LangfuseRuntime>;

package/dist/runtime-core.d.ts

@@ -0,0 +1,26 @@
+import type { TraceBackend } from "./tracing.js";
+export interface LangfuseRuntimeConfig {
+    publicKey?: string;
+    secretKey?: string;
+    baseUrl?: string;
+    environment?: string;
+    release?: string;
+}
+export interface CreateLangfuseRuntimeOptions {
+    config?: LangfuseRuntimeConfig;
+    env?: NodeJS.ProcessEnv | false;
+}
+export interface LangfuseRuntime {
+    readonly closed: boolean;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+type RuntimeSessionDisposer = (statusMessage: string) => void | Promise<void>;
+export interface LangfuseRuntimeInternal extends LangfuseRuntime {
+    readonly backend: TraceBackend;
+    registerSession(disposer: RuntimeSessionDisposer): () => void;
+}
+export declare function getLangfuseRuntimeInternal(runtime: LangfuseRuntime): LangfuseRuntimeInternal;
+export declare function createLangfuseRuntimeFromBackend(backend: TraceBackend): LangfuseRuntime;
+export declare function registerLangfuseRuntime(runtime: LangfuseRuntimeInternal): LangfuseRuntimeInternal;
+export {};

package/dist/runtime.d.ts

@@ -0,0 +1,22 @@
+import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { type LangfuseConfig } from "./config.js";
+import { type CreateLangfuseRuntimeOptions, type LangfuseRuntime } from "./runtime-core.js";
+import type { TraceBackend } from "./tracing.js";
+export type { CreateLangfuseRuntimeOptions, LangfuseRuntime, LangfuseRuntimeConfig, } from "./runtime-core.js";
+interface ResolvedRuntimeConfig {
+    publicKey: string;
+    secretKey: string;
+    baseUrl: string;
+    environment?: string;
+    release?: string;
+}
+export interface RuntimeFactories {
+    createProcessor(config: ResolvedRuntimeConfig): SpanProcessor;
+    createProvider(processor: SpanProcessor): NodeTracerProvider;
+    selectProvider(provider: NodeTracerProvider): void;
+}
+export declare function createLangfuseRuntime(options?: CreateLangfuseRuntimeOptions): Promise<LangfuseRuntime>;
+export declare function createProductionBackend(config: LangfuseConfig, factoryOverrides?: Partial<RuntimeFactories>): Promise<TraceBackend>;
+export declare function resolveLangfuseRuntimeConfig(options: CreateLangfuseRuntimeOptions): ResolvedRuntimeConfig;
+export declare function maskSecrets(data: unknown, secrets: readonly string[]): unknown;

package/dist/sanitizer.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_CAPTURE_BYTES: number;
+export declare function sanitizeTraceValue(value: unknown): unknown;

package/dist/tracing.d.ts

@@ -0,0 +1,202 @@
+export { MAX_CAPTURE_BYTES, sanitizeTraceValue } from "./sanitizer.js";
+export declare const TRACE_SCHEMA_VERSION = "2";
+export interface ObservationAttributes {
+    input?: unknown;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+    level?: "DEBUG" | "DEFAULT" | "WARNING" | "ERROR";
+    statusMessage?: string;
+    completionStartTime?: Date;
+    model?: string;
+    modelParameters?: Record<string, string | number>;
+    usageDetails?: Record<string, number>;
+    costDetails?: Record<string, number>;
+    version?: string;
+    name?: string;
+    sessionId?: string;
+    userId?: string;
+    tags?: string[];
+}
+export interface Observation {
+    readonly traceId?: string;
+    update(attributes: ObservationAttributes): Observation;
+    updateTrace?(attributes: ObservationAttributes): Observation;
+    end(endTime?: number): Observation;
+}
+export type ObservationType = "agent" | "generation" | "span" | "tool";
+export interface TraceBackend {
+    start(name: string, attributes: ObservationAttributes, options: {
+        asType: ObservationType;
+        parent?: Observation;
+        startTime?: Date;
+    }): Observation;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export interface TraceRecorderOptions {
+    sessionId: string;
+    userId?: string;
+    cwd: string;
+    mode: string;
+    captureContent: boolean;
+    traceName?: string;
+    tags?: readonly string[];
+    metadata?: Readonly<Record<string, unknown>>;
+    onTraceId?: (traceId: string) => void;
+}
+interface ModelDescriptor {
+    provider?: string;
+    id?: string;
+    api?: string;
+}
+export interface GitMetadata {
+    branch?: string;
+    commit?: string;
+    detached: boolean;
+}
+export interface ContextSnapshot {
+    leafId?: string | null;
+    contextUsage?: {
+        tokens: number | null;
+        contextWindow: number;
+        percent: number | null;
+    };
+}
+interface BeginAgentInput {
+    prompt: unknown;
+    images?: unknown;
+    model?: ModelDescriptor;
+    git?: GitMetadata;
+    snapshot?: ContextSnapshot;
+    requestId?: string;
+}
+interface AttemptInput {
+    reason?: string;
+}
+interface GenerationInput {
+    startedAt?: number;
+    payload?: unknown;
+    payloadStage?: "before_provider_request";
+    model?: ModelDescriptor;
+    thinkingLevel?: string;
+}
+interface AssistantMessage {
+    role: string;
+    content?: unknown;
+    provider?: string;
+    api?: string;
+    model?: string;
+    responseModel?: string;
+    responseId?: string;
+    usage?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        cacheWrite1h?: number;
+        reasoning?: number;
+        totalTokens?: number;
+        cost?: {
+            input?: number;
+            output?: number;
+            cacheRead?: number;
+            cacheWrite?: number;
+            total?: number;
+        };
+    };
+    stopReason?: string;
+    errorMessage?: string;
+}
+interface ToolResult {
+    content?: unknown;
+    details?: unknown;
+    isError?: boolean;
+}
+interface TurnResult {
+    message: {
+        role: string;
+        stopReason?: string;
+        errorMessage?: string;
+    };
+    toolResultCount: number;
+}
+interface CompactionStart {
+    reason: string;
+    willRetry: boolean;
+    tokensBefore?: number;
+    messagesToSummarize: number;
+    turnPrefixMessages: number;
+    branchEntries: number;
+    isSplitTurn: boolean;
+}
+interface CompactionFinish {
+    reason: string;
+    willRetry: boolean;
+    fromExtension: boolean;
+    tokensBefore?: number;
+    details?: unknown;
+    usage?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        totalTokens?: number;
+        cost?: {
+            input?: number;
+            output?: number;
+            cacheRead?: number;
+            cacheWrite?: number;
+            total?: number;
+        };
+    };
+}
+export declare class TraceRecorder {
+    private readonly backend;
+    private readonly context;
+    private root;
+    private attempt;
+    private attemptIndex;
+    private turn;
+    private turnIndex;
+    private generation;
+    private readonly tools;
+    private readonly duplicateToolIds;
+    private compaction;
+    private lastOutput;
+    private lastAssistant;
+    private lastAttemptOutcome;
+    private unresolvedToolErrors;
+    private startSnapshot;
+    private counters;
+    constructor(backend: TraceBackend, context: TraceRecorderOptions);
+    private startObservation;
+    hasActiveTrace(): boolean;
+    hasActiveAttempt(): boolean;
+    beginAgent(input: BeginAgentInput): void;
+    beginAttempt(input?: AttemptInput): void;
+    finishAttempt(message?: AssistantMessage): void;
+    beginTurn(turnIndex: number): void;
+    finishTurn(turnIndex: number, result: TurnResult): void;
+    beginGeneration(input?: GenerationInput): void;
+    recordProviderResponse(status: number, headers?: Record<string, string>): void;
+    markGenerationFirstOutput(timestamp?: number): void;
+    markGenerationEnd(endTime?: number): void;
+    finishAssistant(message: AssistantMessage): void;
+    beginTool(toolCallId: string, toolName: string, args?: unknown, startedAt?: number): void;
+    recordToolInput(toolCallId: string, input: unknown): void;
+    recordToolProgress(toolCallId: string, timestamp?: number): void;
+    finishTool(toolCallId: string, result: ToolResult): void;
+    beginCompaction(input: CompactionStart): void;
+    finishCompaction(input: CompactionFinish): void;
+    settle(snapshot?: ContextSnapshot): void;
+    interrupt(statusMessage: string, snapshot?: ContextSnapshot): void;
+    dispose(statusMessage?: string, snapshot?: ContextSnapshot): void;
+    private closeActiveTrace;
+    private closeAttempt;
+    private startToolObservation;
+    private closeTurn;
+    private closeTools;
+    private closeGeneration;
+    private closeCompaction;
+    private capture;
+}

package/package.json

@@ -1,61 +1,65 @@
 {
-	"name": "@narumitw/pi-langfuse",
-	"version": "0.50.5",
-	"description": "Pi extension that traces LLM generations and tool activity to Langfuse.",
-	"type": "module",
-	"license": "MIT",
-	"private": false,
-	"keywords": [
-		"pi-package",
-		"pi-extension",
-		"pi",
-		"langfuse",
-		"observability",
-		"tracing"
-	],
-	"files": [
-		"src",
-		"dist",
-		"README.md",
-		"LICENSE"
-	],
-	"pi": {
-		"extensions": [
-			"./dist/index.ts"
-		]
-	},
-	"piExtension": {
-		"lifecycle": "stable"
-	},
-	"scripts": {
-		"build": "node scripts/build-runtime.mjs",
-		"prepack": "npm run build",
-		"check": "npm run build && biome check .",
-		"format": "biome check --write .",
-		"typecheck": "tsc --noEmit"
-	},
-	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": "*"
-	},
-	"devDependencies": {
-		"@biomejs/biome": "2.5.10",
-		"@earendil-works/pi-coding-agent": "0.84.3",
-		"@types/node": "26.2.0",
-		"typescript": "7.0.2",
-		"esbuild": "0.28.2"
-	},
-	"dependencies": {
-		"@langfuse/otel": "^5.10.1",
-		"@langfuse/tracing": "^5.10.1",
-		"@narumitw/pi-tui-kit": "^0.59.0",
-		"@opentelemetry/api": "^1.9.1",
-		"@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
-		"@opentelemetry/sdk-trace-base": "^2.10.0",
-		"@opentelemetry/sdk-trace-node": "^2.10.0"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/narumiruna/pi-extensions",
-		"directory": "packages/pi-langfuse"
-	}
+  "name": "@narumitw/pi-langfuse",
+  "version": "0.51.0",
+  "description": "Pi extension that traces LLM generations and tool activity to Langfuse.",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "private": false,
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "langfuse",
+    "observability",
+    "tracing"
+  ],
+  "files": [
+    "src",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./dist/index.ts"
+    ]
+  },
+  "scripts": {
+    "build": "node scripts/build-runtime.mjs",
+    "prepack": "npm run build",
+    "check": "npm run build && biome check .",
+    "format": "biome check --write .",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@types/node": "26.6.2",
+    "typescript": "7.0.2",
+    "esbuild": "0.28.2"
+  },
+  "dependencies": {
+    "@langfuse/otel": "^5.11.1",
+    "@langfuse/tracing": "^5.11.1",
+    "@narumitw/pi-tui-kit": "^0.59.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/sdk-trace-base": "^2.11.0",
+    "@opentelemetry/sdk-trace-node": "^2.11.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/narumiruna/pi-extensions",
+    "directory": "packages/pi-langfuse"
+  }
 }