viho-llm 0.1.6 → 0.1.8

package/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">viho-llm</h1>
 
-<p align="center">Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions.</p>
+<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
 
@@ -14,7 +14,9 @@ npm install viho-llm
 
 ## Prerequisites
 
-This library supports two ways to access Google Gemini AI:
+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)
@@ -23,6 +25,14 @@ This library supports two ways to access Google Gemini AI:
    - 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 with GeminiAPI
@@ -78,9 +88,35 @@ const response = await gemini.chat({
 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
+});
+
+// Send a chat message
+const response = await openai.chat({
+  modelID: 'gpt-4o',
+  modelThinking: 'enabled', // 'enabled' or 'disabled' for reasoning models
+  systemPrompt: 'You are a helpful assistant.',
+  userPrompt: 'Hello, how are you?',
+});
+
+console.log(response);
+```
+
 ### Streaming Example
 
-Both GeminiAPI and GeminiVertex support streaming responses:
+All providers (GeminiAPI, GeminiVertex, and OpenAIAPI) support streaming responses:
+
+#### Gemini Streaming
 
 ```javascript
 // Send a chat message with streaming
@@ -113,6 +149,45 @@ 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(
+  {
+    modelID: 'deepseek-reasoner',
+    modelThinking: 'enabled',
+    systemPrompt: 'You are a helpful assistant.',
+    userPrompt: 'Explain how neural networks work',
+  },
+  {
+    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:
@@ -331,6 +406,102 @@ await gemini.cacheUpdate('projects/.../cachedContents/abc123', {
 });
 ```
 
+---
+
+### `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')
+
+#### Returns
+
+Returns an OpenAI client object with the following methods:
+
+##### `client.chat(chatOptions)`
+
+Sends a chat request to the OpenAI API.
+
+**Parameters:**
+
+- `chatOptions` (Object) **required** - Chat configuration
+  - `modelID` (string) **required** - Model identifier (e.g., 'gpt-4o', 'deepseek-reasoner')
+  - `modelThinking` (string) **required** - Thinking mode: 'enabled' or 'disabled'
+  - `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({
+  modelID: 'gpt-4o',
+  modelThinking: 'disabled',
+  systemPrompt: 'You are a helpful coding assistant.',
+  userPrompt: 'Write a Python function to reverse a string',
+});
+console.log(response.content);
+```
+
+##### `client.chatWithStreaming(chatOptions, callbackOptions)`
+
+Sends a chat request to the OpenAI API with streaming response and thinking support.
+
+**Parameters:**
+
+- `chatOptions` (Object) **required** - Chat configuration
+  - `modelID` (string) **required** - Model identifier (e.g., 'gpt-4o', 'deepseek-reasoner')
+  - `modelThinking` (string) **required** - Thinking mode: 'enabled' or 'disabled'
+  - `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(
+  {
+    modelID: 'deepseek-reasoner',
+    modelThinking: 'enabled',
+    systemPrompt: 'You are a math tutor.',
+    userPrompt: '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,24 +15,24 @@ 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;
   }
 
@@ -47,13 +48,13 @@ const chat = async (client, 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);
   }
 };
 
@@ -65,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;
   }
 
@@ -98,9 +99,6 @@ const chatWithStreaming = async (client, modelName, chatOptions, callbackOptions
   const firstContentCallback = callbackOptions.firstContentCallback;
 
   try {
-    // begin
-    if (beginCallback) beginCallback();
-
     // options
     const options = Object.assign(
       {
@@ -111,6 +109,7 @@ const chatWithStreaming = async (client, modelName, chatOptions, callbackOptions
 
     // gen
     const response = await client.models.generateContentStream(options);
+    if (beginCallback) beginCallback();
 
     // go
     let firstContent = true;
@@ -146,38 +145,38 @@ const cacheAdd = async (client, modelName, cacheOptions) => {
 
   // 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 (!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
@@ -193,7 +192,7 @@ const cacheAdd = async (client, modelName, cacheOptions) => {
 
     return cache;
   } catch (error) {
-    logger$2.error(methodName, 'error', error);
+    logger$4.error(methodName, 'error', error);
   }
 };
 
@@ -207,7 +206,7 @@ const cacheList = async (client) => {
 
   // check
   if (!client) {
-    logger$2.error(methodName, 'need client');
+    logger$4.error(methodName, 'need client');
     return;
   }
 
@@ -221,7 +220,7 @@ const cacheList = async (client) => {
 
     return cacheObjs;
   } catch (error) {
-    logger$2.error(methodName, 'error', error);
+    logger$4.error(methodName, 'error', error);
   }
 };
 
@@ -237,15 +236,15 @@ const cacheUpdate = async (client, cacheName, cacheOptions) => {
 
   // check
   if (!client) {
-    logger$2.error(methodName, 'need client');
+    logger$4.error(methodName, 'need client');
     return;
   }
   if (!cacheName) {
-    logger$2.error(methodName, 'need cacheName');
+    logger$4.error(methodName, 'need cacheName');
     return;
   }
   if (!cacheOptions) {
-    logger$2.error(methodName, 'need cacheOptions');
+    logger$4.error(methodName, 'need cacheOptions');
     return;
   }
 
@@ -258,12 +257,12 @@ const cacheUpdate = async (client, cacheName, cacheOptions) => {
 
     return res;
   } catch (error) {
-    logger$2.error(methodName, 'error', 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
@@ -275,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;
   }
 
@@ -295,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
@@ -306,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
@@ -318,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;
   }
 
@@ -344,10 +343,10 @@ 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
@@ -365,5 +364,212 @@ const GeminiVertex = (options) => {
   return gemini;
 };
 
+// Logger
+const logger$1 = qiao_log_js.Logger('openai-util.js');
+
+/**
+ * chat
+ * @param {*} client
+ * @param {*} options
+ * @returns
+ */
+const chat = async (client, options) => {
+  const methodName = 'chat';
+
+  // check
+  if (!client) {
+    logger$1.error(methodName, 'need client');
+    return;
+  }
+  if (!options) {
+    logger$1.error(methodName, 'need options');
+    return;
+  }
+  if (!options.modelID) {
+    logger$1.error(methodName, 'need options.modelID');
+    return;
+  }
+  if (!options.modelThinking) {
+    logger$1.error(methodName, 'need options.modelThinking');
+    return;
+  }
+  if (!options.systemPrompt) {
+    logger$1.error(methodName, 'need options.systemPrompt');
+    return;
+  }
+  if (!options.userPrompt) {
+    logger$1.error(methodName, 'need options.userPrompt');
+    return;
+  }
+
+  // chat
+  const chatOptions = {
+    model: options.modelID,
+    messages: [
+      { role: 'system', content: options.systemPrompt },
+      { role: 'user', content: options.userPrompt },
+    ],
+    thinking: {
+      type: options.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 {*} options
+ * @param {*} callbackOptions
+ * @returns
+ */
+const chatWithStreaming = async (client, options, callbackOptions) => {
+  const methodName = 'chatWithStreaming';
+
+  // check
+  if (!client) {
+    logger$1.error(methodName, 'need client');
+    return;
+  }
+  if (!options) {
+    logger$1.error(methodName, 'need options');
+    return;
+  }
+  if (!options.modelID) {
+    logger$1.error(methodName, 'need options.modelID');
+    return;
+  }
+  if (!options.modelThinking) {
+    logger$1.error(methodName, 'need options.modelThinking');
+    return;
+  }
+  if (!options.systemPrompt) {
+    logger$1.error(methodName, 'need options.systemPrompt');
+    return;
+  }
+  if (!options.userPrompt) {
+    logger$1.error(methodName, 'need options.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: options.modelID,
+    messages: [
+      { role: 'system', content: options.systemPrompt },
+      { role: 'user', content: options.userPrompt },
+    ],
+    thinking: {
+      type: options.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;
+  }
+
+  // openai
+  const openai = {};
+  openai.client = new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL,
+  });
+
+  // chat
+  openai.chat = async (chatOptions) => {
+    return await chat(openai.client, chatOptions);
+  };
+
+  // chat with streaming
+  openai.chatWithStreaming = async (chatOptions, callbakOptions) => {
+    return await chatWithStreaming(openai.client, chatOptions, 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.6",
-  "description": "Utility library for working with Google Gemini AI, providing common tools and helpers for AI interactions",
+  "version": "0.1.8",
+  "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": "d77d2ba692eac3cd5262f55ade7cf74b84172385"
+  "gitHead": "7d413880dd77b08d2f09ebff758510a357f0f095"
 }

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

@@ -99,9 +99,6 @@ export const chatWithStreaming = async (client, modelName, chatOptions, callback
   const firstContentCallback = callbackOptions.firstContentCallback;
 
   try {
-    // begin
-    if (beginCallback) beginCallback();
-
     // options
     const options = Object.assign(
       {
@@ -112,6 +109,7 @@ export const chatWithStreaming = async (client, modelName, chatOptions, callback
 
     // gen
     const response = await client.models.generateContentStream(options);
+    if (beginCallback) beginCallback();
 
     // go
     let firstContent = true;

package/src/models/openai-util.js

@@ -0,0 +1,160 @@
+// Logger
+import { Logger } from 'qiao.log.js';
+const logger = Logger('openai-util.js');
+
+/**
+ * chat
+ * @param {*} client
+ * @param {*} options
+ * @returns
+ */
+export const chat = async (client, options) => {
+  const methodName = 'chat';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.modelID) {
+    logger.error(methodName, 'need options.modelID');
+    return;
+  }
+  if (!options.modelThinking) {
+    logger.error(methodName, 'need options.modelThinking');
+    return;
+  }
+  if (!options.systemPrompt) {
+    logger.error(methodName, 'need options.systemPrompt');
+    return;
+  }
+  if (!options.userPrompt) {
+    logger.error(methodName, 'need options.userPrompt');
+    return;
+  }
+
+  // chat
+  const chatOptions = {
+    model: options.modelID,
+    messages: [
+      { role: 'system', content: options.systemPrompt },
+      { role: 'user', content: options.userPrompt },
+    ],
+    thinking: {
+      type: options.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 {*} options
+ * @param {*} callbackOptions
+ * @returns
+ */
+export const chatWithStreaming = async (client, options, callbackOptions) => {
+  const methodName = 'chatWithStreaming';
+
+  // check
+  if (!client) {
+    logger.error(methodName, 'need client');
+    return;
+  }
+  if (!options) {
+    logger.error(methodName, 'need options');
+    return;
+  }
+  if (!options.modelID) {
+    logger.error(methodName, 'need options.modelID');
+    return;
+  }
+  if (!options.modelThinking) {
+    logger.error(methodName, 'need options.modelThinking');
+    return;
+  }
+  if (!options.systemPrompt) {
+    logger.error(methodName, 'need options.systemPrompt');
+    return;
+  }
+  if (!options.userPrompt) {
+    logger.error(methodName, 'need options.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: options.modelID,
+    messages: [
+      { role: 'system', content: options.systemPrompt },
+      { role: 'user', content: options.userPrompt },
+    ],
+    thinking: {
+      type: options.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,52 @@
+// 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;
+  }
+
+  // openai
+  const openai = {};
+  openai.client = new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL,
+  });
+
+  // chat
+  openai.chat = async (chatOptions) => {
+    return await chat(openai.client, chatOptions);
+  };
+
+  // chat with streaming
+  openai.chatWithStreaming = async (chatOptions, callbakOptions) => {
+    return await chatWithStreaming(openai.client, chatOptions, callbakOptions);
+  };
+
+  //
+  return openai;
+};