Feat: bot message routing (#2100)

* refactor: pipeline routing rules - add routed_by_rule bypass and diagnostic logging

- Add routing rules editor (RoutingRulesEditor component)
- Add routed_by_rule bypass logic in response rules
- Add diagnostic logging for pipeline routing
- Database migration for bot pipeline routing rules
- Extract RoutingRulesEditor component from BotForm
- Revert log levels to debug

* feat: add message_has_element routing rule type

Support routing by message element type (Image, Voice, File, Forward,
Face, At, AtAll, Quote) with eq/neq operators.

* test: add unit tests for pipeline routing rules

20 tests covering _match_operator (eq/neq/contains/not_contains/
starts_with/regex/invalid) and resolve_pipeline_uuid (launcher_type/
launcher_id/message_content/message_has_element/first-match-wins/
skip-invalid/default-operator).

* fix(web): add missing 'message_has_element' to routing rule type validation

The Zod schema and TypeScript type for PipelineRoutingRule.type were
missing the 'message_has_element' variant, causing silent form validation
failure when saving routing rules with this type.

* feat: add pipeline discard functionality and localization support

* feat(web): improve drag-and-drop with DragOverlay, add discard monitoring and pipeline icons

- Add DragOverlay for smooth cursor-following drag in routing rules editor
- Remove transition to eliminate redundant swap animation on drop
- Record discarded messages in monitoring system via _record_discarded_message
- Display pipeline name (Workflow icon) and runner name (Play icon) on session monitor messages
- Show discard badge on discarded messages in session monitor
- Add i18n translations for discarded/userMessage/botMessage

* fix: ensure discarded messages appear in session monitor and improve icons

- Create/update monitoring session for discarded messages so they show in
  the bot session monitor (was only inserting message rows, not sessions)
- Use human-readable 'Discarded' as pipeline_name instead of '__discard__'
- Change runner icon from Play to Bot for better AI Agent semantics

* fix: merge discarded messages into same session and remove session-level pipeline name

- Use LauncherTypes enum for session_id in discarded messages to match
  the format used by monitoring_helper (fixes duplicate sessions)
- Don't overwrite session pipeline info on discard — a session can have
  messages from multiple pipelines
- Remove pipeline_name from session list and chat header since it's
  now shown per-message and a session is no longer single-pipeline

* fix(web): only show save button on config tab in bot detail page

* fix(web): scroll to bottom after messages render in session monitor

---------

Co-authored-by: RockChinQ <rockchinq@gmail.com>

web/src/app/home/bots/BotDetailContent.tsx

@@ -174,9 +174,11 @@ export default function BotDetailContent({ id }: { id: string }) {
               </div>
             )}
           </div>
-          <Button type="submit" form="bot-form" disabled={!formDirty}>
-            {t('common.save')}
-          </Button>
+          {activeTab === 'config' && (
+            <Button type="submit" form="bot-form" disabled={!formDirty}>
+              {t('common.save')}
+            </Button>
+          )}
         </div>
 
         {/* Horizontal Tabs */}

web/src/app/home/bots/components/bot-form/BotForm.tsx

@@ -16,6 +16,7 @@ import { httpClient } from '@/app/infra/http/HttpClient';
 import { Bot } from '@/app/infra/entities/api';
 import { getAdapterDocUrl } from '@/app/infra/entities/adapter-docs';
 import { ExternalLink } from 'lucide-react';
+import RoutingRulesEditor from './RoutingRulesEditor';
 
 import { zodResolver } from '@hookform/resolvers/zod';
 import { useForm } from 'react-hook-form';
@@ -64,6 +65,28 @@ const getFormSchema = (t: (key: string) => string) =>
     adapter_config: z.record(z.string(), z.any()),
     enable: z.boolean().optional(),
     use_pipeline_uuid: z.string().optional(),
+    pipeline_routing_rules: z
+      .array(
+        z.object({
+          type: z.enum([
+            'launcher_type',
+            'launcher_id',
+            'message_content',
+            'message_has_element',
+          ]),
+          operator: z.enum([
+            'eq',
+            'neq',
+            'contains',
+            'not_contains',
+            'starts_with',
+            'regex',
+          ]),
+          value: z.string(),
+          pipeline_uuid: z.string(),
+        }),
+      )
+      .optional(),
   });
 
 export default function BotForm({
@@ -89,6 +112,7 @@ export default function BotForm({
       adapter_config: {},
       enable: true,
       use_pipeline_uuid: '',
+      pipeline_routing_rules: [],
     },
   });
 
@@ -155,6 +179,7 @@ export default function BotForm({
               adapter_config: val.adapter_config,
               enable: val.enable,
               use_pipeline_uuid: val.use_pipeline_uuid || '',
+              pipeline_routing_rules: val.pipeline_routing_rules || [],
             });
             handleAdapterSelect(val.adapter);
 
@@ -270,6 +295,7 @@ export default function BotForm({
             adapter_config: bot.adapter_config,
             enable: bot.enable ?? true,
             use_pipeline_uuid: bot.use_pipeline_uuid ?? '',
+            pipeline_routing_rules: bot.pipeline_routing_rules ?? [],
             webhook_full_url: runtimeValues?.webhook_full_url as
               | string
               | undefined,
@@ -314,6 +340,7 @@ export default function BotForm({
         adapter_config: form.getValues().adapter_config,
         enable: form.getValues().enable,
         use_pipeline_uuid: form.getValues().use_pipeline_uuid,
+        pipeline_routing_rules: form.getValues().pipeline_routing_rules ?? [],
       };
       httpClient
         .updateBot(initBotId, updateBot)
@@ -464,6 +491,12 @@ export default function BotForm({
                   </FormItem>
                 )}
               />
+
+              {/* Pipeline Routing Rules */}
+              <RoutingRulesEditor
+                form={form}
+                pipelineNameList={pipelineNameList}
+              />
             </CardContent>
           </Card>
         )}

web/src/app/home/bots/components/bot-form/RoutingRulesEditor.tsx

@@ -0,0 +1,480 @@
+'use client';
+
+import { useTranslation } from 'react-i18next';
+import { UseFormReturn } from 'react-hook-form';
+import {
+  PipelineRoutingRule,
+  RoutingRuleOperator,
+} from '@/app/infra/entities/api';
+import { Ban, GripVertical, Plus, Trash2 } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { FormLabel } from '@/components/ui/form';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import {
+  DndContext,
+  DragOverlay,
+  closestCenter,
+  PointerSensor,
+  KeyboardSensor,
+  useSensor,
+  useSensors,
+  DragEndEvent,
+  DragStartEvent,
+} from '@dnd-kit/core';
+import {
+  arrayMove,
+  SortableContext,
+  sortableKeyboardCoordinates,
+  useSortable,
+  verticalListSortingStrategy,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { useRef, useMemo, useState } from 'react';
+
+export const PIPELINE_DISCARD = '__discard__';
+
+interface PipelineOption {
+  value: string;
+  label: string;
+  emoji?: string;
+}
+
+interface RoutingRulesEditorProps {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  form: UseFormReturn<any>;
+  pipelineNameList: PipelineOption[];
+}
+
+const OPERATORS_BY_TYPE: Record<
+  PipelineRoutingRule['type'],
+  { value: RoutingRuleOperator; labelKey: string }[]
+> = {
+  launcher_type: [
+    { value: 'eq', labelKey: 'bots.operatorEq' },
+    { value: 'neq', labelKey: 'bots.operatorNeq' },
+  ],
+  launcher_id: [
+    { value: 'eq', labelKey: 'bots.operatorEq' },
+    { value: 'neq', labelKey: 'bots.operatorNeq' },
+    { value: 'contains', labelKey: 'bots.operatorContains' },
+    { value: 'not_contains', labelKey: 'bots.operatorNotContains' },
+    { value: 'regex', labelKey: 'bots.operatorRegex' },
+  ],
+  message_content: [
+    { value: 'eq', labelKey: 'bots.operatorEq' },
+    { value: 'neq', labelKey: 'bots.operatorNeq' },
+    { value: 'contains', labelKey: 'bots.operatorContains' },
+    { value: 'not_contains', labelKey: 'bots.operatorNotContains' },
+    { value: 'starts_with', labelKey: 'bots.operatorStartsWith' },
+    { value: 'regex', labelKey: 'bots.operatorRegex' },
+  ],
+  message_has_element: [
+    { value: 'eq', labelKey: 'bots.operatorHas' },
+    { value: 'neq', labelKey: 'bots.operatorNotHas' },
+  ],
+};
+
+function getValuePlaceholder(
+  t: (key: string) => string,
+  rule: PipelineRoutingRule,
+): string {
+  if (rule.type === 'launcher_id')
+    return t('bots.ruleValueLauncherIdPlaceholder');
+  if (rule.type === 'message_has_element')
+    return t('bots.ruleValueElementPlaceholder');
+  if (rule.operator === 'regex') return t('bots.ruleValueRegexpPlaceholder');
+  return t('bots.ruleValueMessagePlaceholder');
+}
+
+/* ── Static rule row (used in DragOverlay) ─────────────────────────── */
+
+interface RuleRowContentProps {
+  rule: PipelineRoutingRule;
+  index: number;
+  pipelineNameList: PipelineOption[];
+  updateRule: (index: number, patch: Partial<PipelineRoutingRule>) => void;
+  removeRule: (index: number) => void;
+  dragHandleProps?: Record<string, unknown>;
+  isOverlay?: boolean;
+}
+
+function RuleRowContent({
+  rule,
+  index,
+  pipelineNameList,
+  updateRule,
+  removeRule,
+  dragHandleProps,
+  isOverlay,
+}: RuleRowContentProps) {
+  const { t } = useTranslation();
+  const operatorsForType =
+    OPERATORS_BY_TYPE[rule.type] || OPERATORS_BY_TYPE.message_content;
+  const isDiscard = rule.pipeline_uuid === PIPELINE_DISCARD;
+
+  return (
+    <div
+      className={`flex items-center gap-2 mt-2 p-3 border rounded-md bg-muted/30 ${
+        isOverlay ? 'shadow-lg ring-2 ring-primary/20 bg-background' : ''
+      }`}
+    >
+      {/* Drag handle */}
+      <button
+        type="button"
+        className="cursor-grab active:cursor-grabbing shrink-0 text-muted-foreground hover:text-foreground touch-none"
+        {...dragHandleProps}
+      >
+        <GripVertical className="h-4 w-4" />
+      </button>
+
+      {/* Field selector */}
+      <Select
+        value={rule.type}
+        onValueChange={(val) => {
+          updateRule(index, {
+            type: val as PipelineRoutingRule['type'],
+            operator: 'eq',
+            value: '',
+          });
+        }}
+      >
+        <SelectTrigger className="w-[130px]">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="launcher_type">
+            {t('bots.ruleTypeLauncherType')}
+          </SelectItem>
+          <SelectItem value="launcher_id">
+            {t('bots.ruleTypeLauncherId')}
+          </SelectItem>
+          <SelectItem value="message_content">
+            {t('bots.ruleTypeMessageContent')}
+          </SelectItem>
+          <SelectItem value="message_has_element">
+            {t('bots.ruleTypeMessageHasElement')}
+          </SelectItem>
+        </SelectContent>
+      </Select>
+
+      {/* Operator selector */}
+      <Select
+        value={rule.operator || 'eq'}
+        onValueChange={(val) => {
+          updateRule(index, { operator: val as RoutingRuleOperator });
+        }}
+      >
+        <SelectTrigger className="w-[120px]">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          {operatorsForType.map((op) => (
+            <SelectItem key={op.value} value={op.value}>
+              {t(op.labelKey)}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+
+      {/* Value input */}
+      {rule.type === 'launcher_type' ? (
+        <Select
+          value={rule.value}
+          onValueChange={(val) => updateRule(index, { value: val })}
+        >
+          <SelectTrigger className="w-[100px]">
+            <SelectValue placeholder={t('bots.ruleValuePlaceholder')} />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value="person">
+              {t('bots.sessionTypePerson')}
+            </SelectItem>
+            <SelectItem value="group">{t('bots.sessionTypeGroup')}</SelectItem>
+          </SelectContent>
+        </Select>
+      ) : rule.type === 'message_has_element' ? (
+        <Select
+          value={rule.value}
+          onValueChange={(val) => updateRule(index, { value: val })}
+        >
+          <SelectTrigger className="w-[120px]">
+            <SelectValue placeholder={t('bots.ruleValueElementPlaceholder')} />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value="Image">{t('bots.elementImage')}</SelectItem>
+            <SelectItem value="Voice">{t('bots.elementVoice')}</SelectItem>
+            <SelectItem value="File">{t('bots.elementFile')}</SelectItem>
+            <SelectItem value="Forward">{t('bots.elementForward')}</SelectItem>
+            <SelectItem value="Face">{t('bots.elementFace')}</SelectItem>
+            <SelectItem value="At">{t('bots.elementAt')}</SelectItem>
+            <SelectItem value="AtAll">{t('bots.elementAtAll')}</SelectItem>
+            <SelectItem value="Quote">{t('bots.elementQuote')}</SelectItem>
+          </SelectContent>
+        </Select>
+      ) : (
+        <Input
+          className="flex-1"
+          placeholder={getValuePlaceholder(t, rule)}
+          value={rule.value}
+          onChange={(e) => updateRule(index, { value: e.target.value })}
+        />
+      )}
+
+      <span className="text-sm text-muted-foreground shrink-0">→</span>
+
+      {/* Pipeline selector */}
+      <Select
+        value={rule.pipeline_uuid}
+        onValueChange={(val) => updateRule(index, { pipeline_uuid: val })}
+      >
+        <SelectTrigger className="w-[200px]">
+          {rule.pipeline_uuid ? (
+            isDiscard ? (
+              <div className="flex items-center gap-2 text-destructive">
+                <Ban className="h-3.5 w-3.5 shrink-0" />
+                <span>{t('bots.pipelineDiscard')}</span>
+              </div>
+            ) : (
+              (() => {
+                const p = pipelineNameList.find(
+                  (p) => p.value === rule.pipeline_uuid,
+                );
+                return (
+                  <div className="flex items-center gap-2">
+                    {p?.emoji && (
+                      <span className="text-sm shrink-0">{p.emoji}</span>
+                    )}
+                    <span>{p?.label ?? rule.pipeline_uuid}</span>
+                  </div>
+                );
+              })()
+            )
+          ) : (
+            <SelectValue placeholder={t('bots.selectPipeline')} />
+          )}
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value={PIPELINE_DISCARD}>
+            <div className="flex items-center gap-2 text-destructive">
+              <Ban className="h-3.5 w-3.5 shrink-0" />
+              <span>{t('bots.pipelineDiscard')}</span>
+            </div>
+          </SelectItem>
+          <SelectSeparator />
+          {pipelineNameList.map((item) => (
+            <SelectItem key={item.value} value={item.value}>
+              <div className="flex items-center gap-2">
+                {item.emoji && (
+                  <span className="text-sm shrink-0">{item.emoji}</span>
+                )}
+                <span>{item.label}</span>
+              </div>
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+
+      <Button
+        type="button"
+        variant="ghost"
+        size="icon"
+        className="shrink-0"
+        onClick={() => removeRule(index)}
+      >
+        <Trash2 className="h-4 w-4 text-destructive" />
+      </Button>
+    </div>
+  );
+}
+
+/* ── Sortable rule row ─────────────────────────────────────────────── */
+
+interface SortableRuleRowProps {
+  id: string;
+  rule: PipelineRoutingRule;
+  index: number;
+  pipelineNameList: PipelineOption[];
+  updateRule: (index: number, patch: Partial<PipelineRoutingRule>) => void;
+  removeRule: (index: number) => void;
+}
+
+function SortableRuleRow({
+  id,
+  rule,
+  index,
+  pipelineNameList,
+  updateRule,
+  removeRule,
+}: SortableRuleRowProps) {
+  const { attributes, listeners, setNodeRef, transform, isDragging } =
+    useSortable({ id });
+
+  const style = {
+    transform: CSS.Transform.toString(transform),
+    // No transition — items reorder visually during drag via transform;
+    // on drop the data updates and transform resets, so animating would
+    // cause a redundant "swap" flicker.
+    opacity: isDragging ? 0.3 : undefined,
+  };
+
+  return (
+    <div ref={setNodeRef} style={style}>
+      <RuleRowContent
+        rule={rule}
+        index={index}
+        pipelineNameList={pipelineNameList}
+        updateRule={updateRule}
+        removeRule={removeRule}
+        dragHandleProps={{ ...attributes, ...listeners }}
+      />
+    </div>
+  );
+}
+
+/* ── Main editor ───────────────────────────────────────────────────── */
+
+export default function RoutingRulesEditor({
+  form,
+  pipelineNameList,
+}: RoutingRulesEditorProps) {
+  const { t } = useTranslation();
+  const [activeId, setActiveId] = useState<string | null>(null);
+
+  const rules: PipelineRoutingRule[] =
+    form.watch('pipeline_routing_rules') || [];
+
+  // Stable unique ids for sortable items.
+  // We keep a running counter so newly added rules always get fresh ids.
+  const nextId = useRef(0);
+  const idsRef = useRef<string[]>([]);
+
+  const sortableIds = useMemo(() => {
+    // Grow the id list to match rules length (newly added items get new ids).
+    while (idsRef.current.length < rules.length) {
+      idsRef.current.push(`rule-${nextId.current++}`);
+    }
+    // Shrink if rules were removed from the end.
+    if (idsRef.current.length > rules.length) {
+      idsRef.current = idsRef.current.slice(0, rules.length);
+    }
+    return idsRef.current;
+  }, [rules.length]);
+
+  const updateRules = (newRules: PipelineRoutingRule[]) => {
+    form.setValue('pipeline_routing_rules', newRules, { shouldDirty: true });
+  };
+
+  const addRule = () => {
+    updateRules([
+      ...rules,
+      {
+        type: 'launcher_type',
+        operator: 'eq',
+        value: '',
+        pipeline_uuid: '',
+      },
+    ]);
+  };
+
+  const updateRule = (index: number, patch: Partial<PipelineRoutingRule>) => {
+    const updated = [...rules];
+    updated[index] = { ...updated[index], ...patch };
+    updateRules(updated);
+  };
+
+  const removeRule = (index: number) => {
+    const updated = [...rules];
+    updated.splice(index, 1);
+    // Also remove the corresponding sortable id so indices stay in sync.
+    idsRef.current.splice(index, 1);
+    updateRules(updated);
+  };
+
+  const sensors = useSensors(
+    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
+    useSensor(KeyboardSensor, {
+      coordinateGetter: sortableKeyboardCoordinates,
+    }),
+  );
+
+  const handleDragStart = (event: DragStartEvent) => {
+    setActiveId(event.active.id as string);
+  };
+
+  const handleDragEnd = (event: DragEndEvent) => {
+    setActiveId(null);
+    const { active, over } = event;
+    if (!over || active.id === over.id) return;
+
+    const oldIndex = sortableIds.indexOf(active.id as string);
+    const newIndex = sortableIds.indexOf(over.id as string);
+    if (oldIndex === -1 || newIndex === -1) return;
+
+    idsRef.current = arrayMove(idsRef.current, oldIndex, newIndex);
+    updateRules(arrayMove(rules, oldIndex, newIndex));
+  };
+
+  const activeIndex = activeId ? sortableIds.indexOf(activeId) : -1;
+  const activeRule = activeIndex >= 0 ? rules[activeIndex] : null;
+
+  return (
+    <div className="mt-6">
+      <div className="flex items-center justify-between mb-2">
+        <div>
+          <FormLabel>{t('bots.routingRules')}</FormLabel>
+          <p className="text-sm text-muted-foreground mt-1">
+            {t('bots.routingRulesDescription')}
+          </p>
+        </div>
+        <Button type="button" variant="outline" size="sm" onClick={addRule}>
+          <Plus className="h-4 w-4 mr-1" />
+          {t('bots.addRoutingRule')}
+        </Button>
+      </div>
+
+      <DndContext
+        sensors={sensors}
+        collisionDetection={closestCenter}
+        onDragStart={handleDragStart}
+        onDragEnd={handleDragEnd}
+      >
+        <SortableContext
+          items={sortableIds}
+          strategy={verticalListSortingStrategy}
+        >
+          {rules.map((rule, index) => (
+            <SortableRuleRow
+              key={sortableIds[index]}
+              id={sortableIds[index]}
+              rule={rule}
+              index={index}
+              pipelineNameList={pipelineNameList}
+              updateRule={updateRule}
+              removeRule={removeRule}
+            />
+          ))}
+        </SortableContext>
+        <DragOverlay dropAnimation={null}>
+          {activeRule ? (
+            <RuleRowContent
+              rule={activeRule}
+              index={activeIndex}
+              pipelineNameList={pipelineNameList}
+              updateRule={updateRule}
+              removeRule={removeRule}
+              isOverlay
+            />
+          ) : null}
+        </DragOverlay>
+      </DndContext>
+    </div>
+  );
+}

web/src/app/home/bots/components/bot-session/BotSessionMonitor.tsx

@@ -10,7 +10,7 @@ import { useTranslation } from 'react-i18next';
 import { httpClient } from '@/app/infra/http/HttpClient';
 import { ScrollArea } from '@/components/ui/scroll-area';
 import { cn } from '@/lib/utils';
-import { Copy, Check } from 'lucide-react';
+import { Ban, Bot, Copy, Check, Workflow } from 'lucide-react';
 import {
   MessageChainComponent,
   Plain,
@@ -19,6 +19,7 @@ import {
   Quote,
   Voice,
 } from '@/app/infra/entities/message';
+import { PIPELINE_DISCARD } from '@/app/home/bots/components/bot-form/RoutingRulesEditor';
 
 interface SessionInfo {
   session_id: string;
@@ -145,14 +146,18 @@ const BotSessionMonitor = forwardRef<
   }, [selectedSessionId, loadMessages]);
 
   useEffect(() => {
-    const container = messagesContainerRef.current;
-    if (container) {
-      const viewport = container.querySelector(
-        '[data-radix-scroll-area-viewport]',
-      );
-      const scrollTarget = viewport || container;
-      scrollTarget.scrollTop = scrollTarget.scrollHeight;
-    }
+    if (messages.length === 0) return;
+    // Wait for DOM to render the new messages before scrolling
+    requestAnimationFrame(() => {
+      const container = messagesContainerRef.current;
+      if (container) {
+        const viewport = container.querySelector(
+          '[data-radix-scroll-area-viewport]',
+        );
+        const scrollTarget = viewport || container;
+        scrollTarget.scrollTop = scrollTarget.scrollHeight;
+      }
+    });
   }, [messages]);
 
   const parseMessageChain = (content: string): MessageChainComponent[] => {
@@ -391,7 +396,6 @@ const BotSessionMonitor = forwardRef<
                           <span className="w-1.5 h-1.5 rounded-full bg-green-500 inline-block" />
                         </span>
                       )}
-                      <span className="truncate">{session.pipeline_name}</span>
                     </div>
                   </button>
                 );
@@ -447,12 +451,6 @@ const BotSessionMonitor = forwardRef<
                       </button>
                     </>
                   )}
-                  {selectedSession?.pipeline_name && (
-                    <>
-                      <span>·</span>
-                      <span>{selectedSession.pipeline_name}</span>
-                    </>
-                  )}
                   {selectedSession?.is_active && (
                     <>
                       <span>·</span>
@@ -483,6 +481,9 @@ const BotSessionMonitor = forwardRef<
                 ) : (
                   messages.map((msg) => {
                     const isUser = isUserMessage(msg);
+                    const isDiscarded =
+                      msg.status === 'discarded' ||
+                      msg.pipeline_id === PIPELINE_DISCARD;
                     return (
                       <div
                         key={msg.id}
@@ -498,10 +499,11 @@ const BotSessionMonitor = forwardRef<
                               ? 'bg-primary/10 rounded-br-sm'
                               : 'bg-muted rounded-bl-sm',
                             msg.status === 'error' && 'ring-1 ring-red-400/50',
+                            isDiscarded && 'opacity-60',
                           )}
                         >
                           {renderMessageContent(msg)}
-                          {/* Role label + timestamp */}
+                          {/* Role label + pipeline + timestamp */}
                           <div
                             className={cn(
                               'text-[11px] mt-1.5 flex items-center gap-1.5 text-muted-foreground',
@@ -519,11 +521,25 @@ const BotSessionMonitor = forwardRef<
                             <span className="tabular-nums">
                               {formatTime(msg.timestamp)}
                             </span>
+                            {isDiscarded ? (
+                              <span className="inline-flex items-center gap-0.5 text-destructive">
+                                <Ban className="w-3 h-3" />
+                                {t('bots.sessionMonitor.discarded', {
+                                  defaultValue: 'Discarded',
+                                })}
+                              </span>
+                            ) : msg.pipeline_name ? (
+                              <span className="inline-flex items-center gap-0.5 opacity-70">
+                                <Workflow className="w-3 h-3" />
+                                {msg.pipeline_name}
+                              </span>
+                            ) : null}
                             {msg.status === 'error' && (
                               <span className="text-red-500">error</span>
                             )}
                             {msg.runner_name && (
-                              <span className="opacity-70">
+                              <span className="inline-flex items-center gap-0.5 opacity-70">
+                                <Bot className="w-3 h-3" />
                                 {msg.runner_name}
                               </span>
                             )}

web/src/app/infra/entities/api/index.ts

@@ -140,11 +140,31 @@ export interface Bot {
   adapter_config: object;
   use_pipeline_name?: string;
   use_pipeline_uuid?: string;
+  pipeline_routing_rules?: PipelineRoutingRule[];
   created_at?: string;
   updated_at?: string;
   adapter_runtime_values?: object;
 }
 
+export type RoutingRuleOperator =
+  | 'eq'
+  | 'neq'
+  | 'contains'
+  | 'not_contains'
+  | 'starts_with'
+  | 'regex';
+
+export interface PipelineRoutingRule {
+  type:
+    | 'launcher_type'
+    | 'launcher_id'
+    | 'message_content'
+    | 'message_has_element';
+  operator: RoutingRuleOperator;
+  value: string;
+  pipeline_uuid: string;
+}
+
 export interface ApiRespKnowledgeBases {
   bases: KnowledgeBase[];
 }