principles-disciple 1.8.0 → 1.8.2

package/{dist/core/risk-calculator.js → src/core/risk-calculator.ts}

@@ -1,64 +1,81 @@
 import * as fs from 'fs';
 import { isRisky } from '../utils/io.js';
-export function estimateLineChanges(modification) {
+
+export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+
+export interface FileModification {
+    toolName: string;
+    params: any;
+}
+
+export function estimateLineChanges(modification: FileModification): number {
     const { toolName, params } = modification;
+    
     if (toolName === 'write_file' || toolName === 'write') {
         const content = params.content || '';
         return content.split('\n').length;
     }
+    
     if (toolName === 'replace' || toolName === 'edit') {
         const newContent = params.new_string || params.newText || '';
         return newContent.split('\n').length;
     }
+    
     if (toolName === 'apply_patch' || toolName === 'patch') {
         const patch = params.patch || '';
         // Rough estimate for patch files
-        return patch.split('\n').filter((l) => l.startsWith('+') || l.startsWith('-')).length;
+        return patch.split('\n').filter((l: string) => l.startsWith('+') || l.startsWith('-')).length;
     }
+
     if (toolName === 'delete_file') {
         // Deleting a file is considered a significant change, but we don't know the size. 
         // We'll treat it as a medium-to-large size change.
         return 50;
     }
+    
     return 0;
 }
-export function assessRiskLevel(filePath, modification, riskPaths) {
+
+export function assessRiskLevel(
+    filePath: string,
+    modification: FileModification,
+    riskPaths: string[]
+): RiskLevel {
     const isRiskPath = isRisky(filePath, riskPaths);
     const estimatedLines = estimateLineChanges(modification);
+    
     if (isRiskPath) {
-        if (estimatedLines > 100)
-            return 'CRITICAL';
+        if (estimatedLines > 100) return 'CRITICAL';
         return 'HIGH';
-    }
-    else {
-        if (estimatedLines > 100)
-            return 'HIGH';
-        if (estimatedLines > 10)
-            return 'MEDIUM';
+    } else {
+        if (estimatedLines > 100) return 'HIGH';
+        if (estimatedLines > 10) return 'MEDIUM';
         return 'LOW';
     }
 }
+
 /**
  * Get the total line count of a target file.
  * @param absoluteFilePath - Absolute path to the file
  * @returns File line count, or null if file doesn't exist or can't be read
  */
-export function getTargetFileLineCount(absoluteFilePath) {
+export function getTargetFileLineCount(absoluteFilePath: string): number | null {
     try {
         if (!fs.existsSync(absoluteFilePath)) {
             return null; // File genuinely doesn't exist
         }
+        
         const stats = fs.statSync(absoluteFilePath);
         if (!stats.isFile()) {
             return null; // Not a regular file (directory, device, etc.)
         }
+        
         const content = fs.readFileSync(absoluteFilePath, 'utf-8');
         return content.split('\n').length;
-    }
-    catch (e) {
+    } catch (e) {
         // Log error before falling back to null - this is intentional for security gates
         const error = e instanceof Error ? e : new Error(String(e));
-        const errorCode = e.code;
+        const errorCode = (e as NodeJS.ErrnoException).code;
         console.error(`[PD:RISK_CALC] Failed to read file for line count: ${absoluteFilePath}`, {
             code: errorCode,
             message: error.message,
@@ -66,6 +83,7 @@ export function getTargetFileLineCount(absoluteFilePath) {
         return null;
     }
 }
+
 /**
  * Calculate the effective line limit based on percentage of target file.
  * @param targetLineCount - Total lines in target file
@@ -74,14 +92,22 @@ export function getTargetFileLineCount(absoluteFilePath) {
  * @param maxLines - Optional upper bound to prevent misconfiguration
  * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
  */
-export function calculatePercentageThreshold(targetLineCount, percentage, minLines, maxLines) {
+export function calculatePercentageThreshold(
+    targetLineCount: number,
+    percentage: number,
+    minLines: number,
+    maxLines?: number
+): number {
     // Clamp percentage to valid range [0, 100]
     const clampedPercentage = Math.max(0, Math.min(100, percentage));
+    
     const calculated = Math.round(targetLineCount * (clampedPercentage / 100));
     let effectiveLimit = Math.max(calculated, minLines);
+    
     // Apply optional upper bound
     if (maxLines !== undefined && maxLines > 0) {
         effectiveLimit = Math.min(effectiveLimit, maxLines);
     }
+    
     return effectiveLimit;
 }

package/{dist/core/session-tracker.js → src/core/session-tracker.ts}

@@ -1,94 +1,153 @@
+import { PluginHookLlmOutputEvent } from '../openclaw-sdk.js';
 import * as path from 'path';
 import * as fs from 'fs';
+import { PainConfig } from './config.js';
 import { SystemLogger } from './system-logger.js';
-const sessions = new Map();
+import { EventLogService } from './event-log.js';
+
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+}
+
+export interface SessionState {
+    sessionId: string;
+    sessionKey?: string;   // Structured session key from OpenClaw (e.g., agent:main:cron:job-1:run:xxx)
+    trigger?: string;      // Trigger source: "user" | "cron" | "heartbeat" | "memory" | "subagent"
+    workspaceDir?: string;
+    toolReadsByFile: Record<string, number>;
+    llmTurns: number;
+    blockedAttempts: number;
+    lastActivityAt: number;
+    lastControlActivityAt: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    cacheHits: number;
+    // Track consecutive loops of similar lengths/ratios (paralysis)
+    stuckLoops: number;
+    
+    // GFI - Track A: Empirical Friction
+    currentGfi: number;
+    gfiBySource?: Record<string, number>;
+    lastErrorSource?: string;
+    lastErrorHash: string;
+    consecutiveErrors: number;
+    
+    // Daily statistics (persisted)
+    dailyToolCalls: number;
+    dailyToolFailures: number;
+    dailyPainSignals: number;
+    dailyGfiPeak: number;
+    
+    // Thinking OS checkpoint - tracks last deep thinking timestamp
+    lastThinkingTimestamp: number;
+
+    // Evolution loop feedback attribution
+    injectedProbationIds?: string[];
+}
+
+
+const sessions = new Map<string, SessionState>();
+
 /** Directory for persisting session state */
-let persistDir = null;
+let persistDir: string | null = null;
+
 /** Debounce timers for persistence, one per session */
-const persistTimers = new Map();
-function logSessionTrackerWarning(message, error) {
+const persistTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function logSessionTrackerWarning(message: string, error?: unknown): void {
     const detail = error instanceof Error ? error.message : error ? String(error) : '';
     const suffix = detail ? `: ${detail}` : '';
+    // eslint-disable-next-line no-console
     console.warn(`[PD:SessionTracker] ${message}${suffix}`);
 }
-function touchActivity(state, kind = 'general') {
+
+function touchActivity(state: SessionState, kind: 'general' | 'control' = 'general'): void {
     const now = Date.now();
     state.lastActivityAt = now;
     if (kind === 'control') {
         state.lastControlActivityAt = now;
     }
 }
+
 /**
  * Initialize persistence for session state.
  * Call this once during plugin startup.
  */
-export function initPersistence(stateDir) {
+export function initPersistence(stateDir: string): void {
     persistDir = path.join(stateDir, 'sessions');
     if (!fs.existsSync(persistDir)) {
         fs.mkdirSync(persistDir, { recursive: true });
     }
+    
     // Load all existing sessions
     loadAllSessions();
 }
+
 /**
  * Get the file path for a session's persisted state.
  */
-function getSessionPath(sessionId) {
-    if (!persistDir)
-        return '';
+function getSessionPath(sessionId: string): string {
+    if (!persistDir) return '';
     // Sanitize sessionId for filesystem
     const safeId = sessionId.replace(/[/\\:]/g, '_');
     return path.join(persistDir, `${safeId}.json`);
 }
+
 /**
  * Load all persisted sessions from disk.
  */
-function loadAllSessions() {
-    if (!persistDir || !fs.existsSync(persistDir))
-        return;
+function loadAllSessions(): void {
+    if (!persistDir || !fs.existsSync(persistDir)) return;
+    
     try {
         const files = fs.readdirSync(persistDir).filter(f => f.endsWith('.json'));
         const now = Date.now();
         const twoHoursAgo = now - 2 * 60 * 60 * 1000;
+        
         for (const file of files) {
             try {
                 const content = fs.readFileSync(path.join(persistDir, file), 'utf-8');
-                const state = JSON.parse(content);
+                const state = JSON.parse(content) as SessionState;
+                
                 // Skip abandoned sessions
                 if (state.lastActivityAt < twoHoursAgo) {
                     continue;
                 }
+                
                 sessions.set(state.sessionId, state);
-            }
-            catch (error) {
+            } catch (error) {
                 logSessionTrackerWarning(`Failed to load session snapshot ${file}`, error);
             }
         }
-    }
-    catch (err) {
+    } catch (err) {
         logSessionTrackerWarning('Failed to load persisted sessions', err);
     }
 }
+
 /**
  * Persist a single session to disk.
  */
-function persistSession(state) {
-    if (!persistDir)
-        return;
+function persistSession(state: SessionState): void {
+    if (!persistDir) return;
+    
     const sessionPath = getSessionPath(state.sessionId);
-    if (!sessionPath)
-        return;
+    if (!sessionPath) return;
+    
     try {
         fs.writeFileSync(sessionPath, JSON.stringify(state, null, 2), 'utf-8');
-    }
-    catch (error) {
+    } catch (error) {
         logSessionTrackerWarning(`Failed to persist session ${state.sessionId}`, error);
     }
 }
+
 /**
  * Schedule persistence with debounce.
  */
-function schedulePersistence(state) {
+function schedulePersistence(state: SessionState): void {
     const existing = persistTimers.get(state.sessionId);
     if (existing) {
         clearTimeout(existing);
@@ -96,13 +155,14 @@ function schedulePersistence(state) {
     const timer = setTimeout(() => {
         persistSession(state);
         persistTimers.delete(state.sessionId);
-    }, 1000); // 1 second debounce
+    }, 1000);  // 1 second debounce
     persistTimers.set(state.sessionId, timer);
 }
+
 /**
  * Force persist all sessions immediately.
  */
-export function flushAllSessions() {
+export function flushAllSessions(): void {
     for (const timer of persistTimers.values()) {
         clearTimeout(timer);
     }
@@ -111,11 +171,14 @@ export function flushAllSessions() {
         persistSession(state);
     }
 }
-function getOrCreateSession(sessionId, workspaceDir) {
+
+function getOrCreateSession(sessionId: string, workspaceDir?: string, sessionKey?: string, trigger?: string): SessionState {
     let state = sessions.get(sessionId);
     if (!state) {
         state = {
             sessionId,
+            sessionKey,
+            trigger,
             workspaceDir,
             toolReadsByFile: {},
             llmTurns: 0,
@@ -140,36 +203,50 @@ function getOrCreateSession(sessionId, workspaceDir) {
         };
         sessions.set(sessionId, state);
     }
+    
     if (workspaceDir && !state.workspaceDir) {
         state.workspaceDir = workspaceDir;
     }
+    // Update sessionKey and trigger if provided (they may be more recent)
+    if (sessionKey && !state.sessionKey) {
+        state.sessionKey = sessionKey;
+    }
+    if (trigger && !state.trigger) {
+        state.trigger = trigger;
+    }
     return state;
 }
-function ensureGfiLedger(state) {
+
+function ensureGfiLedger(state: SessionState): Record<string, number> {
     if (!state.gfiBySource || typeof state.gfiBySource !== 'object') {
         state.gfiBySource = {};
     }
     return state.gfiBySource;
 }
-export function trackToolRead(sessionId, filePath, workspaceDir) {
+
+export function trackToolRead(sessionId: string, filePath: string, workspaceDir?: string): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const normalizedPath = path.posix.normalize(filePath.replace(/\\/g, '/'));
     state.toolReadsByFile[normalizedPath] = (state.toolReadsByFile[normalizedPath] || 0) + 1;
     touchActivity(state);
     return state;
 }
-export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
-    const state = getOrCreateSession(sessionId, workspaceDir);
+
+export function trackLlmOutput(sessionId: string, usage: TokenUsage | undefined, config?: PainConfig, workspaceDir?: string, sessionKey?: string, trigger?: string): SessionState {
+    const state = getOrCreateSession(sessionId, workspaceDir, sessionKey, trigger);
     state.llmTurns += 1;
     touchActivity(state);
+
     if (usage) {
         state.totalInputTokens += usage.input || 0;
         state.totalOutputTokens += usage.output || 0;
         state.cacheHits += usage.cacheRead || 0;
+
         // Use thresholds from config or defaults
         const minTurns = 5; // Increased from 3 to 5 to prevent false positives on short tasks
         const outputThreshold = 30; // Decreased from 50. Only penalize truly stunted outputs.
         const inputThreshold = config ? config.get('thresholds.cognitive_paralysis_input') : 8000; // Increased base to 8k
+
         // Very rough heuristic for empty/paralysis loops: high input context, tiny output, multiple turns
         if (state.llmTurns > minTurns) {
             const isTinyOutput = (usage.output || 0) < outputThreshold;
@@ -177,8 +254,7 @@ export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
             if (isTinyOutput && isLargeInput) {
                 state.stuckLoops += 1;
                 SystemLogger.log(state.workspaceDir, 'EFFICIENCY_ALARM', `Stuck loop detected (Turn ${state.llmTurns}). Input: ${usage.input}, Output: ${usage.output}. Consecutive: ${state.stuckLoops}`);
-            }
-            else {
+            } else {
                 // Reset if we broke out of the tiny output loop
                 if (state.stuckLoops > 0) {
                     SystemLogger.log(state.workspaceDir, 'EFFICIENCY_OK', `Broke out of stuck loop after ${state.stuckLoops} turns.`);
@@ -187,22 +263,31 @@ export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
             }
         }
     }
+
     return state;
 }
+
 /**
  * Tracks physical friction based on tool execution failures.
  */
-export function trackFriction(sessionId, deltaF, hash, workspaceDir, options) {
+export function trackFriction(
+    sessionId: string,
+    deltaF: number,
+    hash: string,
+    workspaceDir?: string,
+    options?: { source?: string }
+): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const ledger = ensureGfiLedger(state);
+    
     if (hash && hash === state.lastErrorHash) {
         state.consecutiveErrors++;
-    }
-    else {
+    } else {
         state.lastErrorSource = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
         state.lastErrorHash = hash;
         state.consecutiveErrors = 1;
     }
+
     // GFI formula with multiplier: GFI = GFI + (Delta_F * 1.5^(n-1))
     const multiplier = Math.pow(1.5, state.consecutiveErrors - 1);
     const addedFriction = deltaF * multiplier;
@@ -210,32 +295,48 @@ export function trackFriction(sessionId, deltaF, hash, workspaceDir, options) {
     const sourceKey = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
     ledger[sourceKey] = (ledger[sourceKey] || 0) + addedFriction;
     touchActivity(state, 'control');
+    
     SystemLogger.log(state.workspaceDir, 'GFI_INC', `Friction added: +${addedFriction.toFixed(1)} (Base: ${deltaF}, Mult: ${multiplier.toFixed(2)}). Total GFI: ${state.currentGfi.toFixed(1)}`);
+    
     // Update daily stats
     state.dailyToolFailures++;
     state.dailyGfiPeak = Math.max(state.dailyGfiPeak, state.currentGfi);
+    
     // Schedule persistence
     schedulePersistence(state);
+    
     return state;
 }
+
 /**
  * Resets the friction index upon successful action.
  */
-export function resetFriction(sessionId, workspaceDir, options) {
+export function resetFriction(
+    sessionId: string,
+    workspaceDir?: string,
+    options?: { source?: string; amount?: number }
+): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const ledger = ensureGfiLedger(state);
+
     if (options?.source) {
         const sourceKey = options.source;
         const currentSource = ledger[sourceKey] || 0;
         const requestedAmount = Number.isFinite(options.amount) ? Number(options.amount) : currentSource;
         const amountToRemove = Math.max(0, Math.min(currentSource, requestedAmount));
+
         if (amountToRemove > 0) {
             ledger[sourceKey] = Math.max(0, currentSource - amountToRemove);
             if (ledger[sourceKey] === 0) {
                 delete ledger[sourceKey];
             }
             state.currentGfi = Math.max(0, (state.currentGfi || 0) - amountToRemove);
-            SystemLogger.log(state.workspaceDir, 'GFI_SLICE_RESET', `Friction slice reset for ${sourceKey}: -${amountToRemove.toFixed(1)}. Total GFI: ${state.currentGfi.toFixed(1)}`);
+            SystemLogger.log(
+                state.workspaceDir,
+                'GFI_SLICE_RESET',
+                `Friction slice reset for ${sourceKey}: -${amountToRemove.toFixed(1)}. Total GFI: ${state.currentGfi.toFixed(1)}`
+            );
+
             if (state.lastErrorSource === sourceKey) {
                 state.consecutiveErrors = 0;
                 state.lastErrorHash = '';
@@ -246,6 +347,7 @@ export function resetFriction(sessionId, workspaceDir, options) {
         schedulePersistence(state);
         return state;
     }
+
     if (state.currentGfi > 0) {
         SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${state.currentGfi.toFixed(1)}). Action successful.`);
     }
@@ -255,15 +357,18 @@ export function resetFriction(sessionId, workspaceDir, options) {
     state.consecutiveErrors = 0;
     state.lastErrorHash = '';
     touchActivity(state, 'control');
+    
     // Schedule persistence
     schedulePersistence(state);
+    
     return state;
 }
+
 /**
  * Records that deep thinking (Thinking OS) was performed in this session.
  * Used by the Thinking OS checkpoint to allow high-risk operations.
  */
-export function recordThinkingCheckpoint(sessionId, workspaceDir) {
+export function recordThinkingCheckpoint(sessionId: string, workspaceDir?: string): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
     state.lastThinkingTimestamp = Date.now();
     touchActivity(state, 'control');
@@ -271,53 +376,61 @@ export function recordThinkingCheckpoint(sessionId, workspaceDir) {
     schedulePersistence(state);
     return state;
 }
+
 /**
  * Checks if deep thinking was performed recently (within the given window).
  * @param sessionId - The session to check
  * @param windowMs - How recent the thinking must be (default: 5 minutes)
  * @returns true if thinking was recorded within the window
  */
-export function hasRecentThinking(sessionId, windowMs = 5 * 60 * 1000) {
+export function hasRecentThinking(sessionId: string, windowMs: number = 5 * 60 * 1000): boolean {
     const state = sessions.get(sessionId);
-    if (!state || !state.lastThinkingTimestamp)
-        return false;
+    if (!state || !state.lastThinkingTimestamp) return false;
     return (Date.now() - state.lastThinkingTimestamp) < windowMs;
 }
-export function trackBlock(sessionId) {
+
+export function trackBlock(sessionId: string): SessionState {
     const state = getOrCreateSession(sessionId);
     state.blockedAttempts += 1;
     touchActivity(state, 'control');
     schedulePersistence(state);
     return state;
 }
-export function setInjectedProbationIds(sessionId, ids, workspaceDir) {
+
+
+export function setInjectedProbationIds(sessionId: string, ids: string[], workspaceDir?: string): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
     state.injectedProbationIds = [...ids];
     touchActivity(state, 'control');
     schedulePersistence(state);
     return state;
 }
-export function getInjectedProbationIds(sessionId, workspaceDir) {
+
+export function getInjectedProbationIds(sessionId: string, workspaceDir?: string): string[] {
     const state = getOrCreateSession(sessionId, workspaceDir);
     return [...(state.injectedProbationIds || [])];
 }
-export function clearInjectedProbationIds(sessionId, workspaceDir) {
+
+export function clearInjectedProbationIds(sessionId: string, workspaceDir?: string): SessionState {
     return setInjectedProbationIds(sessionId, [], workspaceDir);
 }
-export function getSession(sessionId) {
+
+export function getSession(sessionId: string): SessionState | undefined {
     return sessions.get(sessionId);
 }
-export function listSessions(workspaceDir) {
+
+export function listSessions(workspaceDir?: string): SessionState[] {
     return [...sessions.values()]
         .filter((state) => !workspaceDir || !state.workspaceDir || state.workspaceDir === workspaceDir)
         .map((state) => ({
-        ...state,
-        toolReadsByFile: { ...state.toolReadsByFile },
-        gfiBySource: state.gfiBySource ? { ...state.gfiBySource } : undefined,
-        injectedProbationIds: state.injectedProbationIds ? [...state.injectedProbationIds] : undefined,
-    }));
+            ...state,
+            toolReadsByFile: { ...state.toolReadsByFile },
+            gfiBySource: state.gfiBySource ? { ...state.gfiBySource } : undefined,
+            injectedProbationIds: state.injectedProbationIds ? [...state.injectedProbationIds] : undefined,
+        }));
 }
-export function clearSession(sessionId) {
+
+export function clearSession(sessionId: string): void {
     const timer = persistTimers.get(sessionId);
     if (timer) {
         clearTimeout(timer);
@@ -325,6 +438,7 @@ export function clearSession(sessionId) {
     }
     sessions.delete(sessionId);
 }
+
 /**
  * Seed a session directly into SessionTracker.sessions for testing.
  * This bypasses the normal tool-call flow to set up test data for
@@ -334,13 +448,14 @@ export function clearSession(sessionId) {
  * @param workspaceDir - Workspace directory (optional, for filtering)
  * @param lastActivityAt - Unix timestamp in ms (default: now)
  */
-export function seedSessionForTest(sessionId, workspaceDir, lastActivityAt) {
+export function seedSessionForTest(sessionId: string, workspaceDir?: string, lastActivityAt?: number): void {
     const state = getOrCreateSession(sessionId, workspaceDir);
     state.lastActivityAt = lastActivityAt ?? Date.now();
     state.lastControlActivityAt = state.lastActivityAt;
 }
+
 // Memory cleanup for abandoned sessions (older than 2 hours)
-export function garbageCollectSessions() {
+export function garbageCollectSessions(): void {
     const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
     for (const [id, state] of sessions.entries()) {
         if (state.lastActivityAt < twoHoursAgo) {
@@ -350,14 +465,14 @@ export function garbageCollectSessions() {
                 persistTimers.delete(id);
             }
             sessions.delete(id);
+            
             // Also delete persisted file
             if (persistDir) {
                 const sessionPath = getSessionPath(id);
                 if (sessionPath && fs.existsSync(sessionPath)) {
                     try {
                         fs.unlinkSync(sessionPath);
-                    }
-                    catch (error) {
+                    } catch (error) {
                         logSessionTrackerWarning(`Failed to delete session snapshot for ${id}`, error);
                     }
                 }
@@ -365,13 +480,19 @@ export function garbageCollectSessions() {
         }
     }
 }
+
 /**
  * Get daily statistics summary for a session.
  */
-export function getDailySummary(sessionId) {
+export function getDailySummary(sessionId: string): {
+    toolCalls: number;
+    toolFailures: number;
+    painSignals: number;
+    gfiPeak: number;
+} | null {
     const state = sessions.get(sessionId);
-    if (!state)
-        return null;
+    if (!state) return null;
+    
     return {
         toolCalls: state.dailyToolCalls,
         toolFailures: state.dailyToolFailures,
@@ -379,10 +500,11 @@ export function getDailySummary(sessionId) {
         gfiPeak: state.dailyGfiPeak,
     };
 }
+
 /**
  * Reset daily statistics (call at midnight or on new day).
  */
-export function resetDailyStats(sessionId) {
+export function resetDailyStats(sessionId: string): void {
     const state = sessions.get(sessionId);
     if (state) {
         state.dailyToolCalls = 0;