@ai.ntellect/core 0.4.0 → 0.5.0

package/types.ts

@@ -1,4 +1,4 @@
-import { Embedding, EmbeddingModel, StreamTextResult } from "ai";
+import { CoreMessage, Embedding, EmbeddingModel, StreamTextResult } from "ai";
 import { z } from "zod";
 
 export interface BaseLLM {
@@ -70,11 +70,6 @@ export type Behavior = {
   }[];
 };
 
-export type State = {
-  userRequest: string;
-  results: string;
-};
-
 export interface ActionSchema {
   name: string;
   description: string;
@@ -153,7 +148,10 @@ export interface CacheMemoryOptions {
 }
 
 export type GenerateObjectResponse = {
-  shouldContinue: boolean;
+  processing: {
+    stop: boolean;
+    stopReason?: string;
+  };
   actions: Array<{
     name: string;
     parameters: Array<{
@@ -166,11 +164,7 @@ export type GenerateObjectResponse = {
       reason?: string;
     };
   }>;
-  socialResponse?: {
-    shouldRespond: boolean;
-    response?: string;
-    isPartialResponse?: boolean;
-  };
+  response: string;
   interpreter?: string;
 };
 
@@ -286,3 +280,88 @@ export interface WorkflowPattern {
   }>;
   success: boolean;
 }
+
+// État partagé
+export type MyContext = {
+  prompt?: string;
+  processing: {
+    stop: boolean;
+    reason?: string;
+  };
+  actions?: {
+    name: string;
+    parameters: Record<string, any>;
+    result?: any;
+    error?: any;
+    scheduler?: {
+      isScheduled: boolean;
+      cronExpression?: string;
+      reason?: string;
+    };
+  }[];
+  interpreter?: string | null;
+  results?: any;
+};
+
+export interface SharedState<T> {
+  messages?: CoreMessage[]; // Historique des interactions
+  context: T;
+}
+
+export function mergeState<T>(
+  current: SharedState<T>,
+  updates: Partial<SharedState<T>>
+): SharedState<T> {
+  const uniqueMessages = new Map(
+    [...(current.messages || []), ...(updates.messages || [])].map((msg) => [
+      JSON.stringify(msg),
+      msg,
+    ])
+  );
+  return {
+    ...current,
+    context: { ...current.context, ...updates.context },
+    messages: Array.from(uniqueMessages.values()), // Messages uniques
+  };
+}
+export interface RetryConfig {
+  maxRetries: number;
+  retryDelay: number;
+  shouldRetry?: (error: Error) => boolean;
+}
+
+export interface Node<T> {
+  name: string;
+  description?: string;
+  execute: (state: SharedState<T>) => Promise<Partial<SharedState<T>>>;
+  condition?: (state: SharedState<T>) => boolean;
+  next?: string[];
+  events?: string[];
+  retry?: RetryConfig;
+}
+
+export interface Persistence<T> {
+  saveState(
+    graphName: string,
+    state: SharedState<T>,
+    currentNode: string
+  ): Promise<void>;
+  loadState(
+    graphName: string
+  ): Promise<{ state: SharedState<T>; currentNode: string } | null>;
+}
+
+export interface RealTimeNotifier {
+  notify(event: string, data: any): void;
+}
+
+export interface WorkflowDefinition<T> {
+  name: string;
+  nodes: {
+    [key: string]: Node<T> & {
+      condition?: (state: SharedState<T>) => boolean;
+      next?: string[];
+    };
+  };
+  entryNode: string;
+}

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/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/state-manager.ts

@@ -0,0 +1,25 @@
+import { MyContext, SharedState } from "../types";
+
+export class StateManager {
+  /**
+   * Updates the shared state while preserving immutability
+   * @param currentState Current shared state
+   * @param updates Partial updates to apply
+   * @returns Updated shared state
+   */
+  static updateState(
+    currentState: SharedState<MyContext>,
+    updates: Partial<SharedState<MyContext>>
+  ): SharedState<MyContext> {
+    const updatedState = {
+      ...currentState,
+      ...updates,
+      context: {
+        ...currentState.context,
+        ...(updates.context || {}),
+      },
+    };
+    console.log("🔄 Updated State:", updatedState);
+    return updatedState;
+  }
+}

package/bull.ts

@@ -1,5 +0,0 @@
-import cron from "node-cron";
-
-cron.schedule("* * * * *", () => {
-  console.log("running a task every minute");
-});

package/services/redis-cache.ts

@@ -1,128 +0,0 @@
-import Redis from "ioredis";
-import cron from "node-cron";
-
-export interface CacheConfig {
-  host: string;
-  port: number;
-  password?: string;
-  ttl?: number; // Time to live in seconds (default 30 minutes)
-  cleanupInterval?: string; // Cron expression (default every 30 minutes)
-}
-
-export class RedisCache {
-  private redis: Redis;
-  private readonly defaultTTL: number;
-  private readonly cleanupJob: cron.ScheduledTask;
-
-  constructor(config: CacheConfig) {
-    this.redis = new Redis({
-      host: config.host,
-      port: config.port,
-      password: config.password,
-    });
-
-    this.defaultTTL = config.ttl || 1800; // 30 minutes in seconds
-
-    // Setup cleanup job (default: every 30 minutes)
-    this.cleanupJob = cron.schedule(
-      config.cleanupInterval || "*/30 * * * *",
-      () => this.cleanup()
-    );
-  }
-
-  /**
-   * Store previous actions for a specific request
-   */
-  async storePreviousActions(requestId: string, actions: any[]): Promise<void> {
-    const key = `previous_actions:${requestId}`;
-    await this.redis.setex(
-      key,
-      this.defaultTTL,
-      JSON.stringify({
-        timestamp: new Date().toISOString(),
-        actions,
-      })
-    );
-  }
-
-  /**
-   * Get previous actions for a specific request
-   */
-  async getPreviousActions(requestId: string): Promise<any[]> {
-    const key = `previous_actions:${requestId}`;
-    const data = await this.redis.get(key);
-    if (!data) return [];
-
-    const parsed = JSON.parse(data);
-    return parsed.actions;
-  }
-
-  /**
-   * Store a recent message
-   */
-  async storeRecentMessage(
-    message: string,
-    metadata?: Record<string, any>
-  ): Promise<void> {
-    const id = crypto.randomUUID();
-    const key = `recent_messages:${id}`;
-    await this.redis.setex(
-      key,
-      this.defaultTTL,
-      JSON.stringify({
-        timestamp: new Date().toISOString(),
-        message,
-        metadata,
-      })
-    );
-  }
-
-  /**
-   * Get recent messages
-   */
-  async getRecentMessages(limit: number = 10): Promise<any[]> {
-    const keys = await this.redis.keys("recent_messages:*");
-    if (!keys.length) return [];
-
-    const messages = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-
-    return messages
-      .filter(Boolean)
-      .sort(
-        (a, b) =>
-          new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
-      )
-      .slice(0, limit);
-  }
-
-  /**
-   * Cleanup expired keys
-   */
-  private async cleanup(): Promise<void> {
-    console.log("🧹 Starting cache cleanup...");
-    try {
-      // Redis automatically removes expired keys
-      // This is just for logging purposes
-      const actionKeys = await this.redis.keys("previous_actions:*");
-      const messageKeys = await this.redis.keys("recent_messages:*");
-      console.log(
-        `Cache status: ${actionKeys.length} actions, ${messageKeys.length} messages`
-      );
-    } catch (error) {
-      console.error("❌ Cache cleanup error:", error);
-    }
-  }
-
-  /**
-   * Stop the cleanup job and close Redis connection
-   */
-  async close(): Promise<void> {
-    this.cleanupJob.stop();
-    await this.redis.quit();
-  }
-}

package/t.spec

@@ -1,38 +0,0 @@
-# -*- mode: python ; coding: utf-8 -*-
-
-
-a = Analysis(
-    ['t.py'],
-    pathex=[],
-    binaries=[],
-    datas=[],
-    hiddenimports=[],
-    hookspath=[],
-    hooksconfig={},
-    runtime_hooks=[],
-    excludes=[],
-    noarchive=False,
-    optimize=0,
-)
-pyz = PYZ(a.pure)
-
-exe = EXE(
-    pyz,
-    a.scripts,
-    a.binaries,
-    a.datas,
-    [],
-    name='t',
-    debug=False,
-    bootloader_ignore_signals=False,
-    strip=False,
-    upx=True,
-    upx_exclude=[],
-    runtime_tmpdir=None,
-    console=True,
-    disable_windowed_traceback=False,
-    argv_emulation=False,
-    target_arch=None,
-    codesign_identity=None,
-    entitlements_file=None,
-)