From deb9098c51eaa9e9863554550dbb31cb48b4d549 Mon Sep 17 00:00:00 2001 From: a251231 <55580477+a251231@users.noreply.github.com> Date: Thu, 12 Nov 2026 07:54:14 +0000 Subject: [PATCH 1/2] feat(monitoring): enhance sender display name extraction and per-sender group session IDs --- .../api/http/controller/groups/monitoring.py | 1 + .../pkg/api/http/service/monitoring.py | 1 + src/langbot/pkg/pipeline/monitoring_helper.py | 90 ++++++++++++------- .../pipeline/test_plugin_query_monitoring.py | 53 +++++++++++ web/src/app/infra/http/BackendClient.ts | 1 + 5 files changed, 116 insertions(+), 30 deletions(-) diff --git a/src/langbot/pkg/api/http/controller/groups/monitoring.py b/src/langbot/pkg/api/http/controller/groups/monitoring.py index b92ea5d722..64099850e5 100644 --- a/src/langbot/pkg/api/http/controller/groups/monitoring.py +++ b/src/langbot/pkg/api/http/controller/groups/monitoring.py @@ -756,6 +756,7 @@ async def export_data(request_context: RequestContext) -> tuple[str, int]: 'is_active', 'platform', 'user_id', + 'user_name', ] elif export_type == 'feedback': data = await self.ap.monitoring_service.export_feedback( diff --git a/src/langbot/pkg/api/http/service/monitoring.py b/src/langbot/pkg/api/http/service/monitoring.py index 2848ab1a27..b725d7c1b2 100644 --- a/src/langbot/pkg/api/http/service/monitoring.py +++ b/src/langbot/pkg/api/http/service/monitoring.py @@ -3185,6 +3185,7 @@ async def export_sessions( 'is_active': str(row[0].is_active if isinstance(row, tuple) else row.is_active), 'platform': row[0].platform if isinstance(row, tuple) else row.platform, 'user_id': row[0].user_id if isinstance(row, tuple) else row.user_id, + 'user_name': row[0].user_name if isinstance(row, tuple) else row.user_name, } for row in rows ] diff --git a/src/langbot/pkg/pipeline/monitoring_helper.py b/src/langbot/pkg/pipeline/monitoring_helper.py index 700eb7db62..4b20c16abe 100644 --- a/src/langbot/pkg/pipeline/monitoring_helper.py +++ b/src/langbot/pkg/pipeline/monitoring_helper.py @@ -114,7 +114,11 @@ def monitoring_session_id(query: typing.Any) -> str: """Return the monitoring session id for pipeline and plugin-owned Queries.""" platform = monitoring_platform(query) if platform is not None: - return f'{platform}_{getattr(query, "launcher_id", None)}' + launcher_id = getattr(query, 'launcher_id', None) + sender_id = getattr(query, 'sender_id', None) + if platform == 'group' and sender_id not in (None, ''): + return f'{platform}_{launcher_id}_{sender_id}' + return f'{platform}_{launcher_id}' if _origin(query).get('session_id'): return _origin(query)['session_id'] plugin = (getattr(query, 'variables', None) or {}).get(PLUGIN_ATTRIBUTION_VAR) @@ -248,6 +252,57 @@ async def prepare_monitoring_identity( class MonitoringHelper: """Helper class for monitoring operations""" + @staticmethod + def _build_session_id(query: pipeline_query.Query) -> str: + return monitoring_session_id(query) + + @staticmethod + def _extract_sender_name(query: pipeline_query.Query) -> str | None: + """Extract session display name from query message event.""" + sender_name: str | None = None + + message_event = getattr(query, 'message_event', None) + group = getattr(message_event, 'group', None) + group_name = getattr(group, 'name', None) if group is not None else None + if isinstance(group_name, str) and group_name.strip(): + return group_name.strip() + + sender = getattr(message_event, 'sender', None) + if sender is not None: + get_name = getattr(sender, 'get_name', None) + if callable(get_name): + try: + sender_name = get_name() + except Exception: + sender_name = None + else: + sender_name = sender_name.strip() if isinstance(sender_name, str) else None + + if not sender_name: + for attr in ( + 'member_name', + 'nickname', + 'remark', + 'name', + 'display_name', + 'username', + 'user_name', + 'card', + ): + value = getattr(sender, attr, None) + if isinstance(value, str) and value.strip(): + sender_name = value.strip() + break + + if not sender_name: + variables = getattr(query, 'variables', None) + if isinstance(variables, dict): + var_sender_name = variables.get('sender_name') + if isinstance(var_sender_name, str) and var_sender_name.strip(): + sender_name = var_sender_name.strip() + + return sender_name if sender_name else None + @staticmethod async def finish_query(ap, query, message_id: str, status: str) -> None: """Bound terminal writes and retry transient failures without blocking cleanup.""" @@ -291,15 +346,7 @@ async def record_query_start( try: # Message persistence updates the summary in the same transaction. session_id = monitoring_session_id(query) - - # Get sender name from message event - sender_name = None - if hasattr(query, 'message_event'): - if hasattr(query.message_event, 'sender'): - if hasattr(query.message_event.sender, 'nickname'): - sender_name = query.message_event.sender.nickname - elif hasattr(query.message_event.sender, 'member_name'): - sender_name = query.message_event.sender.member_name + sender_name = MonitoringHelper._extract_sender_name(query) # Try to record message # Let persistence externalize images before serializing the message chain. @@ -375,15 +422,7 @@ async def record_query_response( try: handled_by = get_handled_by(query) session_id = monitoring_session_id(query) - - # Get sender name from message event - sender_name = None - if hasattr(query, 'message_event'): - if hasattr(query.message_event, 'sender'): - if hasattr(query.message_event.sender, 'nickname'): - sender_name = query.message_event.sender.nickname - elif hasattr(query.message_event.sender, 'member_name'): - sender_name = query.message_event.sender.member_name + sender_name = MonitoringHelper._extract_sender_name(query) # Extract response content from resp_message_chain if hasattr(query, 'resp_message_chain') and query.resp_message_chain: @@ -444,15 +483,7 @@ async def record_query_error( if original_message_id: await MonitoringHelper.finish_query(ap, query, original_message_id, 'error') session_id = monitoring_session_id(query) - - # Get sender name from message event - sender_name = None - if hasattr(query, 'message_event'): - if hasattr(query.message_event, 'sender'): - if hasattr(query.message_event.sender, 'nickname'): - sender_name = query.message_event.sender.nickname - elif hasattr(query.message_event.sender, 'member_name'): - sender_name = query.message_event.sender.member_name + sender_name = MonitoringHelper._extract_sender_name(query) # Record error message message_id = await ap.monitoring_service.record_message( @@ -563,7 +594,6 @@ async def record_plugin_reply( ) -> str: """Record a ``ctx.reply`` from a plugin as a reply to the triggering message.""" variables = getattr(query, 'variables', None) or {} - sender = getattr(getattr(query, 'message_event', None), 'sender', None) return await MonitoringHelper.record_plugin_message( ap, get_query_execution_context(query), @@ -576,7 +606,7 @@ async def record_plugin_reply( session_id=monitoring_session_id(query), platform=monitoring_platform(query), user_id=getattr(query, 'sender_id', None), - user_name=getattr(sender, 'nickname', None) or getattr(sender, 'member_name', None), + user_name=MonitoringHelper._extract_sender_name(query), parent_message_id=variables.get('_monitoring_message_id'), error=error, error_type='PluginReplyError', diff --git a/tests/unit_tests/pipeline/test_plugin_query_monitoring.py b/tests/unit_tests/pipeline/test_plugin_query_monitoring.py index c3eb5a4c0d..4b20886c3a 100644 --- a/tests/unit_tests/pipeline/test_plugin_query_monitoring.py +++ b/tests/unit_tests/pipeline/test_plugin_query_monitoring.py @@ -59,6 +59,59 @@ def test_pipeline_query_session_id_is_unchanged(sample_query): assert monitoring_platform(sample_query) == sample_query.launcher_type.value +def test_group_query_session_id_includes_sender_id_when_present(): + group_query = SimpleNamespace( + launcher_type=SimpleNamespace(value='group'), + launcher_id='group-100', + sender_id='user-42', + variables={}, + ) + assert monitoring_session_id(group_query) == 'group_group-100_user-42' + + group_query_without_sender = SimpleNamespace( + launcher_type=SimpleNamespace(value='group'), + launcher_id='group-100', + sender_id=None, + variables={}, + ) + assert monitoring_session_id(group_query_without_sender) == 'group_group-100' + + +def test_extract_sender_name_supports_group_sender_methods_and_variables(): + group_query = SimpleNamespace( + message_event=SimpleNamespace( + group=SimpleNamespace(name=' Dev Group '), + sender=SimpleNamespace(nickname='Alice'), + ), + variables={}, + ) + assert MonitoringHelper._extract_sender_name(group_query) == 'Dev Group' + + getter_query = SimpleNamespace( + message_event=SimpleNamespace( + group=None, + sender=SimpleNamespace(get_name=lambda: ' Getter Name ', nickname='Fallback'), + ), + variables={}, + ) + assert MonitoringHelper._extract_sender_name(getter_query) == 'Getter Name' + + remark_query = SimpleNamespace( + message_event=SimpleNamespace( + group=None, + sender=SimpleNamespace(member_name='', nickname=' ', remark=' Remark Name '), + ), + variables={}, + ) + assert MonitoringHelper._extract_sender_name(remark_query) == 'Remark Name' + + var_query = SimpleNamespace( + message_event=SimpleNamespace(group=None, sender=None), + variables={'sender_name': ' Lark User '}, + ) + assert MonitoringHelper._extract_sender_name(var_query) == 'Lark User' + + @pytest.mark.asyncio async def test_llm_call_from_plugin_action_query_is_recorded(): """Regression: ``'Query' object has no attribute 'launcher_type'`` dropped the record.""" diff --git a/web/src/app/infra/http/BackendClient.ts b/web/src/app/infra/http/BackendClient.ts index 7f8d7f8dda..2274467f39 100644 --- a/web/src/app/infra/http/BackendClient.ts +++ b/web/src/app/infra/http/BackendClient.ts @@ -2311,6 +2311,7 @@ export class BackendClient extends BaseHttpClient { start_time: string; platform?: string; user_id?: string; + user_name?: string; }>; errors: Array<{ id: string; From 30597590b443e54f95020bc64453a770a216b81f Mon Sep 17 00:00:00 2001 From: a251231 <55580477+a251231@users.noreply.github.com> Date: Mon, 16 Nov 2026 15:33:03 +0000 Subject: [PATCH 2/2] fix(monitoring): unify per-sender group session ID and fix sender name extraction --- skills/skills/langbot-mcp-ops/SKILL.md | 2 +- .../api/http/controller/groups/monitoring.py | 2 + .../pkg/api/http/service/monitoring.py | 38 +++ .../service/monitoring_execution_details.py | 14 +- src/langbot/pkg/api/mcp/server.py | 4 +- .../persistence/session_summary_contract.py | 29 ++ .../pkg/persistence/session_summary_reader.py | 25 ++ .../pkg/persistence/session_summary_writer.py | 25 +- src/langbot/pkg/pipeline/monitoring_helper.py | 102 +++---- src/langbot/pkg/platform/botmgr.py | 11 +- src/langbot/pkg/provider/tools/toolmgr.py | 9 +- tests/integration/api/test_monitoring.py | 3 +- .../api/service/test_monitoring_sessions.py | 4 +- .../api/service/test_session_context_reset.py | 27 ++ .../pipeline/test_plugin_query_monitoring.py | 258 +++++++++++++++++- web/src/app/infra/http/BackendClient.ts | 4 + 16 files changed, 484 insertions(+), 73 deletions(-) diff --git a/skills/skills/langbot-mcp-ops/SKILL.md b/skills/skills/langbot-mcp-ops/SKILL.md index 1b3d1900c9..6def3c69db 100644 --- a/skills/skills/langbot-mcp-ops/SKILL.md +++ b/skills/skills/langbot-mcp-ops/SKILL.md @@ -278,7 +278,7 @@ execution, not the individual model/tool call outcome. Calls without a recorded execution link are excluded when an execution filter is active. Session lists support `bot_ids`, `pipeline_ids`, `start_time`, `end_time`, -`user_query`, `is_active`, and pagination. For execution status or real/debug +`user_query`, `launcher_id`, `is_active`, and pagination. For execution status or real/debug filters, use `get_monitoring_executions`; HTTP `/monitoring/sessions` rejects them. In HTTP `/monitoring/data`, `sessions` and `totalCount.sessions` use only bot/pipeline/time filters; execution filters apply to the other records. diff --git a/src/langbot/pkg/api/http/controller/groups/monitoring.py b/src/langbot/pkg/api/http/controller/groups/monitoring.py index 64099850e5..10a1016c73 100644 --- a/src/langbot/pkg/api/http/controller/groups/monitoring.py +++ b/src/langbot/pkg/api/http/controller/groups/monitoring.py @@ -353,6 +353,7 @@ async def get_sessions(request_context: RequestContext) -> str: start_time_str = quart.request.args.get('startTime') end_time_str = quart.request.args.get('endTime') user_query = quart.request.args.get('userQuery') + launcher_id = quart.request.args.get('launcherId') or quart.request.args.get('groupId') is_active_str = quart.request.args.get('isActive') limit, offset = self.ap.monitoring_service.normalize_page_window( quart.request.args.get('limit', 100), quart.request.args.get('offset', 0) @@ -375,6 +376,7 @@ async def get_sessions(request_context: RequestContext) -> str: start_time=start_time, end_time=end_time, user_query=user_query, + launcher_id=launcher_id, is_active=is_active, limit=limit, offset=offset, diff --git a/src/langbot/pkg/api/http/service/monitoring.py b/src/langbot/pkg/api/http/service/monitoring.py index b725d7c1b2..ccae4d4a56 100644 --- a/src/langbot/pkg/api/http/service/monitoring.py +++ b/src/langbot/pkg/api/http/service/monitoring.py @@ -2348,6 +2348,42 @@ async def reset_session_context(self, context: TenantContext, bot_id: str, sessi raise LookupError('Session not found') # Legacy sessions use uppercase PERSON/GROUP; envelope IDs use lowercase. conversation = re.sub(r'^(PERSON|GROUP)_', lambda match: match[1].lower() + '_', session_id) + if conversation.startswith('group_') and '#' not in conversation: + session_model = persistence_monitoring.MonitoringSession + user_id = ( + await execute( + sqlalchemy.select(session_model.user_id) + .where( + session_model.workspace_uuid == workspace, + session_model.bot_id == bot_id, + session_model.session_id == session_id, + session_model.user_id.is_not(None), + session_model.user_id != '', + ) + .limit(1) + ) + ).scalar_one_or_none() + if not user_id: + msg_model = persistence_monitoring.MonitoringMessage + user_id = ( + await execute( + sqlalchemy.select(msg_model.user_id) + .where( + msg_model.workspace_uuid == workspace, + msg_model.bot_id == bot_id, + msg_model.session_id == session_id, + sqlalchemy.func.coalesce(msg_model.role, 'user') != 'assistant', + msg_model.user_id.is_not(None), + msg_model.user_id != '', + ) + .order_by(msg_model.timestamp.desc()) + .limit(1) + ) + ).scalar_one_or_none() + if user_id and conversation.endswith(f'_{user_id}'): + stripped = conversation[: -(len(str(user_id)) + 1)] + if stripped != 'group': + conversation = stripped run = persistence_agent_run.AgentRun busy = ( await execute( @@ -2403,6 +2439,7 @@ async def get_sessions( start_time: datetime.datetime | None = None, end_time: datetime.datetime | None = None, user_query: str | None = None, + launcher_id: str | None = None, is_active: bool | None = None, limit: int = 100, offset: int = 0, @@ -2418,6 +2455,7 @@ async def get_sessions( start_time=start_time, end_time=end_time, user_query=user_query, + launcher_id=launcher_id, is_active=is_active, ), limit, diff --git a/src/langbot/pkg/api/http/service/monitoring_execution_details.py b/src/langbot/pkg/api/http/service/monitoring_execution_details.py index 7a8da8bc9e..bc0414d2a6 100644 --- a/src/langbot/pkg/api/http/service/monitoring_execution_details.py +++ b/src/langbot/pkg/api/http/service/monitoring_execution_details.py @@ -139,6 +139,18 @@ def _conversation_message_queries(self, workspace, bot_ids): ), ), ) + monitoring_session = sa.case( + ( + sa.and_( + conversation.like('group\\_%', escape='\\'), + ~conversation.like('%#%', escape='\\'), + EventLog.actor_id.is_not(None), + EventLog.actor_id != '', + ), + conversation + sa.literal('_') + EventLog.actor_id, + ), + else_=conversation, + ) values = { 'id': EventLog.event_id, 'workspace_uuid': EventLog.workspace_id, @@ -152,7 +164,7 @@ def _conversation_message_queries(self, workspace, bot_ids): self._execution_json_text(EventLog.metadata_json, ('routes', 0, 'target_type')), '' ), 'message_content': sa.func.coalesce(EventLog.input_json, EventLog.input_summary, ''), - 'session_id': conversation, + 'session_id': monitoring_session, 'status': sa.func.coalesce(self._execution_json_text(EventLog.metadata_json, 'status'), 'success'), 'level': sa.literal('info'), 'platform': self._execution_json_text(EventLog.metadata_json, 'platform'), diff --git a/src/langbot/pkg/api/mcp/server.py b/src/langbot/pkg/api/mcp/server.py index afb9a147bc..9d881e1764 100644 --- a/src/langbot/pkg/api/mcp/server.py +++ b/src/langbot/pkg/api/mcp/server.py @@ -225,7 +225,7 @@ async def get_sandbox_diagnostics(kind: typing.Literal['status', 'sessions', 'er return _dump(ap.box_service.get_recent_errors(context)) @mcp.tool( - description='Read bounded Workspace runtime records. Message image URLs may be renewed through the connected OneBot peer without downloading images or rewriting stored records; URLs remain temporary. LLM calls include optional details (timing in ms, complete provider usage, structured error); older records have null details. Filters follow the monitoring service: bot_ids, pipeline_ids, session_ids, start_time, end_time, mode (all/real/debug), execution_statuses (owning execution status groups), knowledge_base_id, user_query, is_active as supported by the record kind. Sessions read stored conversation summaries and do not support mode or execution_statuses.' + description='Read bounded Workspace runtime records. Message image URLs may be renewed through the connected OneBot peer without downloading images or rewriting stored records; URLs remain temporary. LLM calls include optional details (timing in ms, complete provider usage, structured error); older records have null details. Filters follow the monitoring service: bot_ids, pipeline_ids, session_ids, start_time, end_time, mode (all/real/debug), execution_statuses (owning execution status groups), knowledge_base_id, user_query, launcher_id, is_active as supported by the record kind. Sessions read stored conversation summaries and do not support mode or execution_statuses.' ) async def get_monitoring_records( kind: typing.Literal['messages', 'llm_calls', 'tool_calls', 'embedding_calls', 'sessions', 'errors'], @@ -245,7 +245,7 @@ async def get_monitoring_records( allowed.add('knowledge_base_id') if kind == 'sessions': allowed -= {'mode', 'execution_statuses'} - allowed |= {'user_query', 'is_active'} + allowed |= {'user_query', 'launcher_id', 'is_active'} kwargs = dict(filters or {}) if set(kwargs) - allowed: raise ValueError('Unsupported monitoring filter') diff --git a/src/langbot/pkg/persistence/session_summary_contract.py b/src/langbot/pkg/persistence/session_summary_contract.py index d383a255b7..f8126efd50 100644 --- a/src/langbot/pkg/persistence/session_summary_contract.py +++ b/src/langbot/pkg/persistence/session_summary_contract.py @@ -12,6 +12,7 @@ class SessionListFilter: start_time: datetime.datetime | None = None end_time: datetime.datetime | None = None user_query: str | None = None + launcher_id: str | None = None is_active: bool | None = None @@ -43,3 +44,31 @@ class SessionSummaryChange: def message_source_key(message_id: str) -> str: """Distinct message records remain distinct even when they share an event.""" return f'message:{message_id}' + + +def build_monitoring_session_id( + launcher_type: object, + launcher_id: object, + sender_id: object = None, +) -> str: + """Build the canonical monitoring session ID without altering conversation keys.""" + launcher_type_value = launcher_type.value if hasattr(launcher_type, 'value') else str(launcher_type) + if launcher_type_value == 'group' and sender_id is not None: + sender_text = str(sender_id).strip() + if sender_text: + return f'group_{launcher_id}_{sender_text}' + return f'{launcher_type_value}_{launcher_id}' + + +def monitoring_session_id_from_conversation( + conversation_id: str | None, + actor_id: object = None, +) -> str: + """Map a conversation key and optional actor ID to the monitoring session ID.""" + if not conversation_id: + return '' + if conversation_id.startswith('group_') and '#' not in conversation_id: + launcher_id = conversation_id.removeprefix('group_') + if launcher_id: + return build_monitoring_session_id('group', launcher_id, actor_id) + return conversation_id diff --git a/src/langbot/pkg/persistence/session_summary_reader.py b/src/langbot/pkg/persistence/session_summary_reader.py index ecc03e4be7..80fd075eb8 100644 --- a/src/langbot/pkg/persistence/session_summary_reader.py +++ b/src/langbot/pkg/persistence/session_summary_reader.py @@ -49,6 +49,31 @@ async def list_page( if filters.user_query and filters.user_query.strip(): pattern = f'%{filters.user_query.strip()}%' conditions.append(sa.or_(model.user_id.ilike(pattern), model.user_name.ilike(pattern))) + if filters.launcher_id and filters.launcher_id.strip(): + raw_launcher = filters.launcher_id.strip() + normalized = raw_launcher + for prefix in ('group_', 'GROUP_', 'person_', 'PERSON_'): + if raw_launcher.startswith(prefix) and len(raw_launcher) > len(prefix): + normalized = raw_launcher[len(prefix) :] + break + escaped = normalized.replace('\\', '\\\\').replace('%', '\\%').replace('_', '\\_') + conditions.append( + sa.or_( + model.session_id.in_( + ( + raw_launcher, + f'group_{normalized}', + f'GROUP_{normalized}', + f'person_{normalized}', + f'PERSON_{normalized}', + ) + ), + model.session_id.like(f'group_{escaped}\\_%', escape='\\'), + model.session_id.like(f'GROUP_{escaped}\\_%', escape='\\'), + model.session_id.like(f'group_{escaped}#%', escape='\\'), + model.session_id.like(f'GROUP_{escaped}#%', escape='\\'), + ) + ) if filters.is_active is not None: conditions.append(model.is_active == filters.is_active) async with self._session_scope(workspace) as session: diff --git a/src/langbot/pkg/persistence/session_summary_writer.py b/src/langbot/pkg/persistence/session_summary_writer.py index f618eb0d8f..c78ff3af7f 100644 --- a/src/langbot/pkg/persistence/session_summary_writer.py +++ b/src/langbot/pkg/persistence/session_summary_writer.py @@ -9,7 +9,11 @@ from ..entity.persistence.monitoring import MonitoringSession, MonitoringSessionReceipt from .datetime_utils import as_naive_utc -from .session_summary_contract import SessionSummaryChange, message_source_key +from .session_summary_contract import ( + SessionSummaryChange, + message_source_key, + monitoring_session_id_from_conversation, +) SESSION_KEY = ['workspace_uuid', 'bot_id', 'session_id'] @@ -47,7 +51,7 @@ def ingress_summary_change(workspace: str, row) -> SessionSummaryChange: return SessionSummaryChange( workspace=workspace, bot_id=row['bot_id'], - session_id=row['conversation_id'] or '', + session_id=monitoring_session_id_from_conversation(row['conversation_id'], row['actor_id']), source_key=f'event:{row["event_id"]}', timestamp=row['event_time'] or row['created_at'], bot_name=metadata.get('bot_name') or '', @@ -265,9 +269,20 @@ async def apply_once(self, session: AsyncSession, change: SessionSummaryChange, ) if state['covered']: return False - if state['session_id'] is not None and state['session_id'] != identity: - raise ValueError('An ingress event cannot belong to two conversations') - claimed = state['session_id'] is None + previous_owner = state['session_id'] + if previous_owner is not None and previous_owner != identity: + if ( + previous_owner.startswith('group_') + and '#' not in previous_owner + and change.user_id not in (None, '') + and identity == f'{previous_owner}_{change.user_id}' + ): + deltas[previous_owner] = deltas.get(previous_owner, 0) - 1 + claimed = True + else: + raise ValueError('An ingress event cannot belong to two conversations') + else: + claimed = previous_owner is None elif change.role != 'assistant': # Legacy message.id matching is part of the historical detail contract. for event_id in sorted({change.source_key.removeprefix('message:'), change.event_id} - {None}): diff --git a/src/langbot/pkg/pipeline/monitoring_helper.py b/src/langbot/pkg/pipeline/monitoring_helper.py index 4b20c16abe..3aa4b3f000 100644 --- a/src/langbot/pkg/pipeline/monitoring_helper.py +++ b/src/langbot/pkg/pipeline/monitoring_helper.py @@ -16,6 +16,7 @@ from ..core import app import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query +from ..persistence.session_summary_contract import build_monitoring_session_id from .pool import get_query_execution_context # Query variable naming the plugin (``author/name``) that owns a Host-built @@ -114,11 +115,11 @@ def monitoring_session_id(query: typing.Any) -> str: """Return the monitoring session id for pipeline and plugin-owned Queries.""" platform = monitoring_platform(query) if platform is not None: - launcher_id = getattr(query, 'launcher_id', None) - sender_id = getattr(query, 'sender_id', None) - if platform == 'group' and sender_id not in (None, ''): - return f'{platform}_{launcher_id}_{sender_id}' - return f'{platform}_{launcher_id}' + return build_monitoring_session_id( + platform, + getattr(query, 'launcher_id', None), + getattr(query, 'sender_id', None), + ) if _origin(query).get('session_id'): return _origin(query)['session_id'] plugin = (getattr(query, 'variables', None) or {}).get(PLUGIN_ATTRIBUTION_VAR) @@ -249,6 +250,48 @@ async def prepare_monitoring_identity( ap.logger.error(f'Failed to prepare monitoring identity: {e}') +def extract_sender_name( + message_event: typing.Any, + variables: typing.Mapping[str, typing.Any] | None = None, +) -> str | None: + """Extract sender display name from a message event or query variables.""" + sender_name: str | None = None + + sender = getattr(message_event, 'sender', None) + if sender is not None: + get_name = getattr(sender, 'get_name', None) + if callable(get_name): + try: + sender_name = get_name() + except Exception: + sender_name = None + else: + sender_name = sender_name.strip() if isinstance(sender_name, str) else None + + if not sender_name: + for attr in ( + 'member_name', + 'nickname', + 'remark', + 'name', + 'display_name', + 'username', + 'user_name', + 'card', + ): + value = getattr(sender, attr, None) + if isinstance(value, str) and value.strip(): + sender_name = value.strip() + break + + if not sender_name and isinstance(variables, typing.Mapping): + var_sender_name = variables.get('sender_name') + if isinstance(var_sender_name, str) and var_sender_name.strip(): + sender_name = var_sender_name.strip() + + return sender_name if sender_name else None + + class MonitoringHelper: """Helper class for monitoring operations""" @@ -258,50 +301,11 @@ def _build_session_id(query: pipeline_query.Query) -> str: @staticmethod def _extract_sender_name(query: pipeline_query.Query) -> str | None: - """Extract session display name from query message event.""" - sender_name: str | None = None - - message_event = getattr(query, 'message_event', None) - group = getattr(message_event, 'group', None) - group_name = getattr(group, 'name', None) if group is not None else None - if isinstance(group_name, str) and group_name.strip(): - return group_name.strip() - - sender = getattr(message_event, 'sender', None) - if sender is not None: - get_name = getattr(sender, 'get_name', None) - if callable(get_name): - try: - sender_name = get_name() - except Exception: - sender_name = None - else: - sender_name = sender_name.strip() if isinstance(sender_name, str) else None - - if not sender_name: - for attr in ( - 'member_name', - 'nickname', - 'remark', - 'name', - 'display_name', - 'username', - 'user_name', - 'card', - ): - value = getattr(sender, attr, None) - if isinstance(value, str) and value.strip(): - sender_name = value.strip() - break - - if not sender_name: - variables = getattr(query, 'variables', None) - if isinstance(variables, dict): - var_sender_name = variables.get('sender_name') - if isinstance(var_sender_name, str) and var_sender_name.strip(): - sender_name = var_sender_name.strip() - - return sender_name if sender_name else None + """Extract sender display name from query message event.""" + return extract_sender_name( + getattr(query, 'message_event', None), + getattr(query, 'variables', None), + ) @staticmethod async def finish_query(ap, query, message_id: str, status: str) -> None: diff --git a/src/langbot/pkg/platform/botmgr.py b/src/langbot/pkg/platform/botmgr.py index 251e67a178..4c7c0ad3dc 100644 --- a/src/langbot/pkg/platform/botmgr.py +++ b/src/langbot/pkg/platform/botmgr.py @@ -1477,16 +1477,13 @@ async def _record_discarded_message( else: message_content = str(message_chain) - sender_name = None - if hasattr(message_event, 'sender'): - if hasattr(message_event.sender, 'nickname'): - sender_name = message_event.sender.nickname - elif hasattr(message_event.sender, 'member_name'): - sender_name = message_event.sender.member_name + from ..pipeline.monitoring_helper import build_monitoring_session_id, extract_sender_name + + sender_name = extract_sender_name(message_event) # Use the same session_id format as monitoring_helper.py - session_id = f'{launcher_type}_{launcher_id}' platform = launcher_type.value if hasattr(launcher_type, 'value') else str(launcher_type) + session_id = build_monitoring_session_id(platform, launcher_id, sender_id) await self.ap.monitoring_service.record_message( self.execution_context, diff --git a/src/langbot/pkg/provider/tools/toolmgr.py b/src/langbot/pkg/provider/tools/toolmgr.py index e754c2c11f..bcecc4b03c 100644 --- a/src/langbot/pkg/provider/tools/toolmgr.py +++ b/src/langbot/pkg/provider/tools/toolmgr.py @@ -411,8 +411,13 @@ def _get_query_session_id(self, query: pipeline_query.Query) -> str | None: if launcher_type is None or launcher_id is None: return None - launcher_type_value = launcher_type.value if hasattr(launcher_type, 'value') else launcher_type - return f'{launcher_type_value}_{launcher_id}' + from ...pipeline.monitoring_helper import build_monitoring_session_id + + return build_monitoring_session_id( + launcher_type, + launcher_id, + getattr(query, 'sender_id', None), + ) async def _record_tool_call( self, diff --git a/tests/integration/api/test_monitoring.py b/tests/integration/api/test_monitoring.py index 88b05cabcc..0a3496b4da 100644 --- a/tests/integration/api/test_monitoring.py +++ b/tests/integration/api/test_monitoring.py @@ -289,7 +289,7 @@ async def test_get_sessions_forwards_user_search_and_page_window(self, quart_tes fake_monitoring_app.monitoring_service.get_sessions.reset_mock() response = await quart_test_client.get( - '/api/v1/monitoring/sessions?botId=bot-1&userQuery=alice&limit=20&offset=40', + '/api/v1/monitoring/sessions?botId=bot-1&userQuery=alice&launcherId=group-100&limit=20&offset=40', headers={'Authorization': 'Bearer test_token'}, ) @@ -297,6 +297,7 @@ async def test_get_sessions_forwards_user_search_and_page_window(self, quart_tes kwargs = fake_monitoring_app.monitoring_service.get_sessions.await_args.kwargs assert kwargs['bot_ids'] == ['bot-1'] assert kwargs['user_query'] == 'alice' + assert kwargs['launcher_id'] == 'group-100' assert kwargs['limit'] == 20 assert kwargs['offset'] == 40 diff --git a/tests/unit_tests/api/service/test_monitoring_sessions.py b/tests/unit_tests/api/service/test_monitoring_sessions.py index 733bc7b855..fc5e37f7ef 100644 --- a/tests/unit_tests/api/service/test_monitoring_sessions.py +++ b/tests/unit_tests/api/service/test_monitoring_sessions.py @@ -453,7 +453,7 @@ async def test_live_replay_and_legacy_initialization_agree(service, order, first bot_name='Bot', pipeline_id='pipeline', pipeline_name='Pipeline', - session_id='group_42', + session_id='group_42_carol', message_content='input', event_id='covered', platform='test', @@ -466,7 +466,7 @@ async def test_live_replay_and_legacy_initialization_agree(service, order, first bot_name='Bot', pipeline_id='assistant', pipeline_name='Assistant', - session_id='group_42', + session_id='group_42_carol', message_content='output', event_id='covered', platform='test', diff --git a/tests/unit_tests/api/service/test_session_context_reset.py b/tests/unit_tests/api/service/test_session_context_reset.py index 6a5892a11b..b01c5f520d 100644 --- a/tests/unit_tests/api/service/test_session_context_reset.py +++ b/tests/unit_tests/api/service/test_session_context_reset.py @@ -195,3 +195,30 @@ async def test_signed_http_reset_uses_normal_adapter_wiring_and_clears_persisted assert (await store.page_transcript('person_peer', bot_id='b', workspace_id='w'))[0] async with engine.connect() as conn: assert (await conn.execute(sa.select(sa.func.count()).select_from(Transcript))).scalar() == 2 + + +@pytest.mark.asyncio +async def test_reset_group_per_sender_session_resets_shared_group_conversation(context_service): + service, engine = context_service + store = TranscriptStore(engine) + async with engine.begin() as conn: + await conn.execute( + sa.insert(MonitoringSession).values( + workspace_uuid='w', + bot_id='b', + session_id='group_g100_u42', + bot_name='Bot', + pipeline_id='p', + pipeline_name='Pipeline', + user_id='u42', + user_name='Alice', + start_time=datetime.datetime.utcnow(), + last_activity=datetime.datetime.utcnow(), + ) + ) + await store.append_transcript(None, 'event', 'group_g100', 'user', bot_id='b', workspace_id='w', content='old') + result = await service.reset_session_context('w', 'b', 'group_g100_u42') + assert result == {'reset': True, 'session_id': 'group_g100_u42'} + assert await get_reset_generation(engine, 'w', 'b', 'group_g100') + assert not (await store.page_transcript('group_g100', bot_id='b', workspace_id='w'))[0] + diff --git a/tests/unit_tests/pipeline/test_plugin_query_monitoring.py b/tests/unit_tests/pipeline/test_plugin_query_monitoring.py index 4b20886c3a..8e9e485abb 100644 --- a/tests/unit_tests/pipeline/test_plugin_query_monitoring.py +++ b/tests/unit_tests/pipeline/test_plugin_query_monitoring.py @@ -78,6 +78,25 @@ def test_group_query_session_id_includes_sender_id_when_present(): def test_extract_sender_name_supports_group_sender_methods_and_variables(): + from langbot_plugin.api.entities.builtin.platform import entities as platform_entities + from langbot_plugin.api.entities.builtin.platform import events as platform_events + from langbot_plugin.api.entities.builtin.platform import message as platform_message + + sdk_group_event = platform_events.GroupMessage( + sender=platform_entities.GroupMember( + id='user-42', + member_name='Alice', + permission=platform_entities.Permission.Member, + group=platform_entities.Group(id='group-100', name='Dev Group', permission=platform_entities.Permission.Member), + ), + message_chain=platform_message.MessageChain([platform_message.Plain(text='hello')]), + ) + sdk_group_query = SimpleNamespace( + message_event=sdk_group_event, + variables={}, + ) + assert MonitoringHelper._extract_sender_name(sdk_group_query) == 'Alice' + group_query = SimpleNamespace( message_event=SimpleNamespace( group=SimpleNamespace(name=' Dev Group '), @@ -85,11 +104,11 @@ def test_extract_sender_name_supports_group_sender_methods_and_variables(): ), variables={}, ) - assert MonitoringHelper._extract_sender_name(group_query) == 'Dev Group' + assert MonitoringHelper._extract_sender_name(group_query) == 'Alice' getter_query = SimpleNamespace( message_event=SimpleNamespace( - group=None, + group=SimpleNamespace(name='Ignored Group Name'), sender=SimpleNamespace(get_name=lambda: ' Getter Name ', nickname='Fallback'), ), variables={}, @@ -106,7 +125,7 @@ def test_extract_sender_name_supports_group_sender_methods_and_variables(): assert MonitoringHelper._extract_sender_name(remark_query) == 'Remark Name' var_query = SimpleNamespace( - message_event=SimpleNamespace(group=None, sender=None), + message_event=SimpleNamespace(group=SimpleNamespace(name='Only Group Name'), sender=None), variables={'sender_name': ' Lark User '}, ) assert MonitoringHelper._extract_sender_name(var_query) == 'Lark User' @@ -136,3 +155,236 @@ async def test_llm_call_from_plugin_action_query_is_recorded(): logger.error.assert_not_called() service.record_llm_call.assert_awaited_once() assert service.record_llm_call.await_args.kwargs['session_id'] == 'plugin:author/plugin' + + +@pytest.mark.asyncio +async def test_group_query_monitoring_session_id_is_consistent_across_all_writers_without_splitting_conversation(): + """A group Query must share ``group_{launcher_id}_{sender_id}`` across all monitoring writers + while keeping ``group_{launcher_id}`` for conversation_id and sessionmgr.""" + import contextvars + from sqlalchemy.ext.asyncio import create_async_engine + import sqlalchemy as sa + + from langbot.pkg.agent.runner.query_entry_adapter import QueryEntryAdapter + from langbot.pkg.api.http.context import ExecutionContext + from langbot.pkg.api.http.service.monitoring import MonitoringService + from langbot.pkg.entity.persistence.base import Base + from langbot.pkg.entity.persistence.event_log import EventLog + from langbot.pkg.entity.persistence.workspace import Workspace + from langbot.pkg.persistence.mgr import PersistenceManager + from langbot.pkg.persistence.tenant_uow import TenantUnitOfWork + from langbot.pkg.platform.botmgr import RuntimeBot + from langbot.pkg.provider.session.sessionmgr import SessionManager + from langbot.pkg.provider.tools.toolmgr import ToolManager + from langbot_plugin.api.entities.builtin.platform import entities as platform_entities + from langbot_plugin.api.entities.builtin.platform import events as platform_events + from langbot_plugin.api.entities.builtin.platform import message as platform_message + from langbot_plugin.api.entities.builtin.provider import session as provider_session + + engine = create_async_engine('sqlite+aiosqlite:///:memory:') + try: + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) + await conn.execute( + sa.insert(Workspace).values(uuid='workspace-1', instance_uuid='inst-1', name='W', slug='w') + ) + + class Persistence: + serialize_model = PersistenceManager.serialize_model + active_transaction = contextvars.ContextVar('group-session-test-tx', default=None) + + def tenant_uow(self, workspace): + return TenantUnitOfWork(engine, workspace, active_transaction=self.active_transaction) + + def get_db_engine(self): + return engine + + async def execute_async(self, statement): + async with engine.begin() as conn: + return await conn.execute(statement) + + ap = SimpleNamespace( + persistence_mgr=Persistence(), + logger=SimpleNamespace(warning=Mock(), error=Mock(), debug=Mock(), info=Mock()), + ) + monitoring_service = MonitoringService(ap) + ap.monitoring_service = monitoring_service + + exec_ctx = ExecutionContext( + instance_uuid='inst-1', + workspace_uuid='workspace-1', + placement_generation=1, + bot_uuid='bot-1', + ) + + group_event = platform_events.GroupMessage( + sender=platform_entities.GroupMember( + id='user-42', + member_name='Alice', + permission=platform_entities.Permission.Member, + group=platform_entities.Group( + id='group-100', + name='Dev Group', + permission=platform_entities.Permission.Member, + ), + ), + message_chain=platform_message.MessageChain([platform_message.Plain(text='hello group')]), + ) + + query = SimpleNamespace( + query_id=1, + launcher_type=provider_session.LauncherTypes.GROUP, + launcher_id='group-100', + sender_id='user-42', + bot_uuid='bot-1', + pipeline_uuid='pipe-1', + workspace_uuid='workspace-1', + _execution_context=exec_ctx, + message_event=group_event, + message_chain=group_event.message_chain, + resp_message_chain=[platform_message.MessageChain([platform_message.Plain(text='hi Alice')])], + session=SimpleNamespace( + launcher_type=provider_session.LauncherTypes.GROUP, + launcher_id='group-100', + using_conversation=None, + ), + variables={}, + ) + + # 1. Ingress event recorded with conversation_id = 'group_group-100' and actor_id = 'user-42' + await monitoring_service.record_ingress_event( + exec_ctx, + event_id='evt-1', + event_type='message.received', + bot_id='bot-1', + bot_name='Bot One', + platform='group', + payload={'text': 'hello group'}, + actor_id='user-42', + actor_name='Alice', + conversation_id='group_group-100', + ) + + # Verify uncovered ingress already projects to 'group_group-100_user-42' while EventLog.conversation_id stays 'group_group-100' + sessions_before, total_before = await monitoring_service.get_sessions(exec_ctx, bot_ids=['bot-1']) + assert total_before == 1 + assert sessions_before[0]['session_id'] == 'group_group-100_user-42' + assert sessions_before[0]['user_id'] == 'user-42' + assert sessions_before[0]['user_name'] == 'Alice' + + # 2. Pipeline message start + response + msg_id = await MonitoringHelper.record_query_start( + ap, + query, + bot_id='bot-1', + bot_name='Bot One', + pipeline_id='pipe-1', + pipeline_name='Main Pipeline', + runner_name='local-agent', + ) + assert msg_id is not None + await monitoring_service.link_execution_message(exec_ctx, msg_id, 'run-1', 'evt-1') + await MonitoringHelper.record_query_response( + ap, + query, + bot_id='bot-1', + bot_name='Bot One', + pipeline_id='pipe-1', + pipeline_name='Main Pipeline', + runner_name='local-agent', + ) + + # 3. LLM call recording + await MonitoringHelper.record_llm_call( + ap=ap, + query=query, + bot_id='bot-1', + bot_name='Bot One', + pipeline_id='pipe-1', + pipeline_name='Main Pipeline', + model_name='gpt-4o-mini', + input_tokens=10, + output_tokens=20, + duration_ms=150, + ) + + # 4. Tool call recording via ToolManager + tool_mgr = ToolManager(ap) + await tool_mgr._record_tool_call( + name='weather_lookup', + source='plugin:demo/weather', + parameters={'city': 'Shanghai'}, + query=query, + duration_ms=45, + status='success', + result={'temp': 22}, + ) + + # 5. Discarded message recording via RuntimeBot._record_discarded_message + dummy_bot = SimpleNamespace( + ap=ap, + execution_context=exec_ctx, + bot_entity=SimpleNamespace(uuid='bot-1', name='Bot One'), + PIPELINE_DISCARD=RuntimeBot.PIPELINE_DISCARD, + PIPELINE_DISCARD_DISPLAY_NAME=RuntimeBot.PIPELINE_DISCARD_DISPLAY_NAME, + logger=SimpleNamespace(error=AsyncMock()), + ) + await RuntimeBot._record_discarded_message( + dummy_bot, + provider_session.LauncherTypes.GROUP, + 'group-100', + 'user-42', + group_event, + group_event.message_chain, + ) + + # Verify all writers converged on the exact same monitoring session_id + sessions, total = await monitoring_service.get_sessions(exec_ctx, bot_ids=['bot-1']) + assert total == 1 + assert sessions[0]['session_id'] == 'group_group-100_user-42' + assert sessions[0]['user_name'] == 'Alice' + assert sessions[0]['message_count'] == 3 # start + response + discarded (ingress covered) + # Filter by group launcher_id returns the per-sender group session + filtered_sessions, filtered_total = await monitoring_service.get_sessions( + exec_ctx, bot_ids=['bot-1'], launcher_id='group-100' + ) + assert filtered_total == 1 + assert filtered_sessions[0]['session_id'] == 'group_group-100_user-42' + + analysis = await monitoring_service.get_session_analysis( + exec_ctx, + 'group_group-100_user-42', + bot_id='bot-1', + ) + assert analysis['found'] is True + assert analysis['message_stats']['total'] == 3 # start + response + discarded + assert analysis['llm_stats']['total_calls'] == 1 + assert analysis['tool_stats']['total_calls'] == 1 + assert len(analysis['tool_calls']) == 1 + assert analysis['tool_calls'][0]['tool_name'] == 'weather_lookup' + + messages, msg_total = await monitoring_service.get_messages( + exec_ctx, + bot_ids=['bot-1'], + session_ids=['group_group-100_user-42'], + ) + assert msg_total == 3 + user_messages = [m for m in messages if m['role'] == 'user'] + assert all(m['user_name'] == 'Alice' for m in user_messages) + + # Verify conversation_id and SessionManager key remain 'group_group-100' + conversation_ctx = QueryEntryAdapter._build_conversation_context(query) + assert conversation_ctx.conversation_id == 'group_group-100' + + session_mgr = SessionManager(ap) + assert f'{query.launcher_type.value}_{query.launcher_id}' == 'group_group-100' + assert session_mgr is not None + + async with engine.connect() as conn: + stored_conv_id = ( + await conn.execute(sa.select(EventLog.conversation_id).where(EventLog.event_id == 'evt-1')) + ).scalar_one() + assert stored_conv_id == 'group_group-100' + finally: + await engine.dispose() + diff --git a/web/src/app/infra/http/BackendClient.ts b/web/src/app/infra/http/BackendClient.ts index 2274467f39..18a1e2c661 100644 --- a/web/src/app/infra/http/BackendClient.ts +++ b/web/src/app/infra/http/BackendClient.ts @@ -893,6 +893,7 @@ export class BackendClient extends BaseHttpClient { startTime?: string; endTime?: string; userQuery?: string; + launcherId?: string; }, ): Promise<{ sessions: Array<{ @@ -924,6 +925,9 @@ export class BackendClient extends BaseHttpClient { if (options.userQuery) { queryParams.append('userQuery', options.userQuery); } + if (options.launcherId) { + queryParams.append('launcherId', options.launcherId); + } return this.get(`/api/v1/monitoring/sessions?${queryParams.toString()}`); }