@agentmark-ai/shared-utils 0.3.1 → 0.3.3

package/dist/index.mjs

@@ -163,27 +163,26 @@ async function generateTypeDefinitionsV1_0(prompts) {
   for (const prompt of prompts) {
     const { path: promptPath, input_schema } = prompt;
     const name = getInterfaceName(promptPath);
-    let tools = {};
     try {
       let kind = "text";
       let output_schema = null;
+      let hasTools = false;
       if ("text_config" in prompt) {
         kind = "text";
-        tools = prompt.text_config.tools || {};
+        hasTools = Array.isArray(prompt.text_config.tools) ? prompt.text_config.tools.length > 0 : !!prompt.text_config.tools;
       } else if ("object_config" in prompt) {
         kind = "object";
-        tools = prompt.object_config.tools || {};
+        hasTools = Array.isArray(prompt.object_config.tools) ? prompt.object_config.tools.length > 0 : !!prompt.object_config.tools;
         output_schema = prompt.object_config.schema;
       } else if ("image_config" in prompt) {
         kind = "image";
-        tools = prompt.image_config.tools || {};
+        hasTools = Array.isArray(prompt.image_config.tools) ? prompt.image_config.tools.length > 0 : !!prompt.image_config.tools;
       }
       const compile = await getCompile();
       const inputInterface = input_schema ? await compile(input_schema, `${name}In`, {
         bannerComment: "",
         additionalProperties: false
       }) : `interface ${name}In { [key: string]: any }`;
-      const toolTypes = await generateToolTypes(tools);
       const outputInterface = output_schema ? await compile(output_schema, `${name}Out`, {
         bannerComment: "",
         additionalProperties: false
@@ -192,12 +191,11 @@ async function generateTypeDefinitionsV1_0(prompts) {
         inputInterface.replace("export interface", "interface"),
         outputInterface.replace("export type", "type").replace("export interface", "interface")
       );
-      output += toolTypes || "";
       output += `type ${name} = {
   kind: '${kind}';
   input:  ${name}In;
-  output: ${name}Out;${toolTypes ? `
-  tools?: Array<keyof Tools>;` : ""}
+  output: ${name}Out;${hasTools ? `
+  tools?: string[];` : ""}
 };
 
 `;
@@ -624,6 +622,7 @@ async function generateTypeDefinitions(prompts, language = "typescript") {
   return generateTypeDefinitionsV0(prompts);
 }
 async function fetchPromptsFrontmatter(options) {
+  var _a, _b, _c;
   if (options.local) {
     const baseUrl = `http://localhost:${options.local}`;
     try {
@@ -633,7 +632,8 @@ async function fetchPromptsFrontmatter(options) {
           `Failed to fetch prompt paths: ${pathsResponse.statusText}`
         );
       }
-      const { paths } = await pathsResponse.json();
+      const body = await pathsResponse.json();
+      const paths = (_c = (_b = (_a = body == null ? void 0 : body.data) == null ? void 0 : _a.paths) != null ? _b : body == null ? void 0 : body.paths) != null ? _c : [];
       return Promise.all(
         paths.map(async (promptPath) => {
           const templateResponse = await fetch(
@@ -699,34 +699,6 @@ async function fetchPromptsFrontmatter(options) {
   }
   throw new Error("Either --local or --root-dir must be specified");
 }
-async function generateToolTypes(tools) {
-  const toolArgTypes = [];
-  for (const [toolName, schema] of Object.entries(tools)) {
-    const typeName = `${getToolInterfaceName(toolName)}Args`;
-    try {
-      const compile = await getCompile();
-      const argInterface = schema.parameters ? await compile(schema.parameters, typeName, {
-        bannerComment: "",
-        additionalProperties: false
-      }) : `type ${typeName} = { ${Object.entries(schema.parameters || {}).map(([key]) => `${key}: any`).join("; ")} };`;
-      toolArgTypes.push(
-        argInterface.replace("export type", "type").replace("export interface", "interface")
-      );
-    } catch (error) {
-      console.error(`Error processing tool ${toolName}:`, error);
-      toolArgTypes.push(`type ${typeName} = { [key: string]: any };`);
-    }
-  }
-  if (Object.keys(tools).length > 0) {
-    const toolsInterface = `export interface Tools {
-${Object.keys(tools).map(
-      (toolName) => `  ${toolName}: { args: ${getToolInterfaceName(toolName)}Args };`
-    ).join("\n")}
-}`;
-    return toolArgTypes.join("\n\n") + "\n\n" + toolsInterface + "\n\n";
-  }
-  return null;
-}
 
 // src/normalizer/types.ts
 var SpanType = /* @__PURE__ */ ((SpanType2) => {
@@ -826,8 +798,7 @@ var KNOWN_METADATA_FIELDS = /* @__PURE__ */ new Set([
   "dataset_expected_output",
   "dataset_input",
   "prompt_name",
-  "props",
-  "commit_sha"
+  "props"
 ]);
 function parseMetadata(attributes, prefix = "agentmark.metadata.") {
   const result = {};
@@ -1612,7 +1583,7 @@ function parseAgentMarkAttributes(attributes, prefix = "agentmark.") {
   if (get("trace_name")) result.traceName = String(get("trace_name"));
   if (get("prompt_name")) result.promptName = String(get("prompt_name"));
   if (get("props")) result.props = String(get("props"));
-  if (get("span.kind")) result.kind = String(get("span.kind"));
+  if (get("span.kind")) result.semanticKind = String(get("span.kind"));
   if (get("dataset_run_id")) result.datasetRunId = String(get("dataset_run_id"));
   if (get("dataset_run_name")) result.datasetRunName = String(get("dataset_run_name"));
   if (get("dataset_item_name")) result.datasetItemName = String(get("dataset_item_name"));
@@ -1682,6 +1653,9 @@ var AgentMarkTransformer = class {
     if (operationName === OperationNames.CHAT || operationName === OperationNames.TEXT_COMPLETION) {
       return "GENERATION" /* GENERATION */;
     }
+    if (operationName === OperationNames.EMBEDDINGS) {
+      return "GENERATION" /* GENERATION */;
+    }
     if (span.name === SpanNames.CHAT || span.name.startsWith(SpanNames.CHAT + " ")) {
       return "GENERATION" /* GENERATION */;
     }
@@ -1711,6 +1685,7 @@ var AgentMarkTransformer = class {
    * Transform the span and extract normalized fields from GenAI attributes.
    */
   transform(_span, attributes) {
+    var _a;
     const result = {};
     const responseModel = attributes[GenAIAttributes.RESPONSE_MODEL];
     const requestModel = attributes[GenAIAttributes.REQUEST_MODEL];
@@ -1784,7 +1759,7 @@ var AgentMarkTransformer = class {
       } catch {
       }
     }
-    const amInput = attributes["agentmark.input"];
+    const amInput = (_a = attributes["agentmark.input"]) != null ? _a : attributes["agentmark.props"];
     if (amInput && typeof amInput === "string" && !result.input) {
       result.input = [{ role: "user", content: amInput }];
     }
@@ -1850,9 +1825,16 @@ var Attrs = {
   RESPONSE_FINISH_REASONS: "gen_ai.response.finish_reasons",
   USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
   USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
-  // v1.37.0+ content attributes
+  // v1.37.0+ content attributes (canonical OTel GenAI semantic conventions).
+  // SDKs that emit the AgentMark-scoped equivalents (`gen_ai.request.input`
+  // / `gen_ai.response.output` — used by `claude-agent-sdk-v0-adapter`) are
+  // also accepted here as fallbacks so an SDK picking either key set
+  // doesn't silently lose IO data on ingest. The canonical pair always wins
+  // when both are present.
   INPUT_MESSAGES: "gen_ai.input.messages",
   OUTPUT_MESSAGES: "gen_ai.output.messages",
+  REQUEST_INPUT_FALLBACK: "gen_ai.request.input",
+  RESPONSE_OUTPUT_FALLBACK: "gen_ai.response.output",
   SYSTEM_INSTRUCTIONS: "gen_ai.system_instructions",
   TOOL_DEFINITIONS: "gen_ai.tool.definitions",
   // Tool call attributes (v1.37.0+)
@@ -1917,6 +1899,7 @@ var OtelGenAiTransformer = class {
     return "SPAN" /* SPAN */;
   }
   transform(span, attributes) {
+    var _a, _b;
     const result = {};
     const model = attributes[Attrs.RESPONSE_MODEL] || attributes[Attrs.REQUEST_MODEL];
     if (model && typeof model === "string") {
@@ -1937,12 +1920,12 @@ var OtelGenAiTransformer = class {
     if (typeof temperature === "number") {
       result.settings = { ...result.settings, temperature };
     }
-    const inputMessages = attributes[Attrs.INPUT_MESSAGES];
+    const inputMessages = (_a = attributes[Attrs.INPUT_MESSAGES]) != null ? _a : attributes[Attrs.REQUEST_INPUT_FALLBACK];
     if (inputMessages && typeof inputMessages === "string") {
       const messages = normalizeMessages(inputMessages);
       if (messages) result.input = messages;
     }
-    const outputMessages = attributes[Attrs.OUTPUT_MESSAGES];
+    const outputMessages = (_b = attributes[Attrs.OUTPUT_MESSAGES]) != null ? _b : attributes[Attrs.RESPONSE_OUTPUT_FALLBACK];
     if (outputMessages && typeof outputMessages === "string") {
       const extracted = extractStructuredOutput(outputMessages);
       if (extracted) {
@@ -2104,6 +2087,83 @@ 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
+    map: {
+      "embed": "embedding",
+      "ai.embed": "embedding",
+      "generateText": "llm",
+      "streamText": "llm",
+      "generateObject": "llm",
+      "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.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) {
@@ -2182,6 +2242,7 @@ function normalizeSpan(resource, scope, span) {
   }
   const agentMarkAttributes = parseAgentMarkAttributes(allAttributes);
   Object.assign(normalized, agentMarkAttributes);
+  normalized.semanticKind = resolveSemanticKind(normalized, allAttributes);
   return normalized;
 }
 function normalizeOtlpSpans(resourceSpans) {
@@ -2201,6 +2262,7 @@ export {
   AgentMarkTransformer as ClaudeAgentTransformer,
   MastraTransformer,
   OtelGenAiTransformer,
+  SEMANTIC_KINDS,
   SpanType,
   TransformerRegistry,
   TypeClassifier,
@@ -2220,6 +2282,7 @@ export {
   parseMetadata,
   parseTokens,
   registry,
+  resolveSemanticKind,
   toFrontMatter,
   typeClassifier,
   verifySignature