overai 1.4.0

package/dist/llm/embeddings.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * Embeddings - AI SDK-backed embedding utilities
+ *
+ * Provides embedding functionality with AI SDK preference and native fallback.
+ * Integrates with existing EmbeddingProvider interface in knowledge/rag.ts and memory/memory.ts
+ */
+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.getDefaultEmbeddingModel = getDefaultEmbeddingModel;
+exports.parseEmbeddingModel = parseEmbeddingModel;
+exports.embed = embed;
+exports.embedMany = embedMany;
+exports.createEmbeddingProvider = createEmbeddingProvider;
+exports.cosineSimilarity = cosineSimilarity;
+exports.euclideanDistance = euclideanDistance;
+const backend_resolver_1 = require("./backend-resolver");
+// Default embedding models per provider
+const DEFAULT_EMBEDDING_MODELS = {
+    openai: 'text-embedding-3-small',
+    anthropic: 'voyage-3', // Anthropic uses Voyage for embeddings
+    google: 'text-embedding-004',
+    cohere: 'embed-english-v3.0',
+};
+/**
+ * Get the default embedding model for a provider
+ */
+function getDefaultEmbeddingModel(provider = 'openai') {
+    return DEFAULT_EMBEDDING_MODELS[provider.toLowerCase()] || DEFAULT_EMBEDDING_MODELS.openai;
+}
+/**
+ * Parse embedding model string into provider and model
+ */
+function parseEmbeddingModel(model) {
+    if (model.includes('/')) {
+        const [provider, ...rest] = model.split('/');
+        return { provider: provider.toLowerCase(), model: rest.join('/') };
+    }
+    // Infer provider from model name
+    if (model.startsWith('text-embedding-') || model.startsWith('ada')) {
+        return { provider: 'openai', model };
+    }
+    if (model.startsWith('voyage-')) {
+        return { provider: 'anthropic', model };
+    }
+    if (model.startsWith('embed-')) {
+        return { provider: 'cohere', model };
+    }
+    // Default to OpenAI
+    return { provider: 'openai', model };
+}
+/**
+ * Embed a single text using AI SDK (preferred) or native provider
+ */
+async function embed(text, options = {}) {
+    const modelString = options.model || getDefaultEmbeddingModel(options.provider);
+    const { provider } = parseEmbeddingModel(modelString);
+    const preferredBackend = options.backend || (0, backend_resolver_1.getPreferredBackend)();
+    // Try AI SDK first
+    if (preferredBackend === 'ai-sdk' || preferredBackend === 'auto') {
+        const aiSdkAvailable = await (0, backend_resolver_1.isAISDKAvailable)();
+        if (aiSdkAvailable) {
+            try {
+                return await embedWithAISDK(text, modelString, options);
+            }
+            catch (error) {
+                if (preferredBackend === 'ai-sdk') {
+                    throw error;
+                }
+                // Fall through to native
+            }
+        }
+    }
+    // Fall back to native OpenAI
+    return await embedWithNative(text, modelString, options);
+}
+/**
+ * Embed multiple texts using AI SDK (preferred) or native provider
+ */
+async function embedMany(texts, options = {}) {
+    if (texts.length === 0) {
+        return { embeddings: [] };
+    }
+    const modelString = options.model || getDefaultEmbeddingModel(options.provider);
+    const preferredBackend = options.backend || (0, backend_resolver_1.getPreferredBackend)();
+    // Try AI SDK first
+    if (preferredBackend === 'ai-sdk' || preferredBackend === 'auto') {
+        const aiSdkAvailable = await (0, backend_resolver_1.isAISDKAvailable)();
+        if (aiSdkAvailable) {
+            try {
+                return await embedManyWithAISDK(texts, modelString, options);
+            }
+            catch (error) {
+                if (preferredBackend === 'ai-sdk') {
+                    throw error;
+                }
+                // Fall through to native
+            }
+        }
+    }
+    // Fall back to native OpenAI
+    return await embedManyWithNative(texts, modelString, options);
+}
+/**
+ * Embed using AI SDK
+ */
+async function embedWithAISDK(text, model, options) {
+    const { provider, model: modelId } = parseEmbeddingModel(model);
+    // Dynamic import AI SDK
+    const ai = await Promise.resolve().then(() => __importStar(require('ai')));
+    // Get the embedding model from the appropriate provider
+    const embeddingModel = await getAISDKEmbeddingModel(provider, modelId);
+    const result = await ai.embed({
+        model: embeddingModel,
+        value: text,
+        maxRetries: options.maxRetries ?? 2,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+    });
+    return {
+        embedding: result.embedding,
+        usage: result.usage ? { tokens: result.usage.tokens } : undefined,
+    };
+}
+/**
+ * Embed many using AI SDK
+ */
+async function embedManyWithAISDK(texts, model, options) {
+    const { provider, model: modelId } = parseEmbeddingModel(model);
+    // Dynamic import AI SDK
+    const ai = await Promise.resolve().then(() => __importStar(require('ai')));
+    // Get the embedding model from the appropriate provider
+    const embeddingModel = await getAISDKEmbeddingModel(provider, modelId);
+    const result = await ai.embedMany({
+        model: embeddingModel,
+        values: texts,
+        maxRetries: options.maxRetries ?? 2,
+        abortSignal: options.abortSignal,
+        headers: options.headers,
+    });
+    return {
+        embeddings: result.embeddings,
+        usage: result.usage ? { tokens: result.usage.tokens } : undefined,
+    };
+}
+/**
+ * Get AI SDK embedding model for a provider
+ */
+async function getAISDKEmbeddingModel(provider, modelId) {
+    switch (provider.toLowerCase()) {
+        case 'openai':
+        case 'oai': {
+            const { createOpenAI } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/openai')));
+            const openai = createOpenAI({});
+            return openai.embedding(modelId);
+        }
+        case 'google':
+        case 'gemini': {
+            const { createGoogleGenerativeAI } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
+            const google = createGoogleGenerativeAI({});
+            return google.textEmbeddingModel(modelId);
+        }
+        case 'cohere': {
+            try {
+                // Dynamic import - cohere is optional
+                const cohereModule = await Promise.resolve(`${'@ai-sdk/cohere'}`).then(s => __importStar(require(s)));
+                const cohere = cohereModule.createCohere({});
+                return cohere.embedding(modelId);
+            }
+            catch {
+                throw new Error(`Cohere provider not installed. Install with: npm install @ai-sdk/cohere`);
+            }
+        }
+        default:
+            throw new Error(`Embedding provider '${provider}' not supported via AI SDK. ` +
+                `Supported: openai, google, cohere`);
+    }
+}
+/**
+ * Embed using native OpenAI client
+ */
+async function embedWithNative(text, model, options) {
+    const { model: modelId } = parseEmbeddingModel(model);
+    const OpenAI = (await Promise.resolve().then(() => __importStar(require('openai')))).default;
+    const client = new OpenAI();
+    const response = await client.embeddings.create({
+        model: modelId,
+        input: text,
+    });
+    return {
+        embedding: response.data[0].embedding,
+        usage: response.usage ? { tokens: response.usage.total_tokens } : undefined,
+    };
+}
+/**
+ * Embed many using native OpenAI client
+ */
+async function embedManyWithNative(texts, model, options) {
+    const { model: modelId } = parseEmbeddingModel(model);
+    const OpenAI = (await Promise.resolve().then(() => __importStar(require('openai')))).default;
+    const client = new OpenAI();
+    const response = await client.embeddings.create({
+        model: modelId,
+        input: texts,
+    });
+    // Sort by index to ensure correct order
+    const sorted = response.data.sort((a, b) => a.index - b.index);
+    return {
+        embeddings: sorted.map(d => d.embedding),
+        usage: response.usage ? { tokens: response.usage.total_tokens } : undefined,
+    };
+}
+/**
+ * Create an EmbeddingProvider that uses AI SDK
+ * Compatible with KnowledgeBase and Memory interfaces
+ */
+function createEmbeddingProvider(options = {}) {
+    return {
+        async embed(text) {
+            const result = await embed(text, options);
+            return result.embedding;
+        },
+        async embedBatch(texts) {
+            const result = await embedMany(texts, options);
+            return result.embeddings;
+        },
+    };
+}
+/**
+ * Cosine similarity between two vectors
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0) {
+        return 0;
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+/**
+ * Euclidean distance between two vectors
+ */
+function euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}

package/dist/llm/index.d.ts

@@ -0,0 +1,29 @@
+export interface LLMConfig {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    apiKey?: string;
+    baseURL?: string;
+}
+export interface LLMResponse {
+    text: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    metadata?: Record<string, any>;
+}
+export interface LLM {
+    config: LLMConfig;
+    generate(prompt: string): Promise<LLMResponse>;
+    generateStream(prompt: string): AsyncGenerator<string, void, unknown>;
+}
+export declare class BaseLLM implements LLM {
+    config: LLMConfig;
+    constructor(config: LLMConfig);
+    generate(prompt: string): Promise<LLMResponse>;
+    generateStream(prompt: string): AsyncGenerator<string, void, unknown>;
+}
+export { resolveBackend, resolveBackendSync, isAISDKAvailable, resetAISDKAvailabilityCache, getPreferredBackend, getDefaultModel, parseModelString, type BackendResolutionResult, type BackendSource, type ResolveBackendOptions, } from './backend-resolver';
+export { embed, embedMany, createEmbeddingProvider, getDefaultEmbeddingModel, parseEmbeddingModel, cosineSimilarity, euclideanDistance, type EmbeddingOptions, type EmbeddingResult, type EmbeddingBatchResult, } from './embeddings';

package/dist/llm/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.euclideanDistance = exports.cosineSimilarity = exports.parseEmbeddingModel = exports.getDefaultEmbeddingModel = exports.createEmbeddingProvider = exports.embedMany = exports.embed = exports.parseModelString = exports.getDefaultModel = exports.getPreferredBackend = exports.resetAISDKAvailabilityCache = exports.isAISDKAvailable = exports.resolveBackendSync = exports.resolveBackend = exports.BaseLLM = void 0;
+class BaseLLM {
+    constructor(config) {
+        this.config = config;
+    }
+    async generate(prompt) {
+        throw new Error('Method not implemented.');
+    }
+    async *generateStream(prompt) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.BaseLLM = BaseLLM;
+// Export backend resolver
+var backend_resolver_1 = require("./backend-resolver");
+Object.defineProperty(exports, "resolveBackend", { enumerable: true, get: function () { return backend_resolver_1.resolveBackend; } });
+Object.defineProperty(exports, "resolveBackendSync", { enumerable: true, get: function () { return backend_resolver_1.resolveBackendSync; } });
+Object.defineProperty(exports, "isAISDKAvailable", { enumerable: true, get: function () { return backend_resolver_1.isAISDKAvailable; } });
+Object.defineProperty(exports, "resetAISDKAvailabilityCache", { enumerable: true, get: function () { return backend_resolver_1.resetAISDKAvailabilityCache; } });
+Object.defineProperty(exports, "getPreferredBackend", { enumerable: true, get: function () { return backend_resolver_1.getPreferredBackend; } });
+Object.defineProperty(exports, "getDefaultModel", { enumerable: true, get: function () { return backend_resolver_1.getDefaultModel; } });
+Object.defineProperty(exports, "parseModelString", { enumerable: true, get: function () { return backend_resolver_1.parseModelString; } });
+// Export embeddings
+var embeddings_1 = require("./embeddings");
+Object.defineProperty(exports, "embed", { enumerable: true, get: function () { return embeddings_1.embed; } });
+Object.defineProperty(exports, "embedMany", { enumerable: true, get: function () { return embeddings_1.embedMany; } });
+Object.defineProperty(exports, "createEmbeddingProvider", { enumerable: true, get: function () { return embeddings_1.createEmbeddingProvider; } });
+Object.defineProperty(exports, "getDefaultEmbeddingModel", { enumerable: true, get: function () { return embeddings_1.getDefaultEmbeddingModel; } });
+Object.defineProperty(exports, "parseEmbeddingModel", { enumerable: true, get: function () { return embeddings_1.parseEmbeddingModel; } });
+Object.defineProperty(exports, "cosineSimilarity", { enumerable: true, get: function () { return embeddings_1.cosineSimilarity; } });
+Object.defineProperty(exports, "euclideanDistance", { enumerable: true, get: function () { return embeddings_1.euclideanDistance; } });

package/dist/llm/llm.js

@@ -0,0 +1 @@
+"use strict";

package/dist/llm/openai.d.ts

@@ -0,0 +1,39 @@
+import type { ChatCompletionTool, ChatCompletionToolChoiceOption } from 'openai/resources/chat/completions';
+export interface LLMResponse {
+    content: string;
+    role: string;
+    tool_calls?: Array<{
+        id: string;
+        type: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ChatMessage {
+    role: ChatRole;
+    content: string | null;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+export declare class OpenAIService {
+    private model;
+    private client;
+    constructor(model?: string);
+    private getClient;
+    generateText(prompt: string, systemPrompt?: string, temperature?: number, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption): Promise<string>;
+    generateChat(messages: ChatMessage[], temperature?: number, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption): Promise<LLMResponse>;
+    streamText(prompt: string, systemPrompt: string | undefined, temperature: number | undefined, onToken: (token: string) => void, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption, onToolCall?: (toolCall: any) => void): Promise<void>;
+    streamChat(messages: ChatMessage[], temperature: number | undefined, onToken: (token: string) => void): Promise<string>;
+    chatCompletion(messages: ChatMessage[], temperature?: number, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption): Promise<LLMResponse>;
+}
+export {};