@ai.ntellect/core 0.0.1

package/agents/synthesizer/context.ts

@@ -0,0 +1,50 @@
+export const 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: string) => {
+    return `
+      ${JSON.stringify(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/agents/synthesizer/index.ts

@@ -0,0 +1,52 @@
+import { openai } from "@ai-sdk/openai";
+import { generateObject, streamText, StreamTextResult } from "ai";
+import { z } from "zod";
+import { Agent } from "../../types";
+import { summarizerContext } from "./context";
+
+export class Summarizer implements Agent {
+  private readonly model = openai("gpt-4-turbo");
+
+  async process(
+    prompt: string,
+    onFinish?: (event: any) => void
+  ): Promise<
+    | {
+        actions: { name: string; reasoning: string }[];
+        response: string;
+      }
+    | StreamTextResult<Record<string, any>>
+  > {
+    console.log("Summarizing results...");
+    const result = await generateObject({
+      model: this.model,
+      schema: z.object({
+        actions: z.array(
+          z.object({
+            name: z.string(),
+            reasoning: z.string(),
+          })
+        ),
+        response: z.string(),
+      }),
+      prompt: summarizerContext.compose(prompt),
+      system: summarizerContext.role,
+    });
+    console.log("Summarized results:", result.object);
+    if (onFinish) onFinish(result.object);
+    return result.object;
+  }
+
+  async streamProcess(
+    prompt: string,
+    onFinish?: (event: any) => void
+  ): Promise<StreamTextResult<Record<string, any>>> {
+    const result = await streamText({
+      model: this.model,
+      prompt: summarizerContext.compose(prompt),
+      onFinish: onFinish,
+      system: summarizerContext.role,
+    });
+    return result;
+  }
+}

package/dist/agents/orchestrator/context.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orchestratorContext = void 0;
+exports.orchestratorContext = {
+    role: "You are the gateway agent, you are the first agent to be called. You are the one who will decide if the user request is clear and if it's possible to achieve the goal.",
+    guidelines: {
+        important: [
+            "IMPORTANT: If there is no action to do, you must answer in the 'answer' field.",
+            "IMPORTANT: If there are actions to do, you must explain why you are doing them in the 'answer' field.",
+            "IMPORTANT: If user ask for a analysis of the market or a cryptocurrency, use the maximum of useful tools to have a global view of the market (fundamental analysis vs technical analysis).",
+            "IMPORTANT: If user ask for an action on chain, use the useful tools to do the action.",
+            "IMPORTANT: You allow to provide an analysis without providing any financial advice.",
+            "IMPORTANT: ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
+        ],
+    },
+    compose: (tools) => {
+        return `
+            ${exports.orchestratorContext.role}
+
+            ${exports.orchestratorContext.guidelines.important.join("\n")}
+
+            If this is an action, extract the parameters required to execute the action. 
+            IMPORTANT: If some parameters are not clear or missing, YOU MUST ask the user for them.
+            
+            The actions are: ${tools.map((action) => {
+            const parameters = action.parameters;
+            const schemaShape = Object.keys(parameters._def.shape()).join(", ");
+            const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments: { ${schemaShape} }`;
+            return actionString;
+        })}
+        `;
+    },
+};

package/dist/agents/orchestrator/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orchestrator = 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 Orchestrator {
+    constructor(tools) {
+        this.model = (0, openai_1.openai)("gpt-4o-mini");
+        this.tools = tools;
+    }
+    process(prompt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (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(),
+                        parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+                    })),
+                    answer: zod_1.z.string(),
+                }),
+                prompt: prompt,
+                system: context_1.orchestratorContext.compose(this.tools),
+            });
+            return response.object;
+        });
+    }
+}
+exports.Orchestrator = Orchestrator;

package/dist/agents/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/agents/synthesizer/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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");
+    }
+    process(prompt, onFinish) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Summarizing results...");
+            const result = yield (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(),
+                        reasoning: 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;
+        });
+    }
+    streamProcess(prompt, onFinish) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield (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/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("./agents/orchestrator"), exports);
+__exportStar(require("./agents/synthesizer"), exports);
+__exportStar(require("./services/queue"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./memory"), exports);
+__exportStar(require("./workflow"), exports);

package/dist/memory/index.js

@@ -0,0 +1,190 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 = {}) {
+        var _a, _b;
+        const ttlInHours = (_a = options.cacheTTL) !== null && _a !== void 0 ? _a : 1;
+        this.CACHE_TTL = ttlInHours * 60 * 60;
+        this.CACHE_PREFIX = (_b = options.cachePrefix) !== null && _b !== void 0 ? _b : 'memory:';
+        this.redis = (0, redis_1.createClient)({
+            url: options.redisUrl || process.env.REDIS_URL,
+            socket: {
+                tls: true,
+                rejectUnauthorized: true
+            }
+        });
+        this.initRedis();
+    }
+    initRedis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.redis.on('error', err => {
+                console.error('Redis Client Error:', err);
+                // Implement retry logic if needed
+            });
+            try {
+                yield 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}:`;
+    }
+    storeMemory(memory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefix = this.getMemoryKey(memory.scope, memory.userId);
+            const key = `${prefix}${memory.id}`;
+            yield this.redis.set(key, JSON.stringify(memory), {
+                EX: this.CACHE_TTL
+            });
+        });
+    }
+    findBestMatches(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, options = {}) {
+            console.log("\n🔍 Searching for query:", query);
+            const { embedding } = yield (0, ai_1.embed)({
+                model: openai_1.openai.embedding("text-embedding-3-small"),
+                value: query
+            });
+            const memories = yield 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 => { var _a; return match.similarityPercentage >= ((_a = options.similarityThreshold) !== null && _a !== void 0 ? _a : 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;
+        });
+    }
+    getAllMemories(scope, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let patterns = [];
+            if (!scope || scope === types_1.MemoryScope.GLOBAL) {
+                const globalPrefix = this.getMemoryKey(types_1.MemoryScope.GLOBAL);
+                const globalKeys = yield this.redis.keys(`${globalPrefix}*`);
+                const globalPatterns = yield 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 = yield this.redis.keys(`${userPrefix}*`);
+                const userPatterns = yield this.getMemoriesFromKeys(userKeys);
+                patterns = patterns.concat(userPatterns);
+            }
+            return patterns;
+        });
+    }
+    getMemoriesFromKeys(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = [];
+            for (const key of keys) {
+                const data = yield this.redis.get(key);
+                if (data) {
+                    memories.push(JSON.parse(data));
+                }
+            }
+            return memories;
+        });
+    }
+    createMemory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { embedding } = yield (0, ai_1.embed)({
+                model: openai_1.openai.embedding("text-embedding-3-small"),
+                value: input.content
+            });
+            const existingPattern = yield 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 = yield (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 = yield (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()
+            };
+            yield this.storeMemory(memory);
+            return variations.object.request;
+        });
+    }
+}
+exports.MemoryCache = MemoryCache;

package/dist/services/queue.js

@@ -0,0 +1,136 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
+        }
+    }
+    processQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            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 ((_a = actionConfig === null || actionConfig === void 0 ? void 0 : actionConfig.confirmation) === null || _a === void 0 ? void 0 : _a.requireConfirmation) {
+                    // Wait for user confirmation before executing this action
+                    const shouldProceed = yield ((_c = (_b = this.callbacks).onConfirmationRequired) === null || _c === void 0 ? void 0 : _c.call(_b, 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) => {
+                    var _a, _b;
+                    (_b = (_a = this.callbacks).onActionComplete) === null || _b === void 0 ? void 0 : _b.call(_a, result);
+                    return result;
+                })
+                    .catch((error) => {
+                    var _a, _b;
+                    const result = {
+                        name: action.name,
+                        parameters: this.formatArguments(action.parameters),
+                        result: null,
+                        error: error.message || "Unknown error occurred"
+                    };
+                    (_b = (_a = this.callbacks).onActionComplete) === null || _b === void 0 ? void 0 : _b.call(_a, result);
+                    return result;
+                }));
+            }
+            try {
+                const results = yield Promise.all(actionPromises);
+                this.results.push(...results);
+                this.queue = [];
+                (_e = (_d = this.callbacks).onQueueComplete) === null || _e === void 0 ? void 0 : _e.call(_d, 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;
+        }, {});
+    }
+    executeAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Call onActionStart callback
+            (_b = (_a = this.callbacks).onActionStart) === null || _b === void 0 ? void 0 : _b.call(_a, 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;
+            }, {});
+            console.log(`Executing ${action.name} with args:`, actionArgs);
+            try {
+                const result = yield actionConfig.execute(actionArgs);
+                return {
+                    name: action.name,
+                    parameters: actionArgs,
+                    result,
+                    error: null,
+                };
+            }
+            catch (error) {
+                console.error(`Error executing action ${action.name}:`, error);
+                return {
+                    name: action.name,
+                    parameters: actionArgs,
+                    result: null,
+                    error: error.message || "Unknown error occurred",
+                };
+            }
+        });
+    }
+}
+exports.ActionQueueManager = ActionQueueManager;

package/dist/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryScope = exports.MemoryType = void 0;
+var MemoryType;
+(function (MemoryType) {
+    MemoryType["ACTION"] = "action";
+    MemoryType["CONVERSATION"] = "conversation";
+    MemoryType["KNOWLEDGE"] = "knowledge";
+})(MemoryType || (exports.MemoryType = MemoryType = {}));
+var MemoryScope;
+(function (MemoryScope) {
+    MemoryScope["GLOBAL"] = "global";
+    MemoryScope["USER"] = "user";
+})(MemoryScope || (exports.MemoryScope = MemoryScope = {}));