overai 1.4.0

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;
+}

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

@@ -0,0 +1,201 @@
+/**
+ * Generate Text - AI SDK Wrapper
+ *
+ * Provides generateText and streamText functions that wrap the AI SDK.
+ * These are the primary text generation primitives.
+ */
+import type { Message } from './types';
+export interface GenerateTextOptions {
+    /** Model to use (e.g., 'gpt-4o', 'claude-3-sonnet', 'openai/gpt-4o') */
+    model: string;
+    /** Simple text prompt */
+    prompt?: string;
+    /** Chat messages (alternative to prompt) */
+    messages?: Message[];
+    /** System message */
+    system?: string;
+    /** Tools available to the model */
+    tools?: Record<string, any>;
+    /** Tool choice strategy */
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'tool';
+        toolName: string;
+    };
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature (0-2) */
+    temperature?: number;
+    /** Top P (0-1) */
+    topP?: number;
+    /** Top K */
+    topK?: number;
+    /** Presence penalty */
+    presencePenalty?: number;
+    /** Frequency penalty */
+    frequencyPenalty?: number;
+    /** Stop sequences */
+    stopSequences?: string[];
+    /** Seed for reproducibility */
+    seed?: number;
+    /** Maximum retries */
+    maxRetries?: number;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Maximum steps for tool calling */
+    maxSteps?: number;
+    /** Callback on step finish */
+    onStepFinish?: (step: StepResult) => void | Promise<void>;
+    /** Callback on finish */
+    onFinish?: (result: GenerateTextResult) => void | Promise<void>;
+}
+export interface StepResult {
+    text: string;
+    toolCalls: ToolCall[];
+    toolResults: ToolResult[];
+    usage: TokenUsage;
+    finishReason: string;
+}
+export interface ToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: any;
+}
+export interface ToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: any;
+}
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface GenerateTextResult {
+    /** Generated text */
+    text: string;
+    /** Tool calls made */
+    toolCalls: ToolCall[];
+    /** Tool results */
+    toolResults: ToolResult[];
+    /** Token usage */
+    usage: TokenUsage;
+    /** Finish reason */
+    finishReason: string;
+    /** All steps (for multi-step) */
+    steps: StepResult[];
+    /** Response messages */
+    responseMessages: Message[];
+    /** Warnings */
+    warnings?: any[];
+}
+export interface StreamTextOptions extends GenerateTextOptions {
+    /** Callback for each text chunk */
+    onChunk?: (chunk: TextStreamPart) => void | Promise<void>;
+}
+export interface TextStreamPart {
+    type: 'text-delta' | 'tool-call' | 'tool-result' | 'finish' | 'error';
+    textDelta?: string;
+    toolCall?: ToolCall;
+    toolResult?: ToolResult;
+    finishReason?: string;
+    usage?: TokenUsage;
+    error?: Error;
+}
+export interface StreamTextResult {
+    /** Async iterator for text chunks */
+    textStream: AsyncIterable<string>;
+    /** Full text stream with all events */
+    fullStream: AsyncIterable<TextStreamPart>;
+    /** Promise that resolves to the final text */
+    text: Promise<string>;
+    /** Promise that resolves to tool calls */
+    toolCalls: Promise<ToolCall[]>;
+    /** Promise that resolves to tool results */
+    toolResults: Promise<ToolResult[]>;
+    /** Promise that resolves to usage */
+    usage: Promise<TokenUsage>;
+    /** Promise that resolves to finish reason */
+    finishReason: Promise<string>;
+    /** Promise that resolves to all steps */
+    steps: Promise<StepResult[]>;
+    /** Promise that resolves to response messages */
+    responseMessages: Promise<Message[]>;
+    /** Convert to Response object for streaming */
+    toDataStreamResponse(options?: {
+        headers?: Record<string, string>;
+    }): Response;
+    /** Pipe to a writable stream */
+    pipeDataStreamToResponse(response: any, options?: {
+        headers?: Record<string, string>;
+    }): void;
+}
+/**
+ * Generate text using a language model.
+ *
+ * @example Simple prompt
+ * ```typescript
+ * const result = await generateText({
+ *   model: 'gpt-4o',
+ *   prompt: 'What is the capital of France?'
+ * });
+ * console.log(result.text);
+ * ```
+ *
+ * @example Chat messages
+ * ```typescript
+ * const result = await generateText({
+ *   model: 'claude-3-sonnet',
+ *   messages: [
+ *     { role: 'user', content: 'Hello!' }
+ *   ]
+ * });
+ * ```
+ *
+ * @example With tools
+ * ```typescript
+ * const result = await generateText({
+ *   model: 'gpt-4o',
+ *   prompt: 'What is the weather in Paris?',
+ *   tools: {
+ *     getWeather: {
+ *       description: 'Get weather for a city',
+ *       parameters: z.object({ city: z.string() }),
+ *       execute: async ({ city }) => `Weather in ${city}: 20°C`
+ *     }
+ *   },
+ *   maxSteps: 5
+ * });
+ * ```
+ */
+export declare function generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+/**
+ * Stream text using a language model.
+ *
+ * @example Simple streaming
+ * ```typescript
+ * const result = await streamText({
+ *   model: 'gpt-4o',
+ *   prompt: 'Write a poem about AI'
+ * });
+ *
+ * for await (const chunk of result.textStream) {
+ *   process.stdout.write(chunk);
+ * }
+ * ```
+ *
+ * @example With tools and multi-step
+ * ```typescript
+ * const result = await streamText({
+ *   model: 'gpt-4o',
+ *   prompt: 'Search for AI news and summarize',
+ *   tools: { webSearch },
+ *   maxSteps: 5,
+ *   onChunk: (chunk) => console.log(chunk)
+ * });
+ *
+ * const text = await result.text;
+ * ```
+ */
+export declare function streamText(options: StreamTextOptions): Promise<StreamTextResult>;