viho-llm 0.1.1 → 0.1.3

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

@@ -39,6 +39,14 @@ const Gemini = (options) => {
   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;
@@ -74,4 +82,82 @@ async function chat(client, modelName, chatOptions) {
   }
 }
 
+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: genai.createUserContent(content),
+      },
+    });
+
+    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.1",
+  "version": "0.1.3",
   "description": "Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions",
   "keywords": [
     "llm",
@@ -60,5 +60,5 @@
       }
     }
   },
-  "gitHead": "30ba092c8b2ab0e52894506eb93fdd77a26e4e36"
+  "gitHead": "89ff0ac8912f04b2c8957dedb05d0c8ad058219f"
 }

package/src/gemini.js

@@ -1,5 +1,5 @@
 // gemini
-import { GoogleGenAI } from '@google/genai';
+import { GoogleGenAI, createUserContent } from '@google/genai';
 
 // Logger
 import { Logger } from 'qiao.log.js';
@@ -38,6 +38,14 @@ export const Gemini = (options) => {
   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;
@@ -72,3 +80,81 @@ async function chat(client, modelName, chatOptions) {
     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);
+  }
+}