@ai.ntellect/core 0.0.21 → 0.0.23

package/.env.example

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+REDIS_URL=

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+  "extension": ["ts"],
+  "spec": "test/**/*.test.ts",
+  "require": "ts-node/register"
+}

package/agent/handlers/ActionHandler.ts

@@ -0,0 +1,48 @@
+import { ActionQueueManager } from "../../services/queue";
+import {
+  ActionSchema,
+  ProcessPromptCallbacks,
+  QueueItem,
+  QueueResult,
+} from "../../types";
+
+export class ActionHandler {
+  async executeActions(
+    predefinedActions: QueueItem[],
+    tools: ActionSchema[],
+    callbacks?: ProcessPromptCallbacks
+  ) {
+    try {
+      const queueManager = new 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: QueueResult[]): boolean {
+    return (
+      Array.isArray(actions) &&
+      actions.some((action) => action.name?.split("-")[0] !== "prepare")
+    );
+  }
+}

package/agent/handlers/ConfirmationHandler.ts

@@ -0,0 +1,37 @@
+import EventEmitter from "events";
+
+export class ConfirmationHandler {
+  private readonly CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+  constructor(private readonly eventEmitter: EventEmitter) {}
+
+  async handleConfirmationRequest(message: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const confirmationId = Date.now().toString();
+      const handleConfirmation = (data: any) => {
+        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);
+    });
+  }
+}

package/agent/handlers/EventHandler.ts

@@ -0,0 +1,35 @@
+import EventEmitter from "events";
+import { IEventHandler, QueueItem, QueueResult } from "../../types";
+
+export class EventHandler implements IEventHandler {
+  constructor(private readonly eventEmitter: EventEmitter) {}
+
+  emitQueueStart(actions: QueueItem[]) {
+    this.eventEmitter.emit("orchestrator-update", {
+      type: "queue-start",
+      actions,
+    });
+  }
+
+  emitActionStart(action: QueueItem) {
+    this.eventEmitter.emit("orchestrator-update", {
+      type: "action-start",
+      action: action.name,
+      args: action.parameters,
+    });
+  }
+
+  emitActionComplete(action: QueueResult) {
+    this.eventEmitter.emit("orchestrator-update", {
+      type: "action-complete",
+      action: action.name,
+      result: action.result,
+    });
+  }
+
+  emitQueueComplete() {
+    this.eventEmitter.emit("orchestrator-update", {
+      type: "queue-complete",
+    });
+  }
+}

package/agent/index.ts

@@ -0,0 +1,119 @@
+import EventEmitter from "events";
+import { Orchestrator } from "../llm/orchestrator";
+import { Summarizer } from "../llm/synthesizer";
+import { MemoryCache } from "../memory";
+import { ActionSchema, AgentEvent, MemoryScope, User } from "../types";
+import { QueueItemTransformer } from "../utils/queue-item-transformer";
+import { ActionHandler } from "./handlers/ActionHandler";
+
+export class Agent {
+  private readonly SIMILARITY_THRESHOLD = 95;
+  private readonly MAX_RESULTS = 1;
+  private readonly actionHandler: ActionHandler;
+
+  constructor(
+    private readonly user: User,
+    private readonly dependencies: {
+      orchestrator: Orchestrator;
+      memoryCache: MemoryCache;
+      eventEmitter: EventEmitter;
+    },
+    private readonly stream: boolean = true
+  ) {
+    this.actionHandler = new ActionHandler();
+  }
+
+  async start(
+    prompt: string,
+    contextualizedPrompt: string,
+    events: AgentEvent
+  ): Promise<any> {
+    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
+      );
+    }
+  }
+
+  private async handleActions(
+    {
+      initialPrompt,
+      actions,
+    }: {
+      initialPrompt: string;
+      actions: ActionSchema[];
+    },
+    events: AgentEvent
+  ) {
+    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 });
+  }
+
+  private async findSimilarActions(prompt: string) {
+    return this.dependencies.memoryCache.findBestMatches(prompt, {
+      similarityThreshold: this.SIMILARITY_THRESHOLD,
+      maxResults: this.MAX_RESULTS,
+      userId: this.user.id,
+      scope: MemoryScope.USER,
+    });
+  }
+
+  private transformActions(actions: ActionSchema[], similarActions: any[]) {
+    let predefinedActions =
+      QueueItemTransformer.transformActionsToQueueItems(actions) || [];
+
+    if (similarActions?.length > 0) {
+      predefinedActions =
+        QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
+    }
+
+    return predefinedActions;
+  }
+
+  private async handleActionResults(actionsResult: {
+    data: any;
+    initialPrompt: string;
+  }) {
+    const summarizer = new Summarizer();
+    const summaryData = JSON.stringify({
+      result: actionsResult.data,
+      initialPrompt: actionsResult.initialPrompt,
+    });
+
+    return this.stream
+      ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
+      : await summarizer.process(summaryData);
+  }
+}

package/llm/orchestrator/index.ts

@@ -0,0 +1,57 @@
+import { openai } from "@ai-sdk/openai";
+import { generateObject } from "ai";
+import { z } from "zod";
+import { ActionSchema, Agent } from "../../types";
+import { orchestratorContext } from "./context";
+
+export class Orchestrator implements Agent {
+  private readonly model = openai("gpt-4o-mini");
+  public tools: ActionSchema[];
+
+  constructor(tools: ActionSchema[]) {
+    this.tools = tools;
+  }
+
+  async process(prompt: string): Promise<any> {
+    try {
+      const response = await generateObject({
+        model: this.model,
+        schema: z.object({
+          actions: z.array(
+            z.object({
+              name: z.string(),
+              parameters: z.object({
+                name: z.string(),
+                value: z.string(),
+              }),
+            })
+          ),
+          answer: z.string(),
+        }),
+        prompt: prompt,
+        system: 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: any) {
+      if (error) {
+        console.log("Error in Orchestrator", error.message);
+        console.dir(error.value, { depth: null });
+        return {
+          ...error.value,
+        };
+      }
+      // throw error;
+    }
+  }
+}

package/{agents → llm}/synthesizer/index.ts

@@ -12,7 +12,7 @@ export class Summarizer implements Agent {
     onFinish?: (event: any) => void
   ): Promise<
     | {
-        actions: { name: string; reasoning: string }[];
+        actions: { name: string; result: string; why: string }[];
         response: string;
       }
     | StreamTextResult<Record<string, any>>
@@ -24,7 +24,8 @@ export class Summarizer implements Agent {
         actions: z.array(
           z.object({
             name: z.string(),
-            reasoning: z.string(),
+            result: z.string(),
+            why: z.string(),
           })
         ),
         response: z.string(),

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "mocha --require ts-node/register",
+    "test:watch": "mocha --require ts-node/register 'test/**/*.test.ts' --watch"
   },
   "keywords": [],
   "author": "Lorcann Rauzduel",
@@ -17,14 +18,21 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/chai": "^4.3.20",
+    "@types/mocha": "^10.0.0",
+    "chai": "^4.5.0",
+    "mocha": "^10.0.0",
+    "ts-node": "^10.9.0",
+    "tsconfig-paths": "^4.2.0",
     "typescript": "^5.7.2"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ai.ntellect/core.git"
+    "url": "git+https://github.com/ai-ntellect/core.git"
   },
   "bugs": {
-    "url": "https://github.com/ai.ntellect/core/issues"
+    "url": "https://github.com/ai-ntellect/core/issues"
   },
-  "homepage": "https://github.com/ai.ntellect/core#readme"
+  "homepage": "https://github.com/ai-ntellect/core#readme"
 }

package/services/queue.ts

@@ -38,7 +38,7 @@ export class ActionQueueManager {
     }
 
     this.isProcessing = true;
-    const actionPromises = [];
+    const actionPromises: Promise<QueueResult>[] = [];
 
     for (const action of this.queue) {
       const actionConfig = this.actions.find((a) => a.name === action.name);
@@ -115,7 +115,6 @@ export class ActionQueueManager {
         error: `Action '${action.name}' not found in actions list`,
       };
     }
-
     const actionArgs = action.parameters.reduce<Record<string, string>>(
       (acc: Record<string, string>, arg: QueueItemParameter) => {
         acc[arg.name] = arg.value;
@@ -123,25 +122,27 @@ export class ActionQueueManager {
       },
       {}
     );
-
-    console.log(`Executing ${action.name} with args:`, actionArgs);
-
     try {
       const result = await actionConfig.execute(actionArgs);
-      return {
+      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) {
-      console.error(`Error executing action ${action.name}:`, error);
-      return {
+      const actionResult = {
         name: action.name,
         parameters: actionArgs,
         result: null,
         error: (error as Error).message || "Unknown error occurred",
       };
+      console.log("Action failed: ", action.name);
+      console.dir(actionResult, { depth: null });
+      return actionResult;
     }
   }
 }

package/test/llm/orchestrator.test.ts

@@ -0,0 +1,47 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { Orchestrator } from "../../llm/orchestrator";
+import { ActionSchema } from "../../types";
+
+describe("Orchestrator", () => {
+  let orchestrator: Orchestrator;
+
+  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(() => {
+    orchestrator = new 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);
+
+    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 });
+    expect(result).to.have.property("actions").that.is.an("array");
+    expect(result).to.have.property("answer").that.is.a("string");
+    expect(result.actions[0])
+      .to.have.property("parameters")
+      .that.is.an("object");
+  });
+});

package/test/llm/synthesizer.test.ts

@@ -0,0 +1,31 @@
+// 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/test/services/queue.test.ts

@@ -0,0 +1,44 @@
+// 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/tsconfig.json

@@ -1,112 +1,16 @@
 {
   "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "lib": ["ES2020"],
+    "declaration": true,
     "outDir": "./dist",
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-    /* Language and Environment */
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
-    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "commonjs" /* Specify what module code is generated. */,
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
-    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
-    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
-    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
-    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
-    /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
-    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
-
-    /* Type Checking */
-    "strict": true /* Enable all strict type-checking options. */,
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true /* Skip type checking all .d.ts files. */
-  }
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules", "dist"]
 }

package/types.ts

@@ -17,6 +17,22 @@ export interface QueueItem {
   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>;

package/agents/orchestrator/index.ts

@@ -1,33 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { generateObject } from "ai";
-import { z } from "zod";
-import { ActionSchema, Agent } from "../../types";
-import { orchestratorContext } from "./context";
-
-export class Orchestrator implements Agent {
-  private readonly model = openai("gpt-4o-mini");
-  public tools: ActionSchema[];
-
-  constructor(tools: ActionSchema[]) {
-    this.tools = tools;
-  }
-
-  async process(prompt: string): Promise<any> {
-    const response = await generateObject({
-      model: this.model,
-      schema: z.object({
-        actions: z.array(
-          z.object({
-            name: z.string(),
-            parameters: z.record(z.string(), z.any()),
-          })
-        ),
-        answer: z.string(),
-      }),
-      prompt: prompt,
-      system: orchestratorContext.compose(this.tools),
-    });
-
-    return response.object;
-  }
-}

package/workflow/index.ts

@@ -1,253 +0,0 @@
-import EventEmitter from "events";
-import { Orchestrator } from "../agents/orchestrator";
-import { Summarizer } from "../agents/synthesizer";
-import { MemoryCache } from "../memory";
-import { ActionQueueManager } from "../services/queue";
-import {
-  ActionSchema,
-  MemoryScope,
-  MemoryType,
-  ProcessPromptCallbacks,
-  QueueItem,
-  QueueResult,
-  User,
-} from "../types";
-import { QueueItemTransformer } from "../utils/queue-item-transformer";
-
-export class Workflow {
-  private readonly CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
-  private readonly SIMILARITY_THRESHOLD = 95;
-  private readonly MAX_RESULTS = 1;
-
-  constructor(
-    private readonly user: User,
-    private readonly dependencies: {
-      orchestrator: Orchestrator;
-      memoryCache: MemoryCache;
-      eventEmitter: EventEmitter;
-    }
-  ) {}
-
-  async start(prompt: string, contextualizedPrompt: string): Promise<any> {
-    const request = await this.dependencies.orchestrator.process(
-      contextualizedPrompt
-    );
-
-    this.dependencies.eventEmitter.emit("orchestrator-update", {
-      type: "on-message",
-      data: request,
-    });
-
-    if (request.actions.length > 0) {
-      return this.handleActions({
-        initialPrompt: prompt,
-        actions: request.actions,
-      });
-    }
-  }
-
-  private async handleActions({
-    initialPrompt,
-    actions,
-  }: {
-    initialPrompt: string;
-    actions: ActionSchema[];
-  }) {
-    let predefinedActions: any[] = actions;
-    console.log("\n🔍 Predefined actions:", predefinedActions);
-    const similarActions = await this.dependencies.memoryCache.findBestMatches(
-      initialPrompt,
-      {
-        similarityThreshold: this.SIMILARITY_THRESHOLD,
-        maxResults: this.MAX_RESULTS,
-        userId: this.user.id,
-        scope: MemoryScope.USER,
-      }
-    );
-
-    console.log("\n🔍 Similar actions:", similarActions);
-
-    predefinedActions =
-      QueueItemTransformer.transformActionsToQueueItems(predefinedActions) ||
-      [];
-    console.log("\n🔍 Transformed predefined actions:", predefinedActions);
-    if (similarActions && similarActions.length > 0) {
-      predefinedActions =
-        QueueItemTransformer.transformFromSimilarActions(similarActions) || [];
-      console.log("\n🔍 Transformed similar actions:", predefinedActions);
-    }
-    console.log("\n🔍 Final actions:", predefinedActions);
-    const callbacks = this.createCallbacks(initialPrompt, similarActions);
-
-    console.log("\n🔍 Queue prepared");
-    const actionsResult = await this.executeActions(
-      predefinedActions,
-      this.dependencies.orchestrator.tools,
-      callbacks
-    );
-
-    console.log("\n🔍 Actions result:", actionsResult);
-    return this.handleActionResults({
-      ...actionsResult,
-      initialPrompt,
-    });
-  }
-
-  private async executeActions(
-    predefinedActions: QueueItem[],
-    tools: ActionSchema[],
-    callbacks?: ProcessPromptCallbacks
-  ) {
-    try {
-      const queueManager = new 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);
-      }
-
-      console.log("Processing queue...");
-      const results = await 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;
-    }
-  }
-
-  private createCallbacks(
-    prompt: string,
-    similarActions: any[]
-  ): ProcessPromptCallbacks {
-    return {
-      onQueueStart: async (actions: QueueItem[]) => {
-        console.dir(actions, { depth: null });
-        this.dependencies.eventEmitter.emit("orchestrator-update", {
-          type: "queue-start",
-          actions,
-        });
-      },
-      onActionStart: (action: QueueItem) => {
-        this.dependencies.eventEmitter.emit("orchestrator-update", {
-          type: "action-start",
-          action: action.name,
-          args: action.parameters,
-        });
-      },
-      onActionComplete: (action: QueueResult) => {
-        this.dependencies.eventEmitter.emit("orchestrator-update", {
-          type: "action-complete",
-          action: action.name,
-          result: action.result,
-        });
-      },
-      onQueueComplete: async (actions: QueueResult[]) => {
-        if (!similarActions.length) {
-          await this.saveToMemory(prompt, actions);
-        }
-        this.dependencies.eventEmitter.emit("orchestrator-update", {
-          type: "queue-complete",
-        });
-      },
-      onConfirmationRequired: this.handleConfirmationRequest.bind(this),
-    };
-  }
-
-  private async handleConfirmationRequest(message: string): Promise<boolean> {
-    return new Promise((resolve) => {
-      const confirmationId = Date.now().toString();
-
-      const handleConfirmation = (data: any) => {
-        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);
-    });
-  }
-
-  private async saveToMemory(
-    prompt: string,
-    actions: QueueResult[]
-  ): Promise<void> {
-    console.log("\n🔍 Creating memory...");
-    await this.dependencies.memoryCache.createMemory({
-      content: prompt,
-      userId: this.user.id,
-      scope: MemoryScope.USER,
-      type: MemoryType.ACTION,
-      data: actions,
-    });
-  }
-
-  private async handleActionResults(
-    actionsResult: {
-      data: any;
-      initialPrompt: string;
-    },
-    stream: boolean = true
-  ) {
-    if (!this.hasNonPrepareActions(actionsResult.data)) {
-      return;
-    }
-
-    const summarizer = new Summarizer();
-    const summaryData = JSON.stringify({
-      result: actionsResult.data,
-      initialPrompt: actionsResult.initialPrompt,
-    });
-
-    return stream
-      ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
-      : await summarizer.process(summaryData);
-  }
-
-  private hasNonPrepareActions(actions: QueueResult[]): boolean {
-    return (
-      Array.isArray(actions) &&
-      actions.some(
-        (action: QueueResult) => action.name?.split("-")[0] !== "prepare"
-      )
-    );
-  }
-}