@ai.ntellect/core 0.3.1 → 0.4.0

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,15 +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;
-    scope: MemoryScopeType;
-    userId?: string;
+    roomId: string;
     createdAt: Date;
     chunks?: MemoryChunk[];
+    tags: string[];
 }
 export declare const ActionSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
@@ -205,3 +226,33 @@ export interface TransformedQueueItem {
     name: string;
     parameters: QueueItemParameter[];
 }
+export interface ScheduledAction {
+    id: string;
+    action: {
+        name: string;
+        parameters: QueueItemParameter[];
+    };
+    scheduledTime: Date;
+    userId: string;
+    status: "pending" | "completed" | "failed";
+    recurrence?: {
+        type: "daily" | "weekly" | "monthly";
+        interval: number;
+    };
+}
+export interface ScheduledActionEvents {
+    onActionStart?: (action: ScheduledAction) => void;
+    onActionComplete?: (action: ScheduledAction, result: any) => void;
+    onActionFailed?: (action: ScheduledAction, error: Error) => void;
+    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;

package/examples/index.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import { deepseek } from "@ai-sdk/deepseek";
+import { configDotenv } from "dotenv";
+import readline from "readline";
+import { Agent } from "../agent";
+import { getRssNews } from "../agent/tools/get-rss";
+import { Interpreter } from "../llm/interpreter";
+import {
+  generalInterpreterCharacter,
+  marketInterpreterCharacter,
+  securityInterpreterCharacter,
+} from "../llm/interpreter/context";
+configDotenv();
+// Initialiser l'agent une fois pour toute la session
+const initializeAgent = () => {
+  const model = deepseek("deepseek-reasoner");
+
+  const securityInterpreter = new Interpreter({
+    name: "security",
+    model,
+    character: securityInterpreterCharacter,
+  });
+  const marketInterpreter = new Interpreter({
+    name: "market",
+    model,
+    character: marketInterpreterCharacter,
+  });
+  const generalInterpreter = new Interpreter({
+    name: "general",
+    model,
+    character: generalInterpreterCharacter,
+  });
+
+  const agent = new Agent({
+    cache: {
+      host: process.env.REDIS_HOST || "localhost",
+      port: Number(process.env.REDIS_PORT) || 6379,
+    },
+    orchestrator: {
+      model,
+      tools: [getRssNews],
+    },
+    interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+    memoryManager: {
+      model,
+    },
+    maxIterations: 3,
+  });
+
+  return agent;
+};
+
+// Fonction pour lancer une session interactive
+const startChatSession = async () => {
+  console.log("Bienvenue dans votre session de chat avec l'agent !");
+  console.log("Tapez 'exit' pour quitter.\n");
+
+  const agent = initializeAgent();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "Vous > ",
+  });
+
+  let state = {
+    currentContext: "",
+    previousActions: [],
+  };
+
+  rl.prompt();
+
+  rl.on("line", async (line) => {
+    const input = line.trim();
+
+    if (input.toLowerCase() === "exit") {
+      console.log("Fin de la session. À bientôt !");
+      rl.close();
+      return;
+    }
+
+    state.currentContext = input;
+
+    console.log("Agent en réflexion...");
+    try {
+      const result = await agent.process(state);
+      console.log(`Agent > ${result}\n`);
+    } catch (error) {
+      console.error("Erreur avec l'agent :", error);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    console.log("Session terminée.");
+    process.exit(0);
+  });
+};
+
+// Lancer la session de chat
+startChatSession();

package/llm/interpreter/context.ts

@@ -1,15 +1,28 @@
-export const generalInterpreterContext = {
+export type Character = {
+  role: string;
+  language: string;
+  guidelines: {
+    important: string[];
+    warnings: string[];
+  };
+  examplesMessages?: {
+    role: string;
+    content: string;
+  }[];
+};
+
+export const generalInterpreterCharacter: Character = {
   role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-  language: "same_as_user",
+  language: "user_request",
   guidelines: {
     important: [],
     warnings: [],
   },
 };
 
-export const securityInterpreterContext = {
+export const securityInterpreterCharacter: Character = {
   role: "You are the security expert. Your role is to provide a clear and factual analysis of the security of the token/coin.",
-  language: "user_language",
+  language: "user_request",
   guidelines: {
     important: [
       "Start with a clear security analysis of the token/coin.",
@@ -47,12 +60,12 @@ export const securityInterpreterContext = {
   ],
 };
 
-export const marketInterpreterContext = {
+export const marketInterpreterCharacter: Character = {
   role: "You are the market expert. Your role is to provide a clear and factual analysis of the market sentiment of the token/coin.",
-  language: "user_language",
+  language: "user_request",
   guidelines: {
     important: [
-      "Start with a clear market sentiment (Bullish/Bearish/Neutral) without any additional comments before.",
+      "Start with a clear market sentiment (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",
@@ -60,7 +73,6 @@ export const marketInterpreterContext = {
     warnings: [
       "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",
     ],
   },
   examplesMessages: [

package/llm/interpreter/index.ts

@@ -1,33 +1,75 @@
-import { openai } from "@ai-sdk/openai";
-import { generateObject, streamText, StreamTextResult } from "ai";
+import { LanguageModel, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
 import { Behavior, State } from "../../types";
+import { generateObject } from "../../utils/generate-object";
+import { LLMHeaderBuilder } from "../../utils/header-builder";
+
+const interpreterSchema = z.object({
+  requestLanguage: z
+    .string()
+    .describe("The language of the user's request (fr, en, es, etc.)"),
+  actionsCompleted: z
+    .array(
+      z.object({
+        name: z.string(),
+        reasoning: z.string(),
+      })
+    )
+    .describe("The actions done and why."),
+  response: z.string().describe("The response to the user's request."),
+});
+
+interface InterpretationResult {
+  actionsCompleted: {
+    name: string;
+    reasoning: string;
+  }[];
+  response: string;
+}
 
 export class Interpreter {
-  private readonly model = openai("gpt-4o");
+  public readonly model: LanguageModel;
   public readonly name: string;
+  public readonly character: Behavior;
 
-  constructor(name: string, private readonly behavior: Behavior) {
+  constructor({
+    name,
+    model,
+    character,
+  }: {
+    name: string;
+    model: LanguageModel;
+    character: Behavior;
+  }) {
     this.name = name;
-    this.behavior = behavior;
+    this.model = model;
+    this.character = character;
   }
 
-  composeContext(state: State) {
+  private buildContext(state: State) {
     const { userRequest, results } = state;
-    const { role, language, guidelines, examplesMessages } = this.behavior;
-
+    const { role, language, guidelines } = this.character;
     const { important, warnings, steps } = guidelines;
 
-    const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # NEVER: ${warnings.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # CURRENT_RESULTS: ${results}
-      # STEPS: ${steps?.join("\n") || ""}
-      # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
-    `;
+    const context = LLMHeaderBuilder.create();
+
+    if (role) {
+      context.addHeader("ROLE", role);
+    }
+
+    if (language) {
+      context.addHeader("LANGUAGE", language);
+    }
+
+    if (important.length > 0) {
+      context.addHeader("IMPORTANT", important);
+    }
+
+    if (warnings.length > 0) {
+      context.addHeader("NEVER", warnings);
+    }
+
+    context.addHeader("CURRENT_RESULTS", results);
     return context;
   }
 
@@ -45,43 +87,27 @@ export class Interpreter {
       }
     | StreamTextResult<Record<string, any>>
   > {
-    console.log("\n🎨 Starting interpretation process");
-    console.log("Prompt:", prompt);
-    console.log("Results to interpret:", JSON.stringify(state, null, 2));
+    try {
+      console.log("\n🎨 Starting interpretation process");
+      console.log("Prompt:", prompt);
+      console.log("Results to interpret:", JSON.stringify(state, null, 2));
 
-    const context = this.composeContext(state);
-
-    const result = await generateObject({
-      model: this.model,
-      schema: z.object({
-        requestLanguage: z.string(),
-        actionsCompleted: z.array(
-          z.object({
-            name: z.string(),
-            reasoning: z.string(),
-          })
-        ),
-        response: z.string(),
-      }),
-      prompt,
-      system: context,
-    });
-
-    console.log("\n✅ Interpretation completed");
-    console.log("─".repeat(50));
-    console.log("Generated response:", result.object);
-
-    if (result.object.actionsCompleted.length > 0) {
-      console.log("\n📋 Suggested actions:");
-      result.object.actionsCompleted.forEach((action, index) => {
-        console.log(`\n${index + 1}. Action Details:`);
-        console.log(`   Name: ${action.name}`);
-        console.log(`   Reasoning: ${action.reasoning}`);
+      const context = this.buildContext(state);
+      console.log("Context:", context.toString());
+      const result = await generateObject<InterpretationResult>({
+        model: this.model,
+        prompt,
+        system: context.toString(),
+        temperature: 1.3,
+        schema: interpreterSchema,
       });
-    }
 
-    if (onFinish) onFinish(result.object);
-    return result.object;
+      if (onFinish) onFinish(result.object);
+      return result.object;
+    } catch (error) {
+      console.error("Error parsing schema:", error);
+      throw error;
+    }
   }
 
   async streamProcess(
@@ -92,7 +118,7 @@ export class Interpreter {
     console.log("\n🎨 Starting streaming interpretation");
     console.log("Prompt:", prompt);
 
-    const context = this.composeContext(state);
+    const context = this.buildContext(state);
 
     const result = await streamText({
       model: this.model,
@@ -101,7 +127,8 @@ export class Interpreter {
         if (onFinish) onFinish(event);
       },
       prompt,
-      system: context,
+      system: context.toString(),
+      temperature: 1.3,
     });
 
     return result;