feat(ovsm): add NOW tool and improve error reporting

- Add NOW() tool to OVSM stdlib for Unix timestamp
- Improve OVSM execution error messages to show actual errors
- Fix RPC bridge to handle Solana parameter format (WIP)
- Add debug logging for RPC calls

Issue: RPC bridge still not correctly building config objects from
named parameters. Currently sends address and raw values instead of
address + config object.

Example: sends ['addr', 5] instead of ['addr', {limit: 5}]

Author: 0xrinegade

crates/ovsm/src/tools/stdlib/utilities.rs

@@ -8,6 +8,7 @@ use crate::tools::{Tool, ToolRegistry};
 pub fn register(registry: &mut ToolRegistry) {
     registry.register(LogTool);
     registry.register(ErrorTool);
+    registry.register(NowTool);
 }
 
 /// Tool for logging messages to stdout (debugging purposes)
@@ -60,3 +61,31 @@ impl Tool for ErrorTool {
         Err(Error::UserError(message))
     }
 }
+
+/// Tool for getting current Unix timestamp
+///
+/// Usage: `NOW()` - returns current Unix timestamp in seconds
+/// Example: `$timestamp = NOW()` returns 1697123456
+/// Note: Returns integer value representing seconds since Unix epoch
+pub struct NowTool;
+
+impl Tool for NowTool {
+    fn name(&self) -> &str {
+        "NOW"
+    }
+
+    fn description(&self) -> &str {
+        "Get current Unix timestamp in seconds"
+    }
+
+    fn execute(&self, _args: &[Value]) -> Result<Value> {
+        use std::time::{SystemTime, UNIX_EPOCH};
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map_err(|e| Error::ToolExecutionError {
+                tool: "NOW".to_string(),
+                reason: format!("Failed to get system time: {}", e),
+            })?;
+        Ok(Value::Int(now.as_secs() as i64))
+    }
+}

src/services/ovsm_service.rs

@@ -90,7 +90,7 @@ impl OvsmService {
         let result = self
             .evaluator
             .execute(&program)
-            .context("Failed to execute OVSM program. Note: OVSM supports both Python-style (colon + indentation) and C-style (braces) syntax for control flow.")?;
+            .map_err(|e| anyhow::anyhow!("Execution error: {}.\n\nNote: OVSM supports both Python-style (colon + indentation) and C-style (braces) syntax for control flow.", e))?;
 
         if self.verbose {
             println!("✨ Execution completed successfully");

src/utils/rpc_bridge.rs

@@ -34,27 +34,40 @@ impl Tool for RpcBridgeTool {
     fn execute(&self, args: &[OvsmValue]) -> OvsmResult<OvsmValue> {
         let mut rpc_params = Vec::new();
 
+        // Handle single object argument (named parameters)
         if args.len() == 1 {
             if let OvsmValue::Object(obj) = &args[0] {
-                if let Some(address) = obj.get("address") {
-                    rpc_params.push(ovsm_value_to_json(address));
+                // Extract primary parameter (address, signature, etc.)
+                let primary_param = obj.get("address")
+                    .or_else(|| obj.get("signature"))
+                    .or_else(|| obj.get("slot"))
+                    .or_else(|| obj.get("pubkey"));
 
-                    let mut options = serde_json::Map::new();
+                if let Some(primary) = primary_param {
+                    rpc_params.push(ovsm_value_to_json(primary));
+
+                    // Build config object from remaining named parameters
+                    let mut config = serde_json::Map::new();
                     for (key, val) in obj.iter() {
-                        if key != "address" {
-                            options.insert(key.clone(), ovsm_value_to_json(val));
+                        if !matches!(key.as_str(), "address" | "signature" | "slot" | "pubkey") {
+                            config.insert(key.clone(), ovsm_value_to_json(val));
                         }
                     }
-                    if !options.is_empty() {
-                        rpc_params.push(Value::Object(options));
+
+                    // Only add config object if it has fields
+                    if !config.is_empty() {
+                        rpc_params.push(Value::Object(config));
                     }
                 } else {
+                    // No primary param found, use the whole object
                     rpc_params.push(ovsm_value_to_json(&args[0]));
                 }
             } else {
+                // Single non-object argument
                 rpc_params.push(ovsm_value_to_json(&args[0]));
             }
         } else {
+            // Multiple arguments - use as positional
             for arg in args {
                 rpc_params.push(ovsm_value_to_json(arg));
             }
@@ -85,6 +98,9 @@ async fn call_solana_rpc(method: &str, params: Vec<Value>) -> anyhow::Result<Val
         "params": params
     });
 
+    // Debug: print RPC request
+    eprintln!("[RPC DEBUG] Method: {}, Params: {}", method, serde_json::to_string_pretty(&params).unwrap_or_else(|_| "invalid".to_string()));
+
     let response = client
         .post(SOLANA_RPC_URL)
         .json(&request_body)