@agentmark-ai/shared-utils 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -2367,13 +2367,38 @@ function extractGenericOutput(attributes) {
   }
   return { output: String(value) };
 }
+function parseDocumentMetadata(raw) {
+  let parsed = raw;
+  if (typeof raw === "string") {
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  return void 0;
+}
 function extractRetrievalDocuments(attributes) {
   const docs = [];
   for (const i of collectIndices(attributes, RETRIEVAL_PREFIX)) {
-    const content = attributes[`${RETRIEVAL_PREFIX}.${i}.document.content`];
-    if (typeof content === "string" && content.length > 0) docs.push(content);
-  }
-  return docs.length > 0 ? docs.join("\n\n") : void 0;
+    const base = `${RETRIEVAL_PREFIX}.${i}.document`;
+    const doc = {};
+    const id = attributes[`${base}.id`];
+    if (id !== void 0 && id !== null && String(id).length > 0) doc.id = String(id);
+    const content = attributes[`${base}.content`];
+    if (typeof content === "string" && content.length > 0) doc.content = content;
+    const score = toNumber(attributes[`${base}.score`]);
+    if (score !== void 0) doc.score = score;
+    const metadata = parseDocumentMetadata(attributes[`${base}.metadata`]);
+    if (metadata !== void 0) doc.metadata = metadata;
+    if (Object.keys(doc).length > 0) docs.push(doc);
+  }
+  return docs;
+}
+function retrievalDocumentsToText(documents) {
+  const text = documents.map((d) => d.content).filter((c) => typeof c === "string" && c.length > 0).join("\n\n");
+  return text.length > 0 ? text : void 0;
 }
 var OpenInferenceTransformer = class {
   classify(_span, attributes) {
@@ -2417,9 +2442,13 @@ var OpenInferenceTransformer = class {
     } else {
       Object.assign(result, extractGenericOutput(attributes));
     }
-    if (result.output === void 0) {
-      const docs = extractRetrievalDocuments(attributes);
-      if (docs) result.output = docs;
+    const documents = extractRetrievalDocuments(attributes);
+    if (documents.length > 0) {
+      if (result.outputObject === void 0) result.outputObject = { documents };
+      if (result.output === void 0) {
+        const text = retrievalDocumentsToText(documents);
+        if (text) result.output = text;
+      }
     }
     const toolName = attributes[Attrs2.TOOL_NAME];
     if (typeof toolName === "string" && toolName.length > 0) result.name = toolName;
@@ -2521,6 +2550,51 @@ function extractFromEvents(events, attrKey) {
   }
   return void 0;
 }
+function parseResultMetadata(raw) {
+  let parsed = raw;
+  if (typeof raw === "string") {
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  return void 0;
+}
+var VECTOR_RESULT_EVENT_NAMES = /* @__PURE__ */ new Set(["db.query.result", "db.search.result"]);
+function extractVectorResultDocuments(events) {
+  var _a, _b;
+  if (!events) return [];
+  const docs = [];
+  for (const event of events) {
+    if (!VECTOR_RESULT_EVENT_NAMES.has(event.name)) continue;
+    const a = (_a = event.attributes) != null ? _a : {};
+    const get = (field) => {
+      var _a2;
+      return (_a2 = a[`db.query.result.${field}`]) != null ? _a2 : a[`db.search.result.${field}`];
+    };
+    const doc = {};
+    const id = get("id");
+    if (id !== void 0 && id !== null && String(id).length > 0) doc.id = String(id);
+    const content = get("document");
+    if (typeof content === "string" && content.length > 0) doc.content = content;
+    const score = toNumber(get("score"));
+    if (score !== void 0) doc.score = score;
+    const distance = toNumber(get("distance"));
+    if (distance !== void 0) doc.distance = distance;
+    let metadata = parseResultMetadata(get("metadata"));
+    if (metadata === void 0) {
+      const entity = get("entity");
+      if (entity !== void 0 && entity !== null && String(entity).length > 0) {
+        metadata = (_b = parseResultMetadata(entity)) != null ? _b : { entity: String(entity) };
+      }
+    }
+    if (metadata !== void 0) doc.metadata = metadata;
+    if (Object.keys(doc).length > 0) docs.push(doc);
+  }
+  return docs;
+}
 function extractFinishReason(attributes) {
   const direct = attributes[Attrs3.RESPONSE_FINISH_REASON];
   if (direct !== void 0) {
@@ -2590,6 +2664,16 @@ var OpenLLMetryTransformer = class {
         if (eventCompletion) result.output = eventCompletion;
       }
     }
+    if (result.outputObject === void 0) {
+      const documents = extractVectorResultDocuments(span.events);
+      if (documents.length > 0) {
+        result.outputObject = { documents };
+        if (result.output === void 0) {
+          const text = documents.map((d) => d.content).filter((c) => typeof c === "string" && c.length > 0).join("\n\n");
+          if (text) result.output = text;
+        }
+      }
+    }
     const entityName = attributes[Attrs3.ENTITY_NAME];
     if (typeof entityName === "string" && entityName.length > 0) result.traceName = entityName;
     const metadata = {};
@@ -2609,6 +2693,115 @@ var OpenLLMetryTransformer = class {
   }
 };
 
+// src/normalizer/resolvers/semantic-kind-resolver.ts
+var SEMANTIC_KINDS = ["function", "llm", "tool", "agent", "retrieval", "embedding", "guardrail"];
+var VALID_KINDS = new Set(SEMANTIC_KINDS);
+var OPENINFERENCE_MAP = {
+  "CHAIN": "function",
+  "LLM": "llm",
+  "TOOL": "tool",
+  "AGENT": "agent",
+  "RETRIEVER": "retrieval",
+  "EMBEDDING": "embedding",
+  "GUARDRAIL": "guardrail",
+  "RERANKER": "retrieval"
+};
+var VECTOR_DB_SYSTEMS = /* @__PURE__ */ new Set([
+  "pinecone",
+  "qdrant",
+  "weaviate",
+  "milvus",
+  "chroma",
+  "chromadb",
+  "marqo",
+  "lancedb"
+]);
+var VECTOR_RESULT_EVENT_NAMES2 = /* @__PURE__ */ new Set(["db.query.result", "db.search.result"]);
+function hasVectorStoreSignature(attributes, events) {
+  var _a;
+  const dbSystem = (_a = attributes["db.system"]) != null ? _a : attributes["db.system.name"];
+  if (typeof dbSystem === "string" && VECTOR_DB_SYSTEMS.has(dbSystem.toLowerCase())) return true;
+  if (Object.keys(attributes).some((k) => k.startsWith("db.vector.query."))) return true;
+  if (events == null ? void 0 : events.some((e) => VECTOR_RESULT_EVENT_NAMES2.has(e.name))) return true;
+  return false;
+}
+var FRAMEWORK_MAPPINGS = [
+  {
+    key: "ai.operationId",
+    // Vercel AI SDK
+    // The AI SDK emits ai.operationId WITH the "ai." prefix (e.g.
+    // "ai.generateText"); accept both prefixed and unprefixed so generation
+    // wrappers resolve to "llm" instead of falling through to "function".
+    map: {
+      "embed": "embedding",
+      "ai.embed": "embedding",
+      "generateText": "llm",
+      "ai.generateText": "llm",
+      "streamText": "llm",
+      "ai.streamText": "llm",
+      "generateObject": "llm",
+      "ai.generateObject": "llm",
+      "streamObject": "llm",
+      "ai.streamObject": "llm"
+    }
+  },
+  {
+    key: "traceloop.span.kind",
+    // Traceloop / OpenLLMetry
+    map: { "LLM": "llm", "TOOL": "tool", "AGENT": "agent", "WORKFLOW": "function", "TASK": "function" }
+  },
+  {
+    key: "langchain.run_type",
+    // LangChain via OTLP
+    map: { "llm": "llm", "chat_model": "llm", "retriever": "retrieval", "tool": "tool", "chain": "function", "embedding": "embedding" }
+  },
+  {
+    key: "genkit:type",
+    // Firebase Genkit
+    map: { "model": "llm", "tool": "tool", "flow": "function", "retriever": "retrieval", "embedder": "embedding" }
+  }
+];
+function resolveSemanticKind(normalized, allAttributes) {
+  if (normalized.semanticKind && VALID_KINDS.has(normalized.semanticKind)) {
+    return normalized.semanticKind;
+  }
+  const oiKind = allAttributes["openinference.span.kind"];
+  if (oiKind) {
+    const mapped = OPENINFERENCE_MAP[String(oiKind).toUpperCase()];
+    if (mapped) return mapped;
+  }
+  for (const { key, map } of FRAMEWORK_MAPPINGS) {
+    const val = allAttributes[key];
+    if (val) {
+      const mapped = map[String(val)];
+      if (mapped) return mapped;
+    }
+  }
+  if (hasVectorStoreSignature(allAttributes, normalized.events)) {
+    return "retrieval";
+  }
+  const opName = allAttributes["gen_ai.operation.name"];
+  if (opName) {
+    const op = String(opName).toLowerCase();
+    if (op === "chat" || op === "text_completion" || op === "generate_content") return "llm";
+    if (op === "embeddings") return "embedding";
+  }
+  if (normalized.type === "GENERATION" /* GENERATION */) {
+    return "llm";
+  }
+  if (normalized.model) {
+    return "llm";
+  }
+  if (normalized.toolCalls && normalized.toolCalls.length > 0) {
+    return "tool";
+  }
+  const name = (normalized.name || "").toLowerCase();
+  if (/retriev|search|rag/i.test(name)) return "retrieval";
+  if (/embed/i.test(name)) return "embedding";
+  if (/guard|safety/i.test(name)) return "guardrail";
+  return "function";
+}
+
 // src/normalizer/transformers/dispatching/index.ts
 var OPENINFERENCE_INDEXED = /^llm\.(input_messages|output_messages|token_count)\./;
 var OPENLLMETRY_INDEXED = /^gen_ai\.(prompt|completion)\.\d+\./;
@@ -2633,20 +2826,25 @@ var DispatchingTransformer = class {
     this.openLLMetry = new OpenLLMetryTransformer();
     this.otelGenAi = new OtelGenAiTransformer();
   }
-  /** Choose the extractor for a span from its attribute signature. OpenInference
-   *  is checked before OpenLLMetry because its markers (`llm.*`,
-   *  `openinference.span.kind`) are more specific; the bare OTel GenAI
-   *  transformer is the catch-all. */
-  select(attributes) {
+  /** Choose the extractor for a span from its attribute/event signature.
+   *  OpenInference is checked before OpenLLMetry because its markers (`llm.*`,
+   *  `openinference.span.kind`) are more specific. Vector-store query spans
+   *  route to the OpenLLMetry extractor — they may carry no `traceloop.*`
+   *  marker (a bare Pinecone span is just `db.system` + `db.query.result`
+   *  events), so without this they'd fall through to the OTel-GenAI catch-all
+   *  and their result documents would be dropped. The bare OTel GenAI
+   *  transformer is the final catch-all. */
+  select(attributes, span) {
     if (isOpenInference(attributes)) return this.openInference;
     if (isOpenLLMetry(attributes)) return this.openLLMetry;
+    if (hasVectorStoreSignature(attributes, span == null ? void 0 : span.events)) return this.openLLMetry;
     return this.otelGenAi;
   }
   classify(span, attributes) {
-    return this.select(attributes).classify(span, attributes);
+    return this.select(attributes, span).classify(span, attributes);
   }
   transform(span, attributes) {
-    return this.select(attributes).transform(span, attributes);
+    return this.select(attributes, span).transform(span, attributes);
   }
 };
 
@@ -2730,93 +2928,6 @@ function extractResourceScopeSpan(resourceSpans) {
   return result;
 }
 
-// src/normalizer/resolvers/semantic-kind-resolver.ts
-var SEMANTIC_KINDS = ["function", "llm", "tool", "agent", "retrieval", "embedding", "guardrail"];
-var VALID_KINDS = new Set(SEMANTIC_KINDS);
-var OPENINFERENCE_MAP = {
-  "CHAIN": "function",
-  "LLM": "llm",
-  "TOOL": "tool",
-  "AGENT": "agent",
-  "RETRIEVER": "retrieval",
-  "EMBEDDING": "embedding",
-  "GUARDRAIL": "guardrail",
-  "RERANKER": "retrieval"
-};
-var FRAMEWORK_MAPPINGS = [
-  {
-    key: "ai.operationId",
-    // Vercel AI SDK
-    // The AI SDK emits ai.operationId WITH the "ai." prefix (e.g.
-    // "ai.generateText"); accept both prefixed and unprefixed so generation
-    // wrappers resolve to "llm" instead of falling through to "function".
-    map: {
-      "embed": "embedding",
-      "ai.embed": "embedding",
-      "generateText": "llm",
-      "ai.generateText": "llm",
-      "streamText": "llm",
-      "ai.streamText": "llm",
-      "generateObject": "llm",
-      "ai.generateObject": "llm",
-      "streamObject": "llm",
-      "ai.streamObject": "llm"
-    }
-  },
-  {
-    key: "traceloop.span.kind",
-    // Traceloop / OpenLLMetry
-    map: { "LLM": "llm", "TOOL": "tool", "AGENT": "agent", "WORKFLOW": "function", "TASK": "function" }
-  },
-  {
-    key: "langchain.run_type",
-    // LangChain via OTLP
-    map: { "llm": "llm", "chat_model": "llm", "retriever": "retrieval", "tool": "tool", "chain": "function", "embedding": "embedding" }
-  },
-  {
-    key: "genkit:type",
-    // Firebase Genkit
-    map: { "model": "llm", "tool": "tool", "flow": "function", "retriever": "retrieval", "embedder": "embedding" }
-  }
-];
-function resolveSemanticKind(normalized, allAttributes) {
-  if (normalized.semanticKind && VALID_KINDS.has(normalized.semanticKind)) {
-    return normalized.semanticKind;
-  }
-  const oiKind = allAttributes["openinference.span.kind"];
-  if (oiKind) {
-    const mapped = OPENINFERENCE_MAP[String(oiKind).toUpperCase()];
-    if (mapped) return mapped;
-  }
-  for (const { key, map } of FRAMEWORK_MAPPINGS) {
-    const val = allAttributes[key];
-    if (val) {
-      const mapped = map[String(val)];
-      if (mapped) return mapped;
-    }
-  }
-  const opName = allAttributes["gen_ai.operation.name"];
-  if (opName) {
-    const op = String(opName).toLowerCase();
-    if (op === "chat" || op === "text_completion" || op === "generate_content") return "llm";
-    if (op === "embeddings") return "embedding";
-  }
-  if (normalized.type === "GENERATION" /* GENERATION */) {
-    return "llm";
-  }
-  if (normalized.model) {
-    return "llm";
-  }
-  if (normalized.toolCalls && normalized.toolCalls.length > 0) {
-    return "tool";
-  }
-  const name = (normalized.name || "").toLowerCase();
-  if (/retriev|search|rag/i.test(name)) return "retrieval";
-  if (/embed/i.test(name)) return "embedding";
-  if (/guard|safety/i.test(name)) return "guardrail";
-  return "function";
-}
-
 // src/normalizer/type-classifier.ts
 var TypeClassifier = class {
   classify(span, attributes) {
@@ -2984,6 +3095,7 @@ export {
   findPromptFiles,
   generateTypeDefinitions,
   generateUnique8CharString,
+  hasVectorStoreSignature,
   messagesToPlainText,
   normalizeOtlpSpans,
   normalizeOtlpStatusCode,
@@ -2994,6 +3106,7 @@ export {
   parseTokens,
   registry,
   resolveSemanticKind,
+  retrievalDocumentsToText,
   toFrontMatter,
   typeClassifier,
   verifySignature