teams_rb 2.0.1 → 2.0.3

data/docs/essentials/app-basics.md

@@ -10,12 +10,12 @@
 | `CLIENT_SECRET` | `client_secret:` | production | Client secret for the client-credentials flow |
 | `TENANT_ID` | `tenant_id:` | single-tenant | Entra tenant for bot tokens and tenant-issuer validation |
 | `SERVICE_URL` | `service_url:` | no | Default Bot Framework URL for proactive sends (inbound requests always use the activity's own service URL) |
-| — | `skip_auth:` | no | Disables inbound validation — local development only |
+| `DANGEROUSLY_ALLOW_UNAUTHENTICATED_REQUESTS` | `dangerously_allow_unauthenticated_requests:` | no | Disables inbound validation — local development only (`skip_auth:` is a deprecated alias) |
 | — | `messaging_endpoint:` | no | Inbound path, default `/api/messages` |
 | — | `default_connection_name:` | no | OAuth connection name for user sign-in, default `"graph"` |
 | — | `logger:`, `storage:`, `cloud:` | no | Logger (stdout default), state store (in-memory default), cloud environment for sovereign clouds |
 
-Without credentials the app logs a startup warning and rejects every inbound request unless `skip_auth: true` was set explicitly — the same behavior as the TypeScript, Python, and .NET SDKs.
+Without credentials the app logs a startup warning and rejects every inbound request unless `dangerously_allow_unauthenticated_requests: true` was set explicitly — the same behavior as the TypeScript, Python, and .NET SDKs.
 
 ## One app instance
 

data/docs/essentials/on-activity.md

@@ -32,6 +32,33 @@ Each invoke family has named routes — their handler return values become the i
 - Feedback: `on_message_submit_feedback` (thumbs up/down from `add_feedback` — [guide](../in-depth-guides/feedback.md)), `on_message_submit` for any `message/submitAction`
 - `on_suggested_action_submit` for suggested-action submissions
 
+## Conversation updates
+
+`on_conversation_update` matches any `conversationUpdate` activity (members added/removed, channel and team changes). The channel/team lifecycle sub-events also have named routes, matched on `channelData.eventType`:
+
+```ruby
+teams.on_conversation_update { |ctx| }     # any conversationUpdate activity
+teams.on_channel_created  { |ctx| ctx.post "Welcome to #{ctx.activity.channel_data.channel.name}!" }
+teams.on_channel_deleted  { |ctx| }        # also: on_channel_renamed, on_channel_restored
+teams.on_team_renamed     { |ctx| }        # also: on_team_archived, on_team_unarchived,
+                                           #   on_team_deleted, on_team_hard_deleted, on_team_restored
+```
+
+A generic `on_conversation_update` registered before a specific route sees the activity first; declare `|ctx, nxt|` and call `nxt.call` to continue to the specific route (see Middleware below).
+
+## Agent 365 lifecycle events
+
+`on_agent_lifecycle` matches any `agentLifecycle` event (sent when this app runs as an Agent 365 agentic user); the variants also have named routes, matched on the activity's `valueType`:
+
+```ruby
+teams.on_agent_lifecycle { |ctx| }                # any agentLifecycle event
+teams.on_agentic_user_identity_created { |ctx| }  # also: identity_updated, manager_updated,
+teams.on_agentic_user_enabled { |ctx| }           #   disabled, deleted, undeleted,
+                                                  #   workload_onboarding_updated
+```
+
+The event value exposes `tenant_id`, `agentic_user_id`, `agentic_app_instance_id`, `agent_identity_blueprint_id`, `version`, and per-variant fields (`manager`, `deletion_reason`, `workload_name`, …).
+
 ## Meeting events
 
 ```ruby

data/docs/essentials/sending-messages.md

@@ -32,6 +32,7 @@ ctx.update sent.id, "Done!"
 ```ruby
 ctx.post Teams::Api::MessageActivity.new("**markdown**", text_format: "markdown")
 # text_format: plain | markdown | xml | extendedmarkdown
+# ("extendedmarkdown" is in public preview and may be subject to change)
 
 ctx.post Teams::Api::MessageActivity.new("Quarterly numbers")
   .add_ai_generated                                          # "AI generated" badge

data/docs/getting-started/quickstart.md

@@ -5,16 +5,17 @@ Build and run your first Teams bot in Ruby.
 ## Prerequisites
 
 - Ruby 4.0+
-- A Microsoft 365 tenant where you can register a Teams app ([developer program](https://developer.microsoft.com/microsoft-365/dev-program) tenants work)
+- A Microsoft 365 tenant with custom app upload enabled ([developer program](https://developer.microsoft.com/microsoft-365/dev-program) tenants work)
 - A tunnel for local development ([Dev Tunnels](https://learn.microsoft.com/azure/developer/dev-tunnels/get-started), ngrok, or similar)
 
 ## Install
 
-Add the gem to your project:
+Add the SDK and a Rack server for this standalone example:
 
 ```ruby
 # Gemfile
 gem "teams_rb"
+gem "puma"
 ```
 
 ```sh
@@ -38,15 +39,15 @@ end
 run teams.to_rack
 ```
 
-And run it:
+This example uses Puma; `teams_rb` itself does not require a server gem. Run it with:
 
 ```sh
-CLIENT_ID=... CLIENT_SECRET=... TENANT_ID=... bundle exec rackup -p 3978 -o 0.0.0.0
+CLIENT_ID=... CLIENT_SECRET=... TENANT_ID=... bundle exec puma -p 3978
 ```
 
 The app listens for Teams activities on `POST /api/messages`, validates every inbound request against Microsoft's signing keys, and echoes any message back as a quoted reply.
 
-The three environment variables come from your bot registration — [Running in Teams](running-in-teams.md) walks through creating one and connecting Teams to your locally running bot. For local experiments without credentials, `Teams::App.new(skip_auth: true)` disables inbound validation (never use it beyond local testing; the app logs a loud warning when you do).
+The three environment variables come from your bot registration — [Running in Teams](running-in-teams.md) walks through creating one and connecting Teams to your locally running bot. For local experiments without credentials, `Teams::App.new(dangerously_allow_unauthenticated_requests: true)` disables inbound validation (never use it beyond local testing; the app logs a loud warning when you do). The `DANGEROUSLY_ALLOW_UNAUTHENTICATED_REQUESTS` environment variable sets the same option.
 
 ## Where to go next
 

data/docs/getting-started/running-in-teams.md

@@ -1,16 +1,18 @@
 # Running in Teams
 
-Connect your locally running bot to a real Teams client.
+Connect your locally running bot to a real Teams client with the [Teams CLI](https://www.npmjs.com/package/@microsoft/teams.cli).
 
-## 1. Register a bot
+## 1. Install and sign in
 
-Create a Teams app with a bot in the [Teams Developer Portal](https://dev.teams.microsoft.com) (or with Microsoft's Teams CLI). You need three values for the app's environment:
+The CLI requires Node.js 20 or newer:
 
-- `CLIENT_ID` — the bot's Microsoft App ID
-- `CLIENT_SECRET` — a client secret for that app registration
-- `TENANT_ID` — your Entra tenant ID (single-tenant bots)
+```sh
+npm install -g @microsoft/teams.cli
+teams login
+teams status
+```
 
-> If you plan to use [user authentication](../in-depth-guides/user-authentication.md), register the bot as an **Azure Bot resource** from the start (Azure portal → Create resource → Azure Bot → "Use existing app registration"). OAuth connection settings only exist there, and converting a Developer Portal registration later means deleting and recreating it.
+`teams status` should report that sideloading is enabled. If it is disabled, your tenant administrator must enable custom app upload before you can install the bot.
 
 ## 2. Start a tunnel
 
@@ -22,23 +24,44 @@ devtunnel port create teams-bot -p 3978
 devtunnel host teams-bot
 ```
 
-Note the tunnel URL, e.g. `https://abc123-3978.euw.devtunnels.ms`. Dev Tunnels URLs are stable across restarts, so this is one-time setup.
+Note the tunnel URL, such as `https://abc123-3978.euw.devtunnels.ms`. Dev Tunnels URLs are stable across restarts, so creation is a one-time step.
+
+## 3. Register the app and bot
 
-## 3. Point the bot at the tunnel
+From your project directory, pass the public endpoint to the CLI:
+
+```sh
+teams app create \
+  --name my-teams-ruby-bot \
+  --endpoint https://<your-tunnel>/api/messages
+```
 
-In the bot registration, set the **messaging endpoint** to `https://<your-tunnel>/api/messages`, and make sure the **Microsoft Teams channel** is enabled.
+The CLI creates the app registration, manifest, bot, and Teams app. It prints the Teams App ID, an **Install in Teams** link, and the three values your Ruby app needs:
+
+- `CLIENT_ID` — the bot's Microsoft App ID
+- `CLIENT_SECRET` — the bot's client secret
+- `TENANT_ID` — the Entra tenant ID
+
+> If you plan to use [user authentication](../in-depth-guides/user-authentication.md), create an Azure-hosted bot with the CLI's `--azure`, `--subscription`, and `--resource-group` options. OAuth connection settings are not available for Teams-managed bots.
+
+You can instead configure the same resources manually in the [Teams Developer Portal](https://dev.teams.microsoft.com/apps).
 
 ## 4. Run and install
 
+Start the bot with the credentials printed by the CLI:
+
 ```sh
-bundle exec rackup -p 3978 -o 0.0.0.0
+CLIENT_ID=... CLIENT_SECRET=... TENANT_ID=... bundle exec puma -p 3978
 ```
 
-Install the app in Teams (Developer Portal → Preview in Teams) and send it a message. Inbound requests are JWT-validated with your real credentials — no `skip_auth` needed behind a tunnel.
+Open the **Install in Teams** link and send the bot a message. If you need the link again, run `teams app get <teams-app-id> --install-link`.
+
+Inbound requests are JWT-validated with your real credentials; no `dangerously_allow_unauthenticated_requests` is needed behind the tunnel.
 
 ## Troubleshooting
 
-- **No response in Teams**: check the messaging endpoint URL, the Teams channel, and that the tunnel and server are both running. The app logs every inbound activity at debug level and every rejected request at warn level.
-- **401s in your logs**: the requests are reaching you but failing validation — usually a `CLIENT_ID`/`TENANT_ID` mismatch with the registration.
+- **No response in Teams**: run `teams app doctor <teams-app-id>`, then check that the tunnel and server are running.
+- **401s in your logs**: the requests are reaching you but failing validation, usually because the running app has credentials from a different registration.
+- **Sideloading disabled**: ask your tenant administrator to enable custom app upload.
 - **Teams caches aggressively**: after manifest changes, fully quit and reopen the Teams client.
 - **At-least-once delivery**: Bot Framework redelivers activities when your bot errors or responds slowly. If a handler's side effects must not repeat, deduplicate by `ctx.activity.id`.

data/docs/in-depth-guides/README.md

@@ -10,5 +10,6 @@ Feature guides for building richer Teams apps:
 - [Streaming](streaming.md) — chunked responses, informative updates, events, typed errors
 - [User authentication](user-authentication.md) — OAuth sign-in, token exchange, Azure setup
 - [Tabs and remote functions](tabs.md) — calling the bot backend from a tab with SSO
+- [Agent 365](agent-365.md) — running as an agentic user (experimental)
 - [Meeting events](meeting-events.md) — meeting start/end
 - [Observability](observability.md) — logging and middleware

data/docs/in-depth-guides/adaptive-cards.md

@@ -48,6 +48,23 @@ end
 
 For richer action flows — opening a modal form from a card button — see [Dialogs](dialogs.md).
 
+## Dynamic typeahead search
+
+An `Input.ChoiceSet` with `choices.data` (`Data.Query`) fetches its choices from your bot as the user types. Teams sends an `application/search` invoke; answer it with `on_card_search`:
+
+```ruby
+teams.on_card_search do |ctx|
+  query = ctx.activity.value.query_text
+  Teams::Api::SearchResponse.new(
+    CITIES.grep(/#{Regexp.escape(query)}/i).map do |city|
+      Teams::Api::SearchInvokeResult.new(title: city, value: city)
+    end
+  )
+end
+```
+
+`ctx.activity.value` also carries `dataset` (the `Data.Query` dataset id, for cards with several dynamic inputs) and `query_options` with `skip`/`top` for paging large result sets.
+
 ## Regenerating
 
 The card classes are generated; don't hand-edit `lib/teams/cards/generated.rb`. To regenerate after an upstream card-model change:

data/docs/in-depth-guides/agent-365.md

@@ -0,0 +1,46 @@
+# Agent 365 (experimental)
+
+> Agent 365 support is experimental across the whole Teams SDK family. Expect
+> changes.
+
+Agent 365 gives an app a *stacked identity*: the app registration acts as an
+**agentic app blueprint** (its client id *is* the blueprint id), a tenant can
+instantiate **agentic apps** from it, and each app can carry **agentic users**
+— user-shaped Entra identities that appear in Teams like people.
+
+## Inbound
+
+Nothing to configure. When Teams delivers an activity to an agentic user, the
+identity arrives on the activity's `recipient` account and the request carries
+an Entra-issued token (accepted automatically alongside classic Bot Framework
+tokens). The SDK scopes the whole turn to that identity — `ctx.post`, replies,
+and streaming authenticate as the agent, not the app:
+
+```ruby
+teams.on_message do |ctx|
+  identity = ctx.activity.recipient.agentic_identity
+  ctx.log.info "acting as agentic user #{identity.agentic_user_id}" if identity
+  ctx.reply "Hello from your agent"
+end
+```
+
+## Lifecycle events
+
+Teams reports agentic-user lifecycle changes as `agentLifecycle` events — see
+[activity routing](../essentials/on-activity.md) for `on_agent_lifecycle` and
+the per-variant routes.
+
+## Proactive
+
+Build the identity explicitly (the blueprint defaults to the app's client id,
+the tenant to the configured credentials tenant) and pass it to the proactive
+senders:
+
+```ruby
+identity = teams.agentic_identity(agentic_app_id: "...", agentic_user_id: "...")
+teams.post(conversation_id, "Proactive hello from the agent", agentic_identity: identity)
+```
+
+Omitting `agentic_user_id` acts as the agentic app itself. There is no
+fallback between identity kinds: if an agentic token cannot be acquired the
+call fails rather than silently sending as the wrong identity.

data/docs/in-depth-guides/user-authentication.md

@@ -31,7 +31,7 @@ teams.on_sign_in do |ctx, token_response|
 end
 ```
 
-`ctx.sign_in` returns the token when the user is already signed in; otherwise it sends an OAuth card (to a 1:1 conversation when invoked from a group chat) and returns `nil`. The SDK's **default handlers** then complete the sign-in invokes automatically — both the interactive card path (`signin/verifyState`) and silent SSO (`signin/tokenExchange`) — and fire `on_sign_in`. You don't handle the invokes yourself.
+`ctx.sign_in` returns the token when the user is already signed in; otherwise it sends an OAuth card and returns `nil`. In group chats and channels the card is delivered in the conversation as a targeted message only the requesting user sees; in channels the card always uses the sign-in button (silent SSO is not supported in channel scope). The SDK's **default handlers** then complete the sign-in invokes automatically — both the interactive card path (`signin/verifyState`) and silent SSO (`signin/tokenExchange`) — and fire `on_sign_in`. You don't handle the invokes yourself.
 
 `ctx.sign_out` clears the stored token.
 

data/lib/teams/activity.rb

@@ -16,6 +16,11 @@ module Teams
       raw["name"]
     end
 
+    # Discriminates agentLifecycle event variants (PascalCase wire values).
+    def value_type
+      raw["valueType"] || raw["value_type"]
+    end
+
     def text
       raw["text"]
     end

data/lib/teams/activity_context.rb

@@ -7,12 +7,13 @@ module Teams
   class ActivityContext
     attr_reader :app, :activity, :conversation_reference, :extra, :stream
 
-    def initialize(app:, activity:, conversation_reference:, extra: {}, stream: nil)
+    def initialize(app:, activity:, conversation_reference:, extra: {}, stream: nil, api: nil)
       @app = app
       @activity = activity
       @conversation_reference = conversation_reference
       @extra = extra
       @stream = stream
+      @api = api
     end
 
     def ref
@@ -31,15 +32,17 @@ module Teams
       app.storage
     end
 
+    # The turn's API client; scoped to the activity's agentic identity when
+    # the app runs as an Agent 365 agent.
     def api
-      app.api
+      @api || app.api
     end
 
     # The TypeScript, Python, and .NET SDKs call this operation `send`.
     # Ruby already defines Object#send for dynamic dispatch, so the public
     # Ruby API uses `post` to avoid shadowing a core language method.
     def post(activity_or_text)
-      app.send_activity(conversation_reference, apply_targeted_defaults(activity_or_text))
+      app.send_activity(conversation_reference, apply_targeted_defaults(activity_or_text), api:)
     end
 
     def reply(activity_or_text)
@@ -93,8 +96,10 @@ module Teams
 
     # Starts the user sign-in flow: returns the token if the user is already
     # signed in, otherwise sends an OAuth card and returns nil. In group
-    # conversations the card goes to a 1:1 conversation with the user (group
-    # OAuth is not supported by Teams), like the TypeScript/Python SDKs.
+    # chats and channels the card is a targeted message visible only to the
+    # requesting user; channels omit the token exchange resource because
+    # channel scope cannot do the silent SSO exchange, so the card renders
+    # the sign-in button instead.
     def sign_in(connection_name: nil, oauth_card_text: "Please Sign In...", sign_in_button_text: "Sign In")
       connection_name ||= app.default_connection_name
 
@@ -109,19 +114,6 @@ module Teams
         # No token yet; continue with the OAuth card flow.
       end
 
-      conversation_id = conversation_reference.conversation_id
-      if activity.conversation.is_group
-        one_on_one = api.conversations.create(
-          members: [activity.from.to_h],
-          tenant_id: activity.conversation.tenant_id
-        )
-        conversation_id = one_on_one.id
-        # Deliberately posts the plain text notice into the group (matching
-        # TypeScript and Python): group chats don't support SSO, so the card
-        # itself goes to the 1:1 below while the group sees only the notice.
-        post(oauth_card_text)
-      end
-
       state = Base64.strict_encode64(JSON.generate(
         "connectionName" => connection_name,
         "conversation" => conversation_reference.to_h,
@@ -129,10 +121,14 @@ module Teams
       ))
       resource = api.bots.sign_in.get_resource(state:)
 
+      is_channel = activity.conversation.conversation_type == "channel"
+      recipient = activity.from.to_h
+      recipient = recipient.merge("isTargeted" => true) if activity.conversation.is_group
+
       card = {
         "text" => oauth_card_text,
         "connectionName" => connection_name,
-        "tokenExchangeResource" => resource.token_exchange_resource&.to_h,
+        "tokenExchangeResource" => (resource.token_exchange_resource&.to_h unless is_channel),
         "tokenPostResource" => resource.token_post_resource&.to_h,
         "buttons" => [
           { "type" => "signin", "title" => sign_in_button_text, "value" => resource.sign_in_link }
@@ -141,13 +137,13 @@ module Teams
 
       payload = {
         "type" => "message",
-        "recipient" => activity.from.to_h,
+        "recipient" => recipient,
         "attachments" => [
           { "contentType" => "application/vnd.microsoft.card.oauth", "content" => card }
         ]
       }
 
-      app.send_activity(sign_in_reference(conversation_id), payload)
+      app.send_activity(conversation_reference, payload, api:)
       nil
     end
 
@@ -167,16 +163,6 @@ module Teams
 
     private
 
-    def sign_in_reference(conversation_id)
-      return conversation_reference if conversation_id == conversation_reference.conversation_id
-
-      Api::ConversationReference.from_h(
-        conversation_reference.to_h.merge(
-          "conversation" => conversation_reference.conversation.to_h.merge("id" => conversation_id)
-        )
-      )
-    end
-
     def incoming_targeted_sender
       return nil unless activity.message?
       return nil unless activity.recipient.is_targeted == true

data/lib/teams/api/account.rb

@@ -55,6 +55,36 @@ module Teams
         read("tenantId", "tenant_id")
       end
 
+      def agentic_user_id
+        read("agenticUserId", "agentic_user_id")
+      end
+
+      def agentic_app_id
+        read("agenticAppId", "agentic_app_id")
+      end
+
+      def agentic_app_blueprint_id
+        read("agenticAppBlueprintId", "agentic_app_blueprint_id")
+      end
+
+      def callback_uri
+        read("callbackUri", "callback_uri")
+      end
+
+      # The Agent 365 identity scope this account carries (agentic accounts
+      # arrive with role "agenticUser" on the activity's recipient); nil
+      # unless the account belongs to an agentic app blueprint.
+      def agentic_identity
+        return nil unless agentic_app_blueprint_id
+
+        AgenticIdentity.new(
+          agentic_app_blueprint_id:,
+          agentic_app_id:,
+          agentic_user_id:,
+          tenant_id:
+        )
+      end
+
       def to_h
         body = raw.dup
         body["id"] = id if id
@@ -70,6 +100,10 @@ module Teams
         body["email"] = email if email
         body["userPrincipalName"] = user_principal_name if user_principal_name
         body["tenantId"] = tenant_id if tenant_id
+        body["agenticUserId"] = agentic_user_id if agentic_user_id
+        body["agenticAppId"] = agentic_app_id if agentic_app_id
+        body["agenticAppBlueprintId"] = agentic_app_blueprint_id if agentic_app_blueprint_id
+        body["callbackUri"] = callback_uri if callback_uri
         remove_aliases(body)
       end
 
@@ -83,6 +117,10 @@ module Teams
         body.delete("given_name")
         body.delete("user_principal_name")
         body.delete("tenant_id")
+        body.delete("agentic_user_id")
+        body.delete("agentic_app_id")
+        body.delete("agentic_app_blueprint_id")
+        body.delete("callback_uri")
         body
       end
     end

data/lib/teams/api/activity_value.rb

@@ -44,6 +44,98 @@ module Teams
       def end_time
         read("EndTime", "endTime", "end_time")
       end
+
+      # application/search invoke fields (Adaptive Card dynamic typeahead
+      # Input.ChoiceSet queries via choices.data / Data.Query).
+      def query_text
+        read("queryText", "query_text")
+      end
+
+      # Pagination options; skip and top read from the nested wrapper.
+      def query_options
+        value = read("queryOptions", "query_options")
+        value.is_a?(Hash) ? ActivityValue.new(value) : value
+      end
+
+      def kind
+        read("kind")
+      end
+
+      # The Data.Query dataset id authored on the Adaptive Card.
+      def dataset
+        read("dataset")
+      end
+
+      def skip
+        read("skip")
+      end
+
+      def top
+        read("top")
+      end
+
+      # Agent 365 agentLifecycle event value fields. The service sends the
+      # agenticAppInstanceId / agentIdentityBlueprintId wire keys (not the
+      # account-style names); all SDKs preserve them.
+      def tenant_id
+        read("tenantId", "tenant_id")
+      end
+
+      def agentic_user_id
+        read("agenticUserId", "agentic_user_id")
+      end
+
+      def agentic_app_instance_id
+        read("agenticAppInstanceId", "agentic_app_instance_id")
+      end
+
+      def agent_identity_blueprint_id
+        read("agentIdentityBlueprintId", "agent_identity_blueprint_id")
+      end
+
+      def version
+        read("version")
+      end
+
+      # Variant extras: manager (identity-created carries userId/email/
+      # displayName; manager-updated carries managerId), deletion reason,
+      # workload onboarding fields, and the created identity's expiry.
+      def manager
+        value = read("manager")
+        value.is_a?(Hash) ? ActivityValue.new(value) : value
+      end
+
+      def user_id
+        read("userId", "user_id")
+      end
+
+      def email
+        read("email")
+      end
+
+      def display_name
+        read("displayName", "display_name")
+      end
+
+      def manager_id
+        read("managerId", "manager_id")
+      end
+
+      def deletion_reason
+        read("deletionReason", "deletion_reason")
+      end
+
+      def workload_name
+        read("workloadName", "workload_name")
+      end
+
+      def workload_onboarding_state
+        read("workloadOnboardingState", "workload_onboarding_state")
+      end
+
+      def expiration_date_time
+        read("expirationDateTime", "expiration_date_time")
+      end
     end
   end
 end

data/lib/teams/api/agentic_identity.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Teams
+  module Api
+    # The Agent 365 identity scope for SDK operations: an agentic app
+    # blueprint (the app registration itself), optionally narrowed to an
+    # agentic app instance and an agentic user attached to that instance.
+    class AgenticIdentity
+      attr_reader :agentic_app_blueprint_id, :agentic_app_id, :agentic_user_id, :tenant_id
+
+      def initialize(agentic_app_blueprint_id:, agentic_app_id: nil, agentic_user_id: nil, tenant_id: nil)
+        @agentic_app_blueprint_id = agentic_app_blueprint_id
+        @agentic_app_id = agentic_app_id
+        @agentic_user_id = agentic_user_id
+        @tenant_id = tenant_id
+      end
+
+      def to_h
+        body = { "agenticAppBlueprintId" => agentic_app_blueprint_id }
+        body["agenticAppId"] = agentic_app_id if agentic_app_id
+        body["agenticUserId"] = agentic_user_id if agentic_user_id
+        body["tenantId"] = tenant_id if tenant_id
+        body
+      end
+    end
+  end
+end

data/lib/teams/api/app_info.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Teams
+  module Api
+    class AppInfo < Model
+      def id
+        read("id")
+      end
+
+      def version
+        read("version")
+      end
+    end
+  end
+end

data/lib/teams/api/channel_data.rb

@@ -3,6 +3,10 @@
 module Teams
   module Api
     class ChannelData < Model
+      def app
+        wrap(read("app"), AppInfo)
+      end
+
       def tenant
         wrap(read("tenant"), TenantInfo)
       end
@@ -55,6 +59,7 @@ module Teams
 
       def to_h
         body = raw.dup
+        body["app"] = app.to_h if app
         body["tenant"] = tenant.to_h if tenant
         body["team"] = team.to_h if team
         body["channel"] = channel.to_h if channel