@xsai-ext/telemetry 0.4.0-beta.12 → 0.4.0-beta.13

package/dist/index.d.ts

@@ -1,10 +1,9 @@
-import { AttributeValue } from '@opentelemetry/api';
+import { Attributes } from '@opentelemetry/api';
 import { WithUnknown, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamTextResult } from 'xsai';
 export * from 'xsai';
 
-type TelemetryMetadata = Record<string, AttributeValue>;
 interface TelemetryOptions {
-    metadata?: TelemetryMetadata;
+    attributes?: Attributes;
 }
 type WithTelemetry<T> = T & {
     telemetry?: TelemetryOptions;
@@ -23,4 +22,4 @@ declare const generateText: (options: WithUnknown<WithTelemetry<GenerateTextOpti
 declare const streamText: (options: WithUnknown<WithTelemetry<StreamTextOptions>>) => StreamTextResult;
 
 export { generateText, streamText };
-export type { TelemetryMetadata, TelemetryOptions, WithTelemetry };
+export type { TelemetryOptions, WithTelemetry };

package/dist/index.js

@@ -1,91 +1,37 @@
-import { determineStepType, clean, executeTool, trampoline, chat, responseJSON, DelayedPromise, objCamelToSnake } from 'xsai';
+import { trampoline, chat, responseJSON, determineStepType, executeTool, DelayedPromise, objCamelToSnake } from 'xsai';
 export * from 'xsai';
 import { trace, SpanStatusCode } from '@opentelemetry/api';
 
-const metadataAttributes = (metadata = {}) => Object.fromEntries(
-  Object.entries(metadata).map(([key, value]) => [`ai.telemetry.metadata.${key}`, value])
-);
-const idAttributes = () => {
-  const id = crypto.randomUUID();
-  return {
-    "ai.response.id": id,
-    "ai.response.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
-    "gen_ai.response.id": id
-  };
-};
-const commonAttributes = (operationId, model) => ({
-  "ai.model.id": model,
-  // TODO: provider name
-  "ai.model.provider": "xsai",
-  "ai.operationId": operationId,
-  "ai.response.providerMetadata": "{}",
-  "operation.name": operationId
+const chatSpan = (options, tracer) => ({
+  attributes: {
+    "gen_ai.input.messages": JSON.stringify(options.messages),
+    "gen_ai.operation.name": "chat",
+    "gen_ai.provider.name": "openai",
+    "gen_ai.request.choice.count": 1,
+    "gen_ai.request.frequency_penalty": options.frequencyPenalty,
+    "gen_ai.request.model": options.model,
+    "gen_ai.request.presence_penalty": options.presencePenalty,
+    "gen_ai.request.seed": options.seed,
+    "gen_ai.request.stop_sequences": options.stop == null ? void 0 : Array.isArray(options.stop) ? options.stop : [options.stop],
+    "gen_ai.request.temperature": options.temperature,
+    "gen_ai.request.top_k": options.topK,
+    "gen_ai.request.top_p": options.topP,
+    "gen_ai.response.id": crypto.randomUUID(),
+    "gen_ai.response.model": options.model,
+    "gen_ai.tool.definitions": JSON.stringify(options.tools?.map((tool) => ({ function: tool.function, type: tool.type }))),
+    "server.address": new URL(options.baseURL).host,
+    ...options.telemetry?.attributes
+    // TODO: gen_ai.output.type
+  },
+  name: `chat ${options.model}`,
+  tracer
 });
 
-const extractGenerateTextStep = async (options, res) => {
-  const { choices, usage } = res;
-  if (!choices?.length)
-    throw new Error(`No choices returned, response body: ${JSON.stringify(res)}`);
-  const messages = [];
-  const toolCalls = [];
-  const { finish_reason: finishReason, message } = choices[0];
-  const msgToolCalls = message?.tool_calls ?? [];
-  const stepType = determineStepType({
-    finishReason,
-    maxSteps: options.maxSteps ?? 1,
-    stepsLength: options.steps?.length ?? 0,
-    toolCallsLength: msgToolCalls.length
-  });
-  messages.push(clean({
-    ...message,
-    reasoning_content: void 0
-  }));
-  if (finishReason !== "stop" || stepType !== "done") {
-    for (const toolCall of msgToolCalls) {
-      toolCalls.push({
-        args: toolCall.function.arguments,
-        toolCallId: toolCall.id,
-        toolCallType: toolCall.type,
-        toolName: toolCall.function.name
-      });
-    }
-  }
-  return [
-    {
-      finishReason,
-      stepType,
-      text: message.content,
-      toolCalls,
-      usage
-    },
-    {
-      messages,
-      msgToolCalls,
-      reasoningText: message.reasoning_content
-    }
-  ];
-};
-const extractGenerateTextStepPost = async (options, msgToolCalls) => {
-  const inputMessages = structuredClone(options.messages);
-  const outputMessages = [];
-  const toolResults = [];
-  for (const toolCall of msgToolCalls) {
-    const { completionToolResult, message } = await executeTool({
-      abortSignal: options.abortSignal,
-      messages: inputMessages,
-      toolCall,
-      tools: options.tools
-    });
-    toolResults.push(completionToolResult);
-    outputMessages.push(message);
-  }
-  return [
-    toolResults,
-    outputMessages
-  ];
-};
+var version = "0.4.0-beta.13";
+var pkg = {
+	version: version};
 
-const getTracer = () => trace.getTracer("@xsai-ext/telemetry");
+const getTracer = () => trace.getTracer("@xsai-ext/telemetry", pkg.version);
 
 const recordErrorOnSpan = (span, error) => {
   if (error instanceof Error) {
@@ -122,44 +68,28 @@ const recordSpan = async ({
     throw error;
   }
 });
-const recordSpanSync = ({
-  attributes,
-  endWhenDone = true,
-  name,
-  tracer
-}, fn) => tracer.startActiveSpan(name, { attributes }, (span) => {
-  try {
-    const result = fn(span);
-    if (endWhenDone)
-      span.end();
-    return result;
-  } catch (error) {
-    try {
-      recordErrorOnSpan(span, error);
-    } finally {
-      span.end();
-    }
-    throw error;
-  }
-});
-
-const stringifyTool = ({ function: func, type }) => JSON.stringify({ description: func.description, inputSchema: func.parameters, name: func.name, type });
 
 const wrapTool = (tool, tracer) => ({
   execute: async (input, options) => recordSpan({
     attributes: {
-      "ai.operationId": "ai.toolCall",
-      "ai.toolCall.args": JSON.stringify(input),
-      "ai.toolCall.id": options.toolCallId,
-      "ai.toolCall.name": tool.function.name,
-      "operation.name": "ai.toolCall"
+      "gen_ai.operation.name": "execute_tool",
+      "gen_ai.tool.call.arguments": JSON.stringify(input),
+      "gen_ai.tool.call.description": tool.function.description,
+      "gen_ai.tool.call.id": options.toolCallId,
+      "gen_ai.tool.call.name": tool.function.name
     },
-    name: "ai.toolCall",
+    name: `execute_tool ${tool.function.name}`,
     tracer
   }, async (span) => {
-    const result = await tool.execute(input, options);
-    span.setAttribute("ai.toolCall.result", JSON.stringify(result));
-    return result;
+    try {
+      const result = await tool.execute(input, options);
+      span.setAttribute("gen_ai.tool.call.result", JSON.stringify(result));
+      return result;
+    } catch (err) {
+      if (err instanceof Error)
+        span.setAttribute("error.type", err.message);
+      throw err;
+    }
   }),
   function: tool.function,
   type: tool.type
@@ -167,65 +97,63 @@ const wrapTool = (tool, tracer) => ({
 
 const generateText = async (options) => {
   const tracer = getTracer();
-  const rawGenerateText = async (options2) => {
+  const rawGenerateText = async (options2) => recordSpan(chatSpan(options2, tracer), async (span) => chat({
+    ...options2,
+    maxSteps: void 0,
+    steps: void 0,
+    stream: false
+  }).then(responseJSON).then(async (res) => {
+    const { choices, usage } = res;
+    if (!choices?.length)
+      throw new Error(`No choices returned, response body: ${JSON.stringify(res)}`);
     const messages = structuredClone(options2.messages);
     const steps = options2.steps ? structuredClone(options2.steps) : [];
-    const [stepWithoutToolCalls, { messages: msgs1, msgToolCalls, reasoningText }] = await recordSpan({
-      attributes: {
-        ...idAttributes(),
-        ...commonAttributes("ai.generateText.doGenerate", options2.model),
-        ...metadataAttributes(options2.telemetry?.metadata),
-        ...options2.tools != null && options2.tools.length > 0 ? {
-          "ai.prompt.toolChoice": JSON.stringify(options2.toolChoice ?? { type: "auto" }),
-          "ai.prompt.tools": options2.tools.map(stringifyTool)
-        } : {},
-        "ai.prompt.messages": JSON.stringify(messages),
-        "ai.response.model": options2.model,
-        "gen_ai.request.model": options2.model,
-        "gen_ai.response.id": crypto.randomUUID(),
-        "gen_ai.response.model": options2.model,
-        "gen_ai.system": "xsai"
-      },
-      name: "ai.generateText.doGenerate",
-      tracer
-    }, async (span) => {
-      const res = await chat({
-        ...options2,
-        maxSteps: void 0,
-        steps: void 0,
-        stream: false,
-        telemetry: void 0
-      }).then(responseJSON);
-      const [step2, { messages: msgs, msgToolCalls: msgToolCalls2, reasoningText: reasoningText2 }] = await extractGenerateTextStep({
-        ...options2,
-        messages,
-        steps
-      }, res);
-      span.setAttributes({
-        ...step2.text != null && step2.toolCalls.length === 0 ? { "ai.response.text": step2.text } : {},
-        ...step2.toolCalls.length > 0 ? { "ai.response.toolCalls": JSON.stringify(step2.toolCalls) } : {},
-        "ai.response.finishReason": step2.finishReason,
-        "ai.usage.completionTokens": step2.usage.completion_tokens,
-        "ai.usage.promptTokens": step2.usage.prompt_tokens,
-        "gen_ai.response.finish_reasons": [step2.finishReason],
-        "gen_ai.usage.input_tokens": step2.usage.prompt_tokens,
-        "gen_ai.usage.output_tokens": step2.usage.completion_tokens
-      });
-      return [step2, { messages: msgs, msgToolCalls: msgToolCalls2, reasoningText: reasoningText2 }];
+    const toolCalls = [];
+    const toolResults = [];
+    const { finish_reason: finishReason, message } = choices[0];
+    const msgToolCalls = message?.tool_calls ?? [];
+    const stepType = determineStepType({
+      finishReason,
+      maxSteps: options2.maxSteps ?? 1,
+      stepsLength: steps.length,
+      toolCallsLength: msgToolCalls.length
     });
-    const [toolResults, msgs2] = await extractGenerateTextStepPost({
-      ...options2,
-      messages}, msgToolCalls);
-    const step = { ...stepWithoutToolCalls, toolResults };
+    messages.push(message);
+    span.setAttribute("gen_ai.output.messages", JSON.stringify([message]));
+    if (finishReason !== "stop" && stepType !== "done") {
+      for (const toolCall of msgToolCalls) {
+        const { completionToolCall, completionToolResult, message: message2 } = await executeTool({
+          abortSignal: options2.abortSignal,
+          messages,
+          toolCall,
+          tools: options2.tools
+        });
+        toolCalls.push(completionToolCall);
+        toolResults.push(completionToolResult);
+        messages.push(message2);
+      }
+    }
+    const step = {
+      finishReason,
+      stepType,
+      text: Array.isArray(message.content) ? message.content.filter((m) => m.type === "text").map((m) => m.text).join("\n") : message.content,
+      toolCalls,
+      toolResults,
+      usage
+    };
     steps.push(step);
-    messages.push(...msgs1, ...msgs2);
+    span.setAttributes({
+      "gen_ai.response.finish_reasons": [step.finishReason],
+      "gen_ai.usage.input_tokens": step.usage.prompt_tokens,
+      "gen_ai.usage.output_tokens": step.usage.completion_tokens
+    });
     if (options2.onStepFinish)
       await options2.onStepFinish(step);
     if (step.finishReason === "stop" || step.stepType === "done") {
       return {
         finishReason: step.finishReason,
         messages,
-        reasoningText,
+        reasoningText: message.reasoning_content,
         steps,
         text: step.text,
         toolCalls: step.toolCalls,
@@ -239,33 +167,13 @@ const generateText = async (options) => {
         steps
       });
     }
-  };
-  return recordSpan({
-    attributes: {
-      ...commonAttributes("ai.generateText", options.model),
-      ...metadataAttributes(options.telemetry?.metadata),
-      "ai.prompt": JSON.stringify({ messages: options.messages })
-    },
-    name: "ai.generateText",
-    tracer
-  }, async (span) => {
-    const result = await trampoline(async () => rawGenerateText({
-      ...options,
-      tools: options.tools?.map((tool) => wrapTool(tool, tracer))
-    }));
-    span.setAttributes({
-      ...result.toolCalls.length > 0 ? { "ai.response.toolCalls": JSON.stringify(result.toolCalls) } : {},
-      ...result.text != null ? { "ai.response.text": result.text } : {},
-      "ai.response.finishReason": result.finishReason,
-      "ai.usage.completionTokens": result.usage.completion_tokens,
-      "ai.usage.promptTokens": result.usage.prompt_tokens
-    });
-    return result;
-  });
+  }));
+  return trampoline(async () => rawGenerateText({
+    ...options,
+    tools: options.tools?.map((tool) => wrapTool(tool, tracer))
+  }));
 };
 
-const now = () => globalThis?.performance?.now() ?? Date.now();
-
 const parseChunk = (text) => {
   if (!text || !text.startsWith("data:"))
     return [void 0, false];
@@ -318,8 +226,10 @@ const streamText = (options) => {
   const resultTotalUsage = new DelayedPromise();
   let eventCtrl;
   let textCtrl;
+  let reasoningTextCtrl;
   const eventStream = new ReadableStream({ start: (controller) => eventCtrl = controller });
   const textStream = new ReadableStream({ start: (controller) => textCtrl = controller });
+  const reasoningTextStream = new ReadableStream({ start: (controller) => reasoningTextCtrl = controller });
   const pushEvent = (stepEvent) => {
     eventCtrl?.enqueue(stepEvent);
     void options.onEvent?.(stepEvent);
@@ -329,26 +239,7 @@ const streamText = (options) => {
     void options.onStepFinish?.(step);
   };
   const tools = options.tools != null && options.tools.length > 0 ? options.tools.map((tool) => wrapTool(tool, tracer)) : void 0;
-  const doStream = async () => recordSpan({
-    attributes: {
-      ...idAttributes(),
-      ...commonAttributes("ai.streamText.doStream", options.model),
-      ...metadataAttributes(options.telemetry?.metadata),
-      ...tools != null && tools.length > 0 && {
-        "ai.prompt.toolChoice": JSON.stringify(options.toolChoice ?? { type: "auto" }),
-        "ai.prompt.tools": tools.map(stringifyTool)
-      },
-      "ai.prompt.messages": JSON.stringify(options.messages),
-      "ai.response.model": options.model,
-      "gen_ai.request.model": options.model,
-      "gen_ai.response.id": crypto.randomUUID(),
-      "gen_ai.response.model": options.model,
-      "gen_ai.system": "xsai"
-    },
-    name: "ai.streamText.doStream",
-    tracer
-  }, async (span) => {
-    const startMs = now();
+  const doStream = async () => recordSpan(chatSpan({ ...options, messages }, tracer), async (span) => {
     const { body: stream } = await chat({
       ...options,
       maxSteps: void 0,
@@ -366,15 +257,21 @@ const streamText = (options) => {
       } : { ...u };
     };
     let text = "";
+    let reasoningText;
     const pushText = (content) => {
       textCtrl?.enqueue(content);
       text += content;
     };
+    const pushReasoningText = (reasoningContent) => {
+      if (reasoningText == null)
+        reasoningText = "";
+      reasoningTextCtrl?.enqueue(reasoningContent);
+      reasoningText += reasoningContent;
+    };
     const tool_calls = [];
     const toolCalls = [];
     const toolResults = [];
     let finishReason = "other";
-    let firstChunk = true;
     await stream.pipeThrough(transformChunk()).pipeTo(new WritableStream({
       abort: (reason) => {
         eventCtrl?.error(reason);
@@ -384,23 +281,15 @@ const streamText = (options) => {
       },
       // eslint-disable-next-line sonarjs/cognitive-complexity
       write: (chunk) => {
-        if (firstChunk) {
-          const msToFirstChunk = now() - startMs;
-          span.addEvent("ai.stream.firstChunk", {
-            "ai.response.msToFirstChunk": msToFirstChunk
-          });
-          span.setAttributes({
-            "ai.response.msToFirstChunk": msToFirstChunk
-          });
-          firstChunk = false;
-        }
         if (chunk.usage)
           pushUsage(chunk.usage);
         if (chunk.choices == null || chunk.choices.length === 0)
           return;
         const choice = chunk.choices[0];
-        if (choice.delta.reasoning_content != null)
+        if (choice.delta.reasoning_content != null) {
           pushEvent({ text: choice.delta.reasoning_content, type: "reasoning-delta" });
+          pushReasoningText(choice.delta.reasoning_content);
+        }
         if (choice.finish_reason != null)
           finishReason = choice.finish_reason;
         if (choice.delta.tool_calls?.length === 0 || choice.delta.tool_calls == null) {
@@ -423,21 +312,37 @@ const streamText = (options) => {
                   arguments: toolCall.function.arguments ?? ""
                 }
               };
-              pushEvent({ toolCallId: toolCall.id, toolName: toolCall.function.name, type: "tool-call-streaming-start" });
+              pushEvent({
+                toolCallId: toolCall.id,
+                toolName: toolCall.function.name,
+                type: "tool-call-streaming-start"
+              });
             } else {
               tool_calls[index].function.arguments += toolCall.function.arguments;
-              pushEvent({ argsTextDelta: toolCall.function.arguments, toolCallId: toolCall.id, toolName: toolCall.function.name ?? tool_calls[index].function.name, type: "tool-call-delta" });
+              pushEvent({
+                argsTextDelta: toolCall.function.arguments,
+                toolCallId: toolCall.id,
+                toolName: toolCall.function.name ?? tool_calls[index].function.name,
+                type: "tool-call-delta"
+              });
             }
           }
         }
       }
     }));
-    messages.push({ content: text, role: "assistant", tool_calls });
+    const message = {
+      content: text,
+      reasoning_content: reasoningText,
+      role: "assistant",
+      tool_calls: tool_calls.length > 0 ? tool_calls : void 0
+    };
+    messages.push(message);
+    span.setAttribute("gen_ai.output.messages", JSON.stringify([message]));
     if (tool_calls.length !== 0) {
       for (const toolCall of tool_calls) {
         if (toolCall == null)
           continue;
-        const { completionToolCall, completionToolResult, message } = await executeTool({
+        const { completionToolCall, completionToolResult, message: message2 } = await executeTool({
           abortSignal: options.abortSignal,
           messages,
           toolCall,
@@ -445,7 +350,7 @@ const streamText = (options) => {
         });
         toolCalls.push(completionToolCall);
         toolResults.push(completionToolResult);
-        messages.push(message);
+        messages.push(message2);
         pushEvent({ ...completionToolCall, type: "tool-call" });
         pushEvent({ ...completionToolResult, type: "tool-result" });
       }
@@ -465,19 +370,9 @@ const streamText = (options) => {
       usage
     };
     pushStep(step);
-    const msToFinish = now() - startMs;
-    span.addEvent("ai.stream.finish");
     span.setAttributes({
-      "ai.response.msToFinish": msToFinish,
-      ...step.toolCalls.length > 0 && { "ai.response.toolCalls": JSON.stringify(step.toolCalls) },
-      "ai.response.finishReason": step.finishReason,
-      "ai.response.text": step.text != null ? step.text : "",
       "gen_ai.response.finish_reasons": [step.finishReason],
       ...step.usage && {
-        "ai.response.avgOutputTokensPerSecond": 1e3 * (step.usage.completion_tokens ?? 0) / msToFinish,
-        "ai.usage.inputTokens": step.usage.prompt_tokens,
-        "ai.usage.outputTokens": step.usage.completion_tokens,
-        "ai.usage.totalTokens": step.usage.total_tokens,
         "gen_ai.usage.input_tokens": step.usage.prompt_tokens,
         "gen_ai.usage.output_tokens": step.usage.completion_tokens
       }
@@ -485,61 +380,38 @@ const streamText = (options) => {
     if (toolCalls.length !== 0 && steps.length < maxSteps)
       return async () => doStream();
   });
-  return recordSpanSync({
-    attributes: {
-      ...commonAttributes("ai.streamText", options.model),
-      ...metadataAttributes(options.telemetry?.metadata),
-      "ai.prompt": JSON.stringify({ messages: options.messages })
-    },
-    endWhenDone: false,
-    name: "ai.streamText",
-    tracer
-  }, (rootSpan) => {
-    void (async () => {
-      try {
-        await trampoline(async () => doStream());
-        eventCtrl?.close();
-        textCtrl?.close();
-      } catch (err) {
-        eventCtrl?.error(err);
-        textCtrl?.error(err);
-        resultSteps.reject(err);
-        resultMessages.reject(err);
-        resultUsage.reject(err);
-        resultTotalUsage.reject(err);
-      } finally {
-        resultSteps.resolve(steps);
-        resultMessages.resolve(messages);
-        resultUsage.resolve(usage);
-        resultTotalUsage.resolve(totalUsage);
-        const finishStep = steps.at(-1);
-        if (finishStep) {
-          rootSpan.setAttributes({
-            ...finishStep.toolCalls.length > 0 && { "ai.response.toolCalls": JSON.stringify(finishStep.toolCalls) },
-            "ai.response.finishReason": finishStep.finishReason,
-            "ai.response.text": finishStep.text != null ? finishStep.text : ""
-          });
-        }
-        if (totalUsage) {
-          rootSpan.setAttributes({
-            "ai.usage.inputTokens": totalUsage.prompt_tokens,
-            "ai.usage.outputTokens": totalUsage.completion_tokens,
-            "ai.usage.totalTokens": totalUsage.total_tokens
-          });
-        }
-        void options.onFinish?.(finishStep);
-        rootSpan.end();
-      }
-    })();
-    return {
-      fullStream: eventStream,
-      messages: resultMessages.promise,
-      steps: resultSteps.promise,
-      textStream,
-      totalUsage: resultTotalUsage.promise,
-      usage: resultUsage.promise
-    };
-  });
+  void (async () => {
+    try {
+      await trampoline(async () => doStream());
+      eventCtrl?.close();
+      textCtrl?.close();
+      reasoningTextCtrl?.close();
+    } catch (err) {
+      eventCtrl?.error(err);
+      textCtrl?.error(err);
+      reasoningTextCtrl?.error(err);
+      resultSteps.reject(err);
+      resultMessages.reject(err);
+      resultUsage.reject(err);
+      resultTotalUsage.reject(err);
+    } finally {
+      resultSteps.resolve(steps);
+      resultMessages.resolve(messages);
+      resultUsage.resolve(usage);
+      resultTotalUsage.resolve(totalUsage);
+      const finishStep = steps.at(-1);
+      void options.onFinish?.(finishStep);
+    }
+  })();
+  return {
+    fullStream: eventStream,
+    messages: resultMessages.promise,
+    reasoningTextStream,
+    steps: resultSteps.promise,
+    textStream,
+    totalUsage: resultTotalUsage.promise,
+    usage: resultUsage.promise
+  };
 };
 
 export { generateText, streamText };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai-ext/telemetry",
   "type": "module",
-  "version": "0.4.0-beta.12",
+  "version": "0.4.0-beta.13",
   "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -30,18 +30,17 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "xsai": "~0.4.0-beta.12"
+    "xsai": "~0.4.0-beta.13"
   },
   "devDependencies": {
-    "@opentelemetry/sdk-trace-base": "^2.0.1",
-    "@opentelemetry/sdk-trace-node": "^2.0.1",
-    "ai": "^5.0.28",
-    "ollama-ai-provider-v2": "^1.2.1",
-    "zod": "^4.1.5"
+    "@langfuse/otel": "^4.5.1",
+    "@opentelemetry/sdk-trace-base": "^2.2.0",
+    "@opentelemetry/sdk-trace-node": "^2.2.0",
+    "zod": "^4.2.1"
   },
   "scripts": {
     "build": "pkgroll",
-    "test": "vitest run --update"
+    "test": "vitest run"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"