Microsoft 365 Agents SDK for Python

The microsoft-agents-hosting-msteams package supports a wide range of Microsoft Teams interactions, including:

• Messaging Extensions: query, fetch action, submit action, link unfurling, anonymous link unfurling, settings URL, configure settings, card button clicked, and bot message preview.
• Task Modules: fetch and submit with optional verb matching.
• Lifecycle Events: Meeting lifecycle (start, end, participant join/leave), Channel management (created, deleted, renamed, shared, unshared, restored, members added/removed), and Team management (archived, unarchived, deleted, hard deleted, renamed, restored).
• Other Flows: File consent (accept/decline), Config invokes (config/fetch and config/submit), and Message updates (edit, delete, undelete, read receipts, actionable message execute).
• Routing: TeamsAgentExtension routing, which wraps any AgentApplication with zero configuration.

The contains factory and Contains class provide predicates that recursively walk through Pydantic models, dictionaries, and iterables to find matching values. This is useful for searching inside nested properties like attachments, channel_data, or card payloads without needing to know the exact path.

Matching Behavior

• Pydantic models: Visits field values.
• Dictionaries: Visits dictionary values.
• Iterables: Visits each item (except strings and bytes).
• Scalars: Stops traversal if the predicate does not match.
• Field Aliases: You can use Python field names (e.g., content_type) even if the serialized payload uses aliases (e.g., contentType).

Configuration and Constraints

• Depth Limits: Use .depth(n) to limit how deep the search goes. The root object is depth 0. .depth() returns a new instance and does not mutate the original.
• Invalid Inputs: contains() (empty), contains({}) (unfiltered), and contains(None) are invalid because they would match everything.

from microsoft_agents.hosting.testing.utils import contains
from microsoft_agents.hosting.testing.utils.contains import Contains

# Using the factory
client.expect().that_for_any(
    attachments=contains(content_type="application/vnd.microsoft.card.hero")
)

# Using the class for reuse
has_hero_card = Contains(content_type="application/vnd.microsoft.card.hero")
hero_replies = client.select().where(has_hero_card).get()

# Limiting depth
deep_search = contains(content_type="hero")
shallow_search = deep_search.depth(1)

The microsoft-agents-authentication-entra-auth-sidecar library integrates the Microsoft 365 Agents SDK with the Microsoft Entra ID Agent Container (the sidecar).

Instead of the agent process handling secrets, certificates, or keys directly via MSAL, the SDK delegates token acquisition to the sidecar's HTTP API. This provides:

• Credential-free agent code: All credential management (Managed Identity, Workload Identity, etc.) lives in the sidecar.
• Language-agnosticism: The sidecar provides a simple HTTP API used by all language SDKs.
• Consistent environments: The same container can run locally (Docker) and in production.

The sidecar handles the entire agentic identity chain (Blueprint → Instance → agentic User) internally and returns the final resource token in a single request.

from microsoft_agents.hosting.core import ConnectionManager
from microsoft_agents.authentication.entra_auth_sidecar import SidecarAuth

connection_manager = ConnectionManager(
    provider_factory=SidecarAuth,
    CONNECTIONS={
        "SERVICE_CONNECTION": {
            "SETTINGS": {
                "AUTHTYPE": "EntraAuthSideCar",
                "CLIENTID": "<blueprint-app-id>",
            }
        }
    },
    CONNECTIONSMAP=[{"SERVICEURL": "*", "CONNECTION": "SERVICE_CONNECTION"}],
)

The fluent assertion engine provides a way to assert over collections of dictionaries and Pydantic models. It is primarily used via Expect to validate items and Select to filter or manipulate collections before validation. Most tests should begin with either Expect(items) or Select(items).

Specialized typed wrappers are available for specific collection types:

• ActivityExpect / ActivitySelect: For activity collections.
• ExchangeExpect / ExchangeSelect: For exchange collections.

from microsoft_agents.hosting.testing import Expect, Select

items = [
    {"type": "message", "text": "welcome"},
    {"type": "typing"},
]

# Assert that at least one item is a message containing 'welcome'
Expect(items).that_for_any(type="message", text="~welcome")

# Filter for messages, then assert none of them contain 'error'
Select(items).where(type="message").expect().that_for_none(text="~error")