viho-llm 0.1.7 → 0.1.9

package/README.md

@@ -99,15 +99,16 @@ import { OpenAIAPI } from 'viho-llm';
 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
-);
+// Send a chat message (using native OpenAI API format)
+const response = await openai.chat({
+  model: 'gpt-4o',
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Hello, how are you?' },
+  ],
+});
 
 console.log(response);
 ```
@@ -156,8 +157,16 @@ 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
+  {
+    model: 'deepseek-reasoner',
+    messages: [
+      { role: 'system', content: 'You are a helpful assistant.' },
+      { role: 'user', content: 'Explain how neural networks work' },
+    ],
+    thinking: {
+      type: 'enabled', // Enable reasoning mode
+    },
+  },
   {
     beginCallback: () => {
       console.log('Stream started...');
@@ -413,21 +422,25 @@ Creates a new OpenAI client instance supporting OpenAI and compatible APIs.
 - `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)`
+##### `client.chat(chatOptions)`
 
 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
+- `chatOptions` (Object) **required** - Native OpenAI API chat completion options
+  - `model` (string) **required** - Model identifier (e.g., 'gpt-4o', 'deepseek-reasoner')
+  - `messages` (Array) **required** - Array of message objects
+    - `role` (string) - 'system', 'user', or 'assistant'
+    - `content` (string) - Message content
+  - `thinking` (Object) - Optional thinking/reasoning configuration
+    - `type` (string) - 'enabled' or 'disabled'
+  - ...other OpenAI API parameters
 
 **Returns:**
 
@@ -436,21 +449,30 @@ Sends a chat request to the OpenAI API.
 **Example:**
 
 ```javascript
-const response = await openai.chat(
-  'You are a helpful coding assistant.',
-  'Write a Python function to reverse a string',
-);
+const response = await openai.chat({
+  model: 'gpt-4o',
+  messages: [
+    { role: 'system', content: 'You are a helpful coding assistant.' },
+    { role: 'user', content: 'Write a Python function to reverse a string' },
+  ],
+});
 console.log(response.content);
 ```
 
-##### `client.chatWithStreaming(systemPrompt, userPrompt, callbackOptions)`
+##### `client.chatWithStreaming(chatOptions, 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
+- `chatOptions` (Object) **required** - Native OpenAI API chat completion options
+  - `model` (string) **required** - Model identifier (e.g., 'gpt-4o', 'deepseek-reasoner')
+  - `messages` (Array) **required** - Array of message objects
+    - `role` (string) - 'system', 'user', or 'assistant'
+    - `content` (string) - Message content
+  - `thinking` (Object) - Optional thinking/reasoning configuration
+    - `type` (string) - 'enabled' or 'disabled'
+  - ...other OpenAI API parameters (note: `stream` will be automatically set to `true`)
 
 - `callbackOptions` (Object) **required** - Callback functions for handling stream events
   - `beginCallback` (Function) - Called when the stream begins
@@ -471,17 +493,29 @@ Sends a chat request to the OpenAI API with streaming response and thinking supp
 **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);
+await openai.chatWithStreaming(
+  {
+    model: 'deepseek-reasoner',
+    messages: [
+      { role: 'system', content: 'You are a math tutor.' },
+      { role: 'user', content: 'Solve: What is 15% of 240?' },
+    ],
+    thinking: {
+      type: 'enabled',
+    },
   },
-  endCallback: () => {
-    console.log('\nDone!');
+  {
+    thinkingCallback: (thinking) => {
+      console.log('Thinking:', thinking);
+    },
+    contentCallback: (chunk) => {
+      process.stdout.write(chunk);
+    },
+    endCallback: () => {
+      console.log('\nDone!');
+    },
   },
-});
+);
 ```
 
 ## License

package/index.js

@@ -370,13 +370,10 @@ const logger$1 = qiao_log_js.Logger('openai-util.js');
 /**
  * chat
  * @param {*} client
- * @param {*} modelID
- * @param {*} modelThinking
- * @param {*} systemPrompt
- * @param {*} userPrompt
+ * @param {*} chatOptions
  * @returns
  */
-const chat = async (client, modelID, modelThinking, systemPrompt, userPrompt) => {
+const chat = async (client, chatOptions) => {
   const methodName = 'chat';
 
   // check
@@ -384,35 +381,11 @@ const chat = async (client, modelID, modelThinking, systemPrompt, userPrompt) =>
     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');
+  if (!chatOptions) {
+    logger$1.error(methodName, 'need chatOptions');
     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);
@@ -425,14 +398,11 @@ const chat = async (client, modelID, modelThinking, systemPrompt, userPrompt) =>
 /**
  * chatWithStreaming
  * @param {*} client
- * @param {*} modelID
- * @param {*} modelThinking
- * @param {*} systemPrompt
- * @param {*} userPrompt
+ * @param {*} chatOptions
  * @param {*} callbackOptions
  * @returns
  */
-const chatWithStreaming = async (client, modelID, modelThinking, systemPrompt, userPrompt, callbackOptions) => {
+const chatWithStreaming = async (client, chatOptions, callbackOptions) => {
   const methodName = 'chatWithStreaming';
 
   // check
@@ -440,20 +410,8 @@ const chatWithStreaming = async (client, modelID, modelThinking, systemPrompt, u
     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');
+  if (!chatOptions) {
+    logger$1.error(methodName, 'need chatOptions');
     return;
   }
   if (!callbackOptions) {
@@ -470,18 +428,6 @@ const chatWithStreaming = async (client, modelID, modelThinking, systemPrompt, u
   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;
@@ -546,14 +492,6 @@ const OpenAIAPI = (options) => {
     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 = {};
@@ -563,20 +501,13 @@ const OpenAIAPI = (options) => {
   });
 
   // chat
-  openai.chat = async (systemPrompt, userPrompt) => {
-    return await chat(openai.client, options.modelID, options.modelThinking, systemPrompt, userPrompt);
+  openai.chat = async (chatOptions) => {
+    return await chat(openai.client, chatOptions);
   };
 
   // chat with streaming
-  openai.chatWithStreaming = async (systemPrompt, userPrompt, callbakOptions) => {
-    return await chatWithStreaming(
-      openai.client,
-      options.modelID,
-      options.modelThinking,
-      systemPrompt,
-      userPrompt,
-      callbakOptions,
-    );
+  openai.chatWithStreaming = async (chatOptions, callbakOptions) => {
+    return await chatWithStreaming(openai.client, chatOptions, callbakOptions);
   };
 
   //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viho-llm",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Utility library for working with multiple LLM providers (Google Gemini and OpenAI), providing common tools and helpers for AI interactions",
   "keywords": [
     "llm",
@@ -68,5 +68,5 @@
       }
     }
   },
-  "gitHead": "21b7c541435da99dceb5dcf657ac5a528ed792ba"
+  "gitHead": "c0e05b33cb09f03f3ae41f85e81534fd16b1a5bf"
 }

package/src/models/openai-util.js

@@ -5,13 +5,10 @@ const logger = Logger('openai-util.js');
 /**
  * chat
  * @param {*} client
- * @param {*} modelID
- * @param {*} modelThinking
- * @param {*} systemPrompt
- * @param {*} userPrompt
+ * @param {*} chatOptions
  * @returns
  */
-export const chat = async (client, modelID, modelThinking, systemPrompt, userPrompt) => {
+export const chat = async (client, chatOptions) => {
   const methodName = 'chat';
 
   // check
@@ -19,34 +16,10 @@ export const chat = async (client, modelID, modelThinking, systemPrompt, userPro
     logger.error(methodName, 'need client');
     return;
   }
-  if (!modelID) {
-    logger.error(methodName, 'need modelID');
+  if (!chatOptions) {
+    logger.error(methodName, 'need chatOptions');
     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 {
@@ -60,14 +33,11 @@ export const chat = async (client, modelID, modelThinking, systemPrompt, userPro
 /**
  * chatWithStreaming
  * @param {*} client
- * @param {*} modelID
- * @param {*} modelThinking
- * @param {*} systemPrompt
- * @param {*} userPrompt
+ * @param {*} chatOptions
  * @param {*} callbackOptions
  * @returns
  */
-export const chatWithStreaming = async (client, modelID, modelThinking, systemPrompt, userPrompt, callbackOptions) => {
+export const chatWithStreaming = async (client, chatOptions, callbackOptions) => {
   const methodName = 'chatWithStreaming';
 
   // check
@@ -75,20 +45,8 @@ export const chatWithStreaming = async (client, modelID, modelThinking, systemPr
     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');
+  if (!chatOptions) {
+    logger.error(methodName, 'need chatOptions');
     return;
   }
   if (!callbackOptions) {
@@ -105,18 +63,6 @@ export const chatWithStreaming = async (client, modelID, modelThinking, systemPr
   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;

package/src/models/openai.js

@@ -29,14 +29,6 @@ export const OpenAIAPI = (options) => {
     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 = {};
@@ -46,20 +38,13 @@ export const OpenAIAPI = (options) => {
   });
 
   // chat
-  openai.chat = async (systemPrompt, userPrompt) => {
-    return await chat(openai.client, options.modelID, options.modelThinking, systemPrompt, userPrompt);
+  openai.chat = async (chatOptions) => {
+    return await chat(openai.client, chatOptions);
   };
 
   // chat with streaming
-  openai.chatWithStreaming = async (systemPrompt, userPrompt, callbakOptions) => {
-    return await chatWithStreaming(
-      openai.client,
-      options.modelID,
-      options.modelThinking,
-      systemPrompt,
-      userPrompt,
-      callbakOptions,
-    );
+  openai.chatWithStreaming = async (chatOptions, callbakOptions) => {
+    return await chatWithStreaming(openai.client, chatOptions, callbakOptions);
   };
 
   //