praisonai 1.3.5 → 1.4.0

package/dist/agent/context.d.ts

@@ -24,12 +24,18 @@ export declare class ContextAgent {
     readonly name: string;
     readonly instructions: string;
     private provider;
+    private providerPromise;
+    private llmModel;
     private knowledgeBase?;
     private contextWindow;
     private maxContextTokens;
     private messages;
     private verbose;
     constructor(config: ContextAgentConfig);
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    private getProvider;
     /**
      * Chat with context awareness
      */

package/dist/agent/context.js

@@ -5,21 +5,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextAgent = void 0;
 exports.createContextAgent = createContextAgent;
-const providers_1 = require("../llm/providers");
+const backend_resolver_1 = require("../llm/backend-resolver");
 /**
  * Context Agent - Agent with RAG and context management
  */
 class ContextAgent {
     constructor(config) {
+        this.provider = null;
+        this.providerPromise = null;
         this.messages = [];
         this.name = config.name || `ContextAgent_${Math.random().toString(36).substr(2, 9)}`;
         this.instructions = config.instructions;
-        this.provider = (0, providers_1.createProvider)(config.llm || 'gpt-4o-mini');
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
         this.knowledgeBase = config.knowledgeBase;
         this.contextWindow = config.contextWindow ?? 10;
         this.maxContextTokens = config.maxContextTokens ?? 4000;
         this.verbose = config.verbose ?? false;
     }
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    async getProvider() {
+        if (this.provider) {
+            return this.provider;
+        }
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, {
+                    attribution: { agentId: this.name },
+                });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
     /**
      * Chat with context awareness
      */
@@ -51,7 +71,8 @@ class ContextAgent {
             ...this.getRecentMessages()
         ];
         // Generate response
-        const result = await this.provider.generateText({ messages });
+        const provider = await this.getProvider();
+        const result = await provider.generateText({ messages });
         // Add assistant message
         this.messages.push({
             role: 'assistant',

package/dist/agent/enhanced.d.ts

@@ -50,6 +50,8 @@ export declare class EnhancedAgent {
     readonly instructions: string;
     readonly sessionId: string;
     private provider;
+    private providerPromise;
+    private llmModel;
     private session;
     private toolRegistry;
     private verbose;
@@ -59,6 +61,10 @@ export declare class EnhancedAgent {
     private maxTokens?;
     private outputSchema?;
     constructor(config: EnhancedAgentConfig);
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    private getProvider;
     private registerTools;
     /**
      * Add a tool to the agent

package/dist/agent/enhanced.js

@@ -4,7 +4,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnhancedAgent = void 0;
-const providers_1 = require("../llm/providers");
+const backend_resolver_1 = require("../llm/backend-resolver");
 const session_1 = require("../session");
 const decorator_1 = require("../tools/decorator");
 const logger_1 = require("../utils/logger");
@@ -13,6 +13,8 @@ const logger_1 = require("../utils/logger");
  */
 class EnhancedAgent {
     constructor(config) {
+        this.provider = null;
+        this.providerPromise = null;
         this.name = config.name || `Agent_${Math.random().toString(36).substr(2, 9)}`;
         this.instructions = config.instructions;
         this.verbose = config.verbose ?? true;
@@ -21,8 +23,8 @@ class EnhancedAgent {
         this.temperature = config.temperature ?? 0.7;
         this.maxTokens = config.maxTokens;
         this.outputSchema = config.outputSchema;
-        // Initialize provider
-        this.provider = (0, providers_1.createProvider)(config.llm || 'gpt-4o-mini');
+        // Store model string for lazy provider initialization
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
         // Initialize session
         if (config.session) {
             this.session = config.session;
@@ -41,6 +43,27 @@ class EnhancedAgent {
         }
         logger_1.Logger.setVerbose(this.verbose);
     }
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    async getProvider() {
+        if (this.provider) {
+            return this.provider;
+        }
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, {
+                    attribution: {
+                        agentId: this.name,
+                        sessionId: this.sessionId,
+                    },
+                });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
     registerTools(tools) {
         if (!tools)
             return;
@@ -118,7 +141,8 @@ class EnhancedAgent {
                 iterations++;
                 if (options.stream && !tools && options.onToken) {
                     // Streaming without tools
-                    const stream = await this.provider.streamText({
+                    const provider = await this.getProvider();
+                    const stream = await provider.streamText({
                         messages,
                         temperature: options.temperature ?? this.temperature,
                         maxTokens: options.maxTokens ?? this.maxTokens,
@@ -140,7 +164,8 @@ class EnhancedAgent {
                 }
                 else if (options.outputSchema) {
                     // Structured output
-                    const objResult = await this.provider.generateObject({
+                    const provider = await this.getProvider();
+                    const objResult = await provider.generateObject({
                         messages,
                         schema: options.outputSchema ?? this.outputSchema,
                         temperature: options.temperature ?? this.temperature,
@@ -156,7 +181,8 @@ class EnhancedAgent {
                 }
                 else {
                     // Regular generation with potential tool calls
-                    result = await this.provider.generateText({
+                    const provider = await this.getProvider();
+                    result = await provider.generateText({
                         messages,
                         temperature: options.temperature ?? this.temperature,
                         maxTokens: options.maxTokens ?? this.maxTokens,

package/dist/agent/image.d.ts

@@ -25,9 +25,15 @@ export interface ImageAgentConfig {
 export declare class ImageAgent {
     readonly name: string;
     private provider;
+    private providerPromise;
+    private llmModel;
     private imageModel;
     private verbose;
     constructor(config?: ImageAgentConfig);
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    private getProvider;
     /**
      * Analyze an image
      */

package/dist/agent/image.js

@@ -5,17 +5,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImageAgent = void 0;
 exports.createImageAgent = createImageAgent;
-const providers_1 = require("../llm/providers");
+const backend_resolver_1 = require("../llm/backend-resolver");
 /**
  * ImageAgent - Agent for image generation and analysis
  */
 class ImageAgent {
     constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
         this.name = config.name || `ImageAgent_${Math.random().toString(36).substr(2, 9)}`;
-        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
         this.imageModel = config.imageModel || 'dall-e-3';
         this.verbose = config.verbose ?? false;
     }
+    /**
+     * Get the LLM provider (lazy initialization with AI SDK backend)
+     */
+    async getProvider() {
+        if (this.provider) {
+            return this.provider;
+        }
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, {
+                    attribution: { agentId: this.name },
+                });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
     /**
      * Analyze an image
      */
@@ -36,7 +56,8 @@ class ImageAgent {
                 ]
             }
         ];
-        const result = await this.provider.generateText({ messages });
+        const provider = await this.getProvider();
+        const result = await provider.generateText({ messages });
         if (this.verbose) {
             console.log(`[ImageAgent] Analysis: ${result.text.substring(0, 100)}...`);
         }
@@ -60,7 +81,8 @@ class ImageAgent {
         if (imageUrl) {
             return this.analyze({ imageUrl, prompt });
         }
-        const result = await this.provider.generateText({
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
             messages: [{ role: 'user', content: prompt }]
         });
         return result.text;
@@ -80,7 +102,8 @@ class ImageAgent {
                 ]
             }
         ];
-        const result = await this.provider.generateText({ messages });
+        const provider = await this.getProvider();
+        const result = await provider.generateText({ messages });
         return result.text;
     }
 }

package/dist/agent/prompt-expander.d.ts

@@ -20,9 +20,12 @@ export interface PromptExpanderConfig {
 export declare class PromptExpanderAgent {
     readonly name: string;
     private provider;
+    private providerPromise;
+    private llmModel;
     private defaultStrategy;
     private verbose;
     constructor(config?: PromptExpanderConfig);
+    private getProvider;
     /**
      * Expand a prompt
      */

package/dist/agent/prompt-expander.js

@@ -5,17 +5,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptExpanderAgent = void 0;
 exports.createPromptExpanderAgent = createPromptExpanderAgent;
-const providers_1 = require("../llm/providers");
+const backend_resolver_1 = require("../llm/backend-resolver");
 /**
  * PromptExpanderAgent - Expand prompts with more detail and context
  */
 class PromptExpanderAgent {
     constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
         this.name = config.name || `PromptExpander_${Math.random().toString(36).substr(2, 9)}`;
-        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
         this.defaultStrategy = config.defaultStrategy || 'auto';
         this.verbose = config.verbose ?? false;
     }
+    async getProvider() {
+        if (this.provider)
+            return this.provider;
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, { attribution: { agentId: this.name } });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
     /**
      * Expand a prompt
      */
@@ -23,7 +37,8 @@ class PromptExpanderAgent {
         const useStrategy = strategy || this.defaultStrategy;
         const actualStrategy = useStrategy === 'auto' ? this.detectStrategy(prompt) : useStrategy;
         const systemPrompt = this.getSystemPrompt(actualStrategy);
-        const result = await this.provider.generateText({
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
             messages: [
                 { role: 'system', content: systemPrompt },
                 { role: 'user', content: `Expand this prompt: ${prompt}` }

package/dist/agent/query-rewriter.d.ts

@@ -20,9 +20,12 @@ export interface QueryRewriterConfig {
 export declare class QueryRewriterAgent {
     readonly name: string;
     private provider;
+    private providerPromise;
+    private llmModel;
     private defaultStrategy;
     private verbose;
     constructor(config?: QueryRewriterConfig);
+    private getProvider;
     /**
      * Rewrite a query
      */

package/dist/agent/query-rewriter.js

@@ -5,17 +5,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryRewriterAgent = void 0;
 exports.createQueryRewriterAgent = createQueryRewriterAgent;
-const providers_1 = require("../llm/providers");
+const backend_resolver_1 = require("../llm/backend-resolver");
 /**
  * QueryRewriterAgent - Optimize and rewrite queries
  */
 class QueryRewriterAgent {
     constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
         this.name = config.name || `QueryRewriter_${Math.random().toString(36).substr(2, 9)}`;
-        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
         this.defaultStrategy = config.defaultStrategy || 'auto';
         this.verbose = config.verbose ?? false;
     }
+    async getProvider() {
+        if (this.provider)
+            return this.provider;
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, { attribution: { agentId: this.name } });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
     /**
      * Rewrite a query
      */
@@ -23,7 +37,8 @@ class QueryRewriterAgent {
         const useStrategy = strategy || this.defaultStrategy;
         const actualStrategy = useStrategy === 'auto' ? this.detectStrategy(query) : useStrategy;
         const prompt = this.buildPrompt(query, actualStrategy);
-        const result = await this.provider.generateText({
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
             messages: [
                 { role: 'system', content: this.getSystemPrompt(actualStrategy) },
                 { role: 'user', content: prompt }

package/dist/agent/research.d.ts

@@ -31,10 +31,13 @@ export interface DeepResearchConfig {
 export declare class DeepResearchAgent {
     readonly name: string;
     private provider;
+    private providerPromise;
+    private llmModel;
     private maxIterations;
     private searchTool?;
     private verbose;
     constructor(config?: DeepResearchConfig);
+    private getProvider;
     /**
      * Conduct deep research on a topic
      */

package/dist/agent/research.js

@@ -5,18 +5,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeepResearchAgent = void 0;
 exports.createDeepResearchAgent = createDeepResearchAgent;
-const providers_1 = require("../llm/providers");
+const backend_resolver_1 = require("../llm/backend-resolver");
 /**
  * DeepResearchAgent - Comprehensive research with citations
  */
 class DeepResearchAgent {
     constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
         this.name = config.name || `ResearchAgent_${Math.random().toString(36).substr(2, 9)}`;
-        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
         this.maxIterations = config.maxIterations ?? 5;
         this.searchTool = config.searchTool;
         this.verbose = config.verbose ?? false;
     }
+    async getProvider() {
+        if (this.provider)
+            return this.provider;
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, { attribution: { agentId: this.name } });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
     /**
      * Conduct deep research on a topic
      */
@@ -76,7 +90,8 @@ class DeepResearchAgent {
         };
     }
     async generateSearchQueries(query) {
-        const result = await this.provider.generateText({
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
             messages: [
                 {
                     role: 'system',
@@ -91,7 +106,8 @@ class DeepResearchAgent {
         const context = citations.length > 0
             ? `\n\nRelevant sources:\n${citations.map(c => `- ${c.title}: ${c.snippet || ''}`).join('\n')}`
             : '';
-        const result = await this.provider.generateText({
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
             messages: [
                 {
                     role: 'system',

package/dist/agent/simple.d.ts

@@ -115,7 +115,7 @@ export declare class Agent {
     private _useAISDKBackend;
     constructor(config: SimpleAgentConfig);
     /**
-     * Generate a session ID based on current hour and agent name (like Python SDK)
+     * Generate a unique session ID based on current hour, agent name, and random suffix
      */
     private generateSessionId;
     /**

package/dist/agent/simple.js

@@ -139,13 +139,14 @@ class Agent {
         }
     }
     /**
-     * Generate a session ID based on current hour and agent name (like Python SDK)
+     * Generate a unique session ID based on current hour, agent name, and random suffix
      */
     generateSessionId() {
         const now = new Date();
         const hourStr = now.toISOString().slice(0, 13).replace(/[-T:]/g, '');
         const hash = this.name ? this.name.slice(0, 6) : 'agent';
-        return `${hourStr}-${hash}`;
+        const randomSuffix = (0, crypto_1.randomUUID)().slice(0, 8);
+        return `${hourStr}-${hash}-${randomSuffix}`;
     }
     /**
      * Initialize DB session - restore history on first chat (lazy)

package/dist/ai/agent-loop.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Agent Loop - Manual Agent Loop Control
+ *
+ * Provides utilities for manual control of agent execution loops.
+ */
+import type { Message } from './types';
+export interface AgentLoopConfig {
+    /** Model to use */
+    model: string;
+    /** System prompt */
+    system?: string;
+    /** Available tools */
+    tools?: Record<string, AgentTool>;
+    /** Maximum steps (default: 10) */
+    maxSteps?: number;
+    /** Stop condition */
+    stopWhen?: StopCondition;
+    /** On step finish callback */
+    onStepFinish?: (step: AgentStep) => void | Promise<void>;
+    /** On tool call callback (for approval) */
+    onToolCall?: (toolCall: ToolCallInfo) => Promise<boolean>;
+}
+export interface AgentTool {
+    description: string;
+    parameters: any;
+    execute: (args: any) => Promise<any>;
+}
+export interface AgentStep {
+    stepNumber: number;
+    text: string;
+    toolCalls: ToolCallInfo[];
+    toolResults: ToolResultInfo[];
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finishReason: string;
+}
+export interface ToolCallInfo {
+    toolCallId: string;
+    toolName: string;
+    args: any;
+}
+export interface ToolResultInfo {
+    toolCallId: string;
+    toolName: string;
+    result: any;
+    isError?: boolean;
+}
+export type StopCondition = {
+    type: 'stepCount';
+    count: number;
+} | {
+    type: 'noToolCalls';
+} | {
+    type: 'custom';
+    check: (step: AgentStep) => boolean;
+};
+export interface AgentLoopResult {
+    text: string;
+    steps: AgentStep[];
+    totalUsage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finishReason: string;
+}
+/**
+ * Create a manual agent loop for fine-grained control.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const loop = createAgentLoop({
+ *   model: 'gpt-4o',
+ *   system: 'You are a helpful assistant',
+ *   tools: {
+ *     search: {
+ *       description: 'Search the web',
+ *       parameters: z.object({ query: z.string() }),
+ *       execute: async ({ query }) => searchWeb(query)
+ *     }
+ *   },
+ *   maxSteps: 5
+ * });
+ *
+ * const result = await loop.run('Find information about AI');
+ * ```
+ *
+ * @example With approval
+ * ```typescript
+ * const loop = createAgentLoop({
+ *   model: 'gpt-4o',
+ *   tools: { ... },
+ *   onToolCall: async (toolCall) => {
+ *     const approved = await askUserForApproval(toolCall);
+ *     return approved;
+ *   }
+ * });
+ * ```
+ *
+ * @example Step-by-step control
+ * ```typescript
+ * const loop = createAgentLoop({ model: 'gpt-4o', tools: { ... } });
+ *
+ * // Initialize with a prompt
+ * loop.addMessage({ role: 'user', content: 'Hello' });
+ *
+ * // Run one step at a time
+ * while (!loop.isComplete()) {
+ *   const step = await loop.step();
+ *   console.log('Step:', step);
+ *
+ *   // Optionally modify messages or tools between steps
+ *   if (needsMoreContext) {
+ *     loop.addMessage({ role: 'user', content: 'Additional context...' });
+ *   }
+ * }
+ *
+ * const result = loop.getResult();
+ * ```
+ */
+export declare function createAgentLoop(config: AgentLoopConfig): AgentLoop;
+export declare class AgentLoop {
+    private config;
+    private messages;
+    private steps;
+    private currentStep;
+    private complete;
+    private totalUsage;
+    constructor(config: AgentLoopConfig);
+    /**
+     * Add a message to the conversation.
+     */
+    addMessage(message: Message): void;
+    /**
+     * Get all messages in the conversation.
+     */
+    getMessages(): Message[];
+    /**
+     * Check if the loop is complete.
+     */
+    isComplete(): boolean;
+    /**
+     * Run a single step of the agent loop.
+     */
+    step(): Promise<AgentStep>;
+    /**
+     * Run the full agent loop until completion.
+     */
+    run(prompt: string): Promise<AgentLoopResult>;
+    /**
+     * Get the final result.
+     */
+    getResult(): AgentLoopResult;
+    /**
+     * Check if the loop should stop.
+     */
+    private shouldStop;
+    /**
+     * Reset the agent loop.
+     */
+    reset(): void;
+}
+/**
+ * Create a stop condition that stops after N steps.
+ */
+export declare function stopAfterSteps(count: number): StopCondition;
+/**
+ * Create a stop condition that stops when no tool calls are made.
+ */
+export declare function stopWhenNoToolCalls(): StopCondition;
+/**
+ * Create a custom stop condition.
+ */
+export declare function stopWhen(check: (step: AgentStep) => boolean): StopCondition;