@ai-sdk/google 1.0.4 → 1.0.5

package/internal/dist/index.js

@@ -0,0 +1,676 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internal/index.ts
+var internal_exports = {};
+__export(internal_exports, {
+  GoogleGenerativeAILanguageModel: () => GoogleGenerativeAILanguageModel
+});
+module.exports = __toCommonJS(internal_exports);
+
+// src/google-generative-ai-language-model.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_zod2 = require("zod");
+
+// src/convert-json-schema-to-openapi-schema.ts
+function convertJSONSchemaToOpenAPISchema(jsonSchema) {
+  if (isEmptyObjectSchema(jsonSchema)) {
+    return void 0;
+  }
+  if (typeof jsonSchema === "boolean") {
+    return { type: "boolean", properties: {} };
+  }
+  const {
+    type,
+    description,
+    required,
+    properties,
+    items,
+    allOf,
+    anyOf,
+    oneOf,
+    format,
+    const: constValue,
+    minLength
+  } = jsonSchema;
+  const result = {};
+  if (description)
+    result.description = description;
+  if (required)
+    result.required = required;
+  if (format)
+    result.format = format;
+  if (constValue !== void 0) {
+    result.enum = [constValue];
+  }
+  if (type) {
+    if (Array.isArray(type)) {
+      if (type.includes("null")) {
+        result.type = type.filter((t) => t !== "null")[0];
+        result.nullable = true;
+      } else {
+        result.type = type;
+      }
+    } else if (type === "null") {
+      result.type = "null";
+    } else {
+      result.type = type;
+    }
+  }
+  if (properties != null) {
+    result.properties = Object.entries(properties).reduce(
+      (acc, [key, value]) => {
+        acc[key] = convertJSONSchemaToOpenAPISchema(value);
+        return acc;
+      },
+      {}
+    );
+  }
+  if (items) {
+    result.items = Array.isArray(items) ? items.map(convertJSONSchemaToOpenAPISchema) : convertJSONSchemaToOpenAPISchema(items);
+  }
+  if (allOf) {
+    result.allOf = allOf.map(convertJSONSchemaToOpenAPISchema);
+  }
+  if (anyOf) {
+    result.anyOf = anyOf.map(convertJSONSchemaToOpenAPISchema);
+  }
+  if (oneOf) {
+    result.oneOf = oneOf.map(convertJSONSchemaToOpenAPISchema);
+  }
+  if (minLength !== void 0)
+    result.minLength = minLength;
+  return result;
+}
+function isEmptyObjectSchema(jsonSchema) {
+  return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0);
+}
+
+// src/convert-to-google-generative-ai-messages.ts
+var import_provider = require("@ai-sdk/provider");
+var import_provider_utils = require("@ai-sdk/provider-utils");
+function convertToGoogleGenerativeAIMessages(prompt) {
+  var _a, _b;
+  const systemInstructionParts = [];
+  const contents = [];
+  let systemMessagesAllowed = true;
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        if (!systemMessagesAllowed) {
+          throw new import_provider.UnsupportedFunctionalityError({
+            functionality: "system messages are only supported at the beginning of the conversation"
+          });
+        }
+        systemInstructionParts.push({ text: content });
+        break;
+      }
+      case "user": {
+        systemMessagesAllowed = false;
+        const parts = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              parts.push({ text: part.text });
+              break;
+            }
+            case "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": {
+              parts.push(
+                part.data instanceof URL ? {
+                  fileData: {
+                    mimeType: part.mimeType,
+                    fileUri: part.data.toString()
+                  }
+                } : {
+                  inlineData: {
+                    mimeType: part.mimeType,
+                    data: part.data
+                  }
+                }
+              );
+              break;
+            }
+            default: {
+              const _exhaustiveCheck = part;
+              throw new import_provider.UnsupportedFunctionalityError({
+                functionality: `prompt part: ${_exhaustiveCheck}`
+              });
+            }
+          }
+        }
+        contents.push({ role: "user", parts });
+        break;
+      }
+      case "assistant": {
+        systemMessagesAllowed = false;
+        contents.push({
+          role: "model",
+          parts: content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return part.text.length === 0 ? void 0 : { text: part.text };
+              }
+              case "tool-call": {
+                return {
+                  functionCall: {
+                    name: part.toolName,
+                    args: part.args
+                  }
+                };
+              }
+            }
+          }).filter(
+            (part) => part !== void 0
+          )
+        });
+        break;
+      }
+      case "tool": {
+        systemMessagesAllowed = false;
+        contents.push({
+          role: "user",
+          parts: content.map((part) => ({
+            functionResponse: {
+              name: part.toolName,
+              response: {
+                name: part.toolName,
+                content: part.result
+              }
+            }
+          }))
+        });
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return {
+    systemInstruction: systemInstructionParts.length > 0 ? { parts: systemInstructionParts } : void 0,
+    contents
+  };
+}
+
+// src/get-model-path.ts
+function getModelPath(modelId) {
+  return modelId.includes("/") ? modelId : `models/${modelId}`;
+}
+
+// src/google-error.ts
+var import_provider_utils2 = 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_utils2.createJsonErrorResponseHandler)({
+  errorSchema: googleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/google-prepare-tools.ts
+var import_provider2 = require("@ai-sdk/provider");
+function prepareTools(mode, useSearchGrounding) {
+  var _a, _b;
+  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+  const toolWarnings = [];
+  if (useSearchGrounding) {
+    return {
+      tools: { googleSearchRetrieval: {} },
+      toolConfig: void 0,
+      toolWarnings
+    };
+  }
+  if (tools == null) {
+    return { tools: void 0, toolConfig: void 0, toolWarnings };
+  }
+  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)
+      });
+    }
+  }
+  const toolChoice = mode.toolChoice;
+  if (toolChoice == null) {
+    return {
+      tools: { functionDeclarations },
+      toolConfig: void 0,
+      toolWarnings
+    };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+      return {
+        tools: { functionDeclarations },
+        toolConfig: { functionCallingConfig: { mode: "AUTO" } },
+        toolWarnings
+      };
+    case "none":
+      return {
+        tools: { functionDeclarations },
+        toolConfig: { functionCallingConfig: { mode: "NONE" } },
+        toolWarnings
+      };
+    case "required":
+      return {
+        tools: { functionDeclarations },
+        toolConfig: { functionCallingConfig: { mode: "ANY" } },
+        toolWarnings
+      };
+    case "tool":
+      return {
+        tools: { functionDeclarations },
+        toolConfig: {
+          functionCallingConfig: {
+            mode: "ANY",
+            allowedFunctionNames: [toolChoice.toolName]
+          }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new import_provider2.UnsupportedFunctionalityError({
+        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+// src/map-google-generative-ai-finish-reason.ts
+function mapGoogleGenerativeAIFinishReason({
+  finishReason,
+  hasToolCalls
+}) {
+  switch (finishReason) {
+    case "STOP":
+      return hasToolCalls ? "tool-calls" : "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "RECITATION":
+    case "SAFETY":
+      return "content-filter";
+    case "FINISH_REASON_UNSPECIFIED":
+    case "OTHER":
+      return "other";
+    default:
+      return "unknown";
+  }
+}
+
+// src/google-generative-ai-language-model.ts
+var GoogleGenerativeAILanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v1";
+    this.defaultObjectGenerationMode = "json";
+    this.supportsImageUrls = false;
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get supportsStructuredOutputs() {
+    var _a;
+    return (_a = this.settings.structuredOutputs) != null ? _a : true;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    mode,
+    prompt,
+    maxTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed
+  }) {
+    var _a, _b;
+    const type = mode.type;
+    const warnings = [];
+    if (seed != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "seed"
+      });
+    }
+    const generationConfig = {
+      // standardized settings:
+      maxOutputTokens: maxTokens,
+      temperature,
+      topK,
+      topP,
+      frequencyPenalty,
+      presencePenalty,
+      stopSequences,
+      // response format:
+      responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
+      responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
+      // so this is needed as an escape hatch:
+      this.supportsStructuredOutputs ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0
+    };
+    const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(prompt);
+    switch (type) {
+      case "regular": {
+        const { tools, toolConfig, toolWarnings } = prepareTools(
+          mode,
+          (_a = this.settings.useSearchGrounding) != null ? _a : false
+        );
+        return {
+          args: {
+            generationConfig,
+            contents,
+            systemInstruction,
+            safetySettings: this.settings.safetySettings,
+            tools,
+            toolConfig,
+            cachedContent: this.settings.cachedContent
+          },
+          warnings: [...warnings, ...toolWarnings]
+        };
+      }
+      case "object-json": {
+        return {
+          args: {
+            generationConfig: {
+              ...generationConfig,
+              responseMimeType: "application/json",
+              responseSchema: mode.schema != null && // Google GenAI does not support all OpenAPI Schema features,
+              // so this is needed as an escape hatch:
+              this.supportsStructuredOutputs ? convertJSONSchemaToOpenAPISchema(mode.schema) : void 0
+            },
+            contents,
+            systemInstruction,
+            safetySettings: this.settings.safetySettings,
+            cachedContent: this.settings.cachedContent
+          },
+          warnings
+        };
+      }
+      case "object-tool": {
+        return {
+          args: {
+            generationConfig,
+            contents,
+            tools: {
+              functionDeclarations: [
+                {
+                  name: mode.tool.name,
+                  description: (_b = mode.tool.description) != null ? _b : "",
+                  parameters: convertJSONSchemaToOpenAPISchema(
+                    mode.tool.parameters
+                  )
+                }
+              ]
+            },
+            toolConfig: { functionCallingConfig: { mode: "ANY" } },
+            safetySettings: this.settings.safetySettings,
+            cachedContent: this.settings.cachedContent
+          },
+          warnings
+        };
+      }
+      default: {
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  supportsUrl(url) {
+    return url.toString().startsWith("https://generativelanguage.googleapis.com/v1beta/files/");
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const { args, warnings } = await this.getArgs(options);
+    const body = JSON.stringify(args);
+    const mergedHeaders = (0, import_provider_utils3.combineHeaders)(
+      await (0, import_provider_utils3.resolve)(this.config.headers),
+      options.headers
+    );
+    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+      url: `${this.config.baseURL}/${getModelPath(
+        this.modelId
+      )}:generateContent`,
+      headers: mergedHeaders,
+      body: args,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(responseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { contents: rawPrompt, ...rawSettings } = args;
+    const candidate = response.candidates[0];
+    const toolCalls = getToolCallsFromParts({
+      parts: (_b = (_a = candidate.content) == null ? void 0 : _a.parts) != null ? _b : [],
+      generateId: this.config.generateId
+    });
+    const usageMetadata = response.usageMetadata;
+    return {
+      text: getTextFromParts((_d = (_c = candidate.content) == null ? void 0 : _c.parts) != null ? _d : []),
+      toolCalls,
+      finishReason: mapGoogleGenerativeAIFinishReason({
+        finishReason: candidate.finishReason,
+        hasToolCalls: toolCalls != null && toolCalls.length > 0
+      }),
+      usage: {
+        promptTokens: (_e = usageMetadata == null ? void 0 : usageMetadata.promptTokenCount) != null ? _e : NaN,
+        completionTokens: (_f = usageMetadata == null ? void 0 : usageMetadata.candidatesTokenCount) != null ? _f : NaN
+      },
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
+      warnings,
+      request: { body }
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs(options);
+    const body = JSON.stringify(args);
+    const headers = (0, import_provider_utils3.combineHeaders)(
+      await (0, import_provider_utils3.resolve)(this.config.headers),
+      options.headers
+    );
+    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+      url: `${this.config.baseURL}/${getModelPath(
+        this.modelId
+      )}:streamGenerateContent?alt=sse`,
+      headers,
+      body: args,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(chunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { contents: rawPrompt, ...rawSettings } = args;
+    let finishReason = "unknown";
+    let usage = {
+      promptTokens: Number.NaN,
+      completionTokens: Number.NaN
+    };
+    const generateId = this.config.generateId;
+    let hasToolCalls = false;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            var _a, _b, _c;
+            if (!chunk.success) {
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            const usageMetadata = value.usageMetadata;
+            if (usageMetadata != null) {
+              usage = {
+                promptTokens: (_a = usageMetadata.promptTokenCount) != null ? _a : NaN,
+                completionTokens: (_b = usageMetadata.candidatesTokenCount) != null ? _b : NaN
+              };
+            }
+            const candidate = (_c = value.candidates) == null ? void 0 : _c[0];
+            if (candidate == null) {
+              return;
+            }
+            if (candidate.finishReason != null) {
+              finishReason = mapGoogleGenerativeAIFinishReason({
+                finishReason: candidate.finishReason,
+                hasToolCalls
+              });
+            }
+            const content = candidate.content;
+            if (content == null) {
+              return;
+            }
+            const deltaText = getTextFromParts(content.parts);
+            if (deltaText != null) {
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: deltaText
+              });
+            }
+            const toolCallDeltas = getToolCallsFromParts({
+              parts: content.parts,
+              generateId
+            });
+            if (toolCallDeltas != null) {
+              for (const toolCall of toolCallDeltas) {
+                controller.enqueue({
+                  type: "tool-call-delta",
+                  toolCallType: "function",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  argsTextDelta: toolCall.args
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallType: "function",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  args: toolCall.args
+                });
+                hasToolCalls = true;
+              }
+            }
+          },
+          flush(controller) {
+            controller.enqueue({ type: "finish", finishReason, usage });
+          }
+        })
+      ),
+      rawCall: { rawPrompt, rawSettings },
+      rawResponse: { headers: responseHeaders },
+      warnings,
+      request: { body }
+    };
+  }
+};
+function getToolCallsFromParts({
+  parts,
+  generateId
+}) {
+  const functionCallParts = parts.filter(
+    (part) => "functionCall" in part
+  );
+  return functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
+    toolCallType: "function",
+    toolCallId: generateId(),
+    toolName: part.functionCall.name,
+    args: JSON.stringify(part.functionCall.args)
+  }));
+}
+function getTextFromParts(parts) {
+  const textParts = parts.filter((part) => "text" in part);
+  return textParts.length === 0 ? void 0 : textParts.map((part) => part.text).join("");
+}
+var contentSchema = import_zod2.z.object({
+  role: import_zod2.z.string(),
+  parts: import_zod2.z.array(
+    import_zod2.z.union([
+      import_zod2.z.object({
+        text: import_zod2.z.string()
+      }),
+      import_zod2.z.object({
+        functionCall: import_zod2.z.object({
+          name: import_zod2.z.string(),
+          args: import_zod2.z.unknown()
+        })
+      })
+    ])
+  )
+});
+var responseSchema = import_zod2.z.object({
+  candidates: import_zod2.z.array(
+    import_zod2.z.object({
+      content: contentSchema.optional(),
+      finishReason: import_zod2.z.string().optional()
+    })
+  ),
+  usageMetadata: import_zod2.z.object({
+    promptTokenCount: import_zod2.z.number(),
+    candidatesTokenCount: import_zod2.z.number().nullish(),
+    totalTokenCount: import_zod2.z.number()
+  }).optional()
+});
+var chunkSchema = import_zod2.z.object({
+  candidates: import_zod2.z.array(
+    import_zod2.z.object({
+      content: contentSchema.optional(),
+      finishReason: import_zod2.z.string().optional()
+    })
+  ).nullish(),
+  usageMetadata: import_zod2.z.object({
+    promptTokenCount: import_zod2.z.number(),
+    candidatesTokenCount: import_zod2.z.number().nullish(),
+    totalTokenCount: import_zod2.z.number()
+  }).nullish()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleGenerativeAILanguageModel
+});
+//# sourceMappingURL=index.js.map