viho-llm 0.1.2 → 0.1.4

package/README.md

@@ -38,6 +38,47 @@ const response = await gemini.chat({
 console.log(response);
 ```
 
+### Streaming Example
+
+```javascript
+import { Gemini } from 'viho-llm';
+
+// Initialize Gemini client
+const gemini = Gemini({
+  apiKey: 'your-google-api-key',
+  modelName: 'gemini-pro',
+});
+
+// Send a chat message with streaming
+await gemini.chatWithStreaming(
+  {
+    contents: [
+      {
+        role: 'user',
+        parts: [{ text: 'Write a long story about AI' }],
+      },
+    ],
+  },
+  {
+    beginCallback: () => {
+      console.log('Stream started...');
+    },
+    firstContentCallback: () => {
+      console.log('First chunk received!');
+    },
+    contentCallback: (content) => {
+      process.stdout.write(content); // Print each chunk as it arrives
+    },
+    endCallback: () => {
+      console.log('\nStream ended.');
+    },
+    errorCallback: (error) => {
+      console.error('Error:', error);
+    },
+  },
+);
+```
+
 ## API Reference
 
 ### `Gemini(options)`
@@ -83,6 +124,54 @@ const response = await gemini.chat({
 });
 ```
 
+##### `client.chatWithStreaming(chatOptions, callbackOptions)`
+
+Sends a chat request to the Gemini API with streaming response.
+
+**Parameters:**
+
+- `chatOptions` (Object)
+  - `contents` (Array) **required** - Array of message objects
+    - `role` (string) - Either 'user' or 'model'
+    - `parts` (Array) - Array of content parts
+      - `text` (string) - The text content
+
+- `callbackOptions` (Object) - Callback functions for handling stream events
+  - `beginCallback` (Function) - Called when the stream begins
+  - `contentCallback` (Function) - Called for each content chunk received
+    - Parameters: `content` (string) - The text chunk
+  - `firstContentCallback` (Function) - Called when the first content chunk is received
+  - `endCallback` (Function) - Called when the stream ends successfully
+  - `errorCallback` (Function) - Called if an error occurs
+    - Parameters: `error` (Error) - The error object
+
+**Returns:**
+
+- (Promise\<void\>) - Resolves when streaming completes
+
+**Example:**
+
+```javascript
+await gemini.chatWithStreaming(
+  {
+    contents: [
+      {
+        role: 'user',
+        parts: [{ text: 'Explain quantum computing' }],
+      },
+    ],
+  },
+  {
+    contentCallback: (chunk) => {
+      console.log('Received:', chunk);
+    },
+    endCallback: () => {
+      console.log('Done!');
+    },
+  },
+);
+```
+
 ## License
 
 MIT

package/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var genai = require('@google/genai');
+var mime = require('mime-types');
 var qiao_log_js = require('qiao.log.js');
 
 // gemini
@@ -16,15 +17,15 @@ const Gemini = (options) => {
 
   // check
   if (!options) {
-    logger.info(methodName, 'need options');
+    logger.error(methodName, 'need options');
     return;
   }
   if (!options.apiKey) {
-    logger.info(methodName, 'need options.apiKey');
+    logger.error(methodName, 'need options.apiKey');
     return;
   }
   if (!options.modelName) {
-    logger.info(methodName, 'need options.modelName');
+    logger.error(methodName, 'need options.modelName');
     return;
   }
 
@@ -39,12 +40,15 @@ const Gemini = (options) => {
   gemini.chat = async (chatOptions) => {
     return await chat(gemini.client, options.modelName, chatOptions);
   };
-
-  // chat with streaming
   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;
 };
@@ -55,11 +59,11 @@ async function chat(client, modelName, chatOptions) {
 
   // check
   if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
+    logger.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
+    logger.error(methodName, 'need chatOptions.contents');
     return;
   }
 
@@ -84,11 +88,11 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
 
   // check
   if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
+    logger.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
+    logger.error(methodName, 'need chatOptions.contents');
     return;
   }
 
@@ -128,4 +132,60 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
   }
 }
 
+// cache add
+async function cacheAdd(client, modelName, cacheOptions) {
+  const methodName = 'Gemini - cacheAdd';
+
+  // check
+  if (!cacheOptions) {
+    logger.error(methodName, 'need cacheOptions');
+    return;
+  }
+  if (!cacheOptions.filePath) {
+    logger.error(methodName, 'need cacheOptions.filePath');
+    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.filePath);
+  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: genai.createUserContent(genai.createPartFromUri(doc.uri, doc.mimeType)),
+        systemInstruction: cacheOptions.systemPrompt,
+        displayName: cacheOptions.cacheName,
+        ttl: cacheOptions.cacheTTL,
+      },
+    });
+
+    return cache;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+}
+
 exports.Gemini = Gemini;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viho-llm",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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": "ddc9883c92c6b3bb4a0521819c79b389b438967f"
+  "gitHead": "38e28266271d8b64e56c5f6d27deca78ce8cdb1b"
 }

package/src/gemini.js

@@ -1,5 +1,8 @@
 // gemini
-import { GoogleGenAI } from '@google/genai';
+import { GoogleGenAI, createUserContent, createPartFromUri } from '@google/genai';
+
+// mime
+import mime from 'mime-types';
 
 // Logger
 import { Logger } from 'qiao.log.js';
@@ -15,15 +18,15 @@ export const Gemini = (options) => {
 
   // check
   if (!options) {
-    logger.info(methodName, 'need options');
+    logger.error(methodName, 'need options');
     return;
   }
   if (!options.apiKey) {
-    logger.info(methodName, 'need options.apiKey');
+    logger.error(methodName, 'need options.apiKey');
     return;
   }
   if (!options.modelName) {
-    logger.info(methodName, 'need options.modelName');
+    logger.error(methodName, 'need options.modelName');
     return;
   }
 
@@ -38,12 +41,15 @@ export const Gemini = (options) => {
   gemini.chat = async (chatOptions) => {
     return await chat(gemini.client, options.modelName, chatOptions);
   };
-
-  // chat with streaming
   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;
 };
@@ -54,11 +60,11 @@ async function chat(client, modelName, chatOptions) {
 
   // check
   if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
+    logger.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
+    logger.error(methodName, 'need chatOptions.contents');
     return;
   }
 
@@ -83,11 +89,11 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
 
   // check
   if (!chatOptions) {
-    logger.info(methodName, 'need chatOptions');
+    logger.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger.info(methodName, 'need chatOptions.contents');
+    logger.error(methodName, 'need chatOptions.contents');
     return;
   }
 
@@ -126,3 +132,59 @@ async function chatWithStreaming(client, modelName, chatOptions, callbackOptions
     if (errorCallback) errorCallback(error);
   }
 }
+
+// cache add
+async function cacheAdd(client, modelName, cacheOptions) {
+  const methodName = 'Gemini - cacheAdd';
+
+  // check
+  if (!cacheOptions) {
+    logger.error(methodName, 'need cacheOptions');
+    return;
+  }
+  if (!cacheOptions.filePath) {
+    logger.error(methodName, 'need cacheOptions.filePath');
+    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.filePath);
+  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)),
+        systemInstruction: cacheOptions.systemPrompt,
+        displayName: cacheOptions.cacheName,
+        ttl: cacheOptions.cacheTTL,
+      },
+    });
+
+    return cache;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+}