@ai.ntellect/core 0.4.1 → 0.6.0

package/types/index.ts

@@ -0,0 +1,270 @@
+import { z } from "zod";
+
+/* ======================== MEMORY ======================== */
+
+/**
+ * Represents the input structure for creating a memory entry.
+ * @typedef {Object} CreateMemoryInput
+ * @property {string} query - The query associated with the memory.
+ * @property {any} data - The data to be stored.
+ * @property {string} roomId - The room identifier.
+ * @property {number} [ttl] - Time-to-live in seconds (optional).
+ */
+export type CreateMemoryInput = {
+  query: string;
+  data: any;
+  roomId: string;
+  ttl?: number;
+};
+
+/**
+ * Represents a stored memory entry.
+ * @typedef {Object} BaseMemoryType
+ * @property {string} id - Unique identifier of the memory entry.
+ * @property {string} data - Stored data as a string.
+ * @property {string} query - The associated query.
+ * @property {number[] | null} embedding - Vector representation of the data.
+ * @property {string} roomId - The associated room ID.
+ * @property {Date} createdAt - Creation date.
+ */
+export type BaseMemoryType = {
+  id: string;
+  data: string;
+  query: string;
+  embedding: number[] | null;
+  roomId: string;
+  createdAt: Date;
+};
+
+/* ======================== QUEUE ======================== */
+
+/**
+ * Represents a single parameter for a queued action.
+ * @typedef {Object} QueueItemParameter
+ * @property {string} name - Parameter name.
+ * @property {string} value - Parameter value.
+ */
+export type QueueItemParameter = {
+  name: string;
+  value: string;
+};
+
+/**
+ * Represents an action in the queue.
+ * @typedef {Object} QueueItem
+ * @property {string} name - Name of the action.
+ * @property {QueueItemParameter[]} parameters - List of parameters.
+ */
+export type QueueItem = {
+  name: string;
+  parameters: QueueItemParameter[];
+};
+
+/**
+ * Represents the result of a processed queue action.
+ * @typedef {Object} QueueResult
+ * @property {string} name - Action name.
+ * @property {Record<string, string>} parameters - Executed parameters.
+ * @property {any} result - The execution result.
+ * @property {string | null} error - Error message if any.
+ * @property {boolean} [cancelled] - Indicates if the action was cancelled.
+ */
+export type QueueResult = {
+  name: string;
+  parameters: Record<string, string>;
+  result: any;
+  error: string | null;
+  cancelled?: boolean;
+};
+
+/**
+ * Defines callback functions for queue execution events.
+ * @typedef {Object} QueueCallbacks
+ * @property {(action: QueueItem) => void} [onActionStart] - Triggered when an action starts.
+ * @property {(result: QueueResult) => void} [onActionComplete] - Triggered when an action completes.
+ * @property {(results: QueueResult[]) => void} [onQueueComplete] - Triggered when the queue is fully processed.
+ * @property {(message: string) => Promise<boolean>} [onConfirmationRequired] - Triggered when confirmation is needed.
+ */
+export type QueueCallbacks = {
+  onActionStart?: (action: QueueItem) => void;
+  onActionComplete?: (result: QueueResult) => void;
+  onQueueComplete?: (results: QueueResult[]) => void;
+  onConfirmationRequired?: (message: string) => Promise<boolean>;
+};
+
+/* ======================== ACTION ======================== */
+
+/**
+ * Represents an executable action schema.
+ * @typedef {Object} ActionSchema
+ * @property {string} name - Action name.
+ * @property {string} description - Action description.
+ * @property {z.ZodObject<Record<string, z.ZodType>>} parameters - Schema for input parameters.
+ * @property {(args: any) => Promise<any>} execute - Function to execute the action.
+ * @property {Object[]} [examples] - Example usages of the action.
+ * @property {Object} [confirmation] - Confirmation requirements.
+ * @property {boolean} confirmation.requireConfirmation - Whether confirmation is needed.
+ * @property {string} confirmation.message - The confirmation message.
+ */
+export type ActionSchema = {
+  name: string;
+  description: string;
+  parameters: z.ZodObject<{ [key: string]: z.ZodType }>;
+  execute: (args: any) => Promise<any>;
+  examples?: {
+    role: string;
+    content: string;
+    parameters?: Record<string, any>;
+  }[];
+  confirmation?: {
+    requireConfirmation: boolean;
+    message: string;
+  };
+};
+
+/* ======================== SCHEDULING ======================== */
+
+/**
+ * Represents a scheduled action with optional recurrence.
+ * @typedef {Object} ScheduledAction
+ * @property {string} id - Unique identifier for the scheduled action.
+ * @property {Object} action - The action details.
+ * @property {string} action.name - The action name.
+ * @property {QueueItemParameter[]} action.parameters - Action parameters.
+ * @property {Date} scheduledTime - The scheduled execution time.
+ * @property {string} userId - Associated user identifier.
+ * @property {"pending" | "completed" | "failed"} status - The execution status.
+ * @property {Object} [recurrence] - Recurrence details (optional).
+ * @property {"daily" | "weekly" | "monthly"} recurrence.type - Recurrence type.
+ * @property {number} recurrence.interval - Recurrence interval.
+ */
+export type ScheduledAction = {
+  id: string;
+  action: {
+    name: string;
+    parameters: QueueItemParameter[];
+  };
+  scheduledTime: Date;
+  userId: string;
+  status: "pending" | "completed" | "failed";
+  recurrence?: {
+    type: "daily" | "weekly" | "monthly";
+    interval: number;
+  };
+};
+
+/**
+ * Represents a scheduled request.
+ * @typedef {Object} ScheduledRequest
+ * @property {string} id - Unique identifier for the scheduled request.
+ * @property {string} originalRequest - The original request string.
+ * @property {string} cronExpression - The cron expression for scheduling.
+ * @property {boolean} isRecurring - Whether the request is recurring.
+ * @property {Date} createdAt - The creation date.
+ */
+export type ScheduledRequest = {
+  id: string;
+  originalRequest: string;
+  cronExpression: string;
+  isRecurring: boolean;
+  createdAt: Date;
+};
+
+/* ======================== GRAPH ======================== */
+
+/**
+ * Defines a graph definition.
+ * @typedef {Object} GraphDefinition
+ * @property {string} name - The graph name.
+ * @property {string} entryNode - The entry node name.
+ * @property {Record<string, Node<T>>} nodes - The nodes in the graph.
+ * @property {z.ZodSchema<T>} [schema] - Optional schema for input validation.
+ */
+export type GraphDefinition<T> = {
+  name: string;
+  entryNode: string;
+  nodes: Record<string, Node<T>>;
+  schema?: z.ZodSchema<T>;
+};
+
+/**
+ * Defines a shared state context for execution graphs.
+ * @typedef {Object} SharedState
+ * @property {Partial<T>} context - The execution context.
+ */
+export type SharedState<T> = {
+  context: Partial<T>;
+};
+
+/**
+ * Defines a graph node within a graph execution structure.
+ * @typedef {Object} Node
+ * @property {string} name - The node name.
+ * @property {string} [description] - Optional description.
+ * @property {(params: P, state: SharedState<T>) => Promise<SharedState<T> | void>} execute - Execution function.
+ * @property {(state: SharedState<T>) => boolean} [condition] - Optional condition for execution.
+ * @property {NodeRelationship[]} [relationships] - Possible node transitions.
+ * @property {z.ZodSchema<P>} [schema] - Optional schema for input validation.
+ * @property {any} [state] - Internal node state.
+ * @property {string[]} [events] - Events triggered by the node.
+ */
+export type Node<T, P = any> = {
+  name: string;
+  description?: string;
+  execute: (params: P, state: SharedState<T>) => Promise<SharedState<T> | void>;
+  condition?: (state: SharedState<T>) => boolean;
+  relationships?: NodeRelationship[];
+  schema?: z.ZodSchema<P>;
+  state?: any;
+  events?: string[];
+};
+
+/**
+ * Defines a node relationship in an execution graph.
+ * @typedef {Object} NodeRelationship
+ * @property {string} name - Relationship name.
+ * @property {string} [description] - Optional description.
+ */
+export type NodeRelationship = {
+  name: string;
+  description?: string;
+};
+
+/* ======================== SEARCH ======================== */
+
+/**
+ * Represents a document that can be indexed and searched.
+ * @typedef {Object} SearchDocument
+ * @property {string} [id] - Optional unique identifier of the document.
+ * @property {string} content - The searchable text content.
+ * @property {Record<string, any>} [metadata] - Additional metadata for context.
+ */
+export type SearchDocument = {
+  id?: string;
+  content: string;
+  metadata?: Record<string, any>;
+};
+
+/**
+ * Represents a search result with a similarity score.
+ * @typedef {Object} SearchResult
+ * @property {SearchDocument} document - The matched document.
+ * @property {number} score - The similarity score.
+ */
+export type SearchResult = {
+  document: SearchDocument;
+  score: number;
+};
+
+/* ======================== MEILISEARCH ======================== */
+export type MeilisearchConfig = {
+  host: string;
+  apiKey: string;
+  searchableAttributes?: string[];
+  sortableAttributes?: string[];
+};
+
+export type MeilisearchSettings = {
+  searchableAttributes?: string[];
+  sortableAttributes?: string[];
+};

package/utils/generate-object.js

@@ -0,0 +1,111 @@
+"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/generate-object.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV1, generateText } from "ai";
+import { CoreMessage, LanguageModelV1, generateText } from "ai";
 import { z } from "zod";
 
 export const describeZodSchema = (schema: z.ZodType): string => {
@@ -54,19 +54,16 @@ export const describeZodSchema = (schema: z.ZodType): string => {
 export const generateObject = async <T>(config: {
   model: LanguageModelV1;
   schema: z.ZodSchema;
-  prompt: string;
   system: string;
   temperature: number;
+  prompt?: string;
+  messages?: CoreMessage[];
 }): Promise<{ object: T }> => {
   // Generate a detailed description of the schema
   const schemaDescription = describeZodSchema(config.schema);
 
-  console.log("🔍 Schema Description:\n", schemaDescription);
-
-  const response = await generateText({
-    model: config.model,
-    prompt: `${config.prompt}
-  
+  const baseContext = `
+  ${config.system}
   EXPECTED SCHEMA:
   ${schemaDescription}
   
@@ -76,16 +73,31 @@ export const generateObject = async <T>(config: {
     "key": "value"
   }
   \`\`\`
-  
+
   GOOD EXAMPLE:
   {
     "key": "value"
   }
-  
-  Output only the JSON schema, no 'triple quotes'json or any other text. Only the JSON schema.
-  `,
+
+  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 = await generateText({
+    model: config.model,
+    messages: !config.prompt
+      ? [
+          {
+            role: "system",
+            content: baseContext,
+          },
+          ...(config.messages ?? []),
+        ]
+      : undefined,
     system: config.system,
     temperature: config.temperature,
+    prompt: !config.prompt ? undefined : `${config.prompt}\n\n${baseContext}`,
   });
 
   try {

package/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/utils/inject-actions.js

@@ -0,0 +1,16 @@
+"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/inject-actions.ts

@@ -5,11 +5,11 @@ export const injectActions = (actions: ActionSchema[]) => {
   return actions.map((action) => {
     const parameters = action.parameters as z.ZodObject<any>;
     const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-    const actionString = `Name: ${action.name}, Description: ${
+    const actionString = `* ${action.name}( { ${schemaShape} }) (${
       action.description
-    }, Arguments: { ${schemaShape} } ${
+    }) ${
       action.examples
-        ? `Format examples: ${action.examples.map((example: any) => {
+        ? `Eg: ${action.examples.map((example: any) => {
             return JSON.stringify(example);
           })}`
         : ""

package/utils/queue-item-transformer.js

@@ -0,0 +1,24 @@
+"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/queue-item-transformer.ts

@@ -1,13 +1,10 @@
-import {
-  ActionData,
-  QueueItem,
-  QueueItemParameter,
-  QueueResult,
-  TransformedQueueItem,
-} from "../types";
+import { QueueItem, QueueItemParameter, QueueResult } from "@/types";
 
 export class QueueItemTransformer {
-  static transformActionToQueueItem(action: ActionData): TransformedQueueItem {
+  static transformActionToQueueItem(action: {
+    name: string;
+    parameters: Record<string, any>;
+  }): QueueItem {
     return {
       name: action.name || "",
       parameters: QueueItemTransformer.transformParameters(
@@ -18,8 +15,8 @@ export class QueueItemTransformer {
 
   static transformFromSimilarActions(
     similarActions: QueueResult[]
-  ): TransformedQueueItem[] | undefined {
-    return similarActions?.map((action: ActionData) =>
+  ): QueueItem[] | undefined {
+    return similarActions?.map((action: QueueResult) =>
       QueueItemTransformer.transformActionToQueueItem(action)
     );
   }
@@ -34,7 +31,7 @@ export class QueueItemTransformer {
   }
 
   static transformActionsToQueueItems(
-    actions: ActionData[] | undefined
+    actions: { name: string; parameters: Record<string, any> }[] | undefined
   ): QueueItem[] | undefined {
     return actions?.map((action) => this.transformActionToQueueItem(action));
   }

package/utils/sanitize-results.js

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

@@ -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;