jsfe 0.8.0 → 0.9.0

package/dist/index.js

@@ -302,6 +302,66 @@ export function getFlowPrompt(engine, flowName) {
     // Fallback to default prompt or flow name
     return flow.prompt || flow.name;
 }
+// Pure function-based transaction management (no methods, always serializable)
+export class TransactionManager {
+    static create(flowName, initiator, userId) {
+        return {
+            id: crypto.randomUUID(),
+            flowName: flowName,
+            initiator: initiator,
+            userId: userId,
+            steps: [],
+            state: 'active',
+            createdAt: new Date(),
+            metadata: {}
+        };
+    }
+    static addStep(transaction, step, result, duration, status = 'success') {
+        const transactionStep = {
+            stepId: step.id || crypto.randomUUID(),
+            stepType: step.type || 'unknown',
+            timestamp: new Date(),
+            duration: duration,
+            status: status,
+            result: TransactionManager.sanitizeForLog(result)
+        };
+        if (status === 'error' && result instanceof Error) {
+            transactionStep.error = result.message;
+        }
+        transaction.steps.push(transactionStep);
+    }
+    static addError(transaction, step, error, duration) {
+        TransactionManager.addStep(transaction, step, error, duration, 'error');
+    }
+    static sanitizeForLog(data) {
+        if (typeof data === 'string') {
+            return data.length > 500 ? data.substring(0, 500) + '...' : data;
+        }
+        if (typeof data === 'object' && data !== null) {
+            try {
+                const jsonStr = JSON.stringify(data);
+                return jsonStr.length > 500 ? jsonStr.substring(0, 500) + '...' : data;
+            }
+            catch {
+                return '[Circular or non-serializable object]';
+            }
+        }
+        return data;
+    }
+    static rollback(transaction) {
+        transaction.state = 'rolled_back';
+        transaction.rolledBackAt = new Date();
+    }
+    static complete(transaction) {
+        transaction.state = 'completed';
+        transaction.completedAt = new Date();
+    }
+    static fail(transaction, reason) {
+        transaction.state = 'failed';
+        transaction.failedAt = new Date();
+        transaction.failureReason = reason;
+    }
+}
 // Initialize JSON Schema validator
 const ajv = new Ajv({ allErrors: true, strict: false });
 addFormats(ajv);
@@ -318,6 +378,7 @@ function isPathTraversableObject(val) {
  * @param data - Source data to transform (typically API response)
  * @param mappingConfig - Mapping configuration specifying how to transform the data
  * @param args - Arguments available for template variables and $args references
+ * @param engine - Engine instance for context and utilities
  * @returns Transformed data according to mapping configuration
  *
  * @example
@@ -335,7 +396,7 @@ function isPathTraversableObject(val) {
  * ) // "Name: Alice, Age: 25"
  * ```
  */
-function applyResponseMapping(data, mappingConfig, args = {}) {
+function applyResponseMapping(data, mappingConfig, args = {}, engine) {
     logger.debug(`applyResponseMapping called with: dataType=${typeof data}, data=${JSON.stringify(data)}, mappingConfig=${JSON.stringify(mappingConfig)}, args=${JSON.stringify(args)}`);
     if (!mappingConfig) {
         logger.debug(`No mapping config provided, returning original data`);
@@ -355,13 +416,13 @@ function applyResponseMapping(data, mappingConfig, args = {}) {
             case 'jsonPath':
                 return applyJsonPathMapping(data, mappingConfig, args);
             case 'object':
-                return applyObjectMapping(data, mappingConfig, args);
+                return applyObjectMapping(data, mappingConfig, args, engine);
             case 'array':
-                return applyArrayMapping(data, mappingConfig, args);
+                return applyArrayMapping(data, mappingConfig, args, engine);
             case 'template':
-                return applyTemplateMapping(data, mappingConfig, args);
+                return applyTemplateMapping(data, mappingConfig, args, engine);
             case 'conditional':
-                return applyConditionalMapping(data, mappingConfig, args);
+                return applyConditionalMapping(data, mappingConfig, args, engine);
         }
     }
     // Handle PathConfig (has path property but not type)
@@ -468,7 +529,7 @@ function applyJsonPathMapping(data, config, args) {
     return result;
 }
 // Object structure mapping with nested transformations
-function applyObjectMapping(data, config, args) {
+function applyObjectMapping(data, config, args, engine) {
     const result = {};
     for (const [key, value] of Object.entries(config.mappings)) {
         try {
@@ -478,7 +539,7 @@ function applyObjectMapping(data, config, args) {
             }
             else if (typeof value === 'object' && value !== null && 'type' in value) {
                 // Nested mapping with type
-                result[key] = applyResponseMapping(data, value, args);
+                result[key] = applyResponseMapping(data, value, args, engine);
             }
             else if (typeof value === 'object' && value !== null && 'path' in value) {
                 // Object with path and optional transform
@@ -496,7 +557,7 @@ function applyObjectMapping(data, config, args) {
             }
             else if (typeof value === 'object' && value !== null) {
                 // Static object with potential interpolation
-                result[key] = interpolateObject(value, data, args);
+                result[key] = interpolateObject(value, data, args, engine);
             }
             else {
                 // Literal value
@@ -517,7 +578,7 @@ function applyObjectMapping(data, config, args) {
     return result;
 }
 // Array transformation and filtering
-function applyArrayMapping(data, config, args) {
+function applyArrayMapping(data, config, args, engine) {
     const sourceArray = config.source ? extractByPath(data, config.source) : data;
     if (!Array.isArray(sourceArray)) {
         logger.warn(`Array mapping source is not an array:`, sourceArray);
@@ -541,7 +602,7 @@ function applyArrayMapping(data, config, args) {
     if (config.itemMapping) {
         result = result.map((item, index) => {
             try {
-                return applyResponseMapping(item, config.itemMapping, { ...args, index });
+                return applyResponseMapping(item, config.itemMapping, { ...args, index }, engine);
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -584,7 +645,7 @@ function applyArrayMapping(data, config, args) {
     return result;
 }
 // Template-based string interpolation
-function applyTemplateMapping(data, config, args) {
+function applyTemplateMapping(data, config, args, engine) {
     let template = config.template;
     // Check if template contains complex Handlebars syntax
     const hasHandlebarsIteration = /\{\{#each\s+[^}]+\}\}/.test(template);
@@ -606,7 +667,7 @@ function applyTemplateMapping(data, config, args) {
     return template;
 }
 // Conditional mapping based on data content
-function applyConditionalMapping(data, config, args) {
+function applyConditionalMapping(data, config, args, engine) {
     if (!config.conditions || !Array.isArray(config.conditions)) {
         throw new Error('Conditional mapping requires a conditions array');
     }
@@ -625,7 +686,7 @@ function applyConditionalMapping(data, config, args) {
                 conditionResult = evaluateCondition(data, condition.if);
             }
             if (conditionResult) {
-                return applyResponseMapping(data, condition.then, args);
+                return applyResponseMapping(data, condition.then, args, engine);
             }
         }
         catch (error) {
@@ -636,7 +697,7 @@ function applyConditionalMapping(data, config, args) {
     }
     // Default case
     if (config.else) {
-        return applyResponseMapping(data, config.else, args);
+        return applyResponseMapping(data, config.else, args, engine);
     }
     return data;
 }
@@ -1212,15 +1273,49 @@ function evaluateCondition(data, condition) {
         return false;
     }
 }
-function interpolateObject(obj, data, args = {}) {
+function interpolateObject(obj, data, args = {}, engine) {
     if (typeof obj === 'string') {
-        // Handle template strings
+        // Check if the string is ONLY a single template expression (e.g., '{{cargo}}')
+        const singleTemplateMatch = obj.match(/^\{\{([^}]+)\}\}$/);
+        if (singleTemplateMatch) {
+            // This is a single template expression - return the actual value, not a string conversion
+            const path = singleTemplateMatch[1].trim();
+            try {
+                let value = undefined;
+                if (isPathTraversableObject(data)) {
+                    value = extractByPath(data, path);
+                }
+                // If not found in data and engine is available, check engine session variables
+                if ((value === undefined || value === null)) {
+                    try {
+                        value = resolveEngineSessionVariable(path, engine);
+                    }
+                    catch (error) {
+                        // Ignore engine session variable resolution errors
+                    }
+                }
+                return value !== undefined && value !== null ? value : '';
+            }
+            catch (error) {
+                return obj; // Keep original on error
+            }
+        }
+        // Handle template strings with multiple expressions or mixed content
         return obj.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
             try {
                 let value = undefined;
                 if (isPathTraversableObject(data)) {
                     value = extractByPath(data, path.trim());
                 }
+                // If not found in data and engine is available, check engine session variables
+                if ((value === undefined || value === null)) {
+                    try {
+                        value = resolveEngineSessionVariable(path.trim(), engine);
+                    }
+                    catch (error) {
+                        // Ignore engine session variable resolution errors
+                    }
+                }
                 return value !== null && value !== undefined ? String(value) : '';
             }
             catch (error) {
@@ -1237,24 +1332,34 @@ function interpolateObject(obj, data, args = {}) {
         });
     }
     else if (Array.isArray(obj)) {
-        return obj.map(item => interpolateObject(item, data, args));
+        return obj.map(item => interpolateObject(item, data, args, engine));
     }
     else if (typeof obj === 'object' && obj !== null) {
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
-            result[key] = interpolateObject(value, data, args);
+            result[key] = interpolateObject(value, data, args, engine);
         }
         return result;
     }
     return obj;
 }
-// Fake logger that does nothing - in case hostLogger argument to engine.initSession is null
-let logger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-    debug: () => { }
-};
+function makeLogger(level = process.env.LOG_LEVEL || "warn") {
+    const ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
+    let current = ORDER[level] ?? ORDER.warn;
+    const allow = (lvl) => ORDER[lvl] >= current;
+    return {
+        setLevel: (lvl) => { current = ORDER[lvl] ?? current; },
+        debug: (...a) => { if (allow("debug"))
+            console.debug(...a); },
+        info: (...a) => { if (allow("info"))
+            console.info(...a); },
+        warn: (...a) => { if (allow("warn"))
+            console.warn(...a); },
+        error: (...a) => { if (allow("error"))
+            console.error(...a); },
+    };
+}
+let logger = makeLogger();
 // Fallback for any remaining console calls
 if (!global.console) {
     global.console = {
@@ -1264,73 +1369,6 @@ if (!global.console) {
         info: (...args) => logger.info(args.join(' '))
     };
 }
-// === TRANSACTION MANAGEMENT CLASS ===
-class FlowTransaction {
-    constructor(flowName, initiator, userId = 'anonymous') {
-        this.steps = [];
-        this.state = 'active';
-        this.metadata = {};
-        this.id = crypto.randomUUID();
-        this.flowName = flowName;
-        this.initiator = initiator;
-        this.userId = userId;
-        this.steps = [];
-        this.state = 'active';
-        this.createdAt = new Date();
-        this.metadata = {};
-    }
-    addStep(step, result, duration, status = 'success') {
-        this.steps.push({
-            stepId: step.id || step.type,
-            stepType: step.type,
-            tool: step.tool,
-            result: this.sanitizeForLog(result),
-            duration,
-            status,
-            timestamp: new Date(),
-            retryCount: step.retryCount || 0
-        });
-    }
-    addError(step, error, duration) {
-        this.steps.push({
-            stepId: step.id || step.type,
-            stepType: step.type,
-            tool: step.tool,
-            error: error.message,
-            duration,
-            status: 'error',
-            timestamp: new Date()
-        });
-    }
-    sanitizeForLog(data) {
-        if (typeof data === 'object' && data !== null) {
-            const sanitized = { ...data };
-            // Remove sensitive fields
-            delete sanitized.signature;
-            delete sanitized.password;
-            delete sanitized.token;
-            return sanitized;
-        }
-        return data;
-    }
-    rollback() {
-        // In a real implementation, this would execute compensating actions
-        this.state = 'rolled_back';
-        this.rolledBackAt = new Date();
-        auditLogger.logTransactionRollback(this);
-    }
-    complete() {
-        this.state = 'completed';
-        this.completedAt = new Date();
-        auditLogger.logTransactionComplete(this);
-    }
-    fail(reason) {
-        this.state = 'failed';
-        this.failedAt = new Date();
-        this.failureReason = reason;
-        auditLogger.logTransactionFailed(this);
-    }
-}
 // === COMPREHENSIVE AUDIT LOGGING ===
 const auditLogger = {
     logFlowStart(flowName, input, userId, transactionId) {
@@ -1616,7 +1654,8 @@ function exportConversationHistory(contextStack, format = 'simple') {
 // Stored in engine.flowStacks for proper context isolation
 function initializeFlowStacks(engine) {
     try {
-        engine.flowStacks = [[]];
+        // Use the engine method directly since Engine is now an alias for WorkflowEngine
+        engine.initializeFlowStacks();
     }
     catch (error) {
         logger.error("Failed to initialize flow stacks:", error.message);
@@ -1631,7 +1670,11 @@ function pushToCurrentStack(engine, flowFrame) {
     getCurrentStack(engine).push(flowFrame);
 }
 function popFromCurrentStack(engine) {
-    return getCurrentStack(engine).pop();
+    const result = getCurrentStack(engine).pop();
+    if (!result) {
+        throw new Error('Cannot pop from empty stack');
+    }
+    return result;
 }
 function createNewStack(engine) {
     // Create new stack and switch to it
@@ -1703,7 +1746,7 @@ async function isFlowActivated(input, engine, userId = 'anonymous') {
     const flowsMenu = engine.flowsMenu;
     const flow = await getFlowForInput(input, engine);
     if (flow) {
-        const transaction = new FlowTransaction(flow.name, 'user-input', userId);
+        const transaction = TransactionManager.create(flow.name, 'user-input', userId);
         // Prepare tentative flow_init message that will be replaced by SAY-GET guidance if present
         const tentativeFlowInit = getSystemMessage(engine, 'flow_init', {
             flowName: flow.name,
@@ -1741,7 +1784,7 @@ async function playFlowFrame(engine) {
             auditLogger.logFlowExit(currentFlowFrame.flowName, currentFlowFrame.userId, currentFlowFrame.transaction.id, 'max_recursion_depth');
             // Do we need this?
             //currentFlowFrame.contextStack.push(error.message);
-            currentFlowFrame.transaction.fail("Max recursion depth exceeded");
+            TransactionManager.fail(currentFlowFrame.transaction, "Max recursion depth exceeded");
         }
         throw error;
     }
@@ -1778,7 +1821,7 @@ async function playFlowFrame(engine) {
         if (currentFlowFrame.flowStepsStack.length === 0) {
             logger.info(`Flow ${currentFlowFrame.flowName} completed, popping from stack (steps length: ${currentFlowFrame.flowStepsStack.length})`);
             const completedFlow = popFromCurrentStack(engine);
-            completedFlow.transaction.complete();
+            TransactionManager.complete(completedFlow.transaction);
             // When a flow completes, it doesn't "return" a value in the traditional sense.
             // It communicates results by setting variables in the shared `variables` object,
             // which are then accessible to the parent flow.
@@ -1832,6 +1875,9 @@ async function playFlowFrame(engine) {
                         }
                         continue;
                     }
+                    else {
+                        logger.error(`Failed to resume flow - no flow frames available after switching stacks.`);
+                    }
                 }
                 else {
                     logger.info(`No more flow frames to process, all flows completed.`);
@@ -1846,7 +1892,7 @@ async function playFlowFrame(engine) {
         try {
             const result = await playStep(currentFlowFrame, engine);
             const duration = Date.now() - startTime;
-            currentFlowFrame.transaction.addStep(step, result, duration, 'success');
+            TransactionManager.addStep(currentFlowFrame.transaction, step, result, duration, 'success');
             logger.info(`Step ${step.type} executed successfully, result: ${typeof result === 'object' ? '[object]' : result}`);
             // If this was a SAY-GET step, return and wait for user input
             if (step.type === 'SAY-GET') {
@@ -1854,7 +1900,7 @@ async function playFlowFrame(engine) {
                 if (currentFlowFrame.flowStepsStack.length === 0) {
                     logger.info(`SAY-GET step was final step, flow ${currentFlowFrame.flowName} completed`);
                     const completedFlow = popFromCurrentStack(engine);
-                    completedFlow.transaction.complete();
+                    TransactionManager.complete(completedFlow.transaction);
                     return result;
                 }
                 return result;
@@ -1864,7 +1910,7 @@ async function playFlowFrame(engine) {
         }
         catch (error) {
             const duration = Date.now() - startTime;
-            currentFlowFrame.transaction.addError(step, error, duration);
+            TransactionManager.addError(currentFlowFrame.transaction, step, error, duration);
             logger.error(`Step ${step.type} failed: ${error.message}`);
             logger.info(`Stack trace: ${error.stack}`);
             throw error;
@@ -2494,18 +2540,29 @@ async function handleToolStep(currentFlowFrame, engine) {
             const onFailStep = Array.isArray(effectiveOnFail) ? effectiveOnFail[0] : effectiveOnFail;
             const callType = onFailStep.callType || "replace"; // Default to current behavior
             if (callType === "reboot") {
-                // Clear all flows and start fresh with the onFail flow
-                logger.info(`Rebooting with flow: ${onFailStep.name || onFailStep.type}`);
-                // Clean up all existing flows
-                while (getCurrentStackLength(engine) > 0) {
-                    const flow = popFromCurrentStack(engine);
-                    flow.transaction.fail(`Rebooted due to critical failure in ${step.tool}`);
+                // Clear ALL flows across ALL stacks and start completely fresh with the onFail flow
+                logger.info(`Rebooted due to 'reboot' type of onFail step: ${onFailStep.name} in flow ${currentFlowFrame.flowName} for tool ${step.tool}`);
+                // Clean up ALL existing flows across ALL stacks (using proven user exit pattern)
+                const exitedFlows = [];
+                while (engine.flowStacks.length > 0) {
+                    const poppedStack = engine.flowStacks.pop();
+                    if (!poppedStack || poppedStack.length === 0) {
+                        continue;
+                    }
+                    // Process all flows in this stack
+                    for (const flow of poppedStack) {
+                        TransactionManager.fail(flow.transaction, `Rebooted due to 'reboot' type of onFail step: ${onFailStep.name} in flow ${flow?.flowName} for tool ${step.tool}`);
+                        exitedFlows.push(flow.flowName);
+                        auditLogger.logFlowExit(flow.flowName, currentFlowFrame.userId, flow.transaction.id, 'onFail_reboot');
+                    }
                 }
+                // Initialize completely fresh stack system (using proven pattern)
+                initializeFlowStacks(engine);
                 // Start the onFail flow as a new root flow
                 if (onFailStep.type === "FLOW") {
                     const rebootFlow = flowsMenu?.find(f => f.name === onFailStep.name);
                     if (rebootFlow) {
-                        const transaction = new FlowTransaction(rebootFlow.name, 'reboot-recovery', currentFlowFrame.userId);
+                        const transaction = TransactionManager.create(rebootFlow.name, 'reboot-recovery', currentFlowFrame.userId);
                         pushToCurrentStack(engine, {
                             flowName: rebootFlow.name,
                             flowId: rebootFlow.id,
@@ -2525,7 +2582,8 @@ async function handleToolStep(currentFlowFrame, engine) {
                     // Handle non-FLOW onFail steps in reboot mode
                     currentFlowFrame.flowStepsStack = [onFailStep];
                 }
-                return `System rebooted due to critical failure in ${step.tool}`;
+                logger.info(`System completely rebooted due to onFail step for tool ${step.tool}. Exited flows: ${exitedFlows.join(', ')}`);
+                return `System rebooted due to onFail step for tool ${step.tool}. Starting recovery flow ${onFailStep.name}`;
             }
             else if (callType === "replace") {
                 // Current behavior - replace remaining steps in current flow
@@ -2543,7 +2601,7 @@ async function handleToolStep(currentFlowFrame, engine) {
                     // Push onFail flow as sub-flow
                     const onFailFlow = flowsMenu?.find(f => f.name === onFailStep.name);
                     if (onFailFlow) {
-                        const transaction = new FlowTransaction(onFailFlow.name, 'onFail-recovery', currentFlowFrame.userId);
+                        const transaction = TransactionManager.create(onFailFlow.name, 'onFail-recovery', currentFlowFrame.userId);
                         pushToCurrentStack(engine, {
                             flowName: onFailFlow.name,
                             flowId: onFailFlow.id,
@@ -2785,12 +2843,12 @@ async function handleSwitchStep(currentFlowFrame, engine) {
     // Find the matching branch (exact value matching only)
     let selectedStep = null;
     let selectedBranch = null;
-    // SWITCH now only supports exact value matching for optimal performance
+    // SWITCH now supports exact value matching for strings, booleans, and numbers
     // For conditional logic, use the CASE step instead
-    if (switchValue !== undefined && typeof switchValue === 'string' && step.branches[switchValue]) {
-        selectedStep = step.branches[switchValue];
+    if (switchValue !== undefined && step.branches[String(switchValue)]) {
+        selectedStep = step.branches[String(switchValue)];
         selectedBranch = String(switchValue);
-        logger.info(`SWITCH: selected exact match branch '${switchValue}'`);
+        logger.info(`SWITCH: selected exact match branch '${switchValue}' (converted to string key '${String(switchValue)}')`);
     }
     // If no exact match found, use default
     if (!selectedStep && step.branches.default) {
@@ -2887,19 +2945,26 @@ async function handleSubFlowStep(currentFlowFrame, engine) {
         const callType = step.callType || "call"; // Default to normal sub-flow call
         logger.info(`Starting sub-flow ${subFlow.name} with callType: ${callType}, input: ${input}`);
         if (callType === "reboot") {
-            // Clear all flows and start fresh
-            logger.info(`Rebooting with flow: ${subFlow.name}`);
-            // Clean up all existing flows
-            while (getCurrentStackLength(engine) > 0) {
-                const flow = popFromCurrentStack(engine);
-                flow.transaction.fail(`Rebooted to flow ${subFlow.name}`);
-            }
-            // Reset to empty stacks
-            // flowStacks = [[]];
-            // We must keep same reference to allow proper stack switching
+            // Clear ALL flows across ALL stacks and start completely fresh
+            logger.info(`Rebooting system with flow: ${subFlow.name}`);
+            // Clean up ALL existing flows across ALL stacks (using proven user exit pattern)
+            const exitedFlows = [];
+            while (engine.flowStacks.length > 0) {
+                const poppedStack = engine.flowStacks.pop();
+                if (!poppedStack || poppedStack.length === 0) {
+                    continue;
+                }
+                // Process all flows in this stack
+                for (const flow of poppedStack) {
+                    TransactionManager.fail(flow.transaction, `System rebooted to flow ${subFlow.name}`);
+                    exitedFlows.push(flow.flowName);
+                    auditLogger.logFlowExit(flow.flowName, currentFlowFrame.userId, flow.transaction.id, 'system_reboot');
+                }
+            }
+            // Initialize completely fresh stack system (using proven pattern)
             initializeFlowStacks(engine);
-            // Start the sub-flow as a new root flow
-            const transaction = new FlowTransaction(subFlow.name, 'reboot', currentFlowFrame.userId);
+            // Start the reboot flow as the only flow in the system
+            const transaction = TransactionManager.create(subFlow.name, 'reboot', currentFlowFrame.userId);
             pushToCurrentStack(engine, {
                 flowName: subFlow.name,
                 flowId: subFlow.id,
@@ -2913,6 +2978,7 @@ async function handleSubFlowStep(currentFlowFrame, engine) {
                 startTime: Date.now()
             });
             auditLogger.logFlowStart(subFlow.name, input, currentFlowFrame.userId, transaction.id);
+            logger.info(`System completely rebooted to flow ${subFlow.name}. Exited flows: ${exitedFlows.join(', ')}`);
             return `System rebooted to flow ${subFlow.name}`;
         }
         else if (callType === "replace") {
@@ -2927,15 +2993,15 @@ async function handleSubFlowStep(currentFlowFrame, engine) {
             addToContextStack(currentFlowFrame.contextStack, 'user', input);
             currentFlowFrame.inputStack.push(input);
             // Update transaction
-            currentFlowFrame.transaction.fail(`Replaced by flow ${subFlow.name}`);
-            currentFlowFrame.transaction = new FlowTransaction(subFlow.name, 'replacement', currentFlowFrame.userId);
+            TransactionManager.fail(currentFlowFrame.transaction, `Replaced by flow ${subFlow.name}`);
+            currentFlowFrame.transaction = TransactionManager.create(subFlow.name, 'replacement', currentFlowFrame.userId);
             auditLogger.logFlowStart(subFlow.name, input, currentFlowFrame.userId, currentFlowFrame.transaction.id);
             logger.debug(`About to return from handleSubFlowStep replacement, flowStepsStack length: ${currentFlowFrame.flowStepsStack.length}`);
             return `Flow replaced with ${subFlow.name}`;
         }
         else { // callType === "call" (default)
             // Normal sub-flow call - create new transaction for sub-flow
-            const subTransaction = new FlowTransaction(subFlow.name, 'sub-flow', currentFlowFrame.userId);
+            const subTransaction = TransactionManager.create(subFlow.name, 'sub-flow', currentFlowFrame.userId);
             // Push sub-flow onto stack - INHERIT parent's variables for unified scope
             pushToCurrentStack(engine, {
                 flowName: subFlow.name,
@@ -2963,7 +3029,7 @@ async function handleSubFlowStep(currentFlowFrame, engine) {
     }
 }
 // === TOOL CALLING AND ARGUMENT GENERATION SYSTEM ===
-async function generateToolCallAndResponse(engine, toolName, input, contextStack = [], userId = 'anonymous', transactionId = null, flowFrame = null, explicitArgs) {
+async function generateToolCallAndResponse(engine, toolName, input, contextStack = [], userId = 'anonymous', transactionId = null, flowFrame, explicitArgs) {
     try {
         const toolsRegistry = engine.toolsRegistry;
         if (!toolsRegistry) {
@@ -2991,7 +3057,7 @@ async function generateToolCallAndResponse(engine, toolName, input, contextStack
                 const contextStack = flowFrame.contextStack || [];
                 logger.debug(`Interpolating args templates:`, rawArgs);
                 logger.debug(`Available variables:`, variables);
-                rawArgs = interpolateObject(rawArgs, variables, variables);
+                rawArgs = interpolateObject(rawArgs, variables, {}, engine);
                 logger.debug(`Interpolated args:`, rawArgs);
             }
             catch (error) {
@@ -3007,7 +3073,7 @@ async function generateToolCallAndResponse(engine, toolName, input, contextStack
         throw error;
     }
 }
-async function generateToolArgs(schema, input, contextStack = [], flowFrame = null, engine) {
+async function generateToolArgs(schema, input, contextStack = [], flowFrame, engine) {
     try {
         if (!schema || typeof schema !== 'object') {
             logger.warn(`Invalid schema provided for argument generation: ${schema}`);
@@ -3047,7 +3113,7 @@ async function generateToolArgs(schema, input, contextStack = [], flowFrame = nu
         throw new Error(`Failed to generate tool arguments: ${error.message}`);
     }
 }
-async function generateArgsWithAI(schema, input, contextStack, flowFrame = null, engine) {
+async function generateArgsWithAI(schema, input, contextStack, flowFrame, engine) {
     const properties = schema.properties || {};
     const required = schema.required || [];
     const schemaDescription = Object.entries(properties)
@@ -3134,7 +3200,7 @@ Context Extraction Examples:
     }
 }
 // Enhanced pattern-based fallback that uses variables and input parsing
-function generateEnhancedFallbackArgs(schema, input, flowFrame = null) {
+function generateEnhancedFallbackArgs(schema, input, flowFrame) {
     const properties = schema.properties || {};
     const required = schema.required || [];
     const args = {};
@@ -3255,12 +3321,96 @@ async function callTool(engine, tool, args, userId = 'anonymous', transactionId
             }
             // Apply timeout if configured
             const timeout = tool.implementation.timeout || 5000;
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Tool execution timeout after ${timeout}ms`)), timeout));
+            let timeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error(`Tool execution timeout after ${timeout}ms - ${tool.implementation.function}`)), timeout);
+            });
             try {
-                const result = await Promise.race([fn(args), timeoutPromise]);
+                // Determine how to call the function based on its signature and tool schema
+                let result;
+                // Check if the tool schema indicates individual parameters vs object parameter
+                const toolSchema = tool.schema || tool.parameters || tool;
+                // Handle different schema formats:
+                // Format 1: JSONSchema with type="object" -> single object parameter
+                // Format 2: Direct parameters object -> individual parameters
+                let schemaProperties = {};
+                let useObjectParameter = false;
+                if (tool.parameters?.type === "object" && tool.parameters?.properties) {
+                    // Format 1: JSONSchema format { type: "object", properties: {...} }
+                    // Function expects single object parameter
+                    schemaProperties = tool.parameters.properties;
+                    useObjectParameter = true;
+                    logger.debug(`Detected JSONSchema format (type: object) - will use object parameter`);
+                }
+                else if (tool.parameters && typeof tool.parameters === 'object' && !tool.parameters.type) {
+                    // Format 2: Direct parameters { param1: {...}, param2: {...} }
+                    // Function expects individual parameters
+                    schemaProperties = tool.parameters;
+                    useObjectParameter = false;
+                    logger.debug(`Detected direct parameters format - will use individual parameters`);
+                }
+                else if (toolSchema?.properties) {
+                    // Fallback: Standard JSONSchema format
+                    schemaProperties = toolSchema.properties;
+                    useObjectParameter = toolSchema.type === "object";
+                    logger.debug(`Detected schema.properties format - object parameter: ${useObjectParameter}`);
+                }
+                const propertyNames = Object.keys(schemaProperties);
+                // Get function parameter count
+                const fnParamCount = fn.length;
+                logger.debug(`Function ${tool.implementation.function} parameter count: ${fnParamCount}`);
+                logger.debug(`Schema properties count: ${propertyNames.length}`);
+                logger.debug(`Schema properties: ${propertyNames.join(', ')}`);
+                logger.debug(`Use object parameter: ${useObjectParameter}`);
+                // Strategy 1: If schema explicitly indicates object parameter OR function expects 1 param
+                if (useObjectParameter || fnParamCount === 1) {
+                    logger.debug(`Calling function with single object parameter`);
+                    result = await Promise.race([fn(args), timeoutPromise]);
+                }
+                // Strategy 2: If function expects multiple parameters and we have multiple schema properties
+                else if (fnParamCount > 1 && propertyNames.length > 1) {
+                    logger.debug(`Calling function with individual parameters (${fnParamCount} params expected)`);
+                    // For tools with 'parameters' property, use the required array or property order
+                    let orderedParamNames;
+                    if (tool.required && Array.isArray(tool.required)) {
+                        // Use required array order first, then add any optional parameters
+                        const optionalParams = propertyNames.filter(name => !tool.required.includes(name));
+                        orderedParamNames = [...tool.required, ...optionalParams];
+                    }
+                    else {
+                        // Fall back to property definition order (note: this may not be reliable in all JS engines)
+                        orderedParamNames = propertyNames;
+                    }
+                    logger.debug(`Parameter order: ${orderedParamNames.join(', ')}`);
+                    const orderedArgs = orderedParamNames.map(propName => {
+                        const value = args[propName];
+                        logger.debug(`Parameter ${propName}: ${JSON.stringify(value)}`);
+                        return value;
+                    });
+                    logger.debug(`Calling ${tool.implementation.function}(${orderedArgs.map(arg => typeof arg === 'object' ? '[object]' : arg).join(', ')})`);
+                    result = await Promise.race([fn(...orderedArgs), timeoutPromise]);
+                }
+                // Strategy 3: Function expects 0 parameters, call without arguments
+                else if (fnParamCount === 0) {
+                    logger.debug(`Calling function with no parameters`);
+                    result = await Promise.race([fn(), timeoutPromise]);
+                }
+                // Fallback: Use object approach
+                else {
+                    logger.debug(`Calling function with object parameter (fallback)`);
+                    result = await Promise.race([fn(args), timeoutPromise]);
+                }
+                // Clear the timeout since function completed successfully
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
                 return result;
             }
             catch (error) {
+                // Clear the timeout on error as well
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
                 // Unconditional Retry logic for local functions
                 const retries = tool.implementation.retries || 0;
                 if (retries > 0) {
@@ -3297,7 +3447,7 @@ async function callHttpTool(tool, args, userId = 'anonymous', transactionId = nu
             // Apply response mapping if configured
             if (implementation.responseMapping) {
                 try {
-                    const mappedResult = applyResponseMapping(mockData, implementation.responseMapping, args);
+                    const mappedResult = applyResponseMapping(mockData, implementation.responseMapping, args, engine);
                     logger.info(`[MOCK] Response mapping applied for ${tool.name}`);
                     return mappedResult;
                 }
@@ -3571,7 +3721,7 @@ async function callHttpTool(tool, args, userId = 'anonymous', transactionId = nu
                     // Apply declarative response mapping if configured (preferred)
                     if (implementation.responseMapping) {
                         try {
-                            return applyResponseMapping(data, implementation.responseMapping, mappingArgs);
+                            return applyResponseMapping(data, implementation.responseMapping, mappingArgs, engine);
                         }
                         catch (error) {
                             logger.error(`Response mapping failed:`, error.message);
@@ -3792,6 +3942,11 @@ function evaluateExpression(expression, variables = {}, contextStack = [], optio
             const result = evaluateSafeMathematicalExpression(processedExpression, variables, contextStack, engine);
             return convertReturnType(result, opts.returnType);
         }
+        // Handle typeof operator (e.g., "typeof variable", "typeof container")
+        if (processedExpression.trim().startsWith('typeof ')) {
+            const result = evaluateTypeofExpression(processedExpression, variables, contextStack, engine);
+            return convertReturnType(result, opts.returnType);
+        }
         // Handle simple variable paths (e.g., "user.name", "data.items.length")
         if (isSimpleVariablePath(processedExpression)) {
             const result = resolveSimpleVariable(processedExpression, variables, contextStack, engine);
@@ -4525,6 +4680,37 @@ function evaluateSafeMathematicalExpression(expression, variables, contextStack,
         return `[math-error: ${expression}]`;
     }
 }
+// Handle typeof operator expressions (e.g., "typeof variable", "typeof container.prop")
+function evaluateTypeofExpression(expression, variables, contextStack, engine) {
+    try {
+        // Extract the variable name after "typeof "
+        const typeofMatch = expression.trim().match(/^typeof\s+(.+)$/);
+        if (!typeofMatch) {
+            logger.warn(`Invalid typeof expression: ${expression}`);
+            return 'undefined';
+        }
+        const variablePath = typeofMatch[1].trim();
+        logger.debug(`Evaluating typeof for variable path: ${variablePath}`);
+        // Resolve the variable value
+        let value;
+        // Try to resolve from variables first
+        if (variables && Object.keys(variables).length > 0) {
+            value = variablePath.split('.').reduce((obj, part) => obj?.[part], variables);
+        }
+        // If not found in variables, check engine session variables
+        if (value === undefined && engine) {
+            value = resolveEngineSessionVariable(variablePath, engine);
+        }
+        // Return the JavaScript typeof result
+        const typeResult = typeof value;
+        logger.debug(`typeof ${variablePath} = ${typeResult} (value: ${JSON.stringify(value)})`);
+        return typeResult;
+    }
+    catch (error) {
+        logger.warn(`Typeof expression evaluation error: ${error.message}`);
+        return 'undefined';
+    }
+}
 // === ENHANCED FLOW CONTROL COMMANDS ===
 // Universal commands that work during any flow
 async function handleFlowControlCommands(input, engine, userId) {
@@ -4727,7 +4913,7 @@ async function handlePendingInterruptionSwitch(engine, userId) {
         return getSystemMessage(engine, 'flow_switch_error', { targetFlow: 'unknown' });
     }
     // Clean up current flow
-    currentFlowFrame.transaction.fail("User confirmed flow switch");
+    TransactionManager.fail(currentFlowFrame.transaction, "User confirmed flow switch");
     popFromCurrentStack(engine);
     logger.info(`🔄 User confirmed switch from "${currentFlowName}" to "${targetFlow}"`);
     // Find and activate the target flow
@@ -4735,7 +4921,7 @@ async function handlePendingInterruptionSwitch(engine, userId) {
     if (!targetFlowDefinition) {
         return getSystemMessage(engine, 'flow_switch_error', { targetFlow });
     }
-    const newTransaction = new FlowTransaction(targetFlow, 'confirmed-switch', userId);
+    const newTransaction = TransactionManager.create(targetFlow, 'confirmed-switch', userId);
     const newFlowFrame = {
         flowName: targetFlow,
         flowId: targetFlowDefinition.id,
@@ -4781,7 +4967,7 @@ async function handleRegularFlowInterruption(intentAnalysis, engine, userId) {
         const flowsMenu = engine.flowsMenu; // Access the global flows menu
         logger.info(`🔄 Processing flow interruption: "${userInput}" -> ${targetFlow}`);
         // For non-financial flows, allow graceful switching with option to resume
-        currentFlowFrame.transaction.complete();
+        TransactionManager.complete(currentFlowFrame.transaction);
         // IMPORTANT: Clear pendingVariable from interrupted flow to avoid stale state when resuming
         if (currentFlowFrame.pendingVariable) {
             logger.info(`🧹 Clearing stale pendingVariable '${currentFlowFrame.pendingVariable}' from interrupted flow`);
@@ -4800,7 +4986,7 @@ async function handleRegularFlowInterruption(intentAnalysis, engine, userId) {
         // Activate the new flow
         const targetFlowDefinition = flowsMenu?.find(f => f.name === targetFlow);
         if (targetFlowDefinition) {
-            const newTransaction = new FlowTransaction(targetFlow, 'intent-switch', userId);
+            const newTransaction = TransactionManager.create(targetFlow, 'intent-switch', userId);
             const newFlowFrame = {
                 flowName: targetFlow,
                 flowId: targetFlowDefinition.id,
@@ -4848,9 +5034,14 @@ async function handleFlowExit(engine, userId, input) {
     // Clean up all flows with proper transaction logging
     const exitedFlows = [];
     let flow;
-    while ((flow = engine.flowStacks?.pop()?.[0])) {
+    while (engine.flowStacks.length > 0) {
+        const poppedStack = engine.flowStacks.pop();
+        if (!poppedStack || poppedStack.length === 0) {
+            break;
+        }
+        flow = poppedStack[0];
         logger.info(`Exiting flow: ${flow.flowName} due to user request`);
-        flow.transaction.fail(`User requested exit: ${input}`);
+        TransactionManager.fail(flow.transaction, `User requested exit: ${input}`);
         exitedFlows.push(flow.flowName);
         auditLogger.logFlowExit(flow.flowName, userId, flow.transaction.id, 'user_requested');
     }
@@ -4905,7 +5096,7 @@ async function processActivity(input, userId, engine) {
                 // Clean up failed flow
                 if (getCurrentStackLength(engine) > 0) {
                     const failedFrame = popFromCurrentStack(engine);
-                    failedFrame.transaction.fail(error.message);
+                    TransactionManager.fail(failedFrame.transaction, error.message);
                 }
                 return `I encountered an error: ${error.message}. Please try again or contact support if the issue persists.`;
             }
@@ -4917,7 +5108,12 @@ async function processActivity(input, userId, engine) {
             if (activatedFlow) {
                 logger.info(`Flow activated: ${activatedFlow.name}`);
                 // Clear lastChatTurn since we now have flow context
-                engine.lastChatTurn = {};
+                const lastChatTurn = engine.lastChatTurn;
+                if (lastChatTurn) {
+                    // Clear the existing properties
+                    delete lastChatTurn.user;
+                    delete lastChatTurn.assistant;
+                }
                 logger.debug(`Cleared lastChatTurn - now using flow context for AI operations`);
                 const response = await playFlowFrame(engine);
                 logger.info(`Initial flow response: ${response}`);
@@ -4940,6 +5136,16 @@ async function processActivity(input, userId, engine) {
 }
 // === WORKFLOW ENGINE CLASS ===
 export class WorkflowEngine {
+    // Session-specific properties as getters - work directly with session data
+    get flowStacks() {
+        return this.sessionContext?.flowStacks || [[]];
+    }
+    get globalAccumulatedMessages() {
+        return this.sessionContext?.globalAccumulatedMessages || [];
+    }
+    get lastChatTurn() {
+        return this.sessionContext?.lastChatTurn || {};
+    }
     /**
      * Initialize a new EngineSessionContext for a user session.
      * If hostLogger is null, uses the global default logger.
@@ -4956,7 +5162,8 @@ export class WorkflowEngine {
     */
     constructor(hostLogger, aiCallback, flowsMenu, toolsRegistry, APPROVED_FUNCTIONS, globalVariables, // Optional global variables shared across all new flows
     validateOnInit, language, messageRegistry, guidanceConfig) {
-        this.lastChatTurn = {};
+        // Private session context - engine works directly with session data (no copying!)
+        this.sessionContext = null;
         hostLogger = hostLogger || logger; // Fallback to global fake logger if none provided
         logger = hostLogger; // Assign to global logger
         this.aiCallback = aiCallback;
@@ -4974,9 +5181,7 @@ export class WorkflowEngine {
             separator: '\n\n',
             contextSelector: 'auto'
         };
-        // Initialize flow stacks and global accumulated messages
-        this.flowStacks = [[]]; // Stack of flowFrames stacks for proper flow interruption/resumption
-        this.globalAccumulatedMessages = []; // Global SAY message accumulation across all stacks
+        // No longer initialize session-specific data in constructor - it's now in sessionContext
         this.sessionId = crypto.randomUUID();
         this.createdAt = new Date();
         this.lastActivity = new Date();
@@ -4999,117 +5204,190 @@ export class WorkflowEngine {
      *   const session = engine.initSession(yourLogger, 'user-123', 'session-456');
      */
     initSession(hostLogger, userId, sessionId) {
-        hostLogger = hostLogger || logger; // Fallback to global fake logger if none provided
         // Validate logger compatibility
-        const requiredMethods = ['info', 'warn', 'error', 'debug'];
-        for (const method of requiredMethods) {
-            if (typeof hostLogger[method] !== 'function') {
-                throw new Error(`Logger is missing required method: ${method}`);
+        if (hostLogger) {
+            const requiredMethods = ['info', 'warn', 'error', 'debug'];
+            for (const method of requiredMethods) {
+                if (typeof hostLogger[method] !== 'function') {
+                    throw new Error(`Logger is missing required method: ${method}`);
+                }
             }
         }
         // Assign the session logger to the global logger
         logger = hostLogger || logger;
         const engineSessionContext = {
-            hostLogger: hostLogger,
+            hostLogger: hostLogger || logger,
             sessionId: sessionId || crypto.randomUUID(),
             userId: userId,
             createdAt: new Date(),
             lastActivity: new Date(),
-            flowStacks: [[]],
+            flowStacks: [[]], // Initialize as array with one empty stack (pure data)
             globalAccumulatedMessages: [],
             lastChatTurn: {},
             globalVariables: this.globalVariables ? { ...this.globalVariables } : {},
-            cargo: {}
+            cargo: {},
+            response: null, // Initialize with no response
+            completedTransactions: [] // Initialize with no completed transactions
         };
         logger.info(`Engine session initialized: ${engineSessionContext.sessionId} for user: ${userId}`);
         return engineSessionContext;
     }
     async updateActivity(contextEntry, engineSessionContext) {
-        // Load session context if provided
-        if (engineSessionContext) {
-            logger = engineSessionContext.hostLogger;
+        try {
+            // Load session context if provided
+            let hostLogger = engineSessionContext.hostLogger || logger; // Fallback to global logger if not provided
+            if (engineSessionContext.hostLogger) {
+                const requiredMethods = ['info', 'warn', 'error', 'debug'];
+                for (const method of requiredMethods) {
+                    if (typeof engineSessionContext.hostLogger[method] !== 'function') {
+                        hostLogger = logger; // Fallback to global logger if hostLogger is missing methods
+                        break; // No need to throw error, just use global logger
+                        //throw new Error(`Logger is missing required method: ${method}`);
+                    }
+                }
+            }
+            logger = hostLogger; // Assign to global logger
             this.cargo = engineSessionContext.cargo;
+            logger.info(`Received Cargo: ${JSON.stringify(this.cargo)}`);
             this.sessionId = engineSessionContext.sessionId;
             this.createdAt = engineSessionContext.createdAt;
-            this.flowStacks = engineSessionContext.flowStacks;
-            this.globalAccumulatedMessages = engineSessionContext.globalAccumulatedMessages;
-            this.lastChatTurn = engineSessionContext.lastChatTurn;
-            this.globalVariables = engineSessionContext.globalVariables;
-        }
-        // Get userId from session context
-        const userId = engineSessionContext?.userId || 'anonymous';
-        this.lastActivity = new Date();
-        // Update session context with latest activity time
-        if (engineSessionContext) {
-            engineSessionContext.lastActivity = this.lastActivity;
-        }
-        // Role-based processing logic
-        if (contextEntry.role === 'user') {
-            // Detect intent to activate a flow or switch flows
-            const flowOrNull = await processActivity(String(contextEntry.content), userId, this);
-            // Store user turn in lastChatTurn if not in a flow
-            if (flowOrNull === null) {
-                this.lastChatTurn.user = contextEntry;
-            }
-            // Update session context with current state
+            // Store reference to session context - no copying needed! Engine works directly with session data
+            this.sessionContext = engineSessionContext;
+            // Ensure session context has proper initialization
+            if (!this.sessionContext.flowStacks || !Array.isArray(this.sessionContext.flowStacks)) {
+                this.sessionContext.flowStacks = [[]];
+                logger.warn('engineSessionContext.flowStacks was invalid, initialized fresh flowStacks');
+            }
+            if (!this.sessionContext.globalAccumulatedMessages) {
+                this.sessionContext.globalAccumulatedMessages = [];
+            }
+            if (!this.sessionContext.lastChatTurn) {
+                this.sessionContext.lastChatTurn = {};
+            }
+            if (!this.sessionContext.globalVariables) {
+                this.sessionContext.globalVariables = {};
+            }
+            // Safety check: ensure flowStacks is always properly initialized
+            if (this.sessionContext.flowStacks.length === 0) {
+                logger.warn('flowStacks was empty, adding initial stack...');
+                this.sessionContext.flowStacks.push([]); // Add empty stack
+            }
+            // Get userId from session context
+            const userId = engineSessionContext?.userId || 'anonymous';
+            this.lastActivity = new Date();
+            // Update session context with latest activity time
             if (engineSessionContext) {
-                engineSessionContext.flowStacks = this.flowStacks;
-                engineSessionContext.globalAccumulatedMessages = this.globalAccumulatedMessages;
-                engineSessionContext.lastChatTurn = this.lastChatTurn;
-                engineSessionContext.globalVariables = this.globalVariables || {};
+                engineSessionContext.lastActivity = this.lastActivity;
+            }
+            // Role-based processing logic
+            if (contextEntry.role === 'user') {
+                // Detect intent to activate a flow or switch flows
+                const responseOrNull = await processActivity(String(contextEntry.content), userId, this);
+                // Store user turn in lastChatTurn if not in a flow
+                if (responseOrNull === null) {
+                    this.sessionContext.lastChatTurn.user = contextEntry;
+                }
+                // No copying needed! Session context already contains the latest data
+                if (engineSessionContext) {
+                    engineSessionContext.response = responseOrNull; // Store the response from flow processing
+                    // Extract and store completed transactions for host access
+                    const newCompletedTransactions = [];
+                    for (const stack of this.flowStacks) {
+                        for (const frame of stack) {
+                            if (frame.transaction && (frame.transaction.state === 'completed' || frame.transaction.state === 'failed')) {
+                                newCompletedTransactions.push(frame.transaction);
+                            }
+                        }
+                    }
+                    if (!engineSessionContext.completedTransactions) {
+                        engineSessionContext.completedTransactions = [];
+                    }
+                    // Add any new completed transactions
+                    for (const transaction of newCompletedTransactions) {
+                        const existingTransaction = engineSessionContext.completedTransactions.find(t => t.id === transaction.id);
+                        if (!existingTransaction) {
+                            engineSessionContext.completedTransactions.push(transaction);
+                        }
+                    }
+                }
+                return engineSessionContext;
             }
-            return flowOrNull;
-        }
-        else if (contextEntry.role === 'assistant') {
-            // Check if we're in a flow or not
-            if (getCurrentStackLength(this) === 0) {
-                // Not in a flow - store in lastChatTurn for context
-                this.lastChatTurn.assistant = contextEntry;
+            else if (contextEntry.role === 'assistant') {
+                // Check if we're in a flow or not
+                if (getCurrentStackLength(this) === 0) {
+                    // Not in a flow - store in lastChatTurn for context
+                    this.sessionContext.lastChatTurn.assistant = contextEntry;
+                }
+                else {
+                    // In a flow - add to current flow's context stack
+                    const currentFlowFrame = getCurrentFlowFrame(this);
+                    addToContextStack(currentFlowFrame.contextStack, 'assistant', contextEntry.content, contextEntry.stepId, contextEntry.toolName, contextEntry.metadata);
+                }
+                // No copying needed! Session context already contains the latest data
+                if (engineSessionContext) {
+                    engineSessionContext.response = null; // No response for assistant turns
+                    // Extract and store completed transactions for host access
+                    const newCompletedTransactions = [];
+                    for (const stack of this.flowStacks) {
+                        for (const frame of stack) {
+                            if (frame.transaction && (frame.transaction.state === 'completed' || frame.transaction.state === 'failed')) {
+                                newCompletedTransactions.push(frame.transaction);
+                            }
+                        }
+                    }
+                    if (!engineSessionContext.completedTransactions) {
+                        engineSessionContext.completedTransactions = [];
+                    }
+                    // Add any new completed transactions
+                    for (const transaction of newCompletedTransactions) {
+                        const existingTransaction = engineSessionContext.completedTransactions.find(t => t.id === transaction.id);
+                        if (!existingTransaction) {
+                            engineSessionContext.completedTransactions.push(transaction);
+                        }
+                    }
+                }
+                return engineSessionContext;
             }
             else {
-                // In a flow - add to current flow's context stack
-                const currentFlowFrame = getCurrentFlowFrame(this);
-                addToContextStack(currentFlowFrame.contextStack, 'assistant', contextEntry.content, contextEntry.stepId, contextEntry.toolName, contextEntry.metadata);
+                // Throw error for unsupported roles
+                throw new Error(`Unsupported role '${contextEntry.role}' in updateActivity. Only 'user' and 'assistant' roles are supported.`);
+            }
+        }
+        catch (error) {
+            if (logger && logger.error) {
+                logger.error(`Error in updateActivity: ${error.message}`);
             }
-            // Update session context with current state
+            // Return session context with error information
             if (engineSessionContext) {
-                engineSessionContext.flowStacks = this.flowStacks;
-                engineSessionContext.globalAccumulatedMessages = this.globalAccumulatedMessages;
-                engineSessionContext.lastChatTurn = this.lastChatTurn;
-                engineSessionContext.globalVariables = this.globalVariables || {};
+                engineSessionContext.response = `Error: ${error.message}`;
+                return engineSessionContext;
             }
-            // Return null to indicate no flow processing needed
-            return null;
-        }
-        else {
-            // Throw error for unsupported roles
-            throw new Error(`Unsupported role '${contextEntry.role}' in updateActivity. Only 'user' and 'assistant' roles are supported.`);
+            // If no session context provided, we can't return it - this should not happen
+            throw error;
         }
     }
     // Add a SAY message to global accumulation
-    addAccumulatedMessage(message, engineSessionContext) {
-        // Load session context if provided
-        if (engineSessionContext) {
-            this.globalAccumulatedMessages = engineSessionContext.globalAccumulatedMessages;
+    addAccumulatedMessage(message) {
+        if (!this.sessionContext) {
+            logger.warn('No session context available for addAccumulatedMessage');
+            return;
         }
-        this.globalAccumulatedMessages.push(message);
-        // Update session context with new message
-        if (engineSessionContext) {
-            engineSessionContext.globalAccumulatedMessages = this.globalAccumulatedMessages;
+        if (!this.sessionContext.globalAccumulatedMessages) {
+            this.sessionContext.globalAccumulatedMessages = [];
         }
+        this.sessionContext.globalAccumulatedMessages.push(message);
     }
     // Get and clear all accumulated messages
-    getAndClearAccumulatedMessages(engineSessionContext) {
-        // Load session context if provided
-        if (engineSessionContext) {
-            this.globalAccumulatedMessages = engineSessionContext.globalAccumulatedMessages;
+    getAndClearAccumulatedMessages() {
+        if (!this.sessionContext) {
+            logger.warn('No session context available for getAndClearAccumulatedMessages');
+            return [];
         }
-        const messages = [...this.globalAccumulatedMessages];
-        this.globalAccumulatedMessages = [];
-        // Update session context with cleared messages
-        if (engineSessionContext) {
-            engineSessionContext.globalAccumulatedMessages = this.globalAccumulatedMessages;
+        if (!this.sessionContext.globalAccumulatedMessages) {
+            this.sessionContext.globalAccumulatedMessages = [];
         }
+        const messages = [...this.sessionContext.globalAccumulatedMessages];
+        this.sessionContext.globalAccumulatedMessages = [];
         return messages;
     }
     // Check if there are accumulated messages
@@ -5117,7 +5395,12 @@ export class WorkflowEngine {
         return this.globalAccumulatedMessages.length > 0;
     }
     initializeFlowStacks() {
-        initializeFlowStacks(this);
+        if (this.sessionContext) {
+            this.sessionContext.flowStacks = [[]];
+        }
+        else {
+            logger.warn('No session context available for initializeFlowStacks');
+        }
     }
     getCurrentStack() {
         return getCurrentStack(this);