viho-llm 0.1.4 → 0.1.5

package/index.js

@@ -5,65 +5,33 @@ 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.error(methodName, 'need options');
+  if (!client) {
+    logger$2.error(methodName, 'need client');
     return;
   }
-  if (!options.apiKey) {
-    logger.error(methodName, 'need options.apiKey');
-    return;
-  }
-  if (!options.modelName) {
-    logger.error(methodName, 'need options.modelName');
+  if (!modelName) {
+    logger$2.error(methodName, 'need 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 (cacheOptions) => {
-    return await cacheAdd(gemini.client, options.modelName, cacheOptions);
-  };
-
-  // r
-  return gemini;
-};
-
-// chat
-async function chat(client, modelName, chatOptions) {
-  const methodName = 'Gemini - chat';
-
-  // check
   if (!chatOptions) {
-    logger.error(methodName, 'need chatOptions');
+    logger$2.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.error(methodName, 'need chatOptions.contents');
+    logger$2.error(methodName, 'need chatOptions.contents');
     return;
   }
 
@@ -73,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.error(methodName, 'need chatOptions');
+    logger$2.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.error(methodName, 'need chatOptions.contents');
+    logger$2.error(methodName, 'need chatOptions.contents');
+    return;
+  }
+  if (!callbackOptions) {
+    logger$2.error(methodName, 'need callbackOptions');
     return;
   }
 
@@ -130,52 +118,51 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
   } catch (error) {
     if (errorCallback) errorCallback(error);
   }
-}
+};
 
-// cache add
-async function cacheAdd(client, modelName, cacheOptions) {
-  const methodName = 'Gemini - cacheAdd';
+/**
+ * cacheAdd
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} cacheOptions
+ * @returns
+ */
+const cacheAdd = async (client, modelName, cacheOptions) => {
+  const methodName = 'cacheAdd';
 
   // check
   if (!cacheOptions) {
-    logger.error(methodName, 'need cacheOptions');
+    logger$2.error(methodName, 'need cacheOptions');
     return;
   }
-  if (!cacheOptions.filePath) {
-    logger.error(methodName, 'need cacheOptions.filePath');
+  if (!cacheOptions.gsPath) {
+    logger$2.error(methodName, 'need cacheOptions.gsPath');
     return;
   }
   if (!cacheOptions.systemPrompt) {
-    logger.error(methodName, 'need cacheOptions.systemPrompt');
+    logger$2.error(methodName, 'need cacheOptions.systemPrompt');
     return;
   }
   if (!cacheOptions.cacheName) {
-    logger.error(methodName, 'need cacheOptions.cacheName');
+    logger$2.error(methodName, 'need cacheOptions.cacheName');
     return;
   }
   if (!cacheOptions.cacheTTL) {
-    logger.error(methodName, 'need cacheOptions.cacheTTL');
+    logger$2.error(methodName, 'need cacheOptions.cacheTTL');
     return;
   }
 
   // const
-  const mimeType = mime.lookup(cacheOptions.filePath);
-  logger.info(methodName, 'cacheOptions', cacheOptions);
-  logger.info(methodName, 'mimeType', mimeType);
+  const mimeType = mime.lookup(cacheOptions.gsPath);
+  logger$2.info(methodName, 'cacheOptions', cacheOptions);
+  logger$2.info(methodName, 'mimeType', mimeType);
 
   try {
-    // upload doc
-    const doc = await client.files.upload({
-      file: cacheOptions.filePath,
-      config: { mimeType: mimeType },
-    });
-    logger.info(methodName, 'doc.name', doc.name);
-
     // cache add
     const cache = await client.caches.create({
       model: modelName,
       config: {
-        contents: genai.createUserContent(genai.createPartFromUri(doc.uri, doc.mimeType)),
+        contents: genai.createUserContent(genai.createPartFromUri(cacheOptions.gsPath, mimeType)),
         systemInstruction: cacheOptions.systemPrompt,
         displayName: cacheOptions.cacheName,
         ttl: cacheOptions.cacheTTL,
@@ -184,8 +171,106 @@ async function cacheAdd(client, modelName, cacheOptions) {
 
     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.4",
+  "version": "0.1.5",
   "description": "Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions",
   "keywords": [
     "llm",
@@ -61,5 +61,5 @@
       }
     }
   },
-  "gitHead": "38e28266271d8b64e56c5f6d27deca78ce8cdb1b"
+  "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/{gemini.js → models/gemini-util.js}

@@ -1,64 +1,32 @@
 // gemini
-import { GoogleGenAI, createUserContent, createPartFromUri } from '@google/genai';
+import { createUserContent, createPartFromUri } from '@google/genai';
 
 // mime
 import mime from 'mime-types';
 
 // Logger
 import { Logger } from 'qiao.log.js';
-const logger = Logger('viho-llm');
+const logger = Logger('gemini-util.js');
 
 /**
- * Gemini
- * @param {*} options
+ * chat
+ * @param {*} client
+ * @param {*} modelName
+ * @param {*} chatOptions
  * @returns
  */
-export const Gemini = (options) => {
-  const methodName = 'Gemini';
+export const chat = async (client, modelName, chatOptions) => {
+  const methodName = 'chat';
 
   // check
-  if (!options) {
-    logger.error(methodName, 'need options');
+  if (!client) {
+    logger.error(methodName, 'need client');
     return;
   }
-  if (!options.apiKey) {
-    logger.error(methodName, 'need options.apiKey');
+  if (!modelName) {
+    logger.error(methodName, 'need modelName');
     return;
   }
-  if (!options.modelName) {
-    logger.error(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 (cacheOptions) => {
-    return await cacheAdd(gemini.client, options.modelName, cacheOptions);
-  };
-
-  // r
-  return gemini;
-};
-
-// chat
-async function chat(client, modelName, chatOptions) {
-  const methodName = 'Gemini - chat';
-
-  // check
   if (!chatOptions) {
     logger.error(methodName, 'need chatOptions');
     return;
@@ -82,12 +50,28 @@ async function chat(client, modelName, chatOptions) {
   } catch (error) {
     logger.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
+ */
+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;
@@ -96,6 +80,10 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
     logger.error(methodName, 'need chatOptions.contents');
     return;
   }
+  if (!callbackOptions) {
+    logger.error(methodName, 'need callbackOptions');
+    return;
+  }
 
   // callback
   const beginCallback = callbackOptions.beginCallback;
@@ -131,19 +119,25 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
   } catch (error) {
     if (errorCallback) errorCallback(error);
   }
-}
+};
 
-// cache add
-async function cacheAdd(client, modelName, cacheOptions) {
-  const methodName = 'Gemini - cacheAdd';
+/**
+ * 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.filePath) {
-    logger.error(methodName, 'need cacheOptions.filePath');
+  if (!cacheOptions.gsPath) {
+    logger.error(methodName, 'need cacheOptions.gsPath');
     return;
   }
   if (!cacheOptions.systemPrompt) {
@@ -160,23 +154,16 @@ async function cacheAdd(client, modelName, cacheOptions) {
   }
 
   // const
-  const mimeType = mime.lookup(cacheOptions.filePath);
+  const mimeType = mime.lookup(cacheOptions.gsPath);
   logger.info(methodName, 'cacheOptions', cacheOptions);
   logger.info(methodName, 'mimeType', mimeType);
 
   try {
-    // upload doc
-    const doc = await client.files.upload({
-      file: cacheOptions.filePath,
-      config: { mimeType: mimeType },
-    });
-    logger.info(methodName, 'doc.name', doc.name);
-
     // cache add
     const cache = await client.caches.create({
       model: modelName,
       config: {
-        contents: createUserContent(createPartFromUri(doc.uri, doc.mimeType)),
+        contents: createUserContent(createPartFromUri(cacheOptions.gsPath, mimeType)),
         systemInstruction: cacheOptions.systemPrompt,
         displayName: cacheOptions.cacheName,
         ttl: cacheOptions.cacheTTL,
@@ -187,4 +174,4 @@ async function cacheAdd(client, modelName, cacheOptions) {
   } 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;
+};