overai 1.4.0

package/dist/ai/models.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * Models - AI SDK Wrapper
+ *
+ * Provides model aliases and utilities for model resolution.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_ALIASES = void 0;
+exports.parseModel = parseModel;
+exports.getModel = getModel;
+exports.createModel = createModel;
+exports.listModelAliases = listModelAliases;
+exports.hasModelAlias = hasModelAlias;
+exports.resolveModelAlias = resolveModelAlias;
+/**
+ * Model aliases for common models across providers.
+ * Maps friendly names to provider/model format.
+ */
+exports.MODEL_ALIASES = {
+    // OpenAI
+    'gpt-4o': 'openai/gpt-4o',
+    'gpt-4o-mini': 'openai/gpt-4o-mini',
+    'gpt-4-turbo': 'openai/gpt-4-turbo',
+    'gpt-4': 'openai/gpt-4',
+    'gpt-3.5-turbo': 'openai/gpt-3.5-turbo',
+    'gpt-5': 'openai/gpt-5',
+    'o1': 'openai/o1',
+    'o1-mini': 'openai/o1-mini',
+    'o1-preview': 'openai/o1-preview',
+    'o3': 'openai/o3',
+    'o3-mini': 'openai/o3-mini',
+    // Anthropic
+    'claude-4': 'anthropic/claude-4-sonnet-20250514',
+    'claude-4-opus': 'anthropic/claude-4-opus-20250514',
+    'claude-4-sonnet': 'anthropic/claude-4-sonnet-20250514',
+    'claude-3.7-sonnet': 'anthropic/claude-3-7-sonnet-20250219',
+    'claude-3.5-sonnet': 'anthropic/claude-3-5-sonnet-20241022',
+    'claude-3-sonnet': 'anthropic/claude-3-sonnet-20240229',
+    'claude-3-opus': 'anthropic/claude-3-opus-20240229',
+    'claude-3-haiku': 'anthropic/claude-3-haiku-20240307',
+    // Google
+    'gemini-3': 'google/gemini-3.0-pro',
+    'gemini-2.5-pro': 'google/gemini-2.5-pro-preview-06-05',
+    'gemini-2.5-flash': 'google/gemini-2.5-flash-preview-05-20',
+    'gemini-2.0-flash': 'google/gemini-2.0-flash',
+    'gemini-1.5-pro': 'google/gemini-1.5-pro',
+    'gemini-1.5-flash': 'google/gemini-1.5-flash',
+    // DeepSeek
+    'deepseek-r1': 'deepseek/deepseek-reasoner',
+    'deepseek-v3': 'deepseek/deepseek-chat',
+    'deepseek-v3.2': 'deepseek/deepseek-chat-v3.2',
+    // Meta Llama
+    'llama-3.1': 'groq/llama-3.1-70b-versatile',
+    'llama-3.1-8b': 'groq/llama-3.1-8b-instant',
+    'llama-3.1-70b': 'groq/llama-3.1-70b-versatile',
+    'llama-3.1-405b': 'together/meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo',
+    // Embedding models
+    'text-embedding-3-small': 'openai/text-embedding-3-small',
+    'text-embedding-3-large': 'openai/text-embedding-3-large',
+    'text-embedding-004': 'google/text-embedding-004',
+    // Image models
+    'dall-e-3': 'openai/dall-e-3',
+    'dall-e-2': 'openai/dall-e-2',
+    'imagen-3': 'google/imagen-3.0-generate-002',
+};
+/**
+ * Parse a model string into provider and model ID.
+ *
+ * @example
+ * ```typescript
+ * parseModel('gpt-4o') // { provider: 'openai', modelId: 'gpt-4o', original: 'gpt-4o' }
+ * parseModel('anthropic/claude-3-sonnet') // { provider: 'anthropic', modelId: 'claude-3-sonnet', original: 'anthropic/claude-3-sonnet' }
+ * ```
+ */
+function parseModel(model) {
+    // Check aliases first
+    const aliased = exports.MODEL_ALIASES[model];
+    const modelString = aliased || model;
+    if (modelString.includes('/')) {
+        const parts = modelString.split('/');
+        return {
+            provider: parts[0].toLowerCase(),
+            modelId: parts.slice(1).join('/'),
+            original: model,
+        };
+    }
+    // Infer provider from model name
+    let provider = 'openai';
+    if (modelString.startsWith('claude'))
+        provider = 'anthropic';
+    else if (modelString.startsWith('gemini'))
+        provider = 'google';
+    else if (modelString.startsWith('deepseek'))
+        provider = 'deepseek';
+    else if (modelString.startsWith('llama'))
+        provider = 'groq';
+    return {
+        provider,
+        modelId: modelString,
+        original: model,
+    };
+}
+/**
+ * Get a model instance from a model string.
+ *
+ * @example
+ * ```typescript
+ * const model = await getModel('gpt-4o');
+ * const result = await generateText({ model, prompt: 'Hello' });
+ * ```
+ */
+async function getModel(model) {
+    const config = parseModel(model);
+    let providerModule;
+    try {
+        switch (config.provider) {
+            case 'openai':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai(config.modelId);
+            case 'anthropic':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/anthropic')));
+                return providerModule.anthropic(config.modelId);
+            case 'google':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
+                return providerModule.google(config.modelId);
+            case 'groq':
+                // @ts-ignore - Optional dependency
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/groq')));
+                return providerModule.groq(config.modelId);
+            case 'deepseek':
+                // @ts-ignore - Optional dependency
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/deepseek')));
+                return providerModule.deepseek(config.modelId);
+            default:
+                // Try OpenAI-compatible
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai(config.modelId);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load provider '${config.provider}': ${error.message}. ` +
+            `Install with: npm install @ai-sdk/${config.provider}`);
+    }
+}
+/**
+ * Create a model with custom configuration.
+ *
+ * @example
+ * ```typescript
+ * const model = await createModel('gpt-4o', {
+ *   baseURL: 'https://custom-endpoint.com/v1',
+ *   apiKey: 'custom-key'
+ * });
+ * ```
+ */
+async function createModel(model, options) {
+    const config = parseModel(model);
+    let providerModule;
+    try {
+        switch (config.provider) {
+            case 'openai':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                const openaiProvider = providerModule.createOpenAI({
+                    baseURL: options?.baseURL,
+                    apiKey: options?.apiKey,
+                    headers: options?.headers,
+                });
+                return openaiProvider(config.modelId);
+            case 'anthropic':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/anthropic')));
+                const anthropicProvider = providerModule.createAnthropic({
+                    baseURL: options?.baseURL,
+                    apiKey: options?.apiKey,
+                    headers: options?.headers,
+                });
+                return anthropicProvider(config.modelId);
+            case 'google':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
+                const googleProvider = providerModule.createGoogleGenerativeAI({
+                    baseURL: options?.baseURL,
+                    apiKey: options?.apiKey,
+                    headers: options?.headers,
+                });
+                return googleProvider(config.modelId);
+            default:
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                const defaultProvider = providerModule.createOpenAI({
+                    baseURL: options?.baseURL,
+                    apiKey: options?.apiKey,
+                    headers: options?.headers,
+                });
+                return defaultProvider(config.modelId);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to create model '${model}': ${error.message}`);
+    }
+}
+/**
+ * List all available model aliases.
+ */
+function listModelAliases() {
+    return Object.keys(exports.MODEL_ALIASES);
+}
+/**
+ * Check if a model alias exists.
+ */
+function hasModelAlias(alias) {
+    return alias in exports.MODEL_ALIASES;
+}
+/**
+ * Resolve a model alias to its full provider/model format.
+ */
+function resolveModelAlias(alias) {
+    return exports.MODEL_ALIASES[alias] || alias;
+}

package/dist/ai/multimodal.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Multimodal - AI SDK Wrapper
+ *
+ * Provides utilities for multimodal inputs (images, files, PDFs).
+ */
+export type InputPart = TextPart | ImagePart | FilePart | PdfPart;
+export interface TextPart {
+    type: 'text';
+    text: string;
+}
+export interface ImagePart {
+    type: 'image';
+    /** Image data as URL, base64 string, or Uint8Array */
+    image: string | Uint8Array | URL;
+    /** MIME type (auto-detected if not provided) */
+    mimeType?: string;
+}
+export interface FilePart {
+    type: 'file';
+    /** File data as URL, base64 string, or Uint8Array */
+    data: string | Uint8Array | URL;
+    /** MIME type (required) */
+    mimeType: string;
+    /** File name (optional) */
+    name?: string;
+}
+export interface PdfPart {
+    type: 'pdf';
+    /** PDF data as URL, base64 string, or Uint8Array */
+    data: string | Uint8Array | URL;
+    /** Page range to extract (optional) */
+    pages?: {
+        start?: number;
+        end?: number;
+    };
+    /** Extract text only (default: false) */
+    textOnly?: boolean;
+}
+/**
+ * Create a text part.
+ */
+export declare function createTextPart(text: string): TextPart;
+/**
+ * Create an image part from various sources.
+ *
+ * @example From URL
+ * ```typescript
+ * const imagePart = createImagePart('https://example.com/image.png');
+ * ```
+ *
+ * @example From base64
+ * ```typescript
+ * const imagePart = createImagePart('data:image/png;base64,...');
+ * ```
+ *
+ * @example From file path
+ * ```typescript
+ * const imagePart = await createImagePart('./image.png');
+ * ```
+ */
+export declare function createImagePart(source: string | Uint8Array | URL, mimeType?: string): ImagePart;
+/**
+ * Create a file part from various sources.
+ *
+ * @example
+ * ```typescript
+ * const filePart = createFilePart('./document.txt', 'text/plain');
+ * ```
+ */
+export declare function createFilePart(source: string | Uint8Array | URL, mimeType: string, name?: string): FilePart;
+/**
+ * Create a PDF part from various sources.
+ *
+ * @example
+ * ```typescript
+ * const pdfPart = createPdfPart('./document.pdf');
+ * ```
+ *
+ * @example With page range
+ * ```typescript
+ * const pdfPart = createPdfPart('./document.pdf', { pages: { start: 1, end: 5 } });
+ * ```
+ */
+export declare function createPdfPart(source: string | Uint8Array | URL, options?: {
+    pages?: {
+        start?: number;
+        end?: number;
+    };
+    textOnly?: boolean;
+}): PdfPart;
+/**
+ * Convert input parts to AI SDK message content format.
+ */
+export declare function toMessageContent(parts: InputPart[]): any[];
+/**
+ * Create a multimodal message with text and images.
+ *
+ * @example
+ * ```typescript
+ * const message = createMultimodalMessage(
+ *   'What is in this image?',
+ *   ['https://example.com/image.png']
+ * );
+ * ```
+ */
+export declare function createMultimodalMessage(text: string, images: (string | Uint8Array | URL)[], role?: 'user' | 'assistant'): {
+    role: string;
+    content: any[];
+};
+/**
+ * Convert a base64 string to Uint8Array.
+ */
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+/**
+ * Convert Uint8Array to base64 string.
+ */
+export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+/**
+ * Check if a string is a valid URL.
+ */
+export declare function isUrl(str: string): boolean;
+/**
+ * Check if a string is a data URL.
+ */
+export declare function isDataUrl(str: string): boolean;

package/dist/ai/multimodal.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Multimodal - AI SDK Wrapper
+ *
+ * Provides utilities for multimodal inputs (images, files, PDFs).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTextPart = createTextPart;
+exports.createImagePart = createImagePart;
+exports.createFilePart = createFilePart;
+exports.createPdfPart = createPdfPart;
+exports.toMessageContent = toMessageContent;
+exports.createMultimodalMessage = createMultimodalMessage;
+exports.base64ToUint8Array = base64ToUint8Array;
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;
+exports.isUrl = isUrl;
+exports.isDataUrl = isDataUrl;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Create a text part.
+ */
+function createTextPart(text) {
+    return { type: 'text', text };
+}
+/**
+ * Create an image part from various sources.
+ *
+ * @example From URL
+ * ```typescript
+ * const imagePart = createImagePart('https://example.com/image.png');
+ * ```
+ *
+ * @example From base64
+ * ```typescript
+ * const imagePart = createImagePart('data:image/png;base64,...');
+ * ```
+ *
+ * @example From file path
+ * ```typescript
+ * const imagePart = await createImagePart('./image.png');
+ * ```
+ */
+function createImagePart(source, mimeType) {
+    // If it's a file path, read it
+    if (typeof source === 'string' && !source.startsWith('http') && !source.startsWith('data:')) {
+        if (fs.existsSync(source)) {
+            const buffer = fs.readFileSync(source);
+            const detectedMime = mimeType || detectImageMimeType(source);
+            return {
+                type: 'image',
+                image: buffer,
+                mimeType: detectedMime,
+            };
+        }
+    }
+    return {
+        type: 'image',
+        image: source,
+        mimeType,
+    };
+}
+/**
+ * Create a file part from various sources.
+ *
+ * @example
+ * ```typescript
+ * const filePart = createFilePart('./document.txt', 'text/plain');
+ * ```
+ */
+function createFilePart(source, mimeType, name) {
+    // If it's a file path, read it
+    if (typeof source === 'string' && !source.startsWith('http') && !source.startsWith('data:')) {
+        if (fs.existsSync(source)) {
+            const buffer = fs.readFileSync(source);
+            return {
+                type: 'file',
+                data: buffer,
+                mimeType,
+                name: name || path.basename(source),
+            };
+        }
+    }
+    return {
+        type: 'file',
+        data: source,
+        mimeType,
+        name,
+    };
+}
+/**
+ * Create a PDF part from various sources.
+ *
+ * @example
+ * ```typescript
+ * const pdfPart = createPdfPart('./document.pdf');
+ * ```
+ *
+ * @example With page range
+ * ```typescript
+ * const pdfPart = createPdfPart('./document.pdf', { pages: { start: 1, end: 5 } });
+ * ```
+ */
+function createPdfPart(source, options) {
+    // If it's a file path, read it
+    if (typeof source === 'string' && !source.startsWith('http') && !source.startsWith('data:')) {
+        if (fs.existsSync(source)) {
+            const buffer = fs.readFileSync(source);
+            return {
+                type: 'pdf',
+                data: buffer,
+                pages: options?.pages,
+                textOnly: options?.textOnly,
+            };
+        }
+    }
+    return {
+        type: 'pdf',
+        data: source,
+        pages: options?.pages,
+        textOnly: options?.textOnly,
+    };
+}
+/**
+ * Convert input parts to AI SDK message content format.
+ */
+function toMessageContent(parts) {
+    return parts.map(part => {
+        switch (part.type) {
+            case 'text':
+                return { type: 'text', text: part.text };
+            case 'image':
+                return {
+                    type: 'image',
+                    image: part.image,
+                    mimeType: part.mimeType,
+                };
+            case 'file':
+                return {
+                    type: 'file',
+                    data: part.data,
+                    mimeType: part.mimeType,
+                };
+            case 'pdf':
+                // PDFs are treated as files with application/pdf mime type
+                return {
+                    type: 'file',
+                    data: part.data,
+                    mimeType: 'application/pdf',
+                };
+            default:
+                return part;
+        }
+    });
+}
+/**
+ * Create a multimodal message with text and images.
+ *
+ * @example
+ * ```typescript
+ * const message = createMultimodalMessage(
+ *   'What is in this image?',
+ *   ['https://example.com/image.png']
+ * );
+ * ```
+ */
+function createMultimodalMessage(text, images, role = 'user') {
+    const content = [];
+    // Add images first
+    for (const image of images) {
+        content.push(createImagePart(image));
+    }
+    // Add text
+    content.push(createTextPart(text));
+    return {
+        role,
+        content: toMessageContent(content),
+    };
+}
+/**
+ * Detect image MIME type from file extension.
+ */
+function detectImageMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.bmp': 'image/bmp',
+        '.ico': 'image/x-icon',
+    };
+    return mimeTypes[ext] || 'image/png';
+}
+/**
+ * Convert a base64 string to Uint8Array.
+ */
+function base64ToUint8Array(base64) {
+    // Handle data URLs
+    const base64Data = base64.includes(',') ? base64.split(',')[1] : base64;
+    const binaryString = atob(base64Data);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Convert Uint8Array to base64 string.
+ */
+function uint8ArrayToBase64(bytes) {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+/**
+ * Check if a string is a valid URL.
+ */
+function isUrl(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a string is a data URL.
+ */
+function isDataUrl(str) {
+    return str.startsWith('data:');
+}