@ai.ntellect/core 0.6.0 → 0.6.1

package/index copy.ts

@@ -0,0 +1,81 @@
+export interface NetworkConfig {
+  name: string;
+  id?: number;
+  rpc: string;
+  explorerUrl: string;
+  nativeToken: string; // WETH
+}
+export const networkConfigs: Record<string, NetworkConfig> = {
+  ethereum: {
+    name: "Ethereum Mainnet",
+    id: 1,
+    rpc: "https://eth.llamarpc.com",
+    explorerUrl: "https://etherscan.io",
+    nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  },
+  polygon: {
+    name: "Polygon Mainnet",
+    id: 137,
+    rpc: "https://polygon.llamarpc.com",
+    explorerUrl: "https://polygonscan.com",
+    nativeToken: "0x0000000000000000000000000000000000001010",
+  },
+  arbitrum: {
+    name: "Arbitrum Mainnet",
+    id: 42161,
+    rpc: "https://arbitrum.llamarpc.com",
+    explorerUrl: "https://arbiscan.io",
+    nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+  },
+  base: {
+    name: "Base Mainnet",
+    id: 8453,
+    rpc: "https://base.llamarpc.com",
+    explorerUrl: "https://basescan.org",
+    nativeToken: "0x4200000000000000000000000000000000000006",
+  },
+  solana: {
+    name: "Solana Mainnet",
+    rpc: "https://api.mainnet-beta.solana.com",
+    explorerUrl: "https://solscan.io",
+    nativeToken: "So11111111111111111111111111111111111111112",
+  },
+  sepolia: {
+    name: "Sepolia Testnet",
+    id: 11155111,
+    rpc: "https://rpc.sepolia.ethpandaops.io",
+    explorerUrl: "https://sepolia.etherscan.io",
+    nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+  },
+  baseSepolia: {
+    name: "Base Sepolia Testnet",
+    id: 84532,
+    rpc: "https://base-sepolia-rpc.publicnode.com",
+    explorerUrl: "https://sepolia.basescan.org",
+    nativeToken: "0x4200000000000000000000000000000000000006",
+  },
+};
+
+export const getNetworkProvider = (networkName: string) => {
+  const config = networkConfigs[networkName.toLowerCase()];
+  if (!config) {
+    throw new Error(`Network ${networkName} not supported`);
+  }
+  return { config };
+};
+
+export const ROUTER_ADDRESSES: { [key: string]: string } = {
+  ethereum: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
+  sepolia: "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
+  arbitrum: "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+  polygon: "0xedf6066a2b290C185783862C7F4776A2C8077AD1",
+  base: "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+  optimism: "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
+  blast: "0xBB66Eb1c5e875933D44DAe661dbD80e5D9B03035",
+  zora: "0xa00F34A632630EFd15223B1968358bA4845bEEC7",
+  worldchain: "0x541aB7c31A119441eF3575F6973277DE0eF460bd",
+};
+
+export const getRouterAddress = (networkName: string) => {
+  return ROUTER_ADDRESSES[networkName.toLowerCase()];
+};

package/package.json

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

package/test/graph/engine.test.ts

@@ -35,11 +35,9 @@ describe("Graph", () => {
         description: "Starting node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "started",
-              step: 1,
-            },
+            ...state.context,
+            status: "started",
+            step: 1,
           });
         },
         relationships: [{ name: "process" }],
@@ -49,11 +47,9 @@ describe("Graph", () => {
         description: "Processing node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "processing",
-              step: 2,
-            },
+            ...state.context,
+            status: "processing",
+            step: 2,
           });
         },
         condition: (state) => state.context.step === 1,
@@ -64,11 +60,9 @@ describe("Graph", () => {
         description: "End node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "completed",
-              step: 3,
-            },
+            ...state.context,
+            status: "completed",
+            step: 3,
           });
         },
         relationships: [],
@@ -145,18 +139,15 @@ describe("Graph", () => {
         description: "A new test node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "new",
-              step: 4,
-            },
+            ...state.context,
+            status: "new",
+            step: 4,
           });
         },
+        relationships: [{ name: "end" }],
       };
 
-      graph.addNode(newNode, {
-        relationships: [{ name: "end" }],
-      });
+      graph.addNode(newNode);
 
       expect(graph.nodes.has("new-node")).to.be.true;
       const addedNode = graph.nodes.get("new-node");
@@ -174,11 +165,9 @@ describe("Graph", () => {
             description: "New step node",
             execute: async (_params: any, state: SharedState<TestState>) => {
               return graph.updateState({
-                context: {
-                  ...state.context,
-                  status: "new-step",
-                  step: 4,
-                },
+                ...state.context,
+                status: "new-step",
+                step: 4,
               });
             },
             relationships: [],
@@ -218,9 +207,7 @@ describe("Graph", () => {
       graph.setState(initialState);
 
       const partialUpdate = {
-        context: {
-          status: "updated",
-        },
+        status: "updated",
       };
 
       const updatedState = graph.updateState(partialUpdate);
@@ -241,7 +228,7 @@ describe("Graph", () => {
         },
       };
 
-      graph.addNode(errorNode, {});
+      graph.addNode(errorNode);
 
       let errorCaught = false;
       try {
@@ -316,7 +303,7 @@ describe("Graph", () => {
       }));
 
       parallelNodes.forEach((node) => {
-        graph.addNode(node, {});
+        graph.addNode(node);
       });
 
       await graph.executeParallel(
@@ -341,17 +328,15 @@ describe("Graph", () => {
         name: "event-node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "event-triggered",
-              step: 10,
-            },
+            ...state.context,
+            status: "event-triggered",
+            step: 10,
           });
         },
         events: ["test-event"],
       };
 
-      graph.addNode(eventNode, { events: ["test-event"] });
+      graph.addNode(eventNode);
 
       // Émettre l'événement
       graph.emit("test-event", {
@@ -382,11 +367,9 @@ describe("Graph", () => {
             name: "sub-start",
             execute: async (_params: any, state: SharedState<TestState>) => {
               return graph.updateState({
-                context: {
-                  ...state.context,
-                  status: "sub-completed",
-                  step: 100,
-                },
+                ...state.context,
+                status: "sub-completed",
+                step: 100,
               });
             },
             relationships: [],

package/tsconfig.json

@@ -12,5 +12,5 @@
     },
     "outDir": "./dist"
   },
-  "exclude": ["examples"]
+  "exclude": ["node_modules", "examples", "test"]
 }

package/types/index.ts

@@ -192,9 +192,7 @@ export type GraphDefinition<T> = {
  * @typedef {Object} SharedState
  * @property {Partial<T>} context - The execution context.
  */
-export type SharedState<T> = {
-  context: Partial<T>;
-};
+export type SharedState<T> = T;
 
 /**
  * Defines a graph node within a graph execution structure.
@@ -268,3 +266,13 @@ export type MeilisearchSettings = {
   searchableAttributes?: string[];
   sortableAttributes?: string[];
 };
+
+/* ======================== ACTIONS ======================== */
+
+export type Action = {
+  name: string;
+  parameters: {
+    name: string;
+    value: string;
+  }[];
+};

package/utils/setup-graphs.ts

@@ -0,0 +1,45 @@
+import { GraphEngine } from "../graph/engine";
+import { Action, GraphDefinition, SharedState } from "../types";
+
+export function setupGraphsWithActions<T>(
+  actions: Action[],
+  baseStateMapping: Record<string, SharedState<T>>,
+  graphMaps: GraphDefinition<T>[]
+): {
+  initialStates: SharedState<T>[];
+  graphs: GraphEngine<T>[];
+  startNodes: string[];
+} {
+  const initialStates = actions.map((action) => {
+    const parametersObject = Object.fromEntries(
+      action.parameters.map((param) => [
+        param.name,
+        param.value !== undefined ? param.value : null,
+      ]) // Handle optional values
+    );
+
+    const baseState = baseStateMapping[action.name] || {};
+
+    return {
+      ...baseState,
+      ...parametersObject,
+    };
+  });
+
+  const selectedGraphs = actions
+    .map((action) => graphMaps.find((graph) => graph.name === action.name))
+    .filter((graph): graph is GraphDefinition<T> => graph !== undefined);
+
+  if (selectedGraphs.length !== actions.length) {
+    throw new Error("Graph not found");
+  }
+
+  const startNodes = selectedGraphs.map((graph) => graph.entryNode);
+  const graphEngines = selectedGraphs.map((graph) => new GraphEngine(graph));
+
+  return {
+    initialStates: initialStates as SharedState<T>[],
+    graphs: graphEngines,
+    startNodes,
+  };
+}

package/utils/stringifiy-zod-schema.ts

@@ -0,0 +1,45 @@
+import { Node } from "@/types";
+import { z } from "zod";
+
+export const stringifyZodSchema = <T>(nodes: Node<T>[]) => {
+  return nodes
+    .map((node) => {
+      const schemaStr = node.schema
+        ? getSchemaString(node.schema)
+        : "No parameters";
+      return `Workflow: ${node.name}\nDescription: ${node.description}\nParameters: ${schemaStr}`;
+    })
+    .join("\n\n");
+};
+
+const getSchemaString = (schema: z.ZodType): string => {
+  if (schema instanceof z.ZodObject) {
+    const entries = Object.entries(schema.shape);
+    const fields = entries.map(([key, value]) => {
+      const description = (value as any)._def.description;
+      const schemaStr = getSchemaString(value as z.ZodType);
+      return description
+        ? `${key}: ${schemaStr} // ${description}`
+        : `${key}: ${schemaStr}`;
+    });
+    return `z.object({${fields.join(", ")}})`;
+  }
+
+  if (schema instanceof z.ZodArray) {
+    return `z.array(${getSchemaString(schema.element)})`;
+  }
+
+  if (schema instanceof z.ZodString) {
+    return "z.string()";
+  }
+
+  if (schema instanceof z.ZodNumber) {
+    return "z.number()";
+  }
+
+  if (schema instanceof z.ZodBoolean) {
+    return "z.boolean()";
+  }
+
+  return `z.unknown()`;
+};

package/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/utils/header-builder.js

@@ -1,34 +0,0 @@
-"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/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/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/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/utils/schema-generator.js

@@ -1,46 +0,0 @@
-"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;