Agent posts multiple tweets instead of one when running actions like crypto search

[Alexisgarci]

Hi, how can I make the agent go through certain actions before replying to a tweet?
I created an action to fetch crypto prices and it works, but the issue is that the agent replies to the tweet first saying it’s retrieving the info, and then makes a second tweet with the actual data.

Is there a way to prevent this behavior? I plan to add more actions for markets, stocks, daily news, and so o, but I don’t want the agent to post 2 or 3 tweets just to provide a price or a news update. I’d like it to respond with a single tweet only.

Thanks!

[canokaue]

I believe you can (system) prompt engineer your way out of this one.

[AlexisGarciaOS]

How?

[ongrowthsedge]

Probably with some kind of system prompt in behaviour.

"Never tell us what you are about to do or inform us of your next action, simply reply with the data and research"

[1BDO]

The issue is that your action is likely calling the callback function multiple times - once to acknowledge the request and again to provide the actual data. To prevent multiple tweets, you need to:

1. Use a Single Callback

Instead of calling callback multiple times, gather all your data first, then make one callback:

const cryptoPriceAction: Action = {
  name: 'GET_CRYPTO_PRICE',
  description: 'Fetch crypto prices',
  
  handler: async (runtime, message, state, options, callback) => {
    try {
      // DON'T do this (causes multiple tweets):
      // await callback({ text: 'Retrieving crypto prices...' });
      
      // Fetch all data first
      const priceData = await fetchCryptoPrices();
      
      // Make ONE callback with complete response
      await callback({
        text: `Current crypto prices: ${priceData}`,
        actions: ['GET_CRYPTO_PRICE']
      });
      
      return true;
    } catch (error) {
      await callback({
        text: 'Sorry, I couldn\'t fetch the crypto prices right now.'
      });
      return false;
    }
  }
};

2. Avoid Streaming Responses

The documentation shows examples of streaming responses that make multiple callbacks. For Twitter, avoid this pattern:

// DON'T do this for Twitter:
await callback({ text: 'Let me check that for you...' });
const result = await fetchData();
await callback({ text: `Here's what I found: ${result}` });

3. Handle Loading States Internally

If you need to show progress, handle it internally without using callbacks:

const marketDataAction: Action = {
  name: 'GET_MARKET_DATA',
  
  handler: async (runtime, message, state, options, callback) => {
    // Show loading internally (no callback)
    console.log('Fetching market data...');
    
    // Gather all data
    const [stocks, crypto, news] = await Promise.all([
      fetchStockData(),
      fetchCryptoData(),
      fetchNewsData()
    ]);
    
    // Single comprehensive response
    const response = `📊 Market Update:
    
Stocks: ${stocks}
Crypto: ${crypto}
News: ${news}`;
    
    // ONE callback only
    await callback({ text: response });
    return true;
  }
};

4. Use the simple Response Pattern

From the documentation, you can use the simple response pattern to ensure only one tweet:

// In your action handler
await callback({
  text: 'Your complete response here',
  simple: true  // This ensures single response
});

5. Check Your Action Validation

Make sure your action's validate function doesn't interfere:

const cryptoAction: Action = {
  name: 'CRYPTO_PRICE',
  
  validate: async (runtime, message) => {
    // Simple validation - don't call callback here
    return message.content.text.toLowerCase().includes('price');
  },
  
  handler: async (runtime, message, state, options, callback) => {
    // Single response only
    const price = await getCryptoPrice();
    await callback({ text: `BTC: $${price}` });
    return true;
  }
};

The key is to avoid multiple callback() calls in your action handler. Gather all your data first, then make one comprehensive response. This will ensure your agent posts only a single tweet with all the information.