@ai-sdk/google-vertex 0.0.40 → 0.0.43

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @ai-sdk/google-vertex
 
+## 0.0.43
+
+### Patch Changes
+
+- 4360e2d: feat (provider/vertex): expose search grounding metadata
+- e7823a3: feat (provider/vertex): add embedding support
+
+## 0.0.42
+
+### Patch Changes
+
+- aa98cdb: chore: more flexible dependency versioning
+- 1486128: feat: add supportsUrl to language model specification
+- 1486128: feat (provider/google): support native file URLs without download
+- 3b1b69a: feat: provider-defined tools
+- Updated dependencies [aa98cdb]
+- Updated dependencies [1486128]
+- Updated dependencies [7b937c5]
+- Updated dependencies [3b1b69a]
+- Updated dependencies [811a317]
+  - @ai-sdk/provider-utils@1.0.22
+  - @ai-sdk/provider@0.0.26
+
+## 0.0.41
+
+### Patch Changes
+
+- Updated dependencies [b9b0d7b]
+  - @ai-sdk/provider@0.0.25
+  - @ai-sdk/provider-utils@1.0.21
+
 ## 0.0.40
 
 ### Patch Changes

package/dist/index.js

@@ -26,14 +26,13 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/google-vertex-provider.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_vertexai2 = require("@google-cloud/vertexai");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_vertexai3 = require("@google-cloud/vertexai");
 
 // src/google-vertex-language-model.ts
 var import_provider2 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_vertexai = require("@google-cloud/vertexai");
+var import_vertexai2 = require("@google-cloud/vertexai");
 
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
@@ -107,7 +106,7 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema) {
 var import_provider = require("@ai-sdk/provider");
 var import_provider_utils = require("@ai-sdk/provider-utils");
 function convertToGoogleVertexContentRequest(prompt) {
-  var _a;
+  var _a, _b;
   const systemInstructionParts = [];
   const contents = [];
   let systemMessagesAllowed = true;
@@ -132,28 +131,35 @@ function convertToGoogleVertexContentRequest(prompt) {
               break;
             }
             case "image": {
-              if (part.image instanceof URL) {
-                throw new import_provider.UnsupportedFunctionalityError({
-                  functionality: "Image URLs in user messages"
-                });
-              }
-              parts.push({
-                inlineData: {
-                  mimeType: (_a = part.mimeType) != null ? _a : "image/jpeg",
-                  data: (0, import_provider_utils.convertUint8ArrayToBase64)(part.image)
+              parts.push(
+                part.image instanceof URL ? {
+                  fileData: {
+                    mimeType: (_a = part.mimeType) != null ? _a : "image/jpeg",
+                    fileUri: part.image.toString()
+                  }
+                } : {
+                  inlineData: {
+                    mimeType: (_b = part.mimeType) != null ? _b : "image/jpeg",
+                    data: (0, import_provider_utils.convertUint8ArrayToBase64)(part.image)
+                  }
                 }
-              });
+              );
               break;
             }
             case "file": {
-              if (part.data instanceof URL) {
-                throw new import_provider.UnsupportedFunctionalityError({
-                  functionality: "File URLs in user messages"
-                });
-              }
-              parts.push({
-                inlineData: { mimeType: part.mimeType, data: part.data }
-              });
+              parts.push(
+                part.data instanceof URL ? {
+                  fileData: {
+                    mimeType: part.mimeType,
+                    fileUri: part.data.toString()
+                  }
+                } : {
+                  inlineData: {
+                    mimeType: part.mimeType,
+                    data: part.data
+                  }
+                }
+              );
               break;
             }
             default: {
@@ -222,6 +228,89 @@ function convertToGoogleVertexContentRequest(prompt) {
   };
 }
 
+// src/google-vertex-prepare-tools.ts
+var import_vertexai = require("@google-cloud/vertexai");
+function prepareTools({
+  useSearchGrounding,
+  mode
+}) {
+  var _a, _b;
+  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+  const toolWarnings = [];
+  const vertexTools = [];
+  if (tools != null) {
+    const functionDeclarations = [];
+    for (const tool of tools) {
+      if (tool.type === "provider-defined") {
+        toolWarnings.push({ type: "unsupported-tool", tool });
+      } else {
+        functionDeclarations.push({
+          name: tool.name,
+          description: (_b = tool.description) != null ? _b : "",
+          parameters: convertJSONSchemaToOpenAPISchema(
+            tool.parameters
+          )
+        });
+      }
+    }
+    vertexTools.push({ functionDeclarations });
+  }
+  if (useSearchGrounding) {
+    vertexTools.push({ googleSearchRetrieval: {} });
+  }
+  const finalTools = vertexTools.length > 0 ? vertexTools : void 0;
+  const toolChoice = mode.toolChoice;
+  if (toolChoice == null) {
+    return {
+      tools: finalTools,
+      toolConfig: void 0,
+      toolWarnings
+    };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.AUTO }
+        },
+        toolWarnings
+      };
+    case "none":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.NONE }
+        },
+        toolWarnings
+      };
+    case "required":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.ANY }
+        },
+        toolWarnings
+      };
+    case "tool":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: {
+            mode: import_vertexai.FunctionCallingMode.ANY,
+            allowedFunctionNames: [toolChoice.toolName]
+          }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new Error(`Unsupported tool choice type: ${_exhaustiveCheck}`);
+    }
+  }
+}
+
 // src/map-google-vertex-finish-reason.ts
 function mapGoogleVertexFinishReason({
   finishReason,
@@ -314,19 +403,21 @@ var GoogleVertexLanguageModel = class {
     const type = mode.type;
     switch (type) {
       case "regular": {
+        const { tools, toolConfig, toolWarnings } = prepareTools({
+          mode,
+          useSearchGrounding: (_a = this.settings.useSearchGrounding) != null ? _a : false
+        });
         const configuration = {
           model: this.modelId,
           generationConfig,
-          ...prepareToolsAndToolConfig({
-            mode,
-            useSearchGrounding: (_a = this.settings.useSearchGrounding) != null ? _a : false
-          }),
+          tools,
+          toolConfig,
           safetySettings: this.settings.safetySettings
         };
         return {
           model: this.config.vertexAI.getGenerativeModel(configuration),
           contentRequest: convertToGoogleVertexContentRequest(prompt),
-          warnings
+          warnings: [...warnings, ...toolWarnings]
         };
       }
       case "object-json": {
@@ -366,7 +457,7 @@ var GoogleVertexLanguageModel = class {
             }
           ],
           toolConfig: {
-            functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.ANY }
+            functionCallingConfig: { mode: import_vertexai2.FunctionCallingMode.ANY }
           },
           safetySettings: this.settings.safetySettings
         };
@@ -382,6 +473,9 @@ var GoogleVertexLanguageModel = class {
       }
     }
   }
+  supportsUrl(url) {
+    return url.protocol === "gs:";
+  }
   async doGenerate(options) {
     var _a, _b, _c;
     const { model, contentRequest, warnings } = await this.getArgs(options);
@@ -411,6 +505,11 @@ var GoogleVertexLanguageModel = class {
         rawPrompt: contentRequest,
         rawSettings: {}
       },
+      providerMetadata: this.settings.useSearchGrounding ? {
+        vertex: {
+          groundingMetadata: firstCandidate.groundingMetadata
+        }
+      } : void 0,
       warnings
     };
   }
@@ -424,6 +523,7 @@ var GoogleVertexLanguageModel = class {
     };
     const generateId2 = this.config.generateId;
     let hasToolCalls = false;
+    let providerMetadata;
     return {
       stream: (0, import_provider_utils2.convertAsyncGeneratorToReadableStream)(stream).pipeThrough(
         new TransformStream(
@@ -447,6 +547,13 @@ var GoogleVertexLanguageModel = class {
                   hasToolCalls
                 });
               }
+              if (candidate.groundingMetadata != null) {
+                providerMetadata = {
+                  vertex: {
+                    groundingMetadata: candidate.groundingMetadata
+                  }
+                };
+              }
               const content = candidate.content;
               const deltaText = getTextFromParts(content.parts);
               if (deltaText != null) {
@@ -483,7 +590,8 @@ var GoogleVertexLanguageModel = class {
               controller.enqueue({
                 type: "finish",
                 finishReason,
-                usage
+                usage,
+                providerMetadata
               });
             }
           }
@@ -497,76 +605,6 @@ var GoogleVertexLanguageModel = class {
     };
   }
 };
-function prepareToolsAndToolConfig({
-  useSearchGrounding,
-  mode
-}) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
-  const mappedTools = tools == null ? [] : [
-    {
-      functionDeclarations: tools.map((tool) => {
-        var _a2;
-        return {
-          name: tool.name,
-          description: (_a2 = tool.description) != null ? _a2 : "",
-          parameters: convertJSONSchemaToOpenAPISchema(
-            tool.parameters
-          )
-        };
-      })
-    }
-  ];
-  if (useSearchGrounding) {
-    mappedTools.push({ googleSearchRetrieval: {} });
-  }
-  const finalTools = mappedTools.length > 0 ? mappedTools : void 0;
-  const toolChoice = mode.toolChoice;
-  if (toolChoice == null) {
-    return {
-      tools: finalTools,
-      toolConfig: void 0
-    };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.AUTO }
-        }
-      };
-    case "none":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.NONE }
-        }
-      };
-    case "required":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: { mode: import_vertexai.FunctionCallingMode.ANY }
-        }
-      };
-    case "tool":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: {
-            mode: import_vertexai.FunctionCallingMode.ANY,
-            allowedFunctionNames: [toolChoice.toolName]
-          }
-        }
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new Error(`Unsupported tool choice type: ${_exhaustiveCheck}`);
-    }
-  }
-}
 function getToolCallsFromParts({
   parts,
   generateId: generateId2
@@ -591,32 +629,138 @@ function getTextFromParts(parts) {
   return textParts.length === 0 ? void 0 : textParts.map((part) => part.text).join("");
 }
 
+// src/google-vertex-embedding-model.ts
+var import_provider3 = require("@ai-sdk/provider");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_zod2 = require("zod");
+
+// src/google-error.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_zod = require("zod");
+var googleErrorDataSchema = import_zod.z.object({
+  error: import_zod.z.object({
+    code: import_zod.z.number().nullable(),
+    message: import_zod.z.string(),
+    status: import_zod.z.string()
+  })
+});
+var googleFailedResponseHandler = (0, import_provider_utils3.createJsonErrorResponseHandler)({
+  errorSchema: googleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/google-vertex-embedding-model.ts
+var GoogleVertexEmbeddingModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v1";
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get maxEmbeddingsPerCall() {
+    return 2048;
+  }
+  get supportsParallelCalls() {
+    return true;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal
+  }) {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new import_provider3.TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+      url: `https://${this.config.region}-aiplatform.googleapis.com/v1/projects/${this.config.project}/locations/${this.config.region}/publishers/google/models/${this.modelId}:predict`,
+      headers: (0, import_provider_utils4.combineHeaders)(
+        { Authorization: `Bearer ${await this.config.generateAuthToken()}` },
+        headers
+      ),
+      body: {
+        instances: values.map((value) => ({ content: value })),
+        parameters: {
+          outputDimensionality: this.settings.outputDimensionality
+        }
+      },
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+        googleVertexTextEmbeddingResponseSchema
+      ),
+      abortSignal
+    });
+    return {
+      embeddings: response.predictions.map(
+        (prediction) => prediction.embeddings.values
+      ),
+      usage: {
+        tokens: response.predictions.reduce(
+          (tokenCount, prediction) => tokenCount + prediction.embeddings.statistics.token_count,
+          0
+        )
+      },
+      rawResponse: { headers: responseHeaders }
+    };
+  }
+};
+var googleVertexTextEmbeddingResponseSchema = import_zod2.z.object({
+  predictions: import_zod2.z.array(
+    import_zod2.z.object({
+      embeddings: import_zod2.z.object({
+        values: import_zod2.z.array(import_zod2.z.number()),
+        statistics: import_zod2.z.object({
+          token_count: import_zod2.z.number()
+        })
+      })
+    })
+  )
+});
+
 // src/google-vertex-provider.ts
 function createVertex(options = {}) {
+  const loadVertexProject = () => (0, import_provider_utils5.loadSetting)({
+    settingValue: options.project,
+    settingName: "project",
+    environmentVariableName: "GOOGLE_VERTEX_PROJECT",
+    description: "Google Vertex project"
+  });
+  const loadVertexLocation = () => (0, import_provider_utils5.loadSetting)({
+    settingValue: options.location,
+    settingName: "location",
+    environmentVariableName: "GOOGLE_VERTEX_LOCATION",
+    description: "Google Vertex location"
+  });
   const createVertexAI = () => {
     var _a, _b;
     const config = {
-      project: (0, import_provider_utils3.loadSetting)({
-        settingValue: options.project,
-        settingName: "project",
-        environmentVariableName: "GOOGLE_VERTEX_PROJECT",
-        description: "Google Vertex project"
-      }),
-      location: (0, import_provider_utils3.loadSetting)({
-        settingValue: options.location,
-        settingName: "location",
-        environmentVariableName: "GOOGLE_VERTEX_LOCATION",
-        description: "Google Vertex location"
-      }),
+      project: loadVertexProject(),
+      location: loadVertexLocation(),
       googleAuthOptions: options.googleAuthOptions
     };
-    return (_b = (_a = options.createVertexAI) == null ? void 0 : _a.call(options, config)) != null ? _b : new import_vertexai2.VertexAI(config);
+    return (_b = (_a = options.createVertexAI) == null ? void 0 : _a.call(options, config)) != null ? _b : new import_vertexai3.VertexAI(config);
   };
   const createChatModel = (modelId, settings = {}) => {
     var _a;
     return new GoogleVertexLanguageModel(modelId, settings, {
       vertexAI: createVertexAI(),
-      generateId: (_a = options.generateId) != null ? _a : import_provider_utils3.generateId
+      generateId: (_a = options.generateId) != null ? _a : import_provider_utils5.generateId
+    });
+  };
+  const createEmbeddingModel = (modelId, settings = {}) => {
+    const vertexAI = createVertexAI();
+    return new GoogleVertexEmbeddingModel(modelId, settings, {
+      provider: "google.vertex",
+      region: loadVertexLocation(),
+      project: loadVertexProject(),
+      generateAuthToken: () => vertexAI.googleAuth.getAccessToken()
     });
   };
   const provider = function(modelId, settings) {
@@ -628,9 +772,7 @@ function createVertex(options = {}) {
     return createChatModel(modelId, settings);
   };
   provider.languageModel = createChatModel;
-  provider.textEmbeddingModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
-  };
+  provider.textEmbeddingModel = createEmbeddingModel;
   return provider;
 }
 var vertex = createVertex();