Initial commit

node_modules/@google/generative-ai/dist/server/index.js

@@ -0,0 +1,797 @@
+'use strict';
+
+var fs = require('fs');
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Basic error type for this SDK.
+ * @public
+ */
+class GoogleGenerativeAIError extends Error {
+    constructor(message) {
+        super(`[GoogleGenerativeAI Error]: ${message}`);
+    }
+}
+/**
+ * Error class covering HTTP errors when calling the server. Includes HTTP
+ * status, statusText, and optional details, if provided in the server response.
+ * @public
+ */
+class GoogleGenerativeAIFetchError extends GoogleGenerativeAIError {
+    constructor(message, status, statusText, errorDetails) {
+        super(message);
+        this.status = status;
+        this.statusText = statusText;
+        this.errorDetails = errorDetails;
+    }
+}
+/**
+ * Errors in the contents of a request originating from user input.
+ * @public
+ */
+class GoogleGenerativeAIRequestInputError extends GoogleGenerativeAIError {
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
+const DEFAULT_API_VERSION = "v1beta";
+/**
+ * We can't `require` package.json if this runs on web. We will use rollup to
+ * swap in the version number here at build time.
+ */
+const PACKAGE_VERSION = "0.21.0";
+const PACKAGE_LOG_HEADER = "genai-js";
+var Task;
+(function (Task) {
+    Task["GENERATE_CONTENT"] = "generateContent";
+    Task["STREAM_GENERATE_CONTENT"] = "streamGenerateContent";
+    Task["COUNT_TOKENS"] = "countTokens";
+    Task["EMBED_CONTENT"] = "embedContent";
+    Task["BATCH_EMBED_CONTENTS"] = "batchEmbedContents";
+})(Task || (Task = {}));
+/**
+ * Simple, but may become more complex if we add more versions to log.
+ */
+function getClientHeaders(requestOptions) {
+    const clientHeaders = [];
+    if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.apiClient) {
+        clientHeaders.push(requestOptions.apiClient);
+    }
+    clientHeaders.push(`${PACKAGE_LOG_HEADER}/${PACKAGE_VERSION}`);
+    return clientHeaders.join(" ");
+}
+async function makeRequest(url, fetchOptions, fetchFn = fetch) {
+    let response;
+    try {
+        response = await fetchFn(url, fetchOptions);
+    }
+    catch (e) {
+        handleResponseError(e, url);
+    }
+    if (!response.ok) {
+        await handleResponseNotOk(response, url);
+    }
+    return response;
+}
+function handleResponseError(e, url) {
+    let err = e;
+    if (!(e instanceof GoogleGenerativeAIFetchError ||
+        e instanceof GoogleGenerativeAIRequestInputError)) {
+        err = new GoogleGenerativeAIError(`Error fetching from ${url.toString()}: ${e.message}`);
+        err.stack = e.stack;
+    }
+    throw err;
+}
+async function handleResponseNotOk(response, url) {
+    let message = "";
+    let errorDetails;
+    try {
+        const json = await response.json();
+        message = json.error.message;
+        if (json.error.details) {
+            message += ` ${JSON.stringify(json.error.details)}`;
+            errorDetails = json.error.details;
+        }
+    }
+    catch (e) {
+        // ignored
+    }
+    throw new GoogleGenerativeAIFetchError(`Error fetching from ${url.toString()}: [${response.status} ${response.statusText}] ${message}`, response.status, response.statusText, errorDetails);
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var RpcTask;
+(function (RpcTask) {
+    RpcTask["UPLOAD"] = "upload";
+    RpcTask["LIST"] = "list";
+    RpcTask["GET"] = "get";
+    RpcTask["DELETE"] = "delete";
+    RpcTask["UPDATE"] = "update";
+    RpcTask["CREATE"] = "create";
+})(RpcTask || (RpcTask = {}));
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const taskToMethod = {
+    [RpcTask.UPLOAD]: "POST",
+    [RpcTask.LIST]: "GET",
+    [RpcTask.GET]: "GET",
+    [RpcTask.DELETE]: "DELETE",
+    [RpcTask.UPDATE]: "PATCH",
+    [RpcTask.CREATE]: "POST",
+};
+class ServerRequestUrl {
+    constructor(task, apiKey, requestOptions) {
+        this.task = task;
+        this.apiKey = apiKey;
+        this.requestOptions = requestOptions;
+    }
+    appendPath(path) {
+        this._url.pathname = this._url.pathname + `/${path}`;
+    }
+    appendParam(key, value) {
+        this._url.searchParams.append(key, value);
+    }
+    toString() {
+        return this._url.toString();
+    }
+}
+class CachedContentUrl extends ServerRequestUrl {
+    constructor(task, apiKey, requestOptions) {
+        var _a, _b;
+        super(task, apiKey, requestOptions);
+        this.task = task;
+        this.apiKey = apiKey;
+        this.requestOptions = requestOptions;
+        const apiVersion = ((_a = this.requestOptions) === null || _a === void 0 ? void 0 : _a.apiVersion) || DEFAULT_API_VERSION;
+        const baseUrl = ((_b = this.requestOptions) === null || _b === void 0 ? void 0 : _b.baseUrl) || DEFAULT_BASE_URL;
+        let initialUrl = baseUrl;
+        initialUrl += `/${apiVersion}/cachedContents`;
+        this._url = new URL(initialUrl);
+    }
+}
+class FilesRequestUrl extends ServerRequestUrl {
+    constructor(task, apiKey, requestOptions) {
+        var _a, _b;
+        super(task, apiKey, requestOptions);
+        this.task = task;
+        this.apiKey = apiKey;
+        this.requestOptions = requestOptions;
+        const apiVersion = ((_a = this.requestOptions) === null || _a === void 0 ? void 0 : _a.apiVersion) || DEFAULT_API_VERSION;
+        const baseUrl = ((_b = this.requestOptions) === null || _b === void 0 ? void 0 : _b.baseUrl) || DEFAULT_BASE_URL;
+        let initialUrl = baseUrl;
+        if (this.task === RpcTask.UPLOAD) {
+            initialUrl += `/upload`;
+        }
+        initialUrl += `/${apiVersion}/files`;
+        this._url = new URL(initialUrl);
+    }
+}
+function getHeaders(url) {
+    const headers = new Headers();
+    headers.append("x-goog-api-client", getClientHeaders(url.requestOptions));
+    headers.append("x-goog-api-key", url.apiKey);
+    return headers;
+}
+async function makeServerRequest(url, headers, body, fetchFn = fetch) {
+    const requestInit = {
+        method: taskToMethod[url.task],
+        headers,
+    };
+    if (body) {
+        requestInit.body = body;
+    }
+    const signal = getSignal(url.requestOptions);
+    if (signal) {
+        requestInit.signal = signal;
+    }
+    return makeRequest(url.toString(), requestInit, fetchFn);
+}
+/**
+ * Create an AbortSignal based on the timeout and signal in the
+ * RequestOptions.
+ */
+function getSignal(requestOptions) {
+    if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.signal) !== undefined || (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeout) >= 0) {
+        const controller = new AbortController();
+        if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeout) >= 0) {
+            setTimeout(() => controller.abort(), requestOptions.timeout);
+        }
+        if (requestOptions.signal) {
+            requestOptions.signal.addEventListener("abort", () => {
+                controller.abort();
+            });
+        }
+        return controller.signal;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class for managing GoogleAI file uploads.
+ * @public
+ */
+class GoogleAIFileManager {
+    constructor(apiKey, _requestOptions = {}) {
+        this.apiKey = apiKey;
+        this._requestOptions = _requestOptions;
+    }
+    /**
+     * Upload a file.
+     */
+    async uploadFile(filePath, fileMetadata) {
+        const file = fs.readFileSync(filePath);
+        const url = new FilesRequestUrl(RpcTask.UPLOAD, this.apiKey, this._requestOptions);
+        const uploadHeaders = getHeaders(url);
+        const boundary = generateBoundary();
+        uploadHeaders.append("X-Goog-Upload-Protocol", "multipart");
+        uploadHeaders.append("Content-Type", `multipart/related; boundary=${boundary}`);
+        const uploadMetadata = getUploadMetadata(fileMetadata);
+        // Multipart formatting code taken from @firebase/storage
+        const metadataString = JSON.stringify({ file: uploadMetadata });
+        const preBlobPart = "--" +
+            boundary +
+            "\r\n" +
+            "Content-Type: application/json; charset=utf-8\r\n\r\n" +
+            metadataString +
+            "\r\n--" +
+            boundary +
+            "\r\n" +
+            "Content-Type: " +
+            fileMetadata.mimeType +
+            "\r\n\r\n";
+        const postBlobPart = "\r\n--" + boundary + "--";
+        const blob = new Blob([preBlobPart, file, postBlobPart]);
+        const response = await makeServerRequest(url, uploadHeaders, blob);
+        return response.json();
+    }
+    /**
+     * List all uploaded files.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    async listFiles(listParams, requestOptions = {}) {
+        const filesRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        const url = new FilesRequestUrl(RpcTask.LIST, this.apiKey, filesRequestOptions);
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageSize) {
+            url.appendParam("pageSize", listParams.pageSize.toString());
+        }
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageToken) {
+            url.appendParam("pageToken", listParams.pageToken);
+        }
+        const uploadHeaders = getHeaders(url);
+        const response = await makeServerRequest(url, uploadHeaders);
+        return response.json();
+    }
+    /**
+     * Get metadata for file with given ID.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    async getFile(fileId, requestOptions = {}) {
+        const filesRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        const url = new FilesRequestUrl(RpcTask.GET, this.apiKey, filesRequestOptions);
+        url.appendPath(parseFileId(fileId));
+        const uploadHeaders = getHeaders(url);
+        const response = await makeServerRequest(url, uploadHeaders);
+        return response.json();
+    }
+    /**
+     * Delete file with given ID.
+     */
+    async deleteFile(fileId) {
+        const url = new FilesRequestUrl(RpcTask.DELETE, this.apiKey, this._requestOptions);
+        url.appendPath(parseFileId(fileId));
+        const uploadHeaders = getHeaders(url);
+        await makeServerRequest(url, uploadHeaders);
+    }
+}
+/**
+ * If fileId is prepended with "files/", remove prefix
+ */
+function parseFileId(fileId) {
+    if (fileId.startsWith("files/")) {
+        return fileId.split("files/")[1];
+    }
+    if (!fileId) {
+        throw new GoogleGenerativeAIError(`Invalid fileId ${fileId}. ` +
+            `Must be in the format "files/filename" or "filename"`);
+    }
+    return fileId;
+}
+function generateBoundary() {
+    let str = "";
+    for (let i = 0; i < 2; i++) {
+        str = str + Math.random().toString().slice(2);
+    }
+    return str;
+}
+function getUploadMetadata(inputMetadata) {
+    if (!inputMetadata.mimeType) {
+        throw new GoogleGenerativeAIRequestInputError("Must provide a mimeType.");
+    }
+    const uploadMetadata = {
+        mimeType: inputMetadata.mimeType,
+        displayName: inputMetadata.displayName,
+    };
+    if (inputMetadata.name) {
+        uploadMetadata.name = inputMetadata.name.includes("/")
+            ? inputMetadata.name
+            : `files/${inputMetadata.name}`;
+    }
+    return uploadMetadata;
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function formatSystemInstruction(input) {
+    // null or undefined
+    if (input == null) {
+        return undefined;
+    }
+    else if (typeof input === "string") {
+        return { role: "system", parts: [{ text: input }] };
+    }
+    else if (input.text) {
+        return { role: "system", parts: [input] };
+    }
+    else if (input.parts) {
+        if (!input.role) {
+            return { role: "system", parts: input.parts };
+        }
+        else {
+            return input;
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class for managing GoogleAI content caches.
+ * @public
+ */
+class GoogleAICacheManager {
+    constructor(apiKey, _requestOptions) {
+        this.apiKey = apiKey;
+        this._requestOptions = _requestOptions;
+    }
+    /**
+     * Upload a new content cache
+     */
+    async create(createOptions) {
+        const newCachedContent = Object.assign({}, createOptions);
+        if (createOptions.ttlSeconds) {
+            if (createOptions.expireTime) {
+                throw new GoogleGenerativeAIRequestInputError("You cannot specify both `ttlSeconds` and `expireTime` when creating" +
+                    " a content cache. You must choose one.");
+            }
+            if (createOptions.systemInstruction) {
+                newCachedContent.systemInstruction = formatSystemInstruction(createOptions.systemInstruction);
+            }
+            newCachedContent.ttl = createOptions.ttlSeconds.toString() + "s";
+            delete newCachedContent.ttlSeconds;
+        }
+        if (!newCachedContent.model) {
+            throw new GoogleGenerativeAIRequestInputError("Cached content must contain a `model` field.");
+        }
+        if (!newCachedContent.model.includes("/")) {
+            // If path is not included, assume it's a non-tuned model.
+            newCachedContent.model = `models/${newCachedContent.model}`;
+        }
+        const url = new CachedContentUrl(RpcTask.CREATE, this.apiKey, this._requestOptions);
+        const headers = getHeaders(url);
+        const response = await makeServerRequest(url, headers, JSON.stringify(newCachedContent));
+        return response.json();
+    }
+    /**
+     * List all uploaded content caches
+     */
+    async list(listParams) {
+        const url = new CachedContentUrl(RpcTask.LIST, this.apiKey, this._requestOptions);
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageSize) {
+            url.appendParam("pageSize", listParams.pageSize.toString());
+        }
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageToken) {
+            url.appendParam("pageToken", listParams.pageToken);
+        }
+        const headers = getHeaders(url);
+        const response = await makeServerRequest(url, headers);
+        return response.json();
+    }
+    /**
+     * Get a content cache
+     */
+    async get(name) {
+        const url = new CachedContentUrl(RpcTask.GET, this.apiKey, this._requestOptions);
+        url.appendPath(parseCacheName(name));
+        const headers = getHeaders(url);
+        const response = await makeServerRequest(url, headers);
+        return response.json();
+    }
+    /**
+     * Update an existing content cache
+     */
+    async update(name, updateParams) {
+        const url = new CachedContentUrl(RpcTask.UPDATE, this.apiKey, this._requestOptions);
+        url.appendPath(parseCacheName(name));
+        const headers = getHeaders(url);
+        const formattedCachedContent = Object.assign({}, updateParams.cachedContent);
+        if (updateParams.cachedContent.ttlSeconds) {
+            formattedCachedContent.ttl =
+                updateParams.cachedContent.ttlSeconds.toString() + "s";
+            delete formattedCachedContent.ttlSeconds;
+        }
+        if (updateParams.updateMask) {
+            url.appendParam("update_mask", updateParams.updateMask.map((prop) => camelToSnake(prop)).join(","));
+        }
+        const response = await makeServerRequest(url, headers, JSON.stringify(formattedCachedContent));
+        return response.json();
+    }
+    /**
+     * Delete content cache with given name
+     */
+    async delete(name) {
+        const url = new CachedContentUrl(RpcTask.DELETE, this.apiKey, this._requestOptions);
+        url.appendPath(parseCacheName(name));
+        const headers = getHeaders(url);
+        await makeServerRequest(url, headers);
+    }
+}
+/**
+ * If cache name is prepended with "cachedContents/", remove prefix
+ */
+function parseCacheName(name) {
+    if (name.startsWith("cachedContents/")) {
+        return name.split("cachedContents/")[1];
+    }
+    if (!name) {
+        throw new GoogleGenerativeAIError(`Invalid name ${name}. ` +
+            `Must be in the format "cachedContents/name" or "name"`);
+    }
+    return name;
+}
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+/**
+ * Processing state of the `File`.
+ * @public
+ */
+exports.FileState = void 0;
+(function (FileState) {
+    // The default value. This value is used if the state is omitted.
+    FileState["STATE_UNSPECIFIED"] = "STATE_UNSPECIFIED";
+    // File is being processed and cannot be used for inference yet.
+    FileState["PROCESSING"] = "PROCESSING";
+    // File is processed and available for inference.
+    FileState["ACTIVE"] = "ACTIVE";
+    // File failed processing.
+    FileState["FAILED"] = "FAILED";
+})(exports.FileState || (exports.FileState = {}));
+
+/**
+ * Contains the list of OpenAPI data types
+ * as defined by https://swagger.io/docs/specification/data-models/data-types/
+ * @public
+ */
+exports.SchemaType = void 0;
+(function (SchemaType) {
+    /** String type. */
+    SchemaType["STRING"] = "string";
+    /** Number type. */
+    SchemaType["NUMBER"] = "number";
+    /** Integer type. */
+    SchemaType["INTEGER"] = "integer";
+    /** Boolean type. */
+    SchemaType["BOOLEAN"] = "boolean";
+    /** Array type. */
+    SchemaType["ARRAY"] = "array";
+    /** Object type. */
+    SchemaType["OBJECT"] = "object";
+})(exports.SchemaType || (exports.SchemaType = {}));
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @public
+ */
+exports.ExecutableCodeLanguage = void 0;
+(function (ExecutableCodeLanguage) {
+    ExecutableCodeLanguage["LANGUAGE_UNSPECIFIED"] = "language_unspecified";
+    ExecutableCodeLanguage["PYTHON"] = "python";
+})(exports.ExecutableCodeLanguage || (exports.ExecutableCodeLanguage = {}));
+/**
+ * Possible outcomes of code execution.
+ * @public
+ */
+exports.Outcome = void 0;
+(function (Outcome) {
+    /**
+     * Unspecified status. This value should not be used.
+     */
+    Outcome["OUTCOME_UNSPECIFIED"] = "outcome_unspecified";
+    /**
+     * Code execution completed successfully.
+     */
+    Outcome["OUTCOME_OK"] = "outcome_ok";
+    /**
+     * Code execution finished but with a failure. `stderr` should contain the
+     * reason.
+     */
+    Outcome["OUTCOME_FAILED"] = "outcome_failed";
+    /**
+     * Code execution ran for too long, and was cancelled. There may or may not
+     * be a partial output present.
+     */
+    Outcome["OUTCOME_DEADLINE_EXCEEDED"] = "outcome_deadline_exceeded";
+})(exports.Outcome || (exports.Outcome = {}));
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Possible roles.
+ * @public
+ */
+/**
+ * Harm categories that would cause prompts or candidates to be blocked.
+ * @public
+ */
+var HarmCategory;
+(function (HarmCategory) {
+    HarmCategory["HARM_CATEGORY_UNSPECIFIED"] = "HARM_CATEGORY_UNSPECIFIED";
+    HarmCategory["HARM_CATEGORY_HATE_SPEECH"] = "HARM_CATEGORY_HATE_SPEECH";
+    HarmCategory["HARM_CATEGORY_SEXUALLY_EXPLICIT"] = "HARM_CATEGORY_SEXUALLY_EXPLICIT";
+    HarmCategory["HARM_CATEGORY_HARASSMENT"] = "HARM_CATEGORY_HARASSMENT";
+    HarmCategory["HARM_CATEGORY_DANGEROUS_CONTENT"] = "HARM_CATEGORY_DANGEROUS_CONTENT";
+})(HarmCategory || (HarmCategory = {}));
+/**
+ * Threshold above which a prompt or candidate will be blocked.
+ * @public
+ */
+var HarmBlockThreshold;
+(function (HarmBlockThreshold) {
+    // Threshold is unspecified.
+    HarmBlockThreshold["HARM_BLOCK_THRESHOLD_UNSPECIFIED"] = "HARM_BLOCK_THRESHOLD_UNSPECIFIED";
+    // Content with NEGLIGIBLE will be allowed.
+    HarmBlockThreshold["BLOCK_LOW_AND_ABOVE"] = "BLOCK_LOW_AND_ABOVE";
+    // Content with NEGLIGIBLE and LOW will be allowed.
+    HarmBlockThreshold["BLOCK_MEDIUM_AND_ABOVE"] = "BLOCK_MEDIUM_AND_ABOVE";
+    // Content with NEGLIGIBLE, LOW, and MEDIUM will be allowed.
+    HarmBlockThreshold["BLOCK_ONLY_HIGH"] = "BLOCK_ONLY_HIGH";
+    // All content will be allowed.
+    HarmBlockThreshold["BLOCK_NONE"] = "BLOCK_NONE";
+})(HarmBlockThreshold || (HarmBlockThreshold = {}));
+/**
+ * Probability that a prompt or candidate matches a harm category.
+ * @public
+ */
+var HarmProbability;
+(function (HarmProbability) {
+    // Probability is unspecified.
+    HarmProbability["HARM_PROBABILITY_UNSPECIFIED"] = "HARM_PROBABILITY_UNSPECIFIED";
+    // Content has a negligible chance of being unsafe.
+    HarmProbability["NEGLIGIBLE"] = "NEGLIGIBLE";
+    // Content has a low chance of being unsafe.
+    HarmProbability["LOW"] = "LOW";
+    // Content has a medium chance of being unsafe.
+    HarmProbability["MEDIUM"] = "MEDIUM";
+    // Content has a high chance of being unsafe.
+    HarmProbability["HIGH"] = "HIGH";
+})(HarmProbability || (HarmProbability = {}));
+/**
+ * Reason that a prompt was blocked.
+ * @public
+ */
+var BlockReason;
+(function (BlockReason) {
+    // A blocked reason was not specified.
+    BlockReason["BLOCKED_REASON_UNSPECIFIED"] = "BLOCKED_REASON_UNSPECIFIED";
+    // Content was blocked by safety settings.
+    BlockReason["SAFETY"] = "SAFETY";
+    // Content was blocked, but the reason is uncategorized.
+    BlockReason["OTHER"] = "OTHER";
+})(BlockReason || (BlockReason = {}));
+/**
+ * Reason that a candidate finished.
+ * @public
+ */
+var FinishReason;
+(function (FinishReason) {
+    // Default value. This value is unused.
+    FinishReason["FINISH_REASON_UNSPECIFIED"] = "FINISH_REASON_UNSPECIFIED";
+    // Natural stop point of the model or provided stop sequence.
+    FinishReason["STOP"] = "STOP";
+    // The maximum number of tokens as specified in the request was reached.
+    FinishReason["MAX_TOKENS"] = "MAX_TOKENS";
+    // The candidate content was flagged for safety reasons.
+    FinishReason["SAFETY"] = "SAFETY";
+    // The candidate content was flagged for recitation reasons.
+    FinishReason["RECITATION"] = "RECITATION";
+    // The candidate content was flagged for using an unsupported language.
+    FinishReason["LANGUAGE"] = "LANGUAGE";
+    // Unknown reason.
+    FinishReason["OTHER"] = "OTHER";
+})(FinishReason || (FinishReason = {}));
+/**
+ * Task type for embedding content.
+ * @public
+ */
+var TaskType;
+(function (TaskType) {
+    TaskType["TASK_TYPE_UNSPECIFIED"] = "TASK_TYPE_UNSPECIFIED";
+    TaskType["RETRIEVAL_QUERY"] = "RETRIEVAL_QUERY";
+    TaskType["RETRIEVAL_DOCUMENT"] = "RETRIEVAL_DOCUMENT";
+    TaskType["SEMANTIC_SIMILARITY"] = "SEMANTIC_SIMILARITY";
+    TaskType["CLASSIFICATION"] = "CLASSIFICATION";
+    TaskType["CLUSTERING"] = "CLUSTERING";
+})(TaskType || (TaskType = {}));
+/**
+ * @public
+ */
+exports.FunctionCallingMode = void 0;
+(function (FunctionCallingMode) {
+    // Unspecified function calling mode. This value should not be used.
+    FunctionCallingMode["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
+    // Default model behavior, model decides to predict either a function call
+    // or a natural language repspose.
+    FunctionCallingMode["AUTO"] = "AUTO";
+    // Model is constrained to always predicting a function call only.
+    // If "allowed_function_names" are set, the predicted function call will be
+    // limited to any one of "allowed_function_names", else the predicted
+    // function call will be any one of the provided "function_declarations".
+    FunctionCallingMode["ANY"] = "ANY";
+    // Model will not predict any function call. Model behavior is same as when
+    // not passing any function declarations.
+    FunctionCallingMode["NONE"] = "NONE";
+})(exports.FunctionCallingMode || (exports.FunctionCallingMode = {}));
+/**
+ * The mode of the predictor to be used in dynamic retrieval.
+ * @public
+ */
+var DynamicRetrievalMode;
+(function (DynamicRetrievalMode) {
+    // Unspecified function calling mode. This value should not be used.
+    DynamicRetrievalMode["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
+    // Run retrieval only when system decides it is necessary.
+    DynamicRetrievalMode["MODE_DYNAMIC"] = "MODE_DYNAMIC";
+})(DynamicRetrievalMode || (DynamicRetrievalMode = {}));
+
+exports.GoogleAICacheManager = GoogleAICacheManager;
+exports.GoogleAIFileManager = GoogleAIFileManager;
+//# sourceMappingURL=index.js.map

node_modules/@google/generative-ai/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/@google/generative-ai/dist/server/index.mjs

@@ -0,0 +1,794 @@
+import { readFileSync } from 'fs';
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Basic error type for this SDK.
+ * @public
+ */
+class GoogleGenerativeAIError extends Error {
+    constructor(message) {
+        super(`[GoogleGenerativeAI Error]: ${message}`);
+    }
+}
+/**
+ * Error class covering HTTP errors when calling the server. Includes HTTP
+ * status, statusText, and optional details, if provided in the server response.
+ * @public
+ */
+class GoogleGenerativeAIFetchError extends GoogleGenerativeAIError {
+    constructor(message, status, statusText, errorDetails) {
+        super(message);
+        this.status = status;
+        this.statusText = statusText;
+        this.errorDetails = errorDetails;
+    }
+}
+/**
+ * Errors in the contents of a request originating from user input.
+ * @public
+ */
+class GoogleGenerativeAIRequestInputError extends GoogleGenerativeAIError {
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
+const DEFAULT_API_VERSION = "v1beta";
+/**
+ * We can't `require` package.json if this runs on web. We will use rollup to
+ * swap in the version number here at build time.
+ */
+const PACKAGE_VERSION = "0.21.0";
+const PACKAGE_LOG_HEADER = "genai-js";
+var Task;
+(function (Task) {
+    Task["GENERATE_CONTENT"] = "generateContent";
+    Task["STREAM_GENERATE_CONTENT"] = "streamGenerateContent";
+    Task["COUNT_TOKENS"] = "countTokens";
+    Task["EMBED_CONTENT"] = "embedContent";
+    Task["BATCH_EMBED_CONTENTS"] = "batchEmbedContents";
+})(Task || (Task = {}));
+/**
+ * Simple, but may become more complex if we add more versions to log.
+ */
+function getClientHeaders(requestOptions) {
+    const clientHeaders = [];
+    if (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.apiClient) {
+        clientHeaders.push(requestOptions.apiClient);
+    }
+    clientHeaders.push(`${PACKAGE_LOG_HEADER}/${PACKAGE_VERSION}`);
+    return clientHeaders.join(" ");
+}
+async function makeRequest(url, fetchOptions, fetchFn = fetch) {
+    let response;
+    try {
+        response = await fetchFn(url, fetchOptions);
+    }
+    catch (e) {
+        handleResponseError(e, url);
+    }
+    if (!response.ok) {
+        await handleResponseNotOk(response, url);
+    }
+    return response;
+}
+function handleResponseError(e, url) {
+    let err = e;
+    if (!(e instanceof GoogleGenerativeAIFetchError ||
+        e instanceof GoogleGenerativeAIRequestInputError)) {
+        err = new GoogleGenerativeAIError(`Error fetching from ${url.toString()}: ${e.message}`);
+        err.stack = e.stack;
+    }
+    throw err;
+}
+async function handleResponseNotOk(response, url) {
+    let message = "";
+    let errorDetails;
+    try {
+        const json = await response.json();
+        message = json.error.message;
+        if (json.error.details) {
+            message += ` ${JSON.stringify(json.error.details)}`;
+            errorDetails = json.error.details;
+        }
+    }
+    catch (e) {
+        // ignored
+    }
+    throw new GoogleGenerativeAIFetchError(`Error fetching from ${url.toString()}: [${response.status} ${response.statusText}] ${message}`, response.status, response.statusText, errorDetails);
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var RpcTask;
+(function (RpcTask) {
+    RpcTask["UPLOAD"] = "upload";
+    RpcTask["LIST"] = "list";
+    RpcTask["GET"] = "get";
+    RpcTask["DELETE"] = "delete";
+    RpcTask["UPDATE"] = "update";
+    RpcTask["CREATE"] = "create";
+})(RpcTask || (RpcTask = {}));
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const taskToMethod = {
+    [RpcTask.UPLOAD]: "POST",
+    [RpcTask.LIST]: "GET",
+    [RpcTask.GET]: "GET",
+    [RpcTask.DELETE]: "DELETE",
+    [RpcTask.UPDATE]: "PATCH",
+    [RpcTask.CREATE]: "POST",
+};
+class ServerRequestUrl {
+    constructor(task, apiKey, requestOptions) {
+        this.task = task;
+        this.apiKey = apiKey;
+        this.requestOptions = requestOptions;
+    }
+    appendPath(path) {
+        this._url.pathname = this._url.pathname + `/${path}`;
+    }
+    appendParam(key, value) {
+        this._url.searchParams.append(key, value);
+    }
+    toString() {
+        return this._url.toString();
+    }
+}
+class CachedContentUrl extends ServerRequestUrl {
+    constructor(task, apiKey, requestOptions) {
+        var _a, _b;
+        super(task, apiKey, requestOptions);
+        this.task = task;
+        this.apiKey = apiKey;
+        this.requestOptions = requestOptions;
+        const apiVersion = ((_a = this.requestOptions) === null || _a === void 0 ? void 0 : _a.apiVersion) || DEFAULT_API_VERSION;
+        const baseUrl = ((_b = this.requestOptions) === null || _b === void 0 ? void 0 : _b.baseUrl) || DEFAULT_BASE_URL;
+        let initialUrl = baseUrl;
+        initialUrl += `/${apiVersion}/cachedContents`;
+        this._url = new URL(initialUrl);
+    }
+}
+class FilesRequestUrl extends ServerRequestUrl {
+    constructor(task, apiKey, requestOptions) {
+        var _a, _b;
+        super(task, apiKey, requestOptions);
+        this.task = task;
+        this.apiKey = apiKey;
+        this.requestOptions = requestOptions;
+        const apiVersion = ((_a = this.requestOptions) === null || _a === void 0 ? void 0 : _a.apiVersion) || DEFAULT_API_VERSION;
+        const baseUrl = ((_b = this.requestOptions) === null || _b === void 0 ? void 0 : _b.baseUrl) || DEFAULT_BASE_URL;
+        let initialUrl = baseUrl;
+        if (this.task === RpcTask.UPLOAD) {
+            initialUrl += `/upload`;
+        }
+        initialUrl += `/${apiVersion}/files`;
+        this._url = new URL(initialUrl);
+    }
+}
+function getHeaders(url) {
+    const headers = new Headers();
+    headers.append("x-goog-api-client", getClientHeaders(url.requestOptions));
+    headers.append("x-goog-api-key", url.apiKey);
+    return headers;
+}
+async function makeServerRequest(url, headers, body, fetchFn = fetch) {
+    const requestInit = {
+        method: taskToMethod[url.task],
+        headers,
+    };
+    if (body) {
+        requestInit.body = body;
+    }
+    const signal = getSignal(url.requestOptions);
+    if (signal) {
+        requestInit.signal = signal;
+    }
+    return makeRequest(url.toString(), requestInit, fetchFn);
+}
+/**
+ * Create an AbortSignal based on the timeout and signal in the
+ * RequestOptions.
+ */
+function getSignal(requestOptions) {
+    if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.signal) !== undefined || (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeout) >= 0) {
+        const controller = new AbortController();
+        if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeout) >= 0) {
+            setTimeout(() => controller.abort(), requestOptions.timeout);
+        }
+        if (requestOptions.signal) {
+            requestOptions.signal.addEventListener("abort", () => {
+                controller.abort();
+            });
+        }
+        return controller.signal;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class for managing GoogleAI file uploads.
+ * @public
+ */
+class GoogleAIFileManager {
+    constructor(apiKey, _requestOptions = {}) {
+        this.apiKey = apiKey;
+        this._requestOptions = _requestOptions;
+    }
+    /**
+     * Upload a file.
+     */
+    async uploadFile(filePath, fileMetadata) {
+        const file = readFileSync(filePath);
+        const url = new FilesRequestUrl(RpcTask.UPLOAD, this.apiKey, this._requestOptions);
+        const uploadHeaders = getHeaders(url);
+        const boundary = generateBoundary();
+        uploadHeaders.append("X-Goog-Upload-Protocol", "multipart");
+        uploadHeaders.append("Content-Type", `multipart/related; boundary=${boundary}`);
+        const uploadMetadata = getUploadMetadata(fileMetadata);
+        // Multipart formatting code taken from @firebase/storage
+        const metadataString = JSON.stringify({ file: uploadMetadata });
+        const preBlobPart = "--" +
+            boundary +
+            "\r\n" +
+            "Content-Type: application/json; charset=utf-8\r\n\r\n" +
+            metadataString +
+            "\r\n--" +
+            boundary +
+            "\r\n" +
+            "Content-Type: " +
+            fileMetadata.mimeType +
+            "\r\n\r\n";
+        const postBlobPart = "\r\n--" + boundary + "--";
+        const blob = new Blob([preBlobPart, file, postBlobPart]);
+        const response = await makeServerRequest(url, uploadHeaders, blob);
+        return response.json();
+    }
+    /**
+     * List all uploaded files.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    async listFiles(listParams, requestOptions = {}) {
+        const filesRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        const url = new FilesRequestUrl(RpcTask.LIST, this.apiKey, filesRequestOptions);
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageSize) {
+            url.appendParam("pageSize", listParams.pageSize.toString());
+        }
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageToken) {
+            url.appendParam("pageToken", listParams.pageToken);
+        }
+        const uploadHeaders = getHeaders(url);
+        const response = await makeServerRequest(url, uploadHeaders);
+        return response.json();
+    }
+    /**
+     * Get metadata for file with given ID.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    async getFile(fileId, requestOptions = {}) {
+        const filesRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        const url = new FilesRequestUrl(RpcTask.GET, this.apiKey, filesRequestOptions);
+        url.appendPath(parseFileId(fileId));
+        const uploadHeaders = getHeaders(url);
+        const response = await makeServerRequest(url, uploadHeaders);
+        return response.json();
+    }
+    /**
+     * Delete file with given ID.
+     */
+    async deleteFile(fileId) {
+        const url = new FilesRequestUrl(RpcTask.DELETE, this.apiKey, this._requestOptions);
+        url.appendPath(parseFileId(fileId));
+        const uploadHeaders = getHeaders(url);
+        await makeServerRequest(url, uploadHeaders);
+    }
+}
+/**
+ * If fileId is prepended with "files/", remove prefix
+ */
+function parseFileId(fileId) {
+    if (fileId.startsWith("files/")) {
+        return fileId.split("files/")[1];
+    }
+    if (!fileId) {
+        throw new GoogleGenerativeAIError(`Invalid fileId ${fileId}. ` +
+            `Must be in the format "files/filename" or "filename"`);
+    }
+    return fileId;
+}
+function generateBoundary() {
+    let str = "";
+    for (let i = 0; i < 2; i++) {
+        str = str + Math.random().toString().slice(2);
+    }
+    return str;
+}
+function getUploadMetadata(inputMetadata) {
+    if (!inputMetadata.mimeType) {
+        throw new GoogleGenerativeAIRequestInputError("Must provide a mimeType.");
+    }
+    const uploadMetadata = {
+        mimeType: inputMetadata.mimeType,
+        displayName: inputMetadata.displayName,
+    };
+    if (inputMetadata.name) {
+        uploadMetadata.name = inputMetadata.name.includes("/")
+            ? inputMetadata.name
+            : `files/${inputMetadata.name}`;
+    }
+    return uploadMetadata;
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function formatSystemInstruction(input) {
+    // null or undefined
+    if (input == null) {
+        return undefined;
+    }
+    else if (typeof input === "string") {
+        return { role: "system", parts: [{ text: input }] };
+    }
+    else if (input.text) {
+        return { role: "system", parts: [input] };
+    }
+    else if (input.parts) {
+        if (!input.role) {
+            return { role: "system", parts: input.parts };
+        }
+        else {
+            return input;
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class for managing GoogleAI content caches.
+ * @public
+ */
+class GoogleAICacheManager {
+    constructor(apiKey, _requestOptions) {
+        this.apiKey = apiKey;
+        this._requestOptions = _requestOptions;
+    }
+    /**
+     * Upload a new content cache
+     */
+    async create(createOptions) {
+        const newCachedContent = Object.assign({}, createOptions);
+        if (createOptions.ttlSeconds) {
+            if (createOptions.expireTime) {
+                throw new GoogleGenerativeAIRequestInputError("You cannot specify both `ttlSeconds` and `expireTime` when creating" +
+                    " a content cache. You must choose one.");
+            }
+            if (createOptions.systemInstruction) {
+                newCachedContent.systemInstruction = formatSystemInstruction(createOptions.systemInstruction);
+            }
+            newCachedContent.ttl = createOptions.ttlSeconds.toString() + "s";
+            delete newCachedContent.ttlSeconds;
+        }
+        if (!newCachedContent.model) {
+            throw new GoogleGenerativeAIRequestInputError("Cached content must contain a `model` field.");
+        }
+        if (!newCachedContent.model.includes("/")) {
+            // If path is not included, assume it's a non-tuned model.
+            newCachedContent.model = `models/${newCachedContent.model}`;
+        }
+        const url = new CachedContentUrl(RpcTask.CREATE, this.apiKey, this._requestOptions);
+        const headers = getHeaders(url);
+        const response = await makeServerRequest(url, headers, JSON.stringify(newCachedContent));
+        return response.json();
+    }
+    /**
+     * List all uploaded content caches
+     */
+    async list(listParams) {
+        const url = new CachedContentUrl(RpcTask.LIST, this.apiKey, this._requestOptions);
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageSize) {
+            url.appendParam("pageSize", listParams.pageSize.toString());
+        }
+        if (listParams === null || listParams === void 0 ? void 0 : listParams.pageToken) {
+            url.appendParam("pageToken", listParams.pageToken);
+        }
+        const headers = getHeaders(url);
+        const response = await makeServerRequest(url, headers);
+        return response.json();
+    }
+    /**
+     * Get a content cache
+     */
+    async get(name) {
+        const url = new CachedContentUrl(RpcTask.GET, this.apiKey, this._requestOptions);
+        url.appendPath(parseCacheName(name));
+        const headers = getHeaders(url);
+        const response = await makeServerRequest(url, headers);
+        return response.json();
+    }
+    /**
+     * Update an existing content cache
+     */
+    async update(name, updateParams) {
+        const url = new CachedContentUrl(RpcTask.UPDATE, this.apiKey, this._requestOptions);
+        url.appendPath(parseCacheName(name));
+        const headers = getHeaders(url);
+        const formattedCachedContent = Object.assign({}, updateParams.cachedContent);
+        if (updateParams.cachedContent.ttlSeconds) {
+            formattedCachedContent.ttl =
+                updateParams.cachedContent.ttlSeconds.toString() + "s";
+            delete formattedCachedContent.ttlSeconds;
+        }
+        if (updateParams.updateMask) {
+            url.appendParam("update_mask", updateParams.updateMask.map((prop) => camelToSnake(prop)).join(","));
+        }
+        const response = await makeServerRequest(url, headers, JSON.stringify(formattedCachedContent));
+        return response.json();
+    }
+    /**
+     * Delete content cache with given name
+     */
+    async delete(name) {
+        const url = new CachedContentUrl(RpcTask.DELETE, this.apiKey, this._requestOptions);
+        url.appendPath(parseCacheName(name));
+        const headers = getHeaders(url);
+        await makeServerRequest(url, headers);
+    }
+}
+/**
+ * If cache name is prepended with "cachedContents/", remove prefix
+ */
+function parseCacheName(name) {
+    if (name.startsWith("cachedContents/")) {
+        return name.split("cachedContents/")[1];
+    }
+    if (!name) {
+        throw new GoogleGenerativeAIError(`Invalid name ${name}. ` +
+            `Must be in the format "cachedContents/name" or "name"`);
+    }
+    return name;
+}
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+/**
+ * Processing state of the `File`.
+ * @public
+ */
+var FileState;
+(function (FileState) {
+    // The default value. This value is used if the state is omitted.
+    FileState["STATE_UNSPECIFIED"] = "STATE_UNSPECIFIED";
+    // File is being processed and cannot be used for inference yet.
+    FileState["PROCESSING"] = "PROCESSING";
+    // File is processed and available for inference.
+    FileState["ACTIVE"] = "ACTIVE";
+    // File failed processing.
+    FileState["FAILED"] = "FAILED";
+})(FileState || (FileState = {}));
+
+/**
+ * Contains the list of OpenAPI data types
+ * as defined by https://swagger.io/docs/specification/data-models/data-types/
+ * @public
+ */
+var SchemaType;
+(function (SchemaType) {
+    /** String type. */
+    SchemaType["STRING"] = "string";
+    /** Number type. */
+    SchemaType["NUMBER"] = "number";
+    /** Integer type. */
+    SchemaType["INTEGER"] = "integer";
+    /** Boolean type. */
+    SchemaType["BOOLEAN"] = "boolean";
+    /** Array type. */
+    SchemaType["ARRAY"] = "array";
+    /** Object type. */
+    SchemaType["OBJECT"] = "object";
+})(SchemaType || (SchemaType = {}));
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @public
+ */
+var ExecutableCodeLanguage;
+(function (ExecutableCodeLanguage) {
+    ExecutableCodeLanguage["LANGUAGE_UNSPECIFIED"] = "language_unspecified";
+    ExecutableCodeLanguage["PYTHON"] = "python";
+})(ExecutableCodeLanguage || (ExecutableCodeLanguage = {}));
+/**
+ * Possible outcomes of code execution.
+ * @public
+ */
+var Outcome;
+(function (Outcome) {
+    /**
+     * Unspecified status. This value should not be used.
+     */
+    Outcome["OUTCOME_UNSPECIFIED"] = "outcome_unspecified";
+    /**
+     * Code execution completed successfully.
+     */
+    Outcome["OUTCOME_OK"] = "outcome_ok";
+    /**
+     * Code execution finished but with a failure. `stderr` should contain the
+     * reason.
+     */
+    Outcome["OUTCOME_FAILED"] = "outcome_failed";
+    /**
+     * Code execution ran for too long, and was cancelled. There may or may not
+     * be a partial output present.
+     */
+    Outcome["OUTCOME_DEADLINE_EXCEEDED"] = "outcome_deadline_exceeded";
+})(Outcome || (Outcome = {}));
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Possible roles.
+ * @public
+ */
+/**
+ * Harm categories that would cause prompts or candidates to be blocked.
+ * @public
+ */
+var HarmCategory;
+(function (HarmCategory) {
+    HarmCategory["HARM_CATEGORY_UNSPECIFIED"] = "HARM_CATEGORY_UNSPECIFIED";
+    HarmCategory["HARM_CATEGORY_HATE_SPEECH"] = "HARM_CATEGORY_HATE_SPEECH";
+    HarmCategory["HARM_CATEGORY_SEXUALLY_EXPLICIT"] = "HARM_CATEGORY_SEXUALLY_EXPLICIT";
+    HarmCategory["HARM_CATEGORY_HARASSMENT"] = "HARM_CATEGORY_HARASSMENT";
+    HarmCategory["HARM_CATEGORY_DANGEROUS_CONTENT"] = "HARM_CATEGORY_DANGEROUS_CONTENT";
+})(HarmCategory || (HarmCategory = {}));
+/**
+ * Threshold above which a prompt or candidate will be blocked.
+ * @public
+ */
+var HarmBlockThreshold;
+(function (HarmBlockThreshold) {
+    // Threshold is unspecified.
+    HarmBlockThreshold["HARM_BLOCK_THRESHOLD_UNSPECIFIED"] = "HARM_BLOCK_THRESHOLD_UNSPECIFIED";
+    // Content with NEGLIGIBLE will be allowed.
+    HarmBlockThreshold["BLOCK_LOW_AND_ABOVE"] = "BLOCK_LOW_AND_ABOVE";
+    // Content with NEGLIGIBLE and LOW will be allowed.
+    HarmBlockThreshold["BLOCK_MEDIUM_AND_ABOVE"] = "BLOCK_MEDIUM_AND_ABOVE";
+    // Content with NEGLIGIBLE, LOW, and MEDIUM will be allowed.
+    HarmBlockThreshold["BLOCK_ONLY_HIGH"] = "BLOCK_ONLY_HIGH";
+    // All content will be allowed.
+    HarmBlockThreshold["BLOCK_NONE"] = "BLOCK_NONE";
+})(HarmBlockThreshold || (HarmBlockThreshold = {}));
+/**
+ * Probability that a prompt or candidate matches a harm category.
+ * @public
+ */
+var HarmProbability;
+(function (HarmProbability) {
+    // Probability is unspecified.
+    HarmProbability["HARM_PROBABILITY_UNSPECIFIED"] = "HARM_PROBABILITY_UNSPECIFIED";
+    // Content has a negligible chance of being unsafe.
+    HarmProbability["NEGLIGIBLE"] = "NEGLIGIBLE";
+    // Content has a low chance of being unsafe.
+    HarmProbability["LOW"] = "LOW";
+    // Content has a medium chance of being unsafe.
+    HarmProbability["MEDIUM"] = "MEDIUM";
+    // Content has a high chance of being unsafe.
+    HarmProbability["HIGH"] = "HIGH";
+})(HarmProbability || (HarmProbability = {}));
+/**
+ * Reason that a prompt was blocked.
+ * @public
+ */
+var BlockReason;
+(function (BlockReason) {
+    // A blocked reason was not specified.
+    BlockReason["BLOCKED_REASON_UNSPECIFIED"] = "BLOCKED_REASON_UNSPECIFIED";
+    // Content was blocked by safety settings.
+    BlockReason["SAFETY"] = "SAFETY";
+    // Content was blocked, but the reason is uncategorized.
+    BlockReason["OTHER"] = "OTHER";
+})(BlockReason || (BlockReason = {}));
+/**
+ * Reason that a candidate finished.
+ * @public
+ */
+var FinishReason;
+(function (FinishReason) {
+    // Default value. This value is unused.
+    FinishReason["FINISH_REASON_UNSPECIFIED"] = "FINISH_REASON_UNSPECIFIED";
+    // Natural stop point of the model or provided stop sequence.
+    FinishReason["STOP"] = "STOP";
+    // The maximum number of tokens as specified in the request was reached.
+    FinishReason["MAX_TOKENS"] = "MAX_TOKENS";
+    // The candidate content was flagged for safety reasons.
+    FinishReason["SAFETY"] = "SAFETY";
+    // The candidate content was flagged for recitation reasons.
+    FinishReason["RECITATION"] = "RECITATION";
+    // The candidate content was flagged for using an unsupported language.
+    FinishReason["LANGUAGE"] = "LANGUAGE";
+    // Unknown reason.
+    FinishReason["OTHER"] = "OTHER";
+})(FinishReason || (FinishReason = {}));
+/**
+ * Task type for embedding content.
+ * @public
+ */
+var TaskType;
+(function (TaskType) {
+    TaskType["TASK_TYPE_UNSPECIFIED"] = "TASK_TYPE_UNSPECIFIED";
+    TaskType["RETRIEVAL_QUERY"] = "RETRIEVAL_QUERY";
+    TaskType["RETRIEVAL_DOCUMENT"] = "RETRIEVAL_DOCUMENT";
+    TaskType["SEMANTIC_SIMILARITY"] = "SEMANTIC_SIMILARITY";
+    TaskType["CLASSIFICATION"] = "CLASSIFICATION";
+    TaskType["CLUSTERING"] = "CLUSTERING";
+})(TaskType || (TaskType = {}));
+/**
+ * @public
+ */
+var FunctionCallingMode;
+(function (FunctionCallingMode) {
+    // Unspecified function calling mode. This value should not be used.
+    FunctionCallingMode["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
+    // Default model behavior, model decides to predict either a function call
+    // or a natural language repspose.
+    FunctionCallingMode["AUTO"] = "AUTO";
+    // Model is constrained to always predicting a function call only.
+    // If "allowed_function_names" are set, the predicted function call will be
+    // limited to any one of "allowed_function_names", else the predicted
+    // function call will be any one of the provided "function_declarations".
+    FunctionCallingMode["ANY"] = "ANY";
+    // Model will not predict any function call. Model behavior is same as when
+    // not passing any function declarations.
+    FunctionCallingMode["NONE"] = "NONE";
+})(FunctionCallingMode || (FunctionCallingMode = {}));
+/**
+ * The mode of the predictor to be used in dynamic retrieval.
+ * @public
+ */
+var DynamicRetrievalMode;
+(function (DynamicRetrievalMode) {
+    // Unspecified function calling mode. This value should not be used.
+    DynamicRetrievalMode["MODE_UNSPECIFIED"] = "MODE_UNSPECIFIED";
+    // Run retrieval only when system decides it is necessary.
+    DynamicRetrievalMode["MODE_DYNAMIC"] = "MODE_DYNAMIC";
+})(DynamicRetrievalMode || (DynamicRetrievalMode = {}));
+
+export { ExecutableCodeLanguage, FileState, FunctionCallingMode, GoogleAICacheManager, GoogleAIFileManager, Outcome, SchemaType };
+//# sourceMappingURL=index.mjs.map

node_modules/@google/generative-ai/dist/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/@google/generative-ai/dist/server/scripts/check-format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

node_modules/@google/generative-ai/dist/server/scripts/format-patterns.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const formatPatterns: string[];
+export declare function getFormatPatternsString(): string;

node_modules/@google/generative-ai/dist/server/scripts/license.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function doLicense(write: boolean): Promise<boolean>;

node_modules/@google/generative-ai/dist/server/scripts/run-format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

node_modules/@google/generative-ai/dist/server/server.d.ts

@@ -0,0 +1,793 @@
+/**
+ * Describes `CachedContent` interface for sending to the server (if creating)
+ * or received from the server (using getters or list methods).
+ * @public
+ */
+export declare interface CachedContent extends CachedContentBase {
+    name?: string;
+    /**
+     * protobuf.Duration format (ex. "3.0001s").
+     */
+    ttl?: string;
+    /**
+     * `CachedContent` creation time in ISO string format.
+     */
+    createTime?: string;
+    /**
+     * `CachedContent` update time in ISO string format.
+     */
+    updateTime?: string;
+}
+
+/**
+ * @public
+ */
+export declare interface CachedContentBase {
+    model?: string;
+    contents: Content[];
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: string | Part | Content;
+    /**
+     * Expiration time in ISO string format. Specify either this or `ttlSeconds`
+     * when creating a `CachedContent`.
+     */
+    expireTime?: string;
+    displayName?: string;
+}
+
+/**
+ * Params to pass to {@link GoogleAICacheManager.create}.
+ * @public
+ */
+export declare interface CachedContentCreateParams extends CachedContentBase {
+    /**
+     * `CachedContent` ttl in seconds. Specify either this or `expireTime`
+     * when creating a `CachedContent`.
+     */
+    ttlSeconds?: number;
+}
+
+/**
+ * Fields that can be updated in an existing content cache.
+ * @public
+ */
+export declare interface CachedContentUpdateInputFields {
+    ttlSeconds?: number;
+    expireTime?: string;
+}
+
+/**
+ * Params to pass to {@link GoogleAICacheManager.update}.
+ * @public
+ */
+export declare interface CachedContentUpdateParams {
+    cachedContent: CachedContentUpdateInputFields;
+    /**
+     * protobuf FieldMask. If not specified, updates all provided fields.
+     */
+    updateMask?: string[];
+}
+
+/**
+ * Params as sent to the backend (ttl instead of ttlSeconds).
+ * @internal
+ */
+export declare interface _CachedContentUpdateRequest {
+    cachedContent: _CachedContentUpdateRequestFields;
+    /**
+     * protobuf FieldMask
+     */
+    updateMask?: string[];
+}
+
+/**
+ * Fields that can be updated in an existing content cache.
+ * @internal
+ */
+export declare interface _CachedContentUpdateRequestFields {
+    ttl?: string;
+    expireTime?: string;
+}
+
+/**
+ * Result of executing the `ExecutableCode`.
+ * Only generated when using code execution, and always follows a `Part`
+ * containing the `ExecutableCode`.
+ * @public
+ */
+export declare interface CodeExecutionResult {
+    /**
+     * Outcome of the code execution.
+     */
+    outcome: Outcome;
+    /**
+     * Contains stdout when code execution is successful, stderr or other
+     * description otherwise.
+     */
+    output: string;
+}
+
+/**
+ * Content part containing the result of executed code.
+ * @public
+ */
+export declare interface CodeExecutionResultPart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult: CodeExecutionResult;
+}
+
+/**
+ * Enables the model to execute code as part of generation.
+ * @public
+ */
+export declare interface CodeExecutionTool {
+    /**
+     * Provide an empty object to enable code execution. This field may have
+     * subfields added in the future.
+     */
+    codeExecution: {};
+}
+
+/**
+ * Content type for both prompts and response candidates.
+ * @public
+ */
+export declare interface Content {
+    role: string;
+    parts: Part[];
+}
+
+/**
+ * Specifies the dynamic retrieval configuration for the given source.
+ * @public
+ */
+declare interface DynamicRetrievalConfig {
+    /**
+     * The mode of the predictor to be used in dynamic retrieval.
+     */
+    mode?: DynamicRetrievalMode;
+    /**
+     * The threshold to be used in dynamic retrieval. If not set, a system default
+     * value is used.
+     */
+    dynamicThreshold?: number;
+}
+
+/**
+ * The mode of the predictor to be used in dynamic retrieval.
+ * @public
+ */
+declare enum DynamicRetrievalMode {
+    MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
+    MODE_DYNAMIC = "MODE_DYNAMIC"
+}
+
+/**
+ * Details object that may be included in an error response.
+ * @public
+ */
+export declare interface ErrorDetails {
+    "@type"?: string;
+    reason?: string;
+    domain?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+
+/**
+ * Code generated by the model that is meant to be executed, where the result
+ * is returned to the model.
+ * Only generated when using the code execution tool, in which the code will
+ * be automatically executed, and a corresponding `CodeExecutionResult` will
+ * also be generated.
+ *
+ * @public
+ */
+export declare interface ExecutableCode {
+    /**
+     * Programming language of the `code`.
+     */
+    language: ExecutableCodeLanguage;
+    /**
+     * The code to be executed.
+     */
+    code: string;
+}
+
+/**
+ * @public
+ */
+export declare enum ExecutableCodeLanguage {
+    LANGUAGE_UNSPECIFIED = "language_unspecified",
+    PYTHON = "python"
+}
+
+/**
+ * Content part containing executable code generated by the model.
+ * @public
+ */
+export declare interface ExecutableCodePart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode: ExecutableCode;
+    codeExecutionResult?: never;
+}
+
+/**
+ * Data pointing to a file uploaded with the Files API.
+ * @public
+ */
+export declare interface FileData {
+    mimeType: string;
+    fileUri: string;
+}
+
+/**
+ * Content part interface if the part represents FileData.
+ * @public
+ */
+export declare interface FileDataPart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData: FileData;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+
+/**
+ * Metadata to provide alongside a file upload
+ * @public
+ */
+export declare interface FileMetadata {
+    name?: string;
+    displayName?: string;
+    mimeType: string;
+}
+
+/**
+ * File metadata response from server.
+ * @public
+ */
+export declare interface FileMetadataResponse {
+    name: string;
+    displayName?: string;
+    mimeType: string;
+    sizeBytes: string;
+    createTime: string;
+    updateTime: string;
+    expirationTime: string;
+    sha256Hash: string;
+    uri: string;
+    state: FileState;
+    /**
+     * Error populated if file processing has failed.
+     */
+    error?: RpcStatus;
+    /**
+     * Video metadata populated after processing is complete.
+     */
+    videoMetadata?: VideoMetadata;
+}
+
+/**
+ * Processing state of the `File`.
+ * @public
+ */
+export declare enum FileState {
+    STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
+    PROCESSING = "PROCESSING",
+    ACTIVE = "ACTIVE",
+    FAILED = "FAILED"
+}
+
+/**
+ * A predicted [FunctionCall] returned from the model
+ * that contains a string representing the [FunctionDeclaration.name]
+ * and a structured JSON object containing the parameters and their values.
+ * @public
+ */
+export declare interface FunctionCall {
+    name: string;
+    args: object;
+}
+
+/**
+ * @public
+ */
+export declare interface FunctionCallingConfig {
+    mode?: FunctionCallingMode;
+    allowedFunctionNames?: string[];
+}
+
+/**
+ * @public
+ */
+export declare enum FunctionCallingMode {
+    MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
+    AUTO = "AUTO",
+    ANY = "ANY",
+    NONE = "NONE"
+}
+
+/**
+ * Content part interface if the part represents a FunctionCall.
+ * @public
+ */
+export declare interface FunctionCallPart {
+    text?: never;
+    inlineData?: never;
+    functionCall: FunctionCall;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+
+/**
+ * Structured representation of a function declaration as defined by the
+ * [OpenAPI 3.0 specification](https://spec.openapis.org/oas/v3.0.3). Included
+ * in this declaration are the function name and parameters. This
+ * FunctionDeclaration is a representation of a block of code that can be used
+ * as a Tool by the model and executed by the client.
+ * @public
+ */
+export declare interface FunctionDeclaration {
+    /**
+     * The name of the function to call. Must start with a letter or an
+     * underscore. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with
+     * a max length of 64.
+     */
+    name: string;
+    /**
+     * Optional. Description and purpose of the function. Model uses it to decide
+     * how and whether to call the function.
+     */
+    description?: string;
+    /**
+     * Optional. Describes the parameters to this function in JSON Schema Object
+     * format. Reflects the Open API 3.03 Parameter Object. string Key: the name
+     * of the parameter. Parameter names are case sensitive. Schema Value: the
+     * Schema defining the type used for the parameter. For function with no
+     * parameters, this can be left unset.
+     *
+     * @example with 1 required and 1 optional parameter: type: OBJECT properties:
+     * ```
+     * param1:
+     *
+     *   type: STRING
+     * param2:
+     *
+     *  type: INTEGER
+     * required:
+     *
+     *   - param1
+     * ```
+     */
+    parameters?: FunctionDeclarationSchema;
+}
+
+/**
+ * Schema for parameters passed to {@link FunctionDeclaration.parameters}.
+ * @public
+ */
+export declare interface FunctionDeclarationSchema {
+    /** The type of the parameter. */
+    type: SchemaType;
+    /** The format of the parameter. */
+    properties: {
+        [k: string]: FunctionDeclarationSchemaProperty;
+    };
+    /** Optional. Description of the parameter. */
+    description?: string;
+    /** Optional. Array of required parameters. */
+    required?: string[];
+}
+
+/**
+ * Schema for top-level function declaration
+ * @public
+ */
+export declare interface FunctionDeclarationSchemaProperty extends Schema {
+}
+
+/**
+ * A FunctionDeclarationsTool is a piece of code that enables the system to
+ * interact with external systems to perform an action, or set of actions,
+ * outside of knowledge and scope of the model.
+ * @public
+ */
+export declare interface FunctionDeclarationsTool {
+    /**
+     * Optional. One or more function declarations
+     * to be passed to the model along with the current user query. Model may
+     * decide to call a subset of these functions by populating
+     * [FunctionCall][content.part.functionCall] in the response. User should
+     * provide a [FunctionResponse][content.part.functionResponse] for each
+     * function call in the next turn. Based on the function responses, Model will
+     * generate the final response back to the user. Maximum 64 function
+     * declarations can be provided.
+     */
+    functionDeclarations?: FunctionDeclaration[];
+}
+
+/**
+ * The result output from a [FunctionCall] that contains a string
+ * representing the [FunctionDeclaration.name]
+ * and a structured JSON object containing any output
+ * from the function is used as context to the model.
+ * This should contain the result of a [FunctionCall]
+ * made based on model prediction.
+ * @public
+ */
+export declare interface FunctionResponse {
+    name: string;
+    response: object;
+}
+
+/**
+ * Content part interface if the part represents FunctionResponse.
+ * @public
+ */
+export declare interface FunctionResponsePart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse: FunctionResponse;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+
+/**
+ * Interface for sending an image.
+ * @public
+ */
+export declare interface GenerativeContentBlob {
+    mimeType: string;
+    /**
+     * Image as a base64 string.
+     */
+    data: string;
+}
+
+/**
+ * Class for managing GoogleAI content caches.
+ * @public
+ */
+export declare class GoogleAICacheManager {
+    apiKey: string;
+    private _requestOptions?;
+    constructor(apiKey: string, _requestOptions?: RequestOptions);
+    /**
+     * Upload a new content cache
+     */
+    create(createOptions: CachedContentCreateParams): Promise<CachedContent>;
+    /**
+     * List all uploaded content caches
+     */
+    list(listParams?: ListParams): Promise<ListCacheResponse>;
+    /**
+     * Get a content cache
+     */
+    get(name: string): Promise<CachedContent>;
+    /**
+     * Update an existing content cache
+     */
+    update(name: string, updateParams: CachedContentUpdateParams): Promise<CachedContent>;
+    /**
+     * Delete content cache with given name
+     */
+    delete(name: string): Promise<void>;
+}
+
+/**
+ * Class for managing GoogleAI file uploads.
+ * @public
+ */
+export declare class GoogleAIFileManager {
+    apiKey: string;
+    private _requestOptions;
+    constructor(apiKey: string, _requestOptions?: RequestOptions);
+    /**
+     * Upload a file.
+     */
+    uploadFile(filePath: string, fileMetadata: FileMetadata): Promise<UploadFileResponse>;
+    /**
+     * List all uploaded files.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    listFiles(listParams?: ListParams, requestOptions?: SingleRequestOptions): Promise<ListFilesResponse>;
+    /**
+     * Get metadata for file with given ID.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    getFile(fileId: string, requestOptions?: SingleRequestOptions): Promise<FileMetadataResponse>;
+    /**
+     * Delete file with given ID.
+     */
+    deleteFile(fileId: string): Promise<void>;
+}
+
+/**
+ * Retrieval tool that is powered by Google search.
+ * @public
+ */
+declare interface GoogleSearchRetrieval {
+    /**
+     * Specifies the dynamic retrieval configuration for the given source.
+     */
+    dynamicRetrievalConfig?: DynamicRetrievalConfig;
+}
+
+/**
+ * Retrieval tool that is powered by Google search.
+ * @public
+ */
+declare interface GoogleSearchRetrievalTool {
+    /**
+     * Google search retrieval tool config.
+     */
+    googleSearchRetrieval?: GoogleSearchRetrieval;
+}
+
+/**
+ * Content part interface if the part represents an image.
+ * @public
+ */
+export declare interface InlineDataPart {
+    text?: never;
+    inlineData: GenerativeContentBlob;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+
+/**
+ * @public
+ */
+export declare interface ListCacheResponse {
+    cachedContents: CachedContent[];
+    nextPageToken?: string;
+}
+
+/**
+ * Response from calling {@link GoogleAIFileManager.listFiles}
+ * @public
+ */
+export declare interface ListFilesResponse {
+    files: FileMetadataResponse[];
+    nextPageToken?: string;
+}
+
+/**
+ * Params to pass to {@link GoogleAIFileManager.listFiles} or
+ * {@link GoogleAICacheManager.list}
+ * @public
+ */
+export declare interface ListParams {
+    pageSize?: number;
+    pageToken?: string;
+}
+
+/**
+ * Possible outcomes of code execution.
+ * @public
+ */
+export declare enum Outcome {
+    /**
+     * Unspecified status. This value should not be used.
+     */
+    OUTCOME_UNSPECIFIED = "outcome_unspecified",
+    /**
+     * Code execution completed successfully.
+     */
+    OUTCOME_OK = "outcome_ok",
+    /**
+     * Code execution finished but with a failure. `stderr` should contain the
+     * reason.
+     */
+    OUTCOME_FAILED = "outcome_failed",
+    /**
+     * Code execution ran for too long, and was cancelled. There may or may not
+     * be a partial output present.
+     */
+    OUTCOME_DEADLINE_EXCEEDED = "outcome_deadline_exceeded"
+}
+
+/**
+ * Content part - includes text or image part types.
+ * @public
+ */
+export declare type Part = TextPart | InlineDataPart | FunctionCallPart | FunctionResponsePart | FileDataPart | ExecutableCodePart | CodeExecutionResultPart;
+
+/**
+ * Params passed to getGenerativeModel() or GoogleAIFileManager().
+ * @public
+ */
+export declare interface RequestOptions {
+    /**
+     * Request timeout in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Version of API endpoint to call (e.g. "v1" or "v1beta"). If not specified,
+     * defaults to latest stable version.
+     */
+    apiVersion?: string;
+    /**
+     * Additional attribution information to include in the x-goog-api-client header.
+     * Used by wrapper SDKs.
+     */
+    apiClient?: string;
+    /**
+     * Base endpoint url. Defaults to "https://generativelanguage.googleapis.com"
+     */
+    baseUrl?: string;
+    /**
+     * Custom HTTP request headers.
+     */
+    customHeaders?: Headers | Record<string, string>;
+}
+
+/**
+ * Schema passed to `GenerationConfig.responseSchema`
+ * @public
+ */
+export declare interface ResponseSchema extends Schema {
+}
+
+/**
+ * Standard RPC error status object.
+ * @public
+ */
+export declare interface RpcStatus {
+    /**
+     * Error status code
+     */
+    code: number;
+    /**
+     * A developer-facing error message.
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.
+     */
+    details?: ErrorDetails[];
+}
+
+/**
+ * Schema is used to define the format of input/output data.
+ * Represents a select subset of an OpenAPI 3.0 schema object.
+ * More fields may be added in the future as needed.
+ * @public
+ */
+export declare interface Schema {
+    /**
+     * Optional. The type of the property. {@link
+     * SchemaType}.
+     */
+    type?: SchemaType;
+    /** Optional. The format of the property. */
+    format?: string;
+    /** Optional. The description of the property. */
+    description?: string;
+    /** Optional. Whether the property is nullable. */
+    nullable?: boolean;
+    /** Optional. The items of the property. */
+    items?: Schema;
+    /** Optional. The enum of the property. */
+    enum?: string[];
+    /** Optional. Map of {@link Schema}. */
+    properties?: {
+        [k: string]: Schema;
+    };
+    /** Optional. Array of required property. */
+    required?: string[];
+    /** Optional. The example of the property. */
+    example?: unknown;
+}
+
+/**
+ * Contains the list of OpenAPI data types
+ * as defined by https://swagger.io/docs/specification/data-models/data-types/
+ * @public
+ */
+export declare enum SchemaType {
+    /** String type. */
+    STRING = "string",
+    /** Number type. */
+    NUMBER = "number",
+    /** Integer type. */
+    INTEGER = "integer",
+    /** Boolean type. */
+    BOOLEAN = "boolean",
+    /** Array type. */
+    ARRAY = "array",
+    /** Object type. */
+    OBJECT = "object"
+}
+
+/**
+ * Params passed to atomic asynchronous operations.
+ * @public
+ */
+export declare interface SingleRequestOptions extends RequestOptions {
+    /**
+     * An object that may be used to abort asynchronous requests. The request may
+     * also be aborted due to the expiration of the timeout value, if provided.
+     *
+     * NOTE: AbortSignal is a client-only operation. Using it to cancel an
+     * operation will not cancel the request in the service. You will still
+     * be charged usage for any applicable operations.
+     */
+    signal?: AbortSignal;
+}
+
+/**
+ * Content part interface if the part represents a text string.
+ * @public
+ */
+export declare interface TextPart {
+    text: string;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+
+/**
+ * Defines a tool that model can call to access external knowledge.
+ * @public
+ */
+export declare type Tool = FunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool;
+
+/**
+ * Tool config. This config is shared for all tools provided in the request.
+ * @public
+ */
+export declare interface ToolConfig {
+    functionCallingConfig: FunctionCallingConfig;
+}
+
+/**
+ * Response from calling {@link GoogleAIFileManager.uploadFile}
+ * @public
+ */
+export declare interface UploadFileResponse {
+    file: FileMetadataResponse;
+}
+
+/**
+ * Metadata populated when video has been processed.
+ * @public
+ */
+export declare interface VideoMetadata {
+    /**
+     * The video duration in
+     * protobuf {@link https://cloud.google.com/ruby/docs/reference/google-cloud-workflows-v1/latest/Google-Protobuf-Duration#json-mapping | Duration} format.
+     */
+    videoDuration: string;
+}
+
+export { }

node_modules/@google/generative-ai/dist/server/src/errors.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ErrorDetails } from "../types";
+/**
+ * Basic error type for this SDK.
+ * @public
+ */
+export declare class GoogleGenerativeAIError extends Error {
+    constructor(message: string);
+}
+/**
+ * Errors in the contents of a response from the model. This includes parsing
+ * errors, or responses including a safety block reason.
+ * @public
+ */
+export declare class GoogleGenerativeAIResponseError<T> extends GoogleGenerativeAIError {
+    response?: T;
+    constructor(message: string, response?: T);
+}
+/**
+ * Error class covering HTTP errors when calling the server. Includes HTTP
+ * status, statusText, and optional details, if provided in the server response.
+ * @public
+ */
+export declare class GoogleGenerativeAIFetchError extends GoogleGenerativeAIError {
+    status?: number;
+    statusText?: string;
+    errorDetails?: ErrorDetails[];
+    constructor(message: string, status?: number, statusText?: string, errorDetails?: ErrorDetails[]);
+}
+/**
+ * Errors in the contents of a request originating from user input.
+ * @public
+ */
+export declare class GoogleGenerativeAIRequestInputError extends GoogleGenerativeAIError {
+}

node_modules/@google/generative-ai/dist/server/src/gen-ai.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CachedContent, ModelParams, RequestOptions } from "../types";
+import { GenerativeModel } from "./models/generative-model";
+export { ChatSession } from "./methods/chat-session";
+export { GenerativeModel };
+/**
+ * Top-level class for this SDK
+ * @public
+ */
+export declare class GoogleGenerativeAI {
+    apiKey: string;
+    constructor(apiKey: string);
+    /**
+     * Gets a {@link GenerativeModel} instance for the provided model name.
+     */
+    getGenerativeModel(modelParams: ModelParams, requestOptions?: RequestOptions): GenerativeModel;
+    /**
+     * Creates a {@link GenerativeModel} instance from provided content cache.
+     */
+    getGenerativeModelFromCachedContent(cachedContent: CachedContent, modelParams?: Partial<ModelParams>, requestOptions?: RequestOptions): GenerativeModel;
+}

node_modules/@google/generative-ai/dist/server/src/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "../types";
+export * from "./gen-ai";
+export * from "./errors";

node_modules/@google/generative-ai/dist/server/src/methods/chat-session-helpers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Content } from "../../types";
+export declare function validateChatHistory(history: Content[]): void;

node_modules/@google/generative-ai/dist/server/src/methods/chat-session.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Content, GenerateContentResult, GenerateContentStreamResult, Part, RequestOptions, SingleRequestOptions, StartChatParams } from "../../types";
+/**
+ * ChatSession class that enables sending chat messages and stores
+ * history of sent and received messages so far.
+ *
+ * @public
+ */
+export declare class ChatSession {
+    model: string;
+    params?: StartChatParams;
+    private _requestOptions;
+    private _apiKey;
+    private _history;
+    private _sendPromise;
+    constructor(apiKey: string, model: string, params?: StartChatParams, _requestOptions?: RequestOptions);
+    /**
+     * Gets the chat history so far. Blocked prompts are not added to history.
+     * Blocked candidates are not added to history, nor are the prompts that
+     * generated them.
+     */
+    getHistory(): Promise<Content[]>;
+    /**
+     * Sends a chat message and receives a non-streaming
+     * {@link GenerateContentResult}.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    sendMessage(request: string | Array<string | Part>, requestOptions?: SingleRequestOptions): Promise<GenerateContentResult>;
+    /**
+     * Sends a chat message and receives the response as a
+     * {@link GenerateContentStreamResult} containing an iterable stream
+     * and a response promise.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    sendMessageStream(request: string | Array<string | Part>, requestOptions?: SingleRequestOptions): Promise<GenerateContentStreamResult>;
+}

node_modules/@google/generative-ai/dist/server/src/methods/count-tokens.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CountTokensRequest, CountTokensResponse, SingleRequestOptions } from "../../types";
+export declare function countTokens(apiKey: string, model: string, params: CountTokensRequest, singleRequestOptions: SingleRequestOptions): Promise<CountTokensResponse>;

node_modules/@google/generative-ai/dist/server/src/methods/embed-content.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BatchEmbedContentsRequest, BatchEmbedContentsResponse, EmbedContentRequest, EmbedContentResponse, RequestOptions } from "../../types";
+export declare function embedContent(apiKey: string, model: string, params: EmbedContentRequest, requestOptions?: RequestOptions): Promise<EmbedContentResponse>;
+export declare function batchEmbedContents(apiKey: string, model: string, params: BatchEmbedContentsRequest, requestOptions?: RequestOptions): Promise<BatchEmbedContentsResponse>;

node_modules/@google/generative-ai/dist/server/src/methods/generate-content.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GenerateContentRequest, GenerateContentResult, GenerateContentStreamResult, SingleRequestOptions } from "../../types";
+export declare function generateContentStream(apiKey: string, model: string, params: GenerateContentRequest, requestOptions: SingleRequestOptions): Promise<GenerateContentStreamResult>;
+export declare function generateContent(apiKey: string, model: string, params: GenerateContentRequest, requestOptions?: SingleRequestOptions): Promise<GenerateContentResult>;

node_modules/@google/generative-ai/dist/server/src/models/generative-model.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BatchEmbedContentsRequest, BatchEmbedContentsResponse, CachedContent, Content, CountTokensRequest, CountTokensResponse, EmbedContentRequest, EmbedContentResponse, GenerateContentRequest, GenerateContentResult, GenerateContentStreamResult, GenerationConfig, ModelParams, Part, RequestOptions, SafetySetting, SingleRequestOptions, StartChatParams, Tool, ToolConfig } from "../../types";
+import { ChatSession } from "../methods/chat-session";
+/**
+ * Class for generative model APIs.
+ * @public
+ */
+export declare class GenerativeModel {
+    apiKey: string;
+    private _requestOptions;
+    model: string;
+    generationConfig: GenerationConfig;
+    safetySettings: SafetySetting[];
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: Content;
+    cachedContent: CachedContent;
+    constructor(apiKey: string, modelParams: ModelParams, _requestOptions?: RequestOptions);
+    /**
+     * Makes a single non-streaming call to the model
+     * and returns an object containing a single {@link GenerateContentResponse}.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    generateContent(request: GenerateContentRequest | string | Array<string | Part>, requestOptions?: SingleRequestOptions): Promise<GenerateContentResult>;
+    /**
+     * Makes a single streaming call to the model and returns an object
+     * containing an iterable stream that iterates over all chunks in the
+     * streaming response as well as a promise that returns the final
+     * aggregated response.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    generateContentStream(request: GenerateContentRequest | string | Array<string | Part>, requestOptions?: SingleRequestOptions): Promise<GenerateContentStreamResult>;
+    /**
+     * Gets a new {@link ChatSession} instance which can be used for
+     * multi-turn chats.
+     */
+    startChat(startChatParams?: StartChatParams): ChatSession;
+    /**
+     * Counts the tokens in the provided request.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    countTokens(request: CountTokensRequest | string | Array<string | Part>, requestOptions?: SingleRequestOptions): Promise<CountTokensResponse>;
+    /**
+     * Embeds the provided content.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    embedContent(request: EmbedContentRequest | string | Array<string | Part>, requestOptions?: SingleRequestOptions): Promise<EmbedContentResponse>;
+    /**
+     * Embeds an array of {@link EmbedContentRequest}s.
+     *
+     * Fields set in the optional {@link SingleRequestOptions} parameter will
+     * take precedence over the {@link RequestOptions} values provided to
+     * {@link GoogleGenerativeAI.getGenerativeModel }.
+     */
+    batchEmbedContents(batchEmbedContentRequest: BatchEmbedContentsRequest, requestOptions?: SingleRequestOptions): Promise<BatchEmbedContentsResponse>;
+}

node_modules/@google/generative-ai/dist/server/src/requests/request-helpers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Content, CountTokensRequest, EmbedContentRequest, GenerateContentRequest, ModelParams, Part, _CountTokensRequestInternal } from "../../types";
+export declare function formatSystemInstruction(input?: string | Part | Content): Content | undefined;
+export declare function formatNewContent(request: string | Array<string | Part>): Content;
+export declare function formatCountTokensInput(params: CountTokensRequest | string | Array<string | Part>, modelParams?: ModelParams): _CountTokensRequestInternal;
+export declare function formatGenerateContentInput(params: GenerateContentRequest | string | Array<string | Part>): GenerateContentRequest;
+export declare function formatEmbedContentInput(params: EmbedContentRequest | string | Array<string | Part>): EmbedContentRequest;

node_modules/@google/generative-ai/dist/server/src/requests/request.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RequestOptions, SingleRequestOptions } from "../../types";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
+export declare const DEFAULT_API_VERSION = "v1beta";
+export declare enum Task {
+    GENERATE_CONTENT = "generateContent",
+    STREAM_GENERATE_CONTENT = "streamGenerateContent",
+    COUNT_TOKENS = "countTokens",
+    EMBED_CONTENT = "embedContent",
+    BATCH_EMBED_CONTENTS = "batchEmbedContents"
+}
+export declare class RequestUrl {
+    model: string;
+    task: Task;
+    apiKey: string;
+    stream: boolean;
+    requestOptions: RequestOptions;
+    constructor(model: string, task: Task, apiKey: string, stream: boolean, requestOptions: RequestOptions);
+    toString(): string;
+}
+/**
+ * Simple, but may become more complex if we add more versions to log.
+ */
+export declare function getClientHeaders(requestOptions: RequestOptions): string;
+export declare function getHeaders(url: RequestUrl): Promise<Headers>;
+export declare function constructModelRequest(model: string, task: Task, apiKey: string, stream: boolean, body: string, requestOptions: SingleRequestOptions): Promise<{
+    url: string;
+    fetchOptions: RequestInit;
+}>;
+export declare function makeModelRequest(model: string, task: Task, apiKey: string, stream: boolean, body: string, requestOptions?: SingleRequestOptions, fetchFn?: typeof fetch): Promise<Response>;
+export declare function makeRequest(url: string, fetchOptions: RequestInit, fetchFn?: typeof fetch): Promise<Response>;

node_modules/@google/generative-ai/dist/server/src/requests/response-helpers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { EnhancedGenerateContentResponse, FunctionCall, GenerateContentResponse } from "../../types";
+/**
+ * Adds convenience helper methods to a response object, including stream
+ * chunks (as long as each chunk is a complete GenerateContentResponse JSON).
+ */
+export declare function addHelpers(response: GenerateContentResponse): EnhancedGenerateContentResponse;
+/**
+ * Returns all text found in all parts of first candidate.
+ */
+export declare function getText(response: GenerateContentResponse): string;
+/**
+ * Returns functionCall of first candidate.
+ */
+export declare function getFunctionCalls(response: GenerateContentResponse): FunctionCall[];
+export declare function formatBlockErrorMessage(response: GenerateContentResponse): string;

node_modules/@google/generative-ai/dist/server/src/requests/stream-reader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GenerateContentResponse, GenerateContentStreamResult } from "../../types";
+/**
+ * Process a response.body stream from the backend and return an
+ * iterator that provides one complete GenerateContentResponse at a time
+ * and a promise that resolves with a single aggregated
+ * GenerateContentResponse.
+ *
+ * @param response - Response from a fetch call
+ */
+export declare function processStream(response: Response): GenerateContentStreamResult;
+/**
+ * Reads a raw stream from the fetch response and join incomplete
+ * chunks, returning a new stream that provides a single complete
+ * GenerateContentResponse in each iteration.
+ */
+export declare function getResponseStream<T>(inputStream: ReadableStream<string>): ReadableStream<T>;
+/**
+ * Aggregates an array of `GenerateContentResponse`s into a single
+ * GenerateContentResponse.
+ */
+export declare function aggregateResponses(responses: GenerateContentResponse[]): GenerateContentResponse;

node_modules/@google/generative-ai/dist/server/src/server/cache-manager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CachedContent, RequestOptions } from "../../types";
+import { CachedContentCreateParams, CachedContentUpdateParams, ListCacheResponse, ListParams } from "../../types/server";
+/**
+ * Class for managing GoogleAI content caches.
+ * @public
+ */
+export declare class GoogleAICacheManager {
+    apiKey: string;
+    private _requestOptions?;
+    constructor(apiKey: string, _requestOptions?: RequestOptions);
+    /**
+     * Upload a new content cache
+     */
+    create(createOptions: CachedContentCreateParams): Promise<CachedContent>;
+    /**
+     * List all uploaded content caches
+     */
+    list(listParams?: ListParams): Promise<ListCacheResponse>;
+    /**
+     * Get a content cache
+     */
+    get(name: string): Promise<CachedContent>;
+    /**
+     * Update an existing content cache
+     */
+    update(name: string, updateParams: CachedContentUpdateParams): Promise<CachedContent>;
+    /**
+     * Delete content cache with given name
+     */
+    delete(name: string): Promise<void>;
+}

node_modules/@google/generative-ai/dist/server/src/server/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare enum RpcTask {
+    UPLOAD = "upload",
+    LIST = "list",
+    GET = "get",
+    DELETE = "delete",
+    UPDATE = "update",
+    CREATE = "create"
+}

node_modules/@google/generative-ai/dist/server/src/server/file-manager.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RequestOptions, SingleRequestOptions } from "../../types";
+import { FileMetadata, FileMetadataResponse, ListFilesResponse, ListParams, UploadFileResponse } from "../../types/server";
+export interface UploadMetadata {
+    name?: string;
+    ["display_name"]?: string;
+}
+/**
+ * Class for managing GoogleAI file uploads.
+ * @public
+ */
+export declare class GoogleAIFileManager {
+    apiKey: string;
+    private _requestOptions;
+    constructor(apiKey: string, _requestOptions?: RequestOptions);
+    /**
+     * Upload a file.
+     */
+    uploadFile(filePath: string, fileMetadata: FileMetadata): Promise<UploadFileResponse>;
+    /**
+     * List all uploaded files.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    listFiles(listParams?: ListParams, requestOptions?: SingleRequestOptions): Promise<ListFilesResponse>;
+    /**
+     * Get metadata for file with given ID.
+     *
+     * Any fields set in the optional {@link SingleRequestOptions} parameter will take
+     * precedence over the {@link RequestOptions} values provided at the time of the
+     * {@link GoogleAIFileManager} initialization.
+     */
+    getFile(fileId: string, requestOptions?: SingleRequestOptions): Promise<FileMetadataResponse>;
+    /**
+     * Delete file with given ID.
+     */
+    deleteFile(fileId: string): Promise<void>;
+}
+export declare function getUploadMetadata(inputMetadata: FileMetadata): FileMetadata;

node_modules/@google/generative-ai/dist/server/src/server/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { GoogleAIFileManager } from "./file-manager";
+export { GoogleAICacheManager } from "./cache-manager";
+export * from "../../types/server";

node_modules/@google/generative-ai/dist/server/src/server/request.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RequestOptions, SingleRequestOptions } from "../../types";
+import { RpcTask } from "./constants";
+export declare class ServerRequestUrl {
+    task: RpcTask;
+    apiKey: string;
+    requestOptions?: SingleRequestOptions;
+    protected _url: URL;
+    constructor(task: RpcTask, apiKey: string, requestOptions?: SingleRequestOptions);
+    appendPath(path: string): void;
+    appendParam(key: string, value: string): void;
+    toString(): string;
+}
+export declare class CachedContentUrl extends ServerRequestUrl {
+    task: RpcTask;
+    apiKey: string;
+    requestOptions?: RequestOptions;
+    constructor(task: RpcTask, apiKey: string, requestOptions?: RequestOptions);
+}
+export declare class FilesRequestUrl extends ServerRequestUrl {
+    task: RpcTask;
+    apiKey: string;
+    requestOptions?: RequestOptions;
+    constructor(task: RpcTask, apiKey: string, requestOptions?: RequestOptions);
+}
+export declare function getHeaders(url: ServerRequestUrl): Headers;
+export declare function makeServerRequest(url: FilesRequestUrl, headers: Headers, body?: Blob | string, fetchFn?: typeof fetch): Promise<Response>;

node_modules/@google/generative-ai/dist/server/types/content.d.ts

@@ -0,0 +1,230 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./function-calling";
+/**
+ * Content type for both prompts and response candidates.
+ * @public
+ */
+export interface Content {
+    role: string;
+    parts: Part[];
+}
+/**
+ * Content part - includes text or image part types.
+ * @public
+ */
+export type Part = TextPart | InlineDataPart | FunctionCallPart | FunctionResponsePart | FileDataPart | ExecutableCodePart | CodeExecutionResultPart;
+/**
+ * Content part interface if the part represents a text string.
+ * @public
+ */
+export interface TextPart {
+    text: string;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+/**
+ * Content part interface if the part represents an image.
+ * @public
+ */
+export interface InlineDataPart {
+    text?: never;
+    inlineData: GenerativeContentBlob;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+/**
+ * Content part interface if the part represents a FunctionCall.
+ * @public
+ */
+export interface FunctionCallPart {
+    text?: never;
+    inlineData?: never;
+    functionCall: FunctionCall;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+/**
+ * Content part interface if the part represents FunctionResponse.
+ * @public
+ */
+export interface FunctionResponsePart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse: FunctionResponse;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+/**
+ * Content part interface if the part represents FileData.
+ * @public
+ */
+export interface FileDataPart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData: FileData;
+    executableCode?: never;
+    codeExecutionResult?: never;
+}
+/**
+ * Content part containing executable code generated by the model.
+ * @public
+ */
+export interface ExecutableCodePart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode: ExecutableCode;
+    codeExecutionResult?: never;
+}
+/**
+ * Content part containing the result of executed code.
+ * @public
+ */
+export interface CodeExecutionResultPart {
+    text?: never;
+    inlineData?: never;
+    functionCall?: never;
+    functionResponse?: never;
+    fileData?: never;
+    executableCode?: never;
+    codeExecutionResult: CodeExecutionResult;
+}
+/**
+ * A predicted [FunctionCall] returned from the model
+ * that contains a string representing the [FunctionDeclaration.name]
+ * and a structured JSON object containing the parameters and their values.
+ * @public
+ */
+export interface FunctionCall {
+    name: string;
+    args: object;
+}
+/**
+ * The result output from a [FunctionCall] that contains a string
+ * representing the [FunctionDeclaration.name]
+ * and a structured JSON object containing any output
+ * from the function is used as context to the model.
+ * This should contain the result of a [FunctionCall]
+ * made based on model prediction.
+ * @public
+ */
+export interface FunctionResponse {
+    name: string;
+    response: object;
+}
+/**
+ * Interface for sending an image.
+ * @public
+ */
+export interface GenerativeContentBlob {
+    mimeType: string;
+    /**
+     * Image as a base64 string.
+     */
+    data: string;
+}
+/**
+ * Data pointing to a file uploaded with the Files API.
+ * @public
+ */
+export interface FileData {
+    mimeType: string;
+    fileUri: string;
+}
+/**
+ * Code generated by the model that is meant to be executed, where the result
+ * is returned to the model.
+ * Only generated when using the code execution tool, in which the code will
+ * be automatically executed, and a corresponding `CodeExecutionResult` will
+ * also be generated.
+ *
+ * @public
+ */
+export interface ExecutableCode {
+    /**
+     * Programming language of the `code`.
+     */
+    language: ExecutableCodeLanguage;
+    /**
+     * The code to be executed.
+     */
+    code: string;
+}
+/**
+ * @public
+ */
+export declare enum ExecutableCodeLanguage {
+    LANGUAGE_UNSPECIFIED = "language_unspecified",
+    PYTHON = "python"
+}
+/**
+ * Result of executing the `ExecutableCode`.
+ * Only generated when using code execution, and always follows a `Part`
+ * containing the `ExecutableCode`.
+ * @public
+ */
+export interface CodeExecutionResult {
+    /**
+     * Outcome of the code execution.
+     */
+    outcome: Outcome;
+    /**
+     * Contains stdout when code execution is successful, stderr or other
+     * description otherwise.
+     */
+    output: string;
+}
+/**
+ * Possible outcomes of code execution.
+ * @public
+ */
+export declare enum Outcome {
+    /**
+     * Unspecified status. This value should not be used.
+     */
+    OUTCOME_UNSPECIFIED = "outcome_unspecified",
+    /**
+     * Code execution completed successfully.
+     */
+    OUTCOME_OK = "outcome_ok",
+    /**
+     * Code execution finished but with a failure. `stderr` should contain the
+     * reason.
+     */
+    OUTCOME_FAILED = "outcome_failed",
+    /**
+     * Code execution ran for too long, and was cancelled. There may or may not
+     * be a partial output present.
+     */
+    OUTCOME_DEADLINE_EXCEEDED = "outcome_deadline_exceeded"
+}

node_modules/@google/generative-ai/dist/server/types/enums.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Possible roles.
+ * @public
+ */
+export declare const POSSIBLE_ROLES: readonly ["user", "model", "function", "system"];
+/**
+ * Harm categories that would cause prompts or candidates to be blocked.
+ * @public
+ */
+export declare enum HarmCategory {
+    HARM_CATEGORY_UNSPECIFIED = "HARM_CATEGORY_UNSPECIFIED",
+    HARM_CATEGORY_HATE_SPEECH = "HARM_CATEGORY_HATE_SPEECH",
+    HARM_CATEGORY_SEXUALLY_EXPLICIT = "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+    HARM_CATEGORY_HARASSMENT = "HARM_CATEGORY_HARASSMENT",
+    HARM_CATEGORY_DANGEROUS_CONTENT = "HARM_CATEGORY_DANGEROUS_CONTENT"
+}
+/**
+ * Threshold above which a prompt or candidate will be blocked.
+ * @public
+ */
+export declare enum HarmBlockThreshold {
+    HARM_BLOCK_THRESHOLD_UNSPECIFIED = "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+    BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
+    BLOCK_MEDIUM_AND_ABOVE = "BLOCK_MEDIUM_AND_ABOVE",
+    BLOCK_ONLY_HIGH = "BLOCK_ONLY_HIGH",
+    BLOCK_NONE = "BLOCK_NONE"
+}
+/**
+ * Probability that a prompt or candidate matches a harm category.
+ * @public
+ */
+export declare enum HarmProbability {
+    HARM_PROBABILITY_UNSPECIFIED = "HARM_PROBABILITY_UNSPECIFIED",
+    NEGLIGIBLE = "NEGLIGIBLE",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH"
+}
+/**
+ * Reason that a prompt was blocked.
+ * @public
+ */
+export declare enum BlockReason {
+    BLOCKED_REASON_UNSPECIFIED = "BLOCKED_REASON_UNSPECIFIED",
+    SAFETY = "SAFETY",
+    OTHER = "OTHER"
+}
+/**
+ * Reason that a candidate finished.
+ * @public
+ */
+export declare enum FinishReason {
+    FINISH_REASON_UNSPECIFIED = "FINISH_REASON_UNSPECIFIED",
+    STOP = "STOP",
+    MAX_TOKENS = "MAX_TOKENS",
+    SAFETY = "SAFETY",
+    RECITATION = "RECITATION",
+    LANGUAGE = "LANGUAGE",
+    OTHER = "OTHER"
+}
+/**
+ * Task type for embedding content.
+ * @public
+ */
+export declare enum TaskType {
+    TASK_TYPE_UNSPECIFIED = "TASK_TYPE_UNSPECIFIED",
+    RETRIEVAL_QUERY = "RETRIEVAL_QUERY",
+    RETRIEVAL_DOCUMENT = "RETRIEVAL_DOCUMENT",
+    SEMANTIC_SIMILARITY = "SEMANTIC_SIMILARITY",
+    CLASSIFICATION = "CLASSIFICATION",
+    CLUSTERING = "CLUSTERING"
+}
+/**
+ * @public
+ */
+export declare enum FunctionCallingMode {
+    MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
+    AUTO = "AUTO",
+    ANY = "ANY",
+    NONE = "NONE"
+}
+/**
+ * The mode of the predictor to be used in dynamic retrieval.
+ * @public
+ */
+export declare enum DynamicRetrievalMode {
+    MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
+    MODE_DYNAMIC = "MODE_DYNAMIC"
+}

node_modules/@google/generative-ai/dist/server/types/function-calling.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FunctionCallingMode } from "./enums";
+/**
+ * Structured representation of a function declaration as defined by the
+ * [OpenAPI 3.0 specification](https://spec.openapis.org/oas/v3.0.3). Included
+ * in this declaration are the function name and parameters. This
+ * FunctionDeclaration is a representation of a block of code that can be used
+ * as a Tool by the model and executed by the client.
+ * @public
+ */
+export declare interface FunctionDeclaration {
+    /**
+     * The name of the function to call. Must start with a letter or an
+     * underscore. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with
+     * a max length of 64.
+     */
+    name: string;
+    /**
+     * Optional. Description and purpose of the function. Model uses it to decide
+     * how and whether to call the function.
+     */
+    description?: string;
+    /**
+     * Optional. Describes the parameters to this function in JSON Schema Object
+     * format. Reflects the Open API 3.03 Parameter Object. string Key: the name
+     * of the parameter. Parameter names are case sensitive. Schema Value: the
+     * Schema defining the type used for the parameter. For function with no
+     * parameters, this can be left unset.
+     *
+     * @example with 1 required and 1 optional parameter: type: OBJECT properties:
+     * ```
+     * param1:
+     *
+     *   type: STRING
+     * param2:
+     *
+     *  type: INTEGER
+     * required:
+     *
+     *   - param1
+     * ```
+     */
+    parameters?: FunctionDeclarationSchema;
+}
+/**
+ * A FunctionDeclarationsTool is a piece of code that enables the system to
+ * interact with external systems to perform an action, or set of actions,
+ * outside of knowledge and scope of the model.
+ * @public
+ */
+export declare interface FunctionDeclarationsTool {
+    /**
+     * Optional. One or more function declarations
+     * to be passed to the model along with the current user query. Model may
+     * decide to call a subset of these functions by populating
+     * [FunctionCall][content.part.functionCall] in the response. User should
+     * provide a [FunctionResponse][content.part.functionResponse] for each
+     * function call in the next turn. Based on the function responses, Model will
+     * generate the final response back to the user. Maximum 64 function
+     * declarations can be provided.
+     */
+    functionDeclarations?: FunctionDeclaration[];
+}
+/**
+ * Contains the list of OpenAPI data types
+ * as defined by https://swagger.io/docs/specification/data-models/data-types/
+ * @public
+ */
+export declare enum SchemaType {
+    /** String type. */
+    STRING = "string",
+    /** Number type. */
+    NUMBER = "number",
+    /** Integer type. */
+    INTEGER = "integer",
+    /** Boolean type. */
+    BOOLEAN = "boolean",
+    /** Array type. */
+    ARRAY = "array",
+    /** Object type. */
+    OBJECT = "object"
+}
+/**
+ * Schema is used to define the format of input/output data.
+ * Represents a select subset of an OpenAPI 3.0 schema object.
+ * More fields may be added in the future as needed.
+ * @public
+ */
+export interface Schema {
+    /**
+     * Optional. The type of the property. {@link
+     * SchemaType}.
+     */
+    type?: SchemaType;
+    /** Optional. The format of the property. */
+    format?: string;
+    /** Optional. The description of the property. */
+    description?: string;
+    /** Optional. Whether the property is nullable. */
+    nullable?: boolean;
+    /** Optional. The items of the property. */
+    items?: Schema;
+    /** Optional. The enum of the property. */
+    enum?: string[];
+    /** Optional. Map of {@link Schema}. */
+    properties?: {
+        [k: string]: Schema;
+    };
+    /** Optional. Array of required property. */
+    required?: string[];
+    /** Optional. The example of the property. */
+    example?: unknown;
+}
+/**
+ * Schema for parameters passed to {@link FunctionDeclaration.parameters}.
+ * @public
+ */
+export interface FunctionDeclarationSchema {
+    /** The type of the parameter. */
+    type: SchemaType;
+    /** The format of the parameter. */
+    properties: {
+        [k: string]: FunctionDeclarationSchemaProperty;
+    };
+    /** Optional. Description of the parameter. */
+    description?: string;
+    /** Optional. Array of required parameters. */
+    required?: string[];
+}
+/**
+ * Schema for top-level function declaration
+ * @public
+ */
+export interface FunctionDeclarationSchemaProperty extends Schema {
+}
+/**
+ * Schema passed to `GenerationConfig.responseSchema`
+ * @public
+ */
+export interface ResponseSchema extends Schema {
+}
+/**
+ * Tool config. This config is shared for all tools provided in the request.
+ * @public
+ */
+export interface ToolConfig {
+    functionCallingConfig: FunctionCallingConfig;
+}
+/**
+ * @public
+ */
+export interface FunctionCallingConfig {
+    mode?: FunctionCallingMode;
+    allowedFunctionNames?: string[];
+}

node_modules/@google/generative-ai/dist/server/types/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./content";
+export * from "./enums";
+export * from "./requests";
+export * from "./responses";
+export * from "./search-grounding";
+export { CachedContent, CachedContentBase } from "./server/caching";

node_modules/@google/generative-ai/dist/server/types/requests.d.ts

@@ -0,0 +1,223 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CachedContent } from "./server/caching";
+import { Content, Part } from "./content";
+import { HarmBlockThreshold, HarmCategory, TaskType } from "./enums";
+import { FunctionDeclarationsTool, ResponseSchema, ToolConfig } from "./function-calling";
+import { GoogleSearchRetrievalTool } from "./search-grounding";
+/**
+ * Base parameters for a number of methods.
+ * @public
+ */
+export interface BaseParams {
+    safetySettings?: SafetySetting[];
+    generationConfig?: GenerationConfig;
+}
+/**
+ * Params passed to {@link GoogleGenerativeAI.getGenerativeModel}.
+ * @public
+ */
+export interface ModelParams extends BaseParams {
+    model: string;
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: string | Part | Content;
+    cachedContent?: CachedContent;
+}
+/**
+ * Request sent to `generateContent` endpoint.
+ * @public
+ */
+export interface GenerateContentRequest extends BaseParams {
+    contents: Content[];
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: string | Part | Content;
+    /**
+     * This is the name of a `CachedContent` and not the cache object itself.
+     */
+    cachedContent?: string;
+}
+/**
+ * Request sent to `generateContent` endpoint.
+ * @internal
+ */
+export interface _GenerateContentRequestInternal extends GenerateContentRequest {
+    model?: string;
+}
+/**
+ * Safety setting that can be sent as part of request parameters.
+ * @public
+ */
+export interface SafetySetting {
+    category: HarmCategory;
+    threshold: HarmBlockThreshold;
+}
+/**
+ * Config options for content-related requests
+ * @public
+ */
+export interface GenerationConfig {
+    candidateCount?: number;
+    stopSequences?: string[];
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    /**
+     * Output response mimetype of the generated candidate text.
+     * Supported mimetype:
+     *   `text/plain`: (default) Text output.
+     *   `application/json`: JSON response in the candidates.
+     */
+    responseMimeType?: string;
+    /**
+     * Output response schema of the generated candidate text.
+     * Note: This only applies when the specified `responseMIMEType` supports a schema; currently
+     * this is limited to `application/json`.
+     */
+    responseSchema?: ResponseSchema;
+    /**
+     * Presence penalty applied to the next token's logprobs if the token has
+     * already been seen in the response.
+     */
+    presencePenalty?: number;
+    /**
+     * Frequency penalty applied to the next token's logprobs, multiplied by the
+     * number of times each token has been seen in the respponse so far.
+     */
+    frequencyPenalty?: number;
+    /**
+     * If True, export the logprobs results in response.
+     */
+    responseLogprobs?: boolean;
+    /**
+     * Valid if responseLogProbs is set to True. This will set the number of top
+     * logprobs to return at each decoding step in the logprobsResult.
+     */
+    logprobs?: number;
+}
+/**
+ * Params for {@link GenerativeModel.startChat}.
+ * @public
+ */
+export interface StartChatParams extends BaseParams {
+    history?: Content[];
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: string | Part | Content;
+    /**
+     * This is the name of a `CachedContent` and not the cache object itself.
+     */
+    cachedContent?: string;
+}
+/**
+ * Params for calling {@link GenerativeModel.countTokens}.
+ *
+ * The request must contain either a {@link Content} array or a
+ * {@link GenerateContentRequest}, but not both. If both are provided
+ * then a {@link GoogleGenerativeAIRequestInputError} is thrown.
+ *
+ * @public
+ */
+export interface CountTokensRequest {
+    generateContentRequest?: GenerateContentRequest;
+    contents?: Content[];
+}
+/**
+ * Params for calling {@link GenerativeModel.countTokens}
+ * @internal
+ */
+export interface _CountTokensRequestInternal {
+    generateContentRequest?: _GenerateContentRequestInternal;
+    contents?: Content[];
+}
+/**
+ * Params for calling {@link GenerativeModel.embedContent}
+ * @public
+ */
+export interface EmbedContentRequest {
+    content: Content;
+    taskType?: TaskType;
+    title?: string;
+}
+/**
+ * Params for calling  {@link GenerativeModel.batchEmbedContents}
+ * @public
+ */
+export interface BatchEmbedContentsRequest {
+    requests: EmbedContentRequest[];
+}
+/**
+ * Params passed to getGenerativeModel() or GoogleAIFileManager().
+ * @public
+ */
+export interface RequestOptions {
+    /**
+     * Request timeout in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Version of API endpoint to call (e.g. "v1" or "v1beta"). If not specified,
+     * defaults to latest stable version.
+     */
+    apiVersion?: string;
+    /**
+     * Additional attribution information to include in the x-goog-api-client header.
+     * Used by wrapper SDKs.
+     */
+    apiClient?: string;
+    /**
+     * Base endpoint url. Defaults to "https://generativelanguage.googleapis.com"
+     */
+    baseUrl?: string;
+    /**
+     * Custom HTTP request headers.
+     */
+    customHeaders?: Headers | Record<string, string>;
+}
+/**
+ * Params passed to atomic asynchronous operations.
+ * @public
+ */
+export interface SingleRequestOptions extends RequestOptions {
+    /**
+     * An object that may be used to abort asynchronous requests. The request may
+     * also be aborted due to the expiration of the timeout value, if provided.
+     *
+     * NOTE: AbortSignal is a client-only operation. Using it to cancel an
+     * operation will not cancel the request in the service. You will still
+     * be charged usage for any applicable operations.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Defines a tool that model can call to access external knowledge.
+ * @public
+ */
+export declare type Tool = FunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool;
+/**
+ * Enables the model to execute code as part of generation.
+ * @public
+ */
+export interface CodeExecutionTool {
+    /**
+     * Provide an empty object to enable code execution. This field may have
+     * subfields added in the future.
+     */
+    codeExecution: {};
+}

node_modules/@google/generative-ai/dist/server/types/responses.d.ts

@@ -0,0 +1,216 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Content, FunctionCall } from "./content";
+import { BlockReason, FinishReason, HarmCategory, HarmProbability } from "./enums";
+import { GroundingMetadata } from "./search-grounding";
+/**
+ * Result object returned from generateContent() call.
+ *
+ * @public
+ */
+export interface GenerateContentResult {
+    response: EnhancedGenerateContentResponse;
+}
+/**
+ * Result object returned from generateContentStream() call.
+ * Iterate over `stream` to get chunks as they come in and/or
+ * use the `response` promise to get the aggregated response when
+ * the stream is done.
+ *
+ * @public
+ */
+export interface GenerateContentStreamResult {
+    stream: AsyncGenerator<EnhancedGenerateContentResponse>;
+    response: Promise<EnhancedGenerateContentResponse>;
+}
+/**
+ * Response object wrapped with helper methods.
+ *
+ * @public
+ */
+export interface EnhancedGenerateContentResponse extends GenerateContentResponse {
+    /**
+     * Returns the text string assembled from all `Part`s of the first candidate
+     * of the response, if available.
+     * Throws if the prompt or candidate was blocked.
+     */
+    text: () => string;
+    /**
+     * Deprecated: use `functionCalls()` instead.
+     * @deprecated - use `functionCalls()` instead
+     */
+    functionCall: () => FunctionCall | undefined;
+    /**
+     * Returns function calls found in any `Part`s of the first candidate
+     * of the response, if available.
+     * Throws if the prompt or candidate was blocked.
+     */
+    functionCalls: () => FunctionCall[] | undefined;
+}
+/**
+ * Individual response from {@link GenerativeModel.generateContent} and
+ * {@link GenerativeModel.generateContentStream}.
+ * `generateContentStream()` will return one in each chunk until
+ * the stream is done.
+ * @public
+ */
+export interface GenerateContentResponse {
+    /** Candidate responses from the model. */
+    candidates?: GenerateContentCandidate[];
+    /** The prompt's feedback related to the content filters. */
+    promptFeedback?: PromptFeedback;
+    /** Metadata on the generation request's token usage. */
+    usageMetadata?: UsageMetadata;
+}
+/**
+ * Logprobs Result
+ * @public
+ */
+export interface LogprobsResult {
+    /** Length = total number of decoding steps. */
+    topCandidates: TopCandidates[];
+    /**
+     * Length = total number of decoding steps.
+     * The chosen candidates may or may not be in topCandidates.
+     */
+    chosenCandidates: LogprobsCandidate[];
+}
+/**
+ * Candidate for the logprobs token and score.
+ * @public
+ */
+export interface LogprobsCandidate {
+    /** The candidate's token string value. */
+    token: string;
+    /** The candidate's token id value. */
+    tokenID: number;
+    /** The candidate's log probability. */
+    logProbability: number;
+}
+/**
+ * Candidates with top log probabilities at each decoding step
+ */
+export interface TopCandidates {
+    /** Sorted by log probability in descending order. */
+    candidates: LogprobsCandidate[];
+}
+/**
+ * Metadata on the generation request's token usage.
+ * @public
+ */
+export interface UsageMetadata {
+    /** Number of tokens in the prompt. */
+    promptTokenCount: number;
+    /** Total number of tokens across the generated candidates. */
+    candidatesTokenCount: number;
+    /** Total token count for the generation request (prompt + candidates). */
+    totalTokenCount: number;
+    /** Total token count in the cached part of the prompt, i.e. in the cached content. */
+    cachedContentTokenCount?: number;
+}
+/**
+ * If the prompt was blocked, this will be populated with `blockReason` and
+ * the relevant `safetyRatings`.
+ * @public
+ */
+export interface PromptFeedback {
+    blockReason: BlockReason;
+    safetyRatings: SafetyRating[];
+    blockReasonMessage?: string;
+}
+/**
+ * A candidate returned as part of a {@link GenerateContentResponse}.
+ * @public
+ */
+export interface GenerateContentCandidate {
+    index: number;
+    content: Content;
+    finishReason?: FinishReason;
+    finishMessage?: string;
+    safetyRatings?: SafetyRating[];
+    citationMetadata?: CitationMetadata;
+    /** Average log probability score of the candidate. */
+    avgLogprobs?: number;
+    /** Log-likelihood scores for the response tokens and top tokens. */
+    logprobsResult?: LogprobsResult;
+    /** Search grounding metadata. */
+    groundingMetadata?: GroundingMetadata;
+}
+/**
+ * Citation metadata that may be found on a {@link GenerateContentCandidate}.
+ * @public
+ */
+export interface CitationMetadata {
+    citationSources: CitationSource[];
+}
+/**
+ * A single citation source.
+ * @public
+ */
+export interface CitationSource {
+    startIndex?: number;
+    endIndex?: number;
+    uri?: string;
+    license?: string;
+}
+/**
+ * A safety rating associated with a {@link GenerateContentCandidate}
+ * @public
+ */
+export interface SafetyRating {
+    category: HarmCategory;
+    probability: HarmProbability;
+}
+/**
+ * Response from calling {@link GenerativeModel.countTokens}.
+ * @public
+ */
+export interface CountTokensResponse {
+    totalTokens: number;
+}
+/**
+ * Response from calling {@link GenerativeModel.embedContent}.
+ * @public
+ */
+export interface EmbedContentResponse {
+    embedding: ContentEmbedding;
+}
+/**
+ * Response from calling {@link GenerativeModel.batchEmbedContents}.
+ * @public
+ */
+export interface BatchEmbedContentsResponse {
+    embeddings: ContentEmbedding[];
+}
+/**
+ * A single content embedding.
+ * @public
+ */
+export interface ContentEmbedding {
+    values: number[];
+}
+/**
+ * Details object that may be included in an error response.
+ * @public
+ */
+export interface ErrorDetails {
+    "@type"?: string;
+    reason?: string;
+    domain?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}

node_modules/@google/generative-ai/dist/server/types/search-grounding.d.ts

@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DynamicRetrievalMode } from "./enums";
+/**
+ * Retrieval tool that is powered by Google search.
+ * @public
+ */
+export declare interface GoogleSearchRetrievalTool {
+    /**
+     * Google search retrieval tool config.
+     */
+    googleSearchRetrieval?: GoogleSearchRetrieval;
+}
+/**
+ * Retrieval tool that is powered by Google search.
+ * @public
+ */
+export declare interface GoogleSearchRetrieval {
+    /**
+     * Specifies the dynamic retrieval configuration for the given source.
+     */
+    dynamicRetrievalConfig?: DynamicRetrievalConfig;
+}
+/**
+ * Specifies the dynamic retrieval configuration for the given source.
+ * @public
+ */
+export declare interface DynamicRetrievalConfig {
+    /**
+     * The mode of the predictor to be used in dynamic retrieval.
+     */
+    mode?: DynamicRetrievalMode;
+    /**
+     * The threshold to be used in dynamic retrieval. If not set, a system default
+     * value is used.
+     */
+    dynamicThreshold?: number;
+}
+/**
+ * Metadata returned to client when grounding is enabled.
+ * @public
+ */
+export declare interface GroundingMetadata {
+    /**
+     * Google search entry for the following-up web searches.
+     */
+    searchEntryPoint?: SearchEntryPoint;
+    /**
+     * List of supporting references retrieved from specified grounding source.
+     */
+    groundingChuncks?: GroundingChunk[];
+    /**
+     * List of grounding support.
+     */
+    groundingSupport?: GroundingSupport[];
+    /**
+     * Metadata related to retrieval in the grounding flow.
+     */
+    retrievalMetadata?: RetrievalMetadata;
+    /**
+     * * Web search queries for the following-up web search.
+     */
+    webSearchQueries: string[];
+}
+/**
+ * Google search entry point.
+ * @public
+ */
+export declare interface SearchEntryPoint {
+    /**
+     * Web content snippet that can be embedded in a web page or an app webview.
+     */
+    renderedContent?: string;
+    /**
+     * Base64 encoded JSON representing array of <search term, search url> tuple.
+     */
+    sdkBlob?: string;
+}
+/**
+ * Grounding chunk.
+ * @public
+ */
+export declare interface GroundingChunk {
+    /**
+     *  Chunk from the web.
+     */
+    web?: GroundingChunkWeb;
+}
+/**
+ * Chunk from the web.
+ * @public
+ */
+export declare interface GroundingChunkWeb {
+    /**
+     * URI reference of the chunk.
+     */
+    uri?: string;
+    /**
+     * Title of the chunk.
+     */
+    title?: string;
+}
+/**
+ * Grounding support.
+ * @public
+ */
+export declare interface GroundingSupport {
+    /**
+     * URI reference of the chunk.
+     */
+    segment?: string;
+    /**
+     * A list of indices (into 'grounding_chunk') specifying the citations
+     * associated with the claim. For instance [1,3,4] means that
+     * grounding_chunk[1], grounding_chunk[3], grounding_chunk[4] are the
+     * retrieved content attributed to the claim.
+     */
+    groundingChunckIndices?: number[];
+    /**
+     * Confidence score of the support references. Ranges from 0 to 1. 1 is the
+     * most confident. This list must have the same size as the
+     * grounding_chunk_indices.
+     */
+    confidenceScores?: number[];
+}
+/**
+ * Segment of the content.
+ * @public
+ */
+export declare interface GroundingSupportSegment {
+    /**
+     * The index of a Part object within its parent Content object.
+     */
+    partIndex?: number;
+    /**
+     * Start index in the given Part, measured in bytes. Offset from the start of
+     * the Part, inclusive, starting at zero.
+     */
+    startIndex?: number;
+    /**
+     * End index in the given Part, measured in bytes. Offset from the start of
+     * the Part, exclusive, starting at zero.
+     */
+    endIndex?: number;
+    /**
+     * The text corresponding to the segment from the response.
+     */
+    text?: string;
+}
+/**
+ * Metadata related to retrieval in the grounding flow.
+ * @public
+ */
+export declare interface RetrievalMetadata {
+    /**
+     * Score indicating how likely information from google search could help
+     * answer the prompt. The score is in the range [0, 1], where 0 is the least
+     * likely and 1 is the most likely. This score is only populated when google
+     * search grounding and dynamic retrieval is enabled. It will becompared to
+     * the threshold to determine whether to trigger google search.
+     */
+    googleSearchDynamicRetrievalScore?: number;
+}

node_modules/@google/generative-ai/dist/server/types/server/caching.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Content, Part } from "../content";
+import { ToolConfig } from "../function-calling";
+import { Tool } from "../requests";
+/**
+ * @public
+ */
+export interface CachedContentBase {
+    model?: string;
+    contents: Content[];
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: string | Part | Content;
+    /**
+     * Expiration time in ISO string format. Specify either this or `ttlSeconds`
+     * when creating a `CachedContent`.
+     */
+    expireTime?: string;
+    displayName?: string;
+}
+/**
+ * Describes `CachedContent` interface for sending to the server (if creating)
+ * or received from the server (using getters or list methods).
+ * @public
+ */
+export interface CachedContent extends CachedContentBase {
+    name?: string;
+    /**
+     * protobuf.Duration format (ex. "3.0001s").
+     */
+    ttl?: string;
+    /**
+     * `CachedContent` creation time in ISO string format.
+     */
+    createTime?: string;
+    /**
+     * `CachedContent` update time in ISO string format.
+     */
+    updateTime?: string;
+}
+/**
+ * Params to pass to {@link GoogleAICacheManager.create}.
+ * @public
+ */
+export interface CachedContentCreateParams extends CachedContentBase {
+    /**
+     * `CachedContent` ttl in seconds. Specify either this or `expireTime`
+     * when creating a `CachedContent`.
+     */
+    ttlSeconds?: number;
+}
+/**
+ * Fields that can be updated in an existing content cache.
+ * @public
+ */
+export interface CachedContentUpdateInputFields {
+    ttlSeconds?: number;
+    expireTime?: string;
+}
+/**
+ * Params to pass to {@link GoogleAICacheManager.update}.
+ * @public
+ */
+export interface CachedContentUpdateParams {
+    cachedContent: CachedContentUpdateInputFields;
+    /**
+     * protobuf FieldMask. If not specified, updates all provided fields.
+     */
+    updateMask?: string[];
+}
+/**
+ * Fields that can be updated in an existing content cache.
+ * @internal
+ */
+export interface _CachedContentUpdateRequestFields {
+    ttl?: string;
+    expireTime?: string;
+}
+/**
+ * Params as sent to the backend (ttl instead of ttlSeconds).
+ * @internal
+ */
+export interface _CachedContentUpdateRequest {
+    cachedContent: _CachedContentUpdateRequestFields;
+    /**
+     * protobuf FieldMask
+     */
+    updateMask?: string[];
+}
+/**
+ * @public
+ */
+export interface ListCacheResponse {
+    cachedContents: CachedContent[];
+    nextPageToken?: string;
+}

node_modules/@google/generative-ai/dist/server/types/server/files.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RpcStatus } from "./shared";
+/**
+ * Metadata to provide alongside a file upload
+ * @public
+ */
+export interface FileMetadata {
+    name?: string;
+    displayName?: string;
+    mimeType: string;
+}
+/**
+ * File metadata response from server.
+ * @public
+ */
+export interface FileMetadataResponse {
+    name: string;
+    displayName?: string;
+    mimeType: string;
+    sizeBytes: string;
+    createTime: string;
+    updateTime: string;
+    expirationTime: string;
+    sha256Hash: string;
+    uri: string;
+    state: FileState;
+    /**
+     * Error populated if file processing has failed.
+     */
+    error?: RpcStatus;
+    /**
+     * Video metadata populated after processing is complete.
+     */
+    videoMetadata?: VideoMetadata;
+}
+/**
+ * Response from calling {@link GoogleAIFileManager.listFiles}
+ * @public
+ */
+export interface ListFilesResponse {
+    files: FileMetadataResponse[];
+    nextPageToken?: string;
+}
+/**
+ * Response from calling {@link GoogleAIFileManager.uploadFile}
+ * @public
+ */
+export interface UploadFileResponse {
+    file: FileMetadataResponse;
+}
+/**
+ * Processing state of the `File`.
+ * @public
+ */
+export declare enum FileState {
+    STATE_UNSPECIFIED = "STATE_UNSPECIFIED",
+    PROCESSING = "PROCESSING",
+    ACTIVE = "ACTIVE",
+    FAILED = "FAILED"
+}
+/**
+ * Metadata populated when video has been processed.
+ * @public
+ */
+export interface VideoMetadata {
+    /**
+     * The video duration in
+     * protobuf {@link https://cloud.google.com/ruby/docs/reference/google-cloud-workflows-v1/latest/Google-Protobuf-Duration#json-mapping | Duration} format.
+     */
+    videoDuration: string;
+}

node_modules/@google/generative-ai/dist/server/types/server/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./files";
+export * from "./caching";
+export * from "./shared";
+export { RequestOptions, Tool, CodeExecutionTool, SingleRequestOptions, } from "../requests";
+export * from "../content";
+export { FunctionCallingMode } from "../enums";

node_modules/@google/generative-ai/dist/server/types/server/shared.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ErrorDetails } from "../responses";
+export { ErrorDetails };
+/**
+ * Standard RPC error status object.
+ * @public
+ */
+export interface RpcStatus {
+    /**
+     * Error status code
+     */
+    code: number;
+    /**
+     * A developer-facing error message.
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.
+     */
+    details?: ErrorDetails[];
+}
+/**
+ * Params to pass to {@link GoogleAIFileManager.listFiles} or
+ * {@link GoogleAICacheManager.list}
+ * @public
+ */
+export interface ListParams {
+    pageSize?: number;
+    pageToken?: string;
+}