unified-ai-router 2.4.4 → 3.0.1

package/legacy/main.js

@@ -0,0 +1,63 @@
+const { ChatOpenAI } = require( "@langchain/openai" );
+const pino = require( "pino" );
+const pretty = require( "pino-pretty" );
+const stream = pretty({ colorize: true, ignore: "pid,hostname" });
+const logger = pino({ base: false }, stream );
+
+class AIRouter
+{
+	constructor ( providers )
+	{
+		this.providers = providers;
+	}
+
+	async chatCompletion ( messages, options = {}, stream = false )
+	{
+		const { stream: streamOption, tools, model, ...restOptions } = options;
+		const isStreaming = stream || streamOption;
+
+		logger.info( `Starting chatCompletion with ${this.providers.length} providers (streaming: ${isStreaming})` );
+		let lastError;
+
+		for ( const provider of this.providers )
+		{
+			try
+			{
+				logger.info( `Attempting with provider: ${provider.name}` );
+				let llm = new ChatOpenAI({
+					apiKey: provider.apiKey,
+					model: provider.model,
+					configuration: {
+						baseURL: provider.apiUrl,
+					},
+					...restOptions,
+				});
+
+				if ( tools && tools.length > 0 )
+				{
+					llm = llm.bindTools( tools );
+				}
+
+				if ( isStreaming )
+				{
+					const stream = await llm.stream( messages );
+					return stream;
+				}
+				else
+				{
+					const response = await llm.invoke( messages, { timeout: 60000 });
+					return response;
+				}
+			}
+			catch ( error )
+			{
+				lastError = error;
+				logger.error( `Failed with ${provider.name}:${error.message}` );
+				// Continue to next provider
+			}
+		}
+		throw new Error( `All providers failed. Last error: ${lastError.message}` );
+	}
+}
+
+module.exports = AIRouter;

package/legacy/openai-compatible-server.js

@@ -0,0 +1,192 @@
+const express = require( "express" );
+const cors = require( "cors" );
+const AIRouter = require( "../main" ); // your existing class
+const pino = require( "pino" );
+const pretty = require( "pino-pretty" );
+const stream = pretty({ colorize: true, ignore: "pid,hostname" });
+const logger = pino({ base: false }, stream );
+require( "dotenv" ).config({ quiet: true });
+
+const app = express();
+app.use( cors() );
+app.use( express.json() );
+
+/**
+ * Initialize router with providers (could load from env/config)
+ */
+const providers = require( "../provider" )
+
+const aiRouter = new AIRouter( providers );
+
+/**
+ * OpenAI-compatible endpoint: POST /v1/chat/completions
+ */
+app.post( "/v1/chat/completions", async ( req, res ) =>
+{
+	try
+	{
+		const { messages, model, stream, ...rest } = req.body;
+
+		if ( !messages || !Array.isArray( messages ) )
+		{
+			return res.status( 400 ).json({ error: { message: "messages must be an array" } });
+		}
+
+		if ( stream )
+		{
+			// Streaming mode → use Server-Sent Events (SSE)
+			res.setHeader( "Content-Type", "text/event-stream" );
+			res.setHeader( "Cache-Control", "no-cache" );
+			res.setHeader( "Connection", "keep-alive" );
+
+			try
+			{
+				const response = await aiRouter.chatCompletion( messages, { model, ...rest }, true );
+				const id = `chatcmpl-${Date.now()}`;
+				const created = Math.floor( Date.now() / 1000 );
+				let fullResponse = null;
+				for await ( const chunk of response )
+				{
+					const modelName = chunk?.response_metadata?.model_name || model || "unknown";
+					const systemFingerprint = chunk?.response_metadata?.system_fingerprint || null;
+					let delta = { ... chunk.delta || { content: chunk.content || "" } };
+					if ( !delta.role ) delta.role = "assistant";
+					delta.reasoning = delta.reasoning || null;
+					delta.reasoning_details = delta.reasoning_details || [];
+					let toolCallsDelta = null;
+					if ( chunk.tool_calls && chunk.tool_calls.length > 0 )
+					{
+						toolCallsDelta = chunk.tool_calls.map( ( tc, index ) =>
+						{
+							return {
+								id: tc.id || `call_${Date.now()}_${Math.random().toString( 36 ).substr( 2, 9 )}`,
+								type: "function",
+								index,
+								function: {
+									name: tc.name,
+									arguments: JSON.stringify( tc.args || {})
+								}
+							};
+						});
+						delta.tool_calls = toolCallsDelta;
+						delta.content = "";
+					}
+					const chunkFinishReason = delta.finish_reason || chunk?.response_metadata?.finish_reason || null;
+					const chunkNativeFinishReason = delta.native_finish_reason || chunk?.response_metadata?.native_finish_reason || chunkFinishReason || null;
+					if ( chunk.content && !fullResponse ) fullResponse = chunk; // Capture full for reasoning if available
+					const payload = {
+						id,
+						provider: "OpenAI",
+						object: "chat.completion.chunk",
+						created,
+						model: modelName,
+						system_fingerprint: systemFingerprint,
+						choices: [
+							{
+								logprobs: null,
+								delta,
+								index: 0,
+								finish_reason: chunkFinishReason,
+								native_finish_reason: chunkNativeFinishReason,
+							},
+						],
+					};
+					const usage = chunk?.response_metadata?.usage;
+					if ( usage && typeof usage === "object" && !Array.isArray( usage ) && Object.keys( usage ).length > 0 )
+					{
+						payload.usage = chunk?.response_metadata?.usage || null;
+					}
+					res.write( `data: ${JSON.stringify( payload )}\n\n` );
+				}
+				// Send done signal
+				res.write( "data: [DONE]\n\n" );
+				res.end();
+			}
+			catch ( err )
+			{
+				logger.error( err );
+				res.write( `data: ${JSON.stringify({ error: err.message })}\n\n` );
+				res.write( "data: [DONE]\n\n" );
+				res.end();
+			}
+		}
+		else
+		{
+			// Non-streaming → return one-shot completion
+			const response = await aiRouter.chatCompletion( messages, { model, ...rest }, false );
+			let reasoning = null;
+			let refusal = null;
+			let toolCalls = null;
+			if ( response.contentBlocks )
+			{
+				const reasoningBlocks = response.contentBlocks.filter( b => { return b.type === "reasoning" || b.type === "thinking" });
+				reasoning = reasoningBlocks.length > 0 ? reasoningBlocks.map( b => { return b.text }).join( "\n" ) : null;
+				const refusalBlocks = response.contentBlocks.filter( b => { return b.type === "refusal" });
+				refusal = refusalBlocks.length > 0 ? refusalBlocks.map( b => { return b.text }).join( "\n" ) : null;
+			}
+			if ( response.tool_calls && response.tool_calls.length > 0 )
+			{
+				toolCalls = response.tool_calls.map( ( tc, index ) =>
+				{
+				  return {
+					 id: tc.id || `call_${Date.now()}_${Math.random().toString( 36 ).substr( 2, 9 )}`,
+					 type: "function",
+					 index,
+					 function: {
+							name: tc.name,
+							arguments: JSON.stringify( tc.args || {})
+					 }
+				  };
+				});
+			}
+			const systemFingerprint = response.response_metadata?.system_fingerprint || null;
+			const finishReason = response.response_metadata?.finish_reason || null;
+			const nativeFinishReason = response.response_metadata?.native_finish_reason || finishReason || null;
+			const messageContent = toolCalls && toolCalls.length > 0 ? "" : response.content;
+			let finalResult = {
+				id: `chatcmpl_${Date.now()}`,
+				provider: "OpenAI",
+				object: "chat.completion",
+				created: Math.floor( Date.now() / 1000 ),
+				model: response.response_metadata?.model_name || model || "unknown",
+				system_fingerprint: systemFingerprint,
+				choices: [
+					{
+						logprobs: null,
+						finish_reason: finishReason,
+						native_finish_reason: nativeFinishReason,
+						index: 0,
+						message: {
+							role: "assistant",
+							content: messageContent,
+							refusal,
+							reasoning,
+							tool_calls: toolCalls
+						},
+					},
+				],
+			}
+			const usage = response?.response_metadata?.usage;
+			if ( usage && typeof usage === "object" && !Array.isArray( usage ) && Object.keys( usage ).length > 0 )
+			{
+				finalResult.usage = response?.response_metadata?.usage || null;
+			}
+			res.json( finalResult );
+		}
+	}
+	catch ( err )
+	{
+		logger.error( err );
+		res.status( 500 ).json({ error: { message: err.message } });
+	}
+});
+
+// Health check
+app.get( "/health", ( req, res ) => { return res.json({ status: "ok" }) });
+
+// Start server
+const PORT = process.env.PORT || 3000;
+app.listen( PORT, () =>
+{
+	logger.info( `🚀 OpenAI-compatible API listening at http://localhost:${PORT}/v1/chat/completions` );
+});

package/main.js

@@ -1,8 +1,8 @@
-const { ChatOpenAI } = require( "@langchain/openai" );
+const OpenAI = require( "openai" );
 const pino = require( "pino" );
 const pretty = require( "pino-pretty" );
-const stream = pretty({ colorize: true, ignore: "pid,hostname" });
-const logger = pino({ base: false }, stream );
+const pinoStream = pretty({ colorize: true, ignore: "pid,hostname" });
+const logger = pino({ base: false }, pinoStream );
 
 class AIRouter
 {
@@ -24,35 +24,111 @@ class AIRouter
 			try
 			{
 				logger.info( `Attempting with provider: ${provider.name}` );
-				let llm = new ChatOpenAI({
+				const client = new OpenAI({
 					apiKey: provider.apiKey,
-					model: provider.model,
-					configuration: {
-						baseURL: provider.apiUrl,
-					},
-					...restOptions,
+					baseURL: provider.apiUrl,
+					timeout: 60000,
 				});
 
-				if ( tools && tools.length > 0 )
-				{
-					llm = llm.bindTools( tools );
-				}
+				const params = {
+					model: provider.model,
+					messages,
+					...tools && tools.length > 0 ? { tools } : {},
+					stream: isStreaming,
+					...restOptions
+				};
 
 				if ( isStreaming )
 				{
-					const stream = await llm.stream( messages );
-					return stream;
+					const responseStream = await client.chat.completions.create( params );
+					return ( async function* ()
+					{
+						for await ( const chunk of responseStream )
+						{
+							const content = chunk.choices[0]?.delta?.content;
+							const reasoning = chunk.choices[0]?.delta?.reasoning
+							const tool_calls_delta = chunk.choices[0]?.delta?.tool_calls;
+							if ( content !== null )
+							{
+								chunk.content = content
+							}
+							if ( reasoning !== null )
+							{
+								chunk.reasoning = reasoning
+							}
+							if ( tool_calls_delta !== null )
+							{
+								chunk.tool_calls_delta = tool_calls_delta;
+							}
+							yield chunk;
+						}
+					})();
 				}
 				else
 				{
-					const response = await llm.invoke( messages, { timeout: 60000 });
+					const response = await client.chat.completions.create( params );
+					const content = response.choices[0]?.message?.content;
+					const reasoning = response.choices[0]?.message?.reasoning;
+					const tool_calls = response.choices[0]?.message?.tool_calls
+					if ( content !== null )
+					{
+						response.content = content
+					}
+					if ( reasoning !== null )
+					{
+						response.reasoning = reasoning
+					}
+					if ( tools !== null )
+					{
+						response.tool_calls = tool_calls
+					}
 					return response;
 				}
 			}
 			catch ( error )
 			{
 				lastError = error;
-				logger.error( `Failed with ${provider.name}:${error.message}` );
+				logger.error( `Failed with ${provider.name}: ${error.message}` );
+				// Continue to next provider
+			}
+		}
+		throw new Error( `All providers failed. Last error: ${lastError.message}` );
+	}
+
+	async chatCompletionWithResponse ( messages, options = {})
+	{
+		const { stream, tools, model, ...restOptions } = options;
+		const isStreaming = stream;
+
+		logger.info( `Starting chatCompletionWithResponse with ${this.providers.length} providers (streaming: ${isStreaming})` );
+		let lastError;
+
+		for ( const provider of this.providers )
+		{
+			try
+			{
+				logger.info( `Attempting with provider: ${provider.name}` );
+				const client = new OpenAI({
+					apiKey: provider.apiKey,
+					baseURL: provider.apiUrl,
+					timeout: 60000,
+				});
+
+				const params = {
+					model: provider.model,
+					messages,
+					...tools && tools.length > 0 ? { tools } : {},
+					stream: isStreaming,
+					...restOptions
+				};
+
+				const { data, response: rawResponse } = await client.chat.completions.create( params ).withResponse();
+				return { data, response: rawResponse }
+			}
+			catch ( error )
+			{
+				lastError = error;
+				logger.error( `Failed with ${provider.name}: ${error.message}` );
 				// Continue to next provider
 			}
 		}
@@ -60,4 +136,4 @@ class AIRouter
 	}
 }
 
-module.exports = AIRouter;
+module.exports = AIRouter;

package/openai-compatible-server/index.js

@@ -23,161 +23,52 @@ const aiRouter = new AIRouter( providers );
  */
 app.post( "/v1/chat/completions", async ( req, res ) =>
 {
-	try
+	const { messages, model, stream, ...rest } = req.body;
+
+	if ( !messages || !Array.isArray( messages ) )
 	{
-		const { messages, model, stream, ...rest } = req.body;
+		return res.status( 400 ).json({ error: { message: "messages must be an array" } });
+	}
 
-		if ( !messages || !Array.isArray( messages ) )
-		{
-			return res.status( 400 ).json({ error: { message: "messages must be an array" } });
-		}
+	if ( stream )
+	{
+		res.setHeader( "Content-Type", "text/event-stream" );
+		res.setHeader( "Cache-Control", "no-cache" );
+		res.setHeader( "Connection", "keep-alive" );
 
-		if ( stream )
+		try
 		{
-			// Streaming mode → use Server-Sent Events (SSE)
-			res.setHeader( "Content-Type", "text/event-stream" );
-			res.setHeader( "Cache-Control", "no-cache" );
-			res.setHeader( "Connection", "keep-alive" );
+			const result = await aiRouter.chatCompletionWithResponse( messages, { model, ...rest });
 
-			try
+			for await ( const chunk of result.data )
 			{
-				const response = await aiRouter.chatCompletion( messages, { model, ...rest }, true );
-				const id = `chatcmpl-${Date.now()}`;
-				const created = Math.floor( Date.now() / 1000 );
-				let fullResponse = null;
-				for await ( const chunk of response )
-				{
-					const modelName = chunk?.response_metadata?.model_name || model || "unknown";
-					const systemFingerprint = chunk?.response_metadata?.system_fingerprint || null;
-					let delta = { ... chunk.delta || { content: chunk.content || "" } };
-					if ( !delta.role ) delta.role = "assistant";
-					delta.reasoning = delta.reasoning || null;
-					delta.reasoning_details = delta.reasoning_details || [];
-					let toolCallsDelta = null;
-					if ( chunk.tool_calls && chunk.tool_calls.length > 0 )
-					{
-						toolCallsDelta = chunk.tool_calls.map( ( tc, index ) =>
-						{
-							return {
-								id: tc.id || `call_${Date.now()}_${Math.random().toString( 36 ).substr( 2, 9 )}`,
-								type: "function",
-								index,
-								function: {
-									name: tc.name,
-									arguments: JSON.stringify( tc.args || {})
-								}
-							};
-						});
-						delta.tool_calls = toolCallsDelta;
-						delta.content = "";
-					}
-					const chunkFinishReason = delta.finish_reason || chunk?.response_metadata?.finish_reason || null;
-					const chunkNativeFinishReason = delta.native_finish_reason || chunk?.response_metadata?.native_finish_reason || chunkFinishReason || null;
-					if ( chunk.content && !fullResponse ) fullResponse = chunk; // Capture full for reasoning if available
-					const payload = {
-						id,
-						provider: "OpenAI",
-						object: "chat.completion.chunk",
-						created,
-						model: modelName,
-						system_fingerprint: systemFingerprint,
-						choices: [
-							{
-								logprobs: null,
-								delta,
-								index: 0,
-								finish_reason: chunkFinishReason,
-								native_finish_reason: chunkNativeFinishReason,
-							},
-						],
-					};
-					const usage = chunk?.response_metadata?.usage;
-					if ( usage && typeof usage === "object" && !Array.isArray( usage ) && Object.keys( usage ).length > 0 )
-					{
-						payload.usage = chunk?.response_metadata?.usage || null;
-					}
-					res.write( `data: ${JSON.stringify( payload )}\n\n` );
-				}
-				// Send done signal
-				res.write( "data: [DONE]\n\n" );
-				res.end();
-			}
-			catch ( err )
-			{
-				logger.error( err );
-				res.write( `data: ${JSON.stringify({ error: err.message })}\n\n` );
-				res.write( "data: [DONE]\n\n" );
-				res.end();
+				res.write( `data: ${JSON.stringify( chunk )}\n\n` );
 			}
+
+			res.write( "data: [DONE]\n\n" );
 		}
-		else
+		catch ( err )
 		{
-			// Non-streaming → return one-shot completion
-			const response = await aiRouter.chatCompletion( messages, { model, ...rest }, false );
-			let reasoning = null;
-			let refusal = null;
-			let toolCalls = null;
-			if ( response.contentBlocks )
-			{
-				const reasoningBlocks = response.contentBlocks.filter( b => { return b.type === "reasoning" || b.type === "thinking" });
-				reasoning = reasoningBlocks.length > 0 ? reasoningBlocks.map( b => { return b.text }).join( "\n" ) : null;
-				const refusalBlocks = response.contentBlocks.filter( b => { return b.type === "refusal" });
-				refusal = refusalBlocks.length > 0 ? refusalBlocks.map( b => { return b.text }).join( "\n" ) : null;
-			}
-			if ( response.tool_calls && response.tool_calls.length > 0 )
-			{
-				toolCalls = response.tool_calls.map( ( tc, index ) =>
-				{
-				  return {
-					 id: tc.id || `call_${Date.now()}_${Math.random().toString( 36 ).substr( 2, 9 )}`,
-					 type: "function",
-					 index,
-					 function: {
-							name: tc.name,
-							arguments: JSON.stringify( tc.args || {})
-					 }
-				  };
-				});
-			}
-			const systemFingerprint = response.response_metadata?.system_fingerprint || null;
-			const finishReason = response.response_metadata?.finish_reason || null;
-			const nativeFinishReason = response.response_metadata?.native_finish_reason || finishReason || null;
-			const messageContent = toolCalls && toolCalls.length > 0 ? "" : response.content;
-			let finalResult = {
-				id: `chatcmpl_${Date.now()}`,
-				provider: "OpenAI",
-				object: "chat.completion",
-				created: Math.floor( Date.now() / 1000 ),
-				model: response.response_metadata?.model_name || model || "unknown",
-				system_fingerprint: systemFingerprint,
-				choices: [
-					{
-						logprobs: null,
-						finish_reason: finishReason,
-						native_finish_reason: nativeFinishReason,
-						index: 0,
-						message: {
-							role: "assistant",
-							content: messageContent,
-							refusal,
-							reasoning,
-							tool_calls: toolCalls
-						},
-					},
-				],
-			}
-			const usage = response?.response_metadata?.usage;
-			if ( usage && typeof usage === "object" && !Array.isArray( usage ) && Object.keys( usage ).length > 0 )
-			{
-				finalResult.usage = response?.response_metadata?.usage || null;
-			}
-			res.json( finalResult );
+			logger.error( err );
+			res.write( `data: ${JSON.stringify({ error: { message: err.message } })}\n\n` );
+			res.write( "data: [DONE]\n\n" );
 		}
+
+		res.end();
 	}
-	catch ( err )
+	else
 	{
-		logger.error( err );
-		res.status( 500 ).json({ error: { message: err.message } });
+		try
+		{
+			const result = await aiRouter.chatCompletionWithResponse( messages, { model, ...rest });
+
+			res.json( result.data );
+		}
+		catch ( err )
+		{
+			logger.error( err );
+			res.status( 500 ).json({ error: { message: err.message } });
+		}
 	}
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unified-ai-router",
-  "version": "2.4.4",
+  "version": "3.0.1",
   "description": "A unified interface for multiple LLM providers with automatic fallback. This project includes an OpenAI-compatible server and a deployable Telegram bot with a Mini App interface. It supports major providers like OpenAI, Google, Grok, and more, ensuring reliability and flexibility for your AI applications.",
   "license": "ISC",
   "author": "mlibre",
@@ -47,6 +47,7 @@
     "eslint": "^9.33.0",
     "express": "^5.1.0",
     "langchain": "^1.0.0-alpha.6",
+    "openai": "^5.23.0",
     "pino": "^9.9.0",
     "pino-pretty": "^13.1.1",
     "zod": "^3.25.76"

package/provider.js

@@ -1,11 +1,17 @@
 module.exports = [
+
+	{
+		name: "openrouter",
+		apiKey: process.env.OPENROUTER_API_KEY,
+		model: "deepseek/deepseek-r1-0528-qwen3-8b:free",
+		apiUrl: "https://openrouter.ai/api/v1",
+	},
 	{
 		name: "openrouter",
 		apiKey: process.env.OPENROUTER_API_KEY,
 		model: "x-ai/grok-4-fast:free",
 		apiUrl: "https://openrouter.ai/api/v1",
 	},
-
 	{
 		name: "cerebras",
 		apiKey: process.env.CEREBRAS_API_KEY,

package/readme.md

@@ -1,31 +1,37 @@
 # Unified AI Router
 
-A unified interface for multiple LLM providers with automatic fallback. This project includes an OpenAI-compatible server and a deployable Telegram bot with a Mini App interface. It supports major providers like OpenAI, Google, Grok, and more, ensuring reliability and flexibility for your AI applications.
-
-* [🚀 Features](#-features)
-* [🛠️ Installation](#️-installation)
-* [📖 Usage](#-usage)
-  * [📚 Basic Library Usage](#-basic-library-usage)
-  * [🤖 OpenAI-Compatible Server](#-openai-compatible-server)
-  * [🧪 Testing](#-testing)
-* [🔧 Supported Providers](#-supported-providers)
-* [🔑 API Keys](#-api-keys)
-* [🔼 Vercel Deployment (Telegram Bot)](#-vercel-deployment-telegram-bot)
-  * [📋 Prerequisites](#-prerequisites)
-  * [🚀 Deployment Steps](#-deployment-steps)
-  * [📱 Enable Telegram Mini App](#-enable-telegram-mini-app)
-* [📁 Project Structure](#-project-structure)
-* [📄 License](#-license)
+Unified AI Router is a comprehensive toolkit for AI applications, featuring:
+
+- A unified interface for multiple LLM providers with automatic fallback (the core router library)
+- An OpenAI-compatible server for seamless API integration
+- A deployable Telegram bot with Mini App interface
+
+It supports major providers like OpenAI, Google, Grok, and more, ensuring reliability and flexibility.
+
+- [🚀 Features](#-features)
+- [🛠️ Installation](#️-installation)
+- [📖 Usage](#-usage)
+  - [📚 Basic Library Usage](#-basic-library-usage)
+  - [🔌 OpenAI-Compatible Server](#-openai-compatible-server)
+  - [🧪 Testing](#-testing)
+- [🔧 Supported Providers](#-supported-providers)
+- [🔑 API Keys](#-api-keys)
+- [🔼 Vercel Deployment (Telegram Bot)](#-vercel-deployment-telegram-bot)
+  - [📋 Prerequisites](#-prerequisites)
+  - [🚀 Deployment Steps](#-deployment-steps)
+  - [📱 Enable Telegram Mini App](#-enable-telegram-mini-app)
+- [📁 Project Structure](#-project-structure)
+- [📄 License](#-license)
 
 ## 🚀 Features
 
-* **Multi-Provider Support**: Works with OpenAI, Google, Grok, OpenRouter, Z.ai, Qroq, Cohere, Vercel, Cerebras, and LLM7
-* **Automatic Fallback**: If one provider fails, automatically tries the next
-* **Simple API**: Easy to use interface for all supported providers
-* **OpenAI-Compatible Server**: Drop-in replacement for OpenAI API
-* **Streaming and Non-Streaming**: Supports both streaming and non-streaming responses
-* **Tool Support**: Use tools with your LLM calls
-* **Telegram Bot**: Deployable as a Telegram bot with a Mini App interface
+- **Multi-Provider Support**: Works with OpenAI, Google, Grok, OpenRouter, Z.ai, Qroq, Cohere, Vercel, Cerebras, and LLM7
+- **Automatic Fallback**: If one provider fails, automatically tries the next
+- **Simple API**: Easy-to-use interface for all supported providers
+- **OpenAI-Compatible Server**: Drop-in replacement for the OpenAI API, enabling easy integration with existing tools and clients
+- **Streaming and Non-Streaming Support**: Handles both streaming and non-streaming responses
+- **Tool Calling**: Full support for tools in LLM interactions
+- **Telegram Bot Integration**: Deployable as a Telegram bot with an interactive Mini App interface
 
 ## 🛠️ Installation
 
@@ -76,17 +82,17 @@ const response = await llm.chatCompletion(messages, {
 console.log(response);
 ```
 
-### 🤖 OpenAI-Compatible Server
+### 🔌 OpenAI-Compatible Server
 
-The project includes an OpenAI-compatible server that can be used as a drop-in replacement for the OpenAI API.
+The OpenAI-compatible server provides a drop-in replacement for the OpenAI API. It routes requests through the unified router with fallback logic, ensuring high availability.
 
-To start the server, run:
+To start the server locally, run:
 
 ```bash
 npm start
 ```
 
-The server will be available at `http://localhost:3000/v1/chat/completions`.
+The server listens at `http://localhost:3000/v1/chat/completions` and supports standard OpenAI endpoints like `/v1/chat/completions`.
 
 ### 🧪 Testing
 
@@ -108,32 +114,32 @@ node tests/tools.js
 
 ## 🔧 Supported Providers
 
-* OpenAI
-* Google Gemini
-* Grok
-* OpenRouter
-* Z.ai
-* Qroq
-* Cohere
-* Vercel
-* Cerebras
-* LLM7
+- OpenAI
+- Google Gemini
+- Grok
+- OpenRouter
+- Z.ai
+- Qroq
+- Cohere
+- Vercel
+- Cerebras
+- LLM7
 
 ## 🔑 API Keys
 
 Get your API keys from the following providers:
 
-* **OpenAI**: [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
-* **Google Gemini**: [aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey)
-* **Grok**: [console.x.ai](https://console.x.ai/)
-* **OpenRouter**: [openrouter.ai/keys](https://openrouter.ai/keys)
-* **Z.ai**: [api.z.ai](https://api.z.ai)
-* **Qroq**: [console.groq.com/keys](https://console.groq.com/keys)
-* **Cohere**: [dashboard.cohere.com/api-keys](https://dashboard.cohere.com/api-keys)
-* **Vercel**: [vercel.com/docs/ai/ai-gateway](https://vercel.com/masoud-ghorbanzadehs-projects/~/ai/api-keys)
-* **Cerebras**: [cloud.cerebras.ai](https://cloud.cerebras.ai)
-* **LLM7**: [token.llm7.io](https://token.llm7.io/)
-  * Seems like it does not support tool calling
+- **OpenAI**: [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
+- **Google Gemini**: [aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey)
+- **Grok**: [console.x.ai](https://console.x.ai/)
+- **OpenRouter**: [openrouter.ai/keys](https://openrouter.ai/keys)
+- **Z.ai**: [api.z.ai](https://api.z.ai)
+- **Qroq**: [console.groq.com/keys](https://console.groq.com/keys)
+- **Cohere**: [dashboard.cohere.com/api-keys](https://dashboard.cohere.com/api-keys)
+- **Vercel AI Gateway**: [vercel.com/docs/ai/ai-gateway](https://vercel.com/docs/ai-gateway)
+- **Cerebras**: [cloud.cerebras.ai](https://cloud.cerebras.ai)
+- **LLM7**: [token.llm7.io](https://token.llm7.io/)
+  - Seems like it does not support tool calling
 
 ## 🔼 Vercel Deployment (Telegram Bot)
 
@@ -141,9 +147,9 @@ This section describes how to deploy the AIRouter as a Telegram bot using Vercel
 
 ### 📋 Prerequisites
 
-* A Telegram Bot Token (@BotFather)
-* API keys for various AI providers
-* Vercel account
+- A Telegram Bot Token (@BotFather)
+- API keys for various AI providers
+- Vercel account
 
 ### 🚀 Deployment Steps
 
@@ -196,16 +202,16 @@ curl "https://ai-router-flame.vercel.app/api?register_webhook=true"
 After deploying the bot, you need to configure the Telegram Mini App and menu button:
 
 1. **Configure Mini App:**
-   * Go to [@BotFather](https://t.me/botfather)
-   * Send `/mybots` and select your bot
-   * Go to `Bot Settings` → `Configure Mini App`
-   * Set the Mini App URL to: `https://ai-router-flame.vercel.app`
+   - Go to [@BotFather](https://t.me/botfather)
+   - Send `/mybots` and select your bot
+   - Go to `Bot Settings` → `Configure Mini App`
+   - Set the Mini App URL to: `https://ai-router-flame.vercel.app`
 
 2. **Configure Menu Button:**
-   * Go to [@BotFather](https://t.me/botfather)
-   * Send `/mybots` and select your bot
-   * Go to `Bot Settings` → `Menu Button`
-   * Ensure the URL shown is: `https://ai-router-flame.vercel.app`
+   - Go to [@BotFather](https://t.me/botfather)
+   - Send `/mybots` and select your bot
+   - Go to `Bot Settings` → `Menu Button`
+   - Ensure the URL shown is: `https://ai-router-flame.vercel.app`
 
 Once configured, users can access the Mini App by sending `/start` or `/app` to your bot, or through the menu button.
 
@@ -213,17 +219,17 @@ An example of a deployed bot is accessible on Telegram: [https://t.me/freePulseA
 
 ## 📁 Project Structure
 
-* `main.js` - The core AIRouter library.
-* `provider.js` - A list of supported AI providers.
-* `openai-compatible-server/index.js` - An OpenAI-compatible server.
-* `tests/` - A suite of tests for the library and server.
-* `bruno/` - A Bruno collection for API testing.
-* `vercel-project/` - A Vercel project for deploying a Telegram bot.
-  * `api/index.js` - Main webhook handler for the Telegram bot.
-  * `api/search.js` - A search proxy for the Telegram bot.
-  * `public/` - The frontend for the Telegram Mini App.
-  * `src/config.js` - Configuration for the Telegram bot.
-  * `src/telegram.js` - Telegram client implementation.
+- `main.js` - Core AIRouter library implementing the unified interface and fallback logic
+- `provider.js` - Configuration for supported AI providers
+- `openai-compatible-server/index.js` - OpenAI-compatible API server
+- `tests/` - Comprehensive tests for the library, server, and tools
+- `bruno/` - Bruno API collection for testing endpoints
+- `vercel-project/` - Ready-to-deploy Vercel setup for the Telegram bot
+  - `api/index.js` - Telegram webhook handler
+  - `api/search.js` - Search proxy endpoint
+  - `public/` - Mini App frontend (HTML, CSS, JS)
+  - `src/config.js` - Bot configuration
+  - `src/telegram.js` - Telegram API integration
 
 ## 📄 License
 

package/tests/chat.js

@@ -20,7 +20,7 @@ async function getResponse ()
 
 		for await ( const chunk of stream )
 		{
-			process.stdout.write( chunk.content );
+			process.stdout.write( chunk.reasoning || chunk.content );
 		}
 	}
 	catch ( error )

package/tests/tools.js

@@ -1,105 +1,130 @@
 const AIRouter = require( "../main" );
-const { tool } = require( "langchain" );
-const z = require( "zod" );
 require( "dotenv" ).config({ quiet: true });
 
 const providers = require( "../provider" )
 const llm = new AIRouter( providers );
 
-// Example tool: Multiply two numbers
-const multiplyTool = tool(
-	async ({ a, b }) =>
+// Tool functions
+async function multiply ({ a, b })
+{
+	return {
+		result: a * b,
+	}
+}
+
+async function getWeather ({ city })
+{
+	// Mock weather data for demonstration
+	const mockWeather = {
+		city,
+		temperature: 25,
+		condition: "Sunny",
+		humidity: 50,
+		wind: "10 km/h"
+	};
+	return mockWeather;
+}
+
+const tools = [
 	{
-		return {
-			result: a * b,
-		}
+		type: "function",
+		function: {
+			name: "multiply",
+			description: "Multiply two numbers",
+			parameters: {
+				type: "object",
+				properties: {
+					a: {
+						type: "number",
+						description: "First number"
+					},
+					b: {
+						type: "number",
+						description: "Second number"
+					},
+				},
+				required: ["a", "b"],
+				additionalProperties: false,
+			},
+			strict: true,
+		},
+	},
+	{
+		type: "function",
+		function: {
+			name: "get_weather",
+			description: "Get the current weather forecast for a given city.",
+			parameters: {
+				type: "object",
+				properties: {
+					city: {
+						type: "string",
+						description: "The name of the city (e.g., Tehran) to get the weather for."
+					}
+				},
+				required: ["city"],
+				additionalProperties: false,
+			},
+			strict: true,
+		},
 	},
+];
+
+const toolMap = {
+	multiply,
+	get_weather: getWeather,
+};
+
+async function executeTool ( toolCall )
+{
+	const toolFn = toolMap[toolCall.function.name];
+	if ( !toolFn )
 	{
-		name: "multiply",
-		description: "Multiply two numbers",
-		schema: z.object({
-			a: z.number().describe( "First number" ),
-			b: z.number().describe( "Second number" ),
-		}),
+		throw new Error( `Unknown tool: ${toolCall.function.name}` );
 	}
-);
 
-const weatherTool = tool(
-	async ({ city }) =>
+	let result;
+	try
 	{
-		// Mock weather data for demonstration
-		const mockWeather = {
-			city,
-			temperature: 25,
-			condition: "Sunny",
-			humidity: 50,
-			wind: "10 km/h"
-		};
-		return mockWeather;
-	},
+		const args = JSON.parse( toolCall.function.arguments );
+		result = await toolFn( args );
+		console.log( `Tool "${toolCall.function.name}" executed with result:`, result );
+	}
+	catch ( toolError )
 	{
-		name: "get_weather",
-		description: "Get the current weather forecast for a given city.",
-		schema: z.object({
-			city: z.string().describe( "The name of the city (e.g., Tehran) to get the weather for." )
-		})
+		console.error( `Error executing tool "${toolCall.function.name}":`, toolError.message );
+		result = `Error: ${toolError.message}`;
 	}
-);
+
+	return {
+		tool_call_id: toolCall.id,
+		content: typeof result === "object" ? JSON.stringify( result ) : result,
+		name: toolCall.function.name
+	};
+}
 async function main ()
 {
 	try
 	{
 		const messages = [
-			{ role: "system", content: "You are a helpful assistant with access to tools for calculations and weather forecasts. Use the multiply tool for calculations and the get_weather tool for weather information." },
-			{ role: "user", content: "What's the weather like in Tehran today?" }
+			{ role: "system", content: "You are a helpful assistant with access to tools for calculations and weather forecasts. Use the multiply tool for calculations, the get_weather tool for weather information." },
+			{ role: "user", content: "how is weather in tehran today and what 1099*45?" }
 		];
 
 		const response = await llm.chatCompletion( messages, {
 			temperature: 0,
-			tools: [multiplyTool, weatherTool],
+			tools,
 		});
 
-		console.log( "Weather tool example response:", response );
+		console.log( "weather tool example response:", response );
 
 		const toolResults = [];
 		if ( response.tool_calls && response.tool_calls.length > 0 )
 		{
 			for ( const toolCall of response.tool_calls )
 			{
-				let selectedTool;
-				if ( toolCall.name === "multiply" )
-				{
-					selectedTool = multiplyTool;
-				}
-				else if ( toolCall.name === "get_weather" )
-				{
-					selectedTool = weatherTool;
-				}
-
-				if ( selectedTool )
-				{
-					try
-					{
-						const result = await selectedTool.call( toolCall.args );
-						console.log( `Tool "${toolCall.name}" executed with result:`, result );
-						toolResults.push({
-							tool_call_id: toolCall.id,
-							content: JSON.stringify( result )
-						});
-					}
-					catch ( toolError )
-					{
-						console.error( `Error executing tool "${toolCall.name}":`, toolError.message );
-						toolResults.push({
-							tool_call_id: toolCall.id,
-							content: `Error: ${toolError.message}`
-						});
-					}
-				}
-				else
-				{
-					console.warn( `Unknown tool: ${toolCall.name}` );
-				}
+				const toolResult = await executeTool( toolCall );
+				toolResults.push( toolResult );
 			}
 
 			if ( toolResults.length > 0 )
@@ -116,13 +141,14 @@ async function main ()
 						return {
 							role: "tool",
 							content: tr.content,
-							tool_call_id: tr.tool_call_id
+							tool_call_id: tr.tool_call_id,
+							name: tr.name
 						}
 					})
 				];
 				const finalResponse = await llm.chatCompletion( updatedMessages, {
 					temperature: 0,
-					tools: [multiplyTool, weatherTool]
+					tools
 				});
 				console.log( "Final response after tool execution:", finalResponse.content || finalResponse );
 			}