@ai.ntellect/core 0.0.25 → 0.0.26

package/dist/agent/handlers/ActionHandler.d.ts

@@ -0,0 +1,8 @@
+import { ActionSchema, ProcessPromptCallbacks, QueueItem, QueueResult } from "../../types";
+export declare class ActionHandler {
+    executeActions(predefinedActions: QueueItem[], tools: ActionSchema[], callbacks?: ProcessPromptCallbacks): Promise<{
+        type: string;
+        data: QueueResult[];
+    }>;
+    hasNonPrepareActions(actions: QueueResult[]): boolean;
+}

package/dist/agent/handlers/ActionHandler.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionHandler = void 0;
+const queue_1 = require("../../services/queue");
+class ActionHandler {
+    async executeActions(predefinedActions, tools, callbacks) {
+        try {
+            const queueManager = new queue_1.ActionQueueManager(tools, {
+                onActionStart: callbacks?.onActionStart,
+                onActionComplete: callbacks?.onActionComplete,
+                onQueueComplete: callbacks?.onQueueComplete,
+                onConfirmationRequired: async (message) => {
+                    if (callbacks?.onConfirmationRequired) {
+                        return await callbacks.onConfirmationRequired(message);
+                    }
+                    return false;
+                },
+            });
+            queueManager.addToQueue(predefinedActions);
+            if (callbacks?.onQueueStart) {
+                callbacks.onQueueStart(predefinedActions);
+            }
+            const results = await queueManager.processQueue();
+            return { type: "success", data: results || [] };
+        }
+        catch (error) {
+            console.error("Error processing prompt:", error);
+            throw error;
+        }
+    }
+    hasNonPrepareActions(actions) {
+        return (Array.isArray(actions) &&
+            actions.some((action) => action.name?.split("-")[0] !== "prepare"));
+    }
+}
+exports.ActionHandler = ActionHandler;

package/dist/agent/handlers/ConfirmationHandler.d.ts

@@ -0,0 +1,7 @@
+import EventEmitter from "events";
+export declare class ConfirmationHandler {
+    private readonly eventEmitter;
+    private readonly CONFIRMATION_TIMEOUT;
+    constructor(eventEmitter: EventEmitter);
+    handleConfirmationRequest(message: string): Promise<boolean>;
+}

package/dist/agent/handlers/ConfirmationHandler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationHandler = void 0;
+class ConfirmationHandler {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+        this.CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+    }
+    async handleConfirmationRequest(message) {
+        return new Promise((resolve) => {
+            const confirmationId = Date.now().toString();
+            const handleConfirmation = (data) => {
+                if (data.confirmationId === confirmationId) {
+                    this.eventEmitter.removeListener("confirmation-response", handleConfirmation);
+                    resolve(data.confirmed);
+                }
+            };
+            this.eventEmitter.once("confirmation-response", handleConfirmation);
+            this.eventEmitter.emit("orchestrator-update", {
+                type: "confirmation-required",
+                id: confirmationId,
+                message,
+            });
+            setTimeout(() => {
+                this.eventEmitter.removeListener("confirmation-response", handleConfirmation);
+                resolve(false);
+            }, this.CONFIRMATION_TIMEOUT);
+        });
+    }
+}
+exports.ConfirmationHandler = ConfirmationHandler;

package/dist/agent/handlers/EventHandler.d.ts

@@ -0,0 +1,10 @@
+import EventEmitter from "events";
+import { IEventHandler, QueueItem, QueueResult } from "../../types";
+export declare class EventHandler implements IEventHandler {
+    private readonly eventEmitter;
+    constructor(eventEmitter: EventEmitter);
+    emitQueueStart(actions: QueueItem[]): void;
+    emitActionStart(action: QueueItem): void;
+    emitActionComplete(action: QueueResult): void;
+    emitQueueComplete(): void;
+}

package/dist/agent/handlers/EventHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+class EventHandler {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    emitQueueStart(actions) {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "queue-start",
+            actions,
+        });
+    }
+    emitActionStart(action) {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "action-start",
+            action: action.name,
+            args: action.parameters,
+        });
+    }
+    emitActionComplete(action) {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "action-complete",
+            action: action.name,
+            result: action.result,
+        });
+    }
+    emitQueueComplete() {
+        this.eventEmitter.emit("orchestrator-update", {
+            type: "queue-complete",
+        });
+    }
+}
+exports.EventHandler = EventHandler;

package/dist/agent/index.d.ts

@@ -0,0 +1,22 @@
+import EventEmitter from "events";
+import { Orchestrator } from "../llm/orchestrator";
+import { MemoryCache } from "../memory";
+import { AgentEvent, User } from "../types";
+export declare class Agent {
+    private readonly user;
+    private readonly dependencies;
+    private readonly stream;
+    private readonly SIMILARITY_THRESHOLD;
+    private readonly MAX_RESULTS;
+    private readonly actionHandler;
+    constructor(user: User, dependencies: {
+        orchestrator: Orchestrator;
+        memoryCache: MemoryCache;
+        eventEmitter: EventEmitter;
+    }, stream?: boolean);
+    start(prompt: string, contextualizedPrompt: string, events: AgentEvent): Promise<any>;
+    private handleActions;
+    private findSimilarActions;
+    private transformActions;
+    private handleActionResults;
+}

package/dist/agent/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const synthesizer_1 = require("../llm/synthesizer");
+const types_1 = require("../types");
+const queue_item_transformer_1 = require("../utils/queue-item-transformer");
+const ActionHandler_1 = require("./handlers/ActionHandler");
+class Agent {
+    constructor(user, dependencies, stream = true) {
+        this.user = user;
+        this.dependencies = dependencies;
+        this.stream = stream;
+        this.SIMILARITY_THRESHOLD = 95;
+        this.MAX_RESULTS = 1;
+        this.actionHandler = new ActionHandler_1.ActionHandler();
+    }
+    async start(prompt, contextualizedPrompt, events) {
+        const request = await this.dependencies.orchestrator.process(contextualizedPrompt);
+        events.onMessage?.(request);
+        if (request.actions.length > 0) {
+            return this.handleActions({
+                initialPrompt: prompt,
+                actions: request.actions,
+            }, events);
+        }
+    }
+    async handleActions({ initialPrompt, actions, }, events) {
+        const similarActions = await this.findSimilarActions(initialPrompt);
+        const predefinedActions = this.transformActions(actions, similarActions);
+        const callbacks = {
+            onQueueStart: events.onQueueStart,
+            onActionStart: events.onActionStart,
+            onActionComplete: events.onActionComplete,
+            onQueueComplete: events.onQueueComplete,
+            onConfirmationRequired: events.onConfirmationRequired,
+        };
+        const actionsResult = await this.actionHandler.executeActions(predefinedActions, this.dependencies.orchestrator.tools, callbacks);
+        if (!this.actionHandler.hasNonPrepareActions(actionsResult.data)) {
+            return {
+                data: actionsResult.data,
+                initialPrompt,
+            };
+        }
+        return this.handleActionResults({ ...actionsResult, initialPrompt });
+    }
+    async findSimilarActions(prompt) {
+        return this.dependencies.memoryCache.findBestMatches(prompt, {
+            similarityThreshold: this.SIMILARITY_THRESHOLD,
+            maxResults: this.MAX_RESULTS,
+            userId: this.user.id,
+            scope: types_1.MemoryScope.USER,
+        });
+    }
+    transformActions(actions, similarActions) {
+        let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];
+        if (similarActions?.length > 0) {
+            predefinedActions =
+                queue_item_transformer_1.QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
+        }
+        return predefinedActions;
+    }
+    async handleActionResults(actionsResult) {
+        const summarizer = new synthesizer_1.Summarizer();
+        const summaryData = JSON.stringify({
+            result: actionsResult.data,
+            initialPrompt: actionsResult.initialPrompt,
+        });
+        return this.stream
+            ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
+            : await summarizer.process(summaryData);
+    }
+}
+exports.Agent = Agent;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./agent";
+export * from "./llm/orchestrator";
+export * from "./llm/synthesizer";
+export * from "./services/queue";
+export * from "./types";
+export * from "./memory";

package/dist/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./agent"), exports);
+__exportStar(require("./llm/orchestrator"), exports);
+__exportStar(require("./llm/synthesizer"), exports);
+__exportStar(require("./services/queue"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./memory"), exports);

package/dist/llm/synthesizer/context.d.ts

@@ -0,0 +1,10 @@
+export declare const summarizerContext: {
+    role: string;
+    guidelines: {
+        important: string[];
+        forMarketAnalysis: string[];
+        forGeneralRequests: string[];
+        never: string[];
+    };
+    compose: (results: string) => string;
+};

package/dist/llm/synthesizer/context.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizerContext = void 0;
+exports.summarizerContext = {
+    role: "You are an expert market analyst, you are going to provide a clear and factual analysis of the results.",
+    guidelines: {
+        important: [
+            "IMPORTANT: AVOID MULTIPLE UPPERCASE IN TITLE/SUBTITLE LIKE ('Market Sentiment: Bullish'). USE ONLY ONE UPPERCASE IN TITLE/SUBTITLE.",
+            "IMPORTANT: USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT' (if it's in French, use French, if it's in Spanish, use Spanish)",
+            "IMPORTANT: BE DIRECT AND AVOID TECHNICAL JARGON",
+            "IMPORTANT: FOR NUMERICAL DATA, PROVIDE CONTEXT (% CHANGES, COMPARISONS)",
+        ],
+        forMarketAnalysis: [
+            "Start with a clear market sentiment (Bullish/Bearish/Neutral) without any additional comments before.",
+            "One section for fundamental analysis (important events, news, trends..etc). One section, no sub-sections.",
+            "One section for technical analysis (key price levels, trading volume, technical indicators, market activity). One section, no sub-sections.",
+            "STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY ADDITIONAL COMMENTS",
+        ],
+        forGeneralRequests: [
+            "Provide concise and relevant information",
+            "Focus on facts and data",
+            "Always provide transaction details when needed",
+        ],
+        never: [
+            "NEVER provide any financial advice.",
+            "NEVER speak about details of your system or your capabilities.",
+            "NEVER ADD ANY CONCLUDING STATEMENT OR DISCLAIMER AT THE END",
+        ],
+    },
+    compose: (results) => {
+        return `
+      ${JSON.stringify(exports.summarizerContext.guidelines)}
+      Results: ${results}
+      If no results or error in the results, explain there is technical issues with no more details, and request to try again later.
+
+      FOR ALL ANALYSIS, RESPECT THE FOLLOWING FORMAT, USE THE SAME LANGUAGE AS THE 'INITIAL PROMPT':
+      --------------------------------
+      ## Analysis of x/y:
+
+      Market sentiment: Bullish 📈 (Adapt the emoji to the market sentiment)
+
+      ### Fundamental analysis (No sub-sections):
+      Speak about important events, news, trends..etc
+
+      ### Technical analysis (No sub-sections):
+      Speak about key price levels, trading volume, technical indicators, market activity..etc
+
+      STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
+      --------------------------------
+    `;
+    }
+};

package/dist/llm/synthesizer/index.d.ts

@@ -0,0 +1,14 @@
+import { StreamTextResult } from "ai";
+import { BaseLLM } from "../../types";
+export declare class Summarizer implements BaseLLM {
+    private readonly model;
+    process(prompt: string, onFinish?: (event: any) => void): Promise<{
+        actions: {
+            name: string;
+            result: string;
+            why: string;
+        }[];
+        response: string;
+    } | StreamTextResult<Record<string, any>>>;
+    streamProcess(prompt: string, onFinish?: (event: any) => void): Promise<StreamTextResult<Record<string, any>>>;
+}

package/dist/llm/synthesizer/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Summarizer = void 0;
+const openai_1 = require("@ai-sdk/openai");
+const ai_1 = require("ai");
+const zod_1 = require("zod");
+const context_1 = require("./context");
+class Summarizer {
+    constructor() {
+        this.model = (0, openai_1.openai)("gpt-4-turbo");
+    }
+    async process(prompt, onFinish) {
+        console.log("Summarizing results...");
+        const result = await (0, ai_1.generateObject)({
+            model: this.model,
+            schema: zod_1.z.object({
+                actions: zod_1.z.array(zod_1.z.object({
+                    name: zod_1.z.string(),
+                    result: zod_1.z.string(),
+                    why: zod_1.z.string(),
+                })),
+                response: zod_1.z.string(),
+            }),
+            prompt: context_1.summarizerContext.compose(prompt),
+            system: context_1.summarizerContext.role,
+        });
+        console.log("Summarized results:", result.object);
+        if (onFinish)
+            onFinish(result.object);
+        return result.object;
+    }
+    async streamProcess(prompt, onFinish) {
+        const result = await (0, ai_1.streamText)({
+            model: this.model,
+            prompt: context_1.summarizerContext.compose(prompt),
+            onFinish: onFinish,
+            system: context_1.summarizerContext.role,
+        });
+        return result;
+    }
+}
+exports.Summarizer = Summarizer;

package/dist/memory/index.d.ts

@@ -0,0 +1,21 @@
+import { CreateMemoryInput, MatchOptions, MemoryCacheOptions, MemoryScope } from "../types";
+export declare class MemoryCache {
+    private redis;
+    private readonly CACHE_PREFIX;
+    private readonly CACHE_TTL;
+    constructor(options?: MemoryCacheOptions);
+    private initRedis;
+    private getMemoryKey;
+    private storeMemory;
+    findBestMatches(query: string, options?: MatchOptions & {
+        userId?: string;
+        scope?: MemoryScope;
+    }): Promise<{
+        data: any;
+        similarityPercentage: number;
+        purpose: string;
+    }[]>;
+    private getAllMemories;
+    private getMemoriesFromKeys;
+    createMemory(input: CreateMemoryInput): Promise<string | undefined>;
+}

package/dist/memory/index.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCache = void 0;
+const openai_1 = require("@ai-sdk/openai");
+const ai_1 = require("ai");
+const redis_1 = require("redis");
+const zod_1 = require("zod");
+const types_1 = require("../types");
+class MemoryCache {
+    constructor(options = {}) {
+        const ttlInHours = options.cacheTTL ?? 1;
+        this.CACHE_TTL = ttlInHours * 60 * 60;
+        this.CACHE_PREFIX = options.cachePrefix ?? 'memory:';
+        this.redis = (0, redis_1.createClient)({
+            url: options.redisUrl || process.env.REDIS_URL,
+            socket: {
+                tls: true,
+                rejectUnauthorized: true
+            }
+        });
+        this.initRedis();
+    }
+    async initRedis() {
+        this.redis.on('error', err => {
+            console.error('Redis Client Error:', err);
+            // Implement retry logic if needed
+        });
+        try {
+            await this.redis.connect();
+            console.log('Successfully connected to Redis');
+        }
+        catch (error) {
+            console.error('Failed to connect to Redis:', error);
+            // Handle connection failure
+        }
+    }
+    getMemoryKey(scope, userId) {
+        if (scope === types_1.MemoryScope.GLOBAL) {
+            return `${this.CACHE_PREFIX}global:`;
+        }
+        return `${this.CACHE_PREFIX}user:${userId}:`;
+    }
+    async storeMemory(memory) {
+        const prefix = this.getMemoryKey(memory.scope, memory.userId);
+        const key = `${prefix}${memory.id}`;
+        await this.redis.set(key, JSON.stringify(memory), {
+            EX: this.CACHE_TTL
+        });
+    }
+    async findBestMatches(query, options = {}) {
+        console.log("\n🔍 Searching for query:", query);
+        const { embedding } = await (0, ai_1.embed)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            value: query
+        });
+        const memories = await this.getAllMemories(options.scope, options.userId);
+        console.log("\n📚 Found", memories.length, "memories to compare with");
+        const matches = memories
+            .map(memory => {
+            const similarities = memory.embeddings.map(emb => {
+                const similarity = (0, ai_1.cosineSimilarity)(embedding, emb);
+                return (similarity + 1) * 50; // Convert to percentage
+            });
+            const maxSimilarity = Math.max(...similarities);
+            console.log(`\n📊 Memory "${memory.purpose}":
+          - Similarity: ${maxSimilarity.toFixed(2)}%
+          - Original queries: ${memory.queries.join(", ")}`);
+            return {
+                data: memory.data,
+                similarityPercentage: maxSimilarity,
+                purpose: memory.purpose,
+            };
+        })
+            .filter(match => match.similarityPercentage >= (options.similarityThreshold ?? 70))
+            .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
+        const results = options.maxResults ? matches.slice(0, options.maxResults) : matches;
+        if (results.length > 0) {
+            console.log("\n✨ Best matches found:");
+            results.forEach(match => {
+                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+            });
+        }
+        else {
+            console.log("No matches found");
+        }
+        console.dir({ results });
+        return results;
+    }
+    async getAllMemories(scope, userId) {
+        let patterns = [];
+        if (!scope || scope === types_1.MemoryScope.GLOBAL) {
+            const globalPrefix = this.getMemoryKey(types_1.MemoryScope.GLOBAL);
+            const globalKeys = await this.redis.keys(`${globalPrefix}*`);
+            const globalPatterns = await this.getMemoriesFromKeys(globalKeys);
+            patterns = patterns.concat(globalPatterns);
+        }
+        if (userId && (!scope || scope === types_1.MemoryScope.USER)) {
+            const userPrefix = this.getMemoryKey(types_1.MemoryScope.USER, userId);
+            const userKeys = await this.redis.keys(`${userPrefix}*`);
+            const userPatterns = await this.getMemoriesFromKeys(userKeys);
+            patterns = patterns.concat(userPatterns);
+        }
+        return patterns;
+    }
+    async getMemoriesFromKeys(keys) {
+        const memories = [];
+        for (const key of keys) {
+            const data = await this.redis.get(key);
+            if (data) {
+                memories.push(JSON.parse(data));
+            }
+        }
+        return memories;
+    }
+    async createMemory(input) {
+        const { embedding } = await (0, ai_1.embed)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            value: input.content
+        });
+        const existingPattern = await this.findBestMatches(input.content, {
+            similarityThreshold: 95,
+            userId: input.userId,
+            scope: input.scope
+        });
+        if (existingPattern.length > 0) {
+            console.log("\n🔍 Similar memory found:");
+            // Display only the name and similarity percentage
+            existingPattern.forEach(match => {
+                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+            });
+            return;
+        }
+        const variations = await (0, ai_1.generateObject)({
+            model: (0, openai_1.openai)("gpt-4"),
+            schema: zod_1.z.object({
+                request: zod_1.z.string().describe("The request to be performed"),
+                queries: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string()
+                }))
+            }),
+            prompt: `For this input: "${input.content}"
+        Generate similar variations that should match the same context.
+        Context type: ${input.type}
+        Data: ${JSON.stringify(input.data)}
+        - Keep variations natural and human-like
+        - Include the original input
+        - Add 3-5 variations`
+        });
+        const embeddingResults = await (0, ai_1.embedMany)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            values: variations.object.queries.map(q => q.text)
+        });
+        const memory = {
+            id: crypto.randomUUID(),
+            type: input.type,
+            data: input.data,
+            purpose: variations.object.request,
+            queries: [input.content, ...variations.object.queries.map(q => q.text)],
+            embeddings: [embedding, ...embeddingResults.embeddings],
+            userId: input.userId,
+            scope: input.scope || (input.userId ? types_1.MemoryScope.USER : types_1.MemoryScope.GLOBAL),
+            createdAt: new Date()
+        };
+        await this.storeMemory(memory);
+        return variations.object.request;
+    }
+}
+exports.MemoryCache = MemoryCache;

package/dist/services/queue.d.ts

@@ -0,0 +1,13 @@
+import { ActionSchema, QueueCallbacks, QueueItem, QueueResult } from "../types";
+export declare class ActionQueueManager {
+    private queue;
+    private results;
+    private callbacks;
+    private actions;
+    private isProcessing;
+    constructor(actions: ActionSchema[], callbacks?: QueueCallbacks);
+    addToQueue(actions: QueueItem | QueueItem[]): void;
+    processQueue(): Promise<QueueResult[] | undefined>;
+    private formatArguments;
+    private executeAction;
+}

package/dist/services/queue.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionQueueManager = void 0;
+class ActionQueueManager {
+    constructor(actions, callbacks = {}) {
+        this.queue = [];
+        this.results = [];
+        this.isProcessing = false;
+        this.actions = actions;
+        this.callbacks = callbacks;
+    }
+    addToQueue(actions) {
+        if (Array.isArray(actions)) {
+            console.log("Adding actions to queue:", actions.map((a) => a.name).join(", "));
+            this.queue.push(...actions);
+        }
+        else {
+            console.log("Adding action to queue:", actions.name);
+            this.queue.push(actions);
+        }
+    }
+    async processQueue() {
+        if (this.isProcessing) {
+            console.warn("Queue is already being processed");
+            return;
+        }
+        this.isProcessing = true;
+        const actionPromises = [];
+        for (const action of this.queue) {
+            const actionConfig = this.actions.find((a) => a.name === action.name);
+            if (actionConfig?.confirmation?.requireConfirmation) {
+                // Wait for user confirmation before executing this action
+                const shouldProceed = await this.callbacks.onConfirmationRequired?.(actionConfig.confirmation.message ||
+                    `Do you want to proceed with action: ${action.name}?`);
+                if (!shouldProceed) {
+                    // Skip this action and add a cancelled result
+                    this.results.push({
+                        name: action.name,
+                        parameters: this.formatArguments(action.parameters),
+                        result: null,
+                        error: "Action cancelled by user",
+                        cancelled: true,
+                    });
+                    continue;
+                }
+            }
+            actionPromises.push(this.executeAction(action)
+                .then((result) => {
+                this.callbacks.onActionComplete?.(result);
+                return result;
+            })
+                .catch((error) => {
+                const result = {
+                    name: action.name,
+                    parameters: this.formatArguments(action.parameters),
+                    result: null,
+                    error: error.message || "Unknown error occurred",
+                };
+                this.callbacks.onActionComplete?.(result);
+                return result;
+            }));
+        }
+        try {
+            const results = await Promise.all(actionPromises);
+            this.results.push(...results);
+            this.queue = [];
+            this.callbacks.onQueueComplete?.(this.results);
+            this.isProcessing = false;
+            return this.results;
+        }
+        catch (error) {
+            this.isProcessing = false;
+            console.error("Unexpected error in queue processing:", error);
+            throw error;
+        }
+    }
+    formatArguments(args) {
+        return args.reduce((acc, arg) => {
+            acc[arg.name] = arg.value;
+            return acc;
+        }, {});
+    }
+    async executeAction(action) {
+        // Call onActionStart callback
+        this.callbacks.onActionStart?.(action);
+        const actionConfig = this.actions.find((a) => a.name === action.name);
+        if (!actionConfig) {
+            return {
+                name: action.name,
+                parameters: {},
+                result: null,
+                error: `Action '${action.name}' not found in actions list`,
+            };
+        }
+        const actionArgs = action.parameters.reduce((acc, arg) => {
+            acc[arg.name] = arg.value;
+            return acc;
+        }, {});
+        try {
+            const result = await actionConfig.execute(actionArgs);
+            const actionResult = {
+                name: action.name,
+                parameters: actionArgs,
+                result,
+                error: null,
+            };
+            console.log("Action executed successfully: ", action.name);
+            console.dir(actionResult, { depth: null });
+            return actionResult;
+        }
+        catch (error) {
+            const actionResult = {
+                name: action.name,
+                parameters: actionArgs,
+                result: null,
+                error: error.message || "Unknown error occurred",
+            };
+            console.log("Action failed: ", action.name);
+            console.dir(actionResult, { depth: null });
+            return actionResult;
+        }
+    }
+}
+exports.ActionQueueManager = ActionQueueManager;

package/dist/utils/queue-item-transformer.d.ts

@@ -0,0 +1,7 @@
+import { ActionData, TransformedQueueItem } from "../types";
+export declare class QueueItemTransformer {
+    static transformActionToQueueItem(action: ActionData): TransformedQueueItem;
+    static transformFromSimilarActions(similarActions: any[]): TransformedQueueItem[] | undefined;
+    private static transformParameters;
+    static transformActionsToQueueItems(actions: ActionData[] | undefined): TransformedQueueItem[] | undefined;
+}

package/dist/utils/queue-item-transformer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueItemTransformer = void 0;
+class QueueItemTransformer {
+    static transformActionToQueueItem(action) {
+        return {
+            name: action.name || '',
+            parameters: QueueItemTransformer.transformParameters(action.parameters || {})
+        };
+    }
+    static transformFromSimilarActions(similarActions) {
+        const firstMatch = similarActions?.[0]?.data;
+        return firstMatch?.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
+    }
+    static transformParameters(parameters) {
+        return Object.entries(parameters).map(([name, value]) => ({
+            name,
+            value: typeof value === 'object' ? JSON.stringify(value) : String(value)
+        }));
+    }
+    static transformActionsToQueueItems(actions) {
+        return actions?.map(action => this.transformActionToQueueItem(action));
+    }
+}
+exports.QueueItemTransformer = QueueItemTransformer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/tsconfig.json

@@ -11,6 +11,5 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true
   },
-  "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "test"]
 }

package/dist/test/llm/orchestrator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/llm/orchestrator.test.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const zod_1 = require("zod");
-const orchestrator_1 = require("../../llm/orchestrator");
-describe("Orchestrator", () => {
-    let orchestrator;
-    const mockAction = {
-        name: "prepare-transaction",
-        description: "Prepare a transfer transaction",
-        parameters: zod_1.z.object({
-            walletAddress: zod_1.z.string(),
-            amount: zod_1.z.string(),
-            networkId: zod_1.z.string(),
-        }),
-        execute: async ({ walletAddress, amount, networkId }) => {
-            return { walletAddress, amount, networkId };
-        },
-    };
-    beforeEach(() => {
-        orchestrator = new orchestrator_1.Orchestrator([mockAction]);
-    });
-    it("should process a prompt and return just the answer", async function () {
-        this.timeout(10000);
-        const prompt = "Hello how are you?";
-        const result = await orchestrator.process(prompt);
-        (0, chai_1.expect)(result).to.have.property("answer").that.is.a("string");
-    });
-    it("should process a prompt and return valid actions", async function () {
-        this.timeout(10000);
-        const prompt = "Send 0.1 ETH to 0x123...456 on ethereum";
-        const result = await orchestrator.process(prompt);
-        console.dir(result, { depth: null });
-        (0, chai_1.expect)(result).to.have.property("actions").that.is.an("array");
-        (0, chai_1.expect)(result).to.have.property("answer").that.is.a("string");
-        (0, chai_1.expect)(result.actions[0])
-            .to.have.property("parameters")
-            .that.is.an("object");
-    });
-});

package/dist/test/llm/synthesizer.test.js

@@ -1,27 +0,0 @@
-"use strict";
-// import { expect } from "chai";
-// import { Summarizer } from "../../llm/synthesizer";
-// describe("Synthesizer", () => {
-//   let synthesizer: Summarizer;
-//   beforeEach(() => {
-//     synthesizer = new Summarizer();
-//   });
-//   it("should process results and return a summary", async function () {
-//     this.timeout(10000);
-//     const mockResults = JSON.stringify({
-//       result: [
-//         {
-//           name: "prepare-transaction",
-//           result: {
-//             to: "0x123...456",
-//             value: "0.1",
-//             chain: { id: 1, name: "ethereum" },
-//           },
-//         },
-//       ],
-//       initialPrompt: "Send 0.1 ETH to 0x123...456 on ethereum",
-//     });
-//     const result = await synthesizer.process(mockResults);
-//     expect(result).to.have.property("response").that.is.a("string");
-//   });
-// });

package/dist/test/services/queue.test.js

@@ -1,39 +0,0 @@
-"use strict";
-// import { expect } from "chai";
-// import { z } from "zod";
-// import { ActionQueueManager } from "../../services/queue";
-// import { ActionSchema } from "../../types";
-// describe("ActionQueueManager", () => {
-//   let queueManager: ActionQueueManager;
-//   const mockAction: ActionSchema = {
-//     name: "prepare-transaction",
-//     description: "Prepare a transfer transaction",
-//     parameters: z.object({
-//       walletAddress: z.string(),
-//       amount: z.string(),
-//       networkId: z.string(),
-//     }),
-//     execute: async ({ walletAddress, amount, networkId }) => {
-//       return { walletAddress, amount, networkId };
-//     },
-//   };
-//   beforeEach(() => {
-//     queueManager = new ActionQueueManager([mockAction]);
-//   });
-//   it("should process queue items correctly", async () => {
-//     const queueItem = {
-//       name: "prepare-transaction",
-//       parameters: [
-//         { name: "walletAddress", value: "0x123...456" },
-//         { name: "amount", value: "0.1" },
-//         { name: "networkId", value: "1" },
-//       ],
-//     };
-//     queueManager.addToQueue([queueItem]);
-//     const results = await queueManager.processQueue();
-//     expect(results).to.exist;
-//     expect(results!).to.be.an("array");
-//     expect(results![0]).to.have.property("name", "prepare-transaction");
-//     expect(results![0]).to.have.property("result").that.is.an("object");
-//   });
-// });