@ai.ntellect/core 0.3.1 → 0.4.0

package/utils/generate-object.ts

@@ -0,0 +1,105 @@
+import { LanguageModelV1, generateText } from "ai";
+import { z } from "zod";
+
+export const describeZodSchema = (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 fieldSchema = describeZodSchema(value as z.ZodType);
+      return description
+        ? `${key}: ${fieldSchema} // ${description}`
+        : `${key}: ${fieldSchema}`;
+    });
+    return `z.object({${fields.join(", ")}})`;
+  }
+
+  if (schema instanceof z.ZodArray) {
+    return `z.array(${describeZodSchema(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()";
+  }
+
+  if (schema instanceof z.ZodOptional) {
+    return `z.optional(${describeZodSchema(schema._def.innerType)})`;
+  }
+
+  if (schema instanceof z.ZodUnion) {
+    return `z.union([${schema._def.options
+      .map((option: z.ZodType) => describeZodSchema(option))
+      .join(", ")}])`;
+  }
+
+  if (schema instanceof z.ZodEnum) {
+    return `z.enum(${JSON.stringify(schema._def.values)})`;
+  }
+
+  if (schema instanceof z.ZodLiteral) {
+    return `z.literal(${JSON.stringify(schema._def.value)})`;
+  }
+
+  return "z.unknown()"; // Fallback for unknown types
+};
+
+export const generateObject = async <T>(config: {
+  model: LanguageModelV1;
+  schema: z.ZodSchema;
+  prompt: string;
+  system: string;
+  temperature: number;
+}): 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}
+  
+  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 as T };
+  } catch (error) {
+    console.error("Error parsing or validating JSON response:", error);
+    throw new Error("Failed to generate valid JSON response");
+  }
+};

package/utils/header-builder.ts

@@ -0,0 +1,40 @@
+type HeaderValue = string | string[] | undefined;
+
+export class LLMHeaderBuilder {
+  private headers: Map<string, HeaderValue>;
+  private _result: string;
+
+  constructor() {
+    this.headers = new Map();
+    this._result = "";
+  }
+
+  addHeader(key: string, value: HeaderValue): LLMHeaderBuilder {
+    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(): string {
+    return this._result;
+  }
+
+  toString(): string {
+    return this._result;
+  }
+
+  static create(): LLMHeaderBuilder {
+    return new LLMHeaderBuilder();
+  }
+}

package/utils/inject-actions.ts

@@ -7,13 +7,11 @@ export const injectActions = (actions: ActionSchema[]) => {
     const schemaShape = Object.keys(parameters._def.shape()).join(", ");
     const actionString = `Name: ${action.name}, Description: ${
       action.description
-    }, Arguments (STRICTLY REQUIRED): { ${schemaShape} } ${
+    }, Arguments: { ${schemaShape} } ${
       action.examples
-        ? `Format examples (MUST RESPECT): ${action.examples.map(
-            (example: any) => {
-              return JSON.stringify(example);
-            }
-          )}`
+        ? `Format examples: ${action.examples.map((example: any) => {
+            return JSON.stringify(example);
+          })}`
         : ""
     }`;
     return actionString;

package/utils/queue-item-transformer.ts

@@ -1,5 +1,6 @@
 import {
   ActionData,
+  QueueItem,
   QueueItemParameter,
   QueueResult,
   TransformedQueueItem,
@@ -34,7 +35,7 @@ export class QueueItemTransformer {
 
   static transformActionsToQueueItems(
     actions: ActionData[] | undefined
-  ): TransformedQueueItem[] | undefined {
+  ): QueueItem[] | undefined {
     return actions?.map((action) => this.transformActionToQueueItem(action));
   }
 }

package/utils/schema-generator.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+export interface SchemaConfig {
+  schema: z.ZodType;
+  instructions?: string;
+  outputExamples?: {
+    input: string;
+    output: string;
+  }[];
+}
+
+export class SchemaGenerator {
+  static generate(config: SchemaConfig): {
+    schema: string;
+    instructions: string;
+    outputExamples: string;
+  } {
+    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: 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()";
+      }
+
+      // 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(),
+    };
+  }
+}

package/agent/handlers/ActionHandler.ts

@@ -1,48 +0,0 @@
-import { ActionQueueManager } from "../../services/queue";
-import {
-  ActionSchema,
-  ProcessPromptCallbacks,
-  QueueItem,
-  QueueResult,
-} from "../../types";
-
-export class ActionHandler {
-  async executeActions(
-    predefinedActions: QueueItem[],
-    tools: ActionSchema[],
-    callbacks?: ProcessPromptCallbacks
-  ) {
-    try {
-      const queueManager = new ActionQueueManager(tools, {
-        onActionStart: callbacks?.onActionStart,
-        onActionComplete: callbacks?.onActionComplete,
-        onQueueComplete: callbacks?.onQueueComplete,
-        onConfirmationRequired: async (message: any) => {
-          if (callbacks?.onConfirmationRequired) {
-            return await callbacks.onConfirmationRequired(message);
-          }
-          return false;
-        },
-      });
-
-      queueManager.addToQueue(predefinedActions);
-
-      if (callbacks?.onQueueStart) {
-        callbacks.onQueueStart(predefinedActions);
-      }
-
-      const results = await queueManager.processQueue();
-      return { type: "success", data: results || [] };
-    } catch (error) {
-      console.error("Error processing prompt:", error);
-      throw error;
-    }
-  }
-
-  hasNonPrepareActions(actions: QueueResult[]): boolean {
-    return (
-      Array.isArray(actions) &&
-      actions.some((action) => action.name?.split("-")[0] !== "prepare")
-    );
-  }
-}

package/agent/handlers/ConfirmationHandler.ts

@@ -1,37 +0,0 @@
-import EventEmitter from "events";
-
-export class ConfirmationHandler {
-  private readonly CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
-
-  constructor(private readonly eventEmitter: EventEmitter) {}
-
-  async handleConfirmationRequest(message: string): Promise<boolean> {
-    return new Promise((resolve) => {
-      const confirmationId = Date.now().toString();
-      const handleConfirmation = (data: any) => {
-        if (data.confirmationId === confirmationId) {
-          this.eventEmitter.removeListener(
-            "confirmation-response",
-            handleConfirmation
-          );
-          resolve(data.confirmed);
-        }
-      };
-
-      this.eventEmitter.once("confirmation-response", handleConfirmation);
-      this.eventEmitter.emit("orchestrator-update", {
-        type: "confirmation-required",
-        id: confirmationId,
-        message,
-      });
-
-      setTimeout(() => {
-        this.eventEmitter.removeListener(
-          "confirmation-response",
-          handleConfirmation
-        );
-        resolve(false);
-      }, this.CONFIRMATION_TIMEOUT);
-    });
-  }
-}

package/agent/handlers/EventHandler.ts

@@ -1,35 +0,0 @@
-import EventEmitter from "events";
-import { IEventHandler, QueueItem, QueueResult } from "../../types";
-
-export class EventHandler implements IEventHandler {
-  constructor(private readonly eventEmitter: EventEmitter) {}
-
-  emitQueueStart(actions: QueueItem[]) {
-    this.eventEmitter.emit("orchestrator-update", {
-      type: "queue-start",
-      actions,
-    });
-  }
-
-  emitActionStart(action: QueueItem) {
-    this.eventEmitter.emit("orchestrator-update", {
-      type: "action-start",
-      action: action.name,
-      args: action.parameters,
-    });
-  }
-
-  emitActionComplete(action: QueueResult) {
-    this.eventEmitter.emit("orchestrator-update", {
-      type: "action-complete",
-      action: action.name,
-      result: action.result,
-    });
-  }
-
-  emitQueueComplete() {
-    this.eventEmitter.emit("orchestrator-update", {
-      type: "queue-complete",
-    });
-  }
-}

package/dist/agent/handlers/ActionHandler.d.ts

@@ -1,8 +0,0 @@
-import { ActionSchema, ProcessPromptCallbacks, QueueItem, QueueResult } from "../../types";
-export declare class ActionHandler {
-    executeActions(predefinedActions: QueueItem[], tools: ActionSchema[], callbacks?: ProcessPromptCallbacks): Promise<{
-        type: string;
-        data: QueueResult[];
-    }>;
-    hasNonPrepareActions(actions: QueueResult[]): boolean;
-}

package/dist/agent/handlers/ActionHandler.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionHandler = void 0;
-const queue_1 = require("../../services/queue");
-class ActionHandler {
-    async executeActions(predefinedActions, tools, callbacks) {
-        try {
-            const queueManager = new queue_1.ActionQueueManager(tools, {
-                onActionStart: callbacks?.onActionStart,
-                onActionComplete: callbacks?.onActionComplete,
-                onQueueComplete: callbacks?.onQueueComplete,
-                onConfirmationRequired: async (message) => {
-                    if (callbacks?.onConfirmationRequired) {
-                        return await callbacks.onConfirmationRequired(message);
-                    }
-                    return false;
-                },
-            });
-            queueManager.addToQueue(predefinedActions);
-            if (callbacks?.onQueueStart) {
-                callbacks.onQueueStart(predefinedActions);
-            }
-            const results = await queueManager.processQueue();
-            return { type: "success", data: results || [] };
-        }
-        catch (error) {
-            console.error("Error processing prompt:", error);
-            throw error;
-        }
-    }
-    hasNonPrepareActions(actions) {
-        return (Array.isArray(actions) &&
-            actions.some((action) => action.name?.split("-")[0] !== "prepare"));
-    }
-}
-exports.ActionHandler = ActionHandler;

package/dist/agent/handlers/ConfirmationHandler.d.ts

@@ -1,7 +0,0 @@
-import EventEmitter from "events";
-export declare class ConfirmationHandler {
-    private readonly eventEmitter;
-    private readonly CONFIRMATION_TIMEOUT;
-    constructor(eventEmitter: EventEmitter);
-    handleConfirmationRequest(message: string): Promise<boolean>;
-}

package/dist/agent/handlers/ConfirmationHandler.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfirmationHandler = void 0;
-class ConfirmationHandler {
-    constructor(eventEmitter) {
-        this.eventEmitter = eventEmitter;
-        this.CONFIRMATION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
-    }
-    async handleConfirmationRequest(message) {
-        return new Promise((resolve) => {
-            const confirmationId = Date.now().toString();
-            const handleConfirmation = (data) => {
-                if (data.confirmationId === confirmationId) {
-                    this.eventEmitter.removeListener("confirmation-response", handleConfirmation);
-                    resolve(data.confirmed);
-                }
-            };
-            this.eventEmitter.once("confirmation-response", handleConfirmation);
-            this.eventEmitter.emit("orchestrator-update", {
-                type: "confirmation-required",
-                id: confirmationId,
-                message,
-            });
-            setTimeout(() => {
-                this.eventEmitter.removeListener("confirmation-response", handleConfirmation);
-                resolve(false);
-            }, this.CONFIRMATION_TIMEOUT);
-        });
-    }
-}
-exports.ConfirmationHandler = ConfirmationHandler;

package/dist/agent/handlers/EventHandler.d.ts

@@ -1,10 +0,0 @@
-import EventEmitter from "events";
-import { IEventHandler, QueueItem, QueueResult } from "../../types";
-export declare class EventHandler implements IEventHandler {
-    private readonly eventEmitter;
-    constructor(eventEmitter: EventEmitter);
-    emitQueueStart(actions: QueueItem[]): void;
-    emitActionStart(action: QueueItem): void;
-    emitActionComplete(action: QueueResult): void;
-    emitQueueComplete(): void;
-}

package/dist/agent/handlers/EventHandler.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventHandler = void 0;
-class EventHandler {
-    constructor(eventEmitter) {
-        this.eventEmitter = eventEmitter;
-    }
-    emitQueueStart(actions) {
-        this.eventEmitter.emit("orchestrator-update", {
-            type: "queue-start",
-            actions,
-        });
-    }
-    emitActionStart(action) {
-        this.eventEmitter.emit("orchestrator-update", {
-            type: "action-start",
-            action: action.name,
-            args: action.parameters,
-        });
-    }
-    emitActionComplete(action) {
-        this.eventEmitter.emit("orchestrator-update", {
-            type: "action-complete",
-            action: action.name,
-            result: action.result,
-        });
-    }
-    emitQueueComplete() {
-        this.eventEmitter.emit("orchestrator-update", {
-            type: "queue-complete",
-        });
-    }
-}
-exports.EventHandler = EventHandler;

package/dist/llm/evaluator/context.d.ts

@@ -1,10 +0,0 @@
-export declare const evaluatorContext: {
-    behavior: {
-        language: string;
-        role: string;
-        guidelines: {
-            important: string[];
-            warnings: string[];
-        };
-    };
-};

package/dist/llm/evaluator/context.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluatorContext = void 0;
-exports.evaluatorContext = {
-    behavior: {
-        language: "user_language",
-        role: "Your role is to verify if the goal has been achieved and make a response or suggest next actions.",
-        guidelines: {
-            important: [
-                "Verify if all required actions were executed successfully.",
-                "Check if the results align with the initial goal.",
-                "If you retrieved the informations from your internal knowledge base, no need to store them in 'extraInformationsToStore'.",
-                "Store ONLY extra new needed informations in 'extraInformationsToStore' (choose the most relevant informations and memory type: episodic, semantic, or procedural).",
-            ],
-            warnings: [
-                "NEVER store an old data you retrieve from your internal knowledge base.",
-                "NEVER make assumptions about missing data.",
-                "NEVER repeat actions already completed unless explicitly required.",
-            ],
-        },
-    },
-};

package/dist/llm/evaluator/index.d.ts

@@ -1,16 +0,0 @@
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, State } from "../../types";
-import { Interpreter } from "../interpreter";
-export declare class Evaluator {
-    private readonly model;
-    tools: ActionSchema[];
-    private memory;
-    private interpreters;
-    constructor(tools: ActionSchema[], memory: {
-        persistent: PersistentMemory;
-        cache?: CacheMemory;
-    }, interpreters: Interpreter[]);
-    composeContext(state: State): string;
-    process(prompt: string, results: string): Promise<any>;
-}