@ai.ntellect/core 0.6.16 → 0.6.19

package/dist/utils/generate-object.js

@@ -1,111 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.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 = (config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // Generate a detailed description of the schema
-    const schemaDescription = (0, exports.describeZodSchema)(config.schema);
-    const baseContext = `
-  ${config.system}
-  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.
-  `;
-    console.log("🔍 Generating object with context:");
-    console.log(`${config.prompt}\n${baseContext}\n`);
-    const response = yield (0, ai_1.generateText)({
-        model: config.model,
-        messages: !config.prompt
-            ? [
-                {
-                    role: "system",
-                    content: baseContext,
-                },
-                ...((_a = config.messages) !== null && _a !== void 0 ? _a : []),
-            ]
-            : undefined,
-        system: config.system,
-        temperature: config.temperature,
-        prompt: !config.prompt ? undefined : `${config.prompt}\n\n${baseContext}`,
-    });
-    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/inject-actions.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectActions = void 0;
-const injectActions = (actions) => {
-    return actions.map((action) => {
-        const parameters = action.parameters;
-        const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-        const actionString = `* ${action.name}( { ${schemaShape} }) (${action.description}) ${action.examples
-            ? `Eg: ${action.examples.map((example) => {
-                return JSON.stringify(example);
-            })}`
-            : ""}`;
-        return actionString;
-    });
-};
-exports.injectActions = injectActions;

package/dist/utils/queue-item-transformer.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueItemTransformer = void 0;
-class QueueItemTransformer {
-    static transformActionToQueueItem(action) {
-        return {
-            name: action.name || "",
-            parameters: QueueItemTransformer.transformParameters(action.parameters || {}),
-        };
-    }
-    static transformFromSimilarActions(similarActions) {
-        return similarActions === null || similarActions === void 0 ? void 0 : similarActions.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
-    }
-    static transformParameters(parameters) {
-        return Object.entries(parameters).map(([name, value]) => ({
-            name,
-            value: typeof value === "object" ? JSON.stringify(value) : String(value),
-        }));
-    }
-    static transformActionsToQueueItems(actions) {
-        return actions === null || actions === void 0 ? void 0 : actions.map((action) => this.transformActionToQueueItem(action));
-    }
-}
-exports.QueueItemTransformer = QueueItemTransformer;

package/dist/utils/sanitize-results.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResultSanitizer = void 0;
-/**
- * Utility class to sanitize JSON results for evaluation
- */
-class ResultSanitizer {
-    /**
-     * Sanitizes JSON results by removing special characters and formatting
-     * @param results - The results to sanitize
-     * @returns Sanitized string
-     */
-    static sanitize(results) {
-        if (!results)
-            return "";
-        try {
-            const jsonString = JSON.stringify(results);
-            return (jsonString
-                // Basic cleanup
-                .replace(/\\n/g, " ") // Remove newlines
-                .replace(/\s+/g, " ") // Remove extra spaces
-                .replace(/\\"/g, '"') // Fix escaped quotes
-                .replace(/\\+/g, "") // Remove extra backslashes
-                // Remove unnecessary quotes around objects and arrays
-                .replace(/"\[/g, "[") // Remove quotes around arrays start
-                .replace(/\]"/g, "]") // Remove quotes around arrays end
-                .replace(/"{/g, "{") // Remove quotes around objects start
-                .replace(/}"/g, "}") // Remove quotes around objects end
-                // Clean up numbers and values
-                .replace(/"(\d+\.?\d*)"/g, "$1") // Remove quotes around numbers
-                .replace(/:\s*"(true|false|null)"/g, ": $1") // Remove quotes around booleans and null
-                // Clean up URLs and content
-                .replace(/(?<=content":")([^"]+)(?=")/g, (match) => match.trim().replace(/\s+/g, " ") // Clean content spacing
-            )
-                .replace(/(?<=link":")([^"]+)(?=")/g, (match) => match.replace(/&amp;/g, "&") // Fix URL encodings
-            )
-                // Final cleanup
-                .replace(/,\s*([}\]])/g, "$1") // Remove trailing commas
-                .replace(/:\s+/g, ":") // Remove spaces after colons
-                .replace(/,\s+/g, ",") // Remove spaces after commas
-                .trim()); // Remove leading/trailing whitespace
-        }
-        catch (error) {
-            console.error("Error sanitizing results:", error);
-            return String(results);
-        }
-    }
-    /**
-     * Formats numbers to a consistent format
-     * @param value - The number to format
-     * @returns Formatted number string
-     */
-    static formatNumber(value) {
-        return value.toLocaleString("en-US", {
-            maximumFractionDigits: 2,
-            useGrouping: false,
-        });
-    }
-}
-exports.ResultSanitizer = ResultSanitizer;

package/graph/graph.ts

@@ -1,193 +0,0 @@
-import { GraphConfig, GraphContext, GraphDefinition, Node } from "@/types";
-import EventEmitter from "events";
-import { ZodSchema } from "zod";
-
-export class Graph<T extends ZodSchema> {
-  private nodes: Map<string, Node<T>>;
-  private context: GraphContext<T>;
-  public validator?: T;
-  private eventEmitter: EventEmitter;
-  private globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
-
-  constructor(public name: string, config: GraphConfig<T>) {
-    this.nodes = new Map(config.nodes.map((node) => [node.name, node]));
-    this.context = config.initialContext || ({} as GraphContext<T>);
-    this.validator = config.validator;
-    this.globalErrorHandler = config.globalErrorHandler;
-    this.eventEmitter = new EventEmitter();
-    this.setupEventListeners();
-  }
-
-  private createNewContext(): GraphContext<T> {
-    return structuredClone(this.context);
-  }
-
-  private setupEventListeners(): void {
-    for (const node of this.nodes.values()) {
-      node.events?.forEach((event) => {
-        this.eventEmitter.on(event, async (data?: Partial<GraphContext<T>>) => {
-          const context = this.createNewContext();
-          if (data) Object.assign(context, data);
-          await this.executeNode(node.name, context);
-        });
-      });
-    }
-  }
-  private async executeNode(
-    nodeName: string,
-    context: GraphContext<T>,
-    params?: any
-  ): Promise<void> {
-    const node = this.nodes.get(nodeName);
-    if (!node) throw new Error(`❌ Node ${nodeName} not found`);
-
-    if (node.condition && !node.condition(context)) return;
-
-    let attempts = 0;
-    const maxAttempts = node.retry?.maxAttempts || 1;
-    const delay = node.retry?.delay || 0;
-
-    while (attempts < maxAttempts) {
-      try {
-        let validatedParams;
-
-        // ✅ Si le nœud a un `parameters`, on valide `params` avant exécution
-        if (node.parameters) {
-          if (!params) {
-            throw new Error(
-              `❌ Paramètres requis pour le nœud "${nodeName}" mais reçus: ${params}`
-            );
-          }
-          validatedParams = node.parameters.parse(params);
-        }
-
-        this.eventEmitter.emit("nodeStarted", { name: nodeName, context });
-        if (node.execute) {
-          await node.execute(context);
-        } else if (node.executeWithParams) {
-          if (!validatedParams) {
-            throw new Error(
-              `❌ Paramètres invalides pour le nœud "${nodeName}"`
-            );
-          }
-          await node.executeWithParams(context, validatedParams);
-        }
-
-        this.validateContext(context);
-
-        this.eventEmitter.emit("nodeCompleted", { name: nodeName, context });
-
-        if (node.next) {
-          await Promise.all(
-            node.next.map((nextNode) => this.executeNode(nextNode, context))
-          );
-        }
-        return;
-      } catch (error) {
-        attempts++;
-
-        if (attempts >= maxAttempts) {
-          this.eventEmitter.emit("nodeError", { nodeName, error });
-          node.onError?.(error as Error);
-          this.globalErrorHandler?.(error as Error, context);
-          throw error;
-        }
-
-        console.warn(
-          `[Graph ${this.name}] Retry attempt ${attempts} for node ${nodeName}`,
-          { error }
-        );
-
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-
-  private validateContext(context: GraphContext<T>): void {
-    if (this.validator) {
-      this.validator.parse(context);
-    }
-  }
-
-  async execute(
-    startNode: string,
-    inputContext?: Partial<GraphContext<T>>,
-    inputParams?: any
-  ): Promise<GraphContext<T>> {
-    const context = this.createNewContext();
-    if (inputContext) Object.assign(context, inputContext);
-
-    this.eventEmitter.emit("graphStarted", { name: this.name });
-    try {
-      await this.executeNode(startNode, context, inputParams);
-      this.eventEmitter.emit("graphCompleted", { name: this.name, context });
-      return context;
-    } catch (error) {
-      this.eventEmitter.emit("graphError", { name: this.name, error });
-      this.globalErrorHandler?.(error as Error, context); // Gestionnaire d'erreurs global
-      throw error;
-    }
-  }
-
-  emit(
-    eventName: string,
-    data?: Partial<GraphContext<T>>
-  ): Promise<GraphContext<T>> {
-    return new Promise((resolve, reject) => {
-      if (data) Object.assign(this.context, data); // ✅ Met à jour le contexte global
-
-      this.eventEmitter.emit(eventName, this.context); // Utilise le contexte global
-
-      const eventNodes = Array.from(this.nodes.values()).filter((node) =>
-        node.events?.includes(eventName)
-      );
-      if (eventNodes.length === 0) return resolve(this.context);
-
-      Promise.all(
-        eventNodes.map(
-          (node) =>
-            new Promise<void>((resolve) => {
-              this.eventEmitter.once("nodeCompleted", ({ nodeName }) => {
-                if (nodeName === node.name) resolve();
-              });
-            })
-        )
-      )
-        .then(() => resolve(this.context))
-        .catch(reject);
-    });
-  }
-
-  on(eventName: string, handler: (...args: any[]) => void): void {
-    this.eventEmitter.on(eventName, handler);
-  }
-
-  loadDefinition(definition: GraphDefinition<T>): void {
-    this.nodes.clear();
-    Object.values(definition.nodes).forEach((node) =>
-      this.nodes.set(node.name, node)
-    );
-    this.setupEventListeners();
-  }
-
-  getContext(): GraphContext<T> {
-    return structuredClone(this.context);
-  }
-
-  log(message: string, data?: any): void {
-    console.log(`[Graph ${this.name}] ${message}`, data);
-  }
-
-  addNode(node: Node<T>): void {
-    this.nodes.set(node.name, node);
-    this.setupEventListeners();
-  }
-
-  removeNode(nodeName: string): void {
-    this.nodes.delete(nodeName);
-  }
-
-  getNodes(): Node<T>[] {
-    return Array.from(this.nodes.values());
-  }
-}

package/memory/adapters/redis/index.ts

@@ -1,103 +0,0 @@
-import { BaseMemoryService } from "@/interfaces";
-import { BaseMemoryType } from "@/types";
-import { createClient } from "redis";
-
-export class RedisAdapter implements BaseMemoryService {
-  private redis;
-  private readonly cachePrefix: string;
-  private readonly cacheTTL: number;
-
-  constructor(
-    private readonly redisUrl: string,
-    options: {
-      cachePrefix?: string;
-      cacheTTL?: number;
-    }
-  ) {
-    this.cachePrefix = options.cachePrefix || "memory:";
-    this.cacheTTL = options.cacheTTL || 3600;
-    this.redis = createClient({
-      url: redisUrl,
-      socket: {
-        tls: true,
-        rejectUnauthorized: true,
-      },
-    });
-  }
-
-  async initializeConnection(): Promise<void> {
-    this.redis.on("error", (err) => console.error("Redis Client Error:", err));
-    await this.redis.connect();
-  }
-
-  async createMemory(memory: BaseMemoryType, ttl?: number): Promise<void> {
-    const key = memory.roomId
-      ? `${this.cachePrefix}${memory.roomId}:${memory.id}`
-      : `${this.cachePrefix}${memory.id}`;
-
-    await this.redis.set(key, JSON.stringify(memory), {
-      EX: ttl || this.cacheTTL,
-    });
-  }
-
-  async getMemoryById(
-    id: string,
-    roomId?: string
-  ): Promise<BaseMemoryType | null> {
-    const key = roomId
-      ? `${this.cachePrefix}${roomId}:${id}`
-      : `${this.cachePrefix}${id}`;
-
-    const data = await this.redis.get(key);
-    return data ? JSON.parse(data) : null;
-  }
-
-  async getMemoryByIndex(
-    query: string,
-    options: {
-      roomId?: string;
-      limit?: number;
-    } = {}
-  ): Promise<BaseMemoryType[]> {
-    const pattern = options.roomId
-      ? `${this.cachePrefix}${options.roomId}:*`
-      : `${this.cachePrefix}*`;
-
-    const keys = await this.redis.keys(pattern);
-    const memories = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-    return memories.filter(Boolean).slice(0, options.limit || 10);
-  }
-
-  async getAllMemories(): Promise<BaseMemoryType[]> {
-    const keys = await this.redis.keys(`${this.cachePrefix}*`);
-    const memories = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-    return memories.filter(Boolean);
-  }
-
-  async clearMemoryById(id: string): Promise<void> {
-    await this.redis.del(`${this.cachePrefix}${id}`);
-  }
-
-  async clearAllMemories(): Promise<void> {
-    const keys = await this.redis.keys(`${this.cachePrefix}*`);
-    if (keys.length > 0) {
-      await this.redis.del(keys);
-    }
-  }
-
-  async quit(): Promise<void> {
-    if (this.redis) {
-      await this.redis.quit();
-    }
-  }
-}

package/memory/index.ts

@@ -1,22 +0,0 @@
-import { BaseMemoryService } from "@/interfaces";
-import { BaseMemoryType, CreateMemoryInput } from "@/types";
-
-export abstract class BaseMemory {
-  constructor(protected readonly cacheService: BaseMemoryService) {}
-
-  abstract init(): Promise<void>;
-  abstract createMemory(
-    input: CreateMemoryInput & { embedding?: number[] }
-  ): Promise<BaseMemoryType | undefined>;
-  abstract getMemoryById(
-    id: string,
-    roomId: string
-  ): Promise<BaseMemoryType | null>;
-  abstract getMemoryByIndex(
-    query: string,
-    options: { roomId: string; limit?: number }
-  ): Promise<BaseMemoryType[]>;
-  abstract getAllMemories(roomId: string): Promise<BaseMemoryType[]>;
-  abstract clearMemoryById(id: string, roomId: string): Promise<void>;
-  abstract clearAllMemories(): Promise<void>;
-}

package/services/agenda.ts

@@ -1,118 +0,0 @@
-import { ScheduledRequest } from "@/types";
-import cron from "node-cron";
-
-export class Agenda {
-  private scheduledRequests: Map<string, ScheduledRequest> = new Map();
-  private cronJobs: Map<string, cron.ScheduledTask> = new Map();
-
-  /**
-   * Schedule a new request to be processed later
-   */
-  async scheduleRequest(
-    request: {
-      originalRequest: string;
-      cronExpression: string;
-    },
-    callbacks?: {
-      onScheduled?: (id: string) => void;
-      onExecuted?: (id: string, originalRequest: string) => void;
-    }
-  ): Promise<string> {
-    const id = crypto.randomUUID();
-
-    const scheduledRequest: ScheduledRequest = {
-      id,
-      originalRequest: request.originalRequest,
-      cronExpression: request.cronExpression,
-      isRecurring: false,
-      createdAt: new Date(),
-    };
-
-    // Create cron job
-    const cronJob = cron.schedule(request.cronExpression, () => {
-      console.log(`🔄 Executing scheduled request: ${id}`);
-
-      if (callbacks?.onExecuted) {
-        callbacks.onExecuted(id, scheduledRequest.originalRequest);
-      }
-
-      console.log(`✅ Scheduled request executed successfully: ${id}`);
-
-      // Auto-stop pour les tâches non récurrentes
-      if (!scheduledRequest.isRecurring) {
-        this.cancelScheduledRequest(id);
-      }
-    });
-
-    // Démarrer le job en mode non-running
-    cronJob.stop();
-
-    // Store request and job
-    this.scheduledRequests.set(id, scheduledRequest);
-    this.cronJobs.set(id, cronJob);
-
-    if (callbacks?.onScheduled) callbacks.onScheduled(id);
-
-    // Démarrer le job après l'avoir stocké
-    cronJob.start();
-
-    return id;
-  }
-
-  /**
-   * Cancel a scheduled request
-   */
-  cancelScheduledRequest(requestId: string): boolean {
-    const cronJob = this.cronJobs.get(requestId);
-    if (cronJob) {
-      try {
-        cronJob.stop();
-        this.cronJobs.delete(requestId);
-        this.scheduledRequests.delete(requestId);
-        return true;
-      } catch (error) {
-        console.error(`Failed to stop cron job ${requestId}:`, error);
-        return false;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Get all scheduled requests
-   */
-  getScheduledRequests(): ScheduledRequest[] {
-    return Array.from(this.scheduledRequests.values());
-  }
-
-  /**
-   * Stop all cron jobs
-   */
-  stopAll(): void {
-    const ids = Array.from(this.cronJobs.keys());
-
-    // Arrêter tous les jobs de manière synchrone
-    for (const id of ids) {
-      const job = this.cronJobs.get(id);
-      if (job) {
-        job.stop();
-        this.cronJobs.delete(id);
-        this.scheduledRequests.delete(id);
-      }
-    }
-
-    // Double vérification
-    this.cronJobs.clear();
-    this.scheduledRequests.clear();
-  }
-
-  public async stop(): Promise<void> {
-    this.stopAll();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
-  public async cancel(query: {}): Promise<void> {
-    this.stopAll();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-}

package/services/embedding.ts

@@ -1,26 +0,0 @@
-import { EmbeddingService } from "@/interfaces";
-import { cosineSimilarity, embed, EmbeddingModel, embedMany } from "ai";
-
-export class AIEmbeddingService implements EmbeddingService {
-  constructor(private readonly model: EmbeddingModel<string>) {}
-
-  async embedText(text: string): Promise<number[]> {
-    const { embedding } = await embed({
-      model: this.model,
-      value: text,
-    });
-    return embedding;
-  }
-
-  async embedMany(texts: string[]): Promise<number[][]> {
-    const { embeddings } = await embedMany({
-      model: this.model,
-      values: texts,
-    });
-    return embeddings;
-  }
-
-  calculateSimilarity(embedding1: number[], embedding2: number[]): number {
-    return (cosineSimilarity(embedding1, embedding2) + 1) * 50;
-  }
-}