praisonai 1.3.4 → 1.3.5

package/dist/agent/simple.d.ts

@@ -1,4 +1,5 @@
 import type { DbAdapter } from '../db/types';
+import type { LLMProvider } from '../llm/providers/types';
 /**
  * Agent Configuration
  *
@@ -108,6 +109,10 @@ export declare class Agent {
     private cacheTTL;
     private responseCache;
     private telemetryEnabled;
+    private _backend;
+    private _backendPromise;
+    private _backendSource;
+    private _useAISDKBackend;
     constructor(config: SimpleAgentConfig);
     /**
      * Generate a session ID based on current hour and agent name (like Python SDK)
@@ -182,6 +187,39 @@ export declare class Agent {
      * Clear response cache
      */
     clearCache(): void;
+    /**
+     * Get the resolved backend (AI SDK preferred, native fallback)
+     * Lazy initialization - backend is only resolved on first use
+     */
+    getBackend(): Promise<LLMProvider>;
+    /**
+     * Get the backend source (ai-sdk, native, custom, or legacy)
+     */
+    getBackendSource(): 'ai-sdk' | 'native' | 'custom' | 'legacy';
+    /**
+     * Embed text using AI SDK (preferred) or native provider
+     *
+     * @param text - Text to embed (string or array of strings)
+     * @param options - Embedding options
+     * @returns Embedding vector(s)
+     *
+     * @example Single text
+     * ```typescript
+     * const embedding = await agent.embed("Hello world");
+     * ```
+     *
+     * @example Multiple texts
+     * ```typescript
+     * const embeddings = await agent.embed(["Hello", "World"]);
+     * ```
+     */
+    embed(text: string | string[], options?: {
+        model?: string;
+    }): Promise<number[] | number[][]>;
+    /**
+     * Get the model string for this agent
+     */
+    getModel(): string;
 }
 /**
  * Configuration for multi-agent orchestration

package/dist/agent/simple.js

@@ -1,4 +1,37 @@
 "use strict";
+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.Agents = exports.PraisonAIAgents = exports.Agent = void 0;
 const openai_1 = require("../llm/openai");
@@ -10,6 +43,11 @@ class Agent {
         this.messages = [];
         this.dbInitialized = false;
         this.responseCache = new Map();
+        // AI SDK backend support
+        this._backend = null;
+        this._backendPromise = null;
+        this._backendSource = 'legacy';
+        this._useAISDKBackend = false;
         // Build instructions from either simple or advanced mode
         if (config.instructions) {
             this.instructions = config.instructions;
@@ -44,7 +82,14 @@ class Agent {
         this.cache = config.cache ?? false;
         this.cacheTTL = config.cacheTTL ?? 3600;
         this.telemetryEnabled = config.telemetry ?? false;
-        this.llmService = new openai_1.OpenAIService(this.llm);
+        // Parse model string to extract provider and model ID
+        // Format: "provider/model" or just "model"
+        const providerId = this.llm.includes('/') ? this.llm.split('/')[0] : 'openai';
+        const modelId = this.llm.includes('/') ? this.llm.split('/').slice(1).join('/') : this.llm;
+        // For OpenAI, use OpenAIService directly for backward compatibility
+        // For other providers, we'll use the AI SDK backend via getBackend()
+        this._useAISDKBackend = providerId !== 'openai';
+        this.llmService = new openai_1.OpenAIService(modelId);
         // Configure logging
         logger_1.Logger.setVerbose(this.verbose);
         logger_1.Logger.setPretty(this.pretty);
@@ -290,8 +335,35 @@ class Agent {
             // Add current user prompt
             messages.push({ role: 'user', content: prompt });
             let finalResponse = '';
-            if (this.stream && !this.tools) {
-                // Use streaming with full conversation history
+            // Use AI SDK backend for non-OpenAI providers
+            if (this._useAISDKBackend) {
+                const backend = await this.getBackend();
+                if (this.stream && !this.tools) {
+                    // Streaming with AI SDK backend
+                    const stream = await backend.streamText({
+                        messages,
+                        temperature: 0.7
+                    });
+                    let accumulated = '';
+                    for await (const chunk of stream) {
+                        if (chunk.text) {
+                            process.stdout.write(chunk.text);
+                            accumulated += chunk.text;
+                        }
+                    }
+                    finalResponse = accumulated;
+                }
+                else {
+                    // Non-streaming with AI SDK backend
+                    const result = await backend.generateText({
+                        messages,
+                        temperature: 0.7
+                    });
+                    finalResponse = result.text;
+                }
+            }
+            else if (this.stream && !this.tools) {
+                // Use streaming with full conversation history (OpenAI)
                 finalResponse = await this.llmService.streamChat(messages, 0.7, (token) => {
                     process.stdout.write(token);
                 });
@@ -437,6 +509,73 @@ class Agent {
     clearCache() {
         this.responseCache.clear();
     }
+    /**
+     * Get the resolved backend (AI SDK preferred, native fallback)
+     * Lazy initialization - backend is only resolved on first use
+     */
+    async getBackend() {
+        if (this._backend) {
+            return this._backend;
+        }
+        if (!this._backendPromise) {
+            this._backendPromise = (async () => {
+                const { resolveBackend } = await Promise.resolve().then(() => __importStar(require('../llm/backend-resolver')));
+                const result = await resolveBackend(this.llm, {
+                    attribution: {
+                        agentId: this.name,
+                        runId: this.runId,
+                        sessionId: this.sessionId,
+                    },
+                });
+                this._backend = result.provider;
+                this._backendSource = result.source;
+                logger_1.Logger.debug(`Agent ${this.name} using ${result.source} backend for ${this.llm}`);
+                return result;
+            })();
+        }
+        const result = await this._backendPromise;
+        return result.provider;
+    }
+    /**
+     * Get the backend source (ai-sdk, native, custom, or legacy)
+     */
+    getBackendSource() {
+        return this._backendSource;
+    }
+    /**
+     * Embed text using AI SDK (preferred) or native provider
+     *
+     * @param text - Text to embed (string or array of strings)
+     * @param options - Embedding options
+     * @returns Embedding vector(s)
+     *
+     * @example Single text
+     * ```typescript
+     * const embedding = await agent.embed("Hello world");
+     * ```
+     *
+     * @example Multiple texts
+     * ```typescript
+     * const embeddings = await agent.embed(["Hello", "World"]);
+     * ```
+     */
+    async embed(text, options) {
+        const { embed, embedMany } = await Promise.resolve().then(() => __importStar(require('../llm/embeddings')));
+        if (Array.isArray(text)) {
+            const result = await embedMany(text, { model: options?.model });
+            return result.embeddings;
+        }
+        else {
+            const result = await embed(text, { model: options?.model });
+            return result.embedding;
+        }
+    }
+    /**
+     * Get the model string for this agent
+     */
+    getModel() {
+        return this.llm;
+    }
 }
 exports.Agent = Agent;
 /**

package/dist/cli/commands/benchmark.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Benchmark Command - Performance benchmarks for AI SDK vs Native backends
+ *
+ * Measures:
+ * - Import time (cold start)
+ * - Memory usage
+ * - First-call latency
+ * - Streaming throughput
+ * - Embedding throughput
+ */
+export interface BenchmarkOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    iterations?: number;
+    backend?: 'ai-sdk' | 'native' | 'both';
+    real?: boolean;
+}
+export declare function execute(args: string[], options: BenchmarkOptions): Promise<void>;