pi-langfuse 1.5.1 → 1.5.3

package/README.md

@@ -150,6 +150,53 @@ The package also includes a Langfuse CLI skill, so Langfuse data can be queried
 /pi-langfuse-langfuse <your-query>
 ```
 
+## Source Metadata
+
+Local prototype note: source metadata support in this installed package is a local prototype patch. A durable solution should be shipped through an upstream PR, a fork, or a maintained package version so reinstalling the extension does not lose the behavior.
+
+For Git-backed runs, the extension attaches safe source metadata to traces:
+
+```json
+{
+  "source_type": "git-repo",
+  "repo_identity": "owner/repo",
+  "repo_owner": "owner",
+  "repo_name": "repo",
+  "repo_root_name": "repo",
+  "git_branch": "main",
+  "git_commit": "abc123",
+  "git_remote_host": "github.com",
+  "git_remote_path": "owner/repo",
+  "metadata_source": "git-detection"
+}
+```
+
+`repo_identity` is `owner/repo`. `repo_name` is the repo name only and must not contain a slash.
+
+A Git repo may optionally provide `.pi-langfuse.metadata.json`. Overrides are whitelist-only; unknown keys are ignored. Allowed keys are:
+
+```text
+repo_identity
+repo_owner
+repo_name
+source_type
+service_name
+project_slug
+environment
+observability_owner
+```
+
+Repo-local overrides are used only after the working directory is confirmed to be inside a usable Git repo. If Git detection fails for any reason, including a missing Git command, corrupted repo, or non-Git folder, the extension ignores repo-local identity files and emits only:
+
+```json
+{
+  "source_type": "non-git",
+  "metadata_source": "non-git"
+}
+```
+
+The extension must not upload raw absolute local paths, credentialed remotes, tokens, unknown override keys, or folder names for non-Git folders.
+
 ## Troubleshooting
 
 ### No traces appearing?

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-langfuse",
-	"version": "1.5.1",
+	"version": "1.5.3",
 	"description": "Langfuse extension for Pi coding agent",
 	"repository": {
 		"type": "git",

package/src/handlers/agent.ts

@@ -4,6 +4,7 @@ import { ensureConfig } from "../config.js";
 import { shapePayload, truncate, extractFinalAssistant, extractAssistantOutput, getCapturePolicy } from "../utils.js";
 import { closeDanglingObservations } from "./tool.js";
 import { applyCapturePolicy } from "../capture-policy.js";
+import { collectSourceMetadata } from "../source-metadata.js";
 
 function stringMetadata(metadata: Record<string, unknown> | undefined): Record<string, string> | undefined {
   if (!metadata) {
@@ -67,11 +68,13 @@ export async function startAgentRun(event: Record<string, unknown>, ctx: any) {
       images: event.images,
       context: event.context ?? event.attachments,
     });
+    const sourceMetadata = collectSourceMetadata(cwd);
     const captured = applyCapturePolicy(
       {
         input: rawPromptInput,
         metadata: {
           cwd,
+          ...sourceMetadata,
           ...(state.currentModel ? { model: state.currentModel } : {}),
           ...(state.currentProvider ? { provider: state.currentProvider } : {}),
           sessionId: state.currentSessionId || undefined,
@@ -88,6 +91,7 @@ export async function startAgentRun(event: Record<string, unknown>, ctx: any) {
       activeGenerations: new Map(),
       generationOrder: [],
       activeTools: new Map(),
+      sourceMetadata,
       providerMetadataByRequest: new Map(),
     };
 
@@ -133,6 +137,7 @@ export async function finishAgentRun(event: Record<string, unknown> = {}) {
       output: rawOutput,
       metadata: {
         cwd: state.agentState.cwd,
+        ...(state.agentState.sourceMetadata ?? {}),
         completed: true,
         model: state.currentModel || undefined,
         provider: state.currentProvider || undefined,

package/src/handlers/generation.ts

@@ -11,6 +11,7 @@ import {
   extractUsage,
   extractCostDetails,
   getCapturePolicy,
+  extractModelParameters,
 } from "../utils.js";
 import type { GenerationState, ObservationUpdate } from "../types.js";
 import { applyCapturePolicy } from "../capture-policy.js";
@@ -39,6 +40,7 @@ export async function startGeneration(event: Record<string, unknown>) {
   try {
     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 metadata = shapePayload({
@@ -63,6 +65,7 @@ export async function startGeneration(event: Record<string, unknown>) {
       body: {
         input: captured.input,
         model: model || undefined,
+        modelParameters,
         metadata: captured.metadata,
       },
       asType: "generation",
@@ -73,6 +76,7 @@ export async function startGeneration(event: Record<string, unknown>) {
       requestKey: key,
       ended: false,
       metadata: captured.metadata ?? {},
+      modelParameters,
     });
     state.agentState.generationOrder.push(key);
   } catch (e) {
@@ -173,10 +177,12 @@ export async function finishGenerationFromMessage(event: Record<string, unknown>
 
   const usageDetails = extractUsage({ ...event, message });
   const costDetails = extractCostDetails({ ...event, message });
+  const modelParameters = extractModelParameters(getProviderPayload(event)) ?? generation.modelParameters;
   const model = String(message.model ?? event.model ?? state.currentModel ?? "");
   const update: ObservationUpdate = {
     output,
     model: model || undefined,
+    modelParameters,
     usageDetails,
     costDetails,
     metadata: {
@@ -202,6 +208,7 @@ export async function createFallbackGenerationFromTurn(event: Record<string, unk
   try {
     const usageDetails = extractUsage({ ...event, message });
     const costDetails = extractCostDetails({ ...event, message });
+    const modelParameters = extractModelParameters(getProviderPayload(event));
     const model = String(message.model ?? event.model ?? state.currentModel ?? "");
     const captured = applyCapturePolicy(
       {
@@ -223,6 +230,7 @@ export async function createFallbackGenerationFromTurn(event: Record<string, unk
         input: captured.input,
         output: captured.output,
         model: model || undefined,
+        modelParameters,
         usageDetails,
         costDetails,
         metadata: captured.metadata,

package/src/langfuse.ts

@@ -29,6 +29,7 @@ interface RestFallbackObservation {
   output?: unknown;
   metadata?: Record<string, unknown>;
   model?: string;
+  modelParameters?: Record<string, string | number>;
   usageDetails?: Record<string, number>;
   costDetails?: Record<string, number>;
   level?: "DEBUG" | "DEFAULT" | "WARNING" | "ERROR";
@@ -114,6 +115,9 @@ function applyObservationUpdate(record: RestFallbackObservation, body: Record<st
     record.metadata = mergeMetadata(record.metadata, body.metadata as Record<string, unknown>);
   }
   if (typeof body.model === "string") record.model = body.model;
+  if (body.modelParameters && typeof body.modelParameters === "object") {
+    record.modelParameters = body.modelParameters as Record<string, string | number>;
+  }
   if (body.usageDetails && typeof body.usageDetails === "object") {
     record.usageDetails = body.usageDetails as Record<string, number>;
   }
@@ -294,6 +298,7 @@ async function fallbackToRestIngestion(rt: LangfuseRuntime) {
         ? {
             completionStartTime: observation.completionStartTime,
             model: observation.model,
+            modelParameters: observation.modelParameters,
             usageDetails: observation.usageDetails,
             costDetails: observation.costDetails,
           }
@@ -330,7 +335,8 @@ async function fallbackToRestIngestion(rt: LangfuseRuntime) {
   }
 
   const responseBody = response as { errors?: unknown[] } | undefined;
-  const errors = Array.isArray(responseBody?.errors) ? responseBody.errors : [];
+  const responseErrors = responseBody?.errors;
+  const errors = Array.isArray(responseErrors) ? responseErrors : [];
   if (errors.length > 0) {
     console.warn("📊 Langfuse: REST fallback ingestion reported errors", errors);
   } else {

package/src/source-metadata.ts

@@ -0,0 +1,160 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+export type SourceMetadata = Record<string, string>;
+
+const OVERRIDE_KEYS = new Set([
+  "repo_identity",
+  "repo_owner",
+  "repo_name",
+  "source_type",
+  "service_name",
+  "project_slug",
+  "environment",
+  "observability_owner",
+]);
+
+function nonGitMetadata(): SourceMetadata {
+  return {
+    source_type: "non-git",
+    metadata_source: "non-git",
+  };
+}
+
+function runGit(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 2000,
+  }).trim();
+}
+
+function firstLine(value: string): string {
+  return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
+}
+
+export function sanitizeGitRemote(remoteUrl: string): Partial<Pick<SourceMetadata, "git_remote_host" | "git_remote_path">> {
+  const raw = firstLine(remoteUrl).replace(/\.git$/i, "");
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    const parsed = new URL(raw);
+    const path = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/i, "");
+    return parsed.hostname && path ? { git_remote_host: parsed.hostname, git_remote_path: path } : {};
+  } catch {
+    // Continue with scp-like SSH syntax, for example git@github.com:owner/repo.git.
+  }
+
+  const scpLike = raw.match(/^(?:[^@\s/:]+@)?([^:\s]+):(.+)$/);
+  if (scpLike) {
+    const host = scpLike[1];
+    const path = scpLike[2].replace(/^\/+/, "").replace(/\.git$/i, "");
+    return host && path && !path.includes("@") ? { git_remote_host: host, git_remote_path: path } : {};
+  }
+
+  return {};
+}
+
+function deriveIdentity(remotePath: string | undefined): Partial<Pick<SourceMetadata, "repo_identity" | "repo_owner" | "repo_name">> {
+  if (!remotePath) {
+    return {};
+  }
+  const parts = remotePath.split("/").filter(Boolean);
+  if (parts.length < 2) {
+    return {};
+  }
+  const repoName = parts[parts.length - 1];
+  const owner = parts[parts.length - 2];
+  if (!repoName || !owner || repoName.includes("/")) {
+    return {};
+  }
+  return {
+    repo_identity: `${owner}/${repoName}`,
+    repo_owner: owner,
+    repo_name: repoName,
+  };
+}
+
+function findRepoMetadataFile(cwd: string, gitRoot: string): string | undefined {
+  let current = cwd;
+  const root = gitRoot;
+  while (true) {
+    const candidate = join(current, ".pi-langfuse.metadata.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    if (current === root) {
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return undefined;
+}
+
+function readWhitelistedOverrides(cwd: string, gitRoot: string): SourceMetadata {
+  const path = findRepoMetadataFile(cwd, gitRoot);
+  if (!path) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+    const output: SourceMetadata = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (OVERRIDE_KEYS.has(key) && typeof value === "string" && value.trim()) {
+        output[key] = value.trim();
+      }
+    }
+    if (output.repo_name?.includes("/")) {
+      delete output.repo_name;
+    }
+    return output;
+  } catch {
+    return {};
+  }
+}
+
+export function collectSourceMetadata(cwd: string): SourceMetadata {
+  try {
+    const inside = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    if (inside !== "true") {
+      return nonGitMetadata();
+    }
+
+    const gitRoot = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    const commit = runGit(cwd, ["rev-parse", "HEAD"]);
+    const branch = runGit(cwd, ["branch", "--show-current"]);
+    const remote = runGit(cwd, ["config", "--get", "remote.origin.url"]);
+    const remoteMetadata = sanitizeGitRemote(remote);
+    const derivedIdentity = deriveIdentity(remoteMetadata.git_remote_path);
+    const overrides = readWhitelistedOverrides(cwd, gitRoot);
+
+    const metadata: SourceMetadata = {
+      source_type: "git-repo",
+      repo_root_name: basename(gitRoot),
+      ...(branch ? { git_branch: branch } : {}),
+      git_commit: commit,
+      ...remoteMetadata,
+      ...derivedIdentity,
+      ...overrides,
+      metadata_source: Object.keys(overrides).length > 0 ? "repo-file" : "git-detection",
+    };
+
+    if (metadata.repo_name?.includes("/")) {
+      delete metadata.repo_name;
+    }
+    if (!metadata.repo_identity && metadata.repo_owner && metadata.repo_name) {
+      metadata.repo_identity = `${metadata.repo_owner}/${metadata.repo_name}`;
+    }
+    return metadata;
+  } catch {
+    return nonGitMetadata();
+  }
+}

package/src/types.ts

@@ -25,6 +25,7 @@ export interface ObservationUpdate {
   output?: unknown;
   metadata?: Record<string, unknown>;
   model?: string;
+  modelParameters?: Record<string, string | number>;
   usageDetails?: Record<string, number>;
   usage?: Record<string, number>;
   costDetails?: Record<string, number>;
@@ -83,6 +84,7 @@ export interface GenerationState {
   requestKey: string;
   ended: boolean;
   metadata: Record<string, unknown>;
+  modelParameters?: Record<string, string | number>;
   ttftRecorded?: boolean;
 }
 
@@ -105,5 +107,6 @@ export interface AgentState {
   generationOrder: string[];
   activeTools: Map<string, ToolState>;
   latestAssistantOutput?: unknown;
+  sourceMetadata?: Record<string, unknown>;
   providerMetadataByRequest: Map<string, Record<string, unknown>>;
 }

package/src/utils.ts

@@ -35,7 +35,7 @@ const PAYLOAD_TOO_LARGE = "[payload too large]";
 
 export function shapePayload(
   value: unknown,
-  options: { maxString?: number; depth?: number; maxNodes?: number; redact?: boolean } = {},
+  options: { maxString?: number; depth?: number; maxNodes?: number; redact?: boolean; parseJson?: boolean } = {},
 ): unknown {
   const maxString = options.maxString ?? MAX_STRING_LENGTH;
   const depth = options.depth ?? MAX_DEPTH;
@@ -55,6 +55,9 @@ export function shapePayload(
 
     if (typeof item === "string") {
       const truncated = truncate(item, maxString);
+      if (options.parseJson === false) {
+        return truncated;
+      }
       const parsed = tryParseJson(truncated);
       if (parsed === truncated) {
         return truncated;
@@ -175,6 +178,63 @@ export function extractTextContent(content: unknown, maxLength?: number): string
   return maxLength ? truncate(text, maxLength) : text;
 }
 
+export function normalizeContentForLangfuse(content: unknown, api?: string): unknown {
+  if (!Array.isArray(content)) {
+    return content;
+  }
+
+  const toolCallItems = content.filter((item) => {
+    return item && typeof item === "object" && (item as { type?: string }).type === "toolCall";
+  });
+  if (toolCallItems.length === 0) {
+    return content;
+  }
+
+  const text = content
+    .map((item) => {
+      if (!item || typeof item !== "object") return "";
+      const block = item as { type?: string; text?: string };
+      return block.type === "text" && typeof block.text === "string" ? block.text : "";
+    })
+    .filter(Boolean)
+    .join("");
+
+  if (api === "anthropic-messages") {
+    const blocks: unknown[] = [];
+    if (text) {
+      blocks.push({ type: "text", text });
+    }
+    for (const item of toolCallItems) {
+      const toolCall = item as { id?: unknown; name?: unknown; arguments?: unknown };
+      const toolInput = shapePayload(toolCall.arguments, { parseJson: false });
+      blocks.push({
+        type: "tool_use",
+        id: String(toolCall.id ?? ""),
+        name: String(toolCall.name ?? "tool"),
+        input: toolInput,
+      });
+    }
+    return blocks;
+  }
+
+  return {
+    role: "assistant",
+    content: text || null,
+    tool_calls: toolCallItems.map((item) => {
+      const toolCall = item as { id?: unknown; name?: unknown; arguments?: unknown };
+      const toolArguments = shapePayload(toolCall.arguments ?? {}, { parseJson: false });
+      return {
+        id: String(toolCall.id ?? ""),
+        type: "function",
+        function: {
+          name: String(toolCall.name ?? "tool"),
+          arguments: typeof toolArguments === "string" ? toolArguments : JSON.stringify(toolArguments),
+        },
+      };
+    }),
+  };
+}
+
 export function extractToolCalls(message: Record<string, unknown>): unknown | undefined {
   return (
     message.toolCalls ??
@@ -182,7 +242,7 @@ export function extractToolCalls(message: Record<string, unknown>): unknown | un
     message.function_calls ??
     (message.content && Array.isArray(message.content)
       ? message.content.filter((block) => {
-          return block && typeof block === "object" && ["tool_use", "tool_call"].includes(String((block as { type?: string }).type));
+          return block && typeof block === "object" && ["tool_use", "tool_call", "toolCall"].includes(String((block as { type?: string }).type));
         })
       : undefined)
   );
@@ -194,6 +254,11 @@ export function extractAssistantOutput(message: unknown): unknown | undefined {
   }
 
   const msg = message as Record<string, unknown>;
+  const normalizedContent = normalizeContentForLangfuse(msg.content, typeof msg.api === "string" ? msg.api : undefined);
+  if (normalizedContent !== msg.content) {
+    return shapePayload(normalizedContent, { parseJson: false });
+  }
+
   const text = extractTextContent(msg.content);
   if (text) {
     return text;
@@ -261,6 +326,33 @@ export function getProviderPayload(event: Record<string, unknown>): unknown {
   return event.request ?? event.payload ?? event.body ?? event.providerPayload ?? event.messages ?? event;
 }
 
+export function extractModelParameters(payload: unknown): Record<string, string | number> | undefined {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return undefined;
+  }
+
+  const params: Record<string, string | number> = {};
+  const record = payload as Record<string, unknown>;
+  for (const key of [
+    "temperature",
+    "top_p",
+    "topP",
+    "max_tokens",
+    "maxTokens",
+    "max_completion_tokens",
+    "presence_penalty",
+    "frequency_penalty",
+    "reasoning_effort",
+  ]) {
+    const value = record[key];
+    if (typeof value === "string" || typeof value === "number") {
+      params[key] = value;
+    }
+  }
+
+  return Object.keys(params).length > 0 ? params : undefined;
+}
+
 export function getMessageFromEvent(event: Record<string, unknown>): Record<string, unknown> | undefined {
   if (event.message && typeof event.message === "object") {
     return event.message as Record<string, unknown>;