lex-microsoft_teams 0.6.45 → 0.6.47

data/lib/legion/extensions/microsoft_teams/runners/ai_insights.rb

@@ -7,33 +7,95 @@ module Legion
     module MicrosoftTeams
       module Runners
         module AiInsights
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[insight insights summary callrecord recorded]
+          end
+
+          definition :list_meeting_ai_insights,
+                     desc:          'List AI-generated insights for an online meeting',
+                     mcp_prefix:    'teams.list_meeting_ai_insights',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[insights summary ai]
+
           def list_meeting_ai_insights(meeting_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/aiInsights")
             { result: response.body }
           end
 
+          definition :get_meeting_ai_insight,
+                     desc:          'Get a specific AI insight for an online meeting',
+                     mcp_prefix:    'teams.get_meeting_ai_insight',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' },
+                                                    insight_id: { type: 'string' } },
+                                      required:   %w[meeting_id insight_id] },
+                     trigger_words: %w[insight details]
+
           def get_meeting_ai_insight(meeting_id:, insight_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/aiInsights/#{insight_id}")
             { result: response.body }
           end
 
+          definition :list_meeting_recordings,
+                     desc:          'List recordings for an online meeting',
+                     mcp_prefix:    'teams.list_meeting_recordings',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[recordings recorded]
+
           def list_meeting_recordings(meeting_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/recordings")
             { result: response.body }
           end
 
+          definition :get_meeting_recording,
+                     desc:          'Get a specific recording for an online meeting',
+                     mcp_prefix:    'teams.get_meeting_recording',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id:   { type: 'string' },
+                                                    recording_id: { type: 'string' } },
+                                      required:   %w[meeting_id recording_id] },
+                     trigger_words: %w[recording download]
+
           def get_meeting_recording(meeting_id:, recording_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/recordings/#{recording_id}")
             { result: response.body }
           end
 
+          definition :list_call_records,
+                     desc:          'List Teams call records from communications API',
+                     mcp_prefix:    'teams.list_call_records',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     trigger_words: %w[records calls history]
+
           def list_call_records(**)
             response = graph_connection(**).get('communications/callRecords')
             { result: response.body }
           end
 
+          definition :get_call_record,
+                     desc:          'Get a specific Teams call record',
+                     mcp_prefix:    'teams.get_call_record',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { call_id: { type: 'string' } }, required: ['call_id'] },
+                     trigger_words: %w[callrecord record]
+
           def get_call_record(call_id:, **)
             response = graph_connection(**).get("communications/callRecords/#{call_id}")
             { result: response.body }

data/lib/legion/extensions/microsoft_teams/runners/api_ingest.rb

@@ -11,17 +11,21 @@ module Legion
     module MicrosoftTeams
       module Runners
         module ApiIngest
+          extend Legion::Extensions::Definitions
           include Helpers::Client
           include Helpers::PermissionGuard
           include Helpers::HighWaterMark
           extend self
 
+          definition :ingest_api, mcp_exposed: false
+
           # Fetch top contacts via /me/people, then pull recent messages from
           # their 1:1 chats. Stores each message as an individual memory trace
           # (same format as CacheIngest) with dedup by content hash.
           #
           # Requires a delegated token with Chat.Read and People.Read scopes.
           def ingest_api(token:, top_people: 15, message_depth: 50, skip_bots: true, imprint_active: false, **) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+            log.debug("ApiIngest#ingest_api top_people=#{top_people} message_depth=#{message_depth}")
             return error_result('lex-memory not loaded') unless memory_available?
             return error_result('no token provided') unless token && !token.empty?
 
@@ -98,8 +102,7 @@ module Legion
                         people_found: people.length, chats_found: chats.length,
                         apollo: apollo_results } }
           rescue StandardError => e
-            log_msg = "ApiIngest failed: #{e.class} — #{e.message}"
-            log.error(log_msg)
+            handle_exception(e, level: :error, operation: 'ApiIngest#ingest_api')
             { result: { stored: stored || 0, skipped: skipped || 0, error: e.message } }
           end
 
@@ -111,6 +114,7 @@ module Legion
           private
 
           def fetch_top_people(token:, top:)
+            log.debug("ApiIngest#fetch_top_people top=#{top}")
             return [] if permission_denied?('/me/people')
 
             conn = graph_connection(token: token)
@@ -125,7 +129,7 @@ module Legion
             people = (resp.body || {}).fetch('value', [])
             people.sort_by { |p| -(p.dig('scoredEmailAddresses', 0, 'relevanceScore') || 0) }
           rescue StandardError => e
-            log.warn("ApiIngest: fetch_top_people failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#fetch_top_people')
             []
           end
 
@@ -156,7 +160,7 @@ module Legion
             log.info("ApiIngest: fetched #{all_chats.size} chats (#{pages} pages), #{filtered.size} eligible (1:1/group/meeting)")
             filtered
           rescue StandardError => e
-            log.warn("ApiIngest: fetch_chats failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#fetch_one_on_one_chats')
             []
           end
 
@@ -174,7 +178,7 @@ module Legion
               end
             end
           rescue StandardError => e
-            log.debug("ApiIngest: match_chat_to_person failed: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ApiIngest#match_chat_to_person')
             nil
           end
 
@@ -198,7 +202,8 @@ module Legion
             log.debug("ApiIngest: fetch_messages chat=#{chat_id} count=#{(resp.body || {}).fetch('value', []).size}")
             (resp.body || {}).fetch('value', [])
           rescue StandardError => e
-            log.warn("ApiIngest: fetch_messages failed for #{chat_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#fetch_chat_messages',
+                             chat_id: chat_id)
             []
           end
 
@@ -242,7 +247,7 @@ module Legion
               imprint_active:      imprint_active
             )
           rescue StandardError => e
-            log.warn("ApiIngest: store trace failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#store_graph_message')
             nil
           end
 
@@ -267,7 +272,7 @@ module Legion
             end
             hashes
           rescue StandardError => e
-            log.debug("ApiIngest: load_existing_hashes failed: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ApiIngest#load_existing_hashes')
             Set.new
           end
 
@@ -283,7 +288,7 @@ module Legion
             store = Legion::Extensions::Agentic::Memory::Trace.shared_store
             store.flush if store.respond_to?(:flush)
           rescue StandardError => e
-            log.warn("ApiIngest: flush failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#flush_trace_store')
           end
 
           def coactivate_thread_traces(thread_groups)
@@ -296,12 +301,12 @@ module Legion
               trace_ids.each_cons(2) do |id_a, id_b|
                 store.record_coactivation(id_a, id_b)
               rescue StandardError => e
-                log.debug("ApiIngest: coactivation link failed for #{id_a}/#{id_b}: #{e.message}")
-                nil
+                handle_exception(e, level: :debug, operation: 'ApiIngest#coactivate_thread_traces',
+                                 id_a: id_a, id_b: id_b)
               end
             end
           rescue StandardError => e
-            log.debug("ApiIngest: coactivation skipped: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ApiIngest#coactivate_thread_traces')
           end
 
           def publish_to_apollo(person_texts)
@@ -332,7 +337,7 @@ module Legion
 
             { ingested: ingested, entities_found: entities_found }
           rescue StandardError => e
-            log.warn("ApiIngest: publish_to_apollo failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#publish_to_apollo')
             { skipped: true, reason: :error, error: e.message }
           end
 
@@ -358,7 +363,8 @@ module Legion
 
             { success: true, count: result[:entities].length }
           rescue StandardError => e
-            log.debug("ApiIngest: entity extraction failed for #{person_name}: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ApiIngest#extract_and_ingest_entities',
+                             person_name: person_name)
             { success: false, count: 0 }
           end
 

data/lib/legion/extensions/microsoft_teams/runners/app_installations.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/microsoft_teams/helpers/client'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module AppInstallations
+          extend Legion::Extensions::Definitions
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          def self.trigger_words
+            %w[app apps addon addons installation installed]
+          end
+
+          definition :list_installed_apps_for_user,
+                     desc:          'List Teams apps installed for a user',
+                     mcp_prefix:    'teams.list_installed_apps_for_user',
+                     mcp_category:  'teams_apps',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     trigger_words: %w[apps installed]
+
+          def list_installed_apps_for_user(user_id: 'me', **)
+            response = graph_connection(**).get("#{user_path(user_id)}/teamwork/installedApps")
+            { result: response.body }
+          end
+
+          definition :list_installed_apps_in_chat,
+                     desc:          'List Teams apps installed in a specific chat',
+                     mcp_prefix:    'teams.list_installed_apps_in_chat',
+                     mcp_category:  'teams_apps',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     inputs:        { properties: { chat_id: { type: 'string' } }, required: ['chat_id'] },
+                     trigger_words: %w[apps chat]
+
+          def list_installed_apps_in_chat(chat_id:, **)
+            response = graph_connection(**).get("chats/#{chat_id}/installedApps")
+            { result: response.body }
+          end
+
+          definition :install_app_for_user,
+                     desc:          'Install a Teams app for a user',
+                     mcp_prefix:    'teams.install_app_for_user',
+                     mcp_category:  'teams_apps',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { app_id: { type:        'string',
+                                                              description: 'Teams app catalog ID' } },
+                                      required:   ['app_id'] },
+                     trigger_words: %w[install add app]
+
+          def install_app_for_user(app_id:, user_id: 'me', **)
+            payload = {
+              'teamsApp@odata.bind' => "https://graph.microsoft.com/v1.0/appCatalogs/teamsApps/#{app_id}"
+            }
+            response = graph_connection(**).post("#{user_path(user_id)}/teamwork/installedApps", payload)
+            { result: response.body }
+          end
+
+          definition :uninstall_app_for_user,
+                     desc:          'Uninstall a Teams app for a user',
+                     mcp_prefix:    'teams.uninstall_app_for_user',
+                     mcp_category:  'teams_apps',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { installation_id: { type: 'string' } },
+                                      required:   ['installation_id'] },
+                     trigger_words: %w[uninstall remove]
+
+          def uninstall_app_for_user(installation_id:, user_id: 'me', **)
+            response = graph_connection(**).delete(
+              "#{user_path(user_id)}/teamwork/installedApps/#{installation_id}"
+            )
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/runners/auth.rb

@@ -7,8 +7,12 @@ module Legion
     module MicrosoftTeams
       module Runners
         module Auth
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          definition :acquire_token, mcp_exposed: false
+          definition :acquire_bot_token, mcp_exposed: false
+
           def acquire_token(tenant_id:, client_id:, client_secret:, scope: 'https://graph.microsoft.com/.default', **)
             response = oauth_connection(tenant_id: tenant_id).post('oauth2/v2.0/token', {
                                                                      grant_type:    'client_credentials',
@@ -30,113 +34,6 @@ module Legion
             { result: response.body }
           end
 
-          def request_device_code(tenant_id:, client_id:,
-                                  scope: 'OnlineMeetings.Read OnlineMeetingTranscript.Read.All offline_access', **)
-            response = oauth_connection(tenant_id: tenant_id).post('oauth2/v2.0/devicecode', {
-                                                                     client_id: client_id,
-                                                                     scope:     scope
-                                                                   })
-            { result: response.body }
-          end
-
-          def poll_device_code(tenant_id:, client_id:, device_code:, interval: 5, timeout: 300, **)
-            conn = oauth_connection(tenant_id: tenant_id)
-            deadline = Time.now + timeout
-            current_interval = interval
-
-            loop do
-              response = conn.post('oauth2/v2.0/token', {
-                                     grant_type:  'urn:ietf:params:oauth:grant-type:device_code',
-                                     client_id:   client_id,
-                                     device_code: device_code
-                                   })
-              body = response.body
-
-              return { result: body } if body['access_token']
-
-              case body['error']
-              when 'authorization_pending'
-                return { error: 'timeout', description: "Device code flow timed out after #{timeout}s" } if Time.now > deadline
-
-                sleep(current_interval)
-              when 'slow_down'
-                current_interval += 5
-                sleep(current_interval)
-              else
-                return { error: body['error'], description: body['error_description'] }
-              end
-            end
-          end
-
-          def authorize_url(tenant_id:, client_id:, redirect_uri:, scope:, state:,
-                            code_challenge:, code_challenge_method: 'S256', **)
-            require 'uri'
-            params = URI.encode_www_form(
-              client_id:             client_id,
-              response_type:         'code',
-              redirect_uri:          redirect_uri,
-              scope:                 scope,
-              state:                 state,
-              code_challenge:        code_challenge,
-              code_challenge_method: code_challenge_method
-            )
-            "https://login.microsoftonline.com/#{tenant_id}/oauth2/v2.0/authorize?#{params}"
-          end
-
-          def exchange_code(tenant_id:, client_id:, code:, redirect_uri:, code_verifier:,
-                            scope: 'OnlineMeetings.Read OnlineMeetingTranscript.Read.All offline_access', **)
-            response = oauth_connection(tenant_id: tenant_id).post('oauth2/v2.0/token', {
-                                                                     grant_type:    'authorization_code',
-                                                                     client_id:     client_id,
-                                                                     code:          code,
-                                                                     redirect_uri:  redirect_uri,
-                                                                     code_verifier: code_verifier,
-                                                                     scope:         scope
-                                                                   })
-            { result: response.body }
-          end
-
-          def refresh_delegated_token(tenant_id:, client_id:, refresh_token:,
-                                      scope: 'OnlineMeetings.Read OnlineMeetingTranscript.Read.All offline_access', **)
-            response = oauth_connection(tenant_id: tenant_id).post('oauth2/v2.0/token', {
-                                                                     grant_type:    'refresh_token',
-                                                                     client_id:     client_id,
-                                                                     refresh_token: refresh_token,
-                                                                     scope:         scope
-                                                                   })
-            { result: response.body }
-          end
-
-          def auth_callback(code: nil, state: nil, **)
-            unless code && state
-              return {
-                result:   { error: 'missing_params' },
-                response: { status: 400, content_type: 'text/html',
-                            body: '<html><body><h2>Missing code or state parameter</h2></body></html>' }
-              }
-            end
-
-            Legion::Events.emit('microsoft_teams.oauth.callback', code: code, state: state) if defined?(Legion::Events)
-
-            {
-              result:   { authenticated: true, code: code, state: state },
-              response: { status: 200, content_type: 'text/html',
-                          body: callback_success_html }
-            }
-          end
-          alias handle auth_callback
-
-          private
-
-          def callback_success_html
-            <<~HTML
-              <html><body style="font-family:sans-serif;text-align:center;padding:40px;">
-              <h2>Authentication complete</h2>
-              <p>You can close this window.</p>
-              </body></html>
-            HTML
-          end
-
           include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                       Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end

data/lib/legion/extensions/microsoft_teams/runners/bot.rb

@@ -180,16 +180,18 @@ module Legion
             instructions = session[:system_prompt]
             instructions = "#{instructions}\n\n#{trace_context}" if trace_context && !trace_context.empty?
 
-            response = llm_chat(
-              text,
-              instructions: instructions,
-              model:        config[:model],
-              intent:       config[:intent],
-              caller:       { id: session[:owner_id], extension: 'lex-microsoft_teams', mode: :bot_response }
+            response = Legion::LLM.chat( # rubocop:disable Legion/HelperMigration/DirectLlm
+              message: [
+                { role: 'system', content: instructions },
+                { role: 'user', content: text }
+              ],
+              model:   config[:model],
+              intent:  config[:intent],
+              caller:  { id: session[:owner_id], extension: 'lex-microsoft_teams', mode: :bot_response }
             )
             response.content
           rescue StandardError => e
-            log.error("LLM call failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'Bot#llm_respond')
             'I encountered an error processing your message. Please try again.'
           end
 
@@ -198,7 +200,7 @@ module Legion
 
             retrieve_context(message: message, owner_id: owner_id, chat_id: chat_id)
           rescue StandardError => e
-            log.debug("retrieve_trace_context failed: #{e.message}") if defined?(log)
+            handle_exception(e, level: :debug, operation: 'Bot#retrieve_trace_context') if defined?(handle_exception)
             nil
           end
 
@@ -241,10 +243,16 @@ module Legion
             prompt = resolve_prompt(mode: :observe, conversation_id: nil)
             context = "#{from[:name] || peer_name} said: #{text}"
 
-            response = llm_chat(context, instructions: prompt, caller: { id: owner_id, extension: 'lex-microsoft_teams', mode: :observe })
+            response = Legion::LLM.chat( # rubocop:disable Legion/HelperMigration/DirectLlm
+              message: [
+                { role: 'system', content: prompt },
+                { role: 'user', content: context }
+              ],
+              caller:  { id: owner_id, extension: 'lex-microsoft_teams', mode: :observe }
+            )
             parse_extraction(response.content)
           rescue StandardError => e
-            log.error("Observation extraction failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'Bot#extract_from_message')
             nil
           end
 
@@ -275,7 +283,7 @@ module Legion
               confidence:      0.6
             )
           rescue StandardError => e
-            log.error("Observation store failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'Bot#store_observation')
           end
 
           def notify_owner(owner_id:, peer_name:, extraction: nil) # rubocop:disable Lint/UnusedMethodArgument
@@ -413,7 +421,7 @@ module Legion
             end
             nil
           rescue StandardError => e
-            log.error("find_chat_with_person failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'Bot#find_chat_with_person', name: name)
             nil
           end
 

data/lib/legion/extensions/microsoft_teams/runners/cache_ingest.rb

@@ -7,6 +7,10 @@ module Legion
     module MicrosoftTeams
       module Runners
         module CacheIngest
+          extend Legion::Extensions::Definitions
+
+          definition :ingest_cache, mcp_exposed: false
+
           # Ingest Teams messages from local cache into lex-memory traces.
           # Returns count of new traces stored and the latest compose_time seen.
           def ingest_cache(since: nil, skip_bots: true, db_path: nil, imprint_active: false, **)
@@ -82,7 +86,7 @@ module Legion
               imprint_active:      imprint_active
             )
           rescue StandardError => e
-            log.warn("CacheIngest: failed to store trace: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'CacheIngest#store_message_trace')
             nil
           end
 
@@ -105,7 +109,7 @@ module Legion
             store = Legion::Extensions::Agentic::Memory::Trace.shared_store
             store.flush if store.respond_to?(:flush)
           rescue StandardError => e
-            log.warn("CacheIngest: flush failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'CacheIngest#flush_trace_store')
           end
 
           # Seed Hebbian coactivation links between messages in the same thread.
@@ -119,12 +123,12 @@ module Legion
               trace_ids.each_cons(2) do |id_a, id_b|
                 store.record_coactivation(id_a, id_b)
               rescue StandardError => e
-                log.debug("CacheIngest: coactivation link failed for #{id_a}/#{id_b}: #{e.message}")
-                nil
+                handle_exception(e, level: :debug, operation: 'CacheIngest#coactivate_thread_traces',
+                                 id_a: id_a, id_b: id_b)
               end
             end
           rescue StandardError => e
-            log.debug("CacheIngest: coactivation linking skipped: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'CacheIngest#coactivate_thread_traces')
           end
         end
       end

data/lib/legion/extensions/microsoft_teams/runners/call_events.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/microsoft_teams/helpers/client'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module CallEvents
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          def self.trigger_words
+            %w[call calls session sessions segment pstn]
+          end
+
+          definition :list_call_sessions,
+                     desc:          'List sessions for a Teams call record',
+                     mcp_prefix:    'teams.list_call_sessions',
+                     mcp_category:  'teams_calls',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { call_id: { type: 'string' } }, required: ['call_id'] },
+                     trigger_words: %w[sessions calls records]
+
+          def list_call_sessions(call_id:, **)
+            response = graph_connection(**).get("communications/callRecords/#{call_id}/sessions")
+            { result: response.body }
+          end
+
+          definition :get_call_session,
+                     desc:          'Get a specific session from a Teams call record',
+                     mcp_prefix:    'teams.get_call_session',
+                     mcp_category:  'teams_calls',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { call_id:    { type: 'string' },
+                                                    session_id: { type: 'string' } },
+                                      required:   %w[call_id session_id] },
+                     trigger_words: %w[session call record]
+
+          def get_call_session(call_id:, session_id:, **)
+            response = graph_connection(**).get(
+              "communications/callRecords/#{call_id}/sessions/#{session_id}"
+            )
+            { result: response.body }
+          end
+
+          definition :list_session_segments,
+                     desc:          'List segments for a session in a Teams call record',
+                     mcp_prefix:    'teams.list_session_segments',
+                     mcp_category:  'teams_calls',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { call_id:    { type: 'string' },
+                                                    session_id: { type: 'string' } },
+                                      required:   %w[call_id session_id] },
+                     trigger_words: %w[segments pstn]
+
+          def list_session_segments(call_id:, session_id:, **)
+            response = graph_connection(**).get(
+              "communications/callRecords/#{call_id}/sessions/#{session_id}/segments"
+            )
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end