viho-llm 0.1.5 → 0.1.7

package/README.md

@@ -1,6 +1,10 @@
-# viho-llm
+<p align="center">
+  <img src="https://static-small.vincentqiao.com/viho/logo.png" alt="viho logo" width="200"/>
+</p>
 
-Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions.
+<h1 align="center">viho-llm</h1>
+
+<p align="center">Utility library for working with multiple LLM providers (Google Gemini and OpenAI), providing common tools and helpers for AI interactions.</p>
 
 ## Installation
 
@@ -10,17 +14,36 @@ npm install viho-llm
 
 ## Prerequisites
 
-You need to have a Google AI API key. Get one from [Google AI Studio](https://makersuite.google.com/app/apikey).
+This library supports multiple LLM providers:
+
+### Google Gemini AI
+
+1. **Google AI Studio (GeminiAPI)** - For personal development and prototyping
+   - Get an API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+
+2. **Vertex AI (GeminiVertex)** - For enterprise applications with advanced features
+   - Requires a Google Cloud project with Vertex AI enabled
+   - Supports context caching for cost optimization
+
+### OpenAI Compatible APIs
+
+**OpenAI API (OpenAIAPI)** - For OpenAI and compatible services
+
+- Supports official OpenAI API
+- Compatible with OpenAI-like APIs (e.g., DeepSeek, local LLMs)
+- Supports thinking/reasoning mode for compatible models
 
 ## Usage
 
-### Basic Example
+### Basic Example with GeminiAPI
+
+Using Google AI Studio API Key (recommended for development):
 
 ```javascript
-import { Gemini } from 'viho-llm';
+import { GeminiAPI } from 'viho-llm';
 
-// Initialize Gemini client
-const gemini = Gemini({
+// Initialize Gemini client with API Key
+const gemini = GeminiAPI({
   apiKey: 'your-google-api-key',
   modelName: 'gemini-pro',
 });
@@ -38,17 +61,64 @@ const response = await gemini.chat({
 console.log(response);
 ```
 
-### Streaming Example
+### Basic Example with GeminiVertex
+
+Using Vertex AI (recommended for production):
 
 ```javascript
-import { Gemini } from 'viho-llm';
+import { GeminiVertex } from 'viho-llm';
 
-// Initialize Gemini client
-const gemini = Gemini({
-  apiKey: 'your-google-api-key',
+// Initialize Gemini client with Vertex AI
+const gemini = GeminiVertex({
+  projectId: 'your-gcp-project-id',
+  location: 'us-east1',
   modelName: 'gemini-pro',
 });
 
+// Send a chat message
+const response = await gemini.chat({
+  contents: [
+    {
+      role: 'user',
+      parts: [{ text: 'Hello, how are you?' }],
+    },
+  ],
+});
+
+console.log(response);
+```
+
+### Basic Example with OpenAI API
+
+Using OpenAI or OpenAI-compatible services:
+
+```javascript
+import { OpenAIAPI } from 'viho-llm';
+
+// Initialize OpenAI client
+const openai = OpenAIAPI({
+  apiKey: 'your-openai-api-key',
+  baseURL: 'https://api.openai.com/v1', // or your custom endpoint
+  modelID: 'gpt-4o',
+  modelThinking: 'enabled', // 'enabled' or 'disabled' for reasoning models
+});
+
+// Send a chat message
+const response = await openai.chat(
+  'You are a helpful assistant.', // system prompt
+  'Hello, how are you?', // user prompt
+);
+
+console.log(response);
+```
+
+### Streaming Example
+
+All providers (GeminiAPI, GeminiVertex, and OpenAIAPI) support streaming responses:
+
+#### Gemini Streaming
+
+```javascript
 // Send a chat message with streaming
 await gemini.chatWithStreaming(
   {
@@ -79,11 +149,79 @@ await gemini.chatWithStreaming(
 );
 ```
 
+#### OpenAI Streaming with Thinking Mode
+
+OpenAI streaming supports thinking/reasoning content for compatible models:
+
+```javascript
+// Send a chat message with streaming (supports thinking mode)
+await openai.chatWithStreaming(
+  'You are a helpful assistant.', // system prompt
+  'Explain how neural networks work', // user prompt
+  {
+    beginCallback: () => {
+      console.log('Stream started...');
+    },
+    firstThinkingCallback: () => {
+      console.log('\n[Thinking...]');
+    },
+    thinkingCallback: (thinking) => {
+      process.stdout.write(thinking); // Print reasoning process
+    },
+    firstContentCallback: () => {
+      console.log('\n[Response:]');
+    },
+    contentCallback: (content) => {
+      process.stdout.write(content); // Print response content
+    },
+    endCallback: () => {
+      console.log('\nStream ended.');
+    },
+    errorCallback: (error) => {
+      console.error('Error:', error);
+    },
+  },
+);
+```
+
+### Context Caching Example (Vertex AI Only)
+
+GeminiVertex supports context caching to reduce costs and latency when using large contexts:
+
+```javascript
+import { GeminiVertex } from 'viho-llm';
+
+const gemini = GeminiVertex({
+  projectId: 'your-gcp-project-id',
+  location: 'us-east1',
+  modelName: 'gemini-1.5-flash-002',
+});
+
+// Add a new cache
+const cache = await gemini.cacheAdd({
+  gsPath: 'gs://your-bucket/large-document.pdf',
+  systemPrompt: 'You are an expert at analyzing technical documents.',
+  cacheName: 'my-document-cache',
+  cacheTTL: '3600s', // 1 hour
+});
+
+console.log('Cache created:', cache.name);
+
+// List all caches
+const caches = await gemini.cacheList();
+console.log('Available caches:', caches);
+
+// Update cache TTL
+await gemini.cacheUpdate(cache.name, {
+  ttl: '7200s', // Extend to 2 hours
+});
+```
+
 ## API Reference
 
-### `Gemini(options)`
+### `GeminiAPI(options)`
 
-Creates a new Gemini client instance.
+Creates a new Gemini client instance using Google AI Studio API.
 
 #### Parameters
 
@@ -172,6 +310,180 @@ await gemini.chatWithStreaming(
 );
 ```
 
+---
+
+### `GeminiVertex(options)`
+
+Creates a new Gemini client instance using Vertex AI. Includes all features of GeminiAPI plus context caching support.
+
+#### Parameters
+
+- `options` (Object) - Configuration options
+  - `projectId` (string) **required** - Your Google Cloud project ID
+  - `location` (string) **required** - GCP region (e.g., 'us-east1', 'us-central1')
+  - `modelName` (string) **required** - Model name (e.g., 'gemini-1.5-flash-002', 'gemini-1.5-pro-002')
+
+#### Returns
+
+Returns a Gemini client object with the following methods:
+
+##### `client.chat(chatOptions)`
+
+Same as GeminiAPI.chat(). See above for details.
+
+##### `client.chatWithStreaming(chatOptions, callbackOptions)`
+
+Same as GeminiAPI.chatWithStreaming(). See above for details.
+
+##### `client.cacheAdd(cacheOptions)`
+
+Creates a new context cache for frequently used content.
+
+**Parameters:**
+
+- `cacheOptions` (Object)
+  - `gsPath` (string) **required** - Google Cloud Storage path (e.g., 'gs://bucket/file.pdf')
+  - `systemPrompt` (string) **required** - System instruction for the cached context
+  - `cacheName` (string) **required** - Display name for the cache
+  - `cacheTTL` (string) **required** - Time-to-live (e.g., '3600s' for 1 hour)
+
+**Returns:**
+
+- (Promise\<Object\>) - Cache object with name and metadata
+
+**Example:**
+
+```javascript
+const cache = await gemini.cacheAdd({
+  gsPath: 'gs://my-bucket/documentation.pdf',
+  systemPrompt: 'You are a helpful documentation assistant.',
+  cacheName: 'docs-cache',
+  cacheTTL: '3600s',
+});
+```
+
+##### `client.cacheList()`
+
+Lists all available caches in the project.
+
+**Parameters:** None
+
+**Returns:**
+
+- (Promise\<Array\>) - Array of cache objects with `name` and `displayName` properties
+
+**Example:**
+
+```javascript
+const caches = await gemini.cacheList();
+console.log(caches);
+// [{ name: 'projects/.../cachedContents/...', displayName: 'docs-cache' }]
+```
+
+##### `client.cacheUpdate(cacheName, cacheOptions)`
+
+Updates an existing cache configuration.
+
+**Parameters:**
+
+- `cacheName` (string) **required** - The cache name to update
+- `cacheOptions` (Object) **required** - Update configuration
+  - `ttl` (string) - New time-to-live value (e.g., '7200s')
+
+**Returns:**
+
+- (Promise\<Object\>) - Updated cache object
+
+**Example:**
+
+```javascript
+await gemini.cacheUpdate('projects/.../cachedContents/abc123', {
+  ttl: '7200s', // Extend to 2 hours
+});
+```
+
+---
+
+### `OpenAIAPI(options)`
+
+Creates a new OpenAI client instance supporting OpenAI and compatible APIs.
+
+#### Parameters
+
+- `options` (Object) - Configuration options
+  - `apiKey` (string) **required** - Your OpenAI API key or compatible service key
+  - `baseURL` (string) **required** - API base URL (e.g., 'https://api.openai.com/v1')
+  - `modelID` (string) **required** - Model identifier (e.g., 'gpt-4o', 'deepseek-reasoner')
+  - `modelThinking` (string) **required** - Thinking mode: 'enabled' or 'disabled'
+
+#### Returns
+
+Returns an OpenAI client object with the following methods:
+
+##### `client.chat(systemPrompt, userPrompt)`
+
+Sends a chat request to the OpenAI API.
+
+**Parameters:**
+
+- `systemPrompt` (string) **required** - System instruction/context for the model
+- `userPrompt` (string) **required** - User's message/question
+
+**Returns:**
+
+- (Promise\<Object\>) - Message object with `role` and `content` properties
+
+**Example:**
+
+```javascript
+const response = await openai.chat(
+  'You are a helpful coding assistant.',
+  'Write a Python function to reverse a string',
+);
+console.log(response.content);
+```
+
+##### `client.chatWithStreaming(systemPrompt, userPrompt, callbackOptions)`
+
+Sends a chat request to the OpenAI API with streaming response and thinking support.
+
+**Parameters:**
+
+- `systemPrompt` (string) **required** - System instruction/context for the model
+- `userPrompt` (string) **required** - User's message/question
+
+- `callbackOptions` (Object) **required** - Callback functions for handling stream events
+  - `beginCallback` (Function) - Called when the stream begins
+  - `firstThinkingCallback` (Function) - Called when the first thinking chunk is received (for reasoning models)
+  - `thinkingCallback` (Function) - Called for each thinking/reasoning chunk received
+    - Parameters: `thinking` (string) - The thinking content chunk
+  - `firstContentCallback` (Function) - Called when the first response content chunk is received
+  - `contentCallback` (Function) - Called for each response content chunk received
+    - Parameters: `content` (string) - The text chunk
+  - `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 openai.chatWithStreaming('You are a math tutor.', 'Solve: What is 15% of 240?', {
+  thinkingCallback: (thinking) => {
+    console.log('Thinking:', thinking);
+  },
+  contentCallback: (chunk) => {
+    process.stdout.write(chunk);
+  },
+  endCallback: () => {
+    console.log('\nDone!');
+  },
+});
+```
+
 ## License
 
 MIT

package/index.js

@@ -3,9 +3,10 @@
 var genai = require('@google/genai');
 var mime = require('mime-types');
 var qiao_log_js = require('qiao.log.js');
+var OpenAI = require('openai');
 
 // gemini
-const logger$2 = qiao_log_js.Logger('gemini-util.js');
+const logger$4 = qiao_log_js.Logger('gemini-util.js');
 
 /**
  * chat
@@ -14,40 +15,46 @@ const logger$2 = qiao_log_js.Logger('gemini-util.js');
  * @param {*} chatOptions
  * @returns
  */
-const chat = async (client, modelName, chatOptions) => {
+const chat$1 = async (client, modelName, chatOptions) => {
   const methodName = 'chat';
 
   // check
   if (!client) {
-    logger$2.error(methodName, 'need client');
+    logger$4.error(methodName, 'need client');
     return;
   }
   if (!modelName) {
-    logger$2.error(methodName, 'need modelName');
+    logger$4.error(methodName, 'need modelName');
     return;
   }
   if (!chatOptions) {
-    logger$2.error(methodName, 'need chatOptions');
+    logger$4.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger$2.error(methodName, 'need chatOptions.contents');
+    logger$4.error(methodName, 'need chatOptions.contents');
     return;
   }
 
   try {
-    const response = await client.models.generateContent({
-      model: modelName,
-      contents: chatOptions.contents,
-    });
+    // options
+    const options = Object.assign(
+      {
+        model: modelName,
+      },
+      chatOptions,
+    );
+
+    // gen
+    const response = await client.models.generateContent(options);
     if (!response || !response.text) {
-      logger$2.error(methodName, 'invalid response');
+      logger$4.error(methodName, 'invalid response');
       return;
     }
 
     return response.text;
   } catch (error) {
-    logger$2.error(methodName, 'error', error);
+    logger$4.error(methodName, 'error', error);
   }
 };
 
@@ -59,28 +66,28 @@ const chat = async (client, modelName, chatOptions) => {
  * @param {*} callbackOptions
  * @returns
  */
-const chatWithStreaming = async (client, modelName, chatOptions, callbackOptions) => {
+const chatWithStreaming$1 = async (client, modelName, chatOptions, callbackOptions) => {
   const methodName = 'chatWithStreaming';
 
   // check
   if (!client) {
-    logger$2.error(methodName, 'need client');
+    logger$4.error(methodName, 'need client');
     return;
   }
   if (!modelName) {
-    logger$2.error(methodName, 'need modelName');
+    logger$4.error(methodName, 'need modelName');
     return;
   }
   if (!chatOptions) {
-    logger$2.error(methodName, 'need chatOptions');
+    logger$4.error(methodName, 'need chatOptions');
     return;
   }
   if (!chatOptions.contents) {
-    logger$2.error(methodName, 'need chatOptions.contents');
+    logger$4.error(methodName, 'need chatOptions.contents');
     return;
   }
   if (!callbackOptions) {
-    logger$2.error(methodName, 'need callbackOptions');
+    logger$4.error(methodName, 'need callbackOptions');
     return;
   }
 
@@ -92,11 +99,17 @@ const chatWithStreaming = async (client, modelName, chatOptions, callbackOptions
   const firstContentCallback = callbackOptions.firstContentCallback;
 
   try {
+    // options
+    const options = Object.assign(
+      {
+        model: modelName,
+      },
+      chatOptions,
+    );
+
+    // gen
+    const response = await client.models.generateContentStream(options);
     if (beginCallback) beginCallback();
-    const response = await client.models.generateContentStream({
-      model: modelName,
-      contents: chatOptions.contents,
-    });
 
     // go
     let firstContent = true;
@@ -131,31 +144,39 @@ const cacheAdd = async (client, modelName, cacheOptions) => {
   const methodName = 'cacheAdd';
 
   // check
+  if (!client) {
+    logger$4.error(methodName, 'need client');
+    return;
+  }
+  if (!modelName) {
+    logger$4.error(methodName, 'need modelName');
+    return;
+  }
   if (!cacheOptions) {
-    logger$2.error(methodName, 'need cacheOptions');
+    logger$4.error(methodName, 'need cacheOptions');
     return;
   }
   if (!cacheOptions.gsPath) {
-    logger$2.error(methodName, 'need cacheOptions.gsPath');
+    logger$4.error(methodName, 'need cacheOptions.gsPath');
     return;
   }
   if (!cacheOptions.systemPrompt) {
-    logger$2.error(methodName, 'need cacheOptions.systemPrompt');
+    logger$4.error(methodName, 'need cacheOptions.systemPrompt');
     return;
   }
   if (!cacheOptions.cacheName) {
-    logger$2.error(methodName, 'need cacheOptions.cacheName');
+    logger$4.error(methodName, 'need cacheOptions.cacheName');
     return;
   }
   if (!cacheOptions.cacheTTL) {
-    logger$2.error(methodName, 'need cacheOptions.cacheTTL');
+    logger$4.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);
+  logger$4.info(methodName, 'cacheOptions', cacheOptions);
+  logger$4.info(methodName, 'mimeType', mimeType);
 
   try {
     // cache add
@@ -171,12 +192,77 @@ const cacheAdd = async (client, modelName, cacheOptions) => {
 
     return cache;
   } catch (error) {
-    logger$2.error(methodName, 'error', error);
+    logger$4.error(methodName, 'error', error);
+  }
+};
+
+/**
+ * cacheList
+ * @param {*} client
+ * @returns
+ */
+const cacheList = async (client) => {
+  const methodName = 'cacheList';
+
+  // check
+  if (!client) {
+    logger$4.error(methodName, 'need client');
+    return;
+  }
+
+  // cache list
+  try {
+    const cacheList = await client.caches.list();
+    const cacheObjs = cacheList?.pageInternal?.map((contentCache) => ({
+      name: contentCache.name,
+      displayName: contentCache.displayName,
+    }));
+
+    return cacheObjs;
+  } catch (error) {
+    logger$4.error(methodName, 'error', error);
+  }
+};
+
+/**
+ * cacheUpdate
+ * @param {*} client
+ * @param {*} cacheName
+ * @param {*} cacheOptions
+ * @returns
+ */
+const cacheUpdate = async (client, cacheName, cacheOptions) => {
+  const methodName = 'cacheUpdate';
+
+  // check
+  if (!client) {
+    logger$4.error(methodName, 'need client');
+    return;
+  }
+  if (!cacheName) {
+    logger$4.error(methodName, 'need cacheName');
+    return;
+  }
+  if (!cacheOptions) {
+    logger$4.error(methodName, 'need cacheOptions');
+    return;
+  }
+
+  // cache update
+  try {
+    const res = await client.caches.update({
+      name: cacheName,
+      config: cacheOptions,
+    });
+
+    return res;
+  } catch (error) {
+    logger$4.error(methodName, 'error', error);
   }
 };
 
 // gemini
-const logger$1 = qiao_log_js.Logger('gemini-api.js');
+const logger$3 = qiao_log_js.Logger('gemini-api.js');
 
 /**
  * GeminiAPI
@@ -188,15 +274,15 @@ const GeminiAPI = (options) => {
 
   // check
   if (!options) {
-    logger$1.error(methodName, 'need options');
+    logger$3.error(methodName, 'need options');
     return;
   }
   if (!options.apiKey) {
-    logger$1.error(methodName, 'need options.apiKey');
+    logger$3.error(methodName, 'need options.apiKey');
     return;
   }
   if (!options.modelName) {
-    logger$1.error(methodName, 'need options.modelName');
+    logger$3.error(methodName, 'need options.modelName');
     return;
   }
 
@@ -208,10 +294,10 @@ const GeminiAPI = (options) => {
 
   // chat
   gemini.chat = async (chatOptions) => {
-    return await chat(gemini.client, options.modelName, chatOptions);
+    return await chat$1(gemini.client, options.modelName, chatOptions);
   };
   gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
-    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
+    return await chatWithStreaming$1(gemini.client, options.modelName, chatOptions, callbackOptions);
   };
 
   // r
@@ -219,7 +305,7 @@ const GeminiAPI = (options) => {
 };
 
 // gemini
-const logger = qiao_log_js.Logger('viho-llm');
+const logger$2 = qiao_log_js.Logger('viho-llm');
 
 /**
  * GeminiVertex
@@ -231,19 +317,19 @@ const GeminiVertex = (options) => {
 
   // check
   if (!options) {
-    logger.error(methodName, 'need options');
+    logger$2.error(methodName, 'need options');
     return;
   }
   if (!options.projectId) {
-    logger.error(methodName, 'need options.projectId');
+    logger$2.error(methodName, 'need options.projectId');
     return;
   }
   if (!options.location) {
-    logger.error(methodName, 'need options.location');
+    logger$2.error(methodName, 'need options.location');
     return;
   }
   if (!options.modelName) {
-    logger.error(methodName, 'need options.modelName');
+    logger$2.error(methodName, 'need options.modelName');
     return;
   }
 
@@ -257,20 +343,246 @@ const GeminiVertex = (options) => {
 
   // chat
   gemini.chat = async (chatOptions) => {
-    return await chat(gemini.client, options.modelName, chatOptions);
+    return await chat$1(gemini.client, options.modelName, chatOptions);
   };
   gemini.chatWithStreaming = async (chatOptions, callbackOptions) => {
-    return await chatWithStreaming(gemini.client, options.modelName, chatOptions, callbackOptions);
+    return await chatWithStreaming$1(gemini.client, options.modelName, chatOptions, callbackOptions);
   };
 
   // cache
   gemini.cacheAdd = async (cacheOptions) => {
     return await cacheAdd(gemini.client, options.modelName, cacheOptions);
   };
+  gemini.cacheList = async () => {
+    return await cacheList(gemini.client);
+  };
+  gemini.cacheUpdate = async (cacheName, cacheOptions) => {
+    return await cacheUpdate(gemini.client, cacheName, cacheOptions);
+  };
 
   // r
   return gemini;
 };
 
+// Logger
+const logger$1 = qiao_log_js.Logger('openai-util.js');
+
+/**
+ * chat
+ * @param {*} client
+ * @param {*} modelID
+ * @param {*} modelThinking
+ * @param {*} systemPrompt
+ * @param {*} userPrompt
+ * @returns
+ */
+const chat = async (client, modelID, modelThinking, systemPrompt, userPrompt) => {
+  const methodName = 'chat';
+
+  // check
+  if (!client) {
+    logger$1.error(methodName, 'need client');
+    return;
+  }
+  if (!modelID) {
+    logger$1.error(methodName, 'need modelID');
+    return;
+  }
+  if (!modelThinking) {
+    logger$1.error(methodName, 'need modelThinking');
+    return;
+  }
+  if (!systemPrompt) {
+    logger$1.error(methodName, 'need systemPrompt');
+    return;
+  }
+  if (!userPrompt) {
+    logger$1.error(methodName, 'need userPrompt');
+    return;
+  }
+
+  // chat
+  const chatOptions = {
+    model: modelID,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+    thinking: {
+      type: modelThinking,
+    },
+  };
+
+  // go
+  try {
+    const completion = await client.chat.completions.create(chatOptions);
+    return completion.choices[0]?.message;
+  } catch (error) {
+    logger$1.error(methodName, 'error', error);
+  }
+};
+
+/**
+ * chatWithStreaming
+ * @param {*} client
+ * @param {*} modelID
+ * @param {*} modelThinking
+ * @param {*} systemPrompt
+ * @param {*} userPrompt
+ * @param {*} callbackOptions
+ * @returns
+ */
+const chatWithStreaming = async (client, modelID, modelThinking, systemPrompt, userPrompt, callbackOptions) => {
+  const methodName = 'chatWithStreaming';
+
+  // check
+  if (!client) {
+    logger$1.error(methodName, 'need client');
+    return;
+  }
+  if (!modelID) {
+    logger$1.error(methodName, 'need modelID');
+    return;
+  }
+  if (!modelThinking) {
+    logger$1.error(methodName, 'need modelThinking');
+    return;
+  }
+  if (!systemPrompt) {
+    logger$1.error(methodName, 'need systemPrompt');
+    return;
+  }
+  if (!userPrompt) {
+    logger$1.error(methodName, 'need userPrompt');
+    return;
+  }
+  if (!callbackOptions) {
+    logger$1.error(methodName, 'need callbackOptions');
+    return;
+  }
+
+  // callback
+  const beginCallback = callbackOptions.beginCallback;
+  const endCallback = callbackOptions.endCallback;
+  const errorCallback = callbackOptions.errorCallback;
+  const thinkingCallback = callbackOptions.thinkingCallback;
+  const firstThinkingCallback = callbackOptions.firstThinkingCallback;
+  const contentCallback = callbackOptions.contentCallback;
+  const firstContentCallback = callbackOptions.firstContentCallback;
+
+  // chat
+  const chatOptions = {
+    model: modelID,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+    thinking: {
+      type: modelThinking,
+    },
+  };
+
+  // go
+  try {
+    chatOptions.stream = true;
+    const stream = await client.chat.completions.create(chatOptions);
+    if (beginCallback) beginCallback();
+
+    // go
+    let firstThinking = true;
+    let firstContent = true;
+    for await (const part of stream) {
+      // thinking
+      const thinkingContent = part.choices[0]?.delta?.reasoning_content;
+      if (thinkingContent && thinkingCallback) {
+        if (firstThinking && firstThinkingCallback) {
+          firstThinking = false;
+          firstThinkingCallback();
+        }
+
+        thinkingCallback(thinkingContent);
+      }
+
+      // content
+      const content = part.choices[0]?.delta?.content;
+      if (content && contentCallback) {
+        if (firstContent && firstContentCallback) {
+          firstContent = false;
+          firstContentCallback();
+        }
+
+        contentCallback(content);
+      }
+    }
+
+    // end
+    if (endCallback) endCallback();
+  } catch (error) {
+    if (errorCallback) errorCallback(error);
+  }
+};
+
+// openai
+const logger = qiao_log_js.Logger('openai.js');
+
+/**
+ * OpenAI
+ * @param {*} options
+ * @returns
+ */
+const OpenAIAPI = (options) => {
+  const methodName = 'OpenAI';
+
+  // check
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.apiKey) {
+    logger.error(methodName, 'need options.apiKey');
+    return;
+  }
+  if (!options.baseURL) {
+    logger.error(methodName, 'need options.baseURL');
+    return;
+  }
+  if (!options.modelID) {
+    logger.error(methodName, 'need options.modelID');
+    return;
+  }
+  if (!options.modelThinking) {
+    logger.error(methodName, 'need options.modelThinking');
+    return;
+  }
+
+  // openai
+  const openai = {};
+  openai.client = new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL,
+  });
+
+  // chat
+  openai.chat = async (systemPrompt, userPrompt) => {
+    return await chat(openai.client, options.modelID, options.modelThinking, systemPrompt, userPrompt);
+  };
+
+  // chat with streaming
+  openai.chatWithStreaming = async (systemPrompt, userPrompt, callbakOptions) => {
+    return await chatWithStreaming(
+      openai.client,
+      options.modelID,
+      options.modelThinking,
+      systemPrompt,
+      userPrompt,
+      callbakOptions,
+    );
+  };
+
+  //
+  return openai;
+};
+
 exports.GeminiAPI = GeminiAPI;
 exports.GeminiVertex = GeminiVertex;
+exports.OpenAIAPI = OpenAIAPI;

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "viho-llm",
-  "version": "0.1.5",
-  "description": "Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions",
+  "version": "0.1.7",
+  "description": "Utility library for working with multiple LLM providers (Google Gemini and OpenAI), providing common tools and helpers for AI interactions",
   "keywords": [
     "llm",
     "ai",
     "gemini",
+    "openai",
     "google-ai",
     "google-gemini",
     "genai",
+    "gpt",
+    "chatgpt",
     "ai-tools",
     "language-model",
     "ai-utilities",
+    "reasoning",
+    "thinking",
+    "deepseek",
     "viho"
   ],
   "author": "uikoo9 <uikoo9@qq.com>",
@@ -42,6 +48,7 @@
   "dependencies": {
     "@google/genai": "^1.34.0",
     "mime-types": "^2.1.35",
+    "openai": "^5.23.2",
     "qiao.log.js": "^3.7.5"
   },
   "nx": {
@@ -61,5 +68,5 @@
       }
     }
   },
-  "gitHead": "b37b523239fe354f991017387e95a6314e994981"
+  "gitHead": "21b7c541435da99dceb5dcf657ac5a528ed792ba"
 }

package/src/index.js

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

package/src/models/gemini-util.js

@@ -37,10 +37,16 @@ export const chat = async (client, modelName, chatOptions) => {
   }
 
   try {
-    const response = await client.models.generateContent({
-      model: modelName,
-      contents: chatOptions.contents,
-    });
+    // options
+    const options = Object.assign(
+      {
+        model: modelName,
+      },
+      chatOptions,
+    );
+
+    // gen
+    const response = await client.models.generateContent(options);
     if (!response || !response.text) {
       logger.error(methodName, 'invalid response');
       return;
@@ -93,11 +99,17 @@ export const chatWithStreaming = async (client, modelName, chatOptions, callback
   const firstContentCallback = callbackOptions.firstContentCallback;
 
   try {
+    // options
+    const options = Object.assign(
+      {
+        model: modelName,
+      },
+      chatOptions,
+    );
+
+    // gen
+    const response = await client.models.generateContentStream(options);
     if (beginCallback) beginCallback();
-    const response = await client.models.generateContentStream({
-      model: modelName,
-      contents: chatOptions.contents,
-    });
 
     // go
     let firstContent = true;
@@ -132,6 +144,14 @@ export const cacheAdd = async (client, modelName, cacheOptions) => {
   const methodName = 'cacheAdd';
 
   // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!modelName) {
+    logger.error(methodName, 'need modelName');
+    return;
+  }
   if (!cacheOptions) {
     logger.error(methodName, 'need cacheOptions');
     return;
@@ -175,3 +195,68 @@ export const cacheAdd = async (client, modelName, cacheOptions) => {
     logger.error(methodName, 'error', error);
   }
 };
+
+/**
+ * cacheList
+ * @param {*} client
+ * @returns
+ */
+export const cacheList = async (client) => {
+  const methodName = 'cacheList';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+
+  // cache list
+  try {
+    const cacheList = await client.caches.list();
+    const cacheObjs = cacheList?.pageInternal?.map((contentCache) => ({
+      name: contentCache.name,
+      displayName: contentCache.displayName,
+    }));
+
+    return cacheObjs;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+};
+
+/**
+ * cacheUpdate
+ * @param {*} client
+ * @param {*} cacheName
+ * @param {*} cacheOptions
+ * @returns
+ */
+export const cacheUpdate = async (client, cacheName, cacheOptions) => {
+  const methodName = 'cacheUpdate';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!cacheName) {
+    logger.error(methodName, 'need cacheName');
+    return;
+  }
+  if (!cacheOptions) {
+    logger.error(methodName, 'need cacheOptions');
+    return;
+  }
+
+  // cache update
+  try {
+    const res = await client.caches.update({
+      name: cacheName,
+      config: cacheOptions,
+    });
+
+    return res;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+};

package/src/models/gemini-vertex.js

@@ -2,7 +2,7 @@
 import { GoogleGenAI } from '@google/genai';
 
 // util
-import { chat, chatWithStreaming, cacheAdd } from './gemini-util.js';
+import { chat, chatWithStreaming, cacheAdd, cacheList, cacheUpdate } from './gemini-util.js';
 
 // Logger
 import { Logger } from 'qiao.log.js';
@@ -54,6 +54,12 @@ export const GeminiVertex = (options) => {
   gemini.cacheAdd = async (cacheOptions) => {
     return await cacheAdd(gemini.client, options.modelName, cacheOptions);
   };
+  gemini.cacheList = async () => {
+    return await cacheList(gemini.client);
+  };
+  gemini.cacheUpdate = async (cacheName, cacheOptions) => {
+    return await cacheUpdate(gemini.client, cacheName, cacheOptions);
+  };
 
   // r
   return gemini;

package/src/models/openai-util.js

@@ -0,0 +1,158 @@
+// Logger
+import { Logger } from 'qiao.log.js';
+const logger = Logger('openai-util.js');
+
+/**
+ * chat
+ * @param {*} client
+ * @param {*} modelID
+ * @param {*} modelThinking
+ * @param {*} systemPrompt
+ * @param {*} userPrompt
+ * @returns
+ */
+export const chat = async (client, modelID, modelThinking, systemPrompt, userPrompt) => {
+  const methodName = 'chat';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!modelID) {
+    logger.error(methodName, 'need modelID');
+    return;
+  }
+  if (!modelThinking) {
+    logger.error(methodName, 'need modelThinking');
+    return;
+  }
+  if (!systemPrompt) {
+    logger.error(methodName, 'need systemPrompt');
+    return;
+  }
+  if (!userPrompt) {
+    logger.error(methodName, 'need userPrompt');
+    return;
+  }
+
+  // chat
+  const chatOptions = {
+    model: modelID,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+    thinking: {
+      type: modelThinking,
+    },
+  };
+
+  // go
+  try {
+    const completion = await client.chat.completions.create(chatOptions);
+    return completion.choices[0]?.message;
+  } catch (error) {
+    logger.error(methodName, 'error', error);
+  }
+};
+
+/**
+ * chatWithStreaming
+ * @param {*} client
+ * @param {*} modelID
+ * @param {*} modelThinking
+ * @param {*} systemPrompt
+ * @param {*} userPrompt
+ * @param {*} callbackOptions
+ * @returns
+ */
+export const chatWithStreaming = async (client, modelID, modelThinking, systemPrompt, userPrompt, callbackOptions) => {
+  const methodName = 'chatWithStreaming';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!modelID) {
+    logger.error(methodName, 'need modelID');
+    return;
+  }
+  if (!modelThinking) {
+    logger.error(methodName, 'need modelThinking');
+    return;
+  }
+  if (!systemPrompt) {
+    logger.error(methodName, 'need systemPrompt');
+    return;
+  }
+  if (!userPrompt) {
+    logger.error(methodName, 'need userPrompt');
+    return;
+  }
+  if (!callbackOptions) {
+    logger.error(methodName, 'need callbackOptions');
+    return;
+  }
+
+  // callback
+  const beginCallback = callbackOptions.beginCallback;
+  const endCallback = callbackOptions.endCallback;
+  const errorCallback = callbackOptions.errorCallback;
+  const thinkingCallback = callbackOptions.thinkingCallback;
+  const firstThinkingCallback = callbackOptions.firstThinkingCallback;
+  const contentCallback = callbackOptions.contentCallback;
+  const firstContentCallback = callbackOptions.firstContentCallback;
+
+  // chat
+  const chatOptions = {
+    model: modelID,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+    thinking: {
+      type: modelThinking,
+    },
+  };
+
+  // go
+  try {
+    chatOptions.stream = true;
+    const stream = await client.chat.completions.create(chatOptions);
+    if (beginCallback) beginCallback();
+
+    // go
+    let firstThinking = true;
+    let firstContent = true;
+    for await (const part of stream) {
+      // thinking
+      const thinkingContent = part.choices[0]?.delta?.reasoning_content;
+      if (thinkingContent && thinkingCallback) {
+        if (firstThinking && firstThinkingCallback) {
+          firstThinking = false;
+          firstThinkingCallback();
+        }
+
+        thinkingCallback(thinkingContent);
+      }
+
+      // content
+      const content = part.choices[0]?.delta?.content;
+      if (content && contentCallback) {
+        if (firstContent && firstContentCallback) {
+          firstContent = false;
+          firstContentCallback();
+        }
+
+        contentCallback(content);
+      }
+    }
+
+    // end
+    if (endCallback) endCallback();
+  } catch (error) {
+    if (errorCallback) errorCallback(error);
+  }
+};

package/src/models/openai.js

@@ -0,0 +1,67 @@
+// openai
+import OpenAI from 'openai';
+
+// util
+import { chat, chatWithStreaming } from './openai-util.js';
+
+// Logger
+import { Logger } from 'qiao.log.js';
+const logger = Logger('openai.js');
+
+/**
+ * OpenAI
+ * @param {*} options
+ * @returns
+ */
+export const OpenAIAPI = (options) => {
+  const methodName = 'OpenAI';
+
+  // check
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.apiKey) {
+    logger.error(methodName, 'need options.apiKey');
+    return;
+  }
+  if (!options.baseURL) {
+    logger.error(methodName, 'need options.baseURL');
+    return;
+  }
+  if (!options.modelID) {
+    logger.error(methodName, 'need options.modelID');
+    return;
+  }
+  if (!options.modelThinking) {
+    logger.error(methodName, 'need options.modelThinking');
+    return;
+  }
+
+  // openai
+  const openai = {};
+  openai.client = new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL,
+  });
+
+  // chat
+  openai.chat = async (systemPrompt, userPrompt) => {
+    return await chat(openai.client, options.modelID, options.modelThinking, systemPrompt, userPrompt);
+  };
+
+  // chat with streaming
+  openai.chatWithStreaming = async (systemPrompt, userPrompt, callbakOptions) => {
+    return await chatWithStreaming(
+      openai.client,
+      options.modelID,
+      options.modelThinking,
+      systemPrompt,
+      userPrompt,
+      callbakOptions,
+    );
+  };
+
+  //
+  return openai;
+};