@o-lang/olang 1.2.31 → 1.2.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.2.31",
+  "version": "1.2.33",
   "author": "Olalekan Ogundipe <info@olang.cloud>",
   "description": "O-Lang: A governance language for user-directed, rule-enforced agent workflows",
   "main": "./src/runtime/index.js",

package/src/runtime/RuntimeAPI.js

@@ -690,15 +690,38 @@ class RuntimeAPI {
     abs: a => Math.abs(a)
   };
 
-  evaluateMath(expr) {
+    evaluateMath(expr) {
+    // ✅ Handle quoted string literals with interpolation: "{var}" → interpolated string
+    if (typeof expr === 'string') {
+      const trimmed = expr.trim();
+      
+      // Check if it's a quoted string (single or double quotes)
+      if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || 
+          (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        // Extract the inner content
+        let inner = trimmed.slice(1, -1);
+        
+        // Perform interpolation: replace {var} with context values
+        inner = inner.replace(/\{([^\}]+)\}/g, (_, path) => {
+          const value = this.getNested(this.context, path.trim());
+          return value !== undefined ? String(value) : `{${path}}`;
+        });
+        
+        return inner;
+      }
+    }
+    
+    // ── Original math evaluation logic (unchanged) ──────────────────────────
     expr = expr.replace(/\{([^\}]+)\}/g, (_, path) => {
       const value = this.getNested(this.context, path.trim());
       if (typeof value === 'string') return `"${value.replace(/"/g, '\\"')}"`;
       return value !== undefined ? value : 0;
     });
+    
     const funcNames = Object.keys(this.mathFunctions);
     const safeFunc = {};
     funcNames.forEach(fn => safeFunc[fn] = this.mathFunctions[fn]);
+    
     try {
       const f = new Function(...funcNames, `return ${expr};`);
       return f(...funcNames.map(fn => safeFunc[fn]));
@@ -1235,9 +1258,14 @@ const forbiddenPatterns = [
       throw new Error(errorMessage);
     };
 
-    switch (stepType) {
+      switch (stepType) {
       case 'calculate': {
-        const result = this.evaluateMath(step.expression || step.actionRaw);
+        // ✅ Interpolate variables in the expression before evaluation
+        let expr = step.expression || step.actionRaw;
+        if (typeof expr === 'string' && expr.includes('{')) {
+          expr = this._safeInterpolate(expr, this.context, 'calculate step');
+        }
+        const result = this.evaluateMath(expr);
         if (step.saveAs) this.context[step.saveAs] = result;
         break;
       }