@ai.ntellect/core 0.4.1 → 0.6.0

package/dist/types.d.ts

@@ -1,258 +0,0 @@
-import { Embedding, EmbeddingModel, StreamTextResult } from "ai";
-import { z } from "zod";
-export interface BaseLLM {
-    process: (prompt: string) => Promise<string | object>;
-    streamProcess?: (prompt: string) => Promise<StreamTextResult<Record<string, any>>>;
-}
-export type User = {
-    id: string;
-};
-export interface QueueItem {
-    name: string;
-    parameters: QueueItemParameter[];
-}
-export interface IEventHandler {
-    emitQueueStart(actions: QueueItem[]): void;
-    emitActionStart(action: QueueItem): void;
-    emitActionComplete(action: QueueResult): void;
-    emitQueueComplete(): void;
-}
-export type AgentEvent = {
-    onMessage?: (data: any) => void;
-    onQueueStart?: (actions: QueueItem[]) => void;
-    onActionStart?: (action: QueueItem) => void;
-    onActionComplete?: (action: QueueResult) => void;
-    onQueueComplete?: (actions: QueueResult[]) => void;
-    onConfirmationRequired?: (message: string) => Promise<boolean>;
-};
-export interface QueueResult {
-    name: string;
-    parameters: Record<string, string>;
-    result: any;
-    error: string | null;
-    cancelled?: boolean;
-}
-export interface QueueCallbacks {
-    onActionStart?: (action: QueueItem) => void;
-    onActionComplete?: (result: QueueResult) => void;
-    onQueueComplete?: (results: QueueResult[]) => void;
-    onConfirmationRequired?: (message: string) => Promise<boolean>;
-}
-export interface ProcessPromptCallbacks {
-    onQueueStart?: (actions: QueueItem[]) => void | Promise<void>;
-    onActionStart?: (action: QueueItem) => void | Promise<void>;
-    onActionComplete?: (action: QueueResult) => void | Promise<void>;
-    onQueueComplete?: (actions: QueueResult[]) => void | Promise<void>;
-    onConfirmationRequired?: (message: string) => Promise<boolean>;
-}
-export type Behavior = {
-    role: string;
-    language: string;
-    guidelines: {
-        important: string[];
-        warnings: string[];
-        steps?: string[];
-    };
-    examplesMessages?: {
-        role: string;
-        content: string;
-    }[];
-};
-export type State = {
-    userRequest: string;
-    results: string;
-};
-export interface 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;
-    };
-}
-export type ProcessPromptResult = {
-    type: "success" | "clarification" | "confirmation";
-    data: QueueResult[] | {
-        validationErrors: string[];
-        prompt: string;
-    } | {
-        actions: QueueItem[];
-    };
-    initialPrompt: string;
-};
-export interface ActionPattern {
-    id: string;
-    actions: QueueResult[];
-    embeddings: number[][];
-    queries: string[];
-    purpose: string;
-}
-export interface MatchOptions {
-    similarityThreshold?: number;
-    maxResults?: number;
-}
-export interface MatchResult {
-    data: any;
-    similarityPercentage: number;
-    purpose: string;
-    name?: string;
-    parameters?: Record<string, any>;
-}
-export interface SummarizerAgent {
-    process: (results: object, onFinish?: (event: any) => void) => Promise<{
-        actions: {
-            name: string;
-            reasoning: string;
-        }[];
-        response: string;
-    } | StreamTextResult<Record<string, any>>>;
-    streamProcess: (results: object, onFinish?: (event: any) => void) => Promise<StreamTextResult<Record<string, any>>>;
-}
-export interface CacheMemoryOptions {
-    embeddingModel: EmbeddingModel<string>;
-    cacheTTL?: number;
-    redisUrl?: string;
-    cachePrefix?: string;
-}
-export type GenerateObjectResponse = {
-    shouldContinue: boolean;
-    actions: Array<{
-        name: string;
-        parameters: Array<{
-            name: string;
-            value: any;
-        }>;
-        scheduler?: {
-            isScheduled: boolean;
-            cronExpression: string;
-            reason?: string;
-        };
-    }>;
-    socialResponse?: {
-        shouldRespond: boolean;
-        response?: string;
-        isPartialResponse?: boolean;
-    };
-    interpreter?: string;
-};
-export interface CreateMemoryInput {
-    query: string;
-    data: any;
-    userId?: string;
-    scope?: MemoryScope;
-    ttl?: number;
-}
-export interface CacheMemoryType {
-    id: string;
-    data: any;
-    query: string;
-    embedding: Embedding;
-    userId?: string;
-    scope: MemoryScope;
-    createdAt: Date;
-}
-export interface PersistentMemoryOptions {
-    host: string;
-    apiKey: string;
-    indexPrefix?: string;
-}
-export interface MemoryChunk {
-    content: string;
-    embedding: number[];
-}
-export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
-export interface LongTermMemory {
-    id: string;
-    query: string;
-    category: string;
-    data: any;
-    roomId: string;
-    createdAt: Date;
-    chunks?: MemoryChunk[];
-    tags: string[];
-}
-export declare const ActionSchema: z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    parameters: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        value: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        value: string;
-        name: string;
-    }, {
-        value: string;
-        name: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    parameters: {
-        value: string;
-        name: string;
-    }[];
-}, {
-    name: string;
-    parameters: {
-        value: string;
-        name: string;
-    }[];
-}>, "many">;
-export declare enum MemoryType {
-    ACTION = "action",
-    CONVERSATION = "conversation",
-    KNOWLEDGE = "knowledge"
-}
-export declare enum MemoryScope {
-    GLOBAL = "global",
-    USER = "user"
-}
-export interface ActionData {
-    name?: string;
-    parameters?: Record<string, any>;
-}
-export interface QueueItemParameter {
-    name: string;
-    value: string;
-}
-export interface TransformedQueueItem {
-    name: string;
-    parameters: QueueItemParameter[];
-}
-export interface ScheduledAction {
-    id: string;
-    action: {
-        name: string;
-        parameters: QueueItemParameter[];
-    };
-    scheduledTime: Date;
-    userId: string;
-    status: "pending" | "completed" | "failed";
-    recurrence?: {
-        type: "daily" | "weekly" | "monthly";
-        interval: number;
-    };
-}
-export interface ScheduledActionEvents {
-    onActionStart?: (action: ScheduledAction) => void;
-    onActionComplete?: (action: ScheduledAction, result: any) => void;
-    onActionFailed?: (action: ScheduledAction, error: Error) => void;
-    onActionScheduled?: (action: ScheduledAction) => void;
-    onActionCancelled?: (actionId: string) => void;
-}
-export interface WorkflowPattern {
-    query: string;
-    actions: Array<{
-        done: boolean;
-        name: string;
-        result: string;
-    }>;
-    success: boolean;
-}

package/dist/types.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryScope = exports.MemoryType = exports.ActionSchema = void 0;
-const zod_1 = require("zod");
-exports.ActionSchema = zod_1.z.array(zod_1.z.object({
-    name: zod_1.z.string(),
-    parameters: zod_1.z.array(zod_1.z.object({
-        name: zod_1.z.string(),
-        value: zod_1.z.string(),
-    })),
-}));
-var MemoryType;
-(function (MemoryType) {
-    MemoryType["ACTION"] = "action";
-    MemoryType["CONVERSATION"] = "conversation";
-    MemoryType["KNOWLEDGE"] = "knowledge";
-})(MemoryType || (exports.MemoryType = MemoryType = {}));
-var MemoryScope;
-(function (MemoryScope) {
-    MemoryScope["GLOBAL"] = "global";
-    MemoryScope["USER"] = "user";
-})(MemoryScope || (exports.MemoryScope = MemoryScope = {}));

package/dist/utils/generate-object.d.ts

@@ -1,12 +0,0 @@
-import { LanguageModelV1 } from "ai";
-import { z } from "zod";
-export declare const describeZodSchema: (schema: z.ZodType) => string;
-export declare const generateObject: <T>(config: {
-    model: LanguageModelV1;
-    schema: z.ZodSchema;
-    prompt: string;
-    system: string;
-    temperature: number;
-}) => Promise<{
-    object: T;
-}>;

package/dist/utils/header-builder.d.ts

@@ -1,11 +0,0 @@
-type HeaderValue = string | string[] | undefined;
-export declare class LLMHeaderBuilder {
-    private headers;
-    private _result;
-    constructor();
-    addHeader(key: string, value: HeaderValue): LLMHeaderBuilder;
-    valueOf(): string;
-    toString(): string;
-    static create(): LLMHeaderBuilder;
-}
-export {};

package/dist/utils/inject-actions.d.ts

@@ -1,2 +0,0 @@
-import { ActionSchema } from "../types";
-export declare const injectActions: (actions: ActionSchema[]) => string[];

package/dist/utils/queue-item-transformer.d.ts

@@ -1,7 +0,0 @@
-import { ActionData, QueueItem, QueueResult, TransformedQueueItem } from "../types";
-export declare class QueueItemTransformer {
-    static transformActionToQueueItem(action: ActionData): TransformedQueueItem;
-    static transformFromSimilarActions(similarActions: QueueResult[]): TransformedQueueItem[] | undefined;
-    private static transformParameters;
-    static transformActionsToQueueItems(actions: ActionData[] | undefined): QueueItem[] | undefined;
-}

package/dist/utils/sanitize-results.d.ts

@@ -1,17 +0,0 @@
-/**
- * Utility class to sanitize JSON results for evaluation
- */
-export declare class ResultSanitizer {
-    /**
-     * Sanitizes JSON results by removing special characters and formatting
-     * @param results - The results to sanitize
-     * @returns Sanitized string
-     */
-    static sanitize(results: any): string;
-    /**
-     * Formats numbers to a consistent format
-     * @param value - The number to format
-     * @returns Formatted number string
-     */
-    private static formatNumber;
-}

package/dist/utils/schema-generator.d.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-export interface SchemaConfig {
-    schema: z.ZodType;
-    instructions?: string;
-    outputExamples?: {
-        input: string;
-        output: string;
-    }[];
-}
-export declare class SchemaGenerator {
-    static generate(config: SchemaConfig): {
-        schema: string;
-        instructions: string;
-        outputExamples: string;
-    };
-}

package/examples/index.ts

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-
-import { deepseek } from "@ai-sdk/deepseek";
-import { configDotenv } from "dotenv";
-import readline from "readline";
-import { Agent } from "../agent";
-import { getRssNews } from "../agent/tools/get-rss";
-import { Interpreter } from "../llm/interpreter";
-import {
-  generalInterpreterCharacter,
-  marketInterpreterCharacter,
-  securityInterpreterCharacter,
-} from "../llm/interpreter/context";
-configDotenv();
-// Initialiser l'agent une fois pour toute la session
-const initializeAgent = () => {
-  const model = deepseek("deepseek-reasoner");
-
-  const securityInterpreter = new Interpreter({
-    name: "security",
-    model,
-    character: securityInterpreterCharacter,
-  });
-  const marketInterpreter = new Interpreter({
-    name: "market",
-    model,
-    character: marketInterpreterCharacter,
-  });
-  const generalInterpreter = new Interpreter({
-    name: "general",
-    model,
-    character: generalInterpreterCharacter,
-  });
-
-  const agent = new Agent({
-    cache: {
-      host: process.env.REDIS_HOST || "localhost",
-      port: Number(process.env.REDIS_PORT) || 6379,
-    },
-    orchestrator: {
-      model,
-      tools: [getRssNews],
-    },
-    interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
-    memoryManager: {
-      model,
-    },
-    maxIterations: 3,
-  });
-
-  return agent;
-};
-
-// Fonction pour lancer une session interactive
-const startChatSession = async () => {
-  console.log("Bienvenue dans votre session de chat avec l'agent !");
-  console.log("Tapez 'exit' pour quitter.\n");
-
-  const agent = initializeAgent();
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: "Vous > ",
-  });
-
-  let state = {
-    currentContext: "",
-    previousActions: [],
-  };
-
-  rl.prompt();
-
-  rl.on("line", async (line) => {
-    const input = line.trim();
-
-    if (input.toLowerCase() === "exit") {
-      console.log("Fin de la session. À bientôt !");
-      rl.close();
-      return;
-    }
-
-    state.currentContext = input;
-
-    console.log("Agent en réflexion...");
-    try {
-      const result = await agent.process(state);
-      console.log(`Agent > ${result}\n`);
-    } catch (error) {
-      console.error("Erreur avec l'agent :", error);
-    }
-
-    rl.prompt();
-  });
-
-  rl.on("close", () => {
-    console.log("Session terminée.");
-    process.exit(0);
-  });
-};
-
-// Lancer la session de chat
-startChatSession();

package/llm/interpreter/context.ts

@@ -1,101 +0,0 @@
-export type Character = {
-  role: string;
-  language: string;
-  guidelines: {
-    important: string[];
-    warnings: string[];
-  };
-  examplesMessages?: {
-    role: string;
-    content: string;
-  }[];
-};
-
-export const generalInterpreterCharacter: Character = {
-  role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-  language: "user_request",
-  guidelines: {
-    important: [],
-    warnings: [],
-  },
-};
-
-export const securityInterpreterCharacter: Character = {
-  role: "You are the security expert. Your role is to provide a clear and factual analysis of the security of the token/coin.",
-  language: "user_request",
-  guidelines: {
-    important: [
-      "Start with a clear security analysis of the token/coin.",
-      "One section for good points of the security check. One section, no sub-sections.",
-      "One section for bad points of the security check. One section, no sub-sections.",
-      "STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS",
-    ],
-    warnings: [
-      "NEVER provide any financial advice.",
-      "NEVER speak about details of your system or your capabilities.",
-      "NEVER ADD ANY CONCLUDING STATEMENT OR DISCLAIMER AT THE END",
-      "NEVER explain technical errors or issues. Just say retry later.",
-    ],
-  },
-  examplesMessages: [
-    {
-      role: "user",
-      content: "Analysis security of token/coin",
-    },
-    {
-      role: "assistant",
-      content: `
-      ## Security analysis of x/y:
-      
-      ### Good:
-      Speak about the good points of the security check. If there is no good point, say "No good point found"
-  
-      ### Bad:
-      Speak about the bad points of the security check. If there is no bad point, say "No bad point found"
-  
-      STOP AFTER SECURITY CHECK SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
-      --------------------------------
-      `,
-    },
-  ],
-};
-
-export const marketInterpreterCharacter: Character = {
-  role: "You are the market expert. Your role is to provide a clear and factual analysis of the market sentiment of the token/coin.",
-  language: "user_request",
-  guidelines: {
-    important: [
-      "Start with a clear market sentiment (Market sentiment: Bullish/Bearish/Neutral 📈📉📊) without any additional comments before.",
-      "One section for fundamental analysis (important events, news, trends..etc). One section, no sub-sections.",
-      "One section for technical analysis (key price levels, trading volume, technical indicators, market activity). One section, no sub-sections.",
-      "STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY ADDITIONAL COMMENTS",
-    ],
-    warnings: [
-      "NEVER provide any financial advice.",
-      "NEVER speak about details of your system or your capabilities.",
-    ],
-  },
-  examplesMessages: [
-    {
-      role: "user",
-      content: "Analysis market sentiment of token/coin",
-    },
-    {
-      role: "assistant",
-      content: `
-    ## Analysis of x/y:
-
-    Market sentiment: Bullish 📈 (Adapt the emoji to the market sentiment)
-
-    ### Fundamental analysis (No sub-sections):
-    Speak about important events, news, trends..etc
-
-    ### Technical analysis (No sub-sections):
-    Speak about key price levels, trading volume, technical indicators, market activity..etc
-
-    STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY CONCLUDING STATEMENT OR DISCLAIMER OR ADDITIONAL COMMENTS
-    --------------------------------
-    `,
-    },
-  ],
-};

package/llm/interpreter/index.ts

@@ -1,136 +0,0 @@
-import { LanguageModel, streamText, StreamTextResult } from "ai";
-import { z } from "zod";
-import { Behavior, State } from "../../types";
-import { generateObject } from "../../utils/generate-object";
-import { LLMHeaderBuilder } from "../../utils/header-builder";
-
-const interpreterSchema = z.object({
-  requestLanguage: z
-    .string()
-    .describe("The language of the user's request (fr, en, es, etc.)"),
-  actionsCompleted: z
-    .array(
-      z.object({
-        name: z.string(),
-        reasoning: z.string(),
-      })
-    )
-    .describe("The actions done and why."),
-  response: z.string().describe("The response to the user's request."),
-});
-
-interface InterpretationResult {
-  actionsCompleted: {
-    name: string;
-    reasoning: string;
-  }[];
-  response: string;
-}
-
-export class Interpreter {
-  public readonly model: LanguageModel;
-  public readonly name: string;
-  public readonly character: Behavior;
-
-  constructor({
-    name,
-    model,
-    character,
-  }: {
-    name: string;
-    model: LanguageModel;
-    character: Behavior;
-  }) {
-    this.name = name;
-    this.model = model;
-    this.character = character;
-  }
-
-  private buildContext(state: State) {
-    const { userRequest, results } = state;
-    const { role, language, guidelines } = this.character;
-    const { important, warnings, steps } = guidelines;
-
-    const context = LLMHeaderBuilder.create();
-
-    if (role) {
-      context.addHeader("ROLE", role);
-    }
-
-    if (language) {
-      context.addHeader("LANGUAGE", language);
-    }
-
-    if (important.length > 0) {
-      context.addHeader("IMPORTANT", important);
-    }
-
-    if (warnings.length > 0) {
-      context.addHeader("NEVER", warnings);
-    }
-
-    context.addHeader("CURRENT_RESULTS", results);
-    return context;
-  }
-
-  async process(
-    prompt: string,
-    state: State,
-    onFinish?: (event: any) => void
-  ): Promise<
-    | {
-        actionsCompleted: {
-          name: string;
-          reasoning: string;
-        }[];
-        response: string;
-      }
-    | StreamTextResult<Record<string, any>>
-  > {
-    try {
-      console.log("\n🎨 Starting interpretation process");
-      console.log("Prompt:", prompt);
-      console.log("Results to interpret:", JSON.stringify(state, null, 2));
-
-      const context = this.buildContext(state);
-      console.log("Context:", context.toString());
-      const result = await generateObject<InterpretationResult>({
-        model: this.model,
-        prompt,
-        system: context.toString(),
-        temperature: 1.3,
-        schema: interpreterSchema,
-      });
-
-      if (onFinish) onFinish(result.object);
-      return result.object;
-    } catch (error) {
-      console.error("Error parsing schema:", error);
-      throw error;
-    }
-  }
-
-  async streamProcess(
-    prompt: string,
-    state: State,
-    onFinish?: (event: any) => void
-  ): Promise<any> {
-    console.log("\n🎨 Starting streaming interpretation");
-    console.log("Prompt:", prompt);
-
-    const context = this.buildContext(state);
-
-    const result = await streamText({
-      model: this.model,
-      onFinish: (event) => {
-        console.log("\n✅ Streaming interpretation completed");
-        if (onFinish) onFinish(event);
-      },
-      prompt,
-      system: context.toString(),
-      temperature: 1.3,
-    });
-
-    return result;
-  }
-}