ai 7.0.22 → 7.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.22",
+  "version": "7.0.23",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.16",
+    "@ai-sdk/gateway": "4.0.17",
     "@ai-sdk/provider": "4.0.3",
     "@ai-sdk/provider-utils": "5.0.7"
   },

package/src/embed/embed-many.ts

@@ -171,236 +171,248 @@ export async function embedMany({
     telemetry,
   });
 
-  await notify({
-    event: {
-      callId,
-      operationId: 'ai.embedMany',
-      provider: model.provider,
-      modelId: model.modelId,
-      value: values,
-      maxRetries,
-      headers: headersWithUserAgent,
-      providerOptions,
-    },
-    callbacks: [resolvedOnStart, telemetryDispatcher.onStart],
-  });
-
-  try {
-    const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all([
-      model.maxEmbeddingsPerCall,
-      model.supportsParallelCalls,
-    ]);
+  const runInTracingChannelSpan =
+    telemetryDispatcher.runInTracingChannelSpan ??
+    (async <T>({ execute }: { execute: () => PromiseLike<T> }) =>
+      await execute());
+
+  const startEvent = {
+    callId,
+    operationId: 'ai.embedMany',
+    provider: model.provider,
+    modelId: model.modelId,
+    value: values,
+    maxRetries,
+    headers: headersWithUserAgent,
+    providerOptions,
+  };
 
-    if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
-      const { embeddings, usage, warnings, response, providerMetadata } =
-        await retry(async () => {
-          const embedCallId = generateCallId();
+  return await runInTracingChannelSpan({
+    type: 'embedMany',
+    event: startEvent,
+    execute: async () => {
+      await notify({
+        event: startEvent,
+        callbacks: [resolvedOnStart, telemetryDispatcher.onStart],
+      });
 
-          await notify({
-            event: {
-              callId,
-              embedCallId,
-              operationId: 'ai.embedMany.doEmbed',
-              provider: model.provider,
-              modelId: model.modelId,
-              values,
-            },
-            callbacks: [telemetryDispatcher.onEmbedStart],
-          });
+      try {
+        const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all(
+          [model.maxEmbeddingsPerCall, model.supportsParallelCalls],
+        );
+
+        if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
+          const { embeddings, usage, warnings, response, providerMetadata } =
+            await retry(async () => {
+              const embedCallId = generateCallId();
+
+              await notify({
+                event: {
+                  callId,
+                  embedCallId,
+                  operationId: 'ai.embedMany.doEmbed',
+                  provider: model.provider,
+                  modelId: model.modelId,
+                  values,
+                },
+                callbacks: [telemetryDispatcher.onEmbedStart],
+              });
+
+              const modelResponse = await model.doEmbed({
+                values,
+                abortSignal,
+                headers: headersWithUserAgent,
+                providerOptions,
+              });
+
+              const embeddings = modelResponse.embeddings;
+              const usage = modelResponse.usage ?? { tokens: NaN };
+
+              await notify({
+                event: {
+                  callId,
+                  embedCallId,
+                  operationId: 'ai.embedMany.doEmbed',
+                  provider: model.provider,
+                  modelId: model.modelId,
+                  values,
+                  embeddings,
+                  usage,
+                },
+                callbacks: [telemetryDispatcher.onEmbedEnd],
+              });
+
+              return {
+                embeddings,
+                usage,
+                warnings: modelResponse.warnings ?? [],
+                providerMetadata: modelResponse.providerMetadata,
+                response: modelResponse.response,
+              };
+            });
 
-          const modelResponse = await model.doEmbed({
-            values,
-            abortSignal,
-            headers: headersWithUserAgent,
-            providerOptions,
+          logWarnings({
+            warnings,
+            provider: model.provider,
+            model: model.modelId,
           });
 
-          const embeddings = modelResponse.embeddings;
-          const usage = modelResponse.usage ?? { tokens: NaN };
-
           await notify({
             event: {
               callId,
-              embedCallId,
-              operationId: 'ai.embedMany.doEmbed',
+              operationId: 'ai.embedMany',
               provider: model.provider,
               modelId: model.modelId,
-              values,
-              embeddings,
+              value: values,
+              embedding: embeddings,
               usage,
+              warnings,
+              providerMetadata,
+              response: [response],
             },
-            callbacks: [telemetryDispatcher.onEmbedEnd],
+            callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd],
           });
 
-          return {
+          return new DefaultEmbedManyResult({
+            values,
             embeddings,
             usage,
-            warnings: modelResponse.warnings ?? [],
-            providerMetadata: modelResponse.providerMetadata,
-            response: modelResponse.response,
-          };
-        });
-
-      logWarnings({
-        warnings,
-        provider: model.provider,
-        model: model.modelId,
-      });
-
-      await notify({
-        event: {
-          callId,
-          operationId: 'ai.embedMany',
-          provider: model.provider,
-          modelId: model.modelId,
-          value: values,
-          embedding: embeddings,
-          usage,
-          warnings,
-          providerMetadata,
-          response: [response],
-        },
-        callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd],
-      });
-
-      return new DefaultEmbedManyResult({
-        values,
-        embeddings,
-        usage,
-        warnings,
-        providerMetadata,
-        responses: [response],
-      });
-    }
-
-    const valueChunks = splitArray(values, maxEmbeddingsPerCall);
-
-    const embeddings: Array<Embedding> = [];
-    const warnings: Array<Warning> = [];
-    const responses: Array<
-      | {
-          headers?: Record<string, string>;
-          body?: unknown;
+            warnings,
+            providerMetadata,
+            responses: [response],
+          });
         }
-      | undefined
-    > = [];
-    let tokens = 0;
-    let providerMetadata: ProviderMetadata | undefined;
-
-    const parallelChunks = splitArray(
-      valueChunks,
-      supportsParallelCalls ? maxParallelCalls : 1,
-    );
-
-    for (const parallelChunk of parallelChunks) {
-      const results = await Promise.all(
-        parallelChunk.map(chunk => {
-          return retry(async () => {
-            const embedCallId = generateCallId();
-
-            await notify({
-              event: {
-                callId,
-                embedCallId,
-                operationId: 'ai.embedMany.doEmbed',
-                provider: model.provider,
-                modelId: model.modelId,
-                values: chunk,
-              },
-              callbacks: [telemetryDispatcher.onEmbedStart],
-            });
 
-            const modelResponse = await model.doEmbed({
-              values: chunk,
-              abortSignal,
-              headers: headersWithUserAgent,
-              providerOptions,
-            });
+        const valueChunks = splitArray(values, maxEmbeddingsPerCall);
 
-            const chunkEmbeddings = modelResponse.embeddings;
-            const usage = modelResponse.usage ?? { tokens: NaN };
-
-            await notify({
-              event: {
-                callId,
-                embedCallId,
-                operationId: 'ai.embedMany.doEmbed',
-                provider: model.provider,
-                modelId: model.modelId,
-                values: chunk,
-                embeddings: chunkEmbeddings,
-                usage,
-              },
-              callbacks: [telemetryDispatcher.onEmbedEnd],
-            });
-
-            return {
-              embeddings: chunkEmbeddings,
-              usage,
-              warnings: modelResponse.warnings ?? [],
-              providerMetadata: modelResponse.providerMetadata,
-              response: modelResponse.response,
-            };
-          });
-        }),
-      );
-
-      for (const result of results) {
-        embeddings.push(...result.embeddings);
-        warnings.push(...result.warnings);
-        responses.push(result.response);
-        tokens += result.usage.tokens;
-        if (result.providerMetadata) {
-          if (!providerMetadata) {
-            providerMetadata = { ...result.providerMetadata };
-          } else {
-            for (const [providerName, metadata] of Object.entries(
-              result.providerMetadata,
-            )) {
-              providerMetadata[providerName] = {
-                ...(providerMetadata[providerName] ?? {}),
-                ...metadata,
-              };
+        const embeddings: Array<Embedding> = [];
+        const warnings: Array<Warning> = [];
+        const responses: Array<
+          | {
+              headers?: Record<string, string>;
+              body?: unknown;
+            }
+          | undefined
+        > = [];
+        let tokens = 0;
+        let providerMetadata: ProviderMetadata | undefined;
+
+        const parallelChunks = splitArray(
+          valueChunks,
+          supportsParallelCalls ? maxParallelCalls : 1,
+        );
+
+        for (const parallelChunk of parallelChunks) {
+          const results = await Promise.all(
+            parallelChunk.map(chunk => {
+              return retry(async () => {
+                const embedCallId = generateCallId();
+
+                await notify({
+                  event: {
+                    callId,
+                    embedCallId,
+                    operationId: 'ai.embedMany.doEmbed',
+                    provider: model.provider,
+                    modelId: model.modelId,
+                    values: chunk,
+                  },
+                  callbacks: [telemetryDispatcher.onEmbedStart],
+                });
+
+                const modelResponse = await model.doEmbed({
+                  values: chunk,
+                  abortSignal,
+                  headers: headersWithUserAgent,
+                  providerOptions,
+                });
+
+                const chunkEmbeddings = modelResponse.embeddings;
+                const usage = modelResponse.usage ?? { tokens: NaN };
+
+                await notify({
+                  event: {
+                    callId,
+                    embedCallId,
+                    operationId: 'ai.embedMany.doEmbed',
+                    provider: model.provider,
+                    modelId: model.modelId,
+                    values: chunk,
+                    embeddings: chunkEmbeddings,
+                    usage,
+                  },
+                  callbacks: [telemetryDispatcher.onEmbedEnd],
+                });
+
+                return {
+                  embeddings: chunkEmbeddings,
+                  usage,
+                  warnings: modelResponse.warnings ?? [],
+                  providerMetadata: modelResponse.providerMetadata,
+                  response: modelResponse.response,
+                };
+              });
+            }),
+          );
+
+          for (const result of results) {
+            embeddings.push(...result.embeddings);
+            warnings.push(...result.warnings);
+            responses.push(result.response);
+            tokens += result.usage.tokens;
+            if (result.providerMetadata) {
+              if (!providerMetadata) {
+                providerMetadata = { ...result.providerMetadata };
+              } else {
+                for (const [providerName, metadata] of Object.entries(
+                  result.providerMetadata,
+                )) {
+                  providerMetadata[providerName] = {
+                    ...(providerMetadata[providerName] ?? {}),
+                    ...metadata,
+                  };
+                }
+              }
             }
           }
         }
+
+        logWarnings({
+          warnings,
+          provider: model.provider,
+          model: model.modelId,
+        });
+
+        await notify({
+          event: {
+            callId,
+            operationId: 'ai.embedMany',
+            provider: model.provider,
+            modelId: model.modelId,
+            value: values,
+            embedding: embeddings,
+            usage: { tokens },
+            warnings,
+            providerMetadata,
+            response: responses,
+          },
+          callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd],
+        });
+
+        return new DefaultEmbedManyResult({
+          values,
+          embeddings,
+          usage: { tokens },
+          warnings,
+          providerMetadata: providerMetadata,
+          responses,
+        });
+      } catch (error) {
+        await telemetryDispatcher.onError?.({ callId, error });
+        throw error;
       }
-    }
-
-    logWarnings({
-      warnings,
-      provider: model.provider,
-      model: model.modelId,
-    });
-
-    await notify({
-      event: {
-        callId,
-        operationId: 'ai.embedMany',
-        provider: model.provider,
-        modelId: model.modelId,
-        value: values,
-        embedding: embeddings,
-        usage: { tokens },
-        warnings,
-        providerMetadata,
-        response: responses,
-      },
-      callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd],
-    });
-
-    return new DefaultEmbedManyResult({
-      values,
-      embeddings,
-      usage: { tokens },
-      warnings,
-      providerMetadata: providerMetadata,
-      responses,
-    });
-  } catch (error) {
-    await telemetryDispatcher.onError?.({ callId, error });
-    throw error;
-  }
+    },
+  });
 }
 
 class DefaultEmbedManyResult implements EmbedManyResult {

package/src/telemetry/tracing-channel.ts

@@ -7,6 +7,7 @@ export type TelemetryTracingEventType =
   | 'languageModelCall'
   | 'executeTool'
   | 'embed'
+  | 'embedMany'
   | 'rerank';
 
 export type TelemetryTracingChannelMessage<EVENT = unknown> = {