Proactive messaging from external trigger (Postman) using Python + M365 Agents Toolkit

[kameshm05]

I have built a Teams bot using the Microsoft 365 Agents Toolkit for Python (microsoft-teams-ai) and the bot works correctly for normal conversations.
Now I need to send a proactive message to a Teams user when an external trigger happens (example: Postman request, webhook, or Power Automate call).

My question:
Is it possible to send a proactive message using Python and the M365 Agents Toolkit, triggered externally?
If yes:
What is the correct approach for proactive messaging using the microsoft-teams-ai SDK only?

1. Do I need BotBuilder or should this work without BotBuilder?
2. Is there another recommended approach (Graph Notifications, something else)?
3. Is there an official sample using the Python M365 Agents Toolkit?

I’m specifically asking about proactive messages initiated outside the Teams conversation, coming from Postman/Power Automate, and delivered to the user in Teams.

Thanks!

[VikrantSingh01]

Yes, proactive messaging is possible — here is how

Proactive messaging (sending a message to a user without them messaging you first) is a well-supported pattern in the Bot Framework ecosystem and works with the Teams AI Library. Let me walk through each of your questions.

1. Is proactive messaging possible with Python + M365 Agents Toolkit?

Yes. There are two paths depending on which SDK layer you are using:

• If you are using the microsoft-teams-ai Python SDK (Teams AI Library): Use app.send(conversation_id, activity) directly.
• If you are using botbuilder-core (Bot Framework SDK): Use adapter.continue_conversation(conversation_reference, callback, app_id).

Both approaches let you send a message triggered by an external HTTP call (Postman, Power Automate, a webhook, etc.).

2. Do you need BotBuilder?

You already have it. The microsoft-teams-ai SDK is built on top of botbuilder-core. When you install it, Bot Framework is pulled in as a dependency. So you do not need to add a separate BotBuilder dependency — it is already there under the hood.

3. How it works: the standard approach

The pattern has two parts:

Part A — Capture the conversation reference when the user first interacts with your bot:

Every incoming activity contains the information your bot needs to reach back out to that user later. You store either a full ConversationReference (Bot Framework approach) or just the conversation_id (Teams AI Library approach).

Part B — Expose an HTTP endpoint that external tools can call to trigger the proactive message:

When Postman (or Power Automate, or any webhook) hits this endpoint, your code retrieves the stored reference and sends the message.

4. Code example using Bot Framework SDK (botbuilder-core)

This follows the pattern from the official BotBuilder-Samples 16.proactive-messages sample:

import uuid
from typing import Dict
from aiohttp import web
from aiohttp.web import Request, Response
from botbuilder.core import TurnContext
from botbuilder.core.integration import aiohttp_error_middleware
from botbuilder.integration.aiohttp import (
    CloudAdapter,
    ConfigurationBotFrameworkAuthentication,
)
from botbuilder.schema import Activity, ConversationReference

from config import DefaultConfig

CONFIG = DefaultConfig()
ADAPTER = CloudAdapter(ConfigurationBotFrameworkAuthentication(CONFIG))

# Shared store for conversation references (use a database in production)
CONVERSATION_REFERENCES: Dict[str, ConversationReference] = {}
APP_ID = CONFIG.APP_ID or str(uuid.uuid4())


class ProactiveBot:
    async def on_message_activity(self, turn_context: TurnContext):
        # Save the conversation reference for later
        ref = TurnContext.get_conversation_reference(turn_context.activity)
        CONVERSATION_REFERENCES[ref.user.id] = ref
        await turn_context.send_activity(f"You said: {turn_context.activity.text}")


# Notify endpoint that Postman / Power Automate can call
async def notify(req: Request) -> Response:
    for conversation_reference in CONVERSATION_REFERENCES.values():
        await ADAPTER.continue_conversation(
            conversation_reference,
            lambda turn_context: turn_context.send_activity("Proactive hello!"),
            APP_ID,
        )
    return Response(status=200, text="Proactive messages have been sent")


APP = web.Application(middlewares=[aiohttp_error_middleware])
APP.router.add_get("/api/notify", notify)

if __name__ == "__main__":
    web.run_app(APP, host="localhost", port=3978)

You can then trigger it from Postman with a simple GET http://localhost:3978/api/notify.

To target a specific user, modify the endpoint to accept a user ID parameter and look up only that user's ConversationReference instead of iterating over all of them.

5. Alternative approach: Microsoft Graph API

You can also send messages via the Microsoft Graph API without going through the Bot Framework adapter:

POST https://graph.microsoft.com/v1.0/chats/{chat-id}/messages
Content-Type: application/json

{
  "body": {
    "content": "Hello from an external trigger!"
  }
}

Key differences with the Graph approach:

• Requires delegated permissions (Chat.ReadWrite)
• The message appears as sent by the user whose token is used, not the bot
• Better suited for scenarios where you want to send messages as a user rather than as a bot

For most bot-initiated notification scenarios, the Bot Framework approach above is the recommended path.

6. Official samples and documentation

Resource	Link
Send proactive messages (Teams docs)	learn.microsoft.com
Bot Framework proactive message how-to	learn.microsoft.com
BotBuilder-Samples: 16.proactive-messages (Python)	GitHub
Bot conversation sample (Python)	GitHub
Graph API: Send message in a chat	learn.microsoft.com

Hope this helps — feel free to follow up if you run into issues with any of these approaches.