@ai-sdk/google-vertex 0.0.40 → 0.0.43

package/dist/index.mjs

@@ -1,7 +1,4 @@
 // src/google-vertex-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
 import { generateId, loadSetting } from "@ai-sdk/provider-utils";
 import { VertexAI as VertexAI2 } from "@google-cloud/vertexai";
 
@@ -11,7 +8,7 @@ import {
 } from "@ai-sdk/provider";
 import { convertAsyncGeneratorToReadableStream } from "@ai-sdk/provider-utils";
 import {
-  FunctionCallingMode
+  FunctionCallingMode as FunctionCallingMode2
 } from "@google-cloud/vertexai";
 
 // src/convert-json-schema-to-openapi-schema.ts
@@ -88,7 +85,7 @@ import {
 } from "@ai-sdk/provider";
 import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
 function convertToGoogleVertexContentRequest(prompt) {
-  var _a;
+  var _a, _b;
   const systemInstructionParts = [];
   const contents = [];
   let systemMessagesAllowed = true;
@@ -113,28 +110,35 @@ function convertToGoogleVertexContentRequest(prompt) {
               break;
             }
             case "image": {
-              if (part.image instanceof URL) {
-                throw new UnsupportedFunctionalityError({
-                  functionality: "Image URLs in user messages"
-                });
-              }
-              parts.push({
-                inlineData: {
-                  mimeType: (_a = part.mimeType) != null ? _a : "image/jpeg",
-                  data: 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: convertUint8ArrayToBase64(part.image)
+                  }
                 }
-              });
+              );
               break;
             }
             case "file": {
-              if (part.data instanceof URL) {
-                throw new 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: {
@@ -203,6 +207,91 @@ function convertToGoogleVertexContentRequest(prompt) {
   };
 }
 
+// src/google-vertex-prepare-tools.ts
+import {
+  FunctionCallingMode
+} from "@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: FunctionCallingMode.AUTO }
+        },
+        toolWarnings
+      };
+    case "none":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: { mode: FunctionCallingMode.NONE }
+        },
+        toolWarnings
+      };
+    case "required":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: { mode: FunctionCallingMode.ANY }
+        },
+        toolWarnings
+      };
+    case "tool":
+      return {
+        tools: finalTools,
+        toolConfig: {
+          functionCallingConfig: {
+            mode: 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,
@@ -295,19 +384,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": {
@@ -347,7 +438,7 @@ var GoogleVertexLanguageModel = class {
             }
           ],
           toolConfig: {
-            functionCallingConfig: { mode: FunctionCallingMode.ANY }
+            functionCallingConfig: { mode: FunctionCallingMode2.ANY }
           },
           safetySettings: this.settings.safetySettings
         };
@@ -363,6 +454,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);
@@ -392,6 +486,11 @@ var GoogleVertexLanguageModel = class {
         rawPrompt: contentRequest,
         rawSettings: {}
       },
+      providerMetadata: this.settings.useSearchGrounding ? {
+        vertex: {
+          groundingMetadata: firstCandidate.groundingMetadata
+        }
+      } : void 0,
       warnings
     };
   }
@@ -405,6 +504,7 @@ var GoogleVertexLanguageModel = class {
     };
     const generateId2 = this.config.generateId;
     let hasToolCalls = false;
+    let providerMetadata;
     return {
       stream: convertAsyncGeneratorToReadableStream(stream).pipeThrough(
         new TransformStream(
@@ -428,6 +528,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) {
@@ -464,7 +571,8 @@ var GoogleVertexLanguageModel = class {
               controller.enqueue({
                 type: "finish",
                 finishReason,
-                usage
+                usage,
+                providerMetadata
               });
             }
           }
@@ -478,76 +586,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: FunctionCallingMode.AUTO }
-        }
-      };
-    case "none":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: { mode: FunctionCallingMode.NONE }
-        }
-      };
-    case "required":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: { mode: FunctionCallingMode.ANY }
-        }
-      };
-    case "tool":
-      return {
-        tools: finalTools,
-        toolConfig: {
-          functionCallingConfig: {
-            mode: FunctionCallingMode.ANY,
-            allowedFunctionNames: [toolChoice.toolName]
-          }
-        }
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new Error(`Unsupported tool choice type: ${_exhaustiveCheck}`);
-    }
-  }
-}
 function getToolCallsFromParts({
   parts,
   generateId: generateId2
@@ -572,23 +610,126 @@ function getTextFromParts(parts) {
   return textParts.length === 0 ? void 0 : textParts.map((part) => part.text).join("");
 }
 
+// src/google-vertex-embedding-model.ts
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createJsonResponseHandler,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod";
+
+// src/google-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod";
+var googleErrorDataSchema = z.object({
+  error: z.object({
+    code: z.number().nullable(),
+    message: z.string(),
+    status: z.string()
+  })
+});
+var googleFailedResponseHandler = 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 TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const { responseHeaders, value: response } = await 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: combineHeaders(
+        { Authorization: `Bearer ${await this.config.generateAuthToken()}` },
+        headers
+      ),
+      body: {
+        instances: values.map((value) => ({ content: value })),
+        parameters: {
+          outputDimensionality: this.settings.outputDimensionality
+        }
+      },
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: 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 = z2.object({
+  predictions: z2.array(
+    z2.object({
+      embeddings: z2.object({
+        values: z2.array(z2.number()),
+        statistics: z2.object({
+          token_count: z2.number()
+        })
+      })
+    })
+  )
+});
+
 // src/google-vertex-provider.ts
 function createVertex(options = {}) {
+  const loadVertexProject = () => loadSetting({
+    settingValue: options.project,
+    settingName: "project",
+    environmentVariableName: "GOOGLE_VERTEX_PROJECT",
+    description: "Google Vertex project"
+  });
+  const loadVertexLocation = () => loadSetting({
+    settingValue: options.location,
+    settingName: "location",
+    environmentVariableName: "GOOGLE_VERTEX_LOCATION",
+    description: "Google Vertex location"
+  });
   const createVertexAI = () => {
     var _a, _b;
     const config = {
-      project: loadSetting({
-        settingValue: options.project,
-        settingName: "project",
-        environmentVariableName: "GOOGLE_VERTEX_PROJECT",
-        description: "Google Vertex project"
-      }),
-      location: 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 VertexAI2(config);
@@ -600,6 +741,15 @@ function createVertex(options = {}) {
       generateId: (_a = options.generateId) != null ? _a : 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) {
     if (new.target) {
       throw new Error(
@@ -609,9 +759,7 @@ function createVertex(options = {}) {
     return createChatModel(modelId, settings);
   };
   provider.languageModel = createChatModel;
-  provider.textEmbeddingModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
-  };
+  provider.textEmbeddingModel = createEmbeddingModel;
   return provider;
 }
 var vertex = createVertex();