@dnax/core 0.13.5 → 0.13.7

package/app/hono.ts

@@ -238,7 +238,7 @@ function HonoInstance(): typeof app {
           action: action,
           c: c,
           isAuth: c.var?._v?.isAuth || false,
-          rest: new useRest({ tenant_id: tenant_id }),
+          rest: new useRest({ tenant_id: tenant_id, c: c }),
           session: session as any,
         });
       }
@@ -353,6 +353,7 @@ function HonoInstance(): typeof app {
 
       const rest = new useRest({
         tenant_id: c.var["tenant-id"],
+        c: c,
       });
 
       // Controlle action
@@ -363,14 +364,20 @@ function HonoInstance(): typeof app {
       // Exec service
       if (action == "execService") {
         if (!service) return fn.error("Service not found", 404);
-        response = await service.fx({
-          io: Cfg.io,
-          data: body?.data || {},
-          rest: rest,
-          error: fn.error,
-          session: sessionStorage(),
-          isAuth: c.var?._v?.isAuth || false,
-        });
+        let fx = service.exec || service.fx;
+        if (fx) {
+          response = await fx({
+            io: Cfg.io,
+            data: body?.data || {},
+            rest: rest,
+            error: fn.error,
+            session: sessionStorage(),
+            isAuth: c.var?._v?.isAuth || false,
+          });
+        } else {
+          c?.status(404);
+          return c.json({ message: "Service's function not found" });
+        }
 
         return c.json(response);
       }

package/driver/mongo/rest.ts

@@ -555,6 +555,8 @@ class useRest {
           })
           .toArray();
 
+        result.docs = toJson(result.docs);
+
         if (col?.hooks?.afterFind && useHook) {
           await col.hooks.afterFind({
             sharedData: sharedData,
@@ -572,8 +574,9 @@ class useRest {
           });
         }
 
-        let resultDocs = toJson(result.docs);
-        if (typeof options?.elementAt == "number") {
+        let resultDocs = toJson([...(result?.docs || [])]);
+
+        if (typeof options?.elementAt == "number" && options?.elementAt) {
           resultDocs = resultDocs[options?.elementAt] ?? null;
         }
         return resolve(resultDocs);

package/index.ts

@@ -4,10 +4,11 @@ import { toBson } from "./driver/mongo/utils";
 import { runApp } from "./app";
 import Joi from "joi";
 import define from "./define";
-import moment from "moment";
 import * as utils from "./utils";
 import { searchEngine } from "./lib/orama";
 import { dataCache } from "./lib/bento";
+import { ai } from "./lib/ai";
+import { crypt } from "./lib/crypto";
 
 /**
  *  v is internal data validation and based of Joi validation.
@@ -16,4 +17,4 @@ import { dataCache } from "./lib/bento";
  */
 const v = Joi;
 
-export { runApp, define, utils, useRest, v, searchEngine, dataCache };
+export { runApp, define, utils, useRest, v, dataCache, ai, crypt };

package/lib/ai/index.ts

@@ -0,0 +1,21 @@
+import { Ollama } from "./provider/ollama";
+import { CohereClient } from "./provider/cohere";
+import { Mistral } from "./provider/mistral";
+import { OpenAI } from "./provider/openai";
+import { Groq } from "./provider/groq";
+import { Agent } from "./lib/Agent";
+import { Space } from "./lib/Space";
+import { Task } from "./lib/Task";
+
+const ai = {
+  Ollama,
+  CohereClient,
+  Mistral,
+  OpenAI,
+  Groq,
+  Agent,
+  Space,
+  Task,
+};
+
+export { ai };

package/lib/ai/lib/Agent.ts

@@ -0,0 +1,159 @@
+import { Groq } from "groq-sdk";
+import { CohereClient } from "../provider/cohere";
+import { OpenAI } from "../provider/openai";
+import { Mistral } from "../provider/mistral";
+type outputFunction = (content: any) => Promise<any>;
+
+type AgentOptions = {
+  config: {
+    provider: "groq" | "cohere" | "openai" | "mistral";
+    model: string;
+    apiKey: string;
+    token?: string;
+  };
+  name?: string;
+  role: string;
+  goal: string;
+  backstory: string;
+  tools?: any[];
+  temperature?: number;
+  max_tokens?: number;
+  output_format?: "string" | "json";
+  fn: (
+    ctx: {
+      instruction: string;
+      data: object | any;
+      chat_history: any[];
+      activities: any[];
+    },
+    ai?: {
+      groq?: InstanceType<typeof Groq>;
+      cohere?: InstanceType<typeof CohereClient>;
+      openai?: InstanceType<typeof OpenAI>;
+      mistral?: InstanceType<typeof Mistral>;
+    }
+  ) => Promise<any>;
+};
+
+export type AgentType = InstanceType<typeof Agent>;
+
+class Agent {
+  public cfg: AgentOptions;
+  #groq?: InstanceType<typeof Groq>;
+  #cohere?: InstanceType<typeof CohereClient>;
+  #openai?: InstanceType<typeof OpenAI>;
+  #mistral?: InstanceType<typeof Mistral>;
+  constructor(cfg: AgentOptions) {
+    this.cfg = cfg;
+
+    // Init default value
+    if (!this.cfg.temperature) this.cfg.temperature = 0.5;
+
+    // set groq client
+    if (cfg.config.provider === "groq") {
+      this.#groq = new Groq({
+        apiKey: cfg.config.apiKey,
+      });
+    }
+
+    // set cohere client
+    if (cfg.config.provider === "cohere") {
+      this.#cohere = new CohereClient({
+        token: cfg.config.apiKey || cfg.config.token,
+      });
+    }
+
+    // set openai client
+    if (cfg.config.provider === "openai") {
+      this.#openai = new OpenAI({
+        apiKey: cfg.config.apiKey,
+      });
+    }
+
+    // set mistral client
+    if (cfg.config.provider === "mistral") {
+      this.#mistral = new Mistral({
+        apiKey: cfg.config.apiKey,
+      });
+    }
+  }
+
+  async exec(
+    instruction: string,
+    data?: object
+  ): Promise<string | object | null | Array<any>> {
+    const messages: any = [];
+    var response: any = null;
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        // Groq AI
+        if (this.#groq) {
+          response = await this.#groq.chat.completions.create({
+            messages: messages,
+            model: this.cfg.config.model,
+
+            temperature: Number(this?.cfg?.temperature),
+            tools: this.cfg?.tools || [],
+            response_format: {
+              type: this.cfg.output_format == "json" ? "json_object" : "text",
+            },
+          });
+        }
+
+        // Cohere AI
+        if (this.#cohere) {
+          response = await this.#cohere.chat({
+            chatHistory: messages,
+            message: instruction,
+            model: this.cfg.config.model,
+            temperature: Number(this?.cfg?.temperature),
+            preamble: this.cfg?.backstory || "",
+            maxTokens: Number(this?.cfg?.max_tokens),
+
+            tools: this.cfg?.tools || [],
+            responseFormat: {
+              type: this.cfg.output_format == "json" ? "json_object" : "text",
+            },
+          });
+        }
+
+        // OpenAI AI
+        if (this.#openai) {
+          response = await this.#openai.chat.completions.create({
+            max_tokens: Number(this?.cfg?.max_tokens),
+            messages: messages,
+            model: this.cfg.config.model,
+            temperature: Number(this?.cfg?.temperature),
+            tools: this.cfg?.tools || [],
+
+            response_format: {
+              type: this.cfg.output_format == "json" ? "json_object" : "text",
+            },
+          });
+        }
+
+        // Mistral AI
+        if (this.#mistral) {
+          response = await this.#mistral.chat.complete({
+            messages: messages,
+            model: this.cfg.config.model,
+            temperature: Number(this?.cfg?.temperature),
+            tools: this.cfg?.tools || [],
+            maxTokens: Number(this?.cfg?.max_tokens),
+            responseFormat: {
+              type: this.cfg.output_format == "json" ? "json_object" : "text",
+            },
+          });
+        }
+
+        resolve(response);
+      } catch (error) {
+        console?.error(error);
+        reject(error);
+      }
+    });
+  }
+}
+
+export { Agent };

package/lib/ai/lib/Space.ts

@@ -0,0 +1,34 @@
+import type { TaskType } from "./Task";
+import type { AgentType } from "./Agent";
+type SpaceOptions = {
+  name: string;
+  tasks: TaskType[];
+  agents: AgentType[];
+  arbitrator?: AgentType;
+  evaluators?: AgentType[];
+  summarizers?: AgentType[];
+};
+
+type responseType = {
+  task_name: string;
+  response: string;
+};
+
+class Space {
+  #tasks: TaskType[];
+  #agents: AgentType[];
+  #summarizers?: AgentType[];
+  #evaluator?: AgentType;
+  #arbitrator?: AgentType;
+  #activities?: any[];
+  constructor(cfg: SpaceOptions) {
+    this.#tasks = cfg.tasks;
+    this.#agents = cfg.agents;
+    this.#summarizers = cfg.summarizers;
+    this.#evaluator = cfg.evaluator;
+    this.#arbitrator = cfg.arbitrator;
+  }
+  run(content: string, data?: object) {}
+}
+
+export { Space };

package/lib/ai/lib/Task.ts

@@ -0,0 +1,19 @@
+import type { AgentType } from "./Agent";
+export type TaskType = InstanceType<typeof Task>;
+type TaskOptions = {
+  title?: string;
+  description: string;
+  expected_output: string;
+  output_format: "string" | "json" | boolean;
+  tools?: any[];
+  agent?: AgentType;
+};
+class Task {
+  public cfg: TaskOptions;
+  constructor(cfg: TaskOptions) {
+    this.cfg = cfg;
+  }
+  exec(instruction: string, data?: object) {}
+}
+
+export { Task };

package/lib/ai/provider/cohere.ts

@@ -0,0 +1,3 @@
+import { CohereClient } from "cohere-ai";
+
+export { CohereClient };

package/lib/ai/provider/groq.ts

@@ -0,0 +1,3 @@
+import { Groq } from "groq-sdk";
+
+export { Groq };

package/lib/ai/provider/mistral.ts

@@ -0,0 +1,3 @@
+import { Mistral } from "@mistralai/mistralai";
+
+export { Mistral };

package/lib/ai/provider/ollama.ts

@@ -0,0 +1,3 @@
+import { Ollama } from "ollama";
+
+export { Ollama };

package/lib/ai/provider/openai.ts

@@ -0,0 +1,3 @@
+import OpenAI from "openai";
+
+export { OpenAI };

package/lib/crypto.ts

@@ -0,0 +1,68 @@
+import crypto from "node:crypto";
+
+class AES {
+  #key;
+  constructor(
+    options: {
+      secretKey: string;
+    } = {
+      secretKey: "",
+    }
+  ) {
+    // Crée une clé de 256 bits (32 octets) en utilisant un hachage SHA-256 de la clé secrète fournie
+    this.#key = crypto.createHash("sha256").update(options.secretKey).digest();
+  }
+
+  // Fonction de chiffrement
+  encrypt(data: string | object) {
+    let dataEncoding = JSON.stringify(data);
+    const iv = crypto.randomBytes(12); // Génère un IV de 12 octets pour AES-GCM
+
+    // Crée un objet de chiffrement avec AES-256-GCM, la clé et l'IV
+    const cipher = crypto.createCipheriv("aes-256-gcm", this.#key, iv);
+
+    // Chiffre le message et convertit le texte chiffré en hexadécimal
+    let encrypted = cipher.update(dataEncoding, "utf8", "hex");
+    encrypted += cipher.final("hex");
+
+    // Récupère l'authTag pour l'intégrité
+    const authTag = cipher.getAuthTag().toString("hex");
+
+    // Retourne l'IV, l'authTag et le texte chiffré en format hexadécimal
+    return iv.toString("hex") + ":" + authTag + ":" + encrypted;
+  }
+
+  // Fonction de déchiffrement
+  decrypt(data: string) {
+    let encryptedData = data;
+    const [iv, authTag, ciphertext] = encryptedData.split(":");
+
+    /*  const iv = Buffer.from(encryptedData.slice(0, 24), "hex");
+    const authTag = Buffer.from(encryptedData.slice(24, 56), "hex");
+    const ciphertext = encryptedData.slice(56); // Extrait les données chiffrées
+ */
+    // Crée un objet de déchiffrement avec AES-256-GCM, la clé et l'IV
+    const decipher = crypto.createDecipheriv(
+      "aes-256-gcm",
+      this.#key,
+      Buffer.from(iv, "hex")
+    );
+
+    // Définit l'authTag pour vérifier l'intégrité
+    decipher.setAuthTag(Buffer.from(authTag, "hex"));
+
+    // Déchiffre le texte chiffré et convertit en UTF-8
+    let decrypted = decipher.update(ciphertext, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+
+    return JSON.parse(decrypted); // Retourne le message déchiffré
+  }
+}
+
+const message = "Bonjour, comment ça va ?";
+
+const crypt = {
+  AES,
+};
+
+export { crypt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.13.5",
+  "version": "0.13.7",
   "module": "index.ts",
   "type": "module",
   "bin": {
@@ -20,6 +20,7 @@
     "@clack/prompts": "^0.7.0",
     "@colors/colors": "^1.6.0",
     "@lukeed/ms": "^2.0.2",
+    "@mistralai/mistralai": "^1.3.0",
     "@orama/orama": "^2.0.23",
     "@types/dot-object": "^2.1.6",
     "@types/jsonwebtoken": "^9.0.6",
@@ -27,6 +28,7 @@
     "boxen": "^7.1.1",
     "chokidar": "^3.6.0",
     "clean-deep": "^3.4.0",
+    "cohere-ai": "^7.14.0",
     "collect.js": "^4.36.1",
     "consola": "^3.2.3",
     "cookie": "^0.6.0",
@@ -35,6 +37,7 @@
     "find-open-port": "^2.0.3",
     "fs-extra": "^11.2.0",
     "generate-unique-id": "^2.0.3",
+    "groq-sdk": "^0.7.0",
     "hono": "^4.6.3",
     "joi": "^17.13.3",
     "json-joy": "^16.8.0",
@@ -44,6 +47,8 @@
     "moment": "^2.30.1",
     "mongodb": "^6.8.0",
     "nodemailer": "^6.9.14",
+    "ollama": "^0.5.9",
+    "openai": "^4.71.1",
     "radash": "^12.1.0",
     "sharp": "^0.33.5",
     "signaldb": "^0.18.0",

package/tsconfig.json

@@ -1,27 +1,27 @@
 {
   "compilerOptions": {
     // Enable latest features
-    "lib": ["ESNext", "DOM"],
+    "lib": [
+      "ESNext",
+      "DOM"
+    ],
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",
     "jsx": "react-jsx",
     "allowJs": true,
-
     // Bundler mode
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
     "noEmit": true,
-
     // Best practices
     "strict": true,
     "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
-
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
     "noPropertyAccessFromIndexSignature": false
   }
-}
+}

package/types/index.ts

@@ -164,6 +164,7 @@ export type sessionCtx = {
     token?: string;
     _v?: object;
     role?: string | null | undefined;
+    expireIn?: string;
   }) => void;
   get: () => {
     state: object;
@@ -185,7 +186,6 @@ export type hooksCtx = (ctx: {
   update?: updateParams;
   pipeline?: Array<object>;
   sharedData?: any;
-  store?: any;
   action?: Actions;
   c?: Context;
   rest: InstanceType<typeof useRest>;
@@ -470,6 +470,7 @@ export type Endpoint = endpointCtx;
 
 export type Service = {
   /**
+   *   @internal
    * Dont touch it automatically generated
    */
   tenant_id?: string;
@@ -482,7 +483,27 @@ export type Service = {
    * @param ctx
    * @returns
    */
-  fx: (ctx: {
+  fx?: (ctx: {
+    /**
+     * Incomming data [payload]
+     */
+    data: object;
+    /**
+     * Local rest linked to  current tenant
+     */
+    rest: InstanceType<typeof useRest>;
+    error: typeof fn.error;
+    /**
+     * Session of request
+     */
+    session: sessionCtx;
+    /**
+     *  authenticated user or no
+     */
+    isAuth: boolean;
+    io: Io;
+  }) => any;
+  exec?: (ctx: {
     /**
      * Incomming data [payload]
      */