overai 1.4.0

package/dist/observability/types.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Observability Types - Unified tracing interface for all observability integrations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBSERVABILITY_TOOLS = void 0;
+exports.getObservabilityToolInfo = getObservabilityToolInfo;
+exports.listObservabilityTools = listObservabilityTools;
+exports.hasObservabilityToolEnvVar = hasObservabilityToolEnvVar;
+/**
+ * All supported observability tools with their configurations
+ */
+exports.OBSERVABILITY_TOOLS = {
+    langfuse: {
+        name: 'langfuse',
+        package: 'langfuse',
+        envKey: 'LANGFUSE_SECRET_KEY',
+        description: 'Langfuse observability platform',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://langfuse.com/docs'
+    },
+    langsmith: {
+        name: 'langsmith',
+        package: 'langsmith',
+        envKey: 'LANGCHAIN_API_KEY',
+        description: 'LangSmith by LangChain',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.smith.langchain.com'
+    },
+    langwatch: {
+        name: 'langwatch',
+        package: 'langwatch',
+        envKey: 'LANGWATCH_API_KEY',
+        description: 'LangWatch monitoring',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.langwatch.ai'
+    },
+    arize: {
+        name: 'arize',
+        package: 'arize-phoenix',
+        envKey: 'ARIZE_API_KEY',
+        description: 'Arize AX (Phoenix)',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.arize.com'
+    },
+    axiom: {
+        name: 'axiom',
+        package: '@axiomhq/js',
+        envKey: 'AXIOM_TOKEN',
+        description: 'Axiom logging and analytics',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://axiom.co/docs'
+    },
+    braintrust: {
+        name: 'braintrust',
+        package: 'braintrust',
+        envKey: 'BRAINTRUST_API_KEY',
+        description: 'Braintrust AI evaluation',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://www.braintrust.dev/docs'
+    },
+    helicone: {
+        name: 'helicone',
+        package: '@helicone/helicone',
+        envKey: 'HELICONE_API_KEY',
+        description: 'Helicone observability proxy',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.helicone.ai'
+    },
+    laminar: {
+        name: 'laminar',
+        package: '@lmnr-ai/lmnr',
+        envKey: 'LMNR_PROJECT_API_KEY',
+        description: 'Laminar AI observability',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.lmnr.ai'
+    },
+    maxim: {
+        name: 'maxim',
+        package: '@maximai/maxim-js',
+        envKey: 'MAXIM_API_KEY',
+        description: 'Maxim AI testing',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.getmaxim.ai'
+    },
+    patronus: {
+        name: 'patronus',
+        package: 'patronus',
+        envKey: 'PATRONUS_API_KEY',
+        description: 'Patronus AI evaluation',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.patronus.ai'
+    },
+    scorecard: {
+        name: 'scorecard',
+        package: '@scorecard-ai/sdk',
+        envKey: 'SCORECARD_API_KEY',
+        description: 'Scorecard AI testing',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://docs.getscorecard.ai'
+    },
+    signoz: {
+        name: 'signoz',
+        package: '@opentelemetry/api',
+        envKey: 'SIGNOZ_ACCESS_TOKEN',
+        description: 'SigNoz OpenTelemetry',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://signoz.io/docs'
+    },
+    traceloop: {
+        name: 'traceloop',
+        package: '@traceloop/node-server-sdk',
+        envKey: 'TRACELOOP_API_KEY',
+        description: 'Traceloop OpenLLMetry',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://traceloop.com/docs'
+    },
+    weave: {
+        name: 'weave',
+        package: 'weave',
+        envKey: 'WANDB_API_KEY',
+        description: 'Weights & Biases Weave',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: true, export: true },
+        docsUrl: 'https://wandb.ai/site/weave'
+    },
+    console: {
+        name: 'console',
+        envKey: '',
+        description: 'Console logging (built-in)',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: false, export: false }
+    },
+    memory: {
+        name: 'memory',
+        envKey: '',
+        description: 'In-memory storage (built-in)',
+        features: { traces: true, spans: true, events: true, errors: true, metrics: false, export: false }
+    },
+    noop: {
+        name: 'noop',
+        envKey: '',
+        description: 'No-op adapter (disabled)',
+        features: { traces: false, spans: false, events: false, errors: false, metrics: false, export: false }
+    }
+};
+/**
+ * Get observability tool info
+ */
+function getObservabilityToolInfo(name) {
+    return exports.OBSERVABILITY_TOOLS[name];
+}
+/**
+ * List all observability tools
+ */
+function listObservabilityTools() {
+    return Object.values(exports.OBSERVABILITY_TOOLS);
+}
+/**
+ * Check if observability tool has required env var
+ */
+function hasObservabilityToolEnvVar(name) {
+    const info = exports.OBSERVABILITY_TOOLS[name];
+    if (!info || !info.envKey)
+        return true; // Built-in tools don't need env vars
+    return !!process.env[info.envKey];
+}

package/dist/planning/index.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Planning System - Plans, Steps, and TodoLists
+ */
+export type PlanStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+export interface PlanConfig {
+    name: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+export interface PlanStepConfig {
+    description: string;
+    status?: PlanStatus;
+    order?: number;
+    dependencies?: string[];
+    metadata?: Record<string, any>;
+}
+export interface TodoItemConfig {
+    content: string;
+    priority?: 'low' | 'medium' | 'high';
+    status?: TodoStatus;
+    dueDate?: Date;
+    metadata?: Record<string, any>;
+}
+/**
+ * PlanStep - A single step in a plan
+ */
+export declare class PlanStep {
+    readonly id: string;
+    description: string;
+    status: PlanStatus;
+    order: number;
+    dependencies: string[];
+    metadata: Record<string, any>;
+    startedAt?: number;
+    completedAt?: number;
+    constructor(config: PlanStepConfig);
+    start(): this;
+    complete(): this;
+    fail(): this;
+    cancel(): this;
+}
+/**
+ * Plan - A collection of steps to accomplish a goal
+ */
+export declare class Plan {
+    readonly id: string;
+    name: string;
+    description?: string;
+    steps: PlanStep[];
+    status: PlanStatus;
+    metadata: Record<string, any>;
+    createdAt: number;
+    updatedAt: number;
+    constructor(config: PlanConfig);
+    addStep(step: PlanStep): this;
+    removeStep(stepId: string): boolean;
+    getStep(stepId: string): PlanStep | undefined;
+    getNextStep(): PlanStep | undefined;
+    getProgress(): {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+    start(): this;
+    complete(): this;
+}
+/**
+ * TodoItem - A single todo item
+ */
+export declare class TodoItem {
+    readonly id: string;
+    content: string;
+    priority: 'low' | 'medium' | 'high';
+    status: TodoStatus;
+    dueDate?: Date;
+    metadata: Record<string, any>;
+    createdAt: number;
+    completedAt?: number;
+    constructor(config: TodoItemConfig);
+    start(): this;
+    complete(): this;
+    reset(): this;
+}
+/**
+ * TodoList - A collection of todo items
+ */
+export declare class TodoList {
+    readonly id: string;
+    name: string;
+    items: TodoItem[];
+    createdAt: number;
+    constructor(name?: string);
+    add(item: TodoItem): this;
+    remove(itemId: string): boolean;
+    get(itemId: string): TodoItem | undefined;
+    getPending(): TodoItem[];
+    getCompleted(): TodoItem[];
+    getByPriority(priority: 'low' | 'medium' | 'high'): TodoItem[];
+    getProgress(): {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+    clear(): this;
+}
+/**
+ * PlanStorage - Persist plans (in-memory implementation)
+ */
+export declare class PlanStorage {
+    private plans;
+    private todoLists;
+    savePlan(plan: Plan): void;
+    getPlan(planId: string): Plan | undefined;
+    deletePlan(planId: string): boolean;
+    listPlans(): Plan[];
+    saveTodoList(list: TodoList): void;
+    getTodoList(listId: string): TodoList | undefined;
+    deleteTodoList(listId: string): boolean;
+    listTodoLists(): TodoList[];
+}
+/**
+ * Create a Plan
+ */
+export declare function createPlan(config: PlanConfig): Plan;
+/**
+ * Create a TodoList
+ */
+export declare function createTodoList(name?: string): TodoList;
+/**
+ * Create a PlanStorage
+ */
+export declare function createPlanStorage(): PlanStorage;
+/**
+ * PlanningAgent - Agent with built-in planning capabilities
+ *
+ * @example Simple usage (4 lines)
+ * ```typescript
+ * import { PlanningAgent } from 'praisonai';
+ *
+ * const agent = new PlanningAgent({ instructions: 'You break down tasks into steps' });
+ * const result = await agent.planAndExecute('Build a web scraper');
+ * console.log(result.plan);  // The plan that was created
+ * console.log(result.results);  // Results from each step
+ * ```
+ */
+export interface PlanningAgentConfig {
+    instructions?: string;
+    name?: string;
+    llm?: string;
+    verbose?: boolean;
+    maxSteps?: number;
+}
+export interface PlanResult {
+    plan: Plan;
+    results: string[];
+    success: boolean;
+}
+export declare class PlanningAgent {
+    private config;
+    private agent;
+    private currentPlan;
+    constructor(config?: PlanningAgentConfig);
+    private getAgent;
+    /**
+     * Create a plan for a task
+     */
+    createPlan(task: string): Promise<Plan>;
+    /**
+     * Execute a single step
+     */
+    executeStep(step: PlanStep): Promise<string>;
+    /**
+     * Plan and execute a task in one call
+     */
+    planAndExecute(task: string): Promise<PlanResult>;
+    /**
+     * Get the current plan
+     */
+    getPlan(): Plan | null;
+    /**
+     * Simple chat (without planning)
+     */
+    chat(message: string): Promise<string>;
+}
+/**
+ * Create a planning agent
+ */
+export declare function createPlanningAgent(config?: PlanningAgentConfig): PlanningAgent;
+/**
+ * TaskAgent - Agent with built-in todo list management
+ *
+ * @example Simple usage (4 lines)
+ * ```typescript
+ * import { TaskAgent } from 'praisonai';
+ *
+ * const agent = new TaskAgent();
+ * await agent.addTask('Fix critical bug', 'high');
+ * await agent.addTask('Write docs', 'medium');
+ * console.log(agent.getPendingTasks());
+ * ```
+ */
+export declare class TaskAgent {
+    private todos;
+    private agent;
+    private config;
+    constructor(config?: {
+        name?: string;
+        llm?: string;
+        verbose?: boolean;
+    });
+    private getAgent;
+    /**
+     * Add a task
+     */
+    addTask(content: string, priority?: 'low' | 'medium' | 'high'): TodoItem;
+    /**
+     * Complete a task by content (partial match)
+     */
+    completeTask(contentMatch: string): boolean;
+    /**
+     * Get pending tasks
+     */
+    getPendingTasks(): TodoItem[];
+    /**
+     * Get all tasks
+     */
+    getAllTasks(): TodoItem[];
+    /**
+     * Get progress
+     */
+    getProgress(): {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+    /**
+     * Clear all tasks
+     */
+    clearTasks(): void;
+    /**
+     * Chat with AI about tasks
+     */
+    chat(message: string): Promise<string>;
+}
+/**
+ * Create a task agent
+ */
+export declare function createTaskAgent(config?: {
+    name?: string;
+    llm?: string;
+    verbose?: boolean;
+}): TaskAgent;