Package Exports

@ooneex/ai
@ooneex/ai/package.json

Readme

@ooneex/ai

Multi-provider AI toolkit for TypeScript — seamlessly integrate OpenAI, Anthropic Claude, Google Gemini, Groq, and Ollama with a unified API for text generation, streaming, and content transformation.

Features

✅ Multiple Providers - Support for OpenAI, Anthropic Claude, Google Gemini, Groq, and Ollama

✅ Unified Interface - Consistent API across all AI providers

✅ Text Transformations - Built-in methods for summarizing, rephrasing, translating, and more

✅ Streaming Support - Real-time response streaming with async generators

✅ Output Validation - Validate AI responses against schemas using ArkType

✅ Configurable Tone - 15 different tone options for content generation

✅ Text-to-Speech - Groq-powered text-to-speech with configurable voices and formats

✅ Multi-language - Translate and generate content in multiple languages

✅ Type-Safe - Full TypeScript support with proper type definitions

Installation

bun add @ooneex/ai

Usage

Basic Usage with OpenAI

import { OpenAi } from '@ooneex/ai';

const ai = new OpenAi();

// Run a simple prompt
const result = await ai.run<string>('What is the capital of France?');
console.log(result); // "Paris"

Text Transformations

import { AnthropicAi } from '@ooneex/ai';

const ai = new AnthropicAi();

// Summarize content
const summary = await ai.summarize('Your long text here...');

// Make text shorter
const shorter = await ai.makeShorter('Your verbose text here...');

// Simplify complex text
const simplified = await ai.simplify('Complex technical jargon...');

// Change tone
const formal = await ai.changeTone('Hey, what\'s up?', 'formal');

// Translate content
const translated = await ai.translate('Hello, world!', { language: 'fr' });

Streaming Responses

import { OpenAi } from '@ooneex/ai';

const ai = new OpenAi();

// Stream the response chunk by chunk
for await (const chunk of ai.runStream('Explain quantum computing')) {
  process.stdout.write(chunk);
}

With Configuration

import { GeminiAi, type GeminiConfigType } from '@ooneex/ai';

const ai = new GeminiAi();

const config: GeminiConfigType = {
  model: 'gemini-1.5-pro',
  wordCount: 200,
  tone: 'professional',
  language: 'en',
  context: 'You are a technical writer.'
};

const result = await ai.run<string>('Explain microservices', config);

Output Validation

import { OpenAi } from '@ooneex/ai';
import { Assert } from '@ooneex/validation';

const ai = new OpenAi();

// Define expected output schema
const ProductSchema = Assert({
  name: 'string',
  price: 'number',
  description: 'string'
});

const product = await ai.run<typeof ProductSchema.infer>(
  'Generate a product for an e-commerce store',
  { output: ProductSchema }
);

console.log(product.name, product.price);

Using Ollama (Local Models)

import { OllamaAi } from '@ooneex/ai';

const ai = new OllamaAi();

const result = await ai.run<string>('Write a haiku about coding', {
  host: 'http://localhost:11434',
  model: 'llama2'
});

API Reference

Classes

`OpenAi`

OpenAI provider implementation with GPT models.

Constructor:

new OpenAi()

Environment Variables:

OPENAI_API_KEY - Your OpenAI API key

`AnthropicAi`

Anthropic provider implementation with Claude models.

Constructor:

new AnthropicAi()

Environment Variables:

ANTHROPIC_API_KEY - Your Anthropic API key

`GeminiAi`

Google Gemini provider implementation.

Constructor:

new GeminiAi()

Environment Variables:

GEMINI_API_KEY - Your Google Gemini API key

`OllamaAi`

Ollama provider for local AI models.

Constructor:

new OllamaAi()

Configuration:

host - Ollama server URL (default: http://localhost:11434)

Common Methods

All AI classes implement the IAiChat interface with these methods:

`run<T>(prompt: string, config?: ConfigType): Promise<T>`

Execute a prompt and return the response.

`runStream(prompt: string, config?: ConfigType): AsyncGenerator<string>`

Stream the response chunk by chunk.

`summarize(content: string, config?: ConfigType): Promise<string>`

Summarize the provided content.

`makeShorter(content: string, config?: ConfigType): Promise<string>`

Condense text while preserving meaning.

`makeLonger(content: string, config?: ConfigType): Promise<string>`

Expand text with additional details.

`simplify(content: string, config?: ConfigType): Promise<string>`

Simplify complex text for general audiences.

`rephrase(content: string, config?: ConfigType): Promise<string>`

Rephrase using different words and structures.

`changeTone(content: string, tone: AiToneType, config?: ConfigType): Promise<string>`

Rewrite content with a different tone.

`translate(content: string, config?: ConfigType): Promise<string>`

Translate content to the specified language.

`proofread(content: string, config?: ConfigType): Promise<string>`

Correct grammar, spelling, and punctuation.

`extractKeywords(content: string, config?: ConfigType): Promise<string[]>`

Extract important keywords from content.

`extractCategories(content: string, config?: ConfigType): Promise<string[]>`

Identify relevant categories for content.

`generateTitle(content: string, config?: ConfigType): Promise<string>`

Generate a compelling title for content.

Types

`AiConfigType`

type AiConfigType = {
  apiKey?: string;
  model?: string;
  wordCount?: number;
  stream?: boolean;
  language?: LocaleType;
  tone?: AiToneType;
  messages?: AiMessageType[];
  context?: string;
  prompt?: string;
  output?: AssertType;
};

`AiToneType`

type AiToneType =
  | "professional"
  | "casual"
  | "formal"
  | "friendly"
  | "confident"
  | "empathetic"
  | "persuasive"
  | "informative"
  | "enthusiastic"
  | "neutral"
  | "humorous"
  | "serious"
  | "inspirational"
  | "conversational"
  | "authoritative";

`AiMessageType`

type AiMessageType = {
  role: "user" | "assistant" | "system" | "tool";
  content: string;
};

Advanced Usage

Conversation History

import { OpenAi, type AiMessageType } from '@ooneex/ai';

const ai = new OpenAi();

const messages: AiMessageType[] = [
  { role: 'user', content: 'My name is Alice.' },
  { role: 'assistant', content: 'Hello Alice! How can I help you today?' }
];

const response = await ai.run<string>('What is my name?', { messages });
// "Your name is Alice."

Custom Context

import { AnthropicAi } from '@ooneex/ai';

const ai = new AnthropicAi();

const response = await ai.run<string>('Summarize the project status', {
  context: `
    Project: E-commerce Platform
    Status: In development
    Progress: 75% complete
    Team: 5 developers
    Deadline: December 2024
  `
});

Error Handling

import { OpenAi, AiException } from '@ooneex/ai';

const ai = new OpenAi();

try {
  const result = await ai.run<string>('Generate content');
} catch (error) {
  if (error instanceof AiException) {
    console.error('AI Error:', error.message);
    console.error('Status:', error.status);
  }
}

Integration with Dependency Injection

import { container } from '@ooneex/container';
import { OpenAi, decorator } from '@ooneex/ai';

// The decorator registers the class with the container
@decorator.ai()
class MyAiService extends OpenAi {
  // Custom implementation
}

// Resolve from container
const aiService = container.get(MyAiService);

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

Development Setup

Clone the repository
Install dependencies: bun install
Run tests: bun run test
Build the project: bun run build

Guidelines

Write tests for new features
Follow the existing code style
Update documentation for API changes
Ensure all tests pass before submitting PR

Made with ❤️ by the Ooneex team