Access to chat history/storage

[eivanov-cart]

Hello everyone,

I'm new to the world of MS teams AI and I'm trying to build an AI chatbot (using the OpenAI API) for Teams in Node.js. I'm seeking examples, advice, and knowledge to help me in this challenge.
Initially, I've adopted an AI chatbot template from the Teams toolkit in JavaScript.

Could anyone please guide me on gaining control of the state or retrieving values from the chat history?
For instance, I want to capture the timestamp of the initial user's message and reset the entire conversation if it surpasses a certain period. I understand that I can reset the state using commands like /reset, however, this state is only accessed within the Application class, for example:

app.message("/reset", async (context, state) => {
  await context.sendActivity("Resetting conversation");
  await resetHistory(context, state);
});

async function resetHistory(context, state) {
  state.deleteConversationState();
  await conversationState.clear(context);
  await conversationState.saveChanges(context);
}

I want to be able to reset the state from other places in the chatbot app, such as in middleware.

And I can see chat logs/token numbers in terminal logs, but it's not clear to me how I can access the token numbers returned by the OpenAI API.

My app code is:

app.js:

const { MemoryStorage, ConversationState } = require("botbuilder");
const path = require("path");
const config = require("./config");

// See https://aka.ms/teams-ai-library to learn more about the Teams AI library.
const {
  Application,
  ActionPlanner,
  OpenAIModel,
  PromptManager,
} = require("@microsoft/teams-ai");

// Create AI components
const model = new OpenAIModel({
  // Use OpenAI
  apiKey: config.openAIKey,
  defaultModel: "gpt-3.5-turbo",

  // Uncomment the following lines to use Azure OpenAI
  // azureApiKey: config.azureOpenAIKey,
  // azureDefaultDeployment: "gpt-35-turbo",
  // azureEndpoint: config.azureOpenAIEndpoint,

  useSystemMessages: true,
  logRequests: true,
});

const prompts = new PromptManager({
  promptsFolder: path.join(__dirname, "../src/prompts"),
});
const planner = new ActionPlanner({
  model,
  prompts,
  defaultPrompt: "chat",
});

// Define storage and application
const storage = new MemoryStorage();
const conversationState = new ConversationState(storage);
const app = new Application({
  storage,
  ai: {
    planner,
  },
});


// Message handler for /help
app.message("/help", async (context, state) => {
  await context.sendActivity("I'm an OpenAI chat. How can I help you today?");
});

// Message handler for /reset
app.message("/reset", async (context, state) => {
  await context.sendActivity("Resetting conversation");
  await context.sendActivity("I'm an OpenAI chat. How can I help you today?");

  await resetHistory(context, state);
});

async function resetHistory(context, state) {
  state.deleteConversationState();
  await conversationState.clear(context);
  await conversationState.saveChanges(context);
}

async function handleFirstMessage(context, firstMessageProperty, conversationState) {
  if (context.activity.type === "message") {
    console.log(`Received message: ${context.activity.text}`);
    const firstMessage = await firstMessageProperty.get(context, null);
    
    if (!firstMessage) {
      const firstMessageData = {
        message: context.activity.text,
        timestamp: context.activity.timestamp,
      };
      
      await firstMessageProperty.set(context, firstMessageData);
      console.log("This is the first message from the user in this conversation.");
      console.log(`Message: ${firstMessageData.message}, Timestamp: ${firstMessageData.timestamp}`);
      
      await conversationState.saveChanges(context);
    }
  }
}

async function checkConversationHistory(context) {
  const firstMessage = await firstMessageProperty.get(
    context,
    "No first message recorded."
  );
  const timestampDate = new Date(firstMessage.timestamp);
  const currentDate = new Date();
  const differenceInMilliseconds = Math.abs(currentDate - timestampDate);
  const differenceInHours = differenceInMilliseconds / (1000 * 60 * 60);

  if (differenceInHours > 24) {
    resetHistory(context);
  }
}

module.exports = {
  app,
  conversationState,
  resetHistory,
  checkConversationHistory,
  handleFirstMessage
};

index.js

// Import required packages
const restify = require("restify");
const config = require("./config");
const { app, conversationState, handleFirstMessage } = require("./app");
// Import required bot services.
// See https://aka.ms/bot-services to learn more about the different parts of a bot.
const {
  CloudAdapter,
  ConfigurationServiceClientCredentialFactory,
  ConfigurationBotFrameworkAuthentication,
} = require("botbuilder");

const botFrameworkAuthentication = new ConfigurationBotFrameworkAuthentication(
  {},
  new ConfigurationServiceClientCredentialFactory({
    MicrosoftAppId: config.botId,
    MicrosoftAppPassword: process.env.BOT_PASSWORD,
    MicrosoftAppType: "MultiTenant",
  })
);

// Create adapter.
// See https://aka.ms/about-bot-adapter to learn more about how bots work.
const adapter = new CloudAdapter(botFrameworkAuthentication);
// Catch-all for errors.
const onTurnErrorHandler = async (context, error) => {
  // This check writes out errors to console log .vs. app insights.
  // NOTE: In production environment, you should consider logging this to Azure
  //       application insights.
  console.error(`\n [onTurnError] unhandled error: ${error}`);

  // Only send error message for user messages, not for other message types so the bot doesn't spam a channel or chat.
  if (context.activity.type === "message") {
    // Send a trace activity, which will be displayed in Bot Framework Emulator
    await context.sendTraceActivity(
      "OnTurnError Trace",
      `${error}`,
      "https://www.botframework.com/schemas/error",
      "TurnError"
    );

    // Send a message to the user
    await context.sendActivity("The bot encountered an error or bug.");
    await context.sendActivity(
      "To continue to run this bot, please fix the bot source code."
    );
  }
};

// Set the onTurnError for the singleton CloudAdapter.
adapter.onTurnError = onTurnErrorHandler;
const firstMessageProperty = conversationState.createProperty("firstMessage");


adapter.use(async (context, next) => {
  await handleFirstMessage(context, firstMessageProperty, conversationState);
  await next();
});


// Create HTTP server.
const server = restify.createServer();
server.use(restify.plugins.bodyParser());

server.listen(process.env.port || process.env.PORT || 3978, () => {
  console.log(`\nBot Started, ${server.name} listening to ${server.url}`);
});

// Listen for incoming server requests.
server.post("/api/messages", async (req, res) => {
  // Route received a request to adapter for processing
  await adapter.process(req, res, async (context) => {
    // Dispatch to application for routing
    await app.run(context);
  });
});

Thank you !

[corinagum]

And I can see chat logs/token numbers in terminal logs, but it's not clear to me how I can access the token numbers returned by the OpenAI API.

Currently we don't provide a way to access token numbers. This is a feature request that is in discussion for being added to our roadmap.

Please see our documentation on TurnState. Please see also previous discussion on history: #191 (comment)

If you want to store conversation history in a less temporary way, you would need to add the pertaining history to storage/database or your choosing. From there, you could add storage handlers that could erase history after a certain amount of time.