praisonai 1.0.19 → 1.2.0

package/dist/tools/decorator.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Tool Decorator and Registry - Type-safe tool creation and management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = exports.FunctionTool = void 0;
+exports.tool = tool;
+exports.getRegistry = getRegistry;
+exports.registerTool = registerTool;
+exports.getTool = getTool;
+/**
+ * Tool class - Represents an executable tool
+ */
+class FunctionTool {
+    constructor(config) {
+        this.name = config.name;
+        this.description = config.description || `Function ${config.name}`;
+        this.parameters = this.normalizeParameters(config.parameters);
+        this.category = config.category;
+        this.executeFn = config.execute;
+    }
+    normalizeParameters(params) {
+        if (!params) {
+            return { type: 'object', properties: {}, required: [] };
+        }
+        // Check if it's a Zod schema
+        if (params && typeof params.parse === 'function' && typeof params._def === 'object') {
+            return this.zodToJsonSchema(params);
+        }
+        // Already a JSON schema
+        return params;
+    }
+    zodToJsonSchema(zodSchema) {
+        // Basic Zod to JSON Schema conversion
+        // For full support, use zod-to-json-schema package
+        const def = zodSchema._def;
+        if (def.typeName === 'ZodObject') {
+            const properties = {};
+            const required = [];
+            for (const [key, value] of Object.entries(def.shape())) {
+                const fieldDef = value._def;
+                properties[key] = this.zodFieldToJsonSchema(fieldDef);
+                // Check if field is required (not optional)
+                if (fieldDef.typeName !== 'ZodOptional' && fieldDef.typeName !== 'ZodDefault') {
+                    required.push(key);
+                }
+            }
+            return { type: 'object', properties, required };
+        }
+        return { type: 'object', properties: {}, required: [] };
+    }
+    zodFieldToJsonSchema(def) {
+        const typeName = def.typeName;
+        switch (typeName) {
+            case 'ZodString':
+                return { type: 'string', description: def.description };
+            case 'ZodNumber':
+                return { type: 'number', description: def.description };
+            case 'ZodBoolean':
+                return { type: 'boolean', description: def.description };
+            case 'ZodArray':
+                return { type: 'array', items: this.zodFieldToJsonSchema(def.type._def) };
+            case 'ZodEnum':
+                return { type: 'string', enum: def.values };
+            case 'ZodOptional':
+                return this.zodFieldToJsonSchema(def.innerType._def);
+            case 'ZodDefault':
+                const inner = this.zodFieldToJsonSchema(def.innerType._def);
+                inner.default = def.defaultValue();
+                return inner;
+            default:
+                return { type: 'string' };
+        }
+    }
+    async execute(params, context) {
+        // Validate parameters if we have a schema
+        // For now, just execute - validation can be added later
+        return this.executeFn(params, context);
+    }
+    /**
+     * Get the tool definition for LLM
+     */
+    getDefinition() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: this.parameters,
+            category: this.category,
+        };
+    }
+    /**
+     * Get OpenAI-compatible tool format
+     */
+    toOpenAITool() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.parameters,
+            },
+        };
+    }
+}
+exports.FunctionTool = FunctionTool;
+/**
+ * Create a tool from a configuration object
+ */
+function tool(config) {
+    return new FunctionTool(config);
+}
+/**
+ * Tool Registry - Manages tool registration and lookup
+ */
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    register(tool, options) {
+        if (this.tools.has(tool.name) && !options?.overwrite) {
+            throw new Error(`Tool '${tool.name}' is already registered. Use { overwrite: true } to replace.`);
+        }
+        this.tools.set(tool.name, tool);
+        return this;
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+    list() {
+        return Array.from(this.tools.values());
+    }
+    getByCategory(category) {
+        return this.list().filter(t => t.category === category);
+    }
+    getDefinitions() {
+        return this.list().map(t => t.getDefinition());
+    }
+    toOpenAITools() {
+        return this.list().map(t => t.toOpenAITool());
+    }
+    delete(name) {
+        return this.tools.delete(name);
+    }
+    clear() {
+        this.tools.clear();
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+// Global registry instance
+let globalRegistry = null;
+function getRegistry() {
+    if (!globalRegistry) {
+        globalRegistry = new ToolRegistry();
+    }
+    return globalRegistry;
+}
+function registerTool(tool, options) {
+    getRegistry().register(tool, options);
+}
+function getTool(name) {
+    return getRegistry().get(name);
+}

package/dist/tools/index.d.ts

@@ -9,4 +9,6 @@ export declare class BaseTool implements Tool {
     constructor(name: string, description: string);
     execute(...args: any[]): Promise<any>;
 }
+export * from './decorator';
 export * from './arxivTools';
+export * from './mcpSse';

package/dist/tools/index.js

@@ -25,5 +25,8 @@ class BaseTool {
     }
 }
 exports.BaseTool = BaseTool;
+// Export decorator and registry
+__exportStar(require("./decorator"), exports);
 // Export all tool modules
 __exportStar(require("./arxivTools"), exports);
+__exportStar(require("./mcpSse"), exports);

package/dist/tools/mcpSse.d.ts

@@ -0,0 +1,41 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { BaseTool } from './index';
+export interface MCPToolInfo {
+    name: string;
+    description?: string;
+    inputSchema?: any;
+}
+export declare class MCPTool extends BaseTool {
+    private client;
+    private inputSchema;
+    constructor(info: MCPToolInfo, client: Client);
+    get schemaProperties(): Record<string, any> | undefined;
+    execute(args?: any): Promise<any>;
+    toOpenAITool(): {
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    };
+}
+export declare class MCP implements Iterable<MCPTool> {
+    private url;
+    private debug;
+    tools: MCPTool[];
+    private client;
+    constructor(url: string, debug?: boolean);
+    initialize(): Promise<void>;
+    [Symbol.iterator](): Iterator<MCPTool>;
+    toOpenAITools(): {
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    }[];
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}

package/dist/tools/mcpSse.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP = exports.MCPTool = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const index_1 = require("./index");
+class MCPTool extends index_1.BaseTool {
+    constructor(info, client) {
+        super(info.name, info.description || `Call the ${info.name} tool`);
+        this.client = client;
+        this.inputSchema = info.inputSchema || { type: 'object', properties: {}, required: [] };
+    }
+    get schemaProperties() {
+        return this.inputSchema?.properties;
+    }
+    async execute(args = {}) {
+        try {
+            const result = await this.client.callTool({ name: this.name, arguments: args });
+            if (result.structuredContent) {
+                return result.structuredContent;
+            }
+            if (Array.isArray(result.content) && result.content.length > 0) {
+                const item = result.content[0];
+                if (typeof item.text === 'string')
+                    return item.text;
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to execute tool ${this.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    toOpenAITool() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.inputSchema
+            }
+        };
+    }
+}
+exports.MCPTool = MCPTool;
+class MCP {
+    constructor(url, debug = false) {
+        this.url = url;
+        this.debug = debug;
+        this.tools = [];
+        this.client = null;
+        if (debug) {
+            console.log(`MCP client initialized for URL: ${url}`);
+        }
+    }
+    async initialize() {
+        if (this.client) {
+            if (this.debug)
+                console.log('MCP client already initialized');
+            return;
+        }
+        try {
+            this.client = new index_js_1.Client({ name: 'praisonai-ts-mcp', version: '1.0.0' });
+            const transport = new sse_js_1.SSEClientTransport(new URL(this.url));
+            await this.client.connect(transport);
+            const { tools } = await this.client.listTools();
+            this.tools = tools.map((t) => new MCPTool({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema
+            }, this.client));
+            if (this.debug)
+                console.log(`Initialized MCP with ${this.tools.length} tools`);
+        }
+        catch (error) {
+            if (this.client) {
+                await this.client.close().catch(() => { });
+                this.client = null;
+            }
+            throw new Error(`Failed to initialize MCP client: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    [Symbol.iterator]() {
+        return this.tools[Symbol.iterator]();
+    }
+    toOpenAITools() {
+        return this.tools.map(t => t.toOpenAITool());
+    }
+    async close() {
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch (error) {
+                if (this.debug) {
+                    console.warn('Error closing MCP client:', error);
+                }
+            }
+            finally {
+                this.client = null;
+                this.tools = [];
+            }
+        }
+    }
+    get isConnected() {
+        return this.client !== null;
+    }
+}
+exports.MCP = MCP;

package/dist/workflows/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Workflows - Pipeline and orchestration patterns
+ */
+export type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface StepResult<T = any> {
+    stepId: string;
+    stepName: string;
+    status: StepStatus;
+    output?: T;
+    error?: Error;
+    duration: number;
+    startedAt: number;
+    completedAt?: number;
+}
+export interface WorkflowContext {
+    workflowId: string;
+    stepResults: Map<string, StepResult>;
+    metadata: Record<string, any>;
+    get<T = any>(stepName: string): T | undefined;
+    set(key: string, value: any): void;
+}
+export type StepFunction<TInput = any, TOutput = any> = (input: TInput, context: WorkflowContext) => Promise<TOutput> | TOutput;
+export interface WorkflowStepConfig<TInput = any, TOutput = any> {
+    name: string;
+    execute: StepFunction<TInput, TOutput>;
+    condition?: (context: WorkflowContext) => boolean;
+    onError?: 'fail' | 'skip' | 'retry';
+    maxRetries?: number;
+    timeout?: number;
+}
+/**
+ * Workflow Step
+ */
+export declare class WorkflowStep<TInput = any, TOutput = any> {
+    readonly id: string;
+    readonly name: string;
+    readonly execute: StepFunction<TInput, TOutput>;
+    readonly condition?: (context: WorkflowContext) => boolean;
+    readonly onError: 'fail' | 'skip' | 'retry';
+    readonly maxRetries: number;
+    readonly timeout?: number;
+    constructor(config: WorkflowStepConfig<TInput, TOutput>);
+    run(input: TInput, context: WorkflowContext): Promise<StepResult<TOutput>>;
+    private executeWithTimeout;
+}
+/**
+ * Workflow - Sequential pipeline execution
+ */
+export declare class Workflow<TInput = any, TOutput = any> {
+    readonly id: string;
+    readonly name: string;
+    private steps;
+    constructor(name: string);
+    /**
+     * Add a step to the workflow
+     */
+    addStep<TStepInput = any, TStepOutput = any>(config: WorkflowStepConfig<TStepInput, TStepOutput>): this;
+    /**
+     * Add a step using a simpler syntax
+     */
+    step<TStepInput = any, TStepOutput = any>(name: string, execute: StepFunction<TStepInput, TStepOutput>): this;
+    /**
+     * Run the workflow
+     */
+    run(input: TInput): Promise<{
+        output: TOutput | undefined;
+        results: StepResult[];
+        context: WorkflowContext;
+    }>;
+    /**
+     * Get step count
+     */
+    get stepCount(): number;
+}
+/**
+ * Pipeline - Alias for Workflow
+ */
+export declare const Pipeline: typeof Workflow;
+/**
+ * Parallel execution helper
+ */
+export declare function parallel<T>(tasks: Array<() => Promise<T>>): Promise<T[]>;
+/**
+ * Route helper - Execute based on condition
+ */
+export declare function route<T>(conditions: Array<{
+    condition: () => boolean;
+    execute: () => Promise<T>;
+}>, defaultExecute?: () => Promise<T>): Promise<T | undefined>;
+/**
+ * Loop helper - Repeat until condition
+ */
+export declare function loop<T>(execute: (iteration: number) => Promise<T>, shouldContinue: (result: T, iteration: number) => boolean, maxIterations?: number): Promise<T[]>;
+/**
+ * Repeat helper - Execute N times
+ */
+export declare function repeat<T>(execute: (iteration: number) => Promise<T>, times: number): Promise<T[]>;

package/dist/workflows/index.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Workflows - Pipeline and orchestration patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipeline = exports.Workflow = exports.WorkflowStep = void 0;
+exports.parallel = parallel;
+exports.route = route;
+exports.loop = loop;
+exports.repeat = repeat;
+const crypto_1 = require("crypto");
+/**
+ * Workflow Step
+ */
+class WorkflowStep {
+    constructor(config) {
+        this.id = (0, crypto_1.randomUUID)();
+        this.name = config.name;
+        this.execute = config.execute;
+        this.condition = config.condition;
+        this.onError = config.onError || 'fail';
+        this.maxRetries = config.maxRetries || 0;
+        this.timeout = config.timeout;
+    }
+    async run(input, context) {
+        const startedAt = Date.now();
+        // Check condition
+        if (this.condition && !this.condition(context)) {
+            return {
+                stepId: this.id,
+                stepName: this.name,
+                status: 'skipped',
+                duration: 0,
+                startedAt,
+                completedAt: Date.now(),
+            };
+        }
+        let lastError;
+        let attempts = 0;
+        while (attempts <= this.maxRetries) {
+            attempts++;
+            try {
+                const output = await this.executeWithTimeout(input, context);
+                const completedAt = Date.now();
+                return {
+                    stepId: this.id,
+                    stepName: this.name,
+                    status: 'completed',
+                    output,
+                    duration: completedAt - startedAt,
+                    startedAt,
+                    completedAt,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                if (this.onError === 'skip') {
+                    return {
+                        stepId: this.id,
+                        stepName: this.name,
+                        status: 'skipped',
+                        error: lastError,
+                        duration: Date.now() - startedAt,
+                        startedAt,
+                        completedAt: Date.now(),
+                    };
+                }
+                if (this.onError !== 'retry' || attempts > this.maxRetries) {
+                    break;
+                }
+            }
+        }
+        return {
+            stepId: this.id,
+            stepName: this.name,
+            status: 'failed',
+            error: lastError,
+            duration: Date.now() - startedAt,
+            startedAt,
+            completedAt: Date.now(),
+        };
+    }
+    async executeWithTimeout(input, context) {
+        if (!this.timeout) {
+            return this.execute(input, context);
+        }
+        return Promise.race([
+            this.execute(input, context),
+            new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Step ${this.name} timed out after ${this.timeout}ms`)), this.timeout);
+            }),
+        ]);
+    }
+}
+exports.WorkflowStep = WorkflowStep;
+/**
+ * Create a workflow context
+ */
+function createContext(workflowId) {
+    const stepResults = new Map();
+    const metadata = {};
+    return {
+        workflowId,
+        stepResults,
+        metadata,
+        get(stepName) {
+            const result = stepResults.get(stepName);
+            return result?.output;
+        },
+        set(key, value) {
+            metadata[key] = value;
+        },
+    };
+}
+/**
+ * Workflow - Sequential pipeline execution
+ */
+class Workflow {
+    constructor(name) {
+        this.steps = [];
+        this.id = (0, crypto_1.randomUUID)();
+        this.name = name;
+    }
+    /**
+     * Add a step to the workflow
+     */
+    addStep(config) {
+        this.steps.push(new WorkflowStep(config));
+        return this;
+    }
+    /**
+     * Add a step using a simpler syntax
+     */
+    step(name, execute) {
+        return this.addStep({ name, execute });
+    }
+    /**
+     * Run the workflow
+     */
+    async run(input) {
+        const context = createContext(this.id);
+        const results = [];
+        let currentInput = input;
+        for (const step of this.steps) {
+            const result = await step.run(currentInput, context);
+            results.push(result);
+            context.stepResults.set(step.name, result);
+            if (result.status === 'failed') {
+                return { output: undefined, results, context };
+            }
+            if (result.status === 'completed') {
+                currentInput = result.output;
+            }
+        }
+        const lastResult = results[results.length - 1];
+        return {
+            output: lastResult?.output,
+            results,
+            context,
+        };
+    }
+    /**
+     * Get step count
+     */
+    get stepCount() {
+        return this.steps.length;
+    }
+}
+exports.Workflow = Workflow;
+/**
+ * Pipeline - Alias for Workflow
+ */
+exports.Pipeline = Workflow;
+/**
+ * Parallel execution helper
+ */
+async function parallel(tasks) {
+    return Promise.all(tasks.map(task => task()));
+}
+/**
+ * Route helper - Execute based on condition
+ */
+async function route(conditions, defaultExecute) {
+    for (const { condition, execute } of conditions) {
+        if (condition()) {
+            return execute();
+        }
+    }
+    return defaultExecute?.();
+}
+/**
+ * Loop helper - Repeat until condition
+ */
+async function loop(execute, shouldContinue, maxIterations = 100) {
+    const results = [];
+    let iteration = 0;
+    while (iteration < maxIterations) {
+        const result = await execute(iteration);
+        results.push(result);
+        if (!shouldContinue(result, iteration)) {
+            break;
+        }
+        iteration++;
+    }
+    return results;
+}
+/**
+ * Repeat helper - Execute N times
+ */
+async function repeat(execute, times) {
+    const results = [];
+    for (let i = 0; i < times; i++) {
+        results.push(await execute(i));
+    }
+    return results;
+}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "praisonai",
-  "version": "1.0.19",
+  "version": "1.2.0",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "praisonai-ts": "./dist/cli/index.js"
+  },
   "scripts": {
     "build": "tsc",
     "test": "jest",
@@ -62,7 +65,7 @@
     "fast-xml-parser": "^4.5.1",
     "node-fetch": "^2.6.9",
     "openai": "^4.81.0",
-    "praisonai": "^1.0.18"
+    "@modelcontextprotocol/sdk": "^1.12.1"
   },
   "optionalDependencies": {
     "boxen": "^7.1.1",