@ai.ntellect/core 1.0.0 → 1.1.1

package/utils/generate-action-schema.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { GraphFlow } from "../execution/index";
+
+export const generateActionSchema = (graphs: GraphFlow<any>[]) => {
+  return graphs
+    .map((graph) => {
+      const rootNode = Array.from(graph.nodes.values())[0];
+      const schemaStr = rootNode.params
+        ? getSchemaString(rootNode.params)
+        : "No parameters";
+      return `Workflow: ${graph.name}\nParameters: ${schemaStr}`;
+    })
+    .join("\n\n");
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const getSchemaString = (schema: any): 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);
+      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()";
+  }
+
+  return `z.unknown()`;
+};

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/logger.ts

@@ -0,0 +1,40 @@
+import pino from 'pino';
+
+/**
+ * Shared Pino logger for the CortexFlow runtime.
+ *
+ * Pretty-prints in development with `HH:MM:ss Z` timestamps.
+ * Use `logger.child({ sessionId, traceId })` inside every session scope so log
+ * lines can be correlated across a full orchestration trace.
+ *
+ * @example
+ * ```ts
+ * import logger from '../utils/logger';
+ *
+ * const log = logger.child({ sessionId: 'abc', traceId: 'trace_123' });
+ * log.info({ intent: 'FETCH_MAILS' }, 'Intent classified');
+ * log.warn({ confidence: 0.4 }, 'Low confidence — requesting clarification');
+ * ```
+ */
+const logger = pino({
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+      translateTime: 'HH:MM:ss Z',
+      ignore: 'pid,hostname',
+    },
+  },
+});
+
+/**
+ * Creates a child logger pre-bound with session and trace identifiers.
+ *
+ * @param sessionId - Stable session ID returned by `CortexFlowOrchestrator.startSession()`.
+ * @param traceId - Correlation ID propagated through all token data and log entries.
+ */
+export const createLogger = (sessionId?: string, traceId?: string) => {
+  return logger.child({ sessionId, traceId });
+};
+
+export default logger;

package/package copy.json

@@ -1,21 +0,0 @@
-{
-  "name": "@ai.ntellect/workflow",
-  "version": "1.0.0",
-  "description": "A robust framework for managing and executing workflows, supporting dynamic decision-making, conditional paths, event-driven execution, and state persistence.",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rm -rf dist && tsc"
-  },
-  "keywords": [],
-  "author": "Lorcann Rauzduel",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ai-ntellect/workflow.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ai-ntellect/workflow/issues"
-  },
-  "homepage": "https://github.com/ai-ntellect/workflow#readme"
-}

package/types.ts

@@ -1,62 +0,0 @@
-export interface SharedState<T> {
-  messages?: { [key: string]: any }[]; // 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/executor.ts

@@ -1,42 +0,0 @@
-import { Workflow } from "..";
-
-export class Executor {
-  private workflows: Record<string, Workflow<any>>;
-
-  constructor() {
-    this.workflows = {};
-  }
-
-  addWorkflow(workflowName: string, workflowInstance: Workflow<any>) {
-    this.workflows[workflowName] = workflowInstance;
-  }
-
-  async executeWorkflowsInParallel(
-    workflowNames: string[],
-    initialState: any,
-    concurrencyLimit: number = 5
-  ) {
-    console.log(
-      `\n🚀 Starting parallel execution of workflows: ${workflowNames.join(
-        ", "
-      )}`
-    );
-
-    const workflowPromises = workflowNames.map(async (workflowName) => {
-      const workflow = this.workflows[workflowName];
-      if (!workflow) {
-        console.error(`❌ Workflow not found: ${workflowName}`);
-        return;
-      }
-
-      console.log(`➡️ Starting execution of workflow: ${workflowName}`);
-      const nodeNames = Array.from(workflow.nodes.keys());
-      await workflow.executeParallel(initialState, nodeNames, concurrencyLimit);
-      console.log(`✔️ Workflow "${workflowName}" completed.`);
-    });
-
-    await Promise.all(workflowPromises);
-
-    console.log("\n✅ All workflows executed successfully.");
-  }
-}