ai 3.2.19 → 3.2.21

package/dist/index.mjs

@@ -1113,6 +1113,157 @@ function prepareToolsAndToolChoice({
   };
 }
 
+// core/telemetry/get-base-telemetry-attributes.ts
+function getBaseTelemetryAttributes({
+  operationName,
+  model,
+  settings,
+  telemetry,
+  headers
+}) {
+  var _a;
+  return {
+    "ai.model.provider": model.provider,
+    "ai.model.id": model.modelId,
+    // settings:
+    ...Object.entries(settings).reduce((attributes, [key, value]) => {
+      attributes[`ai.settings.${key}`] = value;
+      return attributes;
+    }, {}),
+    // special telemetry information
+    "operation.name": operationName,
+    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
+    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId,
+    // add metadata as attributes:
+    ...Object.entries((_a = telemetry == null ? void 0 : telemetry.metadata) != null ? _a : {}).reduce(
+      (attributes, [key, value]) => {
+        attributes[`ai.telemetry.metadata.${key}`] = value;
+        return attributes;
+      },
+      {}
+    ),
+    // request headers
+    ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
+      if (value !== void 0) {
+        attributes[`ai.request.headers.${key}`] = value;
+      }
+      return attributes;
+    }, {})
+  };
+}
+
+// core/telemetry/get-tracer.ts
+import { trace } from "@opentelemetry/api";
+
+// core/telemetry/noop-tracer.ts
+var noopTracer = {
+  startSpan() {
+    return noopSpan;
+  },
+  startActiveSpan(name, arg1, arg2, arg3) {
+    if (typeof arg1 === "function") {
+      return arg1(noopSpan);
+    }
+    if (typeof arg2 === "function") {
+      return arg2(noopSpan);
+    }
+    if (typeof arg3 === "function") {
+      return arg3(noopSpan);
+    }
+  }
+};
+var noopSpan = {
+  spanContext() {
+    return noopSpanContext;
+  },
+  setAttribute() {
+    return this;
+  },
+  setAttributes() {
+    return this;
+  },
+  addEvent() {
+    return this;
+  },
+  addLink() {
+    return this;
+  },
+  addLinks() {
+    return this;
+  },
+  setStatus() {
+    return this;
+  },
+  updateName() {
+    return this;
+  },
+  end() {
+    return this;
+  },
+  isRecording() {
+    return false;
+  },
+  recordException() {
+    return this;
+  }
+};
+var noopSpanContext = {
+  traceId: "",
+  spanId: "",
+  traceFlags: 0
+};
+
+// core/telemetry/get-tracer.ts
+var testTracer = void 0;
+function getTracer({ isEnabled }) {
+  if (!isEnabled) {
+    return noopTracer;
+  }
+  if (testTracer) {
+    return testTracer;
+  }
+  return trace.getTracer("ai");
+}
+
+// core/telemetry/record-span.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+function recordSpan({
+  name,
+  tracer,
+  attributes,
+  fn,
+  endWhenDone = true
+}) {
+  return tracer.startActiveSpan(name, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      if (endWhenDone) {
+        span.end();
+      }
+      return result;
+    } catch (error) {
+      try {
+        if (error instanceof Error) {
+          span.recordException({
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          });
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: error.message
+          });
+        } else {
+          span.setStatus({ code: SpanStatusCode.ERROR });
+        }
+      } finally {
+        span.end();
+      }
+      throw error;
+    }
+  });
+}
+
 // core/generate-text/tool-call.ts
 import {
   InvalidToolArgumentsError,
@@ -1166,71 +1317,128 @@ async function generateText({
   headers,
   maxAutomaticRoundtrips = 0,
   maxToolRoundtrips = maxAutomaticRoundtrips,
+  experimental_telemetry: telemetry,
   ...settings
 }) {
-  var _a, _b, _c;
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
-  const mode = {
-    type: "regular",
-    ...prepareToolsAndToolChoice({ tools, toolChoice })
-  };
-  const callSettings = prepareCallSettings(settings);
-  const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
-  let currentModelResponse;
-  let currentToolCalls = [];
-  let currentToolResults = [];
-  let roundtrips = 0;
-  const responseMessages = [];
-  do {
-    currentModelResponse = await retry(() => {
-      return model.doGenerate({
-        mode,
-        ...callSettings,
-        // once we have a roundtrip, we need to switch to messages format:
-        inputFormat: roundtrips === 0 ? validatedPrompt.type : "messages",
-        prompt: promptMessages,
-        abortSignal,
-        headers
+  var _a;
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    operationName: "ai.generateText",
+    model,
+    telemetry,
+    headers,
+    settings: { ...settings, maxRetries }
+  });
+  const tracer = getTracer({ isEnabled: (_a = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a : false });
+  return recordSpan({
+    name: "ai.generateText",
+    attributes: {
+      ...baseTelemetryAttributes,
+      // specific settings that only make sense on the outer level:
+      "ai.prompt": JSON.stringify({ system, prompt, messages }),
+      "ai.settings.maxToolRoundtrips": maxToolRoundtrips
+    },
+    tracer,
+    fn: async (span) => {
+      var _a2, _b, _c;
+      const retry = retryWithExponentialBackoff({ maxRetries });
+      const validatedPrompt = getValidatedPrompt({
+        system,
+        prompt,
+        messages
       });
-    });
-    currentToolCalls = ((_a = currentModelResponse.toolCalls) != null ? _a : []).map(
-      (modelToolCall) => parseToolCall({ toolCall: modelToolCall, tools })
-    );
-    currentToolResults = tools == null ? [] : await executeTools({ toolCalls: currentToolCalls, tools });
-    const newResponseMessages = toResponseMessages({
-      text: (_b = currentModelResponse.text) != null ? _b : "",
-      toolCalls: currentToolCalls,
-      toolResults: currentToolResults
-    });
-    responseMessages.push(...newResponseMessages);
-    promptMessages.push(
-      ...newResponseMessages.map(convertToLanguageModelMessage)
-    );
-  } while (
-    // there are tool calls:
-    currentToolCalls.length > 0 && // all current tool calls have results:
-    currentToolResults.length === currentToolCalls.length && // the number of roundtrips is less than the maximum:
-    roundtrips++ < maxToolRoundtrips
-  );
-  return new GenerateTextResult({
-    // Always return a string so that the caller doesn't have to check for undefined.
-    // If they need to check if the model did not return any text,
-    // they can check the length of the string:
-    text: (_c = currentModelResponse.text) != null ? _c : "",
-    toolCalls: currentToolCalls,
-    toolResults: currentToolResults,
-    finishReason: currentModelResponse.finishReason,
-    usage: calculateCompletionTokenUsage(currentModelResponse.usage),
-    warnings: currentModelResponse.warnings,
-    rawResponse: currentModelResponse.rawResponse,
-    logprobs: currentModelResponse.logprobs,
-    responseMessages
+      const mode = {
+        type: "regular",
+        ...prepareToolsAndToolChoice({ tools, toolChoice })
+      };
+      const callSettings = prepareCallSettings(settings);
+      const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+      let currentModelResponse;
+      let currentToolCalls = [];
+      let currentToolResults = [];
+      let roundtrips = 0;
+      const responseMessages = [];
+      do {
+        const currentInputFormat = roundtrips === 0 ? validatedPrompt.type : "messages";
+        currentModelResponse = await retry(
+          () => recordSpan({
+            name: "ai.generateText.doGenerate",
+            attributes: {
+              ...baseTelemetryAttributes,
+              "ai.prompt.format": currentInputFormat,
+              "ai.prompt.messages": JSON.stringify(promptMessages)
+            },
+            tracer,
+            fn: async (span2) => {
+              const result = await model.doGenerate({
+                mode,
+                ...callSettings,
+                inputFormat: currentInputFormat,
+                prompt: promptMessages,
+                abortSignal,
+                headers
+              });
+              span2.setAttributes({
+                "ai.finishReason": result.finishReason,
+                "ai.usage.promptTokens": result.usage.promptTokens,
+                "ai.usage.completionTokens": result.usage.completionTokens,
+                "ai.result.text": result.text,
+                "ai.result.toolCalls": JSON.stringify(result.toolCalls)
+              });
+              return result;
+            }
+          })
+        );
+        currentToolCalls = ((_a2 = currentModelResponse.toolCalls) != null ? _a2 : []).map(
+          (modelToolCall) => parseToolCall({ toolCall: modelToolCall, tools })
+        );
+        currentToolResults = tools == null ? [] : await executeTools({
+          toolCalls: currentToolCalls,
+          tools,
+          tracer
+        });
+        const newResponseMessages = toResponseMessages({
+          text: (_b = currentModelResponse.text) != null ? _b : "",
+          toolCalls: currentToolCalls,
+          toolResults: currentToolResults
+        });
+        responseMessages.push(...newResponseMessages);
+        promptMessages.push(
+          ...newResponseMessages.map(convertToLanguageModelMessage)
+        );
+      } while (
+        // there are tool calls:
+        currentToolCalls.length > 0 && // all current tool calls have results:
+        currentToolResults.length === currentToolCalls.length && // the number of roundtrips is less than the maximum:
+        roundtrips++ < maxToolRoundtrips
+      );
+      span.setAttributes({
+        "ai.finishReason": currentModelResponse.finishReason,
+        "ai.usage.promptTokens": currentModelResponse.usage.promptTokens,
+        "ai.usage.completionTokens": currentModelResponse.usage.completionTokens,
+        "ai.result.text": currentModelResponse.text,
+        "ai.result.toolCalls": JSON.stringify(currentModelResponse.toolCalls)
+      });
+      return new GenerateTextResult({
+        // Always return a string so that the caller doesn't have to check for undefined.
+        // If they need to check if the model did not return any text,
+        // they can check the length of the string:
+        text: (_c = currentModelResponse.text) != null ? _c : "",
+        toolCalls: currentToolCalls,
+        toolResults: currentToolResults,
+        finishReason: currentModelResponse.finishReason,
+        usage: calculateCompletionTokenUsage(currentModelResponse.usage),
+        warnings: currentModelResponse.warnings,
+        rawResponse: currentModelResponse.rawResponse,
+        logprobs: currentModelResponse.logprobs,
+        responseMessages
+      });
+    }
   });
 }
 async function executeTools({
   toolCalls,
-  tools
+  tools,
+  tracer
 }) {
   const toolResults = await Promise.all(
     toolCalls.map(async (toolCall) => {
@@ -1238,7 +1446,25 @@ async function executeTools({
       if ((tool2 == null ? void 0 : tool2.execute) == null) {
         return void 0;
       }
-      const result = await tool2.execute(toolCall.args);
+      const result = await recordSpan({
+        name: "ai.toolCall",
+        attributes: {
+          "ai.toolCall.name": toolCall.toolName,
+          "ai.toolCall.id": toolCall.toolCallId,
+          "ai.toolCall.args": JSON.stringify(toolCall.args)
+        },
+        tracer,
+        fn: async (span) => {
+          const result2 = await tool2.execute(toolCall.args);
+          try {
+            span.setAttributes({
+              "ai.toolCall.result": JSON.stringify(result2)
+            });
+          } catch (ignored) {
+          }
+          return result2;
+        }
+      });
       return {
         toolCallId: toolCall.toolCallId,
         toolName: toolCall.toolName,
@@ -1294,7 +1520,8 @@ import { NoSuchToolError as NoSuchToolError2 } from "@ai-sdk/provider";
 import { generateId } from "@ai-sdk/ui-utils";
 function runToolsTransformation({
   tools,
-  generatorStream
+  generatorStream,
+  tracer
 }) {
   let canClose = false;
   const outstandingToolCalls = /* @__PURE__ */ new Set();
@@ -1342,29 +1569,44 @@ function runToolsTransformation({
             if (tool2.execute != null) {
               const toolExecutionId = generateId();
               outstandingToolCalls.add(toolExecutionId);
-              tool2.execute(toolCall.args).then(
-                (result) => {
-                  toolResultsStreamController.enqueue({
-                    ...toolCall,
-                    type: "tool-result",
-                    result
-                  });
-                  outstandingToolCalls.delete(toolExecutionId);
-                  if (canClose && outstandingToolCalls.size === 0) {
-                    toolResultsStreamController.close();
-                  }
+              recordSpan({
+                name: "ai.toolCall",
+                attributes: {
+                  "ai.toolCall.name": toolCall.toolName,
+                  "ai.toolCall.id": toolCall.toolCallId,
+                  "ai.toolCall.args": JSON.stringify(toolCall.args)
                 },
-                (error) => {
-                  toolResultsStreamController.enqueue({
-                    type: "error",
-                    error
-                  });
-                  outstandingToolCalls.delete(toolExecutionId);
-                  if (canClose && outstandingToolCalls.size === 0) {
-                    toolResultsStreamController.close();
+                tracer,
+                fn: async (span) => tool2.execute(toolCall.args).then(
+                  (result) => {
+                    toolResultsStreamController.enqueue({
+                      ...toolCall,
+                      type: "tool-result",
+                      result
+                    });
+                    outstandingToolCalls.delete(toolExecutionId);
+                    if (canClose && outstandingToolCalls.size === 0) {
+                      toolResultsStreamController.close();
+                    }
+                    try {
+                      span.setAttributes({
+                        "ai.toolCall.result": JSON.stringify(result)
+                      });
+                    } catch (ignored) {
+                    }
+                  },
+                  (error) => {
+                    toolResultsStreamController.enqueue({
+                      type: "error",
+                      error
+                    });
+                    outstandingToolCalls.delete(toolExecutionId);
+                    if (canClose && outstandingToolCalls.size === 0) {
+                      toolResultsStreamController.close();
+                    }
                   }
-                }
-              );
+                )
+              });
             }
           } catch (error) {
             toolResultsStreamController.enqueue({
@@ -1437,32 +1679,76 @@ async function streamText({
   maxRetries,
   abortSignal,
   headers,
+  experimental_telemetry: telemetry,
   onFinish,
   ...settings
 }) {
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
-  const { stream, warnings, rawResponse } = await retry(
-    () => model.doStream({
-      mode: {
-        type: "regular",
-        ...prepareToolsAndToolChoice({ tools, toolChoice })
-      },
-      ...prepareCallSettings(settings),
-      inputFormat: validatedPrompt.type,
-      prompt: convertToLanguageModelPrompt(validatedPrompt),
-      abortSignal,
-      headers
-    })
-  );
-  return new StreamTextResult({
-    stream: runToolsTransformation({
-      tools,
-      generatorStream: stream
-    }),
-    warnings,
-    rawResponse,
-    onFinish
+  var _a;
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    operationName: "ai.streamText",
+    model,
+    telemetry,
+    headers,
+    settings: { ...settings, maxRetries }
+  });
+  const tracer = getTracer({ isEnabled: (_a = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a : false });
+  return recordSpan({
+    name: "ai.streamText",
+    attributes: {
+      ...baseTelemetryAttributes,
+      // specific settings that only make sense on the outer level:
+      "ai.prompt": JSON.stringify({ system, prompt, messages })
+    },
+    tracer,
+    endWhenDone: false,
+    fn: async (rootSpan) => {
+      const retry = retryWithExponentialBackoff({ maxRetries });
+      const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+      const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+      const {
+        result: { stream, warnings, rawResponse },
+        doStreamSpan
+      } = await retry(
+        () => recordSpan({
+          name: "ai.streamText.doStream",
+          attributes: {
+            ...baseTelemetryAttributes,
+            "ai.prompt.format": validatedPrompt.type,
+            "ai.prompt.messages": JSON.stringify(promptMessages)
+          },
+          tracer,
+          endWhenDone: false,
+          fn: async (doStreamSpan2) => {
+            return {
+              result: await model.doStream({
+                mode: {
+                  type: "regular",
+                  ...prepareToolsAndToolChoice({ tools, toolChoice })
+                },
+                ...prepareCallSettings(settings),
+                inputFormat: validatedPrompt.type,
+                prompt: promptMessages,
+                abortSignal,
+                headers
+              }),
+              doStreamSpan: doStreamSpan2
+            };
+          }
+        })
+      );
+      return new StreamTextResult({
+        stream: runToolsTransformation({
+          tools,
+          generatorStream: stream,
+          tracer
+        }),
+        warnings,
+        rawResponse,
+        onFinish,
+        rootSpan,
+        doStreamSpan
+      });
+    }
   });
 }
 var StreamTextResult = class {
@@ -1470,7 +1756,9 @@ var StreamTextResult = class {
     stream,
     warnings,
     rawResponse,
-    onFinish
+    onFinish,
+    rootSpan,
+    doStreamSpan
   }) {
     this.warnings = warnings;
     this.rawResponse = rawResponse;
@@ -1500,41 +1788,73 @@ var StreamTextResult = class {
     let text = "";
     const toolCalls = [];
     const toolResults = [];
+    let firstChunk = true;
     const self = this;
     this.originalStream = stream.pipeThrough(
       new TransformStream({
         async transform(chunk, controller) {
           controller.enqueue(chunk);
-          if (chunk.type === "text-delta") {
-            text += chunk.textDelta;
-          }
-          if (chunk.type === "tool-call") {
-            toolCalls.push(chunk);
+          if (firstChunk) {
+            firstChunk = false;
+            doStreamSpan.addEvent("ai.stream.firstChunk");
           }
-          if (chunk.type === "tool-result") {
-            toolResults.push(chunk);
-          }
-          if (chunk.type === "finish") {
-            usage = chunk.usage;
-            finishReason = chunk.finishReason;
-            resolveUsage(usage);
-            resolveFinishReason(finishReason);
-            resolveText(text);
-            resolveToolCalls(toolCalls);
+          const chunkType = chunk.type;
+          switch (chunkType) {
+            case "text-delta":
+              text += chunk.textDelta;
+              break;
+            case "tool-call":
+              toolCalls.push(chunk);
+              break;
+            case "tool-result":
+              toolResults.push(chunk);
+              break;
+            case "finish":
+              usage = chunk.usage;
+              finishReason = chunk.finishReason;
+              resolveUsage(usage);
+              resolveFinishReason(finishReason);
+              resolveText(text);
+              resolveToolCalls(toolCalls);
+              break;
+            case "error":
+              break;
+            default: {
+              const exhaustiveCheck = chunkType;
+              throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
+            }
           }
         },
         // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
         async flush(controller) {
           var _a;
           try {
+            const finalUsage = usage != null ? usage : {
+              promptTokens: NaN,
+              completionTokens: NaN,
+              totalTokens: NaN
+            };
+            const finalFinishReason = finishReason != null ? finishReason : "unknown";
+            const telemetryToolCalls = toolCalls.length > 0 ? JSON.stringify(toolCalls) : void 0;
+            doStreamSpan.setAttributes({
+              "ai.finishReason": finalFinishReason,
+              "ai.usage.promptTokens": finalUsage.promptTokens,
+              "ai.usage.completionTokens": finalUsage.completionTokens,
+              "ai.result.text": text,
+              "ai.result.toolCalls": telemetryToolCalls
+            });
+            doStreamSpan.end();
+            rootSpan.setAttributes({
+              "ai.finishReason": finalFinishReason,
+              "ai.usage.promptTokens": finalUsage.promptTokens,
+              "ai.usage.completionTokens": finalUsage.completionTokens,
+              "ai.result.text": text,
+              "ai.result.toolCalls": telemetryToolCalls
+            });
             resolveToolResults(toolResults);
             await ((_a = self.onFinish) == null ? void 0 : _a.call(self, {
-              finishReason: finishReason != null ? finishReason : "unknown",
-              usage: usage != null ? usage : {
-                promptTokens: NaN,
-                completionTokens: NaN,
-                totalTokens: NaN
-              },
+              finishReason: finalFinishReason,
+              usage: finalUsage,
               text,
               toolCalls,
               // The tool results are inferred as a never[] type, because they are
@@ -1547,6 +1867,8 @@ var StreamTextResult = class {
             }));
           } catch (error) {
             controller.error(error);
+          } finally {
+            rootSpan.end();
           }
         }
       })