@ai.ntellect/core 0.3.3 → 0.4.0

package/dist/test.js

@@ -1,21 +1,11 @@
 "use strict";
 // import ccxt from "ccxt";
+// import { configDotenv } from "dotenv";
 // import { parseEther } from "ethers";
 // import Parser from "rss-parser";
 // import { z } from "zod";
-// import { Agent } from "./agent";
-// import { Interpreter } from "./llm/interpreter";
-// import {
-//   generalInterpreterContext,
-//   marketInterpreterContext,
-//   securityInterpreterContext,
-// } from "./llm/interpreter/context";
-// import { Orchestrator } from "./llm/orchestrator";
-// import { CacheMemory } from "./memory/cache";
-// import { PersistentMemory } from "./memory/persistent";
-// import { ActionQueueManager } from "./services/queue";
-// import { ActionScheduler } from "./services/scheduler";
-// import { ScheduledAction } from "./types";
+// // import { Orchestrator } from "./llm/orchestrator";
+// configDotenv();
 // interface HoneypotParams {
 //   address: string;
 //   chainName?: string;
@@ -329,100 +319,44 @@
 //     }
 //   },
 // };
-// const RSS_FEEDS = [
-//   "https://www.investing.com/rss/news_301.rss",
-//   "https://cointelegraph.com/rss/category/analysis",
-//   "https://cointelegraph.com/rss/category/top-10-cryptocurrencies",
-// ];
-// const parser = new Parser();
-// function stripHtmlTags(content: string): string {
-//   if (!content) return "";
-//   return content
-//     .replace(/<[^>]*>/g, "")
-//     .replace(/\n/g, "")
-//     .replace(" ", "");
-// }
-// export const getRssNews = {
-//   name: "get-news-rss",
-//   description: "Get latest news about on website",
-//   parameters: z.object({}),
-//   execute: async () => {
-//     const itemsPerSource = 5;
-//     try {
-//       const feedPromises = RSS_FEEDS.map((url) => parser.parseURL(url));
-//       const results = await Promise.allSettled(feedPromises);
-//       const successfulFeeds = results
-//         .filter(
-//           (result): result is PromiseFulfilledResult<Parser.Output<any>> => {
-//             return (
-//               result.status === "fulfilled" && result.value?.items?.length > 0
-//             );
-//           }
-//         )
-//         .map((result) => result.value);
-//       const allItems = successfulFeeds
-//         .flatMap((feed) => feed.items.slice(0, itemsPerSource))
-//         .sort((a, b) => {
-//           const dateA = a.pubDate ? new Date(a.pubDate).getTime() : 0;
-//           const dateB = b.pubDate ? new Date(b.pubDate).getTime() : 0;
-//           return dateB - dateA;
-//         })
-//         .slice(0, 5)
-//         .map((item) => ({
-//           title: item.title,
-//           content: stripHtmlTags(item.content),
-//           link: item.link,
-//           date: item.pubDate,
-//           source: item.creator || new URL(item.link).hostname,
-//         }));
-//       const result = {
-//         status: "success",
-//         items: allItems,
-//       };
-//       return result;
-//     } catch (error: any) {
-//       throw error;
-//     }
-//   },
-// };
 // (async () => {
-//   const cacheMemory = new CacheMemory();
-//   const memory = new PersistentMemory({
-//     host: "http://localhost:7700",
-//     apiKey: "aSampleMasterKey",
-//   });
-//   const orchestrator = new Orchestrator({
-//     id: "1",
-//     tools: [
-//       prepareEvmTransaction,
-//       checkHoneypot,
-//       getChainsTVL,
-//       getRssNews,
-//       {
-//         name: "hello",
-//         description: "hello",
-//         parameters: z.object({
-//           name: z.string(),
-//         }),
-//         execute: async () => {
-//           console.log("hello");
-//         },
-//       },
-//     ],
-//     memory: {
-//       persistent: memory,
-//       cache: cacheMemory,
-//     },
-//   });
-//   const securityInterpreter = new Interpreter(
-//     "security",
-//     securityInterpreterContext
-//   );
-//   const marketInterpreter = new Interpreter("market", marketInterpreterContext);
-//   const generalInterpreter = new Interpreter(
-//     "general",
-//     generalInterpreterContext
-//   );
+//   // const cacheMemory = new CacheMemory();
+//   // const memory = new PersistentMemory({
+//   //   host: "http://localhost:7700",
+//   //   apiKey: "aSampleMasterKey",
+//   // });
+//   // const orchestrator = new Orchestrator({
+//   //   id: "1",
+//   //   tools: [
+//   //     prepareEvmTransaction,
+//   //     checkHoneypot,
+//   //     getChainsTVL,
+//   //     getRssNews,
+//   //     {
+//   //       name: "hello",
+//   //       description: "hello",
+//   //       parameters: z.object({
+//   //         name: z.string(),
+//   //       }),
+//   //       execute: async () => {
+//   //         console.log("hello");
+//   //       },
+//   //     },
+//   //   ],
+//   //   memory: {
+//   //     persistent: memory,
+//   //     cache: cacheMemory,
+//   //   },
+//   // });
+//   // const securityInterpreter = new Interpreter(
+//   //   "security",
+//   //   securityInterpreterContext
+//   // );
+//   // const marketInterpreter = new Interpreter("market", marketInterpreterContext);
+//   // const generalInterpreter = new Interpreter(
+//   //   "general",
+//   //   generalInterpreterContext
+//   // );
 //   // const ccacheMemory = await cacheMemory.findSimilarActions(
 //   //   "le top 3 des chaines par TVL en DeFi",
 //   //   {
@@ -433,72 +367,72 @@
 //   //   }
 //   // );
 //   // console.log("✅ RECENT_ACTIONS: ", ccacheMemory);
-//   const agent = new Agent({
-//     interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
-//     orchestrator,
-//     memory: {
-//       persistent: memory,
-//       cache: cacheMemory,
-//     },
-//     stream: false,
-//     maxEvaluatorIteration: 1,
-//   });
-//   const prompt = "tu pourrais analyser le bnb/usdt";
+//   // const agent = new Agent({
+//   //   interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+//   //   orchestrator,
+//   //   memory: {
+//   //     persistent: memory,
+//   //     cache: cacheMemory,
+//   //   },
+//   //   stream: false,
+//   //   maxEvaluatorIteration: 1,
+//   // });
+//   // const prompt = "c quoi les news";
 //   // const result = await agent.process(prompt, {});
-//   const scheduler = new ActionScheduler(
-//     new ActionQueueManager(orchestrator.tools),
-//     orchestrator,
-//     {
-//       onActionScheduled: (action: ScheduledAction) => {
-//         console.log("🗓️ Action programmée:", {
-//           id: action.id,
-//           name: action.action.name,
-//           scheduledTime: action.scheduledTime,
-//         });
-//       },
-//       onActionStart: (action: ScheduledAction) => {
-//         console.log("▶️ Action démarrée:", action.id);
-//       },
-//       onActionComplete: (action: ScheduledAction, result: any) => {
-//         console.log("✅ Action terminée:", {
-//           id: action.id,
-//           result,
-//         });
-//       },
-//       onActionFailed: (action: ScheduledAction, error: any) => {
-//         console.error("❌ Action échouée:", {
-//           id: action.id,
-//           error: error.message,
-//         });
-//       },
-//       onActionCancelled: (actionId: string) => {
-//         console.log("🚫 Action annulée:", actionId);
-//       },
-//     }
-//   );
+//   // const scheduler = new ActionScheduler(
+//   //   new ActionQueueManager(orchestrator.tools),
+//   //   orchestrator,
+//   //   {
+//   //     onActionScheduled: (action: ScheduledAction) => {
+//   //       console.log("🗓️ Action programmée:", {
+//   //         id: action.id,
+//   //         name: action.action.name,
+//   //         scheduledTime: action.scheduledTime,
+//   //       });
+//   //     },
+//   //     onActionStart: (action: ScheduledAction) => {
+//   //       console.log("▶️ Action démarrée:", action.id);
+//   //     },
+//   //     onActionComplete: (action: ScheduledAction, result: any) => {
+//   //       console.log("✅ Action terminée:", {
+//   //         id: action.id,
+//   //         result,
+//   //       });
+//   //     },
+//   //     onActionFailed: (action: ScheduledAction, error: any) => {
+//   //       console.error("❌ Action échouée:", {
+//   //         id: action.id,
+//   //         error: error.message,
+//   //       });
+//   //     },
+//   //     onActionCancelled: (actionId: string) => {
+//   //       console.log("🚫 Action annulée:", actionId);
+//   //     },
+//   //   }
+//   // );
 //   // Test du scheduler
-//   console.log("🕒 Testing scheduler...");
-//   const scheduledTime = new Date(Date.now() + 10000);
-//   const actionId = await scheduler.scheduleAction(
-//     {
-//       name: "hello",
-//       description: "hello",
-//       parameters: z.object({
-//         name: z.string(),
-//       }),
-//       execute: async () => {
-//         console.log("hello");
-//         return "Hello executed!";
-//       },
-//     },
-//     scheduledTime,
-//     "user123",
-//     {
-//       type: "daily",
-//       interval: 1,
-//     }
-//   );
-//   // Attendre 15 secondes
-//   await new Promise((resolve) => setTimeout(resolve, 15000));
-//   console.log("✅ Test terminé");
+//   // console.log("🕒 Testing scheduler...");
+//   // const scheduledTime = new Date(Date.now() + 10000);
+//   // const actionId = await scheduler.scheduleAction(
+//   //   {
+//   //     name: "hello",
+//   //     description: "hello",
+//   //     parameters: z.object({
+//   //       name: z.string(),
+//   //     }),
+//   //     execute: async () => {
+//   //       console.log("hello");
+//   //       return "Hello executed!";
+//   //     },
+//   //   },
+//   //   scheduledTime,
+//   //   "user123",
+//   //   {
+//   //     type: "daily",
+//   //     interval: 1,
+//   //   }
+//   // );
+//   // // Attendre 15 secondes
+//   // await new Promise((resolve) => setTimeout(resolve, 15000));
+//   // console.log("✅ Test terminé");
 // })();

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { Embedding, StreamTextResult } from "ai";
+import { Embedding, EmbeddingModel, StreamTextResult } from "ai";
 import { z } from "zod";
 export interface BaseLLM {
     process: (prompt: string) => Promise<string | object>;
@@ -118,20 +118,41 @@ export interface SummarizerAgent {
     streamProcess: (results: object, onFinish?: (event: any) => void) => Promise<StreamTextResult<Record<string, any>>>;
 }
 export interface CacheMemoryOptions {
+    embeddingModel: EmbeddingModel<string>;
     cacheTTL?: number;
     redisUrl?: string;
     cachePrefix?: string;
 }
+export type GenerateObjectResponse = {
+    shouldContinue: boolean;
+    actions: Array<{
+        name: string;
+        parameters: Array<{
+            name: string;
+            value: any;
+        }>;
+        scheduler?: {
+            isScheduled: boolean;
+            cronExpression: string;
+            reason?: string;
+        };
+    }>;
+    socialResponse?: {
+        shouldRespond: boolean;
+        response?: string;
+        isPartialResponse?: boolean;
+    };
+    interpreter?: string;
+};
 export interface CreateMemoryInput {
-    content: any;
-    type: MemoryType;
-    data: string[];
+    query: string;
+    data: any;
     userId?: string;
     scope?: MemoryScope;
+    ttl?: number;
 }
 export interface CacheMemoryType {
     id: string;
-    type: MemoryType;
     data: any;
     query: string;
     embedding: Embedding;
@@ -149,14 +170,15 @@ export interface MemoryChunk {
     embedding: number[];
 }
 export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
-export interface Memory {
+export interface LongTermMemory {
     id: string;
     query: string;
-    purpose: string;
+    category: string;
     data: any;
     roomId: string;
     createdAt: Date;
     chunks?: MemoryChunk[];
+    tags: string[];
 }
 export declare const ActionSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
@@ -225,3 +247,12 @@ export interface ScheduledActionEvents {
     onActionScheduled?: (action: ScheduledAction) => void;
     onActionCancelled?: (actionId: string) => void;
 }
+export interface WorkflowPattern {
+    query: string;
+    actions: Array<{
+        done: boolean;
+        name: string;
+        result: string;
+    }>;
+    success: boolean;
+}

package/dist/utils/generate-object.d.ts

@@ -0,0 +1,12 @@
+import { LanguageModelV1 } from "ai";
+import { z } from "zod";
+export declare const describeZodSchema: (schema: z.ZodType) => string;
+export declare const generateObject: <T>(config: {
+    model: LanguageModelV1;
+    schema: z.ZodSchema;
+    prompt: string;
+    system: string;
+    temperature: number;
+}) => Promise<{
+    object: T;
+}>;

package/dist/utils/generate-object.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateObject = exports.describeZodSchema = void 0;
+const ai_1 = require("ai");
+const zod_1 = require("zod");
+const describeZodSchema = (schema) => {
+    if (schema instanceof zod_1.z.ZodObject) {
+        const entries = Object.entries(schema.shape);
+        const fields = entries.map(([key, value]) => {
+            const description = value._def.description || "";
+            const fieldSchema = (0, exports.describeZodSchema)(value);
+            return description
+                ? `${key}: ${fieldSchema} // ${description}`
+                : `${key}: ${fieldSchema}`;
+        });
+        return `z.object({${fields.join(", ")}})`;
+    }
+    if (schema instanceof zod_1.z.ZodArray) {
+        return `z.array(${(0, exports.describeZodSchema)(schema.element)})`;
+    }
+    if (schema instanceof zod_1.z.ZodString) {
+        return "z.string()";
+    }
+    if (schema instanceof zod_1.z.ZodNumber) {
+        return "z.number()";
+    }
+    if (schema instanceof zod_1.z.ZodBoolean) {
+        return "z.boolean()";
+    }
+    if (schema instanceof zod_1.z.ZodOptional) {
+        return `z.optional(${(0, exports.describeZodSchema)(schema._def.innerType)})`;
+    }
+    if (schema instanceof zod_1.z.ZodUnion) {
+        return `z.union([${schema._def.options
+            .map((option) => (0, exports.describeZodSchema)(option))
+            .join(", ")}])`;
+    }
+    if (schema instanceof zod_1.z.ZodEnum) {
+        return `z.enum(${JSON.stringify(schema._def.values)})`;
+    }
+    if (schema instanceof zod_1.z.ZodLiteral) {
+        return `z.literal(${JSON.stringify(schema._def.value)})`;
+    }
+    return "z.unknown()"; // Fallback for unknown types
+};
+exports.describeZodSchema = describeZodSchema;
+const generateObject = async (config) => {
+    // Generate a detailed description of the schema
+    const schemaDescription = (0, exports.describeZodSchema)(config.schema);
+    console.log("🔍 Schema Description:\n", schemaDescription);
+    const response = await (0, ai_1.generateText)({
+        model: config.model,
+        prompt: `${config.prompt}
+  
+  EXPECTED SCHEMA:
+  ${schemaDescription}
+  
+  BAD EXAMPLE:
+  \`\`\`json
+  {
+    "key": "value"
+  }
+  \`\`\`
+  
+  GOOD EXAMPLE:
+  {
+    "key": "value"
+  }
+  
+  Output only the JSON schema, no 'triple quotes'json or any other text. Only the JSON schema.
+  `,
+        system: config.system,
+        temperature: config.temperature,
+    });
+    try {
+        // Clean the response text from any markdown or code block markers
+        const cleanText = response.text
+            .replace(/```json\s*/g, "")
+            .replace(/```\s*$/g, "")
+            .trim();
+        const parsedResponse = JSON.parse(cleanText);
+        const validatedResponse = config.schema.parse(parsedResponse);
+        return { object: validatedResponse };
+    }
+    catch (error) {
+        console.error("Error parsing or validating JSON response:", error);
+        throw new Error("Failed to generate valid JSON response");
+    }
+};
+exports.generateObject = generateObject;

package/dist/utils/header-builder.d.ts

@@ -0,0 +1,11 @@
+type HeaderValue = string | string[] | undefined;
+export declare class LLMHeaderBuilder {
+    private headers;
+    private _result;
+    constructor();
+    addHeader(key: string, value: HeaderValue): LLMHeaderBuilder;
+    valueOf(): string;
+    toString(): string;
+    static create(): LLMHeaderBuilder;
+}
+export {};

package/dist/utils/header-builder.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMHeaderBuilder = void 0;
+class LLMHeaderBuilder {
+    constructor() {
+        this.headers = new Map();
+        this._result = "";
+    }
+    addHeader(key, value) {
+        if (Array.isArray(value)) {
+            this.headers.set(key, value.join("\n"));
+        }
+        else {
+            this.headers.set(key, value);
+        }
+        // Build result immediately
+        this._result = Array.from(this.headers.entries())
+            .filter(([_, value]) => value !== undefined)
+            .map(([key, value]) => `# ${key}: ${value}`)
+            .join("\n")
+            .trim();
+        return this;
+    }
+    valueOf() {
+        return this._result;
+    }
+    toString() {
+        return this._result;
+    }
+    static create() {
+        return new LLMHeaderBuilder();
+    }
+}
+exports.LLMHeaderBuilder = LLMHeaderBuilder;

package/dist/utils/inject-actions.js

@@ -5,8 +5,8 @@ const injectActions = (actions) => {
     return actions.map((action) => {
         const parameters = action.parameters;
         const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-        const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments (STRICTLY REQUIRED): { ${schemaShape} } ${action.examples
-            ? `Format examples (MUST RESPECT): ${action.examples.map((example) => {
+        const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments: { ${schemaShape} } ${action.examples
+            ? `Format examples: ${action.examples.map((example) => {
                 return JSON.stringify(example);
             })}`
             : ""}`;

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

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

package/dist/utils/schema-generator.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export interface SchemaConfig {
+    schema: z.ZodType;
+    instructions?: string;
+    outputExamples?: {
+        input: string;
+        output: string;
+    }[];
+}
+export declare class SchemaGenerator {
+    static generate(config: SchemaConfig): {
+        schema: string;
+        instructions: string;
+        outputExamples: string;
+    };
+}

package/dist/utils/schema-generator.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaGenerator = void 0;
+const zod_1 = require("zod");
+class SchemaGenerator {
+    static generate(config) {
+        const { schema, instructions = "Output only the JSON schema, no 'triple quotes'json or any other text. Only the JSON schema.", outputExamples = [], } = config;
+        const getSchemaString = (schema) => {
+            if (schema instanceof zod_1.z.ZodObject) {
+                const entries = Object.entries(schema.shape);
+                const fields = entries.map(([key, value]) => {
+                    const description = value._def.description;
+                    const schemaStr = getSchemaString(value);
+                    return description
+                        ? `${key}: ${schemaStr} // ${description}`
+                        : `${key}: ${schemaStr}`;
+                });
+                return `z.object({${fields.join(", ")}})`;
+            }
+            if (schema instanceof zod_1.z.ZodArray) {
+                return `z.array(${getSchemaString(schema.element)})`;
+            }
+            if (schema instanceof zod_1.z.ZodString) {
+                return "z.string()";
+            }
+            if (schema instanceof zod_1.z.ZodNumber) {
+                return "z.number()";
+            }
+            if (schema instanceof zod_1.z.ZodBoolean) {
+                return "z.boolean()";
+            }
+            // Fallback for other Zod types
+            return `z.unknown()`;
+        };
+        const schemaString = getSchemaString(schema);
+        return {
+            schema: schemaString,
+            instructions,
+            outputExamples: outputExamples
+                .map((example) => `Input: ${JSON.stringify(example.input)}, Output: ${JSON.stringify(example.output)}`)
+                .join("\n")
+                .trim(),
+        };
+    }
+}
+exports.SchemaGenerator = SchemaGenerator;