praisonai 1.0.18 → 1.1.0

package/dist/observability/index.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Observability - Tracing, logging, and metrics hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleObservabilityAdapter = exports.MemoryObservabilityAdapter = void 0;
+exports.setObservabilityAdapter = setObservabilityAdapter;
+exports.getObservabilityAdapter = getObservabilityAdapter;
+/**
+ * In-memory observability adapter for development
+ */
+class MemoryObservabilityAdapter {
+    constructor() {
+        this.traces = new Map();
+        this.spans = new Map();
+    }
+    startTrace(name, metadata = {}) {
+        const traceId = this.generateId();
+        const trace = {
+            id: traceId,
+            name,
+            startTime: Date.now(),
+            status: 'running',
+            spans: [],
+            metadata
+        };
+        this.traces.set(traceId, trace);
+        const self = this;
+        return {
+            traceId,
+            startSpan(spanName, kind) {
+                return self.startSpan(traceId, spanName, kind);
+            },
+            end(status = 'completed') {
+                self.endTrace(traceId, status);
+            }
+        };
+    }
+    endTrace(traceId, status = 'completed') {
+        const trace = this.traces.get(traceId);
+        if (trace) {
+            trace.endTime = Date.now();
+            trace.status = status;
+        }
+    }
+    startSpan(traceId, name, kind, parentId) {
+        const spanId = this.generateId();
+        const span = {
+            id: spanId,
+            traceId,
+            parentId,
+            name,
+            kind,
+            status: 'running',
+            startTime: Date.now(),
+            attributes: {},
+            events: []
+        };
+        this.spans.set(spanId, span);
+        const trace = this.traces.get(traceId);
+        if (trace) {
+            trace.spans.push(span);
+        }
+        const self = this;
+        return {
+            spanId,
+            traceId,
+            addEvent(eventName, attributes) {
+                self.addEvent(spanId, eventName, attributes);
+            },
+            setAttributes(attributes) {
+                const s = self.spans.get(spanId);
+                if (s) {
+                    s.attributes = { ...s.attributes, ...attributes };
+                }
+            },
+            end(status = 'completed') {
+                self.endSpan(spanId, status);
+            }
+        };
+    }
+    endSpan(spanId, status = 'completed', attributes) {
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.endTime = Date.now();
+            span.status = status;
+            if (attributes) {
+                span.attributes = { ...span.attributes, ...attributes };
+            }
+        }
+    }
+    addEvent(spanId, name, attributes) {
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.events.push({
+                name,
+                timestamp: Date.now(),
+                attributes
+            });
+        }
+    }
+    async flush() {
+        // No-op for memory adapter
+    }
+    // Utility methods
+    getTrace(traceId) {
+        return this.traces.get(traceId);
+    }
+    getSpan(spanId) {
+        return this.spans.get(spanId);
+    }
+    getAllTraces() {
+        return Array.from(this.traces.values());
+    }
+    clear() {
+        this.traces.clear();
+        this.spans.clear();
+    }
+    generateId() {
+        return Math.random().toString(36).substring(2, 15);
+    }
+}
+exports.MemoryObservabilityAdapter = MemoryObservabilityAdapter;
+/**
+ * Console observability adapter for debugging
+ */
+class ConsoleObservabilityAdapter {
+    constructor() {
+        this.memory = new MemoryObservabilityAdapter();
+    }
+    startTrace(name, metadata) {
+        console.log(`[TRACE START] ${name}`, metadata || '');
+        return this.memory.startTrace(name, metadata);
+    }
+    endTrace(traceId, status) {
+        console.log(`[TRACE END] ${traceId} - ${status || 'completed'}`);
+        this.memory.endTrace(traceId, status);
+    }
+    startSpan(traceId, name, kind, parentId) {
+        console.log(`  [SPAN START] ${name} (${kind})`);
+        return this.memory.startSpan(traceId, name, kind, parentId);
+    }
+    endSpan(spanId, status, attributes) {
+        console.log(`  [SPAN END] ${spanId} - ${status || 'completed'}`, attributes || '');
+        this.memory.endSpan(spanId, status, attributes);
+    }
+    addEvent(spanId, name, attributes) {
+        console.log(`    [EVENT] ${name}`, attributes || '');
+        this.memory.addEvent(spanId, name, attributes);
+    }
+    async flush() {
+        await this.memory.flush();
+    }
+}
+exports.ConsoleObservabilityAdapter = ConsoleObservabilityAdapter;
+// Global observability instance
+let globalAdapter = null;
+function setObservabilityAdapter(adapter) {
+    globalAdapter = adapter;
+}
+function getObservabilityAdapter() {
+    if (!globalAdapter) {
+        globalAdapter = new MemoryObservabilityAdapter();
+    }
+    return globalAdapter;
+}

package/dist/session/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Session Management - Session, Run, and Trace tracking
+ */
+export interface SessionConfig {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export interface RunConfig {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export interface TraceConfig {
+    id?: string;
+    name: string;
+    attributes?: Record<string, any>;
+}
+export type RunStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type TraceStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface Message {
+    id: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: any[];
+    timestamp: number;
+    runId?: string;
+}
+/**
+ * Trace represents a span within a run (e.g., LLM call, tool call)
+ */
+export declare class Trace {
+    readonly id: string;
+    readonly runId: string;
+    readonly name: string;
+    readonly parentId: string | null;
+    readonly startTime: number;
+    endTime: number | null;
+    status: TraceStatus;
+    attributes: Record<string, any>;
+    private children;
+    constructor(runId: string, config: TraceConfig, parentId?: string | null);
+    start(): this;
+    complete(attributes?: Record<string, any>): this;
+    fail(error?: Error): this;
+    get duration(): number | null;
+    createChild(config: TraceConfig): Trace;
+    getChildren(): Trace[];
+    toJSON(): Record<string, any>;
+}
+/**
+ * Run represents a single execution within a session (e.g., one chat call)
+ */
+export declare class Run {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly startTime: number;
+    endTime: number | null;
+    status: RunStatus;
+    error: Error | null;
+    metadata: Record<string, any>;
+    private traces;
+    private messages;
+    constructor(sessionId: string, config?: RunConfig);
+    start(): this;
+    complete(metadata?: Record<string, any>): this;
+    fail(error: Error): this;
+    get duration(): number | null;
+    createTrace(config: TraceConfig): Trace;
+    addMessage(message: Omit<Message, 'id' | 'timestamp' | 'runId'>): Message;
+    getTraces(): Trace[];
+    getMessages(): Message[];
+    toJSON(): Record<string, any>;
+}
+/**
+ * Session represents a conversation session with message history
+ */
+export declare class Session {
+    readonly id: string;
+    readonly createdAt: number;
+    metadata: Record<string, any>;
+    private _runs;
+    private _messages;
+    constructor(config?: SessionConfig);
+    createRun(config?: RunConfig): Run;
+    get runs(): Run[];
+    get messages(): Message[];
+    addMessage(message: Omit<Message, 'id' | 'timestamp'>): Message;
+    getMessagesForLLM(): Array<{
+        role: string;
+        content: string | null;
+        tool_call_id?: string;
+        tool_calls?: any[];
+    }>;
+    clearMessages(): void;
+    toJSON(): Record<string, any>;
+}
+/**
+ * SessionManager for managing multiple sessions
+ */
+export declare class SessionManager {
+    private sessions;
+    create(config?: SessionConfig): Session;
+    get(id: string): Session | undefined;
+    getOrCreate(id: string, config?: Omit<SessionConfig, 'id'>): Session;
+    list(): Session[];
+    delete(id: string): boolean;
+    clear(): void;
+    toJSON(): Record<string, any>;
+}
+export declare function getSessionManager(): SessionManager;

package/dist/session/index.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * Session Management - Session, Run, and Trace tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.Session = exports.Run = exports.Trace = void 0;
+exports.getSessionManager = getSessionManager;
+const crypto_1 = require("crypto");
+/**
+ * Trace represents a span within a run (e.g., LLM call, tool call)
+ */
+class Trace {
+    constructor(runId, config, parentId = null) {
+        this.endTime = null;
+        this.status = 'pending';
+        this.children = [];
+        this.id = config.id || (0, crypto_1.randomUUID)();
+        this.runId = runId;
+        this.name = config.name;
+        this.parentId = parentId;
+        this.startTime = Date.now();
+        this.attributes = config.attributes || {};
+    }
+    start() {
+        this.status = 'running';
+        return this;
+    }
+    complete(attributes) {
+        this.status = 'completed';
+        this.endTime = Date.now();
+        if (attributes) {
+            this.attributes = { ...this.attributes, ...attributes };
+        }
+        return this;
+    }
+    fail(error) {
+        this.status = 'failed';
+        this.endTime = Date.now();
+        if (error) {
+            this.attributes.error = error.message;
+            this.attributes.errorStack = error.stack;
+        }
+        return this;
+    }
+    get duration() {
+        if (this.endTime === null)
+            return null;
+        return this.endTime - this.startTime;
+    }
+    createChild(config) {
+        const child = new Trace(this.runId, config, this.id);
+        this.children.push(child);
+        return child;
+    }
+    getChildren() {
+        return [...this.children];
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            runId: this.runId,
+            name: this.name,
+            parentId: this.parentId,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            duration: this.duration,
+            status: this.status,
+            attributes: this.attributes,
+            children: this.children.map(c => c.toJSON()),
+        };
+    }
+}
+exports.Trace = Trace;
+/**
+ * Run represents a single execution within a session (e.g., one chat call)
+ */
+class Run {
+    constructor(sessionId, config = {}) {
+        this.endTime = null;
+        this.status = 'pending';
+        this.error = null;
+        this.traces = [];
+        this.messages = [];
+        this.id = config.id || (0, crypto_1.randomUUID)();
+        this.sessionId = sessionId;
+        this.startTime = Date.now();
+        this.metadata = config.metadata || {};
+    }
+    start() {
+        this.status = 'running';
+        return this;
+    }
+    complete(metadata) {
+        this.status = 'completed';
+        this.endTime = Date.now();
+        if (metadata) {
+            this.metadata = { ...this.metadata, ...metadata };
+        }
+        return this;
+    }
+    fail(error) {
+        this.status = 'failed';
+        this.endTime = Date.now();
+        this.error = error;
+        return this;
+    }
+    get duration() {
+        if (this.endTime === null)
+            return null;
+        return this.endTime - this.startTime;
+    }
+    createTrace(config) {
+        const trace = new Trace(this.id, config);
+        this.traces.push(trace);
+        return trace;
+    }
+    addMessage(message) {
+        const msg = {
+            ...message,
+            id: (0, crypto_1.randomUUID)(),
+            timestamp: Date.now(),
+            runId: this.id,
+        };
+        this.messages.push(msg);
+        return msg;
+    }
+    getTraces() {
+        return [...this.traces];
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            sessionId: this.sessionId,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            duration: this.duration,
+            status: this.status,
+            error: this.error?.message,
+            metadata: this.metadata,
+            traces: this.traces.map(t => t.toJSON()),
+            messageCount: this.messages.length,
+        };
+    }
+}
+exports.Run = Run;
+/**
+ * Session represents a conversation session with message history
+ */
+class Session {
+    constructor(config = {}) {
+        this._runs = [];
+        this._messages = [];
+        this.id = config.id || (0, crypto_1.randomUUID)();
+        this.createdAt = Date.now();
+        this.metadata = config.metadata || {};
+    }
+    createRun(config = {}) {
+        const run = new Run(this.id, config);
+        this._runs.push(run);
+        return run;
+    }
+    get runs() {
+        return [...this._runs];
+    }
+    get messages() {
+        return [...this._messages];
+    }
+    addMessage(message) {
+        const msg = {
+            ...message,
+            id: (0, crypto_1.randomUUID)(),
+            timestamp: Date.now(),
+        };
+        this._messages.push(msg);
+        return msg;
+    }
+    getMessagesForLLM() {
+        return this._messages.map(m => ({
+            role: m.role,
+            content: m.content,
+            ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
+            ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+        }));
+    }
+    clearMessages() {
+        this._messages = [];
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            createdAt: this.createdAt,
+            metadata: this.metadata,
+            runCount: this._runs.length,
+            messageCount: this._messages.length,
+            runs: this._runs.map(r => r.toJSON()),
+        };
+    }
+}
+exports.Session = Session;
+/**
+ * SessionManager for managing multiple sessions
+ */
+class SessionManager {
+    constructor() {
+        this.sessions = new Map();
+    }
+    create(config = {}) {
+        const session = new Session(config);
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    get(id) {
+        return this.sessions.get(id);
+    }
+    getOrCreate(id, config = {}) {
+        let session = this.sessions.get(id);
+        if (!session) {
+            session = new Session({ ...config, id });
+            this.sessions.set(id, session);
+        }
+        return session;
+    }
+    list() {
+        return Array.from(this.sessions.values());
+    }
+    delete(id) {
+        return this.sessions.delete(id);
+    }
+    clear() {
+        this.sessions.clear();
+    }
+    toJSON() {
+        return {
+            sessionCount: this.sessions.size,
+            sessions: this.list().map(s => s.toJSON()),
+        };
+    }
+}
+exports.SessionManager = SessionManager;
+// Default session manager instance
+let defaultManager = null;
+function getSessionManager() {
+    if (!defaultManager) {
+        defaultManager = new SessionManager();
+    }
+    return defaultManager;
+}

package/dist/skills/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Skills System - Agent Skills standard implementation
+ */
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    allowedTools?: string[];
+    metadata?: Record<string, string>;
+}
+export interface Skill {
+    metadata: SkillMetadata;
+    instructions: string;
+    path?: string;
+}
+export interface SkillDiscoveryOptions {
+    paths?: string[];
+    includeSystem?: boolean;
+    includeUser?: boolean;
+    includeProject?: boolean;
+}
+/**
+ * Parse SKILL.md file
+ */
+export declare function parseSkillFile(content: string): Skill;
+/**
+ * Skill Manager - Load and manage skills
+ */
+export declare class SkillManager {
+    private skills;
+    private discoveryPaths;
+    constructor(options?: SkillDiscoveryOptions);
+    private setupDiscoveryPaths;
+    /**
+     * Discover and load skills from configured paths
+     */
+    discover(): Promise<Skill[]>;
+    /**
+     * Load a skill from a SKILL.md file
+     */
+    loadSkill(skillPath: string): Promise<Skill>;
+    /**
+     * Register a skill manually
+     */
+    register(skill: Skill): void;
+    /**
+     * Get a skill by name
+     */
+    get(name: string): Skill | undefined;
+    /**
+     * List all loaded skills
+     */
+    list(): Skill[];
+    /**
+     * Generate XML prompt for skills
+     */
+    generatePrompt(skillNames?: string[]): string;
+    /**
+     * Validate a skill
+     */
+    validate(skill: Skill): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * Create a skill manager
+ */
+export declare function createSkillManager(options?: SkillDiscoveryOptions): SkillManager;