@agentmark-ai/shared-utils 0.2.0 → 0.3.1

package/dist/index.mjs

@@ -111,7 +111,15 @@ ${jsonToFrontMatter(content)}---
 // src/generate-types.ts
 import * as fs from "fs-extra";
 import path from "path";
-import fm from "front-matter";
+import yaml from "js-yaml";
+function extractFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    return { attributes: {} };
+  }
+  const attributes = yaml.load(match[1]);
+  return { attributes: attributes || {} };
+}
 var _compile = null;
 async function getCompile() {
   var _a;
@@ -290,7 +298,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);
   }
@@ -355,7 +682,7 @@ async function fetchPromptsFrontmatter(options) {
     return Promise.all(
       promptFiles.map(async (file) => {
         const content = await fs.readFile(file, "utf-8");
-        const { attributes } = fm(content);
+        const { attributes } = extractFrontmatter(content);
         if (isNewFormat(attributes)) {
           return {
             path: path.relative(options.rootDir, file),
@@ -497,6 +824,7 @@ var KNOWN_METADATA_FIELDS = /* @__PURE__ */ new Set([
   "dataset_path",
   "dataset_item_name",
   "dataset_expected_output",
+  "dataset_input",
   "prompt_name",
   "props",
   "commit_sha"
@@ -1284,10 +1612,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.kind = 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;
 }
@@ -1400,6 +1730,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 {
@@ -1445,6 +1779,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];
@@ -1486,6 +1836,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;
@@ -1587,7 +2125,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 = {
@@ -1661,6 +2200,7 @@ export {
   AiSdkTransformer,
   AgentMarkTransformer as ClaudeAgentTransformer,
   MastraTransformer,
+  OtelGenAiTransformer,
   SpanType,
   TransformerRegistry,
   TypeClassifier,