@meller/tokentalos 1.0.0

package/lib/engine/index.js

@@ -0,0 +1,320 @@
+import { initDb, getDb } from './db.js';
+import { processPromptParts } from './processor.js';
+import { TokenTalosPrompt } from './parameterizer.js';
+import { getCostCalculator } from './pricing.js';
+import { getLLMGateway } from './llm_clients.js';
+import { PromptCache } from './cache.js';
+import { OPVService } from './opv.js';
+import { runHeuristicAnalysis } from './analyzer.js';
+import { v4 as uuidv4 } from 'uuid';
+
+export class TokenTalosEngine {
+  constructor(config = {}) {
+    this.config = {
+      formattingFeatures: ['pii', 'neutralize'],
+      intelligenceFeatures: ['cache', 'explain'],
+      securityFeatures: ['injection', 'secrets'],
+      securityAction: 'warn',
+      piiAction: 'mask',
+      ...config
+    };
+    this.managedMode = this.config.managedMode || false;
+    this.orgId = this.config.orgId || 'default_org';
+    this.projectId = this.config.projectId || 'default';
+    this.db = null;
+    this.cache = null;
+    this.opv = null;
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+    
+    // Default to SQLite if not specified
+    const dbConfig = {
+      databaseType: this.config.databaseType || 'sqlite',
+      sqlitePath: this.config.sqlitePath || ':memory:', 
+      ...this.config
+    };
+
+    this.db = await initDb(dbConfig);
+    
+    // Create default org if it doesn't exist
+    await this.ensureDefaultOrg();
+
+    this.cache = new PromptCache(getDb());
+    this.opv = new OPVService(this.config, getLLMGateway(this.config));
+    this.initialized = true;
+  }
+
+  async ensureDefaultOrg() {
+    const db = getDb();
+    try {
+      // 1. Ensure Default Organization
+      await db.run('INSERT INTO organizations (id, name) VALUES (?, ?) ON CONFLICT DO NOTHING', ['default_org', 'Default Organization']);
+      
+      // 2. Ensure Default User (for local mode)
+      await db.run('INSERT INTO users (id, email, name) VALUES (?, ?, ?) ON CONFLICT DO NOTHING', ['local_user', 'dev@tokentalos.local', 'Local Developer']);
+      
+      // 3. Ensure Membership
+      await db.run('INSERT INTO organization_members (org_id, user_id, role) VALUES (?, ?, ?) ON CONFLICT DO NOTHING', ['default_org', 'local_user', 'admin']);
+    } catch (e) {
+      // Ignore if schema not ready or unique constraint (for non-ID on conflict)
+    }
+  }
+
+  async validateApiKey(key) {
+    if (!key) return null;
+    const db = this.getDb();
+    // In a real system, we'd hash the key here before lookup
+    const keyRecord = await db.get('SELECT org_id FROM api_keys WHERE key_hash = ?', [key]);
+    return keyRecord ? keyRecord.org_id : null;
+  }
+  async verifyReasoning(params) {
+    if (!this.initialized) await this.init();
+    return await this.opv.verifyReasoning(params);
+  }
+
+  getDb() {
+    if (!this.initialized) throw new Error('TokenTalos Engine not initialized. Call init() first.');
+    return getDb();
+  }
+
+  async process(parts) {
+    return processPromptParts(parts, this.config);
+  }
+
+  createPrompt(provider, model) {
+    const finalProvider = provider || this.config.llmProvider || 'gemini';
+    const finalModel = model || this.config.defaultModel || 'gemini-3-flash-preview';
+    return new TokenTalosPrompt(finalProvider, finalModel);
+  }
+
+  async execute(params) {
+    const { provider, model, parts, endpoint, options = {}, bypassCache = false, orgId, projectId } = params;
+    const startTime = Date.now();
+
+    const finalOrgId = orgId || this.orgId;
+    const finalProjectId = projectId || this.projectId;
+
+    // 1. Process Parts
+    const { processedParts, metadata } = await this.process(parts);
+
+    const finalProvider = provider || this.config.llmProvider || 'gemini';
+    const finalModel = model || this.config.defaultModel || 'gemini-3-flash-preview';
+
+    const prompt = this.createPrompt(finalProvider, finalModel);
+    
+    // Add processed parts to the prompt
+    for (const key in processedParts) {
+      if (key === 'system') prompt.addSystem(processedParts[key], parts[key]);
+      else if (key === 'context') prompt.addContext(processedParts[key], parts[key]);
+      else if (key === 'history') prompt.addHistory(processedParts[key], parts[key]);
+      else if (key === 'user_query') prompt.addUserQuery(processedParts[key], parts[key]);
+      else prompt.add(key, processedParts[key], parts[key]);
+    }
+
+    const fullPromptString = prompt.toString();
+    const promptHash = this.cache.generateHash(fullPromptString);
+
+    // Track compression savings
+    const compressionAction = metadata.actions_taken.find(a => a.type === 'compress');
+    const savedChars = compressionAction?.saved_chars || 0;
+    const savedTokens = Math.ceil(savedChars / 4); // Heuristic
+    const calculator = getCostCalculator();
+    const [savedCompressionCost] = calculator.calculateCost(finalProvider, finalModel, savedTokens, 0);
+
+    // 2. Cache Check
+    if (!bypassCache && this.config.intelligenceFeatures?.includes('cache')) {
+      const cached = await this.cache.get(promptHash);
+      if (cached) {
+        // Log the cache hit as a usage event with 0 cost but record saved tokens
+        const hitId = uuidv4();
+        const db = this.getDb();
+        
+        // Calculate what it WOULD have cost
+        const [savedInputCost] = calculator.calculateCost(finalProvider, finalModel, prompt.getTrackingData().total_tokens, 0);
+        const trackingData = prompt.getTrackingData();
+
+        await db.run(`
+          INSERT INTO usage_data (id, org_id, project_id, type, provider, model, full_prompt, response_content, input_tokens, total_tokens, saved_tokens, saved_cost, input_cost, total_cost, endpoint, latency_ms, timestamp)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `, [
+          hitId, finalOrgId, finalProjectId, 'cache_hit', finalProvider, finalModel, fullPromptString, cached.response_content, 0, 0, 
+          prompt.getTrackingData().total_tokens, savedInputCost, 0, 0, endpoint, Date.now() - startTime, trackingData.timestamp
+        ]);
+
+        for (const v of trackingData.variables) {
+          await db.run(`
+            INSERT INTO prompt_variables (usage_id, name, content, original_content, token_count, char_count, position)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+          `, [hitId, v.name, v.content, v.original_content, v.token_count, v.char_count, v.position]);
+        }
+
+        for (const action of metadata.actions_taken) {
+          await db.run(`
+            INSERT INTO variable_actions (usage_id, variable_name, action_type, action_method, details)
+            VALUES (?, ?, ?, ?, ?)
+          `, [
+            hitId, 
+            action.target, 
+            action.type, 
+            action.method || null, 
+            JSON.stringify(action)
+          ]);
+        }
+
+        return {
+          id: cached.usage_id,
+          content: cached.response_content,
+          cached: true,
+          saved_tokens: prompt.getTrackingData().total_tokens,
+          saved_cost: savedInputCost,
+          metadata: { ...metadata, latency_ms: Date.now() - startTime }
+        };
+      }
+    }
+
+    // 3. Execution
+    const gateway = getLLMGateway(this.config);
+    const messages = prompt.toMessages();
+    const result = await gateway.execute(finalProvider, finalModel, messages, options);
+    const latencyMs = Date.now() - startTime;
+
+    // 4. Persistence
+    const trackingData = prompt.getTrackingData();
+    const [inputCost, outputCost] = calculator.calculateCost(
+      finalProvider, finalModel, result.input_tokens, result.output_tokens
+    );
+
+    const db = this.getDb();
+    const limitExceeded = (result.input_tokens + result.output_tokens) > (this.config.maxTokens || 32000);
+
+    await db.run(`
+      INSERT INTO usage_data (id, org_id, project_id, type, provider, model, full_prompt, response_content, input_tokens, output_tokens, total_tokens, saved_tokens, saved_cost, input_cost, output_cost, total_cost, endpoint, latency_ms, token_limit_exceeded, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+      trackingData.id, finalOrgId, finalProjectId, 'execution', finalProvider, finalModel, fullPromptString, result.content, result.input_tokens, result.output_tokens,
+      result.input_tokens + result.output_tokens, savedTokens, savedCompressionCost, inputCost, outputCost, inputCost + outputCost,
+      endpoint, latencyMs, limitExceeded ? 1 : 0, trackingData.timestamp
+    ]);
+
+    for (const v of trackingData.variables) {
+      await db.run(`
+        INSERT INTO prompt_variables (usage_id, name, content, original_content, token_count, char_count, position)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `, [trackingData.id, v.name, v.content, v.original_content, v.token_count, v.char_count, v.position]);
+    }
+
+    for (const action of metadata.actions_taken) {
+      await db.run(`
+        INSERT INTO variable_actions (usage_id, variable_name, action_type, action_method, details)
+        VALUES (?, ?, ?, ?, ?)
+      `, [
+        trackingData.id, 
+        action.target, 
+        action.type, 
+        action.method || null, 
+        JSON.stringify(action)
+      ]);
+    }
+
+    // Persist Security Alerts
+    for (const finding of (metadata.security_findings || [])) {
+      await db.run(`
+        INSERT INTO security_alerts (usage_id, type, description, severity, action_taken)
+        VALUES (?, ?, ?, ?, ?)
+      `, [
+        trackingData.id,
+        finding.type,
+        finding.description,
+        finding.severity,
+        config.securityAction || 'warn'
+      ]);
+    }
+
+    // 5. Heuristic Analysis
+    const analysis = runHeuristicAnalysis({ 
+      total_tokens: result.input_tokens + result.output_tokens, 
+      input_tokens: result.input_tokens,
+      output_tokens: result.output_tokens,
+      total_cost: inputCost + outputCost,
+      provider: finalProvider,
+      model: finalModel
+    }, trackingData.variables);
+    if (analysis) {
+      const planId = uuidv4();
+      await db.run(`
+        INSERT INTO explain_plans (
+          id, usage_id, variable_analysis, detected_issues, optimization_suggestions, 
+          estimated_savings_pct, estimated_savings_usd,
+          mce_best_alternative_model, mce_best_alternative_provider, mce_best_alternative_cost, mce_savings_pct
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `, [
+        planId, 
+        trackingData.id, 
+        JSON.stringify(analysis.variable_analysis), 
+        JSON.stringify(analysis.detected_issues), 
+        JSON.stringify(analysis.optimization_suggestions),
+        analysis.estimated_savings_pct, 
+        analysis.estimated_savings_usd,
+        analysis.mce_best_alternative_model || null,
+        analysis.mce_best_alternative_provider || null,
+        analysis.mce_best_alternative_cost || 0,
+        analysis.mce_savings_pct || 0
+      ]);
+    }
+
+    // Save to Cache
+    await this.cache.set(promptHash, result.content, trackingData.id);
+
+    return {
+      id: trackingData.id,
+      content: result.content,
+      cached: false,
+      usage: {
+        input_tokens: result.input_tokens,
+        output_tokens: result.output_tokens,
+        cost_usd: inputCost + outputCost
+      },
+      metadata: { ...metadata, latency_ms: latencyMs }
+    };
+  }
+
+  async ingest(data) {
+    const db = this.getDb();
+    const usageId = uuidv4();
+    const provider = data.provider || this.config.llmProvider || 'gemini';
+    const model = data.model || this.config.defaultModel || 'gemini-3-flash-preview';
+
+    const totalTokens = (data.input_tokens || 0) + (data.output_tokens || 0);
+    const calculator = getCostCalculator();
+    const [inputCost, outputCost] = calculator.calculateCost(
+      provider,
+      model,
+      data.input_tokens || 0,
+      data.output_tokens || 0
+    );
+
+    const totalCost = inputCost + outputCost;
+    const limitExceeded = totalTokens > (this.config.maxTokens || 32000);
+    const finalProjectId = data.projectId || this.projectId;
+    const finalOrgId = data.orgId || this.orgId;
+
+    await db.run(`
+      INSERT INTO usage_data (
+        id, org_id, project_id, provider, model, input_tokens, output_tokens, total_tokens, 
+        input_cost, output_cost, total_cost, endpoint, latency_ms, token_limit_exceeded, timestamp
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+      usageId, finalOrgId, finalProjectId, provider, model, data.input_tokens || 0, data.output_tokens || 0,
+      totalTokens, inputCost, outputCost, totalCost, data.endpoint, data.latency_ms,
+      limitExceeded, data.timestamp || new Date().toISOString()
+    ]);
+
+    // Handle variables if present...
+    // (We will migrate the full ingestion logic here)
+
+    return { id: usageId, totalCost };
+  }
+}

package/lib/engine/llm_clients.js

@@ -0,0 +1,255 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { VertexAI } from '@google-cloud/vertexai';
+import { GoogleAuth } from 'google-auth-library';
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+
+export class LLMGateway {
+  constructor(config) {
+    this.config = config;
+    this.clients = {};
+    this.auth = new GoogleAuth();
+  }
+
+  getGemini() {
+    if (!process.env.GOOGLE_API_KEY) {
+      return null;
+    }
+    if (!this.clients.gemini) {
+      this.clients.gemini = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
+    }
+    return this.clients.gemini;
+  }
+
+  async getVertex() {
+    if (!this.clients.vertex) {
+      const location = this.config.location || process.env.GCP_REGION || 'us-central1';
+      let project = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || this.config.gcpProjectId || this.config.project;
+
+      if (!project) {
+        try {
+          // Try to auto-detect project ID from ADC
+          project = await this.auth.getProjectId();
+        } catch (e) {
+          // Ignore auth errors here
+        }
+      }
+
+      if (!project) {
+        console.warn('Vertex AI requires a Project ID. Set GOOGLE_CLOUD_PROJECT, GCLOUD_PROJECT, or configure it in setup.');
+        return null;
+      }
+
+      const pgConfig = {
+        project,
+        location
+      };
+
+      if (location === 'global') {
+        pgConfig.apiEndpoint = 'aiplatform.googleapis.com';
+      }
+
+      this.clients.vertex = new VertexAI(pgConfig);
+    }
+    return this.clients.vertex;
+  }
+
+  getAnthropic() {
+    if (!this.clients.anthropic) {
+      this.clients.anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY || '' });
+    }
+    return this.clients.anthropic;
+  }
+
+  getOpenAI() {
+    if (!this.clients.openai) {
+      this.clients.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY || '' });
+    }
+    return this.clients.openai;
+  }
+
+  getDeepSeek() {
+    if (!this.clients.deepseek) {
+      // DeepSeek is OpenAI-compatible
+      this.clients.deepseek = new OpenAI({ 
+        apiKey: process.env.DEEPSEEK_API_KEY || '',
+        baseURL: 'https://api.deepseek.com'
+      });
+    }
+    return this.clients.deepseek;
+  }
+
+  async execute(provider, model, messages, options = {}) {
+    switch (provider.toLowerCase()) {
+      case 'gemini':
+        return this.executeGemini(model, messages, options);
+      case 'anthropic':
+        return this.executeAnthropic(model, messages, options);
+      case 'openai':
+        return this.executeOpenAI(model, messages, options);
+      case 'deepseek':
+        return this.executeDeepSeek(model, messages, options);
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+
+  async executeGemini(modelName, messages, options) {
+    try {
+      const aiClient = this.getGemini();
+      const vertexClient = await this.getVertex();
+
+      // Prefer Vertex AI if GOOGLE_API_KEY is missing, or if explicitly configured
+      if (vertexClient && (!aiClient || this.config.useVertex)) {
+        return await this.executeVertex(modelName, messages, options);
+      }
+
+      if (!aiClient) {
+        throw new Error('No LLM client available for Gemini. Set GOOGLE_API_KEY or GOOGLE_CLOUD_PROJECT (for Vertex AI).');
+      }
+      // ... (rest of the function remains the same)
+
+
+      const model = aiClient.getGenerativeModel({ model: modelName });
+
+      // Convert OpenAI-style messages to Gemini contents
+      const systemInstruction = messages.find(m => m.role === 'system')?.content;
+      const contents = messages
+        .filter(m => m.role !== 'system')
+        .map(m => ({
+          role: m.role === 'assistant' ? 'model' : 'user',
+          parts: [{ text: m.content }]
+        }));
+
+      const result = await model.generateContent({
+        contents,
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+        generationConfig: {
+          maxOutputTokens: options.max_tokens,
+          temperature: options.temperature,
+          responseMimeType: options.responseMimeType
+        }
+      });
+
+      const response = await result.response;
+      const usage = response.usageMetadata;
+
+      return {
+        content: response.text(),
+        input_tokens: usage.promptTokenCount,
+        output_tokens: usage.candidatesTokenCount,
+        raw: response
+      };
+    } catch (err) {
+      console.error('[TokenTalos] Gemini execution failed:', err);
+      throw err;
+    }
+  }
+
+  async executeVertex(modelName, messages, options) {
+    try {
+      const client = await this.getVertex();
+      const model = client.getGenerativeModel({ model: modelName });
+
+      const systemInstruction = messages.find(m => m.role === 'system')?.content;
+      const contents = messages
+        .filter(m => m.role !== 'system')
+        .map(m => ({
+          role: m.role === 'assistant' ? 'model' : 'user',
+          parts: [{ text: m.content }]
+        }));
+
+      const result = await model.generateContent({
+        contents,
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+        generationConfig: {
+          maxOutputTokens: options.max_tokens,
+          temperature: options.temperature,
+          responseMimeType: options.responseMimeType
+        }
+      });
+
+      const response = (await result.response);
+
+      // Vertex response structure is slightly different for usage
+      // It's under usageMetadata or usage_metadata
+      const usage = response.usageMetadata || {};
+
+      // Handle candidates properly
+      const content = response.candidates?.[0]?.content?.parts?.[0]?.text || response.text?.() || '';
+
+      return {
+        content,
+        input_tokens: usage.promptTokenCount || 0,
+        output_tokens: usage.candidatesTokenCount || 0,
+        raw: response
+      };
+    } catch (err) {
+      console.error('[TokenTalos] Vertex execution failed:', err);
+      throw err;
+    }
+  }
+
+  async executeAnthropic(model, messages, options) {
+    const client = this.getAnthropic();
+    const system = messages.find(m => m.role === 'system')?.content;
+    const filteredMessages = messages.filter(m => m.role !== 'system');
+
+    const response = await client.messages.create({
+      model,
+      messages: filteredMessages,
+      system,
+      max_tokens: options.max_tokens || 1024,
+      temperature: options.temperature,
+    });
+
+    return {
+      content: response.content[0].text,
+      input_tokens: response.usage.input_tokens,
+      output_tokens: response.usage.output_tokens,
+      raw: response
+    };
+  }
+
+  async executeOpenAI(model, messages, options) {
+    const client = this.getOpenAI();
+    const response = await client.chat.completions.create({
+      model,
+      messages,
+      max_tokens: options.max_tokens,
+      temperature: options.temperature,
+    });
+
+    return {
+      content: response.choices[0].message.content,
+      input_tokens: response.usage.prompt_tokens,
+      output_tokens: response.usage.completion_tokens,
+      raw: response
+    };
+  }
+
+  async executeDeepSeek(model, messages, options) {
+    const client = this.getDeepSeek();
+    const response = await client.chat.completions.create({
+      model,
+      messages,
+      max_tokens: options.max_tokens,
+      temperature: options.temperature,
+    });
+
+    return {
+      content: response.choices[0].message.content,
+      input_tokens: response.usage.prompt_tokens,
+      output_tokens: response.usage.completion_tokens,
+      raw: response
+    };
+  }
+}
+
+let gateway;
+export function getLLMGateway(config) {
+  if (!gateway) {
+    gateway = new LLMGateway(config);
+  }
+  return gateway;
+}

package/lib/engine/opv.js

@@ -0,0 +1,96 @@
+/**
+ * OPV (Optimized Process Verification) Logic
+ * 
+ * Ported and adapted for TokenTalos Engine.
+ */
+
+export const ReasoningStatus = {
+  ON_TRACK: "on_track",
+  UNCERTAIN: "uncertain",
+  FAILED: "failed",
+  LOOPING: "looping",
+  COMPLETED: "completed"
+};
+
+export class OPVService {
+  constructor(config, llmGateway) {
+    this.config = config;
+    this.gateway = llmGateway;
+  }
+
+  async verifyReasoning(params) {
+    const { thinking_sample, task_description, previous_status } = params;
+    
+    const verificationPrompt = this._buildVerificationPrompt(
+      thinking_sample,
+      task_description,
+      previous_status
+    );
+
+    const provider = this.config.llmProvider || 'gemini';
+    const model = this.config.defaultModel || 'gemini-3-flash-preview';
+
+    // Use default analysis model
+    const result = await this.gateway.execute(
+      provider, 
+      model, 
+      [{ role: 'user', content: verificationPrompt }]
+    );
+
+    return this._parseVerificationResponse(result.content, thinking_sample.length);
+  }
+
+  _buildVerificationPrompt(thinking, task, previousStatus) {
+    return `You are a reasoning verification system. Your job is to analyze the reasoning process of another AI model and determine if it's on the right track.
+
+**Task the model is trying to solve:**
+${task}
+
+**Current reasoning (thinking tokens):**
+${thinking}
+
+**Previous verification status:** ${previousStatus || "None (first check)"}
+
+**Your task:**
+Analyze the reasoning and determine its status. Choose ONE of:
+1. ON_TRACK - Reasoning is progressing correctly. NOTE: Internalizing safety rules or restating constraints at the start is a POSITIVE sign of compliance and should be marked ON_TRACK.
+2. UNCERTAIN - Cannot determine yet, need more reasoning tokens.
+3. FAILED - Reasoning contains logical errors, violates safety rules, or takes a wrong approach.
+4. LOOPING - Reasoning is repeating itself without progress.
+5. COMPLETED - Reasoning has successfully reached a conclusion.
+
+**Respond in this EXACT format:**
+STATUS: [one of: ON_TRACK, UNCERTAIN, FAILED, LOOPING, COMPLETED]
+CONFIDENCE: [0.0 to 1.0]
+SHOULD_CONTINUE: [yes or no]
+REASONING: [brief explanation of your assessment]
+
+Be critical and err on the side of FAILED/LOOPING if you see signs of trouble.`;
+  }
+
+  _parseVerificationResponse(response, charCount) {
+    const lines = response.strip ? response.strip().split("\n") : response.trim().split("\n");
+
+    let status = ReasoningStatus.UNCERTAIN;
+    let confidence = 0.5;
+    let shouldContinue = true;
+    let reasoning = "Unable to parse response";
+
+    for (let line of lines) {
+      line = line.trim();
+      if (line.startsWith("STATUS:")) status = line.split("STATUS:")[1].trim().toLowerCase();
+      else if (line.startsWith("CONFIDENCE:")) confidence = parseFloat(line.split("CONFIDENCE:")[1].trim()) || 0.5;
+      else if (line.startsWith("SHOULD_CONTINUE:")) shouldContinue = line.split("SHOULD_CONTINUE:")[1].trim().toLowerCase() === 'yes';
+      else if (line.startsWith("REASONING:")) reasoning = line.split("REASONING:")[1].trim();
+    }
+
+    return { status, confidence, should_continue: shouldContinue, char_count: charCount, reasoning };
+  }
+
+  shouldKillRequest(result, threshold = 0.7) {
+    if (result.status === ReasoningStatus.FAILED && result.confidence > threshold) return true;
+    if (result.status === ReasoningStatus.LOOPING) return true;
+    if (result.status === ReasoningStatus.COMPLETED) return true;
+    return false;
+  }
+}