backendupdated

backend-old/index.js

@@ -0,0 +1,447 @@
+import { exec, spawn } from "child_process";
+import cors from "cors";
+import dotenv from "dotenv";
+import voice from "elevenlabs-node";
+import express from "express";
+import { promises as fs } from "fs";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as sdk from "microsoft-cognitiveservices-speech-sdk";
+import { synthesizeSpeechWithVisemes } from "./azureTtsService.js";
+dotenv.config();
+
+
+
+// Validate environment and API keys
+console.log(`Node environment: ${process.env.NODE_ENV}`);
+console.log(`Running on port: ${process.env.PORT || 3000}`);
+
+// Check for required API keys
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+const ELEVEN_LABS_API_KEY = process.env.ELEVEN_LABS_API_KEY;
+
+// Azure Speech Configuration - Using hardcoded values directly 
+const AZURE_SPEECH_KEY = "dd32a86f9b52496b9504bddadb2a5602"; // Hardcoded value
+const AZURE_SPEECH_REGION = "westeurope"; // Hardcoded value
+
+console.log(`Gemini API Key: ${GEMINI_API_KEY ? 'Present' : 'Missing'}`);
+console.log(`ElevenLabs API Key: ${ELEVEN_LABS_API_KEY ? 'Present' : 'Missing'}`);
+console.log(`Azure Speech Key: Present (Hardcoded)`);
+console.log(`Azure Speech Region: Present (Hardcoded)`);
+
+// Para obter o diretório atual do arquivo em ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Simple in-memory store for conversation history
+let conversationHistory = [];
+const MAX_HISTORY_LENGTH = 6; // Keep only the last 6 messages (3 exchanges) for faster processing
+
+// Function to prune conversation history to keep it under the limit
+function pruneConversationHistory(history) {
+  if (history.length <= MAX_HISTORY_LENGTH) return history;
+  return history.slice(history.length - MAX_HISTORY_LENGTH);
+}
+
+// System instructions for Gemini
+const systemInstructions = `Eres una amiga virtual que se llama Alice, un avatar virtual con cuerpo completo. IMPORTANTE: Responde en español de forma EXTREMADAMENTE BREVE (máximo 10-15 palabras). Usa frases simples y directas. ¡Sé siempre muy animada y expresiva en tus movimientos! NO utilices caracteres especiales, emoticones, emojis o cualquier formato que no sea texto simple. Mantén tus respuestas directas para que la conversación fluya naturalmente. Adicionalmente, sugiere una facialExpression y una animation ADECUADAS Y VARIADAS para tu respuesta, en formato JSON al final de tu respuesta principal.
+
+Lista de facialExpression disponibles: smile, sad, angry, surprised, funnyFace, default, wink, skeptical, thoughtful, excited, fearful, bored.
+Lista de animation disponibles: Talking_0, Talking_1, Talking_2, Crying, Laughing, Rumba, Idle, Terrified, Angry, Wave, Nod, ShakeHead, Shrug, Think, Celebrate, Sigh, Facepalm, Explain_Gesture.
+
+Ejemplo de formato: { "facialExpression": "smile", "animation": "Talking_1" }.
+
+Por favor, escucha el audio del usuario para responder.`;
+
+
+// Azure Viseme Mapping (from user's script)
+const azureVisemeToCharacterMap = {
+    0: "X", 1: "C", 2: "C", 3: "C", 4: "C", 5: "C", 6: "C", 7: "C", 8: "C",
+    9: "C", 10: "C", 11: "C", 12: "D", 13: "D", 14: "D", 15: "D", 16: "D",
+    17: "D", 18: "D", 19: "D", 20: "D", 21: "B"
+};
+
+const geminiAPIKey = process.env.GEMINI_API_KEY;
+if (!geminiAPIKey) {
+  console.warn("GEMINI_API_KEY not found in .env file. Voice chat with Gemini will not work.");
+}
+const genAI = new GoogleGenerativeAI(geminiAPIKey || "YOUR_GEMINI_API_KEY_FALLBACK"); // Added fallback to prevent crash if key is missing
+
+// Define the models to try in order of preference
+const geminiModels = [
+  "gemini-2.0-flash",           // Fastest: 0.6950 seconds
+  "gemini-2.0-flash-lite-001",  // Second: 0.8450 seconds
+  "gemini-1.5-flash"            // Third: 1.3020 seconds
+];
+
+// Optimized generation config for faster responses
+const optimizedGenerationConfig = {
+  maxOutputTokens: 100,     // Limit output size for faster generation
+  temperature: 0.4,         // Lower temperature = more deterministic and typically faster
+  topP: 0.8,                // Slightly lower than default for more focused outputs
+  topK: 20,                 // Limits token selection for faster inference
+  candidateCount: 1,        // Only generate one response
+  presencePenalty: 0.1,     // Slight penalty for repeated topics
+  stopSequences: ["."],     // Encourages shorter responses
+  responseMimeType: "text/plain"  // Optimize for plain text responses
+};
+
+// Initial model
+const geminiModel = genAI.getGenerativeModel({ 
+  model: geminiModels[0],
+  generationConfig: optimizedGenerationConfig
+});
+
+const elevenLabsApiKey = process.env.ELEVEN_LABS_API_KEY;
+const voiceID = "Xb7hH8MSUJpSbSDYk0k2"; // Adam voice - default voice that works with all accounts
+
+const app = express();
+app.use(express.json({ limit: "50mb" }));
+app.use(cors());
+const port = process.env.PORT || 3000;
+
+// Define API routes before static file serving
+app.get("/health", (req, res) => {
+  res.status(200).json({ status: "OK", message: "API is up and running" });
+});
+
+app.get("/voices", async (req, res) => {
+  res.send(await voice.getVoices(elevenLabsApiKey));
+});
+
+const readJsonTranscript = async (file) => {
+  const data = await fs.readFile(file, "utf8");
+  return JSON.parse(data);
+};
+
+const audioFileToBase64 = async (file) => {
+  const data = await fs.readFile(file);
+  return data.toString("base64");
+};
+
+app.post("/voice-chat", async (req, res) => {
+  if (!geminiAPIKey) {
+    return res.status(500).send({ error: "Gemini API key not configured." });
+  }
+
+  const { audio: audioFloatArray, sampleRate } = req.body;
+
+  if (!audioFloatArray || !sampleRate) {
+    return res.status(400).send({ error: "Missing audio data or sampleRate." });
+  }
+
+  try {
+    const pcmData = floatTo16BitPCM(audioFloatArray);
+    const wavBuffer = createWavBuffer(pcmData, sampleRate);
+    const audioBase64 = wavBuffer.toString("base64");
+
+    const partsForGemini = [];
+    // If history is empty, it's the first meaningful user interaction in this session.
+    // Prepend system instructions as part of the first user message to Gemini.
+    if (conversationHistory.length === 0) {
+      partsForGemini.push({ text: systemInstructions });
+    }
+    partsForGemini.push({ inlineData: { data: audioBase64, mimeType: "audio/wav" } });
+    
+    // Try to send the message with a retry mechanism for Gemini models
+    let result;
+    let retryCount = 0;
+    const maxRetries = 3;  // Try the entire model cycle up to 3 times
+    let modelIndex = 0;
+    let currentModel;
+    let success = false;
+    
+    while (retryCount < maxRetries && !success) {
+      // Reset model index if we've gone through all models
+      if (modelIndex >= geminiModels.length) {
+        modelIndex = 0;
+        retryCount++;
+        if (retryCount >= maxRetries) break;
+      }
+      
+      currentModel = geminiModels[modelIndex];
+      console.log(`Attempt ${retryCount+1}/${maxRetries}, trying model: ${currentModel}`);
+      
+      try {
+        // Get a new model instance with the current model
+        const modelInstance = genAI.getGenerativeModel({ 
+          model: currentModel,
+          generationConfig: optimizedGenerationConfig
+        });
+        const chat = modelInstance.startChat({
+          history: conversationHistory,
+        });
+        
+        result = await chat.sendMessage(partsForGemini);
+        success = true; // If we got here, it worked!
+        
+        // Update conversation history after the call
+        conversationHistory = await chat.getHistory();
+        // Prune history to keep only recent messages
+        conversationHistory = pruneConversationHistory(conversationHistory);
+        console.log(`Successfully used model: ${currentModel}`);
+        break;
+        
+      } catch (error) {
+        console.error(`Error with model ${currentModel}:`, error.message || error);
+        // Try the next model
+        modelIndex++;
+      }
+    }
+    
+    if (!success || !result) {
+      throw new Error(`Failed to get a response from any Gemini model after ${maxRetries} complete retry cycles`);
+    }
+    
+    const response = result.response;
+    const geminiTextRaw = response.text();
+    
+    console.log("Gemini Raw Response:", geminiTextRaw);
+    console.log("Updated Conversation History Length:", conversationHistory.length);
+
+    let geminiTextForTTS = geminiTextRaw; // Text that will be sent to TTS
+    let facialExpression = "default";
+    let animation = "Idle";
+
+    try {
+        // More robustly find and extract the JSON part, accounting for potential markdown code blocks
+        // Regex to find a JSON object, possibly wrapped in markdown ```json ... ``` or ``` ... ```
+        const jsonBlockRegex = /```(?:json)?\s*(\{[^\}]*\})\s*```|(\{[^\}]*\})/s;
+        const jsonMatch = geminiTextRaw.match(jsonBlockRegex);
+        
+        let jsonString = null;
+        let textPart = geminiTextRaw;
+
+        if (jsonMatch) {
+            // Prioritize the JSON found within a markdown block, otherwise take the standalone JSON
+            jsonString = jsonMatch[1] || jsonMatch[2]; 
+            if (jsonString) {
+                try {
+                    console.log("Found JSON string for suggestions:", jsonString);
+                    const suggestions = JSON.parse(jsonString);
+                    if (suggestions.facialExpression) facialExpression = suggestions.facialExpression;
+                    if (suggestions.animation) animation = suggestions.animation;
+
+                    // Remove the entire matched block (markdown + JSON or just JSON) from the original text
+                    textPart = geminiTextRaw.replace(jsonMatch[0], "").trim();
+                } catch (parseError) {
+                    console.warn("Could not parse JSON from Gemini response:", parseError);
+                    // If JSON parsing fails, assume the entire response is text
+                    textPart = geminiTextRaw.trim(); 
+                }
+            } else {
+                 // Should not happen if jsonMatch is true, but as a fallback
+                textPart = geminiTextRaw.trim();
+            }
+        } else {
+            // If no JSON-like structure is found, the whole response is considered text for TTS.
+            textPart = geminiTextRaw.trim();
+        }
+        geminiTextForTTS = textPart;
+
+    } catch (e) {
+        console.warn("Error processing facial expression/animation from Gemini response:", e);
+        // Keep geminiTextForTTS as the original raw text, trimmed, in case of unexpected errors.
+        geminiTextForTTS = geminiTextRaw.trim();
+    }
+    
+    if (!geminiTextForTTS || geminiTextForTTS.trim() === "") {
+        geminiTextForTTS = "No pude procesar el audio, ¿puedes repetirlo por favor?";
+        facialExpression = "sad";
+        animation = "Talking_0";
+    }
+
+    // 3. Prepare message for existing TTS/Lipsync pipeline
+    let messagesToProcess = [
+      {
+        text: geminiTextForTTS, // Use the cleaned text for TTS
+        facialExpression: facialExpression,
+        animation: animation,
+        // audio and lipsync will be added by the loop below
+      },
+    ];
+
+    // 4. Process the messages
+    for (let i = 0; i < messagesToProcess.length; i++) {
+      const message = messagesToProcess[i];
+      const textInput = message.text;
+      
+      if (!textInput || textInput.trim() === "") {
+          console.warn("Skipping TTS for empty message from Gemini at index " + i);
+          message.audio = ""; // Or a silent audio base64
+          message.lipsync = { metadata: { version: 1 }, mouthCues: [{ start: 0, end: 1, value: "X" }] }; // Empty lipsync
+          continue;
+      }
+
+      try {
+        // Use the Spanish language and Elena voice from Argentina
+        const language = "es-AR";
+        const voiceName = "es-AR-ElenaNeural";
+        
+        // Use the imported synthesizeSpeechWithVisemes function
+        const azureResult = await synthesizeSpeechWithVisemes(textInput, language, voiceName);
+        
+        // Convert the result to the expected format
+        message.audio = azureResult.audioData.toString('base64'); // Convert Buffer to base64
+        message.lipsync = { mouthCues: azureResult.mouthCues }; // Extract mouth cues
+
+      } catch (azureError) {
+        console.error("Error in Azure TTS/Viseme generation for message: " + textInput, azureError);
+        // Fallback if Azure TTS or lipsync fails
+        message.text = "Lo siento, tuve un problema al generar mi respuesta con Azure.";
+        message.audio = ""; 
+        message.lipsync = { metadata: { version: 1, generator: "fallback-azure-error" }, mouthCues: [{ start: 0, end: 1, value: "X" }] };
+        message.facialExpression = "sad";
+        message.animation = "Idle";
+      }
+    }
+    res.send({ messages: messagesToProcess });
+
+  } catch (error) {
+    console.error("Error in /voice-chat endpoint:", error);
+    // Generic error response
+    const fallbackMessage = {
+        text: "Ups, algo salió mal en el servidor.",
+        audio: "", // Consider having a pre-recorded base64 audio for errors
+        lipsync: { metadata: { version: 1 }, mouthCues: [{ start: 0, end: 0.5, value: "X" }] },
+        facialExpression: "sad",
+        animation: "Idle",
+    };
+    res.status(500).send({ messages: [fallbackMessage] });
+  }
+});
+
+// Helper function to convert float array to 16-bit PCM WAV buffer - optimized version
+function floatTo16BitPCM(floatArray) {
+  // Pre-allocate the array for better performance
+  const pcmArray = new Int16Array(floatArray.length);
+  
+  // Process the array in chunks for better performance
+  const CHUNK_SIZE = 1024;
+  for (let i = 0; i < floatArray.length; i += CHUNK_SIZE) {
+    const end = Math.min(i + CHUNK_SIZE, floatArray.length);
+    for (let j = i; j < end; j++) {
+      // Clamp values between -1 and 1, then scale to 16-bit range
+      // Use faster conditional approach instead of Math.max/min
+      const s = floatArray[j] < -1 ? -1 : (floatArray[j] > 1 ? 1 : floatArray[j]);
+      // Use bit shifting for faster integer conversion when appropriate
+      pcmArray[j] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+    }
+  }
+  
+  return pcmArray;
+}
+
+function createWavBuffer(pcmData, sampleRate) {
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const blockAlign = numChannels * (bitsPerSample / 8);
+  const byteRate = sampleRate * blockAlign;
+  const dataSize = pcmData.length * (bitsPerSample / 8);
+  const bufferSize = 44 + dataSize; // 44 bytes for WAV header
+  
+  // Pre-allocate a buffer of the exact needed size
+  const buffer = Buffer.alloc(bufferSize);
+  let offset = 0;
+
+  // Write header in fewer operations by using strings directly
+  buffer.write("RIFF", offset); offset += 4;
+  buffer.writeUInt32LE(36 + dataSize, offset); offset += 4;
+  buffer.write("WAVE", offset); offset += 4;
+  buffer.write("fmt ", offset); offset += 4;
+  
+  // Write format chunk in a single operation if possible
+  buffer.writeUInt32LE(16, offset); offset += 4; // Subchunk1Size (16 for PCM)
+  buffer.writeUInt16LE(1, offset); offset += 2; // AudioFormat (1 for PCM)
+  buffer.writeUInt16LE(numChannels, offset); offset += 2;
+  buffer.writeUInt32LE(sampleRate, offset); offset += 4;
+  buffer.writeUInt32LE(byteRate, offset); offset += 4;
+  buffer.writeUInt16LE(blockAlign, offset); offset += 2;
+  buffer.writeUInt16LE(bitsPerSample, offset); offset += 2;
+
+  // Write data subchunk
+  buffer.write("data", offset); offset += 4;
+  buffer.writeUInt32LE(dataSize, offset); offset += 4;
+
+  // Write PCM data in larger chunks for better performance
+  const CHUNK_SIZE = 1024;
+  for (let i = 0; i < pcmData.length; i += CHUNK_SIZE) {
+    const end = Math.min(i + CHUNK_SIZE, pcmData.length);
+    for (let j = i; j < end; j++) {
+      buffer.writeInt16LE(pcmData[j], offset);
+      offset += 2;
+    }
+  }
+
+  return buffer;
+}
+
+// Create directory for audio files if it doesn't exist
+try {
+  const audiosPath = path.join(__dirname, 'audios');
+  try {
+    await fs.access(audiosPath);
+  } catch {
+    await fs.mkdir(audiosPath, { recursive: true });
+    console.log('Created audios directory');
+  }
+} catch (err) {
+  console.error('Failed to create audios directory:', err);
+}
+
+// Create public directory if it doesn't exist
+try {
+  const publicPath = path.join(__dirname, 'public');
+  try {
+    await fs.access(publicPath);
+  } catch {
+    await fs.mkdir(publicPath, { recursive: true });
+    console.log('Created public directory');
+  }
+} catch (err) {
+  console.error('Failed to create public directory:', err);
+}
+
+// Serve static files from the public directory (frontend build)
+app.use(express.static(path.join(__dirname, 'public')));
+
+// Add more detailed logging for debugging deployment issues
+console.log(`Static files being served from: ${path.join(__dirname, 'public')}`);
+try {
+  const publicFiles = await fs.readdir(path.join(__dirname, 'public'));
+  console.log(`Public directory contents: ${publicFiles.join(', ')}`);
+  if (publicFiles.includes('index.html')) {
+    console.log('Found index.html in public directory');
+  } else {
+    console.warn('WARNING: index.html not found in public directory!');
+  }
+} catch (err) {
+  console.error(`Error reading public directory: ${err.message}`);
+}
+
+// Fallback to serve index.html for all routes (for SPA routing)
+app.get("*", (req, res) => {
+  console.log(`Serving index.html for path: ${req.path}`);
+  res.sendFile(path.join(__dirname, 'public', 'index.html'));
+});
+
+// Handle 404s for resources that don't exist
+app.use((req, res, next) => {
+  console.log(`404 for: ${req.path}`);
+  res.status(404).send('Resource not found');
+});
+
+// Start the server
+app.listen(port, '0.0.0.0', () => {
+  console.log(`=============================================================`);
+  console.log(`Virtual Girlfriend server is running at:`);
+  console.log(`- Local:   http://localhost:${port}`);
+  console.log(`- Network: http://0.0.0.0:${port}`);
+  console.log(`=============================================================`);
+  console.log(`- Environment: ${process.env.NODE_ENV || 'development'}`);
+  console.log(`- Node version: ${process.version}`);
+  console.log(`- Platform: ${process.platform} ${process.arch}`);
+  console.log(`- Working directory: ${__dirname}`);
+  console.log(`=============================================================`);
+});

backend-old/node_modules/.bin/mime

@@ -0,0 +1 @@
+../mime/cli.js

backend-old/node_modules/.bin/nodemon

@@ -0,0 +1 @@
+../nodemon/bin/nodemon.js

backend-old/node_modules/.bin/nodetouch

@@ -0,0 +1 @@
+../touch/bin/nodetouch.js

backend-old/node_modules/.bin/nopt

@@ -0,0 +1 @@
+../nopt/bin/nopt.js

backend-old/node_modules/.bin/openai

@@ -0,0 +1 @@
+../openai/bin/cli

backend-old/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

backend-old/node_modules/.package-lock.json

@@ -0,0 +1,1458 @@
+{
+  "name": "r3f-virtual-girlfriend-backend",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@google/generative-ai": {
+      "version": "0.24.1",
+      "resolved": "https://registry.npmjs.org/@google/generative-ai/-/generative-ai-0.24.1.tgz",
+      "integrity": "sha512-MqO+MLfM6kjxcKoy0p1wRzG3b4ZZXtPI+z2IE26UogS2Cm/XHO+7gGRBh6gcJsOiIVoH93UwKvW4HdgiOZCy9Q==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "18.19.10",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.10.tgz",
+      "integrity": "sha512-IZD8kAM02AW1HRDTPOlz3npFava678pr8Ie9Vp8uRhBROXAv8MXT2pCnGZZAKYdromsNQLHQcfWQ6EOatVLtqA==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/@types/node-fetch": {
+      "version": "2.6.11",
+      "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.11.tgz",
+      "integrity": "sha512-24xFj9R5+rfQJLRyM56qh+wnVSYhyXC2tkoBndtY0U+vubqNsYXGjufB2nn8Q6gt0LrARwL6UBtMCSVCwl4B1g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "form-data": "^4.0.0"
+      }
+    },
+    "node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/abort-controller": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+      "license": "MIT",
+      "dependencies": {
+        "event-target-shim": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6.5"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/agentkeepalive": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.5.0.tgz",
+      "integrity": "sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==",
+      "license": "MIT",
+      "dependencies": {
+        "humanize-ms": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.5.1.tgz",
+      "integrity": "sha512-Q28iYCWzNHjAm+yEAot5QaAMxhMghWLFVf7rRdwhUI+c2jix2DUXjAHXVi+s1ibs3mjPO/cCgbA++3BjD0vP/A==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.0",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/base-64": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/base-64/-/base-64-0.1.0.tgz",
+      "integrity": "sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA=="
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz",
+      "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.4",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.11.0",
+        "raw-body": "2.5.1",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/charenc": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz",
+      "integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz",
+      "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/crypt": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz",
+      "integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/digest-fetch": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/digest-fetch/-/digest-fetch-1.3.0.tgz",
+      "integrity": "sha512-CGJuv6iKNM7QyZlM2T3sPAdZWd/p9zQiRNS9G+9COUCwzWFTs0Xp8NF5iePx7wtvhDykReiRRrSeNb4oMmB8lA==",
+      "license": "ISC",
+      "dependencies": {
+        "base-64": "^0.1.0",
+        "md5": "^2.3.0"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.3.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz",
+      "integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/motdotla/dotenv?sponsor=1"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/elevenlabs-node": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/elevenlabs-node/-/elevenlabs-node-1.2.0.tgz",
+      "integrity": "sha512-T5ITXXG0lmLKzWjqz4zH3HtNRqAFkMt7mriWAw11fakS417LQkJPIPj4566znGK79E9xmZVVwzf2D0WBxkVzmw==",
+      "license": "MIT",
+      "dependencies": {
+        "axios": "^1.4.0",
+        "fs-extra": "^11.1.1"
+      }
+    },
+    "node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/event-target-shim": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.18.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
+      "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.1",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.5.0",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.2.0",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.1",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.7",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.11.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.18.0",
+        "serve-static": "1.15.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.3",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.3.tgz",
+      "integrity": "sha512-1VzOtuEM8pC9SFU1E+8KfTjZyMztRsgEfwQl44z8A25uy13jSzTj6dyK2Df52iV0vgHCfBwLhDWevLn95w5v6Q==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/form-data-encoder": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz",
+      "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==",
+      "license": "MIT"
+    },
+    "node_modules/formdata-node": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz",
+      "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==",
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "1.0.0",
+        "web-streams-polyfill": "4.0.0-beta.3"
+      },
+      "engines": {
+        "node": ">= 12.20"
+      }
+    },
+    "node_modules/formdata-node/node_modules/web-streams-polyfill": {
+      "version": "4.0.0-beta.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz",
+      "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs-extra": {
+      "version": "11.1.1",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
+      "integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "license": "MIT"
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz",
+      "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC"
+    },
+    "node_modules/has": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.4.tgz",
+      "integrity": "sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz",
+      "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/humanize-ms": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz",
+      "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.0.0"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-buffer": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
+      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+      "license": "MIT"
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/md5": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz",
+      "integrity": "sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "charenc": "0.0.2",
+        "crypt": "0.0.2",
+        "is-buffer": "~1.1.6"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
+      "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==",
+      "license": "MIT"
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "deprecated": "Use your platform's native DOMException instead",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.0.1.tgz",
+      "integrity": "sha512-g9AZ7HmkhQkqXkRc20w+ZfQ73cHLbE8hnPbtaFbFtCumZsjyMhKk9LajQ07U5Ux28lvFjZ5X7HvWR1xzU8jHVw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^3.2.7",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/debug": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.1"
+      }
+    },
+    "node_modules/nodemon/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nopt": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz",
+      "integrity": "sha512-NWmpvLSqUrgrAC9HCuxEvb+PSloHpqVu+FqcO4eeF2h5qYRhA7ev6KvelyQAKtegUbC6RypJnlEOhd8vloNKYg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "abbrev": "1"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.12.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
+      "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/openai": {
+      "version": "4.26.0",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-4.26.0.tgz",
+      "integrity": "sha512-HPC7tgYdeP38F3uHA5WgnoXZyGbAp9jgcIo23p6It+q/07u4C+NZ8xHKlMShsPbDDmFRpPsa3vdbXYpbhJH3eg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/node": "^18.11.18",
+        "@types/node-fetch": "^2.6.4",
+        "abort-controller": "^3.0.0",
+        "agentkeepalive": "^4.2.1",
+        "digest-fetch": "^1.3.0",
+        "form-data-encoder": "1.7.2",
+        "formdata-node": "^4.3.2",
+        "node-fetch": "^2.6.7",
+        "web-streams-polyfill": "^3.2.1"
+      },
+      "bin": {
+        "openai": "bin/cli"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
+      "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==",
+      "license": "MIT"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/qs": {
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
+      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.0.4"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz",
+      "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz",
+      "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "lru-cache": "^6.0.0"
+      },
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
+      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
+      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.18.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.0.tgz",
+      "integrity": "sha512-WBx8Uy5TLtOSRtIq+M03/sKDrXCLHxwDcquSP2c43Le03/9serjQBIztjRz6FkJez9D/hleyAXTBGLwwZUw9lA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "nopt": "~1.0.10"
+      },
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "license": "MIT"
+    },
+    "node_modules/universalify": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+      "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.2.tgz",
+      "integrity": "sha512-3pRGuxRF5gpuZc0W+EpwQRmCD7gRqcDOMt688KmdlDAgAyaB1XlN0zq2njfDNm44XVdIouE7pZ6GzbdyH47uIQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

backend-old/node_modules/@google/generative-ai/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

backend-old/node_modules/@google/generative-ai/README.md

@@ -0,0 +1,20 @@
+# [Deprecated] Google AI JavaScript SDK for the Gemini API
+
+With Gemini 2.0, we took the chance to create a single unified SDK for all developers who want to use Google's GenAI models (Gemini, Veo, Imagen, etc). As part of that process, we took all of the feedback from this SDK and what developers like about other SDKs in the ecosystem to create the [Google Gen AI SDK](https://github.com/googleapis/js-genai). 
+
+The full migration guide from the old SDK to new SDK is available in the [Gemini API docs](https://ai.google.dev/gemini-api/docs/migrate).
+
+The Gemini API docs are fully updated to show examples of the new Google Gen AI SDK. We know how disruptive an SDK change can be and don't take this change lightly, but our goal is to create an extremely simple and clear path for developers to build with our models so it felt necessary to make this change.
+
+Thank you for building with Gemini and [let us know](https://discuss.ai.google.dev/c/gemini-api/4) if you need any help!
+
+**Please be advised that this repository is now considered legacy.** For the latest features, performance improvements, and active development, we strongly recommend migrating to the official **[Google Generative AI SDK for JavaScript](https://github.com/googleapis/js-genai)**.
+
+**Support Plan for this Repository:**
+
+*   **Limited Maintenance:** Development is now restricted to **critical bug fixes only**. No new features will be added.
+*   **Purpose:** This limited support aims to provide stability for users while they transition to the new SDK.
+*   **End-of-Life Date:** All support for this repository (including bug fixes) will permanently end on **August 31st, 2025**.
+
+We encourage all users to begin planning their migration to the [Google Generative AI SDK](https://github.com/googleapis/js-genai) to ensure continued access to the latest capabilities and support.
+

backend-old/node_modules/@google/generative-ai/dist/generative-ai.d.ts

@@ -0,0 +1,1395 @@
+/**
+ * Describes an array, an ordered list of values.
+ *
+ * @public
+ */
+export declare interface ArraySchema extends BaseSchema {
+    type: typeof SchemaType.ARRAY;
+    /** A schema describing the entries in the array. */
+    items: Schema;
+    /** The minimum number of items in the array. */
+    minItems?: number;
+    /** The maximum number of items in the array. */
+    maxItems?: number;
+}
+
+/**
+ * Base parameters for a number of methods.
+ * @public
+ */
+export declare interface BaseParams {
+    safetySettings?: SafetySetting[];
+    generationConfig?: GenerationConfig;
+}
+
+/**
+ * Fields common to all Schema types.
+ *
+ * @internal
+ */
+export declare interface BaseSchema {
+    /** Optional. Description of the value. */
+    description?: string;
+    /** If true, the value can be null. */
+    nullable?: boolean;
+}
+
+/**
+ * Params for calling  {@link GenerativeModel.batchEmbedContents}
+ * @public
+ */
+export declare interface BatchEmbedContentsRequest {
+    requests: EmbedContentRequest[];
+}
+
+/**
+ * Response from calling {@link GenerativeModel.batchEmbedContents}.
+ * @public
+ */
+export declare interface BatchEmbedContentsResponse {
+    embeddings: ContentEmbedding[];
+}
+
+/**
+ * Reason that a prompt was blocked.
+ * @public
+ */
+export declare enum BlockReason {
+    BLOCKED_REASON_UNSPECIFIED = "BLOCKED_REASON_UNSPECIFIED",
+    SAFETY = "SAFETY",
+    OTHER = "OTHER"
+}
+
+/**
+ * Describes a boolean, either 'true' or 'false'.
+ *
+ * @public
+ */
+export declare interface BooleanSchema extends BaseSchema {
+    type: typeof SchemaType.BOOLEAN;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * Citation metadata that may be found on a {@link GenerateContentCandidate}.
+ * @public
+ */
+export declare interface CitationMetadata {
+    citationSources: CitationSource[];
+}
+
+/**
+ * A single citation source.
+ * @public
+ */
+export declare interface CitationSource {
+    startIndex?: number;
+    endIndex?: number;
+    uri?: string;
+    license?: 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[];
+}
+
+/**
+ * A single content embedding.
+ * @public
+ */
+export declare interface ContentEmbedding {
+    values: number[];
+}
+
+/**
+ * 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 declare interface CountTokensRequest {
+    generateContentRequest?: GenerateContentRequest;
+    contents?: Content[];
+}
+
+/**
+ * Params for calling {@link GenerativeModel.countTokens}
+ * @internal
+ */
+export declare interface _CountTokensRequestInternal {
+    generateContentRequest?: _GenerateContentRequestInternal;
+    contents?: Content[];
+}
+
+/**
+ * Response from calling {@link GenerativeModel.countTokens}.
+ * @public
+ */
+export declare interface CountTokensResponse {
+    totalTokens: number;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * The mode of the predictor to be used in dynamic retrieval.
+ * @public
+ */
+export declare enum DynamicRetrievalMode {
+    MODE_UNSPECIFIED = "MODE_UNSPECIFIED",
+    MODE_DYNAMIC = "MODE_DYNAMIC"
+}
+
+/**
+ * Params for calling {@link GenerativeModel.embedContent}
+ * @public
+ */
+export declare interface EmbedContentRequest {
+    content: Content;
+    taskType?: TaskType;
+    title?: string;
+}
+
+/**
+ * Response from calling {@link GenerativeModel.embedContent}.
+ * @public
+ */
+export declare interface EmbedContentResponse {
+    embedding: ContentEmbedding;
+}
+
+/**
+ * Response object wrapped with helper methods.
+ *
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Describes a string enum
+ *
+ * @public
+ */
+export declare interface EnumStringSchema extends BaseSchema {
+    type: typeof SchemaType.STRING;
+    format: "enum";
+    /** Possible values for this enum */
+    enum: string[];
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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",
+    BLOCKLIST = "BLOCKLIST",
+    PROHIBITED_CONTENT = "PROHIBITED_CONTENT",
+    SPII = "SPII",
+    MALFORMED_FUNCTION_CALL = "MALFORMED_FUNCTION_CALL",
+    OTHER = "OTHER"
+}
+
+/**
+ * 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 type FunctionDeclarationSchemaProperty = 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;
+}
+
+/**
+ * A candidate returned as part of a {@link GenerateContentResponse}.
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Request sent to `generateContent` endpoint.
+ * @public
+ */
+export declare 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 declare interface _GenerateContentRequestInternal extends GenerateContentRequest {
+    model?: string;
+}
+
+/**
+ * Individual response from {@link GenerativeModel.generateContent} and
+ * {@link GenerativeModel.generateContentStream}.
+ * `generateContentStream()` will return one in each chunk until
+ * the stream is done.
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Result object returned from generateContent() call.
+ *
+ * @public
+ */
+export declare 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 declare interface GenerateContentStreamResult {
+    stream: AsyncGenerator<EnhancedGenerateContentResponse>;
+    response: Promise<EnhancedGenerateContentResponse>;
+}
+
+/**
+ * Config options for content-related requests
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Interface for sending an image.
+ * @public
+ */
+export declare interface GenerativeContentBlob {
+    mimeType: string;
+    /**
+     * Image as a base64 string.
+     */
+    data: string;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Error thrown when a request is aborted, either due to a timeout or
+ * intentional cancellation by the user.
+ * @public
+ */
+export declare class GoogleGenerativeAIAbortError extends GoogleGenerativeAIError {
+}
+
+/**
+ * Basic error type for this SDK.
+ * @public
+ */
+export declare class GoogleGenerativeAIError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * 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 {
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Retrieval tool that is powered by Google search.
+ * @public
+ */
+export declare interface GoogleSearchRetrieval {
+    /**
+     * Specifies the dynamic retrieval configuration for the given source.
+     */
+    dynamicRetrievalConfig?: DynamicRetrievalConfig;
+}
+
+/**
+ * Retrieval tool that is powered by Google search.
+ * @public
+ */
+export declare interface GoogleSearchRetrievalTool {
+    /**
+     * Google search retrieval tool config.
+     */
+    googleSearchRetrieval?: GoogleSearchRetrieval;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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.
+     */
+    groundingChunks?: GroundingChunk[];
+    /**
+     * List of grounding support.
+     */
+    groundingSupports?: GroundingSupport[];
+    /**
+     * Metadata related to retrieval in the grounding flow.
+     */
+    retrievalMetadata?: RetrievalMetadata;
+    /**
+     * * Web search queries for the following-up web search.
+     */
+    webSearchQueries: 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;
+}
+
+/**
+ * Threshold above which a prompt or candidate will be blocked.
+ * @public
+ */
+export declare enum HarmBlockThreshold {
+    /** Threshold is unspecified. */
+    HARM_BLOCK_THRESHOLD_UNSPECIFIED = "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+    /** Content with NEGLIGIBLE will be allowed. */
+    BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
+    /** Content with NEGLIGIBLE and LOW will be allowed. */
+    BLOCK_MEDIUM_AND_ABOVE = "BLOCK_MEDIUM_AND_ABOVE",
+    /** Content with NEGLIGIBLE, LOW, and MEDIUM will be allowed. */
+    BLOCK_ONLY_HIGH = "BLOCK_ONLY_HIGH",
+    /** All content will be allowed. */
+    BLOCK_NONE = "BLOCK_NONE"
+}
+
+/**
+ * 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",
+    HARM_CATEGORY_CIVIC_INTEGRITY = "HARM_CATEGORY_CIVIC_INTEGRITY"
+}
+
+/**
+ * Probability that a prompt or candidate matches a harm category.
+ * @public
+ */
+export declare enum HarmProbability {
+    /** Probability is unspecified. */
+    HARM_PROBABILITY_UNSPECIFIED = "HARM_PROBABILITY_UNSPECIFIED",
+    /** Content has a negligible chance of being unsafe. */
+    NEGLIGIBLE = "NEGLIGIBLE",
+    /** Content has a low chance of being unsafe. */
+    LOW = "LOW",
+    /** Content has a medium chance of being unsafe. */
+    MEDIUM = "MEDIUM",
+    /** Content has a high chance of being unsafe. */
+    HIGH = "HIGH"
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Describes a JSON-encodable integer.
+ *
+ * @public
+ */
+export declare interface IntegerSchema extends BaseSchema {
+    type: typeof SchemaType.INTEGER;
+    /** Optional. The format of the number. */
+    format?: "int32" | "int64";
+}
+
+/**
+ * Candidate for the logprobs token and score.
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Logprobs Result
+ * @public
+ */
+export declare 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[];
+}
+
+/**
+ * Params passed to {@link GoogleGenerativeAI.getGenerativeModel}.
+ * @public
+ */
+export declare interface ModelParams extends BaseParams {
+    model: string;
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: string | Part | Content;
+    cachedContent?: CachedContent;
+}
+
+/**
+ * Describes a JSON-encodable floating point number.
+ *
+ * @public
+ */
+export declare interface NumberSchema extends BaseSchema {
+    type: typeof SchemaType.NUMBER;
+    /** Optional. The format of the number. */
+    format?: "float" | "double";
+}
+
+/**
+ * Describes a JSON object, a mapping of specific keys to values.
+ *
+ * @public
+ */
+export declare interface ObjectSchema extends BaseSchema {
+    type: typeof SchemaType.OBJECT;
+    /** Describes the properties of the JSON object. Must not be empty. */
+    properties: {
+        [k: string]: Schema;
+    };
+    /**
+     * A list of keys declared in the properties object.
+     * Required properties will always be present in the generated object.
+     */
+    required?: 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;
+
+/**
+ * Possible roles.
+ * @public
+ */
+export declare const POSSIBLE_ROLES: readonly ["user", "model", "function", "system"];
+
+/**
+ * If the prompt was blocked, this will be populated with `blockReason` and
+ * the relevant `safetyRatings`.
+ * @public
+ */
+export declare interface PromptFeedback {
+    blockReason: BlockReason;
+    safetyRatings: SafetyRating[];
+    blockReasonMessage?: string;
+}
+
+/**
+ * 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 type ResponseSchema = Schema;
+
+/**
+ * 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;
+}
+
+/**
+ * A safety rating associated with a {@link GenerateContentCandidate}
+ * @public
+ */
+export declare interface SafetyRating {
+    category: HarmCategory;
+    probability: HarmProbability;
+}
+
+/**
+ * Safety setting that can be sent as part of request parameters.
+ * @public
+ */
+export declare interface SafetySetting {
+    category: HarmCategory;
+    threshold: HarmBlockThreshold;
+}
+
+/**
+ * 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 type Schema = StringSchema | NumberSchema | IntegerSchema | BooleanSchema | ArraySchema | ObjectSchema;
+
+/**
+ * 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"
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Describes a simple string schema, with or without format
+ *
+ * @public
+ */
+export declare interface SimpleStringSchema extends BaseSchema {
+    type: typeof SchemaType.STRING;
+    format?: "date-time" | undefined;
+    enum?: never;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Params for {@link GenerativeModel.startChat}.
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Describes a string.
+ *
+ * @public
+ */
+export declare type StringSchema = SimpleStringSchema | EnumStringSchema;
+
+/**
+ * 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"
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Candidates with top log probabilities at each decoding step
+ */
+export declare interface TopCandidates {
+    /** Sorted by log probability in descending order. */
+    candidates: LogprobsCandidate[];
+}
+
+/**
+ * Metadata on the generation request's token usage.
+ * @public
+ */
+export declare 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;
+}
+
+export { }

backend-old/node_modules/@google/generative-ai/dist/index.js

@@ -0,0 +1,1530 @@
+'use strict';
+
+/**
+ * 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
+ */
+const POSSIBLE_ROLES = ["user", "model", "function", "system"];
+/**
+ * Harm categories that would cause prompts or candidates to be blocked.
+ * @public
+ */
+exports.HarmCategory = void 0;
+(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["HARM_CATEGORY_CIVIC_INTEGRITY"] = "HARM_CATEGORY_CIVIC_INTEGRITY";
+})(exports.HarmCategory || (exports.HarmCategory = {}));
+/**
+ * Threshold above which a prompt or candidate will be blocked.
+ * @public
+ */
+exports.HarmBlockThreshold = void 0;
+(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";
+})(exports.HarmBlockThreshold || (exports.HarmBlockThreshold = {}));
+/**
+ * Probability that a prompt or candidate matches a harm category.
+ * @public
+ */
+exports.HarmProbability = void 0;
+(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";
+})(exports.HarmProbability || (exports.HarmProbability = {}));
+/**
+ * Reason that a prompt was blocked.
+ * @public
+ */
+exports.BlockReason = void 0;
+(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";
+})(exports.BlockReason || (exports.BlockReason = {}));
+/**
+ * Reason that a candidate finished.
+ * @public
+ */
+exports.FinishReason = void 0;
+(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";
+    // Token generation stopped because the content contains forbidden terms.
+    FinishReason["BLOCKLIST"] = "BLOCKLIST";
+    // Token generation stopped for potentially containing prohibited content.
+    FinishReason["PROHIBITED_CONTENT"] = "PROHIBITED_CONTENT";
+    // Token generation stopped because the content potentially contains Sensitive Personally Identifiable Information (SPII).
+    FinishReason["SPII"] = "SPII";
+    // The function call generated by the model is invalid.
+    FinishReason["MALFORMED_FUNCTION_CALL"] = "MALFORMED_FUNCTION_CALL";
+    // Unknown reason.
+    FinishReason["OTHER"] = "OTHER";
+})(exports.FinishReason || (exports.FinishReason = {}));
+/**
+ * Task type for embedding content.
+ * @public
+ */
+exports.TaskType = void 0;
+(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";
+})(exports.TaskType || (exports.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
+ */
+exports.DynamicRetrievalMode = void 0;
+(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";
+})(exports.DynamicRetrievalMode || (exports.DynamicRetrievalMode = {}));
+
+/**
+ * @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}`);
+    }
+}
+/**
+ * Errors in the contents of a response from the model. This includes parsing
+ * errors, or responses including a safety block reason.
+ * @public
+ */
+class GoogleGenerativeAIResponseError extends GoogleGenerativeAIError {
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
+/**
+ * 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 {
+}
+/**
+ * Error thrown when a request is aborted, either due to a timeout or
+ * intentional cancellation by the user.
+ * @public
+ */
+class GoogleGenerativeAIAbortError 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.24.1";
+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 = {}));
+class RequestUrl {
+    constructor(model, task, apiKey, stream, requestOptions) {
+        this.model = model;
+        this.task = task;
+        this.apiKey = apiKey;
+        this.stream = stream;
+        this.requestOptions = requestOptions;
+    }
+    toString() {
+        var _a, _b;
+        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 url = `${baseUrl}/${apiVersion}/${this.model}:${this.task}`;
+        if (this.stream) {
+            url += "?alt=sse";
+        }
+        return url;
+    }
+}
+/**
+ * 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 getHeaders(url) {
+    var _a;
+    const headers = new Headers();
+    headers.append("Content-Type", "application/json");
+    headers.append("x-goog-api-client", getClientHeaders(url.requestOptions));
+    headers.append("x-goog-api-key", url.apiKey);
+    let customHeaders = (_a = url.requestOptions) === null || _a === void 0 ? void 0 : _a.customHeaders;
+    if (customHeaders) {
+        if (!(customHeaders instanceof Headers)) {
+            try {
+                customHeaders = new Headers(customHeaders);
+            }
+            catch (e) {
+                throw new GoogleGenerativeAIRequestInputError(`unable to convert customHeaders value ${JSON.stringify(customHeaders)} to Headers: ${e.message}`);
+            }
+        }
+        for (const [headerName, headerValue] of customHeaders.entries()) {
+            if (headerName === "x-goog-api-key") {
+                throw new GoogleGenerativeAIRequestInputError(`Cannot set reserved header name ${headerName}`);
+            }
+            else if (headerName === "x-goog-api-client") {
+                throw new GoogleGenerativeAIRequestInputError(`Header name ${headerName} can only be set using the apiClient field`);
+            }
+            headers.append(headerName, headerValue);
+        }
+    }
+    return headers;
+}
+async function constructModelRequest(model, task, apiKey, stream, body, requestOptions) {
+    const url = new RequestUrl(model, task, apiKey, stream, requestOptions);
+    return {
+        url: url.toString(),
+        fetchOptions: Object.assign(Object.assign({}, buildFetchOptions(requestOptions)), { method: "POST", headers: await getHeaders(url), body }),
+    };
+}
+async function makeModelRequest(model, task, apiKey, stream, body, requestOptions = {}, 
+// Allows this to be stubbed for tests
+fetchFn = fetch) {
+    const { url, fetchOptions } = await constructModelRequest(model, task, apiKey, stream, body, requestOptions);
+    return makeRequest(url, fetchOptions, fetchFn);
+}
+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 (err.name === "AbortError") {
+        err = new GoogleGenerativeAIAbortError(`Request aborted when fetching ${url.toString()}: ${e.message}`);
+        err.stack = e.stack;
+    }
+    else 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);
+}
+/**
+ * Generates the request options to be passed to the fetch API.
+ * @param requestOptions - The user-defined request options.
+ * @returns The generated request options.
+ */
+function buildFetchOptions(requestOptions) {
+    const fetchOptions = {};
+    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 === null || requestOptions === void 0 ? void 0 : requestOptions.signal) {
+            requestOptions.signal.addEventListener("abort", () => {
+                controller.abort();
+            });
+        }
+        fetchOptions.signal = controller.signal;
+    }
+    return fetchOptions;
+}
+
+/**
+ * @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.
+ */
+/**
+ * Adds convenience helper methods to a response object, including stream
+ * chunks (as long as each chunk is a complete GenerateContentResponse JSON).
+ */
+function addHelpers(response) {
+    response.text = () => {
+        if (response.candidates && response.candidates.length > 0) {
+            if (response.candidates.length > 1) {
+                console.warn(`This response had ${response.candidates.length} ` +
+                    `candidates. Returning text from the first candidate only. ` +
+                    `Access response.candidates directly to use the other candidates.`);
+            }
+            if (hadBadFinishReason(response.candidates[0])) {
+                throw new GoogleGenerativeAIResponseError(`${formatBlockErrorMessage(response)}`, response);
+            }
+            return getText(response);
+        }
+        else if (response.promptFeedback) {
+            throw new GoogleGenerativeAIResponseError(`Text not available. ${formatBlockErrorMessage(response)}`, response);
+        }
+        return "";
+    };
+    /**
+     * TODO: remove at next major version
+     */
+    response.functionCall = () => {
+        if (response.candidates && response.candidates.length > 0) {
+            if (response.candidates.length > 1) {
+                console.warn(`This response had ${response.candidates.length} ` +
+                    `candidates. Returning function calls from the first candidate only. ` +
+                    `Access response.candidates directly to use the other candidates.`);
+            }
+            if (hadBadFinishReason(response.candidates[0])) {
+                throw new GoogleGenerativeAIResponseError(`${formatBlockErrorMessage(response)}`, response);
+            }
+            console.warn(`response.functionCall() is deprecated. ` +
+                `Use response.functionCalls() instead.`);
+            return getFunctionCalls(response)[0];
+        }
+        else if (response.promptFeedback) {
+            throw new GoogleGenerativeAIResponseError(`Function call not available. ${formatBlockErrorMessage(response)}`, response);
+        }
+        return undefined;
+    };
+    response.functionCalls = () => {
+        if (response.candidates && response.candidates.length > 0) {
+            if (response.candidates.length > 1) {
+                console.warn(`This response had ${response.candidates.length} ` +
+                    `candidates. Returning function calls from the first candidate only. ` +
+                    `Access response.candidates directly to use the other candidates.`);
+            }
+            if (hadBadFinishReason(response.candidates[0])) {
+                throw new GoogleGenerativeAIResponseError(`${formatBlockErrorMessage(response)}`, response);
+            }
+            return getFunctionCalls(response);
+        }
+        else if (response.promptFeedback) {
+            throw new GoogleGenerativeAIResponseError(`Function call not available. ${formatBlockErrorMessage(response)}`, response);
+        }
+        return undefined;
+    };
+    return response;
+}
+/**
+ * Returns all text found in all parts of first candidate.
+ */
+function getText(response) {
+    var _a, _b, _c, _d;
+    const textStrings = [];
+    if ((_b = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0].content) === null || _b === void 0 ? void 0 : _b.parts) {
+        for (const part of (_d = (_c = response.candidates) === null || _c === void 0 ? void 0 : _c[0].content) === null || _d === void 0 ? void 0 : _d.parts) {
+            if (part.text) {
+                textStrings.push(part.text);
+            }
+            if (part.executableCode) {
+                textStrings.push("\n```" +
+                    part.executableCode.language +
+                    "\n" +
+                    part.executableCode.code +
+                    "\n```\n");
+            }
+            if (part.codeExecutionResult) {
+                textStrings.push("\n```\n" + part.codeExecutionResult.output + "\n```\n");
+            }
+        }
+    }
+    if (textStrings.length > 0) {
+        return textStrings.join("");
+    }
+    else {
+        return "";
+    }
+}
+/**
+ * Returns functionCall of first candidate.
+ */
+function getFunctionCalls(response) {
+    var _a, _b, _c, _d;
+    const functionCalls = [];
+    if ((_b = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0].content) === null || _b === void 0 ? void 0 : _b.parts) {
+        for (const part of (_d = (_c = response.candidates) === null || _c === void 0 ? void 0 : _c[0].content) === null || _d === void 0 ? void 0 : _d.parts) {
+            if (part.functionCall) {
+                functionCalls.push(part.functionCall);
+            }
+        }
+    }
+    if (functionCalls.length > 0) {
+        return functionCalls;
+    }
+    else {
+        return undefined;
+    }
+}
+const badFinishReasons = [
+    exports.FinishReason.RECITATION,
+    exports.FinishReason.SAFETY,
+    exports.FinishReason.LANGUAGE,
+];
+function hadBadFinishReason(candidate) {
+    return (!!candidate.finishReason &&
+        badFinishReasons.includes(candidate.finishReason));
+}
+function formatBlockErrorMessage(response) {
+    var _a, _b, _c;
+    let message = "";
+    if ((!response.candidates || response.candidates.length === 0) &&
+        response.promptFeedback) {
+        message += "Response was blocked";
+        if ((_a = response.promptFeedback) === null || _a === void 0 ? void 0 : _a.blockReason) {
+            message += ` due to ${response.promptFeedback.blockReason}`;
+        }
+        if ((_b = response.promptFeedback) === null || _b === void 0 ? void 0 : _b.blockReasonMessage) {
+            message += `: ${response.promptFeedback.blockReasonMessage}`;
+        }
+    }
+    else if ((_c = response.candidates) === null || _c === void 0 ? void 0 : _c[0]) {
+        const firstCandidate = response.candidates[0];
+        if (hadBadFinishReason(firstCandidate)) {
+            message += `Candidate was blocked due to ${firstCandidate.finishReason}`;
+            if (firstCandidate.finishMessage) {
+                message += `: ${firstCandidate.finishMessage}`;
+            }
+        }
+    }
+    return message;
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * @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 responseLineRE = /^data\: (.*)(?:\n\n|\r\r|\r\n\r\n)/;
+/**
+ * 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
+ */
+function processStream(response) {
+    const inputStream = response.body.pipeThrough(new TextDecoderStream("utf8", { fatal: true }));
+    const responseStream = getResponseStream(inputStream);
+    const [stream1, stream2] = responseStream.tee();
+    return {
+        stream: generateResponseSequence(stream1),
+        response: getResponsePromise(stream2),
+    };
+}
+async function getResponsePromise(stream) {
+    const allResponses = [];
+    const reader = stream.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            return addHelpers(aggregateResponses(allResponses));
+        }
+        allResponses.push(value);
+    }
+}
+function generateResponseSequence(stream) {
+    return __asyncGenerator(this, arguments, function* generateResponseSequence_1() {
+        const reader = stream.getReader();
+        while (true) {
+            const { value, done } = yield __await(reader.read());
+            if (done) {
+                break;
+            }
+            yield yield __await(addHelpers(value));
+        }
+    });
+}
+/**
+ * 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.
+ */
+function getResponseStream(inputStream) {
+    const reader = inputStream.getReader();
+    const stream = new ReadableStream({
+        start(controller) {
+            let currentText = "";
+            return pump();
+            function pump() {
+                return reader
+                    .read()
+                    .then(({ value, done }) => {
+                    if (done) {
+                        if (currentText.trim()) {
+                            controller.error(new GoogleGenerativeAIError("Failed to parse stream"));
+                            return;
+                        }
+                        controller.close();
+                        return;
+                    }
+                    currentText += value;
+                    let match = currentText.match(responseLineRE);
+                    let parsedResponse;
+                    while (match) {
+                        try {
+                            parsedResponse = JSON.parse(match[1]);
+                        }
+                        catch (e) {
+                            controller.error(new GoogleGenerativeAIError(`Error parsing JSON response: "${match[1]}"`));
+                            return;
+                        }
+                        controller.enqueue(parsedResponse);
+                        currentText = currentText.substring(match[0].length);
+                        match = currentText.match(responseLineRE);
+                    }
+                    return pump();
+                })
+                    .catch((e) => {
+                    let err = e;
+                    err.stack = e.stack;
+                    if (err.name === "AbortError") {
+                        err = new GoogleGenerativeAIAbortError("Request aborted when reading from the stream");
+                    }
+                    else {
+                        err = new GoogleGenerativeAIError("Error reading from the stream");
+                    }
+                    throw err;
+                });
+            }
+        },
+    });
+    return stream;
+}
+/**
+ * Aggregates an array of `GenerateContentResponse`s into a single
+ * GenerateContentResponse.
+ */
+function aggregateResponses(responses) {
+    const lastResponse = responses[responses.length - 1];
+    const aggregatedResponse = {
+        promptFeedback: lastResponse === null || lastResponse === void 0 ? void 0 : lastResponse.promptFeedback,
+    };
+    for (const response of responses) {
+        if (response.candidates) {
+            let candidateIndex = 0;
+            for (const candidate of response.candidates) {
+                if (!aggregatedResponse.candidates) {
+                    aggregatedResponse.candidates = [];
+                }
+                if (!aggregatedResponse.candidates[candidateIndex]) {
+                    aggregatedResponse.candidates[candidateIndex] = {
+                        index: candidateIndex,
+                    };
+                }
+                // Keep overwriting, the last one will be final
+                aggregatedResponse.candidates[candidateIndex].citationMetadata =
+                    candidate.citationMetadata;
+                aggregatedResponse.candidates[candidateIndex].groundingMetadata =
+                    candidate.groundingMetadata;
+                aggregatedResponse.candidates[candidateIndex].finishReason =
+                    candidate.finishReason;
+                aggregatedResponse.candidates[candidateIndex].finishMessage =
+                    candidate.finishMessage;
+                aggregatedResponse.candidates[candidateIndex].safetyRatings =
+                    candidate.safetyRatings;
+                /**
+                 * Candidates should always have content and parts, but this handles
+                 * possible malformed responses.
+                 */
+                if (candidate.content && candidate.content.parts) {
+                    if (!aggregatedResponse.candidates[candidateIndex].content) {
+                        aggregatedResponse.candidates[candidateIndex].content = {
+                            role: candidate.content.role || "user",
+                            parts: [],
+                        };
+                    }
+                    const newPart = {};
+                    for (const part of candidate.content.parts) {
+                        if (part.text) {
+                            newPart.text = part.text;
+                        }
+                        if (part.functionCall) {
+                            newPart.functionCall = part.functionCall;
+                        }
+                        if (part.executableCode) {
+                            newPart.executableCode = part.executableCode;
+                        }
+                        if (part.codeExecutionResult) {
+                            newPart.codeExecutionResult = part.codeExecutionResult;
+                        }
+                        if (Object.keys(newPart).length === 0) {
+                            newPart.text = "";
+                        }
+                        aggregatedResponse.candidates[candidateIndex].content.parts.push(newPart);
+                    }
+                }
+            }
+            candidateIndex++;
+        }
+        if (response.usageMetadata) {
+            aggregatedResponse.usageMetadata = response.usageMetadata;
+        }
+    }
+    return aggregatedResponse;
+}
+
+/**
+ * @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.
+ */
+async function generateContentStream(apiKey, model, params, requestOptions) {
+    const response = await makeModelRequest(model, Task.STREAM_GENERATE_CONTENT, apiKey, 
+    /* stream */ true, JSON.stringify(params), requestOptions);
+    return processStream(response);
+}
+async function generateContent(apiKey, model, params, requestOptions) {
+    const response = await makeModelRequest(model, Task.GENERATE_CONTENT, apiKey, 
+    /* stream */ false, JSON.stringify(params), requestOptions);
+    const responseJson = await response.json();
+    const enhancedResponse = addHelpers(responseJson);
+    return {
+        response: enhancedResponse,
+    };
+}
+
+/**
+ * @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;
+        }
+    }
+}
+function formatNewContent(request) {
+    let newParts = [];
+    if (typeof request === "string") {
+        newParts = [{ text: request }];
+    }
+    else {
+        for (const partOrString of request) {
+            if (typeof partOrString === "string") {
+                newParts.push({ text: partOrString });
+            }
+            else {
+                newParts.push(partOrString);
+            }
+        }
+    }
+    return assignRoleToPartsAndValidateSendMessageRequest(newParts);
+}
+/**
+ * When multiple Part types (i.e. FunctionResponsePart and TextPart) are
+ * passed in a single Part array, we may need to assign different roles to each
+ * part. Currently only FunctionResponsePart requires a role other than 'user'.
+ * @private
+ * @param parts Array of parts to pass to the model
+ * @returns Array of content items
+ */
+function assignRoleToPartsAndValidateSendMessageRequest(parts) {
+    const userContent = { role: "user", parts: [] };
+    const functionContent = { role: "function", parts: [] };
+    let hasUserContent = false;
+    let hasFunctionContent = false;
+    for (const part of parts) {
+        if ("functionResponse" in part) {
+            functionContent.parts.push(part);
+            hasFunctionContent = true;
+        }
+        else {
+            userContent.parts.push(part);
+            hasUserContent = true;
+        }
+    }
+    if (hasUserContent && hasFunctionContent) {
+        throw new GoogleGenerativeAIError("Within a single message, FunctionResponse cannot be mixed with other type of part in the request for sending chat message.");
+    }
+    if (!hasUserContent && !hasFunctionContent) {
+        throw new GoogleGenerativeAIError("No content is provided for sending chat message.");
+    }
+    if (hasUserContent) {
+        return userContent;
+    }
+    return functionContent;
+}
+function formatCountTokensInput(params, modelParams) {
+    var _a;
+    let formattedGenerateContentRequest = {
+        model: modelParams === null || modelParams === void 0 ? void 0 : modelParams.model,
+        generationConfig: modelParams === null || modelParams === void 0 ? void 0 : modelParams.generationConfig,
+        safetySettings: modelParams === null || modelParams === void 0 ? void 0 : modelParams.safetySettings,
+        tools: modelParams === null || modelParams === void 0 ? void 0 : modelParams.tools,
+        toolConfig: modelParams === null || modelParams === void 0 ? void 0 : modelParams.toolConfig,
+        systemInstruction: modelParams === null || modelParams === void 0 ? void 0 : modelParams.systemInstruction,
+        cachedContent: (_a = modelParams === null || modelParams === void 0 ? void 0 : modelParams.cachedContent) === null || _a === void 0 ? void 0 : _a.name,
+        contents: [],
+    };
+    const containsGenerateContentRequest = params.generateContentRequest != null;
+    if (params.contents) {
+        if (containsGenerateContentRequest) {
+            throw new GoogleGenerativeAIRequestInputError("CountTokensRequest must have one of contents or generateContentRequest, not both.");
+        }
+        formattedGenerateContentRequest.contents = params.contents;
+    }
+    else if (containsGenerateContentRequest) {
+        formattedGenerateContentRequest = Object.assign(Object.assign({}, formattedGenerateContentRequest), params.generateContentRequest);
+    }
+    else {
+        // Array or string
+        const content = formatNewContent(params);
+        formattedGenerateContentRequest.contents = [content];
+    }
+    return { generateContentRequest: formattedGenerateContentRequest };
+}
+function formatGenerateContentInput(params) {
+    let formattedRequest;
+    if (params.contents) {
+        formattedRequest = params;
+    }
+    else {
+        // Array or string
+        const content = formatNewContent(params);
+        formattedRequest = { contents: [content] };
+    }
+    if (params.systemInstruction) {
+        formattedRequest.systemInstruction = formatSystemInstruction(params.systemInstruction);
+    }
+    return formattedRequest;
+}
+function formatEmbedContentInput(params) {
+    if (typeof params === "string" || Array.isArray(params)) {
+        const content = formatNewContent(params);
+        return { content };
+    }
+    return params;
+}
+
+/**
+ * @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.
+ */
+// https://ai.google.dev/api/rest/v1beta/Content#part
+const VALID_PART_FIELDS = [
+    "text",
+    "inlineData",
+    "functionCall",
+    "functionResponse",
+    "executableCode",
+    "codeExecutionResult",
+];
+const VALID_PARTS_PER_ROLE = {
+    user: ["text", "inlineData"],
+    function: ["functionResponse"],
+    model: ["text", "functionCall", "executableCode", "codeExecutionResult"],
+    // System instructions shouldn't be in history anyway.
+    system: ["text"],
+};
+function validateChatHistory(history) {
+    let prevContent = false;
+    for (const currContent of history) {
+        const { role, parts } = currContent;
+        if (!prevContent && role !== "user") {
+            throw new GoogleGenerativeAIError(`First content should be with role 'user', got ${role}`);
+        }
+        if (!POSSIBLE_ROLES.includes(role)) {
+            throw new GoogleGenerativeAIError(`Each item should include role field. Got ${role} but valid roles are: ${JSON.stringify(POSSIBLE_ROLES)}`);
+        }
+        if (!Array.isArray(parts)) {
+            throw new GoogleGenerativeAIError("Content should have 'parts' property with an array of Parts");
+        }
+        if (parts.length === 0) {
+            throw new GoogleGenerativeAIError("Each Content should have at least one part");
+        }
+        const countFields = {
+            text: 0,
+            inlineData: 0,
+            functionCall: 0,
+            functionResponse: 0,
+            fileData: 0,
+            executableCode: 0,
+            codeExecutionResult: 0,
+        };
+        for (const part of parts) {
+            for (const key of VALID_PART_FIELDS) {
+                if (key in part) {
+                    countFields[key] += 1;
+                }
+            }
+        }
+        const validParts = VALID_PARTS_PER_ROLE[role];
+        for (const key of VALID_PART_FIELDS) {
+            if (!validParts.includes(key) && countFields[key] > 0) {
+                throw new GoogleGenerativeAIError(`Content with role '${role}' can't contain '${key}' part`);
+            }
+        }
+        prevContent = true;
+    }
+}
+/**
+ * Returns true if the response is valid (could be appended to the history), flase otherwise.
+ */
+function isValidResponse(response) {
+    var _a;
+    if (response.candidates === undefined || response.candidates.length === 0) {
+        return false;
+    }
+    const content = (_a = response.candidates[0]) === null || _a === void 0 ? void 0 : _a.content;
+    if (content === undefined) {
+        return false;
+    }
+    if (content.parts === undefined || content.parts.length === 0) {
+        return false;
+    }
+    for (const part of content.parts) {
+        if (part === undefined || Object.keys(part).length === 0) {
+            return false;
+        }
+        if (part.text !== undefined && part.text === "") {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @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.
+ */
+/**
+ * Do not log a message for this error.
+ */
+const SILENT_ERROR = "SILENT_ERROR";
+/**
+ * ChatSession class that enables sending chat messages and stores
+ * history of sent and received messages so far.
+ *
+ * @public
+ */
+class ChatSession {
+    constructor(apiKey, model, params, _requestOptions = {}) {
+        this.model = model;
+        this.params = params;
+        this._requestOptions = _requestOptions;
+        this._history = [];
+        this._sendPromise = Promise.resolve();
+        this._apiKey = apiKey;
+        if (params === null || params === void 0 ? void 0 : params.history) {
+            validateChatHistory(params.history);
+            this._history = params.history;
+        }
+    }
+    /**
+     * 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.
+     */
+    async getHistory() {
+        await this._sendPromise;
+        return this._history;
+    }
+    /**
+     * 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 }.
+     */
+    async sendMessage(request, requestOptions = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        await this._sendPromise;
+        const newContent = formatNewContent(request);
+        const generateContentRequest = {
+            safetySettings: (_a = this.params) === null || _a === void 0 ? void 0 : _a.safetySettings,
+            generationConfig: (_b = this.params) === null || _b === void 0 ? void 0 : _b.generationConfig,
+            tools: (_c = this.params) === null || _c === void 0 ? void 0 : _c.tools,
+            toolConfig: (_d = this.params) === null || _d === void 0 ? void 0 : _d.toolConfig,
+            systemInstruction: (_e = this.params) === null || _e === void 0 ? void 0 : _e.systemInstruction,
+            cachedContent: (_f = this.params) === null || _f === void 0 ? void 0 : _f.cachedContent,
+            contents: [...this._history, newContent],
+        };
+        const chatSessionRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        let finalResult;
+        // Add onto the chain.
+        this._sendPromise = this._sendPromise
+            .then(() => generateContent(this._apiKey, this.model, generateContentRequest, chatSessionRequestOptions))
+            .then((result) => {
+            var _a;
+            if (isValidResponse(result.response)) {
+                this._history.push(newContent);
+                const responseContent = Object.assign({ parts: [], 
+                    // Response seems to come back without a role set.
+                    role: "model" }, (_a = result.response.candidates) === null || _a === void 0 ? void 0 : _a[0].content);
+                this._history.push(responseContent);
+            }
+            else {
+                const blockErrorMessage = formatBlockErrorMessage(result.response);
+                if (blockErrorMessage) {
+                    console.warn(`sendMessage() was unsuccessful. ${blockErrorMessage}. Inspect response object for details.`);
+                }
+            }
+            finalResult = result;
+        })
+            .catch((e) => {
+            // Resets _sendPromise to avoid subsequent calls failing and throw error.
+            this._sendPromise = Promise.resolve();
+            throw e;
+        });
+        await this._sendPromise;
+        return finalResult;
+    }
+    /**
+     * 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 }.
+     */
+    async sendMessageStream(request, requestOptions = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        await this._sendPromise;
+        const newContent = formatNewContent(request);
+        const generateContentRequest = {
+            safetySettings: (_a = this.params) === null || _a === void 0 ? void 0 : _a.safetySettings,
+            generationConfig: (_b = this.params) === null || _b === void 0 ? void 0 : _b.generationConfig,
+            tools: (_c = this.params) === null || _c === void 0 ? void 0 : _c.tools,
+            toolConfig: (_d = this.params) === null || _d === void 0 ? void 0 : _d.toolConfig,
+            systemInstruction: (_e = this.params) === null || _e === void 0 ? void 0 : _e.systemInstruction,
+            cachedContent: (_f = this.params) === null || _f === void 0 ? void 0 : _f.cachedContent,
+            contents: [...this._history, newContent],
+        };
+        const chatSessionRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        const streamPromise = generateContentStream(this._apiKey, this.model, generateContentRequest, chatSessionRequestOptions);
+        // Add onto the chain.
+        this._sendPromise = this._sendPromise
+            .then(() => streamPromise)
+            // This must be handled to avoid unhandled rejection, but jump
+            // to the final catch block with a label to not log this error.
+            .catch((_ignored) => {
+            throw new Error(SILENT_ERROR);
+        })
+            .then((streamResult) => streamResult.response)
+            .then((response) => {
+            if (isValidResponse(response)) {
+                this._history.push(newContent);
+                const responseContent = Object.assign({}, response.candidates[0].content);
+                // Response seems to come back without a role set.
+                if (!responseContent.role) {
+                    responseContent.role = "model";
+                }
+                this._history.push(responseContent);
+            }
+            else {
+                const blockErrorMessage = formatBlockErrorMessage(response);
+                if (blockErrorMessage) {
+                    console.warn(`sendMessageStream() was unsuccessful. ${blockErrorMessage}. Inspect response object for details.`);
+                }
+            }
+        })
+            .catch((e) => {
+            // Errors in streamPromise are already catchable by the user as
+            // streamPromise is returned.
+            // Avoid duplicating the error message in logs.
+            if (e.message !== SILENT_ERROR) {
+                // Users do not have access to _sendPromise to catch errors
+                // downstream from streamPromise, so they should not throw.
+                console.error(e);
+            }
+        });
+        return streamPromise;
+    }
+}
+
+/**
+ * @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.
+ */
+async function countTokens(apiKey, model, params, singleRequestOptions) {
+    const response = await makeModelRequest(model, Task.COUNT_TOKENS, apiKey, false, JSON.stringify(params), singleRequestOptions);
+    return response.json();
+}
+
+/**
+ * @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.
+ */
+async function embedContent(apiKey, model, params, requestOptions) {
+    const response = await makeModelRequest(model, Task.EMBED_CONTENT, apiKey, false, JSON.stringify(params), requestOptions);
+    return response.json();
+}
+async function batchEmbedContents(apiKey, model, params, requestOptions) {
+    const requestsWithModel = params.requests.map((request) => {
+        return Object.assign(Object.assign({}, request), { model });
+    });
+    const response = await makeModelRequest(model, Task.BATCH_EMBED_CONTENTS, apiKey, false, JSON.stringify({ requests: requestsWithModel }), requestOptions);
+    return response.json();
+}
+
+/**
+ * @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 generative model APIs.
+ * @public
+ */
+class GenerativeModel {
+    constructor(apiKey, modelParams, _requestOptions = {}) {
+        this.apiKey = apiKey;
+        this._requestOptions = _requestOptions;
+        if (modelParams.model.includes("/")) {
+            // Models may be named "models/model-name" or "tunedModels/model-name"
+            this.model = modelParams.model;
+        }
+        else {
+            // If path is not included, assume it's a non-tuned model.
+            this.model = `models/${modelParams.model}`;
+        }
+        this.generationConfig = modelParams.generationConfig || {};
+        this.safetySettings = modelParams.safetySettings || [];
+        this.tools = modelParams.tools;
+        this.toolConfig = modelParams.toolConfig;
+        this.systemInstruction = formatSystemInstruction(modelParams.systemInstruction);
+        this.cachedContent = modelParams.cachedContent;
+    }
+    /**
+     * 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 }.
+     */
+    async generateContent(request, requestOptions = {}) {
+        var _a;
+        const formattedParams = formatGenerateContentInput(request);
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return generateContent(this.apiKey, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, cachedContent: (_a = this.cachedContent) === null || _a === void 0 ? void 0 : _a.name }, formattedParams), generativeModelRequestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async generateContentStream(request, requestOptions = {}) {
+        var _a;
+        const formattedParams = formatGenerateContentInput(request);
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return generateContentStream(this.apiKey, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, cachedContent: (_a = this.cachedContent) === null || _a === void 0 ? void 0 : _a.name }, formattedParams), generativeModelRequestOptions);
+    }
+    /**
+     * Gets a new {@link ChatSession} instance which can be used for
+     * multi-turn chats.
+     */
+    startChat(startChatParams) {
+        var _a;
+        return new ChatSession(this.apiKey, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, cachedContent: (_a = this.cachedContent) === null || _a === void 0 ? void 0 : _a.name }, startChatParams), this._requestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async countTokens(request, requestOptions = {}) {
+        const formattedParams = formatCountTokensInput(request, {
+            model: this.model,
+            generationConfig: this.generationConfig,
+            safetySettings: this.safetySettings,
+            tools: this.tools,
+            toolConfig: this.toolConfig,
+            systemInstruction: this.systemInstruction,
+            cachedContent: this.cachedContent,
+        });
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return countTokens(this.apiKey, this.model, formattedParams, generativeModelRequestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async embedContent(request, requestOptions = {}) {
+        const formattedParams = formatEmbedContentInput(request);
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return embedContent(this.apiKey, this.model, formattedParams, generativeModelRequestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async batchEmbedContents(batchEmbedContentRequest, requestOptions = {}) {
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return batchEmbedContents(this.apiKey, this.model, batchEmbedContentRequest, generativeModelRequestOptions);
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * Top-level class for this SDK
+ * @public
+ */
+class GoogleGenerativeAI {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * Gets a {@link GenerativeModel} instance for the provided model name.
+     */
+    getGenerativeModel(modelParams, requestOptions) {
+        if (!modelParams.model) {
+            throw new GoogleGenerativeAIError(`Must provide a model name. ` +
+                `Example: genai.getGenerativeModel({ model: 'my-model-name' })`);
+        }
+        return new GenerativeModel(this.apiKey, modelParams, requestOptions);
+    }
+    /**
+     * Creates a {@link GenerativeModel} instance from provided content cache.
+     */
+    getGenerativeModelFromCachedContent(cachedContent, modelParams, requestOptions) {
+        if (!cachedContent.name) {
+            throw new GoogleGenerativeAIRequestInputError("Cached content must contain a `name` field.");
+        }
+        if (!cachedContent.model) {
+            throw new GoogleGenerativeAIRequestInputError("Cached content must contain a `model` field.");
+        }
+        /**
+         * Not checking tools and toolConfig for now as it would require a deep
+         * equality comparison and isn't likely to be a common case.
+         */
+        const disallowedDuplicates = ["model", "systemInstruction"];
+        for (const key of disallowedDuplicates) {
+            if ((modelParams === null || modelParams === void 0 ? void 0 : modelParams[key]) &&
+                cachedContent[key] &&
+                (modelParams === null || modelParams === void 0 ? void 0 : modelParams[key]) !== cachedContent[key]) {
+                if (key === "model") {
+                    const modelParamsComp = modelParams.model.startsWith("models/")
+                        ? modelParams.model.replace("models/", "")
+                        : modelParams.model;
+                    const cachedContentComp = cachedContent.model.startsWith("models/")
+                        ? cachedContent.model.replace("models/", "")
+                        : cachedContent.model;
+                    if (modelParamsComp === cachedContentComp) {
+                        continue;
+                    }
+                }
+                throw new GoogleGenerativeAIRequestInputError(`Different value for "${key}" specified in modelParams` +
+                    ` (${modelParams[key]}) and cachedContent (${cachedContent[key]})`);
+            }
+        }
+        const modelParamsFromCache = Object.assign(Object.assign({}, modelParams), { model: cachedContent.model, tools: cachedContent.tools, toolConfig: cachedContent.toolConfig, systemInstruction: cachedContent.systemInstruction, cachedContent });
+        return new GenerativeModel(this.apiKey, modelParamsFromCache, requestOptions);
+    }
+}
+
+exports.ChatSession = ChatSession;
+exports.GenerativeModel = GenerativeModel;
+exports.GoogleGenerativeAI = GoogleGenerativeAI;
+exports.GoogleGenerativeAIAbortError = GoogleGenerativeAIAbortError;
+exports.GoogleGenerativeAIError = GoogleGenerativeAIError;
+exports.GoogleGenerativeAIFetchError = GoogleGenerativeAIFetchError;
+exports.GoogleGenerativeAIRequestInputError = GoogleGenerativeAIRequestInputError;
+exports.GoogleGenerativeAIResponseError = GoogleGenerativeAIResponseError;
+exports.POSSIBLE_ROLES = POSSIBLE_ROLES;
+//# sourceMappingURL=index.js.map

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

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

backend-old/node_modules/@google/generative-ai/dist/index.mjs

@@ -0,0 +1,1520 @@
+/**
+ * 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
+ */
+const POSSIBLE_ROLES = ["user", "model", "function", "system"];
+/**
+ * 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["HARM_CATEGORY_CIVIC_INTEGRITY"] = "HARM_CATEGORY_CIVIC_INTEGRITY";
+})(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";
+    // Token generation stopped because the content contains forbidden terms.
+    FinishReason["BLOCKLIST"] = "BLOCKLIST";
+    // Token generation stopped for potentially containing prohibited content.
+    FinishReason["PROHIBITED_CONTENT"] = "PROHIBITED_CONTENT";
+    // Token generation stopped because the content potentially contains Sensitive Personally Identifiable Information (SPII).
+    FinishReason["SPII"] = "SPII";
+    // The function call generated by the model is invalid.
+    FinishReason["MALFORMED_FUNCTION_CALL"] = "MALFORMED_FUNCTION_CALL";
+    // 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 = {}));
+
+/**
+ * @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}`);
+    }
+}
+/**
+ * Errors in the contents of a response from the model. This includes parsing
+ * errors, or responses including a safety block reason.
+ * @public
+ */
+class GoogleGenerativeAIResponseError extends GoogleGenerativeAIError {
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
+/**
+ * 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 {
+}
+/**
+ * Error thrown when a request is aborted, either due to a timeout or
+ * intentional cancellation by the user.
+ * @public
+ */
+class GoogleGenerativeAIAbortError 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.24.1";
+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 = {}));
+class RequestUrl {
+    constructor(model, task, apiKey, stream, requestOptions) {
+        this.model = model;
+        this.task = task;
+        this.apiKey = apiKey;
+        this.stream = stream;
+        this.requestOptions = requestOptions;
+    }
+    toString() {
+        var _a, _b;
+        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 url = `${baseUrl}/${apiVersion}/${this.model}:${this.task}`;
+        if (this.stream) {
+            url += "?alt=sse";
+        }
+        return url;
+    }
+}
+/**
+ * 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 getHeaders(url) {
+    var _a;
+    const headers = new Headers();
+    headers.append("Content-Type", "application/json");
+    headers.append("x-goog-api-client", getClientHeaders(url.requestOptions));
+    headers.append("x-goog-api-key", url.apiKey);
+    let customHeaders = (_a = url.requestOptions) === null || _a === void 0 ? void 0 : _a.customHeaders;
+    if (customHeaders) {
+        if (!(customHeaders instanceof Headers)) {
+            try {
+                customHeaders = new Headers(customHeaders);
+            }
+            catch (e) {
+                throw new GoogleGenerativeAIRequestInputError(`unable to convert customHeaders value ${JSON.stringify(customHeaders)} to Headers: ${e.message}`);
+            }
+        }
+        for (const [headerName, headerValue] of customHeaders.entries()) {
+            if (headerName === "x-goog-api-key") {
+                throw new GoogleGenerativeAIRequestInputError(`Cannot set reserved header name ${headerName}`);
+            }
+            else if (headerName === "x-goog-api-client") {
+                throw new GoogleGenerativeAIRequestInputError(`Header name ${headerName} can only be set using the apiClient field`);
+            }
+            headers.append(headerName, headerValue);
+        }
+    }
+    return headers;
+}
+async function constructModelRequest(model, task, apiKey, stream, body, requestOptions) {
+    const url = new RequestUrl(model, task, apiKey, stream, requestOptions);
+    return {
+        url: url.toString(),
+        fetchOptions: Object.assign(Object.assign({}, buildFetchOptions(requestOptions)), { method: "POST", headers: await getHeaders(url), body }),
+    };
+}
+async function makeModelRequest(model, task, apiKey, stream, body, requestOptions = {}, 
+// Allows this to be stubbed for tests
+fetchFn = fetch) {
+    const { url, fetchOptions } = await constructModelRequest(model, task, apiKey, stream, body, requestOptions);
+    return makeRequest(url, fetchOptions, fetchFn);
+}
+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 (err.name === "AbortError") {
+        err = new GoogleGenerativeAIAbortError(`Request aborted when fetching ${url.toString()}: ${e.message}`);
+        err.stack = e.stack;
+    }
+    else 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);
+}
+/**
+ * Generates the request options to be passed to the fetch API.
+ * @param requestOptions - The user-defined request options.
+ * @returns The generated request options.
+ */
+function buildFetchOptions(requestOptions) {
+    const fetchOptions = {};
+    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 === null || requestOptions === void 0 ? void 0 : requestOptions.signal) {
+            requestOptions.signal.addEventListener("abort", () => {
+                controller.abort();
+            });
+        }
+        fetchOptions.signal = controller.signal;
+    }
+    return fetchOptions;
+}
+
+/**
+ * @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.
+ */
+/**
+ * Adds convenience helper methods to a response object, including stream
+ * chunks (as long as each chunk is a complete GenerateContentResponse JSON).
+ */
+function addHelpers(response) {
+    response.text = () => {
+        if (response.candidates && response.candidates.length > 0) {
+            if (response.candidates.length > 1) {
+                console.warn(`This response had ${response.candidates.length} ` +
+                    `candidates. Returning text from the first candidate only. ` +
+                    `Access response.candidates directly to use the other candidates.`);
+            }
+            if (hadBadFinishReason(response.candidates[0])) {
+                throw new GoogleGenerativeAIResponseError(`${formatBlockErrorMessage(response)}`, response);
+            }
+            return getText(response);
+        }
+        else if (response.promptFeedback) {
+            throw new GoogleGenerativeAIResponseError(`Text not available. ${formatBlockErrorMessage(response)}`, response);
+        }
+        return "";
+    };
+    /**
+     * TODO: remove at next major version
+     */
+    response.functionCall = () => {
+        if (response.candidates && response.candidates.length > 0) {
+            if (response.candidates.length > 1) {
+                console.warn(`This response had ${response.candidates.length} ` +
+                    `candidates. Returning function calls from the first candidate only. ` +
+                    `Access response.candidates directly to use the other candidates.`);
+            }
+            if (hadBadFinishReason(response.candidates[0])) {
+                throw new GoogleGenerativeAIResponseError(`${formatBlockErrorMessage(response)}`, response);
+            }
+            console.warn(`response.functionCall() is deprecated. ` +
+                `Use response.functionCalls() instead.`);
+            return getFunctionCalls(response)[0];
+        }
+        else if (response.promptFeedback) {
+            throw new GoogleGenerativeAIResponseError(`Function call not available. ${formatBlockErrorMessage(response)}`, response);
+        }
+        return undefined;
+    };
+    response.functionCalls = () => {
+        if (response.candidates && response.candidates.length > 0) {
+            if (response.candidates.length > 1) {
+                console.warn(`This response had ${response.candidates.length} ` +
+                    `candidates. Returning function calls from the first candidate only. ` +
+                    `Access response.candidates directly to use the other candidates.`);
+            }
+            if (hadBadFinishReason(response.candidates[0])) {
+                throw new GoogleGenerativeAIResponseError(`${formatBlockErrorMessage(response)}`, response);
+            }
+            return getFunctionCalls(response);
+        }
+        else if (response.promptFeedback) {
+            throw new GoogleGenerativeAIResponseError(`Function call not available. ${formatBlockErrorMessage(response)}`, response);
+        }
+        return undefined;
+    };
+    return response;
+}
+/**
+ * Returns all text found in all parts of first candidate.
+ */
+function getText(response) {
+    var _a, _b, _c, _d;
+    const textStrings = [];
+    if ((_b = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0].content) === null || _b === void 0 ? void 0 : _b.parts) {
+        for (const part of (_d = (_c = response.candidates) === null || _c === void 0 ? void 0 : _c[0].content) === null || _d === void 0 ? void 0 : _d.parts) {
+            if (part.text) {
+                textStrings.push(part.text);
+            }
+            if (part.executableCode) {
+                textStrings.push("\n```" +
+                    part.executableCode.language +
+                    "\n" +
+                    part.executableCode.code +
+                    "\n```\n");
+            }
+            if (part.codeExecutionResult) {
+                textStrings.push("\n```\n" + part.codeExecutionResult.output + "\n```\n");
+            }
+        }
+    }
+    if (textStrings.length > 0) {
+        return textStrings.join("");
+    }
+    else {
+        return "";
+    }
+}
+/**
+ * Returns functionCall of first candidate.
+ */
+function getFunctionCalls(response) {
+    var _a, _b, _c, _d;
+    const functionCalls = [];
+    if ((_b = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0].content) === null || _b === void 0 ? void 0 : _b.parts) {
+        for (const part of (_d = (_c = response.candidates) === null || _c === void 0 ? void 0 : _c[0].content) === null || _d === void 0 ? void 0 : _d.parts) {
+            if (part.functionCall) {
+                functionCalls.push(part.functionCall);
+            }
+        }
+    }
+    if (functionCalls.length > 0) {
+        return functionCalls;
+    }
+    else {
+        return undefined;
+    }
+}
+const badFinishReasons = [
+    FinishReason.RECITATION,
+    FinishReason.SAFETY,
+    FinishReason.LANGUAGE,
+];
+function hadBadFinishReason(candidate) {
+    return (!!candidate.finishReason &&
+        badFinishReasons.includes(candidate.finishReason));
+}
+function formatBlockErrorMessage(response) {
+    var _a, _b, _c;
+    let message = "";
+    if ((!response.candidates || response.candidates.length === 0) &&
+        response.promptFeedback) {
+        message += "Response was blocked";
+        if ((_a = response.promptFeedback) === null || _a === void 0 ? void 0 : _a.blockReason) {
+            message += ` due to ${response.promptFeedback.blockReason}`;
+        }
+        if ((_b = response.promptFeedback) === null || _b === void 0 ? void 0 : _b.blockReasonMessage) {
+            message += `: ${response.promptFeedback.blockReasonMessage}`;
+        }
+    }
+    else if ((_c = response.candidates) === null || _c === void 0 ? void 0 : _c[0]) {
+        const firstCandidate = response.candidates[0];
+        if (hadBadFinishReason(firstCandidate)) {
+            message += `Candidate was blocked due to ${firstCandidate.finishReason}`;
+            if (firstCandidate.finishMessage) {
+                message += `: ${firstCandidate.finishMessage}`;
+            }
+        }
+    }
+    return message;
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * @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 responseLineRE = /^data\: (.*)(?:\n\n|\r\r|\r\n\r\n)/;
+/**
+ * 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
+ */
+function processStream(response) {
+    const inputStream = response.body.pipeThrough(new TextDecoderStream("utf8", { fatal: true }));
+    const responseStream = getResponseStream(inputStream);
+    const [stream1, stream2] = responseStream.tee();
+    return {
+        stream: generateResponseSequence(stream1),
+        response: getResponsePromise(stream2),
+    };
+}
+async function getResponsePromise(stream) {
+    const allResponses = [];
+    const reader = stream.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            return addHelpers(aggregateResponses(allResponses));
+        }
+        allResponses.push(value);
+    }
+}
+function generateResponseSequence(stream) {
+    return __asyncGenerator(this, arguments, function* generateResponseSequence_1() {
+        const reader = stream.getReader();
+        while (true) {
+            const { value, done } = yield __await(reader.read());
+            if (done) {
+                break;
+            }
+            yield yield __await(addHelpers(value));
+        }
+    });
+}
+/**
+ * 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.
+ */
+function getResponseStream(inputStream) {
+    const reader = inputStream.getReader();
+    const stream = new ReadableStream({
+        start(controller) {
+            let currentText = "";
+            return pump();
+            function pump() {
+                return reader
+                    .read()
+                    .then(({ value, done }) => {
+                    if (done) {
+                        if (currentText.trim()) {
+                            controller.error(new GoogleGenerativeAIError("Failed to parse stream"));
+                            return;
+                        }
+                        controller.close();
+                        return;
+                    }
+                    currentText += value;
+                    let match = currentText.match(responseLineRE);
+                    let parsedResponse;
+                    while (match) {
+                        try {
+                            parsedResponse = JSON.parse(match[1]);
+                        }
+                        catch (e) {
+                            controller.error(new GoogleGenerativeAIError(`Error parsing JSON response: "${match[1]}"`));
+                            return;
+                        }
+                        controller.enqueue(parsedResponse);
+                        currentText = currentText.substring(match[0].length);
+                        match = currentText.match(responseLineRE);
+                    }
+                    return pump();
+                })
+                    .catch((e) => {
+                    let err = e;
+                    err.stack = e.stack;
+                    if (err.name === "AbortError") {
+                        err = new GoogleGenerativeAIAbortError("Request aborted when reading from the stream");
+                    }
+                    else {
+                        err = new GoogleGenerativeAIError("Error reading from the stream");
+                    }
+                    throw err;
+                });
+            }
+        },
+    });
+    return stream;
+}
+/**
+ * Aggregates an array of `GenerateContentResponse`s into a single
+ * GenerateContentResponse.
+ */
+function aggregateResponses(responses) {
+    const lastResponse = responses[responses.length - 1];
+    const aggregatedResponse = {
+        promptFeedback: lastResponse === null || lastResponse === void 0 ? void 0 : lastResponse.promptFeedback,
+    };
+    for (const response of responses) {
+        if (response.candidates) {
+            let candidateIndex = 0;
+            for (const candidate of response.candidates) {
+                if (!aggregatedResponse.candidates) {
+                    aggregatedResponse.candidates = [];
+                }
+                if (!aggregatedResponse.candidates[candidateIndex]) {
+                    aggregatedResponse.candidates[candidateIndex] = {
+                        index: candidateIndex,
+                    };
+                }
+                // Keep overwriting, the last one will be final
+                aggregatedResponse.candidates[candidateIndex].citationMetadata =
+                    candidate.citationMetadata;
+                aggregatedResponse.candidates[candidateIndex].groundingMetadata =
+                    candidate.groundingMetadata;
+                aggregatedResponse.candidates[candidateIndex].finishReason =
+                    candidate.finishReason;
+                aggregatedResponse.candidates[candidateIndex].finishMessage =
+                    candidate.finishMessage;
+                aggregatedResponse.candidates[candidateIndex].safetyRatings =
+                    candidate.safetyRatings;
+                /**
+                 * Candidates should always have content and parts, but this handles
+                 * possible malformed responses.
+                 */
+                if (candidate.content && candidate.content.parts) {
+                    if (!aggregatedResponse.candidates[candidateIndex].content) {
+                        aggregatedResponse.candidates[candidateIndex].content = {
+                            role: candidate.content.role || "user",
+                            parts: [],
+                        };
+                    }
+                    const newPart = {};
+                    for (const part of candidate.content.parts) {
+                        if (part.text) {
+                            newPart.text = part.text;
+                        }
+                        if (part.functionCall) {
+                            newPart.functionCall = part.functionCall;
+                        }
+                        if (part.executableCode) {
+                            newPart.executableCode = part.executableCode;
+                        }
+                        if (part.codeExecutionResult) {
+                            newPart.codeExecutionResult = part.codeExecutionResult;
+                        }
+                        if (Object.keys(newPart).length === 0) {
+                            newPart.text = "";
+                        }
+                        aggregatedResponse.candidates[candidateIndex].content.parts.push(newPart);
+                    }
+                }
+            }
+            candidateIndex++;
+        }
+        if (response.usageMetadata) {
+            aggregatedResponse.usageMetadata = response.usageMetadata;
+        }
+    }
+    return aggregatedResponse;
+}
+
+/**
+ * @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.
+ */
+async function generateContentStream(apiKey, model, params, requestOptions) {
+    const response = await makeModelRequest(model, Task.STREAM_GENERATE_CONTENT, apiKey, 
+    /* stream */ true, JSON.stringify(params), requestOptions);
+    return processStream(response);
+}
+async function generateContent(apiKey, model, params, requestOptions) {
+    const response = await makeModelRequest(model, Task.GENERATE_CONTENT, apiKey, 
+    /* stream */ false, JSON.stringify(params), requestOptions);
+    const responseJson = await response.json();
+    const enhancedResponse = addHelpers(responseJson);
+    return {
+        response: enhancedResponse,
+    };
+}
+
+/**
+ * @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;
+        }
+    }
+}
+function formatNewContent(request) {
+    let newParts = [];
+    if (typeof request === "string") {
+        newParts = [{ text: request }];
+    }
+    else {
+        for (const partOrString of request) {
+            if (typeof partOrString === "string") {
+                newParts.push({ text: partOrString });
+            }
+            else {
+                newParts.push(partOrString);
+            }
+        }
+    }
+    return assignRoleToPartsAndValidateSendMessageRequest(newParts);
+}
+/**
+ * When multiple Part types (i.e. FunctionResponsePart and TextPart) are
+ * passed in a single Part array, we may need to assign different roles to each
+ * part. Currently only FunctionResponsePart requires a role other than 'user'.
+ * @private
+ * @param parts Array of parts to pass to the model
+ * @returns Array of content items
+ */
+function assignRoleToPartsAndValidateSendMessageRequest(parts) {
+    const userContent = { role: "user", parts: [] };
+    const functionContent = { role: "function", parts: [] };
+    let hasUserContent = false;
+    let hasFunctionContent = false;
+    for (const part of parts) {
+        if ("functionResponse" in part) {
+            functionContent.parts.push(part);
+            hasFunctionContent = true;
+        }
+        else {
+            userContent.parts.push(part);
+            hasUserContent = true;
+        }
+    }
+    if (hasUserContent && hasFunctionContent) {
+        throw new GoogleGenerativeAIError("Within a single message, FunctionResponse cannot be mixed with other type of part in the request for sending chat message.");
+    }
+    if (!hasUserContent && !hasFunctionContent) {
+        throw new GoogleGenerativeAIError("No content is provided for sending chat message.");
+    }
+    if (hasUserContent) {
+        return userContent;
+    }
+    return functionContent;
+}
+function formatCountTokensInput(params, modelParams) {
+    var _a;
+    let formattedGenerateContentRequest = {
+        model: modelParams === null || modelParams === void 0 ? void 0 : modelParams.model,
+        generationConfig: modelParams === null || modelParams === void 0 ? void 0 : modelParams.generationConfig,
+        safetySettings: modelParams === null || modelParams === void 0 ? void 0 : modelParams.safetySettings,
+        tools: modelParams === null || modelParams === void 0 ? void 0 : modelParams.tools,
+        toolConfig: modelParams === null || modelParams === void 0 ? void 0 : modelParams.toolConfig,
+        systemInstruction: modelParams === null || modelParams === void 0 ? void 0 : modelParams.systemInstruction,
+        cachedContent: (_a = modelParams === null || modelParams === void 0 ? void 0 : modelParams.cachedContent) === null || _a === void 0 ? void 0 : _a.name,
+        contents: [],
+    };
+    const containsGenerateContentRequest = params.generateContentRequest != null;
+    if (params.contents) {
+        if (containsGenerateContentRequest) {
+            throw new GoogleGenerativeAIRequestInputError("CountTokensRequest must have one of contents or generateContentRequest, not both.");
+        }
+        formattedGenerateContentRequest.contents = params.contents;
+    }
+    else if (containsGenerateContentRequest) {
+        formattedGenerateContentRequest = Object.assign(Object.assign({}, formattedGenerateContentRequest), params.generateContentRequest);
+    }
+    else {
+        // Array or string
+        const content = formatNewContent(params);
+        formattedGenerateContentRequest.contents = [content];
+    }
+    return { generateContentRequest: formattedGenerateContentRequest };
+}
+function formatGenerateContentInput(params) {
+    let formattedRequest;
+    if (params.contents) {
+        formattedRequest = params;
+    }
+    else {
+        // Array or string
+        const content = formatNewContent(params);
+        formattedRequest = { contents: [content] };
+    }
+    if (params.systemInstruction) {
+        formattedRequest.systemInstruction = formatSystemInstruction(params.systemInstruction);
+    }
+    return formattedRequest;
+}
+function formatEmbedContentInput(params) {
+    if (typeof params === "string" || Array.isArray(params)) {
+        const content = formatNewContent(params);
+        return { content };
+    }
+    return params;
+}
+
+/**
+ * @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.
+ */
+// https://ai.google.dev/api/rest/v1beta/Content#part
+const VALID_PART_FIELDS = [
+    "text",
+    "inlineData",
+    "functionCall",
+    "functionResponse",
+    "executableCode",
+    "codeExecutionResult",
+];
+const VALID_PARTS_PER_ROLE = {
+    user: ["text", "inlineData"],
+    function: ["functionResponse"],
+    model: ["text", "functionCall", "executableCode", "codeExecutionResult"],
+    // System instructions shouldn't be in history anyway.
+    system: ["text"],
+};
+function validateChatHistory(history) {
+    let prevContent = false;
+    for (const currContent of history) {
+        const { role, parts } = currContent;
+        if (!prevContent && role !== "user") {
+            throw new GoogleGenerativeAIError(`First content should be with role 'user', got ${role}`);
+        }
+        if (!POSSIBLE_ROLES.includes(role)) {
+            throw new GoogleGenerativeAIError(`Each item should include role field. Got ${role} but valid roles are: ${JSON.stringify(POSSIBLE_ROLES)}`);
+        }
+        if (!Array.isArray(parts)) {
+            throw new GoogleGenerativeAIError("Content should have 'parts' property with an array of Parts");
+        }
+        if (parts.length === 0) {
+            throw new GoogleGenerativeAIError("Each Content should have at least one part");
+        }
+        const countFields = {
+            text: 0,
+            inlineData: 0,
+            functionCall: 0,
+            functionResponse: 0,
+            fileData: 0,
+            executableCode: 0,
+            codeExecutionResult: 0,
+        };
+        for (const part of parts) {
+            for (const key of VALID_PART_FIELDS) {
+                if (key in part) {
+                    countFields[key] += 1;
+                }
+            }
+        }
+        const validParts = VALID_PARTS_PER_ROLE[role];
+        for (const key of VALID_PART_FIELDS) {
+            if (!validParts.includes(key) && countFields[key] > 0) {
+                throw new GoogleGenerativeAIError(`Content with role '${role}' can't contain '${key}' part`);
+            }
+        }
+        prevContent = true;
+    }
+}
+/**
+ * Returns true if the response is valid (could be appended to the history), flase otherwise.
+ */
+function isValidResponse(response) {
+    var _a;
+    if (response.candidates === undefined || response.candidates.length === 0) {
+        return false;
+    }
+    const content = (_a = response.candidates[0]) === null || _a === void 0 ? void 0 : _a.content;
+    if (content === undefined) {
+        return false;
+    }
+    if (content.parts === undefined || content.parts.length === 0) {
+        return false;
+    }
+    for (const part of content.parts) {
+        if (part === undefined || Object.keys(part).length === 0) {
+            return false;
+        }
+        if (part.text !== undefined && part.text === "") {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @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.
+ */
+/**
+ * Do not log a message for this error.
+ */
+const SILENT_ERROR = "SILENT_ERROR";
+/**
+ * ChatSession class that enables sending chat messages and stores
+ * history of sent and received messages so far.
+ *
+ * @public
+ */
+class ChatSession {
+    constructor(apiKey, model, params, _requestOptions = {}) {
+        this.model = model;
+        this.params = params;
+        this._requestOptions = _requestOptions;
+        this._history = [];
+        this._sendPromise = Promise.resolve();
+        this._apiKey = apiKey;
+        if (params === null || params === void 0 ? void 0 : params.history) {
+            validateChatHistory(params.history);
+            this._history = params.history;
+        }
+    }
+    /**
+     * 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.
+     */
+    async getHistory() {
+        await this._sendPromise;
+        return this._history;
+    }
+    /**
+     * 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 }.
+     */
+    async sendMessage(request, requestOptions = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        await this._sendPromise;
+        const newContent = formatNewContent(request);
+        const generateContentRequest = {
+            safetySettings: (_a = this.params) === null || _a === void 0 ? void 0 : _a.safetySettings,
+            generationConfig: (_b = this.params) === null || _b === void 0 ? void 0 : _b.generationConfig,
+            tools: (_c = this.params) === null || _c === void 0 ? void 0 : _c.tools,
+            toolConfig: (_d = this.params) === null || _d === void 0 ? void 0 : _d.toolConfig,
+            systemInstruction: (_e = this.params) === null || _e === void 0 ? void 0 : _e.systemInstruction,
+            cachedContent: (_f = this.params) === null || _f === void 0 ? void 0 : _f.cachedContent,
+            contents: [...this._history, newContent],
+        };
+        const chatSessionRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        let finalResult;
+        // Add onto the chain.
+        this._sendPromise = this._sendPromise
+            .then(() => generateContent(this._apiKey, this.model, generateContentRequest, chatSessionRequestOptions))
+            .then((result) => {
+            var _a;
+            if (isValidResponse(result.response)) {
+                this._history.push(newContent);
+                const responseContent = Object.assign({ parts: [], 
+                    // Response seems to come back without a role set.
+                    role: "model" }, (_a = result.response.candidates) === null || _a === void 0 ? void 0 : _a[0].content);
+                this._history.push(responseContent);
+            }
+            else {
+                const blockErrorMessage = formatBlockErrorMessage(result.response);
+                if (blockErrorMessage) {
+                    console.warn(`sendMessage() was unsuccessful. ${blockErrorMessage}. Inspect response object for details.`);
+                }
+            }
+            finalResult = result;
+        })
+            .catch((e) => {
+            // Resets _sendPromise to avoid subsequent calls failing and throw error.
+            this._sendPromise = Promise.resolve();
+            throw e;
+        });
+        await this._sendPromise;
+        return finalResult;
+    }
+    /**
+     * 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 }.
+     */
+    async sendMessageStream(request, requestOptions = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        await this._sendPromise;
+        const newContent = formatNewContent(request);
+        const generateContentRequest = {
+            safetySettings: (_a = this.params) === null || _a === void 0 ? void 0 : _a.safetySettings,
+            generationConfig: (_b = this.params) === null || _b === void 0 ? void 0 : _b.generationConfig,
+            tools: (_c = this.params) === null || _c === void 0 ? void 0 : _c.tools,
+            toolConfig: (_d = this.params) === null || _d === void 0 ? void 0 : _d.toolConfig,
+            systemInstruction: (_e = this.params) === null || _e === void 0 ? void 0 : _e.systemInstruction,
+            cachedContent: (_f = this.params) === null || _f === void 0 ? void 0 : _f.cachedContent,
+            contents: [...this._history, newContent],
+        };
+        const chatSessionRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        const streamPromise = generateContentStream(this._apiKey, this.model, generateContentRequest, chatSessionRequestOptions);
+        // Add onto the chain.
+        this._sendPromise = this._sendPromise
+            .then(() => streamPromise)
+            // This must be handled to avoid unhandled rejection, but jump
+            // to the final catch block with a label to not log this error.
+            .catch((_ignored) => {
+            throw new Error(SILENT_ERROR);
+        })
+            .then((streamResult) => streamResult.response)
+            .then((response) => {
+            if (isValidResponse(response)) {
+                this._history.push(newContent);
+                const responseContent = Object.assign({}, response.candidates[0].content);
+                // Response seems to come back without a role set.
+                if (!responseContent.role) {
+                    responseContent.role = "model";
+                }
+                this._history.push(responseContent);
+            }
+            else {
+                const blockErrorMessage = formatBlockErrorMessage(response);
+                if (blockErrorMessage) {
+                    console.warn(`sendMessageStream() was unsuccessful. ${blockErrorMessage}. Inspect response object for details.`);
+                }
+            }
+        })
+            .catch((e) => {
+            // Errors in streamPromise are already catchable by the user as
+            // streamPromise is returned.
+            // Avoid duplicating the error message in logs.
+            if (e.message !== SILENT_ERROR) {
+                // Users do not have access to _sendPromise to catch errors
+                // downstream from streamPromise, so they should not throw.
+                console.error(e);
+            }
+        });
+        return streamPromise;
+    }
+}
+
+/**
+ * @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.
+ */
+async function countTokens(apiKey, model, params, singleRequestOptions) {
+    const response = await makeModelRequest(model, Task.COUNT_TOKENS, apiKey, false, JSON.stringify(params), singleRequestOptions);
+    return response.json();
+}
+
+/**
+ * @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.
+ */
+async function embedContent(apiKey, model, params, requestOptions) {
+    const response = await makeModelRequest(model, Task.EMBED_CONTENT, apiKey, false, JSON.stringify(params), requestOptions);
+    return response.json();
+}
+async function batchEmbedContents(apiKey, model, params, requestOptions) {
+    const requestsWithModel = params.requests.map((request) => {
+        return Object.assign(Object.assign({}, request), { model });
+    });
+    const response = await makeModelRequest(model, Task.BATCH_EMBED_CONTENTS, apiKey, false, JSON.stringify({ requests: requestsWithModel }), requestOptions);
+    return response.json();
+}
+
+/**
+ * @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 generative model APIs.
+ * @public
+ */
+class GenerativeModel {
+    constructor(apiKey, modelParams, _requestOptions = {}) {
+        this.apiKey = apiKey;
+        this._requestOptions = _requestOptions;
+        if (modelParams.model.includes("/")) {
+            // Models may be named "models/model-name" or "tunedModels/model-name"
+            this.model = modelParams.model;
+        }
+        else {
+            // If path is not included, assume it's a non-tuned model.
+            this.model = `models/${modelParams.model}`;
+        }
+        this.generationConfig = modelParams.generationConfig || {};
+        this.safetySettings = modelParams.safetySettings || [];
+        this.tools = modelParams.tools;
+        this.toolConfig = modelParams.toolConfig;
+        this.systemInstruction = formatSystemInstruction(modelParams.systemInstruction);
+        this.cachedContent = modelParams.cachedContent;
+    }
+    /**
+     * 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 }.
+     */
+    async generateContent(request, requestOptions = {}) {
+        var _a;
+        const formattedParams = formatGenerateContentInput(request);
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return generateContent(this.apiKey, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, cachedContent: (_a = this.cachedContent) === null || _a === void 0 ? void 0 : _a.name }, formattedParams), generativeModelRequestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async generateContentStream(request, requestOptions = {}) {
+        var _a;
+        const formattedParams = formatGenerateContentInput(request);
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return generateContentStream(this.apiKey, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, cachedContent: (_a = this.cachedContent) === null || _a === void 0 ? void 0 : _a.name }, formattedParams), generativeModelRequestOptions);
+    }
+    /**
+     * Gets a new {@link ChatSession} instance which can be used for
+     * multi-turn chats.
+     */
+    startChat(startChatParams) {
+        var _a;
+        return new ChatSession(this.apiKey, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, cachedContent: (_a = this.cachedContent) === null || _a === void 0 ? void 0 : _a.name }, startChatParams), this._requestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async countTokens(request, requestOptions = {}) {
+        const formattedParams = formatCountTokensInput(request, {
+            model: this.model,
+            generationConfig: this.generationConfig,
+            safetySettings: this.safetySettings,
+            tools: this.tools,
+            toolConfig: this.toolConfig,
+            systemInstruction: this.systemInstruction,
+            cachedContent: this.cachedContent,
+        });
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return countTokens(this.apiKey, this.model, formattedParams, generativeModelRequestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async embedContent(request, requestOptions = {}) {
+        const formattedParams = formatEmbedContentInput(request);
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return embedContent(this.apiKey, this.model, formattedParams, generativeModelRequestOptions);
+    }
+    /**
+     * 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 }.
+     */
+    async batchEmbedContents(batchEmbedContentRequest, requestOptions = {}) {
+        const generativeModelRequestOptions = Object.assign(Object.assign({}, this._requestOptions), requestOptions);
+        return batchEmbedContents(this.apiKey, this.model, batchEmbedContentRequest, generativeModelRequestOptions);
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * Top-level class for this SDK
+ * @public
+ */
+class GoogleGenerativeAI {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * Gets a {@link GenerativeModel} instance for the provided model name.
+     */
+    getGenerativeModel(modelParams, requestOptions) {
+        if (!modelParams.model) {
+            throw new GoogleGenerativeAIError(`Must provide a model name. ` +
+                `Example: genai.getGenerativeModel({ model: 'my-model-name' })`);
+        }
+        return new GenerativeModel(this.apiKey, modelParams, requestOptions);
+    }
+    /**
+     * Creates a {@link GenerativeModel} instance from provided content cache.
+     */
+    getGenerativeModelFromCachedContent(cachedContent, modelParams, requestOptions) {
+        if (!cachedContent.name) {
+            throw new GoogleGenerativeAIRequestInputError("Cached content must contain a `name` field.");
+        }
+        if (!cachedContent.model) {
+            throw new GoogleGenerativeAIRequestInputError("Cached content must contain a `model` field.");
+        }
+        /**
+         * Not checking tools and toolConfig for now as it would require a deep
+         * equality comparison and isn't likely to be a common case.
+         */
+        const disallowedDuplicates = ["model", "systemInstruction"];
+        for (const key of disallowedDuplicates) {
+            if ((modelParams === null || modelParams === void 0 ? void 0 : modelParams[key]) &&
+                cachedContent[key] &&
+                (modelParams === null || modelParams === void 0 ? void 0 : modelParams[key]) !== cachedContent[key]) {
+                if (key === "model") {
+                    const modelParamsComp = modelParams.model.startsWith("models/")
+                        ? modelParams.model.replace("models/", "")
+                        : modelParams.model;
+                    const cachedContentComp = cachedContent.model.startsWith("models/")
+                        ? cachedContent.model.replace("models/", "")
+                        : cachedContent.model;
+                    if (modelParamsComp === cachedContentComp) {
+                        continue;
+                    }
+                }
+                throw new GoogleGenerativeAIRequestInputError(`Different value for "${key}" specified in modelParams` +
+                    ` (${modelParams[key]}) and cachedContent (${cachedContent[key]})`);
+            }
+        }
+        const modelParamsFromCache = Object.assign(Object.assign({}, modelParams), { model: cachedContent.model, tools: cachedContent.tools, toolConfig: cachedContent.toolConfig, systemInstruction: cachedContent.systemInstruction, cachedContent });
+        return new GenerativeModel(this.apiKey, modelParamsFromCache, requestOptions);
+    }
+}
+
+export { BlockReason, ChatSession, DynamicRetrievalMode, ExecutableCodeLanguage, FinishReason, FunctionCallingMode, GenerativeModel, GoogleGenerativeAI, GoogleGenerativeAIAbortError, GoogleGenerativeAIError, GoogleGenerativeAIFetchError, GoogleGenerativeAIRequestInputError, GoogleGenerativeAIResponseError, HarmBlockThreshold, HarmCategory, HarmProbability, Outcome, POSSIBLE_ROLES, SchemaType, TaskType };
+//# sourceMappingURL=index.mjs.map

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

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

backend-old/node_modules/@google/generative-ai/dist/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 {};

backend-old/node_modules/@google/generative-ai/dist/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;

backend-old/node_modules/@google/generative-ai/dist/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>;

backend-old/node_modules/@google/generative-ai/dist/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 {};

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

@@ -0,0 +1,838 @@
+'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 {
+}
+/**
+ * Error thrown when a request is aborted, either due to a timeout or
+ * intentional cancellation by the user.
+ * @public
+ */
+class GoogleGenerativeAIAbortError 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.24.1";
+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 (err.name === "AbortError") {
+        err = new GoogleGenerativeAIAbortError(`Request aborted when fetching ${url.toString()}: ${e.message}`);
+        err.stack = e.stack;
+    }
+    else 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) {
+    var _a;
+    const headers = new Headers();
+    headers.append("x-goog-api-client", getClientHeaders(url.requestOptions));
+    headers.append("x-goog-api-key", url.apiKey);
+    let customHeaders = (_a = url.requestOptions) === null || _a === void 0 ? void 0 : _a.customHeaders;
+    if (customHeaders) {
+        if (!(customHeaders instanceof Headers)) {
+            try {
+                customHeaders = new Headers(customHeaders);
+            }
+            catch (e) {
+                throw new GoogleGenerativeAIRequestInputError(`unable to convert customHeaders value ${JSON.stringify(customHeaders)} to Headers: ${e.message}`);
+            }
+        }
+        for (const [headerName, headerValue] of customHeaders.entries()) {
+            if (headerName === "x-goog-api-key") {
+                throw new GoogleGenerativeAIRequestInputError(`Cannot set reserved header name ${headerName}`);
+            }
+            else if (headerName === "x-goog-api-client") {
+                throw new GoogleGenerativeAIRequestInputError(`Header name ${headerName} can only be set using the apiClient field`);
+            }
+            headers.append(headerName, headerValue);
+        }
+    }
+    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(fileData, fileMetadata) {
+        const file = fileData instanceof Buffer ? fileData : fs.readFileSync(fileData);
+        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.");
+            }
+            newCachedContent.ttl = createOptions.ttlSeconds.toString() + "s";
+            delete newCachedContent.ttlSeconds;
+        }
+        if (createOptions.systemInstruction) {
+            newCachedContent.systemInstruction = formatSystemInstruction(createOptions.systemInstruction);
+        }
+        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["HARM_CATEGORY_CIVIC_INTEGRITY"] = "HARM_CATEGORY_CIVIC_INTEGRITY";
+})(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";
+    // Token generation stopped because the content contains forbidden terms.
+    FinishReason["BLOCKLIST"] = "BLOCKLIST";
+    // Token generation stopped for potentially containing prohibited content.
+    FinishReason["PROHIBITED_CONTENT"] = "PROHIBITED_CONTENT";
+    // Token generation stopped because the content potentially contains Sensitive Personally Identifiable Information (SPII).
+    FinishReason["SPII"] = "SPII";
+    // The function call generated by the model is invalid.
+    FinishReason["MALFORMED_FUNCTION_CALL"] = "MALFORMED_FUNCTION_CALL";
+    // 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

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

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

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

@@ -0,0 +1,835 @@
+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 {
+}
+/**
+ * Error thrown when a request is aborted, either due to a timeout or
+ * intentional cancellation by the user.
+ * @public
+ */
+class GoogleGenerativeAIAbortError 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.24.1";
+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 (err.name === "AbortError") {
+        err = new GoogleGenerativeAIAbortError(`Request aborted when fetching ${url.toString()}: ${e.message}`);
+        err.stack = e.stack;
+    }
+    else 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) {
+    var _a;
+    const headers = new Headers();
+    headers.append("x-goog-api-client", getClientHeaders(url.requestOptions));
+    headers.append("x-goog-api-key", url.apiKey);
+    let customHeaders = (_a = url.requestOptions) === null || _a === void 0 ? void 0 : _a.customHeaders;
+    if (customHeaders) {
+        if (!(customHeaders instanceof Headers)) {
+            try {
+                customHeaders = new Headers(customHeaders);
+            }
+            catch (e) {
+                throw new GoogleGenerativeAIRequestInputError(`unable to convert customHeaders value ${JSON.stringify(customHeaders)} to Headers: ${e.message}`);
+            }
+        }
+        for (const [headerName, headerValue] of customHeaders.entries()) {
+            if (headerName === "x-goog-api-key") {
+                throw new GoogleGenerativeAIRequestInputError(`Cannot set reserved header name ${headerName}`);
+            }
+            else if (headerName === "x-goog-api-client") {
+                throw new GoogleGenerativeAIRequestInputError(`Header name ${headerName} can only be set using the apiClient field`);
+            }
+            headers.append(headerName, headerValue);
+        }
+    }
+    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(fileData, fileMetadata) {
+        const file = fileData instanceof Buffer ? fileData : readFileSync(fileData);
+        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.");
+            }
+            newCachedContent.ttl = createOptions.ttlSeconds.toString() + "s";
+            delete newCachedContent.ttlSeconds;
+        }
+        if (createOptions.systemInstruction) {
+            newCachedContent.systemInstruction = formatSystemInstruction(createOptions.systemInstruction);
+        }
+        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["HARM_CATEGORY_CIVIC_INTEGRITY"] = "HARM_CATEGORY_CIVIC_INTEGRITY";
+})(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";
+    // Token generation stopped because the content contains forbidden terms.
+    FinishReason["BLOCKLIST"] = "BLOCKLIST";
+    // Token generation stopped for potentially containing prohibited content.
+    FinishReason["PROHIBITED_CONTENT"] = "PROHIBITED_CONTENT";
+    // Token generation stopped because the content potentially contains Sensitive Personally Identifiable Information (SPII).
+    FinishReason["SPII"] = "SPII";
+    // The function call generated by the model is invalid.
+    FinishReason["MALFORMED_FUNCTION_CALL"] = "MALFORMED_FUNCTION_CALL";
+    // 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

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

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

backend-old/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 {};

backend-old/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;

backend-old/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>;

backend-old/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 {};

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

@@ -0,0 +1,875 @@
+/// <reference types="node" />
+
+/**
+ * Describes an array, an ordered list of values.
+ *
+ * @public
+ */
+export declare interface ArraySchema extends BaseSchema {
+    type: typeof SchemaType.ARRAY;
+    /** A schema describing the entries in the array. */
+    items: Schema;
+    /** The minimum number of items in the array. */
+    minItems?: number;
+    /** The maximum number of items in the array. */
+    maxItems?: number;
+}
+
+/**
+ * Fields common to all Schema types.
+ *
+ * @internal
+ */
+export declare interface BaseSchema {
+    /** Optional. Description of the value. */
+    description?: string;
+    /** If true, the value can be null. */
+    nullable?: boolean;
+}
+
+/**
+ * Describes a boolean, either 'true' or 'false'.
+ *
+ * @public
+ */
+export declare interface BooleanSchema extends BaseSchema {
+    type: typeof SchemaType.BOOLEAN;
+}
+
+/**
+ * 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"
+}
+
+/**
+ * Describes a string enum
+ *
+ * @public
+ */
+export declare interface EnumStringSchema extends BaseSchema {
+    type: typeof SchemaType.STRING;
+    format: "enum";
+    /** Possible values for this enum */
+    enum: string[];
+}
+
+/**
+ * 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 type FunctionDeclarationSchemaProperty = 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(fileData: string | Buffer, 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;
+}
+
+/**
+ * Describes a JSON-encodable integer.
+ *
+ * @public
+ */
+export declare interface IntegerSchema extends BaseSchema {
+    type: typeof SchemaType.INTEGER;
+    /** Optional. The format of the number. */
+    format?: "int32" | "int64";
+}
+
+/**
+ * @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;
+}
+
+/**
+ * Describes a JSON-encodable floating point number.
+ *
+ * @public
+ */
+export declare interface NumberSchema extends BaseSchema {
+    type: typeof SchemaType.NUMBER;
+    /** Optional. The format of the number. */
+    format?: "float" | "double";
+}
+
+/**
+ * Describes a JSON object, a mapping of specific keys to values.
+ *
+ * @public
+ */
+export declare interface ObjectSchema extends BaseSchema {
+    type: typeof SchemaType.OBJECT;
+    /** Describes the properties of the JSON object. Must not be empty. */
+    properties: {
+        [k: string]: Schema;
+    };
+    /**
+     * A list of keys declared in the properties object.
+     * Required properties will always be present in the generated object.
+     */
+    required?: 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 type ResponseSchema = 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 type Schema = StringSchema | NumberSchema | IntegerSchema | BooleanSchema | ArraySchema | ObjectSchema;
+
+/**
+ * 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"
+}
+
+/**
+ * Describes a simple string schema, with or without format
+ *
+ * @public
+ */
+export declare interface SimpleStringSchema extends BaseSchema {
+    type: typeof SchemaType.STRING;
+    format?: "date-time" | undefined;
+    enum?: never;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Describes a string.
+ *
+ * @public
+ */
+export declare type StringSchema = SimpleStringSchema | EnumStringSchema;
+
+/**
+ * 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 { }

backend-old/node_modules/@google/generative-ai/dist/server/src/errors.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 { 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 {
+}
+/**
+ * Error thrown when a request is aborted, either due to a timeout or
+ * intentional cancellation by the user.
+ * @public
+ */
+export declare class GoogleGenerativeAIAbortError extends GoogleGenerativeAIError {
+}

backend-old/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;
+}

backend-old/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";

backend-old/node_modules/@google/generative-ai/dist/server/src/methods/chat-session-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, GenerateContentResponse } from "../../types";
+export declare function validateChatHistory(history: Content[]): void;
+/**
+ * Returns true if the response is valid (could be appended to the history), flase otherwise.
+ */
+export declare function isValidResponse(response: GenerateContentResponse): boolean;

backend-old/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>;
+}

backend-old/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>;

backend-old/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>;

backend-old/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>;

backend-old/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>;
+}

backend-old/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;

backend-old/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>;

backend-old/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;

backend-old/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;

backend-old/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>;
+}

backend-old/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"
+}

backend-old/node_modules/@google/generative-ai/dist/server/src/server/file-manager.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.
+ */
+/// <reference types="node" />
+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(fileData: string | Buffer, 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;

backend-old/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";

backend-old/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>;

backend-old/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"
+}

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

@@ -0,0 +1,120 @@
+/**
+ * @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",
+    HARM_CATEGORY_CIVIC_INTEGRITY = "HARM_CATEGORY_CIVIC_INTEGRITY"
+}
+/**
+ * Threshold above which a prompt or candidate will be blocked.
+ * @public
+ */
+export declare enum HarmBlockThreshold {
+    /** Threshold is unspecified. */
+    HARM_BLOCK_THRESHOLD_UNSPECIFIED = "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+    /** Content with NEGLIGIBLE will be allowed. */
+    BLOCK_LOW_AND_ABOVE = "BLOCK_LOW_AND_ABOVE",
+    /** Content with NEGLIGIBLE and LOW will be allowed. */
+    BLOCK_MEDIUM_AND_ABOVE = "BLOCK_MEDIUM_AND_ABOVE",
+    /** Content with NEGLIGIBLE, LOW, and MEDIUM will be allowed. */
+    BLOCK_ONLY_HIGH = "BLOCK_ONLY_HIGH",
+    /** All content will be allowed. */
+    BLOCK_NONE = "BLOCK_NONE"
+}
+/**
+ * Probability that a prompt or candidate matches a harm category.
+ * @public
+ */
+export declare enum HarmProbability {
+    /** Probability is unspecified. */
+    HARM_PROBABILITY_UNSPECIFIED = "HARM_PROBABILITY_UNSPECIFIED",
+    /** Content has a negligible chance of being unsafe. */
+    NEGLIGIBLE = "NEGLIGIBLE",
+    /** Content has a low chance of being unsafe. */
+    LOW = "LOW",
+    /** Content has a medium chance of being unsafe. */
+    MEDIUM = "MEDIUM",
+    /** Content has a high chance of being unsafe. */
+    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",
+    BLOCKLIST = "BLOCKLIST",
+    PROHIBITED_CONTENT = "PROHIBITED_CONTENT",
+    SPII = "SPII",
+    MALFORMED_FUNCTION_CALL = "MALFORMED_FUNCTION_CALL",
+    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"
+}

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

@@ -0,0 +1,241 @@
+/**
+ * @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 type Schema = StringSchema | NumberSchema | IntegerSchema | BooleanSchema | ArraySchema | ObjectSchema;
+/**
+ * Fields common to all Schema types.
+ *
+ * @internal
+ */
+export interface BaseSchema {
+    /** Optional. Description of the value. */
+    description?: string;
+    /** If true, the value can be null. */
+    nullable?: boolean;
+}
+/**
+ * Describes a JSON-encodable floating point number.
+ *
+ * @public
+ */
+export interface NumberSchema extends BaseSchema {
+    type: typeof SchemaType.NUMBER;
+    /** Optional. The format of the number. */
+    format?: "float" | "double";
+}
+/**
+ * Describes a JSON-encodable integer.
+ *
+ * @public
+ */
+export interface IntegerSchema extends BaseSchema {
+    type: typeof SchemaType.INTEGER;
+    /** Optional. The format of the number. */
+    format?: "int32" | "int64";
+}
+/**
+ * Describes a string.
+ *
+ * @public
+ */
+export type StringSchema = SimpleStringSchema | EnumStringSchema;
+/**
+ * Describes a simple string schema, with or without format
+ *
+ * @public
+ */
+export interface SimpleStringSchema extends BaseSchema {
+    type: typeof SchemaType.STRING;
+    format?: "date-time" | undefined;
+    enum?: never;
+}
+/**
+ * Describes a string enum
+ *
+ * @public
+ */
+export interface EnumStringSchema extends BaseSchema {
+    type: typeof SchemaType.STRING;
+    format: "enum";
+    /** Possible values for this enum */
+    enum: string[];
+}
+/**
+ * Describes a boolean, either 'true' or 'false'.
+ *
+ * @public
+ */
+export interface BooleanSchema extends BaseSchema {
+    type: typeof SchemaType.BOOLEAN;
+}
+/**
+ * Describes an array, an ordered list of values.
+ *
+ * @public
+ */
+export interface ArraySchema extends BaseSchema {
+    type: typeof SchemaType.ARRAY;
+    /** A schema describing the entries in the array. */
+    items: Schema;
+    /** The minimum number of items in the array. */
+    minItems?: number;
+    /** The maximum number of items in the array. */
+    maxItems?: number;
+}
+/**
+ * Describes a JSON object, a mapping of specific keys to values.
+ *
+ * @public
+ */
+export interface ObjectSchema extends BaseSchema {
+    type: typeof SchemaType.OBJECT;
+    /** Describes the properties of the JSON object. Must not be empty. */
+    properties: {
+        [k: string]: Schema;
+    };
+    /**
+     * A list of keys declared in the properties object.
+     * Required properties will always be present in the generated object.
+     */
+    required?: string[];
+}
+/**
+ * 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 type FunctionDeclarationSchemaProperty = Schema;
+/**
+ * Schema passed to `GenerationConfig.responseSchema`
+ * @public
+ */
+export type ResponseSchema = 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[];
+}