viho-llm 0.1.3 → 0.1.5

package/index.js

@@ -1,68 +1,37 @@
 'use strict';
 
 var genai = require('@google/genai');
+var mime = require('mime-types');
 var qiao_log_js = require('qiao.log.js');
 
 // gemini
-const logger = qiao_log_js.Logger('viho-llm');
+const logger$2 = qiao_log_js.Logger('gemini-util.js');
 
 /**
- * Gemini
- * @param {*} options
+ * chat
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} chatOptions
  * @returns
  */
-const Gemini = (options) => {
-  const methodName = 'Gemini';
+const chat = async (client, modelName, chatOptions) => {
+  const methodName = 'chat';
 
   // check
-  if (!options) {
-    logger.info(methodName, 'need options');
+  if (!client) {
+    logger$2.error(methodName, 'need client');
     return;
   }
-  if (!options.apiKey) {
-    logger.info(methodName, 'need options.apiKey');
+  if (!modelName) {
+    logger$2.error(methodName, 'need modelName');
     return;
   }
-  if (!options.modelName) {
-    logger.info(methodName, 'need options.modelName');
-    return;
-  }
-
-  // gemini
-  const gemini = {};
-  gemini.client = new genai.GoogleGenAI({
-    vertexai: true,
-    apiKey: options.apiKey,
-  });
-
-  // chat
-  gemini.chat = async (chatOptions) => {
-    return await chat(gemini.client, options.modelName, chatOptions);
-  };
-  gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
-    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
-  };
-
-  // cache
-  gemini.cacheAdd = async (systemPrompt, content) => {
-    return await cacheAdd(gemini.client, options.modelName, systemPrompt, content);
-  };
-
-  // r
-  return gemini;
-};
-
-// chat
-async function chat(client, modelName, chatOptions) {
-  const methodName = 'Gemini - chat';
-
-  // check
   if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
+    logger$2.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
+    logger$2.error(methodName, 'need chatOptions.contents');
     return;
   }
 
@@ -72,26 +41,46 @@ async function chat(client, modelName, chatOptions) {
       contents: chatOptions.contents,
     });
     if (!response || !response.text) {
-      logger.error(methodName, 'invalid response');
+      logger$2.error(methodName, 'invalid response');
       return;
     }
 
     return response.text;
   } catch (error) {
-    logger.error(methodName, 'error', error);
+    logger$2.error(methodName, 'error', error);
   }
-}
+};
 
-async function chatWithStreaming(client, modelName, chatOptions, callbackOptions) {
-  const methodName = 'Gemini - chatWithStreaming';
+/**
+ * chatWithStreaming
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} chatOptions
+ * @param {*} callbackOptions
+ * @returns
+ */
+const chatWithStreaming = async (client, modelName, chatOptions, callbackOptions) => {
+  const methodName = 'chatWithStreaming';
 
   // check
+  if (!client) {
+    logger$2.error(methodName, 'need client');
+    return;
+  }
+  if (!modelName) {
+    logger$2.error(methodName, 'need modelName');
+    return;
+  }
   if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
+    logger$2.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
+    logger$2.error(methodName, 'need chatOptions.contents');
+    return;
+  }
+  if (!callbackOptions) {
+    logger$2.error(methodName, 'need callbackOptions');
     return;
   }
 
@@ -129,35 +118,159 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
   } catch (error) {
     if (errorCallback) errorCallback(error);
   }
-}
+};
 
-// cache add
-async function cacheAdd(client, modelName, systemPrompt, content) {
-  const methodName = 'Gemini - cacheAdd';
+/**
+ * cacheAdd
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} cacheOptions
+ * @returns
+ */
+const cacheAdd = async (client, modelName, cacheOptions) => {
+  const methodName = 'cacheAdd';
 
   // check
-  if (!systemPrompt) {
-    logger.info(methodName, 'need systemPrompt');
+  if (!cacheOptions) {
+    logger$2.error(methodName, 'need cacheOptions');
+    return;
+  }
+  if (!cacheOptions.gsPath) {
+    logger$2.error(methodName, 'need cacheOptions.gsPath');
+    return;
+  }
+  if (!cacheOptions.systemPrompt) {
+    logger$2.error(methodName, 'need cacheOptions.systemPrompt');
     return;
   }
-  if (!content) {
-    logger.info(methodName, 'need content');
+  if (!cacheOptions.cacheName) {
+    logger$2.error(methodName, 'need cacheOptions.cacheName');
+    return;
+  }
+  if (!cacheOptions.cacheTTL) {
+    logger$2.error(methodName, 'need cacheOptions.cacheTTL');
     return;
   }
 
+  // const
+  const mimeType = mime.lookup(cacheOptions.gsPath);
+  logger$2.info(methodName, 'cacheOptions', cacheOptions);
+  logger$2.info(methodName, 'mimeType', mimeType);
+
   try {
+    // cache add
     const cache = await client.caches.create({
       model: modelName,
       config: {
-        systemInstruction: systemPrompt,
-        contents: genai.createUserContent(content),
+        contents: genai.createUserContent(genai.createPartFromUri(cacheOptions.gsPath, mimeType)),
+        systemInstruction: cacheOptions.systemPrompt,
+        displayName: cacheOptions.cacheName,
+        ttl: cacheOptions.cacheTTL,
       },
     });
 
     return cache;
   } catch (error) {
-    logger.error(methodName, 'error', error);
+    logger$2.error(methodName, 'error', error);
+  }
+};
+
+// gemini
+const logger$1 = qiao_log_js.Logger('gemini-api.js');
+
+/**
+ * GeminiAPI
+ * @param {*} options
+ * @returns
+ */
+const GeminiAPI = (options) => {
+  const methodName = 'GeminiAPI';
+
+  // check
+  if (!options) {
+    logger$1.error(methodName, 'need options');
+    return;
   }
-}
+  if (!options.apiKey) {
+    logger$1.error(methodName, 'need options.apiKey');
+    return;
+  }
+  if (!options.modelName) {
+    logger$1.error(methodName, 'need options.modelName');
+    return;
+  }
+
+  // gemini
+  const gemini = {};
+  gemini.client = new genai.GoogleGenAI({
+    apiKey: options.apiKey,
+  });
+
+  // chat
+  gemini.chat = async (chatOptions) => {
+    return await chat(gemini.client, options.modelName, chatOptions);
+  };
+  gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
+    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
+  };
+
+  // r
+  return gemini;
+};
+
+// gemini
+const logger = qiao_log_js.Logger('viho-llm');
+
+/**
+ * GeminiVertex
+ * @param {*} options
+ * @returns
+ */
+const GeminiVertex = (options) => {
+  const methodName = 'GeminiVertex';
+
+  // check
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.projectId) {
+    logger.error(methodName, 'need options.projectId');
+    return;
+  }
+  if (!options.location) {
+    logger.error(methodName, 'need options.location');
+    return;
+  }
+  if (!options.modelName) {
+    logger.error(methodName, 'need options.modelName');
+    return;
+  }
+
+  // gemini
+  const gemini = {};
+  gemini.client = new genai.GoogleGenAI({
+    vertexai: true,
+    project: options.projectId,
+    location: options.location,
+  });
+
+  // chat
+  gemini.chat = async (chatOptions) => {
+    return await chat(gemini.client, options.modelName, chatOptions);
+  };
+  gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
+    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
+  };
+
+  // cache
+  gemini.cacheAdd = async (cacheOptions) => {
+    return await cacheAdd(gemini.client, options.modelName, cacheOptions);
+  };
+
+  // r
+  return gemini;
+};
 
-exports.Gemini = Gemini;
+exports.GeminiAPI = GeminiAPI;
+exports.GeminiVertex = GeminiVertex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viho-llm",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions",
   "keywords": [
     "llm",
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "@google/genai": "^1.34.0",
+    "mime-types": "^2.1.35",
     "qiao.log.js": "^3.7.5"
   },
   "nx": {
@@ -60,5 +61,5 @@
       }
     }
   },
-  "gitHead": "89ff0ac8912f04b2c8957dedb05d0c8ad058219f"
+  "gitHead": "b37b523239fe354f991017387e95a6314e994981"
 }

package/src/index.js

@@ -1 +1,2 @@
-export * from './gemini.js';
+export * from './models/gemini-api.js';
+export * from './models/gemini-vertex.js';

package/src/models/gemini-api.js

@@ -0,0 +1,49 @@
+// gemini
+import { GoogleGenAI } from '@google/genai';
+
+// util
+import { chat, chatWithStreaming } from './gemini-util.js';
+
+// Logger
+import { Logger } from 'qiao.log.js';
+const logger = Logger('gemini-api.js');
+
+/**
+ * GeminiAPI
+ * @param {*} options
+ * @returns
+ */
+export const GeminiAPI = (options) => {
+  const methodName = 'GeminiAPI';
+
+  // check
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.apiKey) {
+    logger.error(methodName, 'need options.apiKey');
+    return;
+  }
+  if (!options.modelName) {
+    logger.error(methodName, 'need options.modelName');
+    return;
+  }
+
+  // gemini
+  const gemini = {};
+  gemini.client = new GoogleGenAI({
+    apiKey: options.apiKey,
+  });
+
+  // chat
+  gemini.chat = async (chatOptions) => {
+    return await chat(gemini.client, options.modelName, chatOptions);
+  };
+  gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
+    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
+  };
+
+  // r
+  return gemini;
+};

package/src/models/gemini-util.js

@@ -0,0 +1,177 @@
+// gemini
+import { createUserContent, createPartFromUri } from '@google/genai';
+
+// mime
+import mime from 'mime-types';
+
+// Logger
+import { Logger } from 'qiao.log.js';
+const logger = Logger('gemini-util.js');
+
+/**
+ * chat
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} chatOptions
+ * @returns
+ */
+export const chat = async (client, modelName, chatOptions) => {
+  const methodName = 'chat';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!modelName) {
+    logger.error(methodName, 'need modelName');
+    return;
+  }
+  if (!chatOptions) {
+    logger.error(methodName, 'need chatOptions');
+    return;
+  }
+  if (!chatOptions.contents) {
+    logger.error(methodName, 'need chatOptions.contents');
+    return;
+  }
+
+  try {
+    const response = await client.models.generateContent({
+      model: modelName,
+      contents: chatOptions.contents,
+    });
+    if (!response || !response.text) {
+      logger.error(methodName, 'invalid response');
+      return;
+    }
+
+    return response.text;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+};
+
+/**
+ * chatWithStreaming
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} chatOptions
+ * @param {*} callbackOptions
+ * @returns
+ */
+export const chatWithStreaming = async (client, modelName, chatOptions, callbackOptions) => {
+  const methodName = 'chatWithStreaming';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!modelName) {
+    logger.error(methodName, 'need modelName');
+    return;
+  }
+  if (!chatOptions) {
+    logger.error(methodName, 'need chatOptions');
+    return;
+  }
+  if (!chatOptions.contents) {
+    logger.error(methodName, 'need chatOptions.contents');
+    return;
+  }
+  if (!callbackOptions) {
+    logger.error(methodName, 'need callbackOptions');
+    return;
+  }
+
+  // callback
+  const beginCallback = callbackOptions.beginCallback;
+  const endCallback = callbackOptions.endCallback;
+  const errorCallback = callbackOptions.errorCallback;
+  const contentCallback = callbackOptions.contentCallback;
+  const firstContentCallback = callbackOptions.firstContentCallback;
+
+  try {
+    if (beginCallback) beginCallback();
+    const response = await client.models.generateContentStream({
+      model: modelName,
+      contents: chatOptions.contents,
+    });
+
+    // go
+    let firstContent = true;
+    for await (const chunk of response) {
+      // content
+      const content = chunk.text;
+      if (content && contentCallback) {
+        if (firstContent && firstContentCallback) {
+          firstContent = false;
+          firstContentCallback();
+        }
+
+        contentCallback(content);
+      }
+    }
+
+    // end
+    if (endCallback) endCallback();
+  } catch (error) {
+    if (errorCallback) errorCallback(error);
+  }
+};
+
+/**
+ * cacheAdd
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} cacheOptions
+ * @returns
+ */
+export const cacheAdd = async (client, modelName, cacheOptions) => {
+  const methodName = 'cacheAdd';
+
+  // check
+  if (!cacheOptions) {
+    logger.error(methodName, 'need cacheOptions');
+    return;
+  }
+  if (!cacheOptions.gsPath) {
+    logger.error(methodName, 'need cacheOptions.gsPath');
+    return;
+  }
+  if (!cacheOptions.systemPrompt) {
+    logger.error(methodName, 'need cacheOptions.systemPrompt');
+    return;
+  }
+  if (!cacheOptions.cacheName) {
+    logger.error(methodName, 'need cacheOptions.cacheName');
+    return;
+  }
+  if (!cacheOptions.cacheTTL) {
+    logger.error(methodName, 'need cacheOptions.cacheTTL');
+    return;
+  }
+
+  // const
+  const mimeType = mime.lookup(cacheOptions.gsPath);
+  logger.info(methodName, 'cacheOptions', cacheOptions);
+  logger.info(methodName, 'mimeType', mimeType);
+
+  try {
+    // cache add
+    const cache = await client.caches.create({
+      model: modelName,
+      config: {
+        contents: createUserContent(createPartFromUri(cacheOptions.gsPath, mimeType)),
+        systemInstruction: cacheOptions.systemPrompt,
+        displayName: cacheOptions.cacheName,
+        ttl: cacheOptions.cacheTTL,
+      },
+    });
+
+    return cache;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+};

package/src/models/gemini-vertex.js

@@ -0,0 +1,60 @@
+// gemini
+import { GoogleGenAI } from '@google/genai';
+
+// util
+import { chat, chatWithStreaming, cacheAdd } from './gemini-util.js';
+
+// Logger
+import { Logger } from 'qiao.log.js';
+const logger = Logger('viho-llm');
+
+/**
+ * GeminiVertex
+ * @param {*} options
+ * @returns
+ */
+export const GeminiVertex = (options) => {
+  const methodName = 'GeminiVertex';
+
+  // check
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.projectId) {
+    logger.error(methodName, 'need options.projectId');
+    return;
+  }
+  if (!options.location) {
+    logger.error(methodName, 'need options.location');
+    return;
+  }
+  if (!options.modelName) {
+    logger.error(methodName, 'need options.modelName');
+    return;
+  }
+
+  // gemini
+  const gemini = {};
+  gemini.client = new GoogleGenAI({
+    vertexai: true,
+    project: options.projectId,
+    location: options.location,
+  });
+
+  // chat
+  gemini.chat = async (chatOptions) => {
+    return await chat(gemini.client, options.modelName, chatOptions);
+  };
+  gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
+    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
+  };
+
+  // cache
+  gemini.cacheAdd = async (cacheOptions) => {
+    return await cacheAdd(gemini.client, options.modelName, cacheOptions);
+  };
+
+  // r
+  return gemini;
+};

package/src/gemini.js

@@ -1,160 +0,0 @@
-// gemini
-import { GoogleGenAI, createUserContent } from '@google/genai';
-
-// Logger
-import { Logger } from 'qiao.log.js';
-const logger = Logger('viho-llm');
-
-/**
- * Gemini
- * @param {*} options
- * @returns
- */
-export const Gemini = (options) => {
-  const methodName = 'Gemini';
-
-  // check
-  if (!options) {
-    logger.info(methodName, 'need options');
-    return;
-  }
-  if (!options.apiKey) {
-    logger.info(methodName, 'need options.apiKey');
-    return;
-  }
-  if (!options.modelName) {
-    logger.info(methodName, 'need options.modelName');
-    return;
-  }
-
-  // gemini
-  const gemini = {};
-  gemini.client = new GoogleGenAI({
-    vertexai: true,
-    apiKey: options.apiKey,
-  });
-
-  // chat
-  gemini.chat = async (chatOptions) => {
-    return await chat(gemini.client, options.modelName, chatOptions);
-  };
-  gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
-    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
-  };
-
-  // cache
-  gemini.cacheAdd = async (systemPrompt, content) => {
-    return await cacheAdd(gemini.client, options.modelName, systemPrompt, content);
-  };
-
-  // r
-  return gemini;
-};
-
-// chat
-async function chat(client, modelName, chatOptions) {
-  const methodName = 'Gemini - chat';
-
-  // check
-  if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
-    return;
-  }
-  if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
-    return;
-  }
-
-  try {
-    const response = await client.models.generateContent({
-      model: modelName,
-      contents: chatOptions.contents,
-    });
-    if (!response || !response.text) {
-      logger.error(methodName, 'invalid response');
-      return;
-    }
-
-    return response.text;
-  } catch (error) {
-    logger.error(methodName, 'error', error);
-  }
-}
-
-async function chatWithStreaming(client, modelName, chatOptions, callbackOptions) {
-  const methodName = 'Gemini - chatWithStreaming';
-
-  // check
-  if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
-    return;
-  }
-  if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
-    return;
-  }
-
-  // callback
-  const beginCallback = callbackOptions.beginCallback;
-  const endCallback = callbackOptions.endCallback;
-  const errorCallback = callbackOptions.errorCallback;
-  const contentCallback = callbackOptions.contentCallback;
-  const firstContentCallback = callbackOptions.firstContentCallback;
-
-  try {
-    if (beginCallback) beginCallback();
-    const response = await client.models.generateContentStream({
-      model: modelName,
-      contents: chatOptions.contents,
-    });
-
-    // go
-    let firstContent = true;
-    for await (const chunk of response) {
-      // content
-      const content = chunk.text;
-      if (content && contentCallback) {
-        if (firstContent && firstContentCallback) {
-          firstContent = false;
-          firstContentCallback();
-        }
-
-        contentCallback(content);
-      }
-    }
-
-    // end
-    if (endCallback) endCallback();
-  } catch (error) {
-    if (errorCallback) errorCallback(error);
-  }
-}
-
-// cache add
-async function cacheAdd(client, modelName, systemPrompt, content) {
-  const methodName = 'Gemini - cacheAdd';
-
-  // check
-  if (!systemPrompt) {
-    logger.info(methodName, 'need systemPrompt');
-    return;
-  }
-  if (!content) {
-    logger.info(methodName, 'need content');
-    return;
-  }
-
-  try {
-    const cache = await client.caches.create({
-      model: modelName,
-      config: {
-        systemInstruction: systemPrompt,
-        contents: createUserContent(content),
-      },
-    });
-
-    return cache;
-  } catch (error) {
-    logger.error(methodName, 'error', error);
-  }
-}