neural-ai-sdk 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NeuralArc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,201 @@
+# Neural AI SDK
+
+A unified JavaScript/TypeScript SDK for interacting with various AI LLM providers. This SDK allows you to integrate multiple AI models from different organizations through a single consistent interface.
+
+## Supported AI Providers
+
+- OpenAI (GPT models)
+- Google (Gemini models)
+- DeepSeek
+- Ollama (local models)
+- HuggingFace
+
+## Installation
+
+```bash
+npm install neural-ai-sdk
+```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { NeuralAI, AIProvider } from "neural-ai-sdk";
+
+// Create an OpenAI model
+const openaiModel = NeuralAI.createModel(AIProvider.OPENAI, {
+  apiKey: "your-openai-api-key", // Optional if OPENAI_API_KEY environment variable is set
+  model: "gpt-4",
+});
+
+// Generate a response
+async function generateResponse() {
+  const response = await openaiModel.generate({
+    prompt: "What is artificial intelligence?",
+    systemPrompt: "You are a helpful AI assistant.",
+  });
+
+  console.log(response.text);
+}
+
+generateResponse();
+```
+
+### Environment Variables Support
+
+You can provide API keys and base URLs through environment variables instead of directly in code:
+
+```typescript
+// No need to provide API keys in code if they're set as environment variables
+const openaiModel = NeuralAI.createModel(AIProvider.OPENAI, {
+  model: "gpt-4",
+});
+
+const googleModel = NeuralAI.createModel(AIProvider.GOOGLE, {
+  model: "gemini-pro",
+});
+```
+
+Available environment variables:
+
+| Provider    | API Key Variable      | Base URL Variable (optional) |
+| ----------- | --------------------- | ---------------------------- |
+| OpenAI      | `OPENAI_API_KEY`      | -                            |
+| Google      | `GOOGLE_API_KEY`      | -                            |
+| DeepSeek    | `DEEPSEEK_API_KEY`    | `DEEPSEEK_BASE_URL`          |
+| HuggingFace | `HUGGINGFACE_API_KEY` | `HUGGINGFACE_BASE_URL`       |
+| Ollama      | -                     | `OLLAMA_BASE_URL`            |
+
+### Using Streaming
+
+```typescript
+import { NeuralAI, AIProvider } from "neural-ai-sdk";
+
+// Create a Google model
+const googleModel = NeuralAI.createModel(AIProvider.GOOGLE, {
+  apiKey: "your-google-api-key",
+  model: "gemini-pro",
+});
+
+// Stream a response
+async function streamResponse() {
+  const stream = googleModel.stream({
+    prompt: "Write a short story about AI.",
+  });
+
+  for await (const chunk of stream) {
+    process.stdout.write(chunk);
+  }
+}
+
+streamResponse();
+```
+
+### Working With Different Providers
+
+```typescript
+import { NeuralAI, AIProvider } from "neural-ai-sdk";
+
+// Create Ollama model (for local inference)
+const ollamaModel = NeuralAI.createModel(AIProvider.OLLAMA, {
+  // baseURL is optional if OLLAMA_BASE_URL environment variable is set
+  model: "llama2",
+});
+
+// Create HuggingFace model
+const huggingfaceModel = NeuralAI.createModel(AIProvider.HUGGINGFACE, {
+  // apiKey is optional if HUGGINGFACE_API_KEY environment variable is set
+  model: "meta-llama/Llama-2-7b-chat-hf",
+});
+
+// Create DeepSeek model
+const deepseekModel = NeuralAI.createModel(AIProvider.DEEPSEEK, {
+  // apiKey is optional if DEEPSEEK_API_KEY environment variable is set
+  model: "deepseek-chat",
+});
+```
+
+## Environment Configuration
+
+You can set up environment variables by:
+
+1. Creating a `.env` file in your project root
+2. Setting environment variables in your deployment platform
+3. Setting them in your system environment
+
+Example `.env` file:
+
+```
+OPENAI_API_KEY=your_openai_key_here
+GOOGLE_API_KEY=your_google_key_here
+DEEPSEEK_API_KEY=your_deepseek_key_here
+HUGGINGFACE_API_KEY=your_huggingface_key_here
+OLLAMA_BASE_URL=http://localhost:11434/api
+```
+
+Make sure to load environment variables from your `.env` file using a package like `dotenv`:
+
+```javascript
+require("dotenv").config();
+```
+
+## Configuration Options
+
+All models accept the following configuration options:
+
+| Option        | Description                                                                    |
+| ------------- | ------------------------------------------------------------------------------ |
+| `apiKey`      | API key for authentication (optional if set as environment variable)           |
+| `baseURL`     | Base URL for the API (optional, uses environment variable or default endpoint) |
+| `model`       | The model to use (optional, each provider has a default)                       |
+| `temperature` | Controls randomness (0.0 to 1.0)                                               |
+| `maxTokens`   | Maximum number of tokens to generate                                           |
+| `topP`        | Nucleus sampling parameter                                                     |
+
+## Using Request Options
+
+You can provide options at the time of the request that override the model's default configuration:
+
+```typescript
+const response = await openaiModel.generate({
+  prompt: "Explain quantum computing",
+  options: {
+    temperature: 0.7,
+    maxTokens: 500,
+  },
+});
+```
+
+## Advanced Usage
+
+### Access Raw API Responses
+
+Each response includes a `raw` property with the full response data from the provider:
+
+```typescript
+const response = await openaiModel.generate({
+  prompt: "Summarize machine learning",
+});
+
+// Access the raw response data
+console.log(response.raw);
+```
+
+### Response Usage Information
+
+When available, you can access token usage information:
+
+```typescript
+const response = await openaiModel.generate({
+  prompt: "Explain neural networks",
+});
+
+console.log(`Prompt tokens: ${response.usage?.promptTokens}`);
+console.log(`Completion tokens: ${response.usage?.completionTokens}`);
+console.log(`Total tokens: ${response.usage?.totalTokens}`);
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { AIProvider, type AIModelConfig, type AIModelRequest, type AIModelResponse, type AIModel, } from "./types";
+export { OpenAIModel } from "./models/openai-model";
+export { GoogleModel } from "./models/google-model";
+export { DeepSeekModel } from "./models/deepseek-model";
+export { OllamaModel } from "./models/ollama-model";
+export { HuggingFaceModel } from "./models/huggingface-model";
+import { AIProvider, AIModelConfig } from "./types";
+import { OpenAIModel } from "./models/openai-model";
+import { GoogleModel } from "./models/google-model";
+import { DeepSeekModel } from "./models/deepseek-model";
+import { OllamaModel } from "./models/ollama-model";
+import { HuggingFaceModel } from "./models/huggingface-model";
+export declare class NeuralAI {
+    /**
+     * Create an AI model instance based on the provider and configuration
+     * @param provider The AI provider to use
+     * @param config Configuration for the AI model
+     * @returns An instance of the specified AI model
+     */
+    static createModel(provider: AIProvider, config: AIModelConfig): OpenAIModel | GoogleModel | DeepSeekModel | OllamaModel | HuggingFaceModel;
+}

package/dist/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeuralAI = exports.HuggingFaceModel = exports.OllamaModel = exports.DeepSeekModel = exports.GoogleModel = exports.OpenAIModel = exports.AIProvider = void 0;
+// Type exports
+var types_1 = require("./types");
+Object.defineProperty(exports, "AIProvider", { enumerable: true, get: function () { return types_1.AIProvider; } });
+// Model implementations
+var openai_model_1 = require("./models/openai-model");
+Object.defineProperty(exports, "OpenAIModel", { enumerable: true, get: function () { return openai_model_1.OpenAIModel; } });
+var google_model_1 = require("./models/google-model");
+Object.defineProperty(exports, "GoogleModel", { enumerable: true, get: function () { return google_model_1.GoogleModel; } });
+var deepseek_model_1 = require("./models/deepseek-model");
+Object.defineProperty(exports, "DeepSeekModel", { enumerable: true, get: function () { return deepseek_model_1.DeepSeekModel; } });
+var ollama_model_1 = require("./models/ollama-model");
+Object.defineProperty(exports, "OllamaModel", { enumerable: true, get: function () { return ollama_model_1.OllamaModel; } });
+var huggingface_model_1 = require("./models/huggingface-model");
+Object.defineProperty(exports, "HuggingFaceModel", { enumerable: true, get: function () { return huggingface_model_1.HuggingFaceModel; } });
+// Factory class for easier model creation
+const types_2 = require("./types");
+const openai_model_2 = require("./models/openai-model");
+const google_model_2 = require("./models/google-model");
+const deepseek_model_2 = require("./models/deepseek-model");
+const ollama_model_2 = require("./models/ollama-model");
+const huggingface_model_2 = require("./models/huggingface-model");
+class NeuralAI {
+    /**
+     * Create an AI model instance based on the provider and configuration
+     * @param provider The AI provider to use
+     * @param config Configuration for the AI model
+     * @returns An instance of the specified AI model
+     */
+    static createModel(provider, config) {
+        switch (provider) {
+            case types_2.AIProvider.OPENAI:
+                return new openai_model_2.OpenAIModel(config);
+            case types_2.AIProvider.GOOGLE:
+                return new google_model_2.GoogleModel(config);
+            case types_2.AIProvider.DEEPSEEK:
+                return new deepseek_model_2.DeepSeekModel(config);
+            case types_2.AIProvider.OLLAMA:
+                return new ollama_model_2.OllamaModel(config);
+            case types_2.AIProvider.HUGGINGFACE:
+                return new huggingface_model_2.HuggingFaceModel(config);
+            default:
+                throw new Error(`Unsupported AI provider: ${provider}`);
+        }
+    }
+}
+exports.NeuralAI = NeuralAI;

package/dist/models/base-model.d.ts

@@ -0,0 +1,9 @@
+import { AIModel, AIModelConfig, AIModelRequest, AIModelResponse, AIProvider } from "../types";
+export declare abstract class BaseModel implements AIModel {
+    protected config: AIModelConfig;
+    abstract provider: AIProvider;
+    constructor(config: AIModelConfig);
+    abstract generate(request: AIModelRequest): Promise<AIModelResponse>;
+    abstract stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+    protected mergeConfig(options?: Partial<AIModelConfig>): AIModelConfig;
+}

package/dist/models/base-model.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModel = void 0;
+class BaseModel {
+    constructor(config) {
+        this.config = config;
+    }
+    mergeConfig(options) {
+        return {
+            ...this.config,
+            ...(options || {}),
+        };
+    }
+}
+exports.BaseModel = BaseModel;

package/dist/models/deepseek-model.d.ts

@@ -0,0 +1,9 @@
+import { AIModelConfig, AIModelRequest, AIModelResponse, AIProvider } from "../types";
+import { BaseModel } from "./base-model";
+export declare class DeepSeekModel extends BaseModel {
+    readonly provider = AIProvider.DEEPSEEK;
+    private baseURL;
+    constructor(config: AIModelConfig);
+    generate(request: AIModelRequest): Promise<AIModelResponse>;
+    stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+}

package/dist/models/deepseek-model.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepSeekModel = void 0;
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("../types");
+const base_model_1 = require("./base-model");
+const utils_1 = require("../utils");
+class DeepSeekModel extends base_model_1.BaseModel {
+    constructor(config) {
+        super(config);
+        this.provider = types_1.AIProvider.DEEPSEEK;
+        const apiKey = (0, utils_1.getApiKey)(config.apiKey, "DEEPSEEK_API_KEY", "DeepSeek");
+        this.baseURL = (0, utils_1.getBaseUrl)(config.baseURL, "DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1");
+    }
+    async generate(request) {
+        const config = this.mergeConfig(request.options);
+        const messages = [];
+        if (request.systemPrompt) {
+            messages.push({
+                role: "system",
+                content: request.systemPrompt,
+            });
+        }
+        messages.push({
+            role: "user",
+            content: request.prompt,
+        });
+        const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+            model: config.model || "deepseek-chat",
+            messages,
+            temperature: config.temperature,
+            max_tokens: config.maxTokens,
+            top_p: config.topP,
+        }, {
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey ||
+                    (0, utils_1.getApiKey)(config.apiKey, "DEEPSEEK_API_KEY", "DeepSeek")}`,
+            },
+        });
+        return {
+            text: response.data.choices[0].message.content,
+            usage: {
+                promptTokens: response.data.usage?.prompt_tokens,
+                completionTokens: response.data.usage?.completion_tokens,
+                totalTokens: response.data.usage?.total_tokens,
+            },
+            raw: response.data,
+        };
+    }
+    async *stream(request) {
+        const config = this.mergeConfig(request.options);
+        const messages = [];
+        if (request.systemPrompt) {
+            messages.push({
+                role: "system",
+                content: request.systemPrompt,
+            });
+        }
+        messages.push({
+            role: "user",
+            content: request.prompt,
+        });
+        const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+            model: config.model || "deepseek-chat",
+            messages,
+            temperature: config.temperature,
+            max_tokens: config.maxTokens,
+            top_p: config.topP,
+            stream: true,
+        }, {
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey ||
+                    (0, utils_1.getApiKey)(config.apiKey, "DEEPSEEK_API_KEY", "DeepSeek")}`,
+            },
+            responseType: "stream",
+        });
+        const reader = response.data;
+        for await (const chunk of reader) {
+            const lines = chunk.toString().split("\n").filter(Boolean);
+            for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                    const data = line.slice(6);
+                    if (data === "[DONE]")
+                        continue;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const content = parsed.choices[0]?.delta?.content;
+                        if (content) {
+                            yield content;
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error parsing DeepSeek stream data:", error);
+                    }
+                }
+            }
+        }
+    }
+}
+exports.DeepSeekModel = DeepSeekModel;

package/dist/models/google-model.d.ts

@@ -0,0 +1,10 @@
+import { AIModelConfig, AIModelRequest, AIModelResponse, AIProvider } from "../types";
+import { BaseModel } from "./base-model";
+export declare class GoogleModel extends BaseModel {
+    readonly provider = AIProvider.GOOGLE;
+    private client;
+    constructor(config: AIModelConfig);
+    generate(request: AIModelRequest): Promise<AIModelResponse>;
+    stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+    private formatPrompt;
+}

package/dist/models/google-model.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleModel = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const types_1 = require("../types");
+const base_model_1 = require("./base-model");
+const utils_1 = require("../utils");
+class GoogleModel extends base_model_1.BaseModel {
+    constructor(config) {
+        super(config);
+        this.provider = types_1.AIProvider.GOOGLE;
+        const apiKey = (0, utils_1.getApiKey)(config.apiKey, "GOOGLE_API_KEY", "Google");
+        this.client = new generative_ai_1.GoogleGenerativeAI(apiKey);
+    }
+    async generate(request) {
+        const config = this.mergeConfig(request.options);
+        const model = this.client.getGenerativeModel({
+            model: config.model || "gemini-2.0-flash", // Updated default model
+            generationConfig: {
+                temperature: config.temperature,
+                maxOutputTokens: config.maxTokens,
+                topP: config.topP,
+            },
+        });
+        const prompt = this.formatPrompt(request);
+        const result = await model.generateContent(prompt);
+        const response = result.response;
+        return {
+            text: response.text(),
+            raw: response,
+        };
+    }
+    async *stream(request) {
+        const config = this.mergeConfig(request.options);
+        const model = this.client.getGenerativeModel({
+            model: config.model || "gemini-2.0-flash", // Updated default model
+            generationConfig: {
+                temperature: config.temperature,
+                maxOutputTokens: config.maxTokens,
+                topP: config.topP,
+            },
+        });
+        const prompt = this.formatPrompt(request);
+        const result = await model.generateContentStream(prompt);
+        for await (const chunk of result.stream) {
+            const text = chunk.text();
+            if (text) {
+                yield text;
+            }
+        }
+    }
+    formatPrompt(request) {
+        const parts = [];
+        if (request.systemPrompt) {
+            parts.push(request.systemPrompt);
+        }
+        parts.push(request.prompt);
+        return parts;
+    }
+}
+exports.GoogleModel = GoogleModel;

package/dist/models/huggingface-model.d.ts

@@ -0,0 +1,9 @@
+import { AIModelConfig, AIModelRequest, AIModelResponse, AIProvider } from "../types";
+import { BaseModel } from "./base-model";
+export declare class HuggingFaceModel extends BaseModel {
+    readonly provider = AIProvider.HUGGINGFACE;
+    private baseURL;
+    constructor(config: AIModelConfig);
+    generate(request: AIModelRequest): Promise<AIModelResponse>;
+    stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+}

package/dist/models/huggingface-model.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HuggingFaceModel = void 0;
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("../types");
+const base_model_1 = require("./base-model");
+const utils_1 = require("../utils");
+class HuggingFaceModel extends base_model_1.BaseModel {
+    constructor(config) {
+        super(config);
+        this.provider = types_1.AIProvider.HUGGINGFACE;
+        const apiKey = (0, utils_1.getApiKey)(config.apiKey, "HUGGINGFACE_API_KEY", "HuggingFace");
+        this.baseURL = (0, utils_1.getBaseUrl)(config.baseURL, "HUGGINGFACE_BASE_URL", "https://api-inference.huggingface.co/models");
+    }
+    async generate(request) {
+        const config = this.mergeConfig(request.options);
+        const model = config.model || "meta-llama/Llama-2-7b-chat-hf";
+        let fullPrompt = request.prompt;
+        if (request.systemPrompt) {
+            fullPrompt = `${request.systemPrompt}\n\n${fullPrompt}`;
+        }
+        const payload = {
+            inputs: fullPrompt,
+            parameters: {
+                temperature: config.temperature,
+                max_new_tokens: config.maxTokens,
+                top_p: config.topP,
+                return_full_text: false,
+            },
+        };
+        const response = await axios_1.default.post(`${this.baseURL}/${model}`, payload, {
+            headers: {
+                Authorization: `Bearer ${config.apiKey ||
+                    (0, utils_1.getApiKey)(config.apiKey, "HUGGINGFACE_API_KEY", "HuggingFace")}`,
+                "Content-Type": "application/json",
+            },
+        });
+        // HuggingFace can return different formats depending on the model
+        let text = "";
+        if (Array.isArray(response.data)) {
+            text = response.data[0]?.generated_text || "";
+        }
+        else if (response.data.generated_text) {
+            text = response.data.generated_text;
+        }
+        else {
+            text = JSON.stringify(response.data);
+        }
+        return {
+            text,
+            raw: response.data,
+        };
+    }
+    async *stream(request) {
+        // HuggingFace Inference API doesn't natively support streaming for all models
+        // We'll implement a basic chunking on top of the non-streaming API
+        const response = await this.generate(request);
+        // Simple chunking for demonstration purposes
+        const chunkSize = 10;
+        const text = response.text;
+        for (let i = 0; i < text.length; i += chunkSize) {
+            const chunk = text.slice(i, i + chunkSize);
+            yield chunk;
+            // Add a small delay to simulate streaming
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+}
+exports.HuggingFaceModel = HuggingFaceModel;

package/dist/models/ollama-model.d.ts

@@ -0,0 +1,9 @@
+import { AIModelConfig, AIModelRequest, AIModelResponse, AIProvider } from "../types";
+import { BaseModel } from "./base-model";
+export declare class OllamaModel extends BaseModel {
+    readonly provider = AIProvider.OLLAMA;
+    private baseURL;
+    constructor(config: AIModelConfig);
+    generate(request: AIModelRequest): Promise<AIModelResponse>;
+    stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+}

package/dist/models/ollama-model.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaModel = void 0;
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("../types");
+const base_model_1 = require("./base-model");
+const utils_1 = require("../utils");
+class OllamaModel extends base_model_1.BaseModel {
+    constructor(config) {
+        super(config);
+        this.provider = types_1.AIProvider.OLLAMA;
+        this.baseURL = (0, utils_1.getBaseUrl)(config.baseURL, "OLLAMA_BASE_URL", "http://localhost:11434/api");
+    }
+    async generate(request) {
+        const config = this.mergeConfig(request.options);
+        let prompt = request.prompt;
+        // Add system prompt if provided
+        if (request.systemPrompt) {
+            prompt = `${request.systemPrompt}\n\n${prompt}`;
+        }
+        const response = await axios_1.default.post(`${this.baseURL}/generate`, {
+            model: config.model || "llama2",
+            prompt,
+            temperature: config.temperature,
+            num_predict: config.maxTokens,
+            top_p: config.topP,
+        });
+        return {
+            text: response.data.response,
+            usage: {
+                promptTokens: response.data.prompt_eval_count,
+                completionTokens: response.data.eval_count,
+                totalTokens: response.data.prompt_eval_count + response.data.eval_count,
+            },
+            raw: response.data,
+        };
+    }
+    async *stream(request) {
+        const config = this.mergeConfig(request.options);
+        let prompt = request.prompt;
+        if (request.systemPrompt) {
+            prompt = `${request.systemPrompt}\n\n${prompt}`;
+        }
+        const response = await axios_1.default.post(`${this.baseURL}/generate`, {
+            model: config.model || "llama2",
+            prompt,
+            temperature: config.temperature,
+            num_predict: config.maxTokens,
+            top_p: config.topP,
+            stream: true,
+        }, {
+            responseType: "stream",
+        });
+        const reader = response.data;
+        for await (const chunk of reader) {
+            const lines = chunk.toString().split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.response) {
+                        yield parsed.response;
+                    }
+                }
+                catch (error) {
+                    console.error("Error parsing Ollama stream data:", error);
+                }
+            }
+        }
+    }
+}
+exports.OllamaModel = OllamaModel;

package/dist/models/openai-model.d.ts

@@ -0,0 +1,9 @@
+import { AIModelConfig, AIModelRequest, AIModelResponse, AIProvider } from "../types";
+import { BaseModel } from "./base-model";
+export declare class OpenAIModel extends BaseModel {
+    readonly provider = AIProvider.OPENAI;
+    private client;
+    constructor(config: AIModelConfig);
+    generate(request: AIModelRequest): Promise<AIModelResponse>;
+    stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+}

package/dist/models/openai-model.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIModel = void 0;
+const openai_1 = require("openai");
+const types_1 = require("../types");
+const base_model_1 = require("./base-model");
+const utils_1 = require("../utils");
+class OpenAIModel extends base_model_1.BaseModel {
+    constructor(config) {
+        super(config);
+        this.provider = types_1.AIProvider.OPENAI;
+        const apiKey = (0, utils_1.getApiKey)(config.apiKey, "OPENAI_API_KEY", "OpenAI");
+        this.client = new openai_1.OpenAI({
+            apiKey: apiKey,
+            baseURL: config.baseURL,
+        });
+    }
+    async generate(request) {
+        const config = this.mergeConfig(request.options);
+        const messages = [];
+        // Add system prompt if provided
+        if (request.systemPrompt) {
+            messages.push({
+                role: "system",
+                content: request.systemPrompt,
+            });
+        }
+        // Add user prompt
+        messages.push({
+            role: "user",
+            content: request.prompt,
+        });
+        const response = await this.client.chat.completions.create({
+            model: config.model || "gpt-3.5-turbo",
+            messages,
+            temperature: config.temperature,
+            max_tokens: config.maxTokens,
+            top_p: config.topP,
+        });
+        return {
+            text: response.choices[0].message.content || "",
+            usage: {
+                promptTokens: response.usage?.prompt_tokens,
+                completionTokens: response.usage?.completion_tokens,
+                totalTokens: response.usage?.total_tokens,
+            },
+            raw: response,
+        };
+    }
+    async *stream(request) {
+        const config = this.mergeConfig(request.options);
+        const messages = [];
+        if (request.systemPrompt) {
+            messages.push({
+                role: "system",
+                content: request.systemPrompt,
+            });
+        }
+        messages.push({
+            role: "user",
+            content: request.prompt,
+        });
+        const stream = await this.client.chat.completions.create({
+            model: config.model || "gpt-3.5-turbo",
+            messages,
+            temperature: config.temperature,
+            max_tokens: config.maxTokens,
+            top_p: config.topP,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const content = chunk.choices[0]?.delta?.content || "";
+            if (content) {
+                yield content;
+            }
+        }
+    }
+}
+exports.OpenAIModel = OpenAIModel;

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+export interface AIModelConfig {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+}
+export declare enum AIProvider {
+    OPENAI = "openai",
+    GOOGLE = "google",
+    DEEPSEEK = "deepseek",
+    OLLAMA = "ollama",
+    HUGGINGFACE = "huggingface"
+}
+export interface AIModelResponse {
+    text: string;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+    raw?: any;
+}
+export interface AIModelRequest {
+    prompt: string;
+    systemPrompt?: string;
+    options?: Partial<AIModelConfig>;
+}
+export interface AIModel {
+    provider: AIProvider;
+    generate(request: AIModelRequest): Promise<AIModelResponse>;
+    stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+}

package/dist/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIProvider = void 0;
+var AIProvider;
+(function (AIProvider) {
+    AIProvider["OPENAI"] = "openai";
+    AIProvider["GOOGLE"] = "google";
+    AIProvider["DEEPSEEK"] = "deepseek";
+    AIProvider["OLLAMA"] = "ollama";
+    AIProvider["HUGGINGFACE"] = "huggingface";
+})(AIProvider || (exports.AIProvider = AIProvider = {}));

package/dist/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utilities for the Neural AI SDK
+ */
+/**
+ * Get an API key from config or environment variables
+ * @param configKey The API key from the config object
+ * @param envVarName The name of the environment variable to check
+ * @param providerName The name of the AI provider (for error messages)
+ * @returns The API key if found, throws an error otherwise
+ */
+export declare function getApiKey(configKey: string | undefined, envVarName: string, providerName: string): string;
+/**
+ * Get a base URL from config or environment variables
+ * @param configUrl The URL from the config object
+ * @param envVarName The name of the environment variable to check
+ * @param defaultUrl The default URL to use if not provided
+ * @returns The base URL
+ */
+export declare function getBaseUrl(configUrl: string | undefined, envVarName: string, defaultUrl: string): string;

package/dist/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Utilities for the Neural AI SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiKey = getApiKey;
+exports.getBaseUrl = getBaseUrl;
+/**
+ * Get an API key from config or environment variables
+ * @param configKey The API key from the config object
+ * @param envVarName The name of the environment variable to check
+ * @param providerName The name of the AI provider (for error messages)
+ * @returns The API key if found, throws an error otherwise
+ */
+function getApiKey(configKey, envVarName, providerName) {
+    // First check if the API key is provided in the config
+    if (configKey) {
+        return configKey;
+    }
+    // Then check environment variables
+    const envKey = process.env[envVarName];
+    if (envKey) {
+        return envKey;
+    }
+    // If no API key is found, throw a helpful error message
+    throw new Error(`${providerName} API key is required.\n` +
+        `Please provide it via the 'apiKey' option or set the ${envVarName} environment variable.\n` +
+        `Example:\n` +
+        `- In code: NeuralAI.createModel(AIProvider.${providerName.toUpperCase()}, { apiKey: "your-api-key" })\n` +
+        `- In .env: ${envVarName}=your-api-key`);
+}
+/**
+ * Get a base URL from config or environment variables
+ * @param configUrl The URL from the config object
+ * @param envVarName The name of the environment variable to check
+ * @param defaultUrl The default URL to use if not provided
+ * @returns The base URL
+ */
+function getBaseUrl(configUrl, envVarName, defaultUrl) {
+    if (configUrl) {
+        return configUrl;
+    }
+    return process.env[envVarName] || defaultUrl;
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "neural-ai-sdk",
+  "version": "0.1.1",
+  "description": "Unified SDK for interacting with various AI LLM providers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "prepare": "npm run build",
+    "example": "ts-node examples/all-providers.ts",
+    "clean": "rimraf dist",
+    "publish": "npm publish"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NeuralArc/neural-ai-sdk.git"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "openai",
+    "google",
+    "deepseek",
+    "ollama",
+    "huggingface",
+    "sdk",
+    "api"
+  ],
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "author": "NeuralArc",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/NeuralArc/neural-ai-sdk/issues"
+  },
+  "homepage": "https://github.com/NeuralArc/neural-ai-sdk#readme",
+  "dependencies": {
+    "@google/generative-ai": "^0.2.0",
+    "axios": "^1.6.0",
+    "openai": "^4.28.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.8.3",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.4",
+    "dotenv": "^16.3.1",
+    "eslint": "^8.51.0",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.10",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "dotenv": "^16.0.0"
+  }
+}