@ai.ntellect/core 1.0.0 → 1.1.0

package/agent/handlers/cognitive-handler.ts

@@ -0,0 +1,197 @@
+import { z } from "zod";
+import { AgentContext } from "../../types/agent";
+import { AgentLogger, LogLevel } from "../tools/logger";
+
+const DEFAULT_DYNAMIC_GOAL_PROMPT = `Contexte actuel:
+- Input utilisateur: {input}
+- Actions déjà exécutées: {executedActions}
+- Résultats disponibles: {results}
+- Goal original: {originalGoal}
+
+Réponds uniquement avec le format JSON: {"goal": "votre sous-goal en 1-2 phrases"}
+Le sous-goal doit être la prochaine étape à accomplir.`;
+
+const DEFAULT_DYNAMIC_NEXT_PROMPT = `Contexte actuel:
+- État actuel: {currentState}
+- Input utilisateur: {input}
+- Goal: {goal}
+- Actions exécutées: {executedActions}
+- Résultats disponibles: {results}
+- Nombre d'itérations: {iteration}
+
+Nodes cognitifs disponibles:
+- defineGoal: Déterminer le goal dynamique
+- think: Analyser le contexte et décider des actions
+- execute: Exécuter les outils/actions
+- plan: Planifier les étapes suivantes
+- schedule: Planifier une tâche pour plus tard (utilise le module Agenda)
+- reply: Répondre à l'utilisateur
+- ask: Poser une question clarificatrice
+- end: Terminer le workflow
+
+Choisis le prochain node le plus approprié.
+Réponds uniquement: {"next": "nom_du_node", "reason": "explication courte"}`;
+
+export const COGNITIVE_NODES = ["defineGoal", "think", "execute", "plan", "schedule", "reply", "ask", "end"];
+
+type LLM = {
+  generate: (messages: { system: string; user: string }, schema: any) => Promise<{ object: any }>;
+};
+
+export class CognitiveHandler {
+  private dynamicGoalEnabled: boolean;
+  private dynamicNextEnabled: boolean;
+  private goalPromptTemplate: string;
+  private nextPromptTemplate: string;
+  private currentGoal: string;
+  private currentState: string;
+
+  constructor(
+    private llm: LLM,
+    private logger: AgentLogger,
+    private options: {
+      dynamicGoal?: boolean;
+      goalPrompt?: string;
+      initialGoal?: string;
+      dynamicNext?: boolean;
+      nextPrompt?: string;
+    } = {}
+  ) {
+    this.dynamicGoalEnabled = options.dynamicGoal ?? false;
+    this.dynamicNextEnabled = options.dynamicNext ?? false;
+    this.goalPromptTemplate = options.goalPrompt ?? DEFAULT_DYNAMIC_GOAL_PROMPT;
+    this.nextPromptTemplate = options.nextPrompt ?? DEFAULT_DYNAMIC_NEXT_PROMPT;
+    this.currentGoal = options.initialGoal ?? "";
+    this.currentState = "defineGoal";
+  }
+
+  setGoal(goal: string): void {
+    this.currentGoal = goal;
+    this.log("info", `Goal adjusted: ${goal}`);
+  }
+
+  getCurrentGoal(): string {
+    return this.currentGoal;
+  }
+
+  getCurrentState(): string {
+    return this.currentState;
+  }
+
+  setCurrentState(state: string): void {
+    if (COGNITIVE_NODES.includes(state)) {
+      this.currentState = state;
+    }
+  }
+
+  getAvailableNodes(): string[] {
+    return COGNITIVE_NODES;
+  }
+
+  setEnabled(opts: { dynamicGoal?: boolean; dynamicNext?: boolean }): void {
+    if (opts.dynamicGoal !== undefined) this.dynamicGoalEnabled = opts.dynamicGoal;
+    if (opts.dynamicNext !== undefined) this.dynamicNextEnabled = opts.dynamicNext;
+  }
+
+  async computeGoal(context: AgentContext): Promise<string> {
+    if (!this.dynamicGoalEnabled) return this.currentGoal;
+
+    this.log("thinking", "Computing dynamic goal...");
+
+    const executedTools = context.executedActions.map(a => a.name);
+    const results = context.executedActions
+      .map(a => `${a.name}: ${JSON.stringify(a.result)}`)
+      .join("\n");
+
+    const prompt = this.goalPromptTemplate
+      .replace("{input}", context.input.raw)
+      .replace("{executedActions}", executedTools.join(", ") || "Aucune")
+      .replace("{results}", results || "Aucun résultat")
+      .replace("{originalGoal}", this.currentGoal);
+
+    try {
+      const result = await this.llm.generate(
+        {
+          system: "Tu dois répondre au format JSON exact: {\"goal\": \"votre texte\"}. Sois concis.",
+          user: prompt,
+        },
+        z.object({
+          goal: z.string(),
+        }).transform(v => ({ goal: v.goal || "Accomplir la tâche" }))
+      );
+
+      const computedGoal = result.object?.goal || this.currentGoal;
+      this.currentGoal = computedGoal;
+      this.log("info", `Dynamic goal: ${computedGoal}`);
+      return computedGoal;
+    } catch (error) {
+      this.log("warning", `Failed to compute dynamic goal: ${error}, falling back to original`);
+      return this.currentGoal;
+    }
+  }
+
+  async computeNext(context: AgentContext, currentState: string, iteration: number): Promise<string> {
+    if (!this.dynamicNextEnabled) {
+      return this.getDefaultNextState(currentState, context);
+    }
+
+    this.log("thinking", `Computing next state from "${currentState}"...`);
+
+    const executedTools = context.executedActions.map(a => a.name);
+    const results = context.executedActions
+      .map(a => `${a.name}: ${JSON.stringify(a.result)}`)
+      .join("\n");
+
+    const prompt = this.nextPromptTemplate
+      .replace("{currentState}", currentState)
+      .replace("{input}", context.input.raw)
+      .replace("{goal}", this.currentGoal)
+      .replace("{executedActions}", executedTools.join(", ") || "Aucune")
+      .replace("{results}", results || "Aucun résultat")
+      .replace("{iteration}", String(iteration));
+
+    try {
+      const result = await this.llm.generate(
+        {
+          system: "Tu es un assistant qui détermine le prochain état cognitif. Réponds uniquement en JSON.",
+          user: prompt,
+        },
+        z.object({
+          next: z.string(),
+          reason: z.string().optional(),
+        }).transform(v => ({
+          next: COGNITIVE_NODES.includes(v.next) ? v.next : "think",
+          reason: v.reason
+        }))
+      );
+
+      const nextState = result.object.next;
+      this.currentState = nextState;
+      this.log("info", `Next state: ${nextState}${result.object.reason ? ` (${result.object.reason})` : ''}`);
+      return nextState;
+    } catch (error) {
+      this.log("warning", `Failed to compute next state: ${error}, using default`);
+      return this.getDefaultNextState(currentState, context);
+    }
+  }
+
+  private getDefaultNextState(currentState: string, context: AgentContext): string {
+    switch (currentState) {
+      case "defineGoal": return "think";
+      case "think": return context.actions && context.actions.length > 0 ? "execute" : "reply";
+      case "execute": return context.executedActions && context.executedActions.length > 0 ? "think" : "reply";
+      case "plan": return "think";
+      case "schedule": return "think";
+      case "reply": return "end";
+      case "ask": return "think";
+      default: return "think";
+    }
+  }
+
+  private log(type: "info" | "success" | "warning" | "error" | "thinking", message: string) {
+    const levelMap: Record<string, LogLevel> = {
+      info: "info", success: "info", warning: "warn", error: "error", thinking: "info",
+    };
+    this.logger.log(levelMap[type], "cognitive", message);
+  }
+}

package/agent/handlers/index.ts

@@ -0,0 +1 @@
+export { CognitiveHandler, COGNITIVE_NODES } from "./cognitive-handler";

package/agent/handoff.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { GraphFlow } from "../execution/index";
+import { AgentRegistry } from "./registry";
+import { AgentLogger } from "./tools/logger";
+
+export function createHandoffTool(registry?: AgentRegistry): GraphFlow<any> {
+  return new GraphFlow({
+    name: "handoff",
+    schema: z.object({
+      targetAgent: z.string().describe("Nom de l'agent cible (enregistré dans le registry)"),
+      task: z.string().describe("Description de la tâche à déléguer"),
+      contextData: z.string().optional().describe("Données de contexte supplémentaires en JSON"),
+    }),
+    context: { targetAgent: "", task: "", contextData: "" },
+    nodes: [
+      {
+        name: "handoff",
+        execute: async (ctx: any) => {
+          const { targetAgent, task } = ctx;
+          if (!targetAgent) {
+            throw new Error("Handoff: targetAgent requis");
+          }
+          if (registry && !registry.has(targetAgent)) {
+            const logger = new AgentLogger();
+            logger.warn("handoff", `Agent "${targetAgent}" non trouvé dans le registry, handoff ignoré`);
+            return;
+          }
+          ctx._handoff = {
+            goto: targetAgent,
+            graph: "PARENT",
+            update: { handoffTask: task, handoffFrom: ctx._agentName || "unknown" },
+            metadata: {
+              sourceAgent: ctx._agentName || "unknown",
+              handoffTime: Date.now(),
+            },
+          };
+        },
+        next: [],
+      },
+    ],
+  });
+}
+
+export function createCommand(
+  goto: string,
+  update?: Record<string, any>,
+  metadata?: Record<string, any>
+) {
+  return {
+    goto,
+    update,
+    graph: "PARENT" as const,
+    metadata: {
+      ...metadata,
+      timestamp: Date.now(),
+    },
+  };
+}

package/agent/llm-factory.ts

@@ -0,0 +1,343 @@
+import chalk from "chalk";
+import { LLMConfig, LLMProvider, PromptInput } from "@/types/agent";
+import { openai } from "@ai-sdk/openai";
+import { generateObject } from "ai";
+import { z } from "zod";
+
+const DEFAULT_GROQ_MODEL = "llama-3.1-8b-instant";
+
+const GROQ_FALLBACK_MODELS = [
+  "allam-2-7b",
+  "groq/compound-mini", 
+  "groq/compound",
+  "qwen/qwen3-32b",
+  "llama-3.3-70b-versatile",
+  "meta-llama/llama-4-scout-17b-16e-instruct",
+];
+
+const DEFAULT_FALLBACK_MODEL = "llama-3.1-8b-instant";
+
+interface LLMUsage {
+  promptTokens: number;
+  completionTokens: number;
+}
+
+interface LLMResult {
+  object: any;
+  usage?: LLMUsage;
+  duration: number;
+}
+
+interface LLMInstance {
+  generate: (prompt: string | PromptInput, schema: z.ZodType<any>) => Promise<LLMResult>;
+}
+
+function createOpenAICompatibleLLM(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  providerName: string
+): LLMInstance {
+  return {
+    generate: async (
+      prompt: string | PromptInput,
+      schema: z.ZodType<any>
+    ) => {
+      const t0 = performance.now();
+      const userPrompt = typeof prompt === "string" ? prompt : prompt.user;
+      const systemPrompt = typeof prompt === "string" ? undefined : prompt.system;
+
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: model,
+          messages: [
+            ...(systemPrompt ? [{ role: "system", content: systemPrompt }] : []),
+            { role: "user", content: userPrompt },
+          ],
+          temperature: 0.7,
+          max_tokens: 4096,
+          response_format: { type: "json_object" },
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`${providerName} API error (${response.status}): ${errorText}`);
+      }
+
+      const data = await response.json();
+      const duration = performance.now() - t0;
+      const usage: LLMUsage | undefined = data.usage
+        ? { promptTokens: data.usage.prompt_tokens ?? 0, completionTokens: data.usage.completion_tokens ?? 0 }
+        : undefined;
+      let content = data.choices?.[0]?.message?.content || "";
+
+      try {
+        const parsed = JSON.parse(content);
+        const validated = schema.parse(parsed);
+        return { object: validated, usage, duration };
+      } catch (e: any) {
+        console.log(chalk.yellow(`[WARN] ${providerName} JSON parse error: ${e.message}`));
+        return { object: { actions: [], response: content.substring(0, 200) }, usage, duration };
+      }
+    },
+  };
+}
+
+function createLLMWithFallback(
+  baseUrl: string,
+  apiKey: string,
+  primaryModel: string,
+  fallbackModels: string[],
+  providerName: string
+): LLMInstance {
+  const allModels = [primaryModel, ...fallbackModels];
+  let currentModelIndex = 0;
+
+  return {
+    generate: async (prompt: string | PromptInput, schema: z.ZodType<any>) => {
+      let lastError: Error | null = null;
+
+      for (const model of allModels.slice(currentModelIndex)) {
+        try {
+          // model trying info suppressed for cleaner CLI
+          const llm = createOpenAICompatibleLLM(baseUrl, apiKey, model, providerName);
+          const result = await llm.generate(prompt, schema);
+          
+          if (result?.object) {
+            currentModelIndex = allModels.indexOf(model);
+            return result;
+          }
+        } catch (error: any) {
+          lastError = error;
+          
+          const isRateLimit = error.message?.includes("429") || 
+                           error.message?.includes("rate limit");
+          
+          if (isRateLimit) {
+            console.log(chalk.yellow(`[WARN] Rate limit for ${model}, trying fallback...`));
+            continue;
+          }
+          
+          console.log(chalk.yellow(`[WARN] ${providerName} error: ${error.message}`));
+          
+          if (error.message?.includes("500") || error.message?.includes("502") || error.message?.includes("503")) {
+            continue;
+          }
+          
+          throw error;
+        }
+      }
+
+      throw lastError || new Error(`All ${providerName} models failed`);
+    },
+  };
+}
+
+/**
+ * Factory class for creating Language Model instances based on configuration
+ * @class LLMFactory
+ */
+export class LLMFactory {
+  /**
+   * Creates an LLM instance based on the provided configuration
+   * @static
+   * @param {LLMConfig} config - Configuration for the LLM
+   * @returns {Object} An object with a generate method for interacting with the LLM
+   * @throws {Error} When an unsupported provider is specified or custom provider lacks required function
+   */
+  static createLLM(config: LLMConfig) {
+    switch (config.provider) {
+      case "openai":
+        return {
+          generate: async (
+            prompt: string | PromptInput,
+            schema: z.ZodType<any>
+          ) => {
+            const t0 = performance.now();
+            const result = await generateObject({
+              model: openai(config.model),
+              temperature: config.temperature ?? 0.7,
+              maxTokens: config.maxTokens,
+              prompt: typeof prompt === "string" ? prompt : prompt.user,
+              system: typeof prompt === "string" ? undefined : prompt.system,
+              schema,
+            });
+            const duration = performance.now() - t0;
+            return {
+              object: result.object,
+              usage: result.usage
+                ? { promptTokens: result.usage.promptTokens ?? 0, completionTokens: result.usage.completionTokens ?? 0 }
+                : undefined,
+              duration,
+            };
+          },
+        };
+      case "ollama":
+        return {
+          generate: async (
+            prompt: string | PromptInput,
+            schema: z.ZodType<any>
+          ) => {
+            const t0 = performance.now();
+            const baseUrl = config.baseUrl || "http://localhost:11434";
+            const userPrompt = typeof prompt === "string" ? prompt : prompt.user;
+            const systemPrompt = typeof prompt === "string" ? undefined : prompt.system;
+
+            const response = await fetch(`${baseUrl}/api/chat`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                model: config.model,
+                messages: [
+                  ...(systemPrompt ? [{ role: "system", content: systemPrompt }] : []),
+                  { role: "user", content: userPrompt + "\n\nImportant: Respond ONLY with valid JSON matching the required schema." },
+                ],
+                stream: false,
+              }),
+            });
+
+            if (!response.ok) {
+              const errorText = await response.text();
+              throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+            }
+
+            const data = await response.json();
+            const duration = performance.now() - t0;
+            const usage: LLMUsage | undefined = data.usage
+              ? { promptTokens: data.usage.prompt_eval_count ?? 0, completionTokens: data.usage.eval_count ?? 0 }
+              : undefined;
+            let content = data.message?.content || "";
+            
+            if (data.message?.thinking) {
+              console.log(chalk.cyan('\n[REASONING] ') + data.message.thinking.substring(0, 500) + '...\n');
+            }
+
+            let parsed: any;
+            const firstBrace = content.indexOf('{');
+            
+            const errResult = (obj: any) => ({ object: obj, usage, duration });
+
+            if (firstBrace !== -1) {
+              let endBrace = -1;
+              let braceCount = 0;
+              for (let i = firstBrace; i < content.length; i++) {
+                if (content[i] === '{') braceCount++;
+                else if (content[i] === '}') {
+                  braceCount--;
+                  if (braceCount === 0) {
+                    endBrace = i;
+                    break;
+                  }
+                }
+              }
+              
+              if (endBrace !== -1) {
+                const jsonStr = content.substring(firstBrace, endBrace + 1);
+                try {
+                  parsed = JSON.parse(jsonStr);
+                } catch (e: any) {
+                  console.log(chalk.yellow('[WARN] Truncated JSON, attempting repair...'));
+                  const repaired = jsonStr.replace(/,(\s*[}\]])/g, '$1').replace(/([}\]])(\s*[,\n])/g, '$1$2');
+                  try {
+                    parsed = JSON.parse(repaired);
+                  } catch {
+                    console.log(chalk.yellow('[WARN] Repair failed, extracting partial actions...'));
+                    const actionMatches = jsonStr.matchAll(/"name"\s*:\s*"([^"]+)"/g);
+                    const actions = [];
+                    for (const match of actionMatches) {
+                      actions.push({ name: match[1], parameters: {} });
+                    }
+                    if (actions.length > 0) {
+                      parsed = { actions, response: "Partial response" };
+                    } else {
+                      return errResult({ actions: [], response: content.substring(0, 200) });
+                    }
+                  }
+                }
+              } else {
+                console.log(chalk.yellow('[WARN] Incomplete JSON, returning empty response'));
+                return errResult({ actions: [], response: content.substring(0, 100) });
+              }
+            } else {
+              return errResult({ actions: [], response: content.substring(0, 200) });
+            }
+
+            const validated = schema.parse(parsed);
+            return { object: validated, usage, duration };
+          },
+        };
+      case "groq":
+        return createLLMWithFallback(
+          "https://api.groq.com/openai/v1",
+          config.apiKey || "",
+          config.model || DEFAULT_GROQ_MODEL,
+          GROQ_FALLBACK_MODELS,
+          "Groq"
+        );
+      case "openrouter":
+        return createLLMWithFallback(
+          "https://openrouter.ai/api/v1",
+          config.apiKey || "",
+          config.model || "google/gemini-flash-1.5",
+          [],
+          "OpenRouter"
+        );
+      case "google":
+        return {
+          generate: async (prompt: string | PromptInput, schema: z.ZodType<any>) => {
+            const t0 = performance.now();
+            const userPrompt = typeof prompt === "string" ? prompt : prompt.user;
+            const systemPrompt = typeof prompt === "string" ? undefined : prompt.system;
+            const apiKey = config.apiKey || "";
+            const model = config.model || "gemini-flash-1.5";
+            const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+            const body = {
+              contents: [{
+                parts: [{ text: `${systemPrompt ? `System: ${systemPrompt}\n\n` : ""}${userPrompt}` }]
+              }],
+              generationConfig: { temperature: 0.7, maxOutputTokens: 4096 }
+            };
+            const response = await fetch(url, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(body)
+            });
+            if (!response.ok) {
+              const errorText = await response.text();
+              throw new Error(`Google API error (${response.status}): ${errorText}`);
+            }
+            const data = await response.json();
+            const duration = performance.now() - t0;
+            const usage: LLMUsage | undefined = data.usageMetadata
+              ? {
+                  promptTokens: data.usageMetadata.promptTokenCount ?? 0,
+                  completionTokens: data.usageMetadata.candidatesTokenCount ?? 0,
+                }
+              : undefined;
+            const text = data.candidates?.[0]?.content?.parts?.[0]?.text || "";
+            try {
+              const parsed = JSON.parse(text);
+              return { object: schema.parse(parsed), usage, duration };
+            } catch {
+              return { object: { actions: [], response: text.substring(0, 200) }, usage, duration };
+            }
+          }
+        };
+      case "custom":
+        if (!config.customCall) {
+          throw new Error("Custom LLM provider requires a customCall function");
+        }
+        return {
+          generate: config.customCall,
+        };
+      default:
+        throw new Error(`Unsupported LLM provider: ${config.provider}`);
+    }
+  }
+}

package/agent/orchestrator.ts

@@ -0,0 +1,45 @@
+import { AgentContext } from "../types/agent";
+import { Agent } from "./agent";
+import { AgentRegistry } from "./registry";
+
+export type OrchestratorConfig = {
+  mainAgent: Agent;
+  registry: AgentRegistry;
+  autoHandoff?: boolean;
+};
+
+export class OrchestratorAgent {
+  private mainAgent: Agent;
+  private registry: AgentRegistry;
+  private autoHandoff: boolean;
+
+  constructor(config: OrchestratorConfig) {
+    this.mainAgent = config.mainAgent;
+    this.registry = config.registry;
+    this.autoHandoff = config.autoHandoff ?? true;
+  }
+
+  async process(input: string): Promise<AgentContext> {
+    const ctx = await this.mainAgent.process(input);
+
+    const handoff = (ctx as any)._handoff;
+    if (handoff && handoff.graph === "PARENT" && this.autoHandoff) {
+      const targetName = handoff.goto;
+      const target = this.registry.getAgent(targetName);
+      if (target) {
+        const handoffTask = handoff.update?.handoffTask || input;
+        return target.process(handoffTask);
+      }
+    }
+
+    return ctx;
+  }
+
+  getMainAgent(): Agent {
+    return this.mainAgent;
+  }
+
+  getRegistry(): AgentRegistry {
+    return this.registry;
+  }
+}