oh-langfuse 0.1.52 → 0.1.53

package/langfuse_hook.py

@@ -924,7 +924,7 @@ def emit_turn(
 
             # Tool observations
             for tc in tool_calls:
-                in_obj = tc["input"]
+                in_obj = tc["input"]
                 # truncate tool input if it's a large string payload
                 if isinstance(in_obj, str):
                     in_obj, in_meta = truncate_text(in_obj)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "private": false,
   "type": "module",
   "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",

package/scripts/opencode-langfuse-setup.mjs

@@ -312,15 +312,17 @@ function getPatchedLangfuseDistIndexJs() {
     "const skillAgentPath = (detectedBy) => {",
     "  if (detectedBy === 'tool_call') return 'opencode_skill_tool';",
     "  if (detectedBy === 'slash_command') return 'opencode_slash_prompt';",
+    "  if (detectedBy === 'natural_language_request') return 'opencode_prompt_skill_name';",
     "  if (detectedBy === 'skill_file_path') return 'skill_file_path';",
     "  return detectedBy || 'metadata';",
     "};",
     "const skillInvocationMode = (detectedBy) => {",
     "  if (detectedBy === 'slash_command') return 'explicit_request';",
+    "  if (detectedBy === 'natural_language_request') return 'implicit_request';",
     "  if (detectedBy === 'tool_call' || detectedBy === 'plugin_event') return 'implicit';",
     "  return 'detected';",
     "};",
-    "const skillEventType = (detectedBy) => detectedBy === 'slash_command' ? 'requested' : (detectedBy === 'tool_call' || detectedBy === 'plugin_event' ? 'invoked' : 'detected');",
+    "const skillEventType = (detectedBy) => (detectedBy === 'slash_command' || detectedBy === 'natural_language_request') ? 'requested' : (detectedBy === 'tool_call' || detectedBy === 'plugin_event' ? 'invoked' : 'detected');",
     "const skillIdSegment = (name) => String(name || 'unknown').trim().replace(/[^A-Za-z0-9_.:-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'unknown';",
     "",
     "const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');",
@@ -373,6 +375,18 @@ function getPatchedLangfuseDistIndexJs() {
     "  return out;",
     "};",
     "",
+    "const detectPromptSkillRequests = (haystack, skills) => {",
+    "  const text = String(haystack || '');",
+    "  if (!text.trim()) return [];",
+    "  const out = [];",
+    "  for (const skillName of skills) {",
+    "    const escaped = escapeRegExp(skillName);",
+    "    const pattern = new RegExp(`(?:请\\\\s*)?(?:使用|调用|启用|采用)\\\\s*[\\\"'“”‘’]?${escaped}(?=$|[\\\\s,，。；;:：、])|\\\\b(?:use|invoke|run|apply)\\\\s+[\\\"']?${escaped}(?=$|[\\\\s,，。；;:：])`, 'i');",
+    "    if (pattern.test(text)) out.push({ name: skillName, skill_namespace: skillNamespace(skillName), detected_by: 'natural_language_request', skill_call_id: '' });",
+    "  }",
+    "  return out;",
+    "};",
+    "",
     "const detectOpencodeSkillUsages = (source, knownSkills = []) => {",
     "  const skills = normalizeSkillNames(knownSkills);",
     "  if (skills.length === 0) return [];",
@@ -393,6 +407,12 @@ function getPatchedLangfuseDistIndexJs() {
     "  }",
     "  found.push(...explicit);",
     "  const haystack = collectStrings(source).join('\\n');",
+    "  const promptSeen = new Set(explicit.map((usage) => usage.name));",
+    "  for (const usage of detectPromptSkillRequests(haystack, skills)) {",
+    "    if (promptSeen.has(usage.name)) continue;",
+    "    promptSeen.add(usage.name);",
+    "    found.push(usage);",
+    "  }",
     "  const pathSeen = new Set();",
     "  for (const match of haystack.matchAll(/(?:^|[\"'\\s])(?:[A-Za-z]:)?[^\"'\\n\\r]*[\\\\/]+([^\\\\/\"'\\n\\r]+)[\\\\/]+SKILL\\.md(?=$|[\"'\\s])/gi)) {",
     "    const skillName = match[1];",
@@ -495,9 +515,11 @@ function getPatchedLangfuseDistIndexJs() {
     "  sdk.start();",
     "  const metricsTracer = trace.getTracer('oh-langfuse-opencode-metrics');",
     "  const knownSkillNames = await collectKnownSkillNames();",
+    "  const startupSkillUsages = detectOpencodeSkillUsages(process.argv.join('\\n'), knownSkillNames);",
     "  const messageTextById = new Map();",
     "  const skillUsagesByMessageId = new Map();",
     "  const skillUsagesBySessionId = new Map();",
+    "  const startupSkillSessionIds = new Set();",
     "  const toolCallIdsByMessageId = new Map();",
     "  const toolCallIdsBySessionId = new Map();",
     "  const toolResultIdsByMessageId = new Map();",
@@ -566,6 +588,10 @@ function getPatchedLangfuseDistIndexJs() {
     "    const partType = part?.type ?? '';",
     "    const sessionId = pickEventString(part?.sessionID, part?.sessionId, payload?.sessionID, payload?.sessionId, payload?.session?.id, event?.sessionID, event?.sessionId);",
     "    const messageId = pickEventString(part?.messageID, part?.messageId, payload?.messageID, payload?.messageId, payload?.message?.id, event?.messageID, event?.messageId);",
+    "    if (sessionId && startupSkillUsages.length && !startupSkillSessionIds.has(sessionId)) {",
+    "      startupSkillSessionIds.add(sessionId);",
+    "      rememberSkillUsages(skillUsagesBySessionId, sessionId, startupSkillUsages);",
+    "    }",
     "    const skillDetectionSources = [part, payload, part?.state?.input, part?.input, payload?.input, part?.state?.metadata, payload?.metadata, part?.state?.file, part?.file];",
     "    const eventSkillUsages = detectOpencodeSkillUsages(skillDetectionSources, knownSkillNames);",
     "    rememberSkillUsages(skillUsagesByMessageId, messageId, eventSkillUsages);",

package/scripts/real-self-verify.mjs

@@ -339,6 +339,12 @@ function hasMetadataKey(item, key) {
   return metadataValue(item, key) !== undefined;
 }
 
+function metricInteractionId(item, target) {
+  return target === "opencode"
+    ? directMetadataValue(item, "interaction_id") || metadataValue(item, "interaction_id")
+    : metadataValue(item, "interaction_id");
+}
+
 function isAgentTurnObservation(item) {
   if (item?.name === "Agent Turn" || metadataValue(item, "interaction_count") === 1 || metadataValue(item, "interaction_count") === "1") {
     return true;
@@ -363,33 +369,76 @@ async function observationsForTrace(config, traceId, since) {
   return fallback.filter((item) => item.traceId === traceId || item.trace_id === traceId);
 }
 
-async function verifyMetricObservations(config, found, { since, target }) {
+function mergeMetricCandidates(items) {
+  const out = [];
+  const seen = new Set();
+  for (const item of items || []) {
+    if (!item || typeof item !== "object") continue;
+    const key = [idOf(item), item.name || "", item.traceId || item.trace_id || ""].join(":");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  return out;
+}
+
+async function recentMetricCandidates(config, since) {
+  const baseParams = { limit: 100, fromTimestamp: since.toISOString() };
+  const candidates = [];
+  for (const pathname of ["/traces"]) {
+    for (const params of [{ ...baseParams, userId: config.userId }, baseParams]) {
+      try {
+        candidates.push(...dataArray(await langfuseGetLenient(config, pathname, params)));
+      } catch (error) {
+        if (error.name === "AbortError" || error.status === 404) continue;
+        throw error;
+      }
+    }
+  }
+  return mergeMetricCandidates(candidates);
+}
+
+async function verifyMetricObservations(config, found, { since, target, marker = "" }) {
   const traceId = traceIdOfFound(found);
-  let observations = await observationsForTrace(config, traceId, since);
+  let observations = mergeMetricCandidates([...(await observationsForTrace(config, traceId, since)), found?.item]);
 
   if (!observations.length && Array.isArray(found?.item?.observations)) {
-    observations = found.item.observations.filter((item) => typeof item === "object");
+    observations = mergeMetricCandidates(found.item.observations.filter((item) => typeof item === "object"));
+  } else if (Array.isArray(found?.item?.observations)) {
+    observations = mergeMetricCandidates([
+      ...observations,
+      ...found.item.observations.filter((item) => typeof item === "object"),
+    ]);
+  }
+
+  let skillUseObservations = observations.filter((item) => item?.name === "Skill Use");
+  let interactions = observations.filter(isAgentTurnObservation);
+
+  if (!interactions.length) {
+    const recentRelated = (await recentMetricCandidates(config, since)).filter((item) => marker && containsMarker(item, marker));
+    observations = mergeMetricCandidates([...observations, ...recentRelated]);
+    skillUseObservations = observations.filter((item) => item?.name === "Skill Use");
+    interactions = observations.filter(isAgentTurnObservation);
   }
 
-  const skillUseObservations = observations.filter((item) => item?.name === "Skill Use");
   if (skillUseObservations.length) {
-    throw new Error(`Metric verification failed for ${target}: Skill Use observations should not be emitted anymore, found ${skillUseObservations.length}.`);
+    throw new Error(`Metric verification failed for ${target}: Skill Use observations should not be emitted as standalone metrics.`);
   }
 
-  const interactions = observations.filter(isAgentTurnObservation);
   if (!interactions.length) {
     throw new Error(`Metric verification failed for ${target}: Agent Turn observation was not found for trace ${traceId || found.id}.`);
   }
 
   const byInteractionId = new Map();
+  const seenInteractionIds = new Set();
   for (const item of interactions) {
-    const interactionId = target === "opencode"
-      ? directMetadataValue(item, "interaction_id") || metadataValue(item, "interaction_id")
-      : metadataValue(item, "interaction_id");
+    const interactionId = metricInteractionId(item, target);
     if (!interactionId) {
       throw new Error(`Metric verification failed for ${target}: Agent Turn is missing interaction_id.`);
     }
-    byInteractionId.set(interactionId, (byInteractionId.get(interactionId) || 0) + 1);
+    if (seenInteractionIds.has(interactionId)) continue;
+    seenInteractionIds.add(interactionId);
+    byInteractionId.set(interactionId, 1);
     for (const key of ["user_id", "token_metrics_available", "tool_call_count", "skill_use_count", "metrics_schema_version"]) {
       if (!hasMetadataKey(item, key)) {
         throw new Error(`Metric verification failed for ${target}: Agent Turn is missing ${key}.`);
@@ -415,12 +464,6 @@ async function verifyMetricObservations(config, found, { since, target }) {
     }
   }
 
-  for (const [interactionId, count] of byInteractionId.entries()) {
-    if (count !== 1) {
-      throw new Error(`Metric verification failed for ${target}: interaction_id ${interactionId} appeared ${count} times.`);
-    }
-  }
-
   return { traceId, interactionCount: interactions.length };
 }
 
@@ -558,7 +601,7 @@ async function main() {
 
     const found = await pollLangfuse(config, marker, { ...args, since, target });
     console.log(`[OK] Langfuse marker found for ${target}: ${found.kind} ${found.id || ""}`.trim());
-    const metrics = await verifyMetricObservations(config, found, { since, target });
+    const metrics = await verifyMetricObservations(config, found, { since, target, marker });
     console.log(`[OK] Langfuse metrics found for ${target}: Agent Turn x${metrics.interactionCount}`);
     results.push({ target, marker, langfuse: { kind: found.kind, id: found.id || "", traceId: metrics.traceId }, metrics });
   }