@agentmark-ai/shared-utils 0.3.0 → 0.3.2

package/dist/index.js

@@ -35,6 +35,8 @@ __export(index_exports, {
   AiSdkTransformer: () => AiSdkTransformer,
   ClaudeAgentTransformer: () => AgentMarkTransformer,
   MastraTransformer: () => MastraTransformer,
+  OtelGenAiTransformer: () => OtelGenAiTransformer,
+  SEMANTIC_KINDS: () => SEMANTIC_KINDS,
   SpanType: () => SpanType,
   TransformerRegistry: () => TransformerRegistry,
   TypeClassifier: () => TypeClassifier,
@@ -54,6 +56,7 @@ __export(index_exports, {
   parseMetadata: () => parseMetadata,
   parseTokens: () => parseTokens,
   registry: () => registry,
+  resolveSemanticKind: () => resolveSemanticKind,
   toFrontMatter: () => toFrontMatter,
   typeClassifier: () => typeClassifier,
   verifySignature: () => verifySignature
@@ -360,7 +363,326 @@ ${typeMapping.join(",\n")}
 var isNewFormat = (frontmatter) => {
   return frontmatter["text_config"] || frontmatter["object_config"] || frontmatter["image_config"];
 };
-async function generateTypeDefinitions(prompts) {
+function pythonPrimitiveType(schemaType) {
+  const map = {
+    string: "str",
+    number: "float",
+    integer: "int",
+    boolean: "bool",
+    null: "None"
+  };
+  return map[schemaType] || "Any";
+}
+function propToPascal(prop) {
+  return prop.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function schemaToPythonType(schema, parentClass, propKey, collected) {
+  if (!schema) return "Any";
+  const union = schema.anyOf || schema.oneOf;
+  if (union) {
+    const nullIdx = union.findIndex((v) => v.type === "null");
+    const hasNull = nullIdx >= 0;
+    const others = union.filter((_, i) => i !== nullIdx);
+    if (hasNull && others.length === 1) {
+      return `${schemaToPythonType(others[0], parentClass, propKey, collected)} | None`;
+    }
+    const parts = others.map(
+      (v, i) => schemaToPythonType(v, parentClass, `${propKey}${i}`, collected)
+    );
+    if (hasNull) parts.push("None");
+    return parts.join(" | ");
+  }
+  if (Array.isArray(schema.type)) {
+    const hasNull = schema.type.includes("null");
+    const nonNull = schema.type.filter((t) => t !== "null");
+    if (nonNull.length === 1 && nonNull[0] === "object" && schema.properties) {
+      const clsName = `${parentClass}${propToPascal(propKey)}`;
+      collected.push(buildTypedDict(clsName, schema, collected));
+      return hasNull ? `${clsName} | None` : clsName;
+    }
+    if (nonNull.length === 1 && nonNull[0] === "array" && schema.items) {
+      const item = schemaToPythonType(
+        schema.items,
+        parentClass,
+        propKey,
+        collected
+      );
+      return hasNull ? `list[${item}] | None` : `list[${item}]`;
+    }
+    const base = nonNull.length === 1 ? pythonPrimitiveType(nonNull[0]) : nonNull.map(pythonPrimitiveType).join(" | ");
+    return hasNull ? `${base} | None` : base;
+  }
+  switch (schema.type) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "null":
+      return pythonPrimitiveType(schema.type);
+    case "array": {
+      const item = schema.items ? schemaToPythonType(schema.items, parentClass, propKey, collected) : "Any";
+      return `list[${item}]`;
+    }
+    case "object": {
+      if (!schema.properties || Object.keys(schema.properties).length === 0) {
+        return "dict[str, Any]";
+      }
+      const clsName = `${parentClass}${propToPascal(propKey)}`;
+      collected.push(buildTypedDict(clsName, schema, collected));
+      return clsName;
+    }
+    default:
+      if (schema.properties) {
+        const clsName = `${parentClass}${propToPascal(propKey)}`;
+        collected.push(buildTypedDict(clsName, schema, collected));
+        return clsName;
+      }
+      return "Any";
+  }
+}
+function buildTypedDict(className, schema, collected) {
+  const props = schema.properties || {};
+  const requiredSet = new Set(schema.required || []);
+  const lines = [];
+  const desc = schema.description;
+  if (desc) {
+    lines.push(`class ${className}(TypedDict):`);
+    lines.push(`    """${desc}"""`);
+  } else {
+    lines.push(`class ${className}(TypedDict):`);
+  }
+  const entries = Object.entries(props);
+  if (entries.length === 0) {
+    lines.push("    pass");
+    return lines.join("\n");
+  }
+  for (const [key, propSchema] of entries) {
+    const pyType = schemaToPythonType(
+      propSchema,
+      className,
+      key,
+      collected
+    );
+    const isRequired = requiredSet.has(key);
+    const annotation = isRequired ? pyType : `NotRequired[${pyType}]`;
+    const propDesc = propSchema.description;
+    if (propDesc) {
+      const prefix = `    ${key}: ${annotation}  # `;
+      const maxDesc = 99 - prefix.length;
+      if (maxDesc > 10) {
+        const shortDesc = propDesc.length > maxDesc ? propDesc.substring(0, maxDesc - 3) + "..." : propDesc;
+        lines.push(`${prefix}${shortDesc}`);
+      } else {
+        lines.push(`    ${key}: ${annotation}`);
+      }
+    } else {
+      lines.push(`    ${key}: ${annotation}`);
+    }
+  }
+  return lines.join("\n");
+}
+function generatePythonToolTypes(tools) {
+  if (Object.keys(tools).length === 0) return null;
+  const collected = [];
+  for (const [toolName, schema] of Object.entries(tools)) {
+    const argsName = `${getToolInterfaceName(toolName)}Args`;
+    if (schema.parameters && schema.parameters.properties) {
+      collected.push(buildTypedDict(argsName, schema.parameters, collected));
+    } else {
+      collected.push(`class ${argsName}(TypedDict):
+    pass`);
+    }
+  }
+  const toolLines = Object.keys(tools).map((name) => `    ${name}: ${getToolInterfaceName(name)}Args`).join("\n");
+  collected.push(`class Tools(TypedDict):
+${toolLines}`);
+  return collected.join("\n\n\n");
+}
+function buildPythonHeader(body) {
+  const imports = ["TypedDict"];
+  if (body.includes("NotRequired[")) imports.push("NotRequired");
+  if (body.includes("Literal[")) imports.push("Literal");
+  if (/\bAny\b/.test(body)) imports.push("Any");
+  imports.sort();
+  return `# Auto-generated types from AgentMark
+# Do not edit this file directly
+
+from __future__ import annotations
+
+from typing import ${imports.join(", ")}
+
+
+`;
+}
+async function generatePythonTypeDefinitionsV1_0(prompts) {
+  const allClasses = [];
+  const typeMapping = [];
+  for (const prompt of prompts) {
+    const { path: promptPath, input_schema } = prompt;
+    const name = getInterfaceName(promptPath);
+    try {
+      let kind = "text";
+      let outputSchema = null;
+      let tools = {};
+      if ("text_config" in prompt) {
+        kind = "text";
+        tools = prompt.text_config.tools || {};
+      } else if ("object_config" in prompt) {
+        kind = "object";
+        tools = prompt.object_config.tools || {};
+        outputSchema = prompt.object_config.schema;
+      } else if ("image_config" in prompt) {
+        kind = "image";
+        tools = prompt.image_config.tools || {};
+      }
+      const inputCollected = [];
+      if (input_schema && input_schema.properties) {
+        inputCollected.push(
+          buildTypedDict(`${name}In`, input_schema, inputCollected)
+        );
+      } else {
+        inputCollected.push(`class ${name}In(TypedDict):
+    pass`);
+      }
+      allClasses.push(...inputCollected);
+      const outputCollected = [];
+      if (outputSchema && outputSchema.properties) {
+        outputCollected.push(
+          buildTypedDict(`${name}Out`, outputSchema, outputCollected)
+        );
+      } else if (kind === "object") {
+        outputCollected.push(`class ${name}Out(TypedDict):
+    pass`);
+      } else {
+        outputCollected.push(`${name}Out = str`);
+      }
+      allClasses.push(...outputCollected);
+      if (Object.keys(tools).length > 0) {
+        const toolOutput = generatePythonToolTypes(tools);
+        if (toolOutput) allClasses.push(toolOutput);
+      }
+      const toolsLine = Object.keys(tools).length > 0 ? "\n    tools: NotRequired[list[str]]" : "";
+      allClasses.push(
+        `class ${name}(TypedDict):
+    kind: Literal['${kind}']
+    input: ${name}In
+    output: ${name}Out${toolsLine}`
+      );
+      typeMapping.push({ path: promptPath, name });
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath)
+        typeMapping.push({ path: withoutMdx, name });
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push({ path: shortName, name });
+      }
+    } catch (error) {
+      console.error(`Error processing ${promptPath}:`, error);
+      allClasses.push(`class ${name}In(TypedDict):
+    pass`);
+      allClasses.push(`${name}Out = str`);
+      allClasses.push(
+        `class ${name}(TypedDict):
+    kind: Literal['text']
+    input: ${name}In
+    output: ${name}Out`
+      );
+      typeMapping.push({ path: promptPath, name });
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath)
+        typeMapping.push({ path: withoutMdx, name });
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push({ path: shortName, name });
+      }
+    }
+  }
+  const mappingLines = typeMapping.map(({ path: path2, name }) => `    '${path2}': ${name}`).join(",\n");
+  allClasses.push(
+    `AgentmarkTypes = TypedDict('AgentmarkTypes', {
+${mappingLines},
+})`
+  );
+  const body = allClasses.join("\n\n\n") + "\n";
+  return buildPythonHeader(body) + body;
+}
+async function generatePythonTypeDefinitionsV0(prompts) {
+  var _a, _b;
+  const allClasses = [];
+  const typeMapping = [];
+  for (const prompt of prompts) {
+    const { path: promptPath, metadata, input_schema } = prompt;
+    const name = getInterfaceName(promptPath);
+    try {
+      const inputCollected = [];
+      if (input_schema && input_schema.properties) {
+        inputCollected.push(
+          buildTypedDict(`${name}In`, input_schema, inputCollected)
+        );
+      } else {
+        inputCollected.push(`class ${name}In(TypedDict):
+    pass`);
+      }
+      allClasses.push(...inputCollected);
+      const outputSchema = (_b = (_a = metadata == null ? void 0 : metadata.model) == null ? void 0 : _a.settings) == null ? void 0 : _b.schema;
+      const outputCollected = [];
+      if (outputSchema && outputSchema.properties) {
+        outputCollected.push(
+          buildTypedDict(`${name}Out`, outputSchema, outputCollected)
+        );
+      } else {
+        outputCollected.push(`${name}Out = str`);
+      }
+      allClasses.push(...outputCollected);
+      allClasses.push(
+        `class ${name}(TypedDict):
+    input: ${name}In
+    output: ${name}Out`
+      );
+      typeMapping.push({ path: promptPath, name });
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath)
+        typeMapping.push({ path: withoutMdx, name });
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push({ path: shortName, name });
+      }
+    } catch (error) {
+      console.error(`Error processing ${promptPath}:`, error);
+      allClasses.push(`class ${name}In(TypedDict):
+    pass`);
+      allClasses.push(`${name}Out = str`);
+      allClasses.push(
+        `class ${name}(TypedDict):
+    input: ${name}In
+    output: ${name}Out`
+      );
+      typeMapping.push({ path: promptPath, name });
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath)
+        typeMapping.push({ path: withoutMdx, name });
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push({ path: shortName, name });
+      }
+    }
+  }
+  const mappingLines = typeMapping.map(({ path: path2, name }) => `    '${path2}': ${name}`).join(",\n");
+  allClasses.push(
+    `AgentmarkTypes = TypedDict('AgentmarkTypes', {
+${mappingLines},
+})`
+  );
+  const body = allClasses.join("\n\n\n") + "\n";
+  return buildPythonHeader(body) + body;
+}
+async function generateTypeDefinitions(prompts, language = "typescript") {
+  if (language === "python") {
+    if (prompts[0].version === "1.0") {
+      return generatePythonTypeDefinitionsV1_0(prompts);
+    }
+    return generatePythonTypeDefinitionsV0(prompts);
+  }
   if (prompts[0].version === "1.0") {
     return generateTypeDefinitionsV1_0(prompts);
   }
@@ -567,9 +889,9 @@ var KNOWN_METADATA_FIELDS = /* @__PURE__ */ new Set([
   "dataset_path",
   "dataset_item_name",
   "dataset_expected_output",
+  "dataset_input",
   "prompt_name",
-  "props",
-  "commit_sha"
+  "props"
 ]);
 function parseMetadata(attributes, prefix = "agentmark.metadata.") {
   const result = {};
@@ -1354,10 +1676,12 @@ 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.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"));
   if (get("dataset_expected_output")) result.datasetExpectedOutput = String(get("dataset_expected_output"));
+  if (get("dataset_input")) result.datasetInput = String(get("dataset_input"));
   if (get("dataset_path")) result.datasetPath = String(get("dataset_path"));
   return result;
 }
@@ -1422,6 +1746,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 */;
     }
@@ -1470,6 +1797,10 @@ var AgentMarkTransformer = class {
     if (result.inputTokens !== void 0 && result.outputTokens !== void 0) {
       result.totalTokens = result.inputTokens + result.outputTokens;
     }
+    const costUsd = attributes["agentmark.usage.cost_usd"];
+    if (typeof costUsd === "number" && costUsd > 0) {
+      result.cost = costUsd;
+    }
     const finishReasons = attributes[GenAIAttributes.RESPONSE_FINISH_REASONS];
     if (finishReasons) {
       try {
@@ -1515,6 +1846,22 @@ var AgentMarkTransformer = class {
     const responseOutput = attributes[GenAIAttributes.RESPONSE_OUTPUT];
     if (responseOutput && typeof responseOutput === "string") {
       result.output = responseOutput;
+      try {
+        result.outputObject = JSON.parse(responseOutput);
+      } catch {
+      }
+    }
+    const amInput = attributes["agentmark.input"];
+    if (amInput && typeof amInput === "string" && !result.input) {
+      result.input = [{ role: "user", content: amInput }];
+    }
+    const amOutput = attributes["agentmark.output"];
+    if (amOutput && typeof amOutput === "string" && !result.output) {
+      result.output = amOutput;
+      try {
+        result.outputObject = JSON.parse(amOutput);
+      } catch {
+      }
     }
     const toolName = attributes[GenAIAttributes.TOOL_NAME];
     const toolCallId = attributes[GenAIAttributes.TOOL_CALL_ID];
@@ -1556,6 +1903,194 @@ var AgentMarkTransformer = class {
 };
 var AGENTMARK_SCOPE_NAME = "agentmark";
 
+// src/normalizer/transformers/otel-genai/index.ts
+var Attrs = {
+  // Standard OTel GenAI attributes
+  SYSTEM: "gen_ai.system",
+  PROVIDER_NAME: "gen_ai.provider.name",
+  OPERATION_NAME: "gen_ai.operation.name",
+  REQUEST_MODEL: "gen_ai.request.model",
+  REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens",
+  REQUEST_TEMPERATURE: "gen_ai.request.temperature",
+  RESPONSE_ID: "gen_ai.response.id",
+  RESPONSE_MODEL: "gen_ai.response.model",
+  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
+  INPUT_MESSAGES: "gen_ai.input.messages",
+  OUTPUT_MESSAGES: "gen_ai.output.messages",
+  SYSTEM_INSTRUCTIONS: "gen_ai.system_instructions",
+  TOOL_DEFINITIONS: "gen_ai.tool.definitions",
+  // Tool call attributes (v1.37.0+)
+  TOOL_NAME: "gen_ai.tool.name",
+  TOOL_CALL_ID: "gen_ai.tool.call.id",
+  TOOL_CALL_ARGS: "gen_ai.tool.call.arguments",
+  TOOL_CALL_RESULT: "gen_ai.tool.call.result"
+};
+function partsToText(parts) {
+  return parts.filter((p) => p.type === "text" && p.content).map((p) => p.content).join("\n");
+}
+function normalizeMessages(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed) || parsed.length === 0) return null;
+    const messages = [];
+    for (const msg of parsed) {
+      if (!msg.role) continue;
+      if (msg.content && typeof msg.content === "string") {
+        messages.push(msg);
+      } else if (msg.parts && Array.isArray(msg.parts)) {
+        const text = partsToText(msg.parts);
+        if (text) {
+          messages.push({ role: msg.role, content: text });
+        }
+      }
+    }
+    return messages.length > 0 ? messages : null;
+  } catch {
+    return null;
+  }
+}
+function extractStructuredOutput(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return null;
+    for (const msg of parsed) {
+      for (const part of msg.parts || []) {
+        if (part.type === "tool_call" && part.arguments) {
+          return {
+            output: JSON.stringify(part.arguments),
+            outputObject: part.arguments
+          };
+        }
+      }
+    }
+    for (const msg of parsed) {
+      const text = partsToText(msg.parts || []);
+      if (text) return { output: text };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var OtelGenAiTransformer = class {
+  classify(span, attributes) {
+    if (span.name.startsWith("chat ")) return "GENERATION" /* GENERATION */;
+    if (span.name.startsWith("invoke_agent") || span.name === "agent run") return "SPAN" /* SPAN */;
+    if (span.name.startsWith("execute_tool") || span.name.startsWith("running ")) return "SPAN" /* SPAN */;
+    if (attributes[Attrs.USAGE_INPUT_TOKENS] !== void 0) return "GENERATION" /* GENERATION */;
+    return "SPAN" /* SPAN */;
+  }
+  transform(span, attributes) {
+    const result = {};
+    const model = attributes[Attrs.RESPONSE_MODEL] || attributes[Attrs.REQUEST_MODEL];
+    if (model && typeof model === "string") {
+      result.model = model;
+    }
+    const inputTokens = attributes[Attrs.USAGE_INPUT_TOKENS];
+    const outputTokens = attributes[Attrs.USAGE_OUTPUT_TOKENS];
+    if (typeof inputTokens === "number") result.inputTokens = inputTokens;
+    if (typeof outputTokens === "number") result.outputTokens = outputTokens;
+    if (result.inputTokens !== void 0 && result.outputTokens !== void 0) {
+      result.totalTokens = result.inputTokens + result.outputTokens;
+    }
+    const finishReasons = attributes[Attrs.RESPONSE_FINISH_REASONS];
+    if (Array.isArray(finishReasons) && finishReasons.length > 0) {
+      result.finishReason = finishReasons[0];
+    }
+    const temperature = attributes[Attrs.REQUEST_TEMPERATURE];
+    if (typeof temperature === "number") {
+      result.settings = { ...result.settings, temperature };
+    }
+    const inputMessages = attributes[Attrs.INPUT_MESSAGES];
+    if (inputMessages && typeof inputMessages === "string") {
+      const messages = normalizeMessages(inputMessages);
+      if (messages) result.input = messages;
+    }
+    const outputMessages = attributes[Attrs.OUTPUT_MESSAGES];
+    if (outputMessages && typeof outputMessages === "string") {
+      const extracted = extractStructuredOutput(outputMessages);
+      if (extracted) {
+        result.output = extracted.output;
+        if (extracted.outputObject) {
+          result.outputObject = extracted.outputObject;
+        }
+      }
+    }
+    const allMessages = attributes["pydantic_ai.all_messages"];
+    if (allMessages && typeof allMessages === "string" && !result.input) {
+      const messages = normalizeMessages(allMessages);
+      if (messages) {
+        const userMessages = messages.filter((m) => m.role === "user");
+        if (userMessages.length > 0) {
+          result.input = userMessages;
+        }
+      }
+    }
+    const finalResult = attributes["final_result"];
+    if (finalResult && typeof finalResult === "string" && !result.output) {
+      result.output = finalResult;
+      try {
+        result.outputObject = JSON.parse(finalResult);
+      } catch {
+      }
+    }
+    const propsStr = attributes["agentmark.props"];
+    if (propsStr && typeof propsStr === "string" && !result.input) {
+      try {
+        const props = JSON.parse(propsStr);
+        result.input = [{ role: "user", content: JSON.stringify(props) }];
+      } catch {
+      }
+    }
+    const outputStr = attributes["agentmark.output"];
+    if (outputStr && typeof outputStr === "string" && !result.output) {
+      result.output = outputStr;
+      try {
+        result.outputObject = JSON.parse(outputStr);
+      } catch {
+      }
+    }
+    const toolName = attributes[Attrs.TOOL_NAME];
+    if (toolName && typeof toolName === "string") {
+      result.name = toolName;
+      const toolCall = {
+        type: "tool-call",
+        toolCallId: attributes[Attrs.TOOL_CALL_ID] || "",
+        toolName,
+        args: {}
+      };
+      const toolArgs = attributes[Attrs.TOOL_CALL_ARGS];
+      if (toolArgs && typeof toolArgs === "string") {
+        try {
+          toolCall.args = JSON.parse(toolArgs);
+        } catch {
+          toolCall.args = { raw: toolArgs };
+        }
+      }
+      const toolResult = attributes[Attrs.TOOL_CALL_RESULT];
+      if (toolResult && typeof toolResult === "string") {
+        toolCall.result = toolResult;
+      }
+      result.toolCalls = [toolCall];
+    }
+    const agentmarkAttrs = parseAgentMarkAttributes(attributes);
+    Object.assign(result, agentmarkAttrs);
+    const parsedMeta = parseMetadata(attributes);
+    if (parsedMeta.metadata && Object.keys(parsedMeta.metadata).length > 0) {
+      result.metadata = { ...result.metadata, ...parsedMeta.metadata };
+    }
+    const customMeta = extractCustomMetadata(attributes);
+    if (Object.keys(customMeta).length > 0) {
+      result.metadata = { ...result.metadata, ...customMeta };
+    }
+    return result;
+  }
+};
+OtelGenAiTransformer.SCOPE_NAME = "pydantic-ai";
+
 // src/normalizer/converters/otlp-converter.ts
 function convertOtlpValue(value) {
   var _a;
@@ -1636,6 +2171,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) {
@@ -1657,7 +2269,8 @@ var typeClassifier = new TypeClassifier();
 registry.register("ai", new AiSdkTransformer());
 registry.register("default-tracer", new MastraTransformer());
 registry.register("agentmark", new AgentMarkTransformer());
-registry.setDefault(new AiSdkTransformer());
+registry.register("pydantic-ai", new OtelGenAiTransformer());
+registry.setDefault(new OtelGenAiTransformer());
 function normalizeSpan(resource, scope, span) {
   var _a, _b, _c;
   const allAttributes = {
@@ -1713,6 +2326,7 @@ function normalizeSpan(resource, scope, span) {
   }
   const agentMarkAttributes = parseAgentMarkAttributes(allAttributes);
   Object.assign(normalized, agentMarkAttributes);
+  normalized.semanticKind = resolveSemanticKind(normalized, allAttributes);
   return normalized;
 }
 function normalizeOtlpSpans(resourceSpans) {
@@ -1732,6 +2346,8 @@ function normalizeOtlpSpans(resourceSpans) {
   AiSdkTransformer,
   ClaudeAgentTransformer,
   MastraTransformer,
+  OtelGenAiTransformer,
+  SEMANTIC_KINDS,
   SpanType,
   TransformerRegistry,
   TypeClassifier,
@@ -1751,6 +2367,7 @@ function normalizeOtlpSpans(resourceSpans) {
   parseMetadata,
   parseTokens,
   registry,
+  resolveSemanticKind,
   toFrontMatter,
   typeClassifier,
   verifySignature