praisonai 1.3.6 → 1.5.0

package/dist/ai/embed.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Embed - AI SDK Wrapper
+ *
+ * Provides embed and embedMany functions for text embeddings.
+ */
+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.embed = embed;
+exports.embedMany = embedMany;
+// Lazy load AI SDK
+let aiSdk = null;
+let aiSdkLoaded = false;
+async function loadAISDK() {
+    if (aiSdkLoaded)
+        return aiSdk;
+    try {
+        aiSdk = await Promise.resolve().then(() => __importStar(require('ai')));
+        aiSdkLoaded = true;
+        return aiSdk;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve model string to AI SDK embedding model instance
+ */
+async function resolveEmbeddingModel(modelString) {
+    let provider = 'openai';
+    let modelId = modelString;
+    if (modelString.includes('/')) {
+        const parts = modelString.split('/');
+        provider = parts[0].toLowerCase();
+        modelId = parts.slice(1).join('/');
+    }
+    else {
+        if (modelString.startsWith('text-embedding'))
+            provider = 'openai';
+        else if (modelString.startsWith('voyage'))
+            provider = 'anthropic';
+        else if (modelString.startsWith('embed-'))
+            provider = 'cohere';
+    }
+    let providerModule;
+    try {
+        switch (provider) {
+            case 'openai':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai.embedding(modelId);
+            case 'google':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
+                return providerModule.google.embedding(modelId);
+            default:
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai.embedding(modelId);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load embedding provider '${provider}': ${error.message}`);
+    }
+}
+/**
+ * Embed a single text using an embedding model.
+ *
+ * @example
+ * ```typescript
+ * const result = await embed({
+ *   model: 'text-embedding-3-small',
+ *   value: 'Hello, world!'
+ * });
+ * console.log(result.embedding); // [0.1, 0.2, ...]
+ * ```
+ */
+async function embed(options) {
+    const sdk = await loadAISDK();
+    if (!sdk) {
+        throw new Error('AI SDK not available. Install with: npm install ai @ai-sdk/openai');
+    }
+    const model = await resolveEmbeddingModel(options.model);
+    const result = await sdk.embed({
+        model,
+        value: options.value,
+        maxRetries: options.maxRetries,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+    });
+    return {
+        embedding: result.embedding,
+        usage: result.usage || { tokens: 0 },
+    };
+}
+/**
+ * Embed multiple texts using an embedding model.
+ *
+ * @example
+ * ```typescript
+ * const result = await embedMany({
+ *   model: 'text-embedding-3-small',
+ *   values: ['Hello', 'World']
+ * });
+ * console.log(result.embeddings); // [[0.1, ...], [0.2, ...]]
+ * ```
+ */
+async function embedMany(options) {
+    const sdk = await loadAISDK();
+    if (!sdk) {
+        throw new Error('AI SDK not available. Install with: npm install ai @ai-sdk/openai');
+    }
+    const model = await resolveEmbeddingModel(options.model);
+    const result = await sdk.embedMany({
+        model,
+        values: options.values,
+        maxRetries: options.maxRetries,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+    });
+    return {
+        embeddings: result.embeddings,
+        usage: result.usage || { tokens: 0 },
+    };
+}

package/dist/ai/generate-image.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Generate Image - AI SDK Wrapper
+ *
+ * Provides generateImage function for image generation.
+ */
+export interface GenerateImageOptions {
+    /** Model to use (e.g., 'dall-e-3', 'google/imagen-3') */
+    model: string;
+    /** Text prompt for image generation */
+    prompt: string;
+    /** Number of images to generate */
+    n?: number;
+    /** Image size (e.g., '1024x1024') */
+    size?: `${number}x${number}`;
+    /** Aspect ratio (e.g., '16:9') */
+    aspectRatio?: `${number}:${number}`;
+    /** Seed for reproducibility */
+    seed?: number;
+    /** Maximum retries */
+    maxRetries?: number;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Provider-specific options */
+    providerOptions?: Record<string, unknown>;
+}
+export interface GeneratedImage {
+    /** Base64-encoded image data */
+    base64: string;
+    /** Image as Uint8Array */
+    uint8Array: Uint8Array;
+    /** MIME type */
+    mimeType?: string;
+}
+export interface GenerateImageResult {
+    /** Generated images */
+    images: GeneratedImage[];
+    /** Warnings */
+    warnings?: any[];
+}
+/**
+ * Generate images using an image model.
+ *
+ * @example Generate with DALL-E
+ * ```typescript
+ * const result = await generateImage({
+ *   model: 'dall-e-3',
+ *   prompt: 'A futuristic city at sunset',
+ *   size: '1024x1024'
+ * });
+ *
+ * // Save the image
+ * fs.writeFileSync('image.png', result.images[0].uint8Array);
+ * ```
+ *
+ * @example Generate with Google Imagen
+ * ```typescript
+ * const result = await generateImage({
+ *   model: 'google/imagen-3',
+ *   prompt: 'A beautiful landscape',
+ *   aspectRatio: '16:9'
+ * });
+ * ```
+ */
+export declare function generateImage(options: GenerateImageOptions): Promise<GenerateImageResult>;

package/dist/ai/generate-image.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Generate Image - AI SDK Wrapper
+ *
+ * Provides generateImage function for image generation.
+ */
+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.generateImage = generateImage;
+// Lazy load AI SDK
+let aiSdk = null;
+let aiSdkLoaded = false;
+async function loadAISDK() {
+    if (aiSdkLoaded)
+        return aiSdk;
+    try {
+        aiSdk = await Promise.resolve().then(() => __importStar(require('ai')));
+        aiSdkLoaded = true;
+        return aiSdk;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve model string to AI SDK image model instance
+ */
+async function resolveImageModel(modelString) {
+    let provider = 'openai';
+    let modelId = modelString;
+    if (modelString.includes('/')) {
+        const parts = modelString.split('/');
+        provider = parts[0].toLowerCase();
+        modelId = parts.slice(1).join('/');
+    }
+    else {
+        if (modelString.startsWith('imagen'))
+            provider = 'google';
+        else if (modelString.startsWith('dall-e'))
+            provider = 'openai';
+    }
+    let providerModule;
+    try {
+        switch (provider) {
+            case 'openai':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai.image(modelId);
+            case 'google':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
+                return providerModule.google.image(modelId);
+            default:
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai.image(modelId);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load image provider '${provider}': ${error.message}`);
+    }
+}
+/**
+ * Generate images using an image model.
+ *
+ * @example Generate with DALL-E
+ * ```typescript
+ * const result = await generateImage({
+ *   model: 'dall-e-3',
+ *   prompt: 'A futuristic city at sunset',
+ *   size: '1024x1024'
+ * });
+ *
+ * // Save the image
+ * fs.writeFileSync('image.png', result.images[0].uint8Array);
+ * ```
+ *
+ * @example Generate with Google Imagen
+ * ```typescript
+ * const result = await generateImage({
+ *   model: 'google/imagen-3',
+ *   prompt: 'A beautiful landscape',
+ *   aspectRatio: '16:9'
+ * });
+ * ```
+ */
+async function generateImage(options) {
+    const sdk = await loadAISDK();
+    if (!sdk) {
+        throw new Error('AI SDK not available. Install with: npm install ai @ai-sdk/openai');
+    }
+    const model = await resolveImageModel(options.model);
+    const result = await sdk.generateImage({
+        model,
+        prompt: options.prompt,
+        n: options.n,
+        size: options.size,
+        aspectRatio: options.aspectRatio,
+        seed: options.seed,
+        maxRetries: options.maxRetries,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+        providerOptions: options.providerOptions,
+    });
+    return {
+        images: result.images || [],
+        warnings: result.warnings,
+    };
+}

package/dist/ai/generate-object.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Generate Object - AI SDK Wrapper
+ *
+ * Provides generateObject and streamObject functions for structured output generation.
+ */
+import type { Message } from './types';
+export interface GenerateObjectOptions<T = unknown> {
+    /** Model to use */
+    model: string;
+    /** Schema for the output (Zod schema or JSON schema) */
+    schema: any;
+    /** Schema name for the output */
+    schemaName?: string;
+    /** Schema description */
+    schemaDescription?: string;
+    /** Output mode: 'object' | 'array' | 'enum' | 'no-schema' */
+    mode?: 'object' | 'array' | 'enum' | 'no-schema';
+    /** Simple text prompt */
+    prompt?: string;
+    /** Chat messages */
+    messages?: Message[];
+    /** System message */
+    system?: string;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Temperature */
+    temperature?: number;
+    /** Top P */
+    topP?: number;
+    /** Maximum retries */
+    maxRetries?: number;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Callback on finish */
+    onFinish?: (result: GenerateObjectResult<T>) => void | Promise<void>;
+}
+export interface GenerateObjectResult<T = unknown> {
+    /** Generated object */
+    object: T;
+    /** Token usage */
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Finish reason */
+    finishReason: string;
+    /** Warnings */
+    warnings?: any[];
+}
+export interface StreamObjectOptions<T = unknown> extends GenerateObjectOptions<T> {
+    /** Callback for partial object updates */
+    onPartialObject?: (partial: Partial<T>) => void | Promise<void>;
+}
+export interface StreamObjectResult<T = unknown> {
+    /** Async iterator for partial objects */
+    partialObjectStream: AsyncIterable<Partial<T>>;
+    /** Promise that resolves to the final object */
+    object: Promise<T>;
+    /** Promise that resolves to usage */
+    usage: Promise<{
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }>;
+    /** Promise that resolves to finish reason */
+    finishReason: Promise<string>;
+    /** Convert to Response for streaming */
+    toTextStreamResponse(options?: {
+        headers?: Record<string, string>;
+    }): Response;
+}
+/**
+ * Generate a structured object using a language model.
+ *
+ * @example With Zod schema
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const result = await generateObject({
+ *   model: 'gpt-4o',
+ *   schema: z.object({
+ *     name: z.string(),
+ *     age: z.number()
+ *   }),
+ *   prompt: 'Generate a person'
+ * });
+ * console.log(result.object); // { name: 'John', age: 30 }
+ * ```
+ *
+ * @example With JSON schema
+ * ```typescript
+ * const result = await generateObject({
+ *   model: 'gpt-4o',
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name', 'age']
+ *   },
+ *   prompt: 'Generate a person'
+ * });
+ * ```
+ */
+export declare function generateObject<T = unknown>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+/**
+ * Stream a structured object using a language model.
+ *
+ * @example Streaming partial objects
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const result = await streamObject({
+ *   model: 'gpt-4o',
+ *   schema: z.object({
+ *     story: z.string(),
+ *     characters: z.array(z.string())
+ *   }),
+ *   prompt: 'Write a short story',
+ *   onPartialObject: (partial) => {
+ *     console.log('Partial:', partial);
+ *   }
+ * });
+ *
+ * const finalObject = await result.object;
+ * ```
+ */
+export declare function streamObject<T = unknown>(options: StreamObjectOptions<T>): Promise<StreamObjectResult<T>>;

package/dist/ai/generate-object.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * Generate Object - AI SDK Wrapper
+ *
+ * Provides generateObject and streamObject functions for structured output generation.
+ */
+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.generateObject = generateObject;
+exports.streamObject = streamObject;
+// Lazy load AI SDK
+let aiSdk = null;
+let aiSdkLoaded = false;
+async function loadAISDK() {
+    if (aiSdkLoaded)
+        return aiSdk;
+    try {
+        aiSdk = await Promise.resolve().then(() => __importStar(require('ai')));
+        aiSdkLoaded = true;
+        return aiSdk;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve model string to AI SDK model instance
+ */
+async function resolveModel(modelString) {
+    let provider = 'openai';
+    let modelId = modelString;
+    if (modelString.includes('/')) {
+        const parts = modelString.split('/');
+        provider = parts[0].toLowerCase();
+        modelId = parts.slice(1).join('/');
+    }
+    else {
+        if (modelString.startsWith('claude'))
+            provider = 'anthropic';
+        else if (modelString.startsWith('gemini'))
+            provider = 'google';
+    }
+    let providerModule;
+    try {
+        switch (provider) {
+            case 'openai':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai(modelId);
+            case 'anthropic':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/anthropic')));
+                return providerModule.anthropic(modelId);
+            case 'google':
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
+                return providerModule.google(modelId);
+            default:
+                providerModule = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+                return providerModule.openai(modelId);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load provider '${provider}': ${error.message}`);
+    }
+}
+/**
+ * Generate a structured object using a language model.
+ *
+ * @example With Zod schema
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const result = await generateObject({
+ *   model: 'gpt-4o',
+ *   schema: z.object({
+ *     name: z.string(),
+ *     age: z.number()
+ *   }),
+ *   prompt: 'Generate a person'
+ * });
+ * console.log(result.object); // { name: 'John', age: 30 }
+ * ```
+ *
+ * @example With JSON schema
+ * ```typescript
+ * const result = await generateObject({
+ *   model: 'gpt-4o',
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name', 'age']
+ *   },
+ *   prompt: 'Generate a person'
+ * });
+ * ```
+ */
+async function generateObject(options) {
+    const sdk = await loadAISDK();
+    if (!sdk) {
+        throw new Error('AI SDK not available. Install with: npm install ai @ai-sdk/openai');
+    }
+    const model = await resolveModel(options.model);
+    const result = await sdk.generateObject({
+        model,
+        schema: options.schema,
+        schemaName: options.schemaName,
+        schemaDescription: options.schemaDescription,
+        mode: options.mode,
+        prompt: options.prompt,
+        messages: options.messages,
+        system: options.system,
+        maxTokens: options.maxTokens,
+        temperature: options.temperature,
+        topP: options.topP,
+        maxRetries: options.maxRetries,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+        onFinish: options.onFinish,
+    });
+    return {
+        object: result.object,
+        usage: result.usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        finishReason: result.finishReason || 'stop',
+        warnings: result.warnings,
+    };
+}
+/**
+ * Stream a structured object using a language model.
+ *
+ * @example Streaming partial objects
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const result = await streamObject({
+ *   model: 'gpt-4o',
+ *   schema: z.object({
+ *     story: z.string(),
+ *     characters: z.array(z.string())
+ *   }),
+ *   prompt: 'Write a short story',
+ *   onPartialObject: (partial) => {
+ *     console.log('Partial:', partial);
+ *   }
+ * });
+ *
+ * const finalObject = await result.object;
+ * ```
+ */
+async function streamObject(options) {
+    const sdk = await loadAISDK();
+    if (!sdk) {
+        throw new Error('AI SDK not available. Install with: npm install ai @ai-sdk/openai');
+    }
+    const model = await resolveModel(options.model);
+    const result = sdk.streamObject({
+        model,
+        schema: options.schema,
+        schemaName: options.schemaName,
+        schemaDescription: options.schemaDescription,
+        mode: options.mode,
+        prompt: options.prompt,
+        messages: options.messages,
+        system: options.system,
+        maxTokens: options.maxTokens,
+        temperature: options.temperature,
+        topP: options.topP,
+        maxRetries: options.maxRetries,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+        onFinish: options.onFinish,
+    });
+    return result;
+}