ai 5.0.0-beta.31 → 5.0.0-beta.33

package/dist/index.mjs

@@ -1823,12 +1823,15 @@ function createToolModelOutput({
   if (errorMode === "text") {
     return { type: "error-text", value: getErrorMessage4(output) };
   } else if (errorMode === "json") {
-    return { type: "error-json", value: output };
+    return { type: "error-json", value: toJSONValue(output) };
   }
   if (tool3 == null ? void 0 : tool3.toModelOutput) {
     return tool3.toModelOutput(output);
   }
-  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output };
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
+}
+function toJSONValue(value) {
+  return value === void 0 ? null : value;
 }
 
 // src/generate-text/to-response-messages.ts
@@ -5341,7 +5344,7 @@ async function embed({
     }),
     tracer,
     fn: async (span) => {
-      const { embedding, usage, response } = await retry(
+      const { embedding, usage, response, providerMetadata } = await retry(
         () => (
           // nested spans to align with the embedMany telemetry data:
           recordSpan({
@@ -5385,6 +5388,7 @@ async function embed({
               return {
                 embedding: embedding2,
                 usage: usage2,
+                providerMetadata: modelResponse.providerMetadata,
                 response: modelResponse.response
               };
             }
@@ -5404,6 +5408,7 @@ async function embed({
         value,
         embedding,
         usage,
+        providerMetadata,
         response
       });
     }
@@ -5414,6 +5419,7 @@ var DefaultEmbedResult = class {
     this.value = options.value;
     this.embedding = options.embedding;
     this.usage = options.usage;
+    this.providerMetadata = options.providerMetadata;
     this.response = options.response;
   }
 };
@@ -5471,58 +5477,64 @@ async function embedMany({
     }),
     tracer,
     fn: async (span) => {
+      var _a16;
       const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all([
         model.maxEmbeddingsPerCall,
         model.supportsParallelCalls
       ]);
       if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
-        const { embeddings: embeddings2, usage, response } = await retry(() => {
-          return recordSpan({
-            name: "ai.embedMany.doEmbed",
-            attributes: selectTelemetryAttributes({
-              telemetry,
-              attributes: {
-                ...assembleOperationName({
-                  operationId: "ai.embedMany.doEmbed",
-                  telemetry
-                }),
-                ...baseTelemetryAttributes,
-                // specific settings that only make sense on the outer level:
-                "ai.values": {
-                  input: () => values.map((value) => JSON.stringify(value))
+        const { embeddings: embeddings2, usage, response, providerMetadata: providerMetadata2 } = await retry(
+          () => {
+            return recordSpan({
+              name: "ai.embedMany.doEmbed",
+              attributes: selectTelemetryAttributes({
+                telemetry,
+                attributes: {
+                  ...assembleOperationName({
+                    operationId: "ai.embedMany.doEmbed",
+                    telemetry
+                  }),
+                  ...baseTelemetryAttributes,
+                  // specific settings that only make sense on the outer level:
+                  "ai.values": {
+                    input: () => values.map((value) => JSON.stringify(value))
+                  }
                 }
+              }),
+              tracer,
+              fn: async (doEmbedSpan) => {
+                var _a17;
+                const modelResponse = await model.doEmbed({
+                  values,
+                  abortSignal,
+                  headers,
+                  providerOptions
+                });
+                const embeddings3 = modelResponse.embeddings;
+                const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
+                doEmbedSpan.setAttributes(
+                  selectTelemetryAttributes({
+                    telemetry,
+                    attributes: {
+                      "ai.embeddings": {
+                        output: () => embeddings3.map(
+                          (embedding) => JSON.stringify(embedding)
+                        )
+                      },
+                      "ai.usage.tokens": usage2.tokens
+                    }
+                  })
+                );
+                return {
+                  embeddings: embeddings3,
+                  usage: usage2,
+                  providerMetadata: modelResponse.providerMetadata,
+                  response: modelResponse.response
+                };
               }
-            }),
-            tracer,
-            fn: async (doEmbedSpan) => {
-              var _a16;
-              const modelResponse = await model.doEmbed({
-                values,
-                abortSignal,
-                headers,
-                providerOptions
-              });
-              const embeddings3 = modelResponse.embeddings;
-              const usage2 = (_a16 = modelResponse.usage) != null ? _a16 : { tokens: NaN };
-              doEmbedSpan.setAttributes(
-                selectTelemetryAttributes({
-                  telemetry,
-                  attributes: {
-                    "ai.embeddings": {
-                      output: () => embeddings3.map((embedding) => JSON.stringify(embedding))
-                    },
-                    "ai.usage.tokens": usage2.tokens
-                  }
-                })
-              );
-              return {
-                embeddings: embeddings3,
-                usage: usage2,
-                response: modelResponse.response
-              };
-            }
-          });
-        });
+            });
+          }
+        );
         span.setAttributes(
           selectTelemetryAttributes({
             telemetry,
@@ -5538,6 +5550,7 @@ async function embedMany({
           values,
           embeddings: embeddings2,
           usage,
+          providerMetadata: providerMetadata2,
           responses: [response]
         });
       }
@@ -5545,6 +5558,7 @@ async function embedMany({
       const embeddings = [];
       const responses = [];
       let tokens = 0;
+      let providerMetadata;
       const parallelChunks = splitArray(
         valueChunks,
         supportsParallelCalls ? maxParallelCalls : 1
@@ -5571,7 +5585,7 @@ async function embedMany({
                 }),
                 tracer,
                 fn: async (doEmbedSpan) => {
-                  var _a16;
+                  var _a17;
                   const modelResponse = await model.doEmbed({
                     values: chunk,
                     abortSignal,
@@ -5579,7 +5593,7 @@ async function embedMany({
                     providerOptions
                   });
                   const embeddings2 = modelResponse.embeddings;
-                  const usage = (_a16 = modelResponse.usage) != null ? _a16 : { tokens: NaN };
+                  const usage = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
                   doEmbedSpan.setAttributes(
                     selectTelemetryAttributes({
                       telemetry,
@@ -5596,6 +5610,7 @@ async function embedMany({
                   return {
                     embeddings: embeddings2,
                     usage,
+                    providerMetadata: modelResponse.providerMetadata,
                     response: modelResponse.response
                   };
                 }
@@ -5607,6 +5622,20 @@ async function embedMany({
           embeddings.push(...result.embeddings);
           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] = {
+                  ...(_a16 = providerMetadata[providerName]) != null ? _a16 : {},
+                  ...metadata
+                };
+              }
+            }
+          }
         }
       }
       span.setAttributes(
@@ -5624,6 +5653,7 @@ async function embedMany({
         values,
         embeddings,
         usage: { tokens },
+        providerMetadata,
         responses
       });
     }
@@ -5634,6 +5664,7 @@ var DefaultEmbedManyResult = class {
     this.values = options.values;
     this.embeddings = options.embeddings;
     this.usage = options.usage;
+    this.providerMetadata = options.providerMetadata;
     this.responses = options.responses;
   }
 };
@@ -6650,6 +6681,7 @@ var DefaultStreamObjectResult = class {
     this._warnings = new DelayedPromise();
     this._request = new DelayedPromise();
     this._response = new DelayedPromise();
+    this._finishReason = new DelayedPromise();
     const model = resolveLanguageModel(modelArg);
     const { maxRetries, retry } = prepareRetries({
       maxRetries: maxRetriesArg
@@ -6869,6 +6901,7 @@ var DefaultStreamObjectResult = class {
                     ...fullResponse,
                     headers: response == null ? void 0 : response.headers
                   });
+                  self._finishReason.resolve(finishReason != null ? finishReason : "unknown");
                   const validationResult = await outputStrategy.validateFinalResult(
                     latestObjectJson,
                     {
@@ -7003,6 +7036,9 @@ var DefaultStreamObjectResult = class {
   get response() {
     return this._response.promise;
   }
+  get finishReason() {
+    return this._finishReason.promise;
+  }
   get partialObjectStream() {
     return createAsyncIterableStream(
       this.baseStream.pipeThrough(
@@ -7867,38 +7903,38 @@ var SUPPORTED_PROTOCOL_VERSIONS = [
   "2025-03-26",
   "2024-11-05"
 ];
-var ClientOrServerImplementationSchema = z8.object({
+var ClientOrServerImplementationSchema = z8.looseObject({
   name: z8.string(),
   version: z8.string()
-}).passthrough();
-var BaseParamsSchema = z8.object({
-  _meta: z8.optional(z8.object({}).passthrough())
-}).passthrough();
+});
+var BaseParamsSchema = z8.looseObject({
+  _meta: z8.optional(z8.object({}).loose())
+});
 var ResultSchema = BaseParamsSchema;
 var RequestSchema = z8.object({
   method: z8.string(),
   params: z8.optional(BaseParamsSchema)
 });
-var ServerCapabilitiesSchema = z8.object({
-  experimental: z8.optional(z8.object({}).passthrough()),
-  logging: z8.optional(z8.object({}).passthrough()),
+var ServerCapabilitiesSchema = z8.looseObject({
+  experimental: z8.optional(z8.object({}).loose()),
+  logging: z8.optional(z8.object({}).loose()),
   prompts: z8.optional(
-    z8.object({
+    z8.looseObject({
       listChanged: z8.optional(z8.boolean())
-    }).passthrough()
+    })
   ),
   resources: z8.optional(
-    z8.object({
+    z8.looseObject({
       subscribe: z8.optional(z8.boolean()),
       listChanged: z8.optional(z8.boolean())
-    }).passthrough()
+    })
   ),
   tools: z8.optional(
-    z8.object({
+    z8.looseObject({
       listChanged: z8.optional(z8.boolean())
-    }).passthrough()
+    })
   )
-}).passthrough();
+});
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: z8.string(),
   capabilities: ServerCapabilitiesSchema,
@@ -7913,21 +7949,21 @@ var ToolSchema = z8.object({
   description: z8.optional(z8.string()),
   inputSchema: z8.object({
     type: z8.literal("object"),
-    properties: z8.optional(z8.object({}).passthrough())
-  }).passthrough()
-}).passthrough();
+    properties: z8.optional(z8.object({}).loose())
+  }).loose()
+}).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
   tools: z8.array(ToolSchema)
 });
 var TextContentSchema = z8.object({
   type: z8.literal("text"),
   text: z8.string()
-}).passthrough();
+}).loose();
 var ImageContentSchema = z8.object({
   type: z8.literal("image"),
-  data: z8.string().base64(),
+  data: z8.base64(),
   mimeType: z8.string()
-}).passthrough();
+}).loose();
 var ResourceContentsSchema = z8.object({
   /**
    * The URI of this resource.
@@ -7937,17 +7973,17 @@ var ResourceContentsSchema = z8.object({
    * The MIME type of this resource, if known.
    */
   mimeType: z8.optional(z8.string())
-}).passthrough();
+}).loose();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
   text: z8.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: z8.string().base64()
+  blob: z8.base64()
 });
 var EmbeddedResourceSchema = z8.object({
   type: z8.literal("resource"),
   resource: z8.union([TextResourceContentsSchema, BlobResourceContentsSchema])
-}).passthrough();
+}).loose();
 var CallToolResultSchema = ResultSchema.extend({
   content: z8.array(
     z8.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
@@ -8145,11 +8181,11 @@ function isCustomMcpTransport(transport) {
 // src/tool/mcp/mcp-client.ts
 var CLIENT_VERSION = "1.0.0";
 async function createMCPClient(config) {
-  const client = new MCPClient(config);
+  const client = new DefaultMCPClient(config);
   await client.init();
   return client;
 }
-var MCPClient = class {
+var DefaultMCPClient = class {
   constructor({
     transport: transportConfig,
     name: name16 = "ai-sdk-mcp-client",