@ai.ntellect/core 0.0.23 → 0.0.25

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

@@ -0,0 +1,8 @@
+import { ActionSchema } from "../../types";
+export declare const orchestratorContext: {
+    role: string;
+    guidelines: {
+        important: string[];
+    };
+    compose: (tools: ActionSchema[]) => string;
+};

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

@@ -0,0 +1,7 @@
+import { ActionSchema, BaseLLM } from "../../types";
+export declare class Orchestrator implements BaseLLM {
+    private readonly model;
+    tools: ActionSchema[];
+    constructor(tools: ActionSchema[]);
+    process(prompt: string): Promise<any>;
+}

package/dist/llm/orchestrator/index.js

@@ -0,0 +1,52 @@
+"use strict";
+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;
+    }
+    async process(prompt) {
+        try {
+            const response = 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(),
+                        parameters: zod_1.z.object({
+                            name: zod_1.z.string(),
+                            value: zod_1.z.string(),
+                        }),
+                    })),
+                    answer: zod_1.z.string(),
+                }),
+                prompt: prompt,
+                system: context_1.orchestratorContext.compose(this.tools),
+            });
+            const validatedResponse = {
+                ...response.object,
+                actions: response.object.actions.map((action) => ({
+                    ...action,
+                    parameters: action.parameters || {},
+                })),
+            };
+            console.dir(validatedResponse, { depth: null });
+            return validatedResponse;
+        }
+        catch (error) {
+            if (error) {
+                console.log("Error in Orchestrator", error.message);
+                console.dir(error.value, { depth: null });
+                return {
+                    ...error.value,
+                };
+            }
+            // throw error;
+        }
+    }
+}
+exports.Orchestrator = Orchestrator;

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

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

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

@@ -0,0 +1,40 @@
+"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

@@ -0,0 +1,27 @@
+"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

@@ -0,0 +1,39 @@
+"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");
+//   });
+// });

package/dist/types.d.ts

@@ -0,0 +1,139 @@
+import { StreamTextResult } from "ai";
+import { z } from "zod";
+export interface BaseLLM {
+    process: (prompt: string) => Promise<string | object>;
+    streamProcess?: (prompt: string) => Promise<StreamTextResult<Record<string, any>>>;
+}
+export type User = {
+    id: string;
+};
+export interface QueueItem {
+    name: string;
+    parameters: QueueItemParameter[];
+}
+export interface IEventHandler {
+    emitQueueStart(actions: QueueItem[]): void;
+    emitActionStart(action: QueueItem): void;
+    emitActionComplete(action: QueueResult): void;
+    emitQueueComplete(): void;
+}
+export type AgentEvent = {
+    onMessage?: (data: any) => void;
+    onQueueStart?: (actions: QueueItem[]) => void;
+    onActionStart?: (action: QueueItem) => void;
+    onActionComplete?: (action: QueueResult) => void;
+    onQueueComplete?: (actions: QueueResult[]) => void;
+    onConfirmationRequired?: (message: string) => Promise<boolean>;
+};
+export interface QueueResult {
+    name: string;
+    parameters: Record<string, string>;
+    result: any;
+    error: string | null;
+    cancelled?: boolean;
+}
+export interface QueueCallbacks {
+    onActionStart?: (action: QueueItem) => void;
+    onActionComplete?: (result: QueueResult) => void;
+    onQueueComplete?: (results: QueueResult[]) => void;
+    onConfirmationRequired?: (message: string) => Promise<boolean>;
+}
+export interface ProcessPromptCallbacks {
+    onQueueStart?: (actions: QueueItem[]) => void | Promise<void>;
+    onActionStart?: (action: QueueItem) => void | Promise<void>;
+    onActionComplete?: (action: QueueResult) => void | Promise<void>;
+    onQueueComplete?: (actions: QueueResult[]) => void | Promise<void>;
+    onConfirmationRequired?: (message: string) => Promise<boolean>;
+}
+export interface ActionSchema {
+    name: string;
+    description: string;
+    parameters: z.ZodSchema;
+    execute: (args: any) => Promise<any>;
+    confirmation?: {
+        requireConfirmation: boolean;
+        message: string;
+    };
+}
+export type ProcessPromptResult = {
+    type: "success" | "clarification" | "confirmation";
+    data: QueueResult[] | {
+        validationErrors: string[];
+        prompt: string;
+    } | {
+        actions: QueueItem[];
+    };
+    initialPrompt: string;
+};
+export interface ActionPattern {
+    id: string;
+    actions: QueueResult[];
+    embeddings: number[][];
+    queries: string[];
+    purpose: string;
+}
+export interface MatchOptions {
+    similarityThreshold?: number;
+    maxResults?: number;
+}
+export interface MatchResult {
+    data: any;
+    similarityPercentage: number;
+    purpose: string;
+    name?: string;
+    parameters?: Record<string, any>;
+}
+export interface SummarizerAgent {
+    process: (results: object, onFinish?: (event: any) => void) => Promise<{
+        actions: {
+            name: string;
+            reasoning: string;
+        }[];
+        response: string;
+    } | StreamTextResult<Record<string, any>>>;
+    streamProcess: (results: object, onFinish?: (event: any) => void) => Promise<StreamTextResult<Record<string, any>>>;
+}
+export interface MemoryCacheOptions {
+    cacheTTL?: number;
+    redisUrl?: string;
+    cachePrefix?: string;
+}
+export interface CreateMemoryInput {
+    content: string;
+    type: MemoryType;
+    data: any;
+    userId?: string;
+    scope?: MemoryScope;
+}
+export interface Memory {
+    id: string;
+    type: MemoryType;
+    data: any;
+    purpose: string;
+    queries: string[];
+    embeddings: number[][];
+    userId?: string;
+    scope: MemoryScope;
+    createdAt: Date;
+}
+export declare enum MemoryType {
+    ACTION = "action",
+    CONVERSATION = "conversation",
+    KNOWLEDGE = "knowledge"
+}
+export declare enum MemoryScope {
+    GLOBAL = "global",
+    USER = "user"
+}
+export interface ActionData {
+    name?: string;
+    parameters?: Record<string, any>;
+}
+export interface QueueItemParameter {
+    name: string;
+    value: string;
+}
+export interface TransformedQueueItem {
+    name: string;
+    parameters: QueueItemParameter[];
+}

package/index.ts

@@ -1,7 +1,8 @@
-export * from "./agents/orchestrator";
-export * from "./agents/synthesizer";
+export * from "./agent";
+export * from "./llm/orchestrator";
+export * from "./llm/synthesizer";
+
 export * from "./services/queue";
 export * from "./types";
 
-export * from "./memory";
-export * from "./workflow";
+export * from "./memory";

package/llm/orchestrator/index.ts

@@ -1,10 +1,10 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
-import { ActionSchema, Agent } from "../../types";
+import { ActionSchema, BaseLLM } from "../../types";
 import { orchestratorContext } from "./context";
 
-export class Orchestrator implements Agent {
+export class Orchestrator implements BaseLLM {
   private readonly model = openai("gpt-4o-mini");
   public tools: ActionSchema[];
 

package/llm/synthesizer/index.ts

@@ -1,10 +1,10 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
-import { Agent } from "../../types";
+import { BaseLLM } from "../../types";
 import { summarizerContext } from "./context";
 
-export class Summarizer implements Agent {
+export class Summarizer implements BaseLLM {
   private readonly model = openai("gpt-4-turbo");
 
   async process(

package/package.json

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

package/types.ts

@@ -1,7 +1,7 @@
 import { StreamTextResult } from "ai";
 import { z } from "zod";
 
-export interface Agent {
+export interface BaseLLM {
   process: (prompt: string) => Promise<string | object>;
   streamProcess?: (
     prompt: string

package/dist/agents/orchestrator/index.js

@@ -1,40 +0,0 @@
-"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

@@ -1,52 +0,0 @@
-"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

@@ -1,54 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-"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

@@ -1,190 +0,0 @@
-"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

@@ -1,136 +0,0 @@
-"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/utils/queue-item-transformer.js

@@ -1,26 +0,0 @@
-"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) {
-        var _a;
-        const firstMatch = (_a = similarActions === null || similarActions === void 0 ? void 0 : similarActions[0]) === null || _a === void 0 ? void 0 : _a.data;
-        return firstMatch === null || firstMatch === void 0 ? void 0 : 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 === null || actions === void 0 ? void 0 : actions.map(action => this.transformActionToQueueItem(action));
-    }
-}
-exports.QueueItemTransformer = QueueItemTransformer;

package/dist/workflow/index.js

@@ -1,187 +0,0 @@
-"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.Workflow = void 0;
-const synthesizer_1 = require("../agents/synthesizer");
-const queue_1 = require("../services/queue");
-const types_1 = require("../types");
-const queue_item_transformer_1 = require("../utils/queue-item-transformer");
-class Workflow {
-    constructor(user, dependencies) {
-        this.user = user;
-        this.dependencies = dependencies;
-        this.CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
-        this.SIMILARITY_THRESHOLD = 95;
-        this.MAX_RESULTS = 1;
-    }
-    start(prompt, promptWithContext, stream) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const request = yield this.dependencies.orchestrator.process(promptWithContext);
-            this.dependencies.eventEmitter.emit("orchestrator-update", {
-                type: "on-message",
-                data: request,
-            });
-            if (request.actions.length > 0) {
-                return this.handleActions(prompt, request.actions);
-            }
-        });
-    }
-    handleActions(prompt, actions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let predefinedActions = actions;
-            console.log("\n🔍 Predefined actions:", predefinedActions);
-            const similarActions = yield this.dependencies.memoryCache.findBestMatches(prompt, {
-                similarityThreshold: this.SIMILARITY_THRESHOLD,
-                maxResults: this.MAX_RESULTS,
-                userId: this.user.id,
-                scope: types_1.MemoryScope.USER,
-            });
-            console.log("\n🔍 Similar actions:", similarActions);
-            predefinedActions =
-                queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(predefinedActions) ||
-                    [];
-            console.log("\n🔍 Transformed predefined actions:", predefinedActions);
-            if (similarActions && similarActions.length > 0) {
-                predefinedActions =
-                    queue_item_transformer_1.QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
-                console.log("\n🔍 Transformed similar actions:", predefinedActions);
-            }
-            console.log("\n🔍 Final actions:", predefinedActions);
-            const callbacks = this.createCallbacks(prompt, similarActions);
-            console.log("\n🔍 Queue prepared");
-            const actionsResult = yield this.executeActions(predefinedActions, this.dependencies.orchestrator.tools, callbacks);
-            console.log("\n🔍 Actions result:", actionsResult);
-            return this.handleActionResults(Object.assign(Object.assign({}, actionsResult), { initialPrompt: prompt }), prompt);
-        });
-    }
-    executeActions(predefinedActions, tools, callbacks) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const queueManager = new queue_1.ActionQueueManager(tools, {
-                    onActionStart: callbacks === null || callbacks === void 0 ? void 0 : callbacks.onActionStart,
-                    onActionComplete: callbacks === null || callbacks === void 0 ? void 0 : callbacks.onActionComplete,
-                    onQueueComplete: callbacks === null || callbacks === void 0 ? void 0 : callbacks.onQueueComplete,
-                    onConfirmationRequired: (message) => __awaiter(this, void 0, void 0, function* () {
-                        if (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onConfirmationRequired) {
-                            return yield callbacks.onConfirmationRequired(message);
-                        }
-                        return false;
-                    }),
-                });
-                queueManager.addToQueue(predefinedActions);
-                if (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onQueueStart) {
-                    callbacks.onQueueStart(predefinedActions);
-                }
-                console.log("Processing queue...");
-                const results = yield queueManager.processQueue();
-                console.log("Queue completed:");
-                console.dir(results, { depth: null });
-                return {
-                    type: "success",
-                    data: results || [],
-                };
-            }
-            catch (error) {
-                console.error("Error processing prompt:", error);
-                throw error;
-            }
-        });
-    }
-    createCallbacks(prompt, similarActions) {
-        return {
-            onQueueStart: (actions) => __awaiter(this, void 0, void 0, function* () {
-                console.dir(actions, { depth: null });
-                this.dependencies.eventEmitter.emit("orchestrator-update", {
-                    type: "queue-start",
-                    actions,
-                });
-            }),
-            onActionStart: (action) => {
-                this.dependencies.eventEmitter.emit("orchestrator-update", {
-                    type: "action-start",
-                    action: action.name,
-                    args: action.parameters,
-                });
-            },
-            onActionComplete: (action) => {
-                this.dependencies.eventEmitter.emit("orchestrator-update", {
-                    type: "action-complete",
-                    action: action.name,
-                    result: action.result,
-                });
-            },
-            onQueueComplete: (actions) => __awaiter(this, void 0, void 0, function* () {
-                if (!similarActions.length) {
-                    yield this.saveToMemory(prompt, actions);
-                }
-                this.dependencies.eventEmitter.emit("orchestrator-update", {
-                    type: "queue-complete",
-                });
-            }),
-            onConfirmationRequired: this.handleConfirmationRequest.bind(this),
-        };
-    }
-    handleConfirmationRequest(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                const confirmationId = Date.now().toString();
-                const handleConfirmation = (data) => {
-                    if (data.confirmationId === confirmationId) {
-                        this.dependencies.eventEmitter.removeListener("confirmation-response", handleConfirmation);
-                        resolve(data.confirmed);
-                    }
-                };
-                this.dependencies.eventEmitter.once("confirmation-response", handleConfirmation);
-                this.dependencies.eventEmitter.emit("orchestrator-update", {
-                    type: "confirmation-required",
-                    id: confirmationId,
-                    message,
-                });
-                setTimeout(() => {
-                    this.dependencies.eventEmitter.removeListener("confirmation-response", handleConfirmation);
-                    resolve(false);
-                }, this.CONFIRMATION_TIMEOUT);
-            });
-        });
-    }
-    saveToMemory(prompt, actions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log("\n🔍 Creating memory...");
-            yield this.dependencies.memoryCache.createMemory({
-                content: prompt,
-                userId: this.user.id,
-                scope: types_1.MemoryScope.USER,
-                type: types_1.MemoryType.ACTION,
-                data: actions,
-            });
-        });
-    }
-    handleActionResults(actionsResult_1, prompt_1) {
-        return __awaiter(this, arguments, void 0, function* (actionsResult, prompt, stream = true) {
-            if (!this.hasNonPrepareActions(actionsResult.data)) {
-                return;
-            }
-            const summarizer = new synthesizer_1.Summarizer();
-            const summaryData = JSON.stringify({
-                result: actionsResult.data,
-                initialPrompt: prompt,
-            });
-            return stream
-                ? (yield summarizer.streamProcess(summaryData)).toDataStreamResponse()
-                : yield summarizer.process(summaryData);
-        });
-    }
-    hasNonPrepareActions(actions) {
-        return (Array.isArray(actions) &&
-            actions.some((action) => { var _a; return ((_a = action.name) === null || _a === void 0 ? void 0 : _a.split("-")[0]) !== "prepare"; }));
-    }
-}
-exports.Workflow = Workflow;