aiden-runtime 3.16.0

package/dist/core/privateMode.js

@@ -0,0 +1,85 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSessionPrivate = setSessionPrivate;
+exports.clearSessionPrivate = clearSessionPrivate;
+exports.toggleSessionPrivate = toggleSessionPrivate;
+exports.isSessionPrivate = isSessionPrivate;
+exports.markNextTurnPrivate = markNextTurnPrivate;
+exports.isCurrentTurnPrivate = isCurrentTurnPrivate;
+exports.clearTurnPrivate = clearTurnPrivate;
+// core/privateMode.ts — Phase 5: Per-turn and per-session memory opacity toggle.
+//
+// When private mode is active for a session, all memory writes are suppressed:
+//   - memoryLayers.write()
+//   - sessionMemory.addExchange()
+//   - memoryExtractor.extractFromSession()
+//   - conversationMemory.addAssistantMessage() (skipped at call site)
+//
+// Two granularities:
+//   Session-level  — ALL turns in the session are private until explicitly toggled off.
+//   Turn-level     — Only the NEXT turn is private; flag auto-clears after that turn.
+//
+// Usage (server.ts):
+//   if (!isCurrentTurnPrivate(sessionId)) {
+//     sessionMemory.addExchange(...)
+//     memoryLayers.write(...)
+//   }
+//   clearTurnPrivate(sessionId)   // always call after turn completes
+//
+// Usage (CLI, /private command):
+//   const nowPrivate = toggleSessionPrivate(sessionId)
+//   console.log(nowPrivate ? '🔒 Private mode ON' : '🔓 Private mode OFF')
+// ── State ─────────────────────────────────────────────────────────────────────
+/** Sessions where every turn is private until explicitly cleared. */
+const sessionPrivate = new Set();
+/** Sessions where only the NEXT single turn is private (auto-clears). */
+const nextTurnPrivate = new Set();
+// ── Session-level API ─────────────────────────────────────────────────────────
+/** Mark all future turns in `sessionId` as private. */
+function setSessionPrivate(sessionId) {
+    sessionPrivate.add(sessionId);
+}
+/** Remove session-level private flag (turns private mode off for the session). */
+function clearSessionPrivate(sessionId) {
+    sessionPrivate.delete(sessionId);
+}
+/**
+ * Toggle session-level private mode.
+ * @returns true when private mode is now ON, false when now OFF.
+ */
+function toggleSessionPrivate(sessionId) {
+    if (sessionPrivate.has(sessionId)) {
+        sessionPrivate.delete(sessionId);
+        return false;
+    }
+    sessionPrivate.add(sessionId);
+    return true;
+}
+/** True when the entire session is set to private. */
+function isSessionPrivate(sessionId) {
+    return sessionPrivate.has(sessionId);
+}
+// ── Turn-level API ────────────────────────────────────────────────────────────
+/** Mark only the NEXT turn for `sessionId` as private. Auto-clears after that turn. */
+function markNextTurnPrivate(sessionId) {
+    nextTurnPrivate.add(sessionId);
+}
+/**
+ * Returns true when the current turn should suppress all memory writes.
+ * Checks both session-level and turn-level flags.
+ */
+function isCurrentTurnPrivate(sessionId) {
+    return sessionPrivate.has(sessionId) || nextTurnPrivate.has(sessionId);
+}
+/**
+ * Clear the one-turn private flag for `sessionId`.
+ * Call this after every turn completes, regardless of private state —
+ * it is a no-op when the flag is not set.
+ */
+function clearTurnPrivate(sessionId) {
+    nextTurnPrivate.delete(sessionId);
+}

package/dist/core/reactLoop.js

@@ -0,0 +1,156 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReActLoop = runReActLoop;
+// core/reactLoop.ts — ReAct (Reasoning + Acting) agent loop.
+// Iterates: Thought → Action → Observation until FINISH or maxIterations.
+const agentLoop_1 = require("./agentLoop");
+const toolRegistry_1 = require("./toolRegistry");
+const livePulse_1 = require("../coordination/livePulse");
+// ── ReAct system prompt ────────────────────────────────────────
+const REACT_SYSTEM = `You are DevOS ReAct agent. You solve goals iteratively using a Thought→Action→Observation loop.
+
+At each step, output ONLY valid JSON with this shape:
+{
+  "reasoning": "what you're thinking",
+  "action": "tool_name or FINISH",
+  "actionInput": { ...tool args },
+  "finalAnswer": "only when action is FINISH — the complete answer"
+}
+
+Available tools:
+- web_search    { "query": "..." }
+- fetch_url     { "url": "https://..." }
+- file_read     { "path": "..." }
+- file_write    { "path": "...", "content": "..." }
+- run_python    { "script": "..." }
+- run_node      { "code": "..." }
+- shell_exec    { "command": "..." }
+- system_info   {}
+- deep_research { "topic": "..." }
+- get_stocks    { "market": "NSE", "type": "gainers" }
+
+Rules:
+1. Think step-by-step. Use observations from previous steps.
+2. When you have enough information to answer, set action to FINISH and provide finalAnswer.
+3. Output ONLY valid JSON — no markdown, no prose outside the JSON.
+4. If a tool fails, adapt your approach in the next thought.`;
+// ── Parse LLM output to Thought ────────────────────────────────
+function parseThought(raw) {
+    try {
+        const cleaned = raw
+            .replace(/```json\s*/g, '')
+            .replace(/```\s*/g, '')
+            .trim();
+        const match = cleaned.match(/\{[\s\S]*\}/);
+        if (!match)
+            return null;
+        const parsed = JSON.parse(match[0]);
+        return {
+            reasoning: String(parsed.reasoning || ''),
+            action: String(parsed.action || 'FINISH'),
+            actionInput: parsed.actionInput && typeof parsed.actionInput === 'object'
+                ? parsed.actionInput
+                : {},
+            finalAnswer: parsed.finalAnswer ? String(parsed.finalAnswer) : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Build context string from prior steps ──────────────────────
+function buildContext(goal, steps) {
+    let ctx = `Goal: ${goal}\n\n`;
+    for (let i = 0; i < steps.length; i++) {
+        const s = steps[i];
+        ctx += `Step ${i + 1}:\n`;
+        ctx += `  Thought: ${s.thought.reasoning}\n`;
+        ctx += `  Action: ${s.thought.action}(${JSON.stringify(s.thought.actionInput)})\n`;
+        ctx += `  Observation: ${s.observation.success ? 'OK' : 'ERROR'} — ${s.observation.result.slice(0, 400)}\n\n`;
+    }
+    ctx += 'What is your next thought and action? Output JSON only.';
+    return ctx;
+}
+// ── Main ReAct loop ────────────────────────────────────────────
+async function runReActLoop(goal, apiKey, model, provider, onStep, maxIterations = 5) {
+    const steps = [];
+    let answer = '';
+    livePulse_1.livePulse.act('ReAct', `Starting: ${goal.slice(0, 60)}`);
+    for (let iter = 0; iter < maxIterations; iter++) {
+        // Build prompt from system + accumulated context
+        const contextPrompt = `${REACT_SYSTEM}\n\n${buildContext(goal, steps)}`;
+        // Call LLM
+        let raw = '';
+        try {
+            raw = await (0, agentLoop_1.callLLM)(contextPrompt, apiKey, model, provider);
+        }
+        catch (e) {
+            console.warn(`[ReAct] LLM call failed at iter ${iter}: ${e.message}`);
+            break;
+        }
+        if (!raw || raw.trim().length === 0) {
+            console.warn(`[ReAct] Empty LLM response at iter ${iter}`);
+            break;
+        }
+        // Parse thought
+        const thought = parseThought(raw);
+        if (!thought) {
+            console.warn(`[ReAct] Could not parse thought at iter ${iter}: ${raw.slice(0, 100)}`);
+            break;
+        }
+        livePulse_1.livePulse.act('ReAct', `Iter ${iter + 1}: ${thought.action}`);
+        // FINISH — return final answer
+        if (thought.action === 'FINISH') {
+            answer = thought.finalAnswer || thought.reasoning || 'Done.';
+            // Record a terminal step with a synthetic observation
+            const terminalStep = {
+                thought,
+                observation: { tool: 'FINISH', result: answer, success: true },
+            };
+            steps.push(terminalStep);
+            onStep(terminalStep);
+            break;
+        }
+        // Execute the tool
+        let toolResult = '';
+        let toolSuccess = false;
+        try {
+            const result = await (0, toolRegistry_1.executeTool)(thought.action, thought.actionInput);
+            toolResult = typeof result.output === 'string'
+                ? result.output
+                : JSON.stringify(result.output || result);
+            toolSuccess = result.success !== false;
+        }
+        catch (e) {
+            toolResult = `Tool error: ${e.message}`;
+            toolSuccess = false;
+        }
+        const step = {
+            thought,
+            observation: {
+                tool: thought.action,
+                result: toolResult,
+                success: toolSuccess,
+            },
+        };
+        steps.push(step);
+        onStep(step);
+        console.log(`[ReAct] Iter ${iter + 1}: ${thought.action} → ${toolSuccess ? 'OK' : 'ERR'} (${toolResult.slice(0, 80)})`);
+    }
+    // If loop exhausted without FINISH, summarise what was gathered
+    if (!answer && steps.length > 0) {
+        const lastObs = steps[steps.length - 1].observation;
+        answer = lastObs.success
+            ? lastObs.result.slice(0, 800)
+            : `Could not complete the goal after ${steps.length} steps. Last error: ${lastObs.result.slice(0, 200)}`;
+    }
+    if (!answer) {
+        answer = 'I was unable to complete the task.';
+    }
+    livePulse_1.livePulse.done('ReAct', `Finished in ${steps.length} step(s)`);
+    return { answer, steps };
+}

package/dist/core/recipeEngine.js

@@ -0,0 +1,166 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAllRecipes = loadAllRecipes;
+exports.executeRecipe = executeRecipe;
+exports.matchRecipe = matchRecipe;
+// core/recipeEngine.ts — YAML workflow definitions with typed
+// params, explicit tool chains, conditions, and retry logic.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const toolRegistry_1 = require("./toolRegistry");
+// ── Loader ────────────────────────────────────────────────────
+function loadRecipe(filePath) {
+    try {
+        const content = fs_1.default.readFileSync(filePath, 'utf8');
+        const recipe = js_yaml_1.default.load(content);
+        if (!recipe.name || !recipe.steps || recipe.steps.length === 0) {
+            console.log(`[Recipe] Invalid recipe: ${filePath} — missing name or steps`);
+            return null;
+        }
+        return recipe;
+    }
+    catch {
+        console.log(`[Recipe] Failed to parse: ${filePath}`);
+        return null;
+    }
+}
+function loadAllRecipes() {
+    const recipeDirs = [
+        path_1.default.join(process.cwd(), 'workspace', 'recipes'),
+        path_1.default.join(process.cwd(), 'recipes'),
+    ];
+    const recipes = [];
+    for (const dir of recipeDirs) {
+        if (!fs_1.default.existsSync(dir))
+            continue;
+        const files = fs_1.default.readdirSync(dir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+        for (const file of files) {
+            const recipe = loadRecipe(path_1.default.join(dir, file));
+            if (recipe)
+                recipes.push(recipe);
+        }
+    }
+    if (recipes.length > 0) {
+        console.log(`[Recipe] Loaded ${recipes.length} recipes`);
+    }
+    return recipes;
+}
+// ── Template resolution ───────────────────────────────────────
+function resolveTemplate(template, params, stepResults) {
+    return template.replace(/\{\{(\w+\.[\w.]+)\}\}/g, (match, dotPath) => {
+        const parts = dotPath.split('.');
+        if (parts[0] === 'params') {
+            return String(params[parts[1]] ?? match);
+        }
+        if (parts[0] === 'steps') {
+            const stepResult = stepResults[parts[1]];
+            if (stepResult && parts[2]) {
+                return String(stepResult[parts[2]] ?? stepResult.output ?? match);
+            }
+            return String(stepResult?.output ?? match);
+        }
+        return match;
+    });
+}
+function resolveArgs(args, params, stepResults) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+        resolved[key] = typeof value === 'string'
+            ? resolveTemplate(value, params, stepResults)
+            : value;
+    }
+    return resolved;
+}
+// ── Condition evaluator ───────────────────────────────────────
+function evaluateCondition(condition, stepResults) {
+    try {
+        const resolved = condition.replace(/steps\.(\w+)\.(\w+)/g, (_full, stepId, prop) => {
+            const result = stepResults[stepId];
+            if (!result)
+                return 'undefined';
+            return JSON.stringify(result[prop] ?? result.output);
+        });
+        // eslint-disable-next-line no-new-func
+        return new Function(`return ${resolved}`)();
+    }
+    catch {
+        return true; // default to true if condition can't be evaluated
+    }
+}
+// ── Executor ──────────────────────────────────────────────────
+async function executeRecipe(recipe, params) {
+    console.log(`[Recipe] Executing: ${recipe.name}`);
+    // Apply defaults for missing optional params
+    for (const [name, def] of Object.entries(recipe.params || {})) {
+        if (!(name in params) && 'default' in def) {
+            params[name] = def.default;
+        }
+    }
+    const stepResults = {};
+    for (const step of recipe.steps) {
+        // Evaluate condition gate
+        if (step.condition) {
+            try {
+                if (!evaluateCondition(step.condition, stepResults)) {
+                    console.log(`[Recipe] Skipping ${step.id}: condition not met`);
+                    stepResults[step.id] = { skipped: true };
+                    continue;
+                }
+            }
+            catch { }
+        }
+        const resolvedArgs = resolveArgs(step.args || {}, params, stepResults);
+        console.log(`[Recipe] Step ${step.id}: ${step.tool}`);
+        const maxAttempts = step.retries ?? 1;
+        let result = null;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                result = await (0, toolRegistry_1.executeTool)(step.tool, resolvedArgs);
+                if (result?.success)
+                    break;
+            }
+            catch (err) {
+                if (attempt === maxAttempts - 1) {
+                    if (step.onFail === 'abort') {
+                        return { success: false, output: `Recipe aborted at step ${step.id}: ${err}` };
+                    }
+                    // 'skip' or no onFail — mark skipped and continue
+                    result = { skipped: true, error: String(err), output: '' };
+                }
+            }
+        }
+        stepResults[step.id] = result;
+    }
+    const output = resolveTemplate(recipe.output || '', params, stepResults);
+    return { success: true, output };
+}
+function matchRecipe(message, recipes) {
+    for (const recipe of recipes) {
+        for (const trigger of (recipe.trigger || [])) {
+            // Extract param names from {{param}} placeholders
+            const paramNames = (trigger.match(/\{\{(\w+)\}\}/g) || [])
+                .map(p => p.replace(/[{}]/g, ''));
+            // Build a regex by replacing {{param}} with capture groups
+            const escaped = trigger.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const pattern = escaped.replace(/\\\{\\\{(\w+)\\\}\\\}/g, '(.+)');
+            const match = message.match(new RegExp(`^${pattern}$`, 'i'));
+            if (match) {
+                console.log(`[Recipe] Matched: ${recipe.name} via trigger: "${trigger}"`);
+                const params = {};
+                paramNames.forEach((name, i) => {
+                    params[name] = match[i + 1]?.trim();
+                });
+                return { recipe, params };
+            }
+        }
+    }
+    return null;
+}

package/dist/core/responseCache.js

@@ -0,0 +1,128 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseCache = exports.ResponseCache = void 0;
+// core/responseCache.ts — TTL-based response cache for tool results.
+// Tools with defined TTLs get their outputs cached and reused within
+// the TTL window. Side-effectful tools (file_write, shell_exec, etc.)
+// are explicitly excluded via NO_CACHE_TOOLS.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const CACHE_PATH = path_1.default.join(process.cwd(), 'workspace', 'cache', 'response-cache.json');
+// TTL per tool type (milliseconds)
+const TOOL_TTL = {
+    system_info: 30 * 1000, // 30 seconds — hardware changes rarely
+    get_market_data: 5 * 60 * 1000, // 5 minutes  — prices update frequently
+    get_company_info: 60 * 60 * 1000, // 1 hour     — fundamentals change slowly
+    get_stocks: 5 * 60 * 1000, // 5 minutes
+    social_research: 30 * 60 * 1000, // 30 minutes
+    web_search: 10 * 60 * 1000, // 10 minutes
+    fetch_url: 15 * 60 * 1000, // 15 minutes
+    fetch_page: 15 * 60 * 1000, // 15 minutes
+};
+// Tools that should NEVER be cached (side-effectful or time-sensitive)
+const NO_CACHE_TOOLS = new Set([
+    'file_write', 'file_read', 'shell_exec', 'run_python',
+    'run_node', 'screenshot', 'notify', 'open_browser',
+    'browser_click', 'browser_type', 'mouse_click', 'keyboard_type',
+    'code_interpreter_python', 'code_interpreter_node',
+]);
+class ResponseCache {
+    constructor() {
+        this.cache = new Map();
+        this.load();
+        // Cleanup expired entries every 5 minutes
+        setInterval(() => this.cleanup(), 5 * 60 * 1000);
+    }
+    // ── Key hashing ───────────────────────────────────────────────
+    hashKey(tool, input) {
+        const str = `${tool}:${JSON.stringify(input, Object.keys(input).sort())}`;
+        return crypto_1.default.createHash('md5').update(str).digest('hex');
+    }
+    // ── Cache read ────────────────────────────────────────────────
+    get(tool, input) {
+        if (NO_CACHE_TOOLS.has(tool))
+            return null;
+        const key = this.hashKey(tool, input);
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        entry.hitCount++;
+        console.log(`[Cache] HIT: ${tool} (hits: ${entry.hitCount})`);
+        return entry.output;
+    }
+    // ── Cache write ───────────────────────────────────────────────
+    set(tool, input, output) {
+        if (NO_CACHE_TOOLS.has(tool))
+            return;
+        const ttl = TOOL_TTL[tool];
+        if (!ttl)
+            return; // Only cache tools with a defined TTL
+        const key = this.hashKey(tool, input);
+        this.cache.set(key, {
+            key,
+            output,
+            tool,
+            input,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + ttl,
+            hitCount: 0,
+        });
+        this.save();
+    }
+    // ── Stats ─────────────────────────────────────────────────────
+    getStats() {
+        const tools = {};
+        let totalHits = 0;
+        for (const entry of this.cache.values()) {
+            tools[entry.tool] = (tools[entry.tool] || 0) + 1;
+            totalHits += entry.hitCount;
+        }
+        return { totalEntries: this.cache.size, totalHits, tools };
+    }
+    // ── Clear all ─────────────────────────────────────────────────
+    clear() {
+        this.cache.clear();
+        this.save();
+    }
+    // ── Expired entry cleanup ─────────────────────────────────────
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            if (now > entry.expiresAt)
+                this.cache.delete(key);
+        }
+        this.save();
+    }
+    // ── Persistence ───────────────────────────────────────────────
+    load() {
+        try {
+            if (!fs_1.default.existsSync(CACHE_PATH))
+                return;
+            const data = JSON.parse(fs_1.default.readFileSync(CACHE_PATH, 'utf-8'));
+            this.cache = new Map(Object.entries(data));
+            this.cleanup(); // Remove expired entries on load
+        }
+        catch { }
+    }
+    save() {
+        try {
+            fs_1.default.mkdirSync(path_1.default.dirname(CACHE_PATH), { recursive: true });
+            fs_1.default.writeFileSync(CACHE_PATH, JSON.stringify(Object.fromEntries(this.cache), null, 2));
+        }
+        catch { }
+    }
+}
+exports.ResponseCache = ResponseCache;
+exports.responseCache = new ResponseCache();

package/dist/core/runSandbox.js

@@ -0,0 +1,132 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInSandbox = runInSandbox;
+// core/runSandbox.ts — Node.js VM-based sandbox for the ▲ run tool.
+//
+// Injects the Aiden SDK (`aiden` namespace) into a fresh VM context.
+// All tool calls are tracked. Timeout and max-tool-call limits enforced.
+// No new dependencies — uses built-in `vm` module only.
+const vm_1 = require("vm");
+const aidenSdk_1 = require("./aidenSdk");
+// ── Sandbox ───────────────────────────────────────────────────────────────────
+const DEFAULT_TIMEOUT = 30000; // 30 s
+const DEFAULT_MAX_TOOL_CALLS = 20;
+async function runInSandbox(code, options = {}) {
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const maxToolCalls = options.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS;
+    const start = Date.now();
+    const outputLog = [];
+    const toolCalls = [];
+    // ── Build SDK runtime with tracking ───────────────────────────────────────
+    const sdk = (0, aidenSdk_1.buildSdkRuntime)((toolName, args) => {
+        if (toolCalls.length >= maxToolCalls) {
+            throw new Error(`Tool call limit exceeded (max ${maxToolCalls}). Aborting.`);
+        }
+        const callStart = Date.now();
+        // We push after the fact — duration set to 0 here, patched in wrapper below
+        toolCalls.push({ tool: toolName, args, durationMs: 0 });
+        const idx = toolCalls.length - 1;
+        // Patch the duration after the call completes (via a post-hook approach)
+        const origTime = callStart;
+        // We'll update durationMs via the wrapper in makeTrackedSdk
+        void origTime; // suppress unused warning; timing done differently below
+        void idx;
+    });
+    // ── Patch SDK to record timing per-call ───────────────────────────────────
+    const trackedSdk = patchSdkTiming(sdk, toolCalls, maxToolCalls);
+    // ── Sandboxed console ─────────────────────────────────────────────────────
+    const sandboxConsole = {
+        log: (...a) => outputLog.push(a.map(String).join(' ')),
+        warn: (...a) => outputLog.push('[warn] ' + a.map(String).join(' ')),
+        error: (...a) => outputLog.push('[error] ' + a.map(String).join(' ')),
+        info: (...a) => outputLog.push(a.map(String).join(' ')),
+    };
+    // ── VM context — minimal globals ─────────────────────────────────────────
+    const ctx = (0, vm_1.createContext)({
+        aiden: trackedSdk,
+        console: sandboxConsole,
+        JSON,
+        Math,
+        Date,
+        parseInt,
+        parseFloat,
+        isNaN,
+        isFinite,
+        String,
+        Number,
+        Boolean,
+        Array,
+        Object,
+        Promise,
+        setTimeout,
+        clearTimeout,
+        setInterval,
+        clearInterval,
+    });
+    // ── Wrap user code in async IIFE ─────────────────────────────────────────
+    const wrappedCode = `
+(async () => {
+  ${code}
+})()
+`;
+    try {
+        const script = new vm_1.Script(wrappedCode);
+        const resultPromise = script.runInContext(ctx, { timeout: Math.min(timeout, 5000) });
+        // The script.runInContext timeout only applies to sync execution.
+        // For async, we race with a wall-clock timeout.
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Sandbox timeout after ${timeout}ms`)), timeout));
+        const finalValue = await Promise.race([resultPromise, timeoutPromise]);
+        return {
+            success: true,
+            output: outputLog,
+            result: finalValue,
+            toolCalls,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            output: outputLog,
+            error: err?.message ?? String(err),
+            toolCalls,
+            durationMs: Date.now() - start,
+        };
+    }
+}
+// ── Timing patcher ────────────────────────────────────────────────────────────
+/**
+ * Walks the SDK object tree and wraps every async function to record
+ * actual call duration in the toolCalls array.
+ */
+function patchSdkTiming(sdkNode, toolCalls, maxToolCalls) {
+    if (typeof sdkNode === 'function') {
+        return async (...args) => {
+            if (toolCalls.length >= maxToolCalls) {
+                throw new Error(`Tool call limit exceeded (max ${maxToolCalls}). Aborting.`);
+            }
+            const t0 = Date.now();
+            try {
+                return await sdkNode(...args);
+            }
+            finally {
+                // Find the last entry that was pushed by the inner onToolCall handler
+                const last = toolCalls[toolCalls.length - 1];
+                if (last)
+                    last.durationMs = Date.now() - t0;
+            }
+        };
+    }
+    if (typeof sdkNode === 'object' && sdkNode !== null) {
+        const patched = {};
+        for (const [k, v] of Object.entries(sdkNode)) {
+            patched[k] = patchSdkTiming(v, toolCalls, maxToolCalls);
+        }
+        return patched;
+    }
+    return sdkNode;
+}