pi-langfuse 1.6.1 → 1.7.0

package/README.md

@@ -273,10 +273,18 @@ This command makes a timeout-bounded authenticated request to Langfuse and, if i
 - Each user prompt within that session becomes a separate trace.
 - The trace contains the final assistant output shown in Pi.
 - Tool runs appear as tool observations with arguments, results, and error state.
+  Pi 1.0 nested calls (including codemode tools) are parented by `parentToolCallId`.
+  A tool's own model usage/cost appears in a child `tool-usage` generation; transcript totals that
+  include descendants are not ingested again. Pi's tool usage does not identify each nested model,
+  so these aggregate generations have no inferred model name or price.
 - LLM requests appear as generation observations, including usage and cost when the provider exposes them.
   Reasoning tokens are reported as their own usage bucket when `PI_LANGFUSE_SPLIT_REASONING_TOKENS` is enabled.
+  Virtual routing preserves `selectedModel`/`selectedProvider` alongside `actualModel`/`actualProvider`;
+  the generation model and `provider` metadata use the actual identity when available.
 - Pi 0.86 transcript-aware prompt/tool state appears as `system-state` events. Generations reference the
   effective prompt/tool state hashes, active tool count, update transport, and cache hit ratio.
+  State is refreshed before every provider request, including after lazy tool loading, and unchanged
+  state is deduplicated within an attempt.
 - Automatic retries are grouped under `agent-attempt` spans and the trace remains open until `agent_settled`.
 - Cache-warming decisions and persisted `cache_warm` usage are reported, including standalone session-grouped
   traces when warming happens while no user-request trace is active.

package/README_CN.md

@@ -254,10 +254,16 @@ pi list
 - 该会话中的每个用户提示词都会生成一个独立 trace。
 - trace 中会包含 Pi 实际显示的最终助手回复。
 - 工具执行会以工具观察节点展示参数、结果和错误状态。
+  Pi 1.0 的嵌套调用（含 codemode 内部工具）按 `parentToolCallId` 建立父子关系。
+  工具自身的模型用量和费用记录在子级 `tool-usage` generation 中，不会重复上报 transcript 中包含
+  后代工具的合计用量。Pi 的工具 usage 未标识每个内部模型，因此这些聚合节点不推断模型名称或价格。
 - 模型请求会以生成观察节点展示；如果提供商暴露相关信息，还会包含用量和成本。
   开启 `PI_LANGFUSE_SPLIT_REASONING_TOKENS` 后，推理 token 会作为独立用量桶上报。
+  虚拟模型路由分别记录 `selectedModel`/`selectedProvider` 和 `actualModel`/`actualProvider`；
+  获得实际模型身份后，generation 的 model 和 `provider` 元数据使用实际值。
 - Pi 0.86 的 transcript-aware system/tool 状态会作为 `system-state` 事件上报；generation 会引用有效的
   prompt/tool 状态指纹、活动工具数、更新传输方式和缓存命中率。
+  每次 provider 请求前都会刷新状态，覆盖工具延迟加载；同一 attempt 内的未变化状态不会重复生成事件。
 - 自动重试会归入 `agent-attempt` span，trace 会持续到 `agent_settled` 才结束。
 - cache warming 决策及持久化的 `cache_warm` 用量会被记录；若 warming 发生时没有活动的用户请求 trace，
   会创建按相同 session 分组的独立 trace。

package/index.ts

@@ -37,6 +37,7 @@ import {
   finishGenerationFromMessage,
   createFallbackGenerationFromTurn,
   recordTTFT,
+  recordGenerationIdentity,
 } from "./src/handlers/generation.js";
 import {
   startToolObservation,
@@ -145,13 +146,18 @@ export default async function (pi: ExtensionAPI) {
   }));
 
   pi.on("before_provider_request", async (event, ctx) => withSession(ctx, async () => {
-    await startGeneration(asRecord(event));
+    await recordSystemState(ctx, pi.getActiveTools(), false);
+    await startGeneration(asRecord(event), ctx.model);
   }));
 
   pi.on("after_provider_response", async (event, ctx) => withSession(ctx, async () => {
     updateGenerationMetadata(asRecord(event));
   }));
 
+  pi.on("provider_stream_event", (event, ctx) => withSession(ctx, () => {
+    recordGenerationIdentity(asRecord(event));
+  }));
+
   pi.on("message_update", async (event, ctx) => withSession(ctx, async () => {
     recordTTFT(asRecord(event));
     const message = getMessageFromEvent(asRecord(event));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-langfuse",
-	"version": "1.6.1",
+	"version": "1.7.0",
 	"description": "Langfuse extension for Pi coding agent",
 	"repository": {
 		"type": "git",
@@ -62,7 +62,7 @@
 		"node": ">=22"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "^0.86.0",
+		"@earendil-works/pi-coding-agent": "^1.0.0",
 		"tsx": "^4.19.0",
 		"typescript": "^6.0.3"
 	}

package/src/handlers/generation.ts

@@ -14,6 +14,7 @@ import {
   extractModelParameters,
   extractCacheMetrics,
   inferToolUpdateTransport,
+  extractModelIdentity,
 } from "../utils.js";
 import type { GenerationState, ObservationUpdate } from "../types.js";
 import { applyCapturePolicy } from "../capture-policy.js";
@@ -34,7 +35,7 @@ export function getOpenGeneration(): GenerationState | undefined {
   return undefined;
 }
 
-export async function startGeneration(event: Record<string, unknown>) {
+export async function startGeneration(event: Record<string, unknown>, selectedModel?: unknown) {
   if (state.isTracingDisabled || !state.agentState?.root) {
     return;
   }
@@ -43,11 +44,16 @@ export async function startGeneration(event: Record<string, unknown>) {
     const key = getRequestKey(event, `generation-${++state.agentState.generationSeq}`);
     const payload = getProviderPayload(event);
     const modelParameters = extractModelParameters(payload);
-    const model = String(event.model ?? event.modelId ?? state.currentModel ?? "");
-    const provider = String(event.provider ?? state.currentProvider ?? "");
+    const selected = extractModelIdentity(selectedModel ?? state.currentModel, selectedModel ? undefined : state.currentProvider);
+    const payloadModel = payload && typeof payload === "object" ? (payload as Record<string, unknown>).model : undefined;
+    const actual = extractModelIdentity(event.model ?? event.modelId ?? payloadModel, event.provider);
     const toolUpdateTransport = inferToolUpdateTransport(payload, (state.agentState.systemStateSequence ?? 0) > 1);
     const metadata = shapePayload({
-      provider,
+      provider: actual.provider ?? selected.provider,
+      selectedModel: selected.model,
+      selectedProvider: selected.provider,
+      actualModel: actual.model,
+      actualProvider: actual.provider,
       requestId: key,
       url: event.url,
       method: event.method,
@@ -81,7 +87,7 @@ export async function startGeneration(event: Record<string, unknown>) {
       name: "llm-generation",
       body: {
         input: captured.input,
-        model: model || undefined,
+        model: actual.model ?? selected.model,
         modelParameters,
         metadata: captured.metadata,
       },
@@ -172,6 +178,21 @@ export function recordTTFT(event: Record<string, unknown>) {
   }
 }
 
+/** Routing identity is available before the assistant message, including failed streams. */
+export function recordGenerationIdentity(event: Record<string, unknown>) {
+  const generation = getOpenGeneration();
+  if (!generation) return;
+  const actual = extractModelIdentity(event.model, event.provider);
+  if (!actual.model && !actual.provider) return;
+  if (generation.metadata.actualModel === actual.model && generation.metadata.actualProvider === actual.provider) return;
+  generation.metadata = applyCapturePolicy({ metadata: shapePayload({
+    ...generation.metadata,
+    ...(actual.model ? { actualModel: actual.model } : {}),
+    ...(actual.provider ? { provider: actual.provider, actualProvider: actual.provider } : {}),
+  }) as Record<string, unknown> }, getCapturePolicy()).metadata ?? {};
+  generation.observation.update({ model: actual.model, metadata: generation.metadata });
+}
+
 export async function finishGenerationFromMessage(event: Record<string, unknown>) {
   if (state.isTracingDisabled || !state.agentState) {
     return;
@@ -196,15 +217,17 @@ export async function finishGenerationFromMessage(event: Record<string, unknown>
   const costDetails = extractCostDetails({ ...event, message });
   const cacheMetrics = extractCacheMetrics({ ...event, message });
   const modelParameters = extractModelParameters(getProviderPayload(event)) ?? generation.modelParameters;
-  const model = String(message.model ?? event.model ?? state.currentModel ?? "");
+  const actual = extractModelIdentity(message.model ?? event.model, message.provider ?? event.provider);
   const update: ObservationUpdate = {
     output,
-    model: model || undefined,
+    model: actual.model ?? (generation.metadata.actualModel as string | undefined) ?? (state.currentModel || undefined),
     modelParameters,
     usageDetails,
     ...(costDetails ? { costDetails } : {}),
     metadata: {
       ...generation.metadata,
+      ...(actual.model ? { actualModel: actual.model } : {}),
+      ...(actual.provider ? { provider: actual.provider, actualProvider: actual.provider } : {}),
       finishReason: message.finishReason ?? message.stopReason ?? event.finishReason,
       ...cacheMetrics,
     },
@@ -235,13 +258,17 @@ export async function createFallbackGenerationFromTurn(event: Record<string, unk
     const costDetails = extractCostDetails({ ...event, message });
     const cacheMetrics = extractCacheMetrics({ ...event, message });
     const modelParameters = extractModelParameters(getProviderPayload(event));
-    const model = String(message.model ?? event.model ?? state.currentModel ?? "");
+    const actual = extractModelIdentity(message.model ?? event.model, message.provider ?? event.provider);
     const captured = applyCapturePolicy(
       {
         input: state.agentState.promptInput,
         output: extractAssistantOutput(message),
         metadata: {
-          provider: state.currentProvider || undefined,
+          provider: actual.provider ?? (state.currentProvider || undefined),
+          selectedModel: state.currentModel || undefined,
+          selectedProvider: state.currentProvider || undefined,
+          actualModel: actual.model,
+          actualProvider: actual.provider,
           sourceEvent: "turn_end",
           promptStateHash: state.agentState.promptStateHash,
           toolStateHash: state.agentState.toolStateHash,
@@ -260,7 +287,7 @@ export async function createFallbackGenerationFromTurn(event: Record<string, unk
       body: {
         input: captured.input,
         output: captured.output,
-        model: model || undefined,
+        model: actual.model ?? (state.currentModel || undefined),
         modelParameters,
         usageDetails,
         ...(costDetails ? { costDetails } : {}),

package/src/handlers/system-state.ts

@@ -73,7 +73,7 @@ export function initializeSystemStateTracking(ctx: any): void {
   }
 }
 
-export async function recordSystemState(ctx: any, activeTools: string[]): Promise<void> {
+export async function recordSystemState(ctx: any, activeTools: string[], emitUnchanged = true): Promise<void> {
   const agent = state.agentState;
   if (state.isTracingDisabled || !agent?.root) return;
 
@@ -133,6 +133,9 @@ export async function recordSystemState(ctx: any, activeTools: string[]): Promis
   const changed = isInitial || promptChanged || toolsChanged || systemMessages.length > 0;
   if (changed) session.systemStateSequence++;
 
+  // agent_start emits a snapshot; unchanged request hooks keep the existing reference.
+  if (!changed && !emitUnchanged && agent.systemStateSequence !== undefined) return;
+
   const capturePolicy = getCapturePolicy();
   const rawSystemUpdate = systemMessages.length > 0
     ? systemMessages.map(({ entryId, message }) => ({ entryId, ...message }))

package/src/handlers/tool.ts

@@ -11,6 +11,7 @@ import {
   estimatePayloadBytes,
   getCapturePolicy,
   getLimits,
+  extractToolUsage,
 } from "../utils.js";
 import { applyCapturePolicy, redactOptionsFor } from "../capture-policy.js";
 import { redactString } from "../redaction.js";
@@ -27,17 +28,19 @@ export async function startToolObservation(event: Record<string, unknown>) {
 
   try {
     const toolName = getToolName(event);
+    const parentToolCallId = typeof event.parentToolCallId === "string" ? event.parentToolCallId : undefined;
     const toolInput = getToolInput(event);
     const shapedInput = shapePayload(toolInput, { maxString: getLimits().maxToolPayload });
     const captured = applyCapturePolicy(
       {
         toolInput: shapedInput,
-        metadata: { toolName, toolCallId },
+        metadata: shapePayload({ toolName, toolCallId, parentToolCallId }) as Record<string, unknown>,
       },
       getCapturePolicy(),
     );
     const inputBytes = estimatePayloadBytes(captured.toolInput, getLimits().maxToolPayload);
-    const parent = state.agentState.activeTurn ?? state.agentState.activeAttempt ?? state.agentState.root;
+    const parentTool = parentToolCallId ? state.agentState.activeTools.get(parentToolCallId) : undefined;
+    const parent = parentTool?.observation ?? state.agentState.activeTurn ?? state.agentState.activeAttempt ?? state.agentState.root;
     const tool = await startChildObservation({
       parent,
       runtime: getRuntime,
@@ -56,6 +59,7 @@ export async function startToolObservation(event: Record<string, unknown>) {
       ended: false,
       startedAt: Date.now(),
       inputBytes,
+      parentToolCallId,
     });
   } catch (e) {
     console.warn("📊 Langfuse: Failed to start tool observation", e);
@@ -76,6 +80,8 @@ export async function finishToolObservation(event: Record<string, unknown>) {
   if (!activeTool || activeTool.ended) {
     return;
   }
+  // Claim completion before creating the usage child (which awaits the runtime).
+  activeTool.ended = true;
 
   const isError = Boolean(event.isError ?? event.error ?? event.status === "error");
   const output =
@@ -92,17 +98,47 @@ export async function finishToolObservation(event: Record<string, unknown>) {
     const captured = applyCapturePolicy(
       {
         toolOutput: shapedOutput,
-        metadata: {
+        metadata: shapePayload({
           toolName: activeTool.toolName,
           toolCallId,
+          parentToolCallId: activeTool.parentToolCallId,
           isError,
-        },
+        }) as Record<string, unknown>,
       },
       policy,
     );
     const outputBytes = estimatePayloadBytes(captured.toolOutput, getLimits().maxToolPayload);
     const durationMs = Math.max(0, Date.now() - activeTool.startedAt);
 
+    // Pi's tool_result and tool_execution_end carry only this tool's own usage.
+    // Do not consume transcript toolResult usage, which includes all descendants.
+    // A separate generation makes this cost visible on Langfuse versions that
+    // only account for usage/cost on generation observations.
+    const { usageDetails, costDetails } = extractToolUsage(event);
+    if (usageDetails || costDetails) {
+      try {
+        const usage = await startChildObservation({
+          parent: activeTool.observation,
+          runtime: getRuntime,
+          name: "tool-usage",
+          body: {
+            usageDetails,
+            costDetails,
+            metadata: applyCapturePolicy({ metadata: shapePayload({
+              toolName: activeTool.toolName,
+              toolCallId,
+              parentToolCallId: activeTool.parentToolCallId,
+              usageSource: "tool-result",
+            }) as Record<string, unknown> }, policy).metadata,
+          },
+          asType: "generation",
+        });
+        usage.end();
+      } catch (error) {
+        console.warn("📊 Langfuse: Failed to record tool usage", error);
+      }
+    }
+
     activeTool.observation
       .update({
         output: captured.toolOutput,
@@ -118,8 +154,6 @@ export async function finishToolObservation(event: Record<string, unknown>) {
         },
       })
       .end();
-    activeTool.ended = true;
-
     if (isError) {
       state.errorCount++;
       await sendScore("tool_is_error", 1, {

package/src/types.ts

@@ -133,6 +133,7 @@ export interface ToolState {
   ended: boolean;
   startedAt: number;
   inputBytes: number;
+  parentToolCallId?: string;
 }
 
 export interface AgentState {

package/src/utils.ts

@@ -593,6 +593,29 @@ export function extractCostDetails(messageOrEvent: Record<string, unknown>): Rec
   };
 }
 
+/** Accept both provider model ids and Pi Model objects without serializing the whole model. */
+export function extractModelIdentity(value: unknown, provider?: unknown): { model?: string; provider?: string } {
+  const record = value && typeof value === "object" ? value as Record<string, unknown> : undefined;
+  const model = record?.id ?? record?.model ?? value;
+  const actualProvider = provider ?? record?.provider;
+  return {
+    ...(typeof model === "string" && model ? { model } : {}),
+    ...(typeof actualProvider === "string" && actualProvider ? { provider: actualProvider } : {}),
+  };
+}
+
+/** Tool hooks report own usage; transcript toolResult messages also include descendants' usage. */
+export function extractToolUsage(event: Record<string, unknown>): {
+  usageDetails?: Record<string, number>;
+  costDetails?: Record<string, number>;
+} {
+  const result = event.result && typeof event.result === "object"
+    ? event.result as Record<string, unknown>
+    : {};
+  const source = { usage: event.usage ?? result.usage, cost: event.cost ?? result.cost };
+  return { usageDetails: extractUsage(source), costDetails: extractCostDetails(source) };
+}
+
 export function extractResponseMetadata(event: Record<string, unknown>): Record<string, unknown> {
   return shapePayload(
     {