@ai.ntellect/core 0.2.6 → 0.2.8

package/agent/index.ts

@@ -5,6 +5,7 @@ import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
 import { ActionSchema, AgentEvent, QueueResult, User } from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
+import { ResultSanitizer } from "../utils/sanitize-results";
 import { ActionHandler } from "./handlers/ActionHandler";
 
 export class Agent {
@@ -15,7 +16,7 @@ export class Agent {
   private readonly stream: boolean;
   private readonly maxEvaluatorIteration: number;
   private evaluatorIteration = 0;
-  private accumulatedResults: QueueResult[] = [];
+  private accumulatedResults: string = "";
 
   constructor({
     orchestrator,
@@ -37,11 +38,11 @@ export class Agent {
     this.stream = stream;
     this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
-    this.accumulatedResults = [];
+    this.accumulatedResults = "";
   }
 
   async process(prompt: string, events: AgentEvent): Promise<any> {
-    this.accumulatedResults = [];
+    this.accumulatedResults = "";
     this.evaluatorIteration = 0;
     console.log("Requesting orchestrator for actions..");
     const request = await this.orchestrator.process(
@@ -92,10 +93,7 @@ export class Agent {
       }
     );
 
-    this.accumulatedResults = [
-      ...this.accumulatedResults,
-      ...actionsResult.data,
-    ];
+    this.accumulatedResults += this.formatResults(actionsResult.data);
 
     const isOnChainAction = actions.some(
       (action) => action.type === "on-chain"
@@ -146,7 +144,7 @@ export class Agent {
   }
 
   private async handleActionResults(actionsResult: {
-    data: QueueResult[];
+    data: string;
     initialPrompt: string;
   }) {
     const synthesizer = new Synthesizer();
@@ -155,12 +153,12 @@ export class Agent {
       ? (
           await synthesizer.streamProcess(
             actionsResult.initialPrompt,
-            this.formatResults(actionsResult.data)
+            actionsResult.data
           )
         ).toDataStreamResponse()
       : await synthesizer.process(
           actionsResult.initialPrompt,
-          this.formatResults(actionsResult.data)
+          actionsResult.data
         );
   }
 
@@ -171,13 +169,15 @@ export class Agent {
     return predefinedActions;
   }
 
-  private formatResults(results: QueueResult[]): QueueResult[] {
-    return results.map((result) => ({
+  private formatResults(results: QueueResult[]): string {
+    const formattedResults = results.map((result) => ({
       ...result,
       result:
         typeof result.result === "object"
           ? JSON.stringify(result.result)
           : result.result,
     }));
+    const sanitizedResults = ResultSanitizer.sanitize(formattedResults);
+    return sanitizedResults;
   }
 }

package/dist/agent/index.js

@@ -4,21 +4,22 @@ exports.Agent = void 0;
 const evaluator_1 = require("../llm/evaluator");
 const synthesizer_1 = require("../llm/synthesizer");
 const queue_item_transformer_1 = require("../utils/queue-item-transformer");
+const sanitize_results_1 = require("../utils/sanitize-results");
 const ActionHandler_1 = require("./handlers/ActionHandler");
 class Agent {
     constructor({ orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration = 1, }) {
         this.evaluatorIteration = 0;
-        this.accumulatedResults = [];
+        this.accumulatedResults = "";
         this.orchestrator = orchestrator;
         this.cacheMemory = cacheMemory;
         this.persistentMemory = persistentMemory;
         this.stream = stream;
         this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
-        this.accumulatedResults = [];
+        this.accumulatedResults = "";
     }
     async process(prompt, events) {
-        this.accumulatedResults = [];
+        this.accumulatedResults = "";
         this.evaluatorIteration = 0;
         console.log("Requesting orchestrator for actions..");
         const request = await this.orchestrator.process(prompt, this.accumulatedResults);
@@ -39,10 +40,7 @@ class Agent {
             onQueueComplete: events.onQueueComplete,
             onConfirmationRequired: events.onConfirmationRequired,
         });
-        this.accumulatedResults = [
-            ...this.accumulatedResults,
-            ...actionsResult.data,
-        ];
+        this.accumulatedResults += this.formatResults(actionsResult.data);
         const isOnChainAction = actions.some((action) => action.type === "on-chain");
         if (isOnChainAction) {
             return {
@@ -75,20 +73,22 @@ class Agent {
     async handleActionResults(actionsResult) {
         const synthesizer = new synthesizer_1.Synthesizer();
         return this.stream
-            ? (await synthesizer.streamProcess(actionsResult.initialPrompt, this.formatResults(actionsResult.data))).toDataStreamResponse()
-            : await synthesizer.process(actionsResult.initialPrompt, this.formatResults(actionsResult.data));
+            ? (await synthesizer.streamProcess(actionsResult.initialPrompt, actionsResult.data)).toDataStreamResponse()
+            : await synthesizer.process(actionsResult.initialPrompt, actionsResult.data);
     }
     transformActions(actions) {
         let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];
         return predefinedActions;
     }
     formatResults(results) {
-        return results.map((result) => ({
+        const formattedResults = results.map((result) => ({
             ...result,
             result: typeof result.result === "object"
                 ? JSON.stringify(result.result)
                 : result.result,
         }));
+        const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(formattedResults);
+        return sanitizedResults;
     }
 }
 exports.Agent = Agent;

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

@@ -1,10 +1,10 @@
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, QueueResult, State } from "../../types";
+import { ActionSchema, State } from "../../types";
 export declare class Evaluator {
     private readonly model;
     tools: ActionSchema[];
     private memory;
     constructor(tools: ActionSchema[], memory: PersistentMemory);
     composeContext(state: State): string;
-    process(prompt: string, results: QueueResult[]): Promise<any>;
+    process(prompt: string, results: string): Promise<any>;
 }

package/dist/llm/evaluator/index.js

@@ -24,10 +24,9 @@ class Evaluator {
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
       # ACTIONS AVAILABLE: ${(0, inject_actions_1.injectActions)(actions)}
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # CURRENT_RESULTS: ${results}
       # STEPS: ${steps?.join("\n") || ""}
     `;
-        console.log("Evaluator Context:", context);
         return context;
     }
     async process(prompt, results) {

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

@@ -1,6 +1,6 @@
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, QueueResult, State } from "../../types";
+import { ActionSchema, State } from "../../types";
 export declare class Orchestrator {
     private readonly model;
     tools: ActionSchema[];
@@ -11,7 +11,7 @@ export declare class Orchestrator {
         cache: CacheMemory;
     });
     composeContext(state: State): string;
-    process(prompt: string, results: QueueResult[]): Promise<{
+    process(prompt: string, results: string): Promise<{
         actions: {
             name: string;
             type: string;

package/dist/llm/orchestrator/index.js

@@ -79,7 +79,7 @@ class Orchestrator {
       # IMPORTANT: ${important.join("\n")}
       # USER_REQUEST: ${userRequest}
       # ACTIONS_AVAILABLES: ${(0, inject_actions_1.injectActions)(actions)} (NEVER REPEAT ACTIONS)
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # CURRENT_RESULTS: ${results}
     `.trim();
         return context;
     }

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

@@ -1,14 +1,14 @@
 import { StreamTextResult } from "ai";
-import { QueueResult, State } from "../../types";
+import { State } from "../../types";
 export declare class Synthesizer {
     private readonly model;
     composeContext(state: Partial<State>): string;
-    process(prompt: string, results: QueueResult[], onFinish?: (event: any) => void): Promise<{
+    process(prompt: string, results: string, onFinish?: (event: any) => void): Promise<{
         actionsCompleted: {
             name: string;
             reasoning: string;
         }[];
         response: string;
     } | StreamTextResult<Record<string, any>>>;
-    streamProcess(prompt: string, results: QueueResult[], onFinish?: (event: any) => void): Promise<any>;
+    streamProcess(prompt: string, results: string, onFinish?: (event: any) => void): Promise<any>;
 }

package/dist/llm/synthesizer/index.js

@@ -22,11 +22,10 @@ class Synthesizer {
       # IMPORTANT: ${important.join("\n")}
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
-      # CURRENT_RESULTS: ${results?.map((r) => r.result).join(", ") || ""}
+      # CURRENT_RESULTS: ${results}
       # STEPS: ${steps?.join("\n") || ""}
       # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
     `;
-        console.log("Synthesizer Context:", context);
         return context;
     }
     async process(prompt, results, onFinish) {

package/dist/types.d.ts

@@ -57,7 +57,7 @@ export type State = {
     };
     userRequest: string;
     actions: ActionSchema[];
-    results: QueueResult[];
+    results: string;
     examplesMessages?: {
         role: string;
         content: string;

package/llm/evaluator/index.ts

@@ -2,7 +2,7 @@ import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope, QueueResult, State } from "../../types";
+import { ActionSchema, MemoryScope, State } from "../../types";
 import { injectActions } from "../../utils/inject-actions";
 import { evaluatorContext } from "./context";
 
@@ -28,14 +28,13 @@ export class Evaluator {
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
       # ACTIONS AVAILABLE: ${injectActions(actions)}
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # CURRENT_RESULTS: ${results}
       # STEPS: ${steps?.join("\n") || ""}
     `;
-    console.log("Evaluator Context:", context);
     return context;
   }
 
-  async process(prompt: string, results: QueueResult[]): Promise<any> {
+  async process(prompt: string, results: string): Promise<any> {
     try {
       const context = this.composeContext({
         behavior: evaluatorContext.behavior,

package/llm/orchestrator/index.ts

@@ -3,13 +3,7 @@ import { generateObject } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import {
-  ActionSchema,
-  MemoryScope,
-  MemoryScopeType,
-  QueueResult,
-  State,
-} from "../../types";
+import { ActionSchema, MemoryScope, MemoryScopeType, State } from "../../types";
 import { injectActions } from "../../utils/inject-actions";
 import { orchestratorContext } from "./context";
 
@@ -118,7 +112,7 @@ export class Orchestrator {
       # IMPORTANT: ${important.join("\n")}
       # USER_REQUEST: ${userRequest}
       # ACTIONS_AVAILABLES: ${injectActions(actions)} (NEVER REPEAT ACTIONS)
-      # CURRENT_RESULTS: ${results.map((r) => r.result).join(", ")}
+      # CURRENT_RESULTS: ${results}
     `.trim();
 
     return context;
@@ -126,7 +120,7 @@ export class Orchestrator {
 
   async process(
     prompt: string,
-    results: QueueResult[]
+    results: string
   ): Promise<{
     actions: {
       name: string;

package/llm/synthesizer/index.ts

@@ -1,7 +1,7 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
-import { QueueResult, State } from "../../types";
+import { State } from "../../types";
 import { synthesizerContext } from "./context";
 
 export class Synthesizer {
@@ -22,17 +22,16 @@ export class Synthesizer {
       # IMPORTANT: ${important.join("\n")}
       # NEVER: ${warnings.join("\n")}
       # USER_REQUEST: ${userRequest}
-      # CURRENT_RESULTS: ${results?.map((r) => r.result).join(", ") || ""}
+      # CURRENT_RESULTS: ${results}
       # STEPS: ${steps?.join("\n") || ""}
       # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
     `;
-    console.log("Synthesizer Context:", context);
     return context;
   }
 
   async process(
     prompt: string,
-    results: QueueResult[],
+    results: string,
     onFinish?: (event: any) => void
   ): Promise<
     | {
@@ -89,7 +88,7 @@ export class Synthesizer {
 
   async streamProcess(
     prompt: string,
-    results: QueueResult[],
+    results: string,
     onFinish?: (event: any) => void
   ): Promise<any> {
     console.log("\n🎨 Starting streaming synthesis");

package/package.json

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

package/types.ts

@@ -68,7 +68,7 @@ export type State = {
   };
   userRequest: string;
   actions: ActionSchema[];
-  results: QueueResult[];
+  results: string;
   examplesMessages?: {
     role: string;
     content: string;