@ai.ntellect/core 1.0.0 → 1.1.1

package/test/routing/intent-classifier.test.ts

@@ -0,0 +1,102 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { IntentClassifier, IntentClassifierFn } from '../../routing/intent-classifier';
+
+describe('IntentClassifier', () => {
+  it('should classify a simple intent', async () => {
+    const mockLLM = async (prompt: string) => {
+      return JSON.stringify({
+        intent: 'APPROVE',
+        confidence: 0.95,
+        entities: { id: 'task_123' },
+      });
+    };
+
+    const classifier = new IntentClassifier(mockLLM);
+    const result = await classifier.classify('Approve task T-123');
+
+    expect(result.intent).to.equal('APPROVE');
+    expect(result.confidence).to.be.above(0.9);
+    expect(result.entities).to.deep.equal({ id: 'task_123' });
+  });
+
+  it('should return UNKNOWN on LLM failure', async () => {
+    const mockLLM = async (prompt: string) => {
+      throw new Error('LLM unavailable');
+    };
+
+    const classifier = new IntentClassifier(mockLLM);
+    const result = await classifier.classify('Some message');
+
+    expect(result.intent).to.equal('UNKNOWN');
+    expect(result.confidence).to.equal(0);
+  });
+
+  it('should handle low confidence (ambiguity)', async () => {
+    const mockLLM = async (prompt: string) => {
+      return JSON.stringify({
+        intent: 'QUERY',
+        confidence: 0.4,
+        entities: {},
+      });
+    };
+
+    const classifier = new IntentClassifier(mockLLM, {
+      confidenceThreshold: 0.6,
+    });
+    const result = await classifier.classify('What is the status?');
+    expect(result.confidence).to.be.below(0.6);
+    expect(classifier.getConfidenceThreshold()).to.equal(0.6);
+  });
+
+  it('should include turn history in context', async () => {
+    let capturedPrompt = '';
+    const mockLLM = async (prompt: string) => {
+      capturedPrompt = prompt;
+      return JSON.stringify({
+        intent: 'CANCEL',
+        confidence: 0.85,
+        entities: {},
+      });
+    };
+
+    const classifier = new IntentClassifier(mockLLM);
+    await classifier.classify('Cancel my order', {
+      turnHistory: ['I want to order', 'Here is your order #456'],
+    });
+
+    expect(capturedPrompt).to.include('order #456');
+    expect(capturedPrompt).to.include('Recent history');
+  });
+
+  it('should use custom intents list', async () => {
+    const mockLLM = async (prompt: string) => {
+      return JSON.stringify({
+        intent: 'GREETING',
+        confidence: 0.9,
+        entities: {},
+      });
+    };
+
+    const classifier = new IntentClassifier(mockLLM, {
+      intents: ['GREETING', 'FAREWELL', 'UNKNOWN'],
+    });
+    const result = await classifier.classify('Hello there!');
+    expect(result.intent).to.equal('GREETING');
+  });
+
+  it('should work as IntentClassifierFn', async () => {
+    const mockLLM = async (prompt: string) => {
+      return JSON.stringify({
+        intent: 'APPROVE',
+        confidence: 0.9,
+        entities: {},
+      });
+    };
+
+    const classifier = new IntentClassifier(mockLLM);
+    const fn: IntentClassifierFn = IntentClassifier.toFn(classifier);
+    const result = await fn('Approve this', { turnHistory: ['Previous message'] });
+    expect(result.intent).to.equal('APPROVE');
+  });
+});

package/test/routing/petri.test.ts

@@ -0,0 +1,156 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import { PetriNet } from '../../routing/index';
+import { Transition, Token } from '../../routing/types';
+
+describe('PetriNet', () => {
+  let net: PetriNet;
+
+  beforeEach(() => {
+    net = new PetriNet('test');
+  });
+
+  it('should create an empty net', () => {
+    expect(net.name).to.equal('test');
+    expect(net.places.size).to.equal(0);
+  });
+
+  it('should add places and initial tokens', () => {
+    net.addPlace({ id: 'start', type: 'initial', tokens: [] });
+    net.addPlace({
+      id: 'p1',
+      type: 'normal',
+      tokens: [{ id: 't1', data: {}, createdAt: Date.now() }],
+    });
+    expect(net.places.get('start')!.tokens).to.be.empty;
+    expect(net.places.get('p1')!.tokens).to.have.lengthOf(1);
+  });
+
+  it('should fire a transition and move tokens', async () => {
+    net.addPlace({
+      id: 'start',
+      type: 'initial',
+      tokens: [{ id: 't0', data: { value: 10 }, createdAt: 0 }],
+    });
+    net.addPlace({ id: 'end', type: 'final', tokens: [] });
+    net.addTransition({ id: 't1', from: ['start'], to: 'end' });
+
+    const res = await net.fireTransition('t1');
+    expect(res.success).to.be.true;
+    expect(res.consumedTokens).to.have.lengthOf(1);
+    expect(res.producedTokens).to.have.lengthOf(1);
+    expect(res.producedTokens[0].data).to.deep.equal({ value: 10 });
+    expect(net.state.marking.get('start')!).to.be.empty;
+    expect(net.state.marking.get('end')!).to.have.lengthOf(1);
+  });
+
+  it('should detect deadlock when no transition enabled', () => {
+    const net2 = new PetriNet('dead');
+    net2.addPlace({
+      id: 'p',
+      type: 'initial',
+      tokens: [{ id: 't', data: {}, createdAt: 0 }],
+    });
+    expect(net2.detectDeadlock()).to.be.true;
+  });
+
+  it('should pass boundedness for a safe workflow', () => {
+    net.addPlace({ id: 'start', type: 'initial', tokens: [] });
+    net.addPlace({ id: 'p1', type: 'normal', tokens: [] });
+    net.addPlace({ id: 'p2', type: 'normal', tokens: [] });
+    net.addPlace({ id: 'end', type: 'final', tokens: [] });
+
+    net.addTransition({ id: 't1', from: ['start'], to: ['p1', 'p2'] });
+    net.addTransition({ id: 't2', from: ['p1', 'p2'], to: 'end' });
+
+    const result = net.validateBoundedness();
+    expect(result.bounded).to.be.true;
+  });
+
+  it('should detect unboundedness for a token generator', () => {
+    const net2 = new PetriNet('unbounded');
+    net2.addPlace({
+      id: 'p',
+      type: 'normal',
+      tokens: [{ id: 't0', data: {}, createdAt: 0 }],
+    });
+    net2.addTransition({ id: 't1', from: [], to: 'p' });
+
+    const result = net2.validateBoundedness();
+    expect(result.bounded).to.be.false;
+  });
+
+  it('should evaluate deterministic guard', async () => {
+    net.addPlace({
+      id: 'start',
+      type: 'initial',
+      tokens: [{ id: 't0', data: { amount: 500 }, createdAt: 0 }],
+    });
+    net.addPlace({ id: 'ok', type: 'normal', tokens: [] });
+    net.addTransition({
+      id: 'check',
+      from: ['start'],
+      to: 'ok',
+      guard: { type: 'deterministic', condition: 'amount > 1000' },
+    });
+
+    const res = await net.fireTransition('check');
+    expect(res.success).to.be.false;
+
+    net.state.marking.get('start')![0].data.amount = 1500;
+    const res2 = await net.fireTransition('check');
+    expect(res2.success).to.be.true;
+  });
+
+  it('should distribute tokens to multiple output places', async () => {
+    net.addPlace({
+      id: 'in',
+      type: 'initial',
+      tokens: [{ id: 't0', data: {}, createdAt: 0 }],
+    });
+    net.addPlace({ id: 'out1', type: 'normal', tokens: [] });
+    net.addPlace({ id: 'out2', type: 'normal', tokens: [] });
+    net.addTransition({ id: 'fork', from: ['in'], to: ['out1', 'out2'] });
+
+    await net.fireTransition('fork');
+    expect(net.state.marking.get('in')!).to.be.empty;
+    expect(net.state.marking.get('out1')!).to.have.lengthOf(1);
+    expect(net.state.marking.get('out2')!).to.have.lengthOf(1);
+  });
+
+  it('should fire transition with LLM guard and action', async () => {
+    net.addPlace({
+      id: 'start',
+      type: 'initial',
+      tokens: [{ id: 't0', data: { msg: 'hello' }, createdAt: 0 }],
+    });
+    net.addPlace({ id: 'end', type: 'final', tokens: [] });
+
+    const transition: Transition = {
+      id: 'process',
+      from: ['start'],
+      to: 'end',
+      guard: { type: 'llm_evaluated', condition: 'Is this valid?' },
+      action: { type: 'graphflow', name: 'echo' },
+    };
+    net.addTransition(transition);
+
+    let actionCalled = false;
+    net.setActionExecutor(async (action, ctx) => {
+      actionCalled = true;
+      expect(action.type).to.equal('graphflow');
+      expect(ctx.msg).to.equal('hello');
+      return { echoed: ctx.msg };
+    });
+
+    net.setLLMExecutor(async (prompt, ctx) => {
+      expect(prompt).to.equal('Is this valid?');
+      return true;
+    });
+
+    const res = await net.fireTransitionWithAction('process');
+    expect(res.success).to.be.true;
+    expect(actionCalled).to.be.true;
+    expect(res.actionResult).to.deep.equal({ echoed: 'hello' });
+  });
+});

package/test/routing/real-llm.test.ts

@@ -0,0 +1,260 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import { CortexFlowOrchestrator } from '../../routing/orchestrator';
+import { PetriNet, TransitionAction } from '../../routing/index';
+import { ToolRegistry } from '../../execution/registry';
+import { GraphFlow } from '../../execution/index';
+import { z } from 'zod';
+import { IntentClassifier, IntentClassifierFn } from '../../routing/intent-classifier';
+import { google } from 'googleapis';
+import fs from 'fs';
+import path from 'path';
+
+// Helper: create LLM call using Ollama
+function createOllamaCall(model = 'llama3:latest') {
+  return async (prompt: string) => {
+    const response = await fetch('http://localhost:11434/api/generate', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: false,
+        format: 'json',
+      }),
+      signal: AbortSignal.timeout(30000),
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = await response.json();
+    return data.response;
+  };
+}
+
+// Helper: create Gmail client using token
+function createGmailClient() {
+  const tokenPath = path.join(__dirname, '../../gmail_token.json');
+  if (!fs.existsSync(tokenPath)) {
+    throw new Error('gmail_token.json not found. Run: node scripts/get-gmail-token.js');
+  }
+  const credentials = JSON.parse(fs.readFileSync(path.join(__dirname, '../../client_secret.json'), 'utf8'));
+  const token = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
+
+  const oauth2Client = new google.auth.OAuth2(
+    credentials.web.client_id,
+    credentials.web.client_secret,
+    'http://localhost:3000/oauth2callback'
+  );
+  oauth2Client.setCredentials(token);
+  return google.gmail({ version: 'v1', auth: oauth2Client });
+}
+
+describe('CortexFlow Real LLM Test (Ollama/Llama 3)', function() {
+  this.timeout(120000);
+
+  let orchestrator: CortexFlowOrchestrator;
+  let toolRegistry: ToolRegistry;
+
+  beforeEach(() => {
+    toolRegistry = new ToolRegistry();
+    orchestrator = new CortexFlowOrchestrator('mail_assistant', toolRegistry);
+  });
+
+  it('should classify intent with real LLM', async function() {
+    try {
+      const checkResp = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(3000) });
+      if (!checkResp.ok) throw new Error('Ollama not accessible');
+    } catch (e) {
+      console.log('⚠️  Ollama API not accessible, skipping real LLM test');
+      this.skip();
+      return;
+    }
+
+    const llmCall = createOllamaCall();
+    const classifier = new IntentClassifier(llmCall, {
+      intents: ['FETCH_MAILS', 'SUMMARIZE', 'APPROVE', 'REJECT', 'UNKNOWN'],
+      confidenceThreshold: 0.6,
+    });
+    orchestrator.setIntentClassifier(IntentClassifier.toFn(classifier), classifier);
+
+    const result = await orchestrator.orchestrate('Please summarize my 5 latest mails');
+    expect(result.intent.intent).to.not.equal('UNKNOWN');
+    expect(result.intent.confidence).to.be.above(0.5);
+  });
+
+  it('should handle low confidence with real LLM', async function() {
+    try {
+      const checkResp = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(3000) });
+      if (!checkResp.ok) throw new Error('Ollama not accessible');
+    } catch (e) {
+      console.log('⚠️  Ollama not available, skipping');
+      this.skip();
+      return;
+    }
+
+    const llmCall = createOllamaCall();
+    const classifier = new IntentClassifier(llmCall, {
+      confidenceThreshold: 0.9,
+    });
+    orchestrator.setIntentClassifier(IntentClassifier.toFn(classifier), classifier);
+
+    console.log('\n🚀  Testing low confidence handling with Ollama...');
+    const sessionId = orchestrator.startSession();
+
+    const result = await orchestrator.orchestrate(
+      'asdfghjkl qwertyuiop',  // Nonsense input
+      sessionId
+    );
+
+    console.log('\n📊  Result:', {
+      intent: result.intent,
+      confidence: result.intent.confidence,
+      needsClarification: result.needsClarification,
+      clarificationQuestion: result.clarificationQuestion,
+    });
+
+    expect(result.needsClarification).to.be.true;
+    expect(result.clarificationQuestion).to.be.a('string').and.not.empty;
+
+    console.log('✅  Low confidence handling works!\n');
+  });
+
+  it('should fetch 5 real mails and summarize with LLM', async function() {
+    // Check Ollama
+    try {
+      const checkResp = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(3000) });
+      if (!checkResp.ok) throw new Error('Ollama not accessible');
+    } catch (e) {
+      console.log('⚠️  Ollama not available, skipping');
+      this.skip();
+      return;
+    }
+
+    // Check Gmail token
+    if (!fs.existsSync(path.join(__dirname, '../../gmail_token.json'))) {
+      console.log('⚠️  gmail_token.json not found, skipping');
+      this.skip();
+      return;
+    }
+
+    // Check if Gmail API is enabled
+    try {
+      const gmail = createGmailClient();
+      await gmail.users.getProfile({ userId: 'me' });
+    } catch (error: any) {
+      if (error.code === 403) {
+        console.log('⚠️  Gmail API not enabled. Enable at: https://console.developers.google.com/apis/api/gmail.googleapis.com/overview?project=266761775636');
+        this.skip();
+        return;
+      }
+    }
+
+    const llmCall = createOllamaCall();
+    const gmail = createGmailClient();
+    const classifier = new IntentClassifier(llmCall, {
+      intents: ['FETCH_MAILS', 'SUMMARIZE', 'UNKNOWN'],
+      confidenceThreshold: 0.6,
+    });
+    orchestrator.setIntentClassifier(IntentClassifier.toFn(classifier), classifier);
+    orchestrator.setLLMCall(llmCall);
+
+    // Setup Petri net
+    const net = orchestrator.petri;
+    net.addPlace({ id: 'idle', type: 'initial', tokens: [{ id: 'start', data: {}, createdAt: 0 }] });
+    net.addPlace({ id: 'processing', type: 'normal', tokens: [] });
+    net.addPlace({ id: 'done', type: 'final', tokens: [] });
+
+    // Create GraphFlow that fetches real mails and summarizes
+    const mailGraph = new GraphFlow<any>({
+      name: 'mail_fetch_summarize',
+      context: { maxMails: 5 },
+      schema: z.object({ maxMails: z.number() }).passthrough(),
+      nodes: [
+        {
+          name: 'fetch_mails',
+          execute: async (ctx: any) => {
+            console.log('  [fetch_mails] Fetching mails from Gmail API...');
+            const res = await gmail.users.messages.list({
+              userId: 'me',
+              maxResults: ctx.maxMails || 5,
+              q: '',
+            });
+            const messages = res.data.messages || [];
+            ctx.fetchedMails = [];
+            for (const msg of messages) {
+              const detail = await gmail.users.messages.get({
+                userId: 'me',
+                id: msg.id!,
+                format: 'metadata',
+                metadataHeaders: ['Subject', 'From'],
+              });
+              const headers = detail.data.payload?.headers || [];
+              ctx.fetchedMails.push({
+                id: msg.id,
+                subject: headers.find(h => h.name === 'Subject')?.value || '(no subject)',
+                from: headers.find(h => h.name === 'From')?.value || '(unknown)',
+              });
+            }
+            console.log(`  [fetch_mails] Fetched ${ctx.fetchedMails.length} mails`);
+          },
+          next: 'summarize',
+        },
+        {
+          name: 'summarize',
+          execute: async (ctx: any) => {
+            console.log('  [summarize] Summarizing with LLM...');
+            const mailText = ctx.fetchedMails.map((m: any) => `From: ${m.from}\nSubject: ${m.subject}`).join('\n\n');
+            const prompt = `Summarize these emails in 3 bullet points max:\n\n${mailText}\n\nRespond in JSON: {"summary": "..."}`;
+            const response = await llmCall(prompt);
+            const parsed = JSON.parse(response);
+            ctx.summary = parsed.summary;
+            console.log(`  [summarize] Summary: ${ctx.summary}`);
+          },
+        },
+      ],
+      entryNode: 'fetch_mails',
+    });
+
+    toolRegistry.register({
+      name: 'mail_fetch_summarize',
+      description: 'Fetch and summarize mails from Gmail',
+      graph: mailGraph,
+      startNode: 'fetch_mails',
+    });
+
+    net.addTransition({
+      id: 'process_mails',
+      from: ['idle'],
+      to: 'processing',
+      action: {
+        type: 'graphflow',
+        name: 'mail_fetch_summarize',
+        contextMapper: (ctx) => ({ maxMails: ctx.maxMails || 5 }),
+      } as TransitionAction,
+    });
+
+    net.addTransition({
+      id: 'complete',
+      from: ['processing'],
+      to: 'done',
+    });
+
+    console.log('\n🚀  Starting real Gmail + LLM test...');
+    const sessionId = orchestrator.startSession();
+
+    const result = await orchestrator.orchestrate(
+      'Please fetch my 5 latest mails and summarize them',
+      sessionId
+    );
+
+    console.log('\n📊  Result:', {
+      intent: result.intent,
+      needsClarification: result.needsClarification,
+    });
+
+    expect(result.intent.intent).to.not.equal('UNKNOWN');
+    expect(result.needsClarification).to.be.false;
+    expect((result as any).transitionResult).to.exist;
+
+    console.log('✅  Real Gmail + LLM test passed!\n');
+  });
+});