decisions cannot be changed during runtime (zalgo?)

[thfrei]

So I was wandering if this is like a typical synchronous, asynchronous issue.
In order to demonstrate, I modified an existing example.
What I want is, that uppon listening, I set some vaues, in this case a new name, and then send this back in my decision. However it does not work:

var babble = require('../index');

var emma = babble.babbler('emma');
var jack = babble.babbler('jack');

var newName = 'foo';

emma.listen('hi')
    .listen(function (message, context) {
      console.log(context.from + ': ' + message);
      newName = 'baaaaaaaar';
      return message;
    })
    .decide(function (message, context) {
      return (message.indexOf('age') != -1) ? 'age' : 'name';
    }, {
      'name': babble.tell('hi, my name is not emma but:'+newName),
      'age':  babble.tell('hi, my age is 27')
    });

jack.tell('emma', 'hi')
    .tell(function (message, context) {
      if (Math.random() > 0.5) {
        return 'my name is jack'
      } else {
        return 'my age is 25';
      }
    })
    .listen(function (message, context) {
      console.log(context.from + ': ' + message);
    });

Console Output:

jack: my name is jack
emma: hi, my name is not emma but:foo

Maybe it is not a big issue, but in my point of view the flow would seem more natural.

PS:
Another symptom is, if you put a function, it will immediatly be executed, regardless of whether this decision is taken or not:

function tellName() {
  console.log('foobar');
  return 'whatever';
}
....
      'name': babble.tell(tellName()),

[josdejong]

The string in the following line of your code:

     'name': babble.tell('hi, my name is not emma but:'+newName),

is built at the moment that you build the flow, before you change newName, it's equivalent to something like this:

var newName = 'foo';
var text = 'hi, my name is not emma but:'+newName;

setTimeout(function () {
  // changing newName now will not affect text...
  newName = 'bar'; 
  console.log(text);  // will output 'hi, my name is not emma but:foo';
}, 100)

If you want to built the string dynamically at the moment this "tell" is executed, you have to generate it in inside a callback function:

      'name': babble.tell(function () {
        return 'hi, my name is not emma but:' + newName;
      }),

Your second case 'name': babble.tell(tellName()), will execute simply because you invoke the function already, you do tellName(). I guess you mean the following instead:

'name': babble.tell(tellName),

[thfrei]

Thank you for your quick reply. It was good information.
I guess I was not seeing clearly the other day... ^^ It seems now for me that it was awfully complicated my code.

On another issue: You say, that you plan to integrate Error Handling.
I guess, partially it is possible to use a Promise with a catch to at least have some notification:
Are you using something similiar? Somehow I also find, that a try/catch block isnt working.

  Agent.listen('cfp-book-trading-accept')
    .listen(function (message, context) { // cfp (book-title)
      develop('in cfp-book-trading-accept:', message);
      return message;
    })
    .tell(function (message, context) {
      return new Promise( (resolve, reject) => {
        develop(message, context);
        let bookIndex = _.findIndex(Agent.books, {title: message.title});
        let book = _.pullAt(Agent.books, bookIndex); // remove the book from array
        book.agent = Agent.id;
        console.log('current stock', Agent.books);

        if(book) {
          develop('inform-result:', book);
          resolve({informResult: book}); // inform-result
        } else {
          develop('book could not be fetched in stock');
          resolve({failure: 'book could not be fetched in stock'}); // failure
        }
      }).catch(console.error);
    });

[josdejong]

You're welcome.

The Error handling bullet in the Roadmap is about when communicating to a remote or misconfigured agent. Network communication can fail. So if you .tell something, and the message could not be delivered, you should be able to handle this error. And when you're in a conversation and listening (.listen) and you don't hear back within say 60 seconds, you may want to stop the conversation or try again. It could look like:

Agent.tell(function (message, context) {
      // ..
    })
    .listen(function (message, context) {
      // ...
    }, {timeout: 60000})
    .catch(function (err) {
      // ...
    });

The .catch would indeed also catch errors occurring in callbacks of tell and listen. Until this .catch is available you indeed have to do error handling yourself in the callbacks. In your last code example you use a Promise but I don't see reason for it: I don't see any asynchronous code there. So try/catch should just work:

  Agent.listen('cfp-book-trading-accept')
    .listen(function (message, context) { // cfp (book-title)
      develop('in cfp-book-trading-accept:', message);
      return message;
    })
    .tell(function (message, context) {
      try {
        develop(message, context);
        let bookIndex = _.findIndex(Agent.books, {title: message.title});
        let book = _.pullAt(Agent.books, bookIndex); // remove the book from array
        book.agent = Agent.id;
        console.log('current stock', Agent.books);

        if(book) {
          develop('inform-result:', book);
          return {informResult: book}; // inform-result
        } else {
          develop('book could not be fetched in stock');
          return {failure: 'book could not be fetched in stock'}; // failure
        }
      }
      catch(err) {
        console.log(err;
      }
    });