@alia.onl/sdk 15.8.0 → 19.0.0

package/src/runtime/thread/agent-activity.ts

@@ -0,0 +1,261 @@
+/**
+ * What an agent's run is doing, as data: the events it emits, and the state they add up to.
+ *
+ * Pure. `use-agent-activity.ts` subscribes to the run and feeds `applyActivityEvent` with what
+ * arrives; `hydrateActivity` seeds the state from what the run had already done when the screen
+ * opened. Both the live card in the thread and a task's timeline read the result.
+ */
+
+export interface PlanItem {
+  id: number;
+  text: string;
+  status: string;
+}
+
+export interface PlanProgress {
+  items: PlanItem[];
+  completed: number;
+  total: number;
+}
+
+export type AgentActivityEventType =
+  | 'system'
+  | 'thinking'
+  | 'response'
+  | 'tool_call'
+  | 'tool_result'
+  | 'error'
+  | 'complete'
+  | 'screenshot'
+  | 'plan_progress'
+  | 'file_change'
+  | 'source_found'
+  | 'threat';
+
+export interface AgentActivityEvent {
+  type: AgentActivityEventType;
+  content: string;
+  timestamp: number;
+  sessionId: string;
+  agentId?: string;
+  metadata?: {
+    toolName?: string;
+    /** What the tool was called with; the browser tool's `action`, `url` and `query`, a plan's `action`, a delegate's `agent`. */
+    args?: {
+      action?: string;
+      url?: string;
+      query?: string;
+      agent?: string;
+      [key: string]: unknown;
+    };
+    duration?: number;
+    url?: string;
+    title?: string;
+    domain?: string;
+  };
+  data?: {
+    url?: string;
+    plan?: PlanProgress;
+    currentStep?: number;
+    maxSteps?: number;
+  };
+}
+
+export interface AgentSource {
+  url: string;
+  title: string;
+  domain: string;
+  snippet: string;
+  timestamp: number;
+}
+
+export interface AgentActivityState {
+  /** Current plan with checklist items */
+  plan: PlanProgress | null;
+  /** Current action being executed */
+  currentAction: { toolName: string; content: string } | null;
+  /** Whether the agent has completed */
+  isComplete: boolean;
+  /** Whether there's an error */
+  hasError: boolean;
+  /** Last error message */
+  lastError: string | null;
+  /** Total events received */
+  eventCount: number;
+  /** All activity events (last 50) */
+  events: AgentActivityEvent[];
+  /** Start time of first event */
+  startedAt: number | null;
+  /** Sources found during browsing */
+  sources: AgentSource[];
+  /** Latest text response from agent */
+  latestResponse: string | null;
+  /** Total credits charged for this session (present once the run settles) */
+  creditsCharged?: number;
+}
+
+export const INITIAL_ACTIVITY: AgentActivityState = {
+  plan: null,
+  currentAction: null,
+  isComplete: false,
+  hasError: false,
+  lastError: null,
+  eventCount: 0,
+  events: [],
+  startedAt: null,
+  sources: [],
+  latestResponse: null,
+};
+
+/** How many events the state keeps. */
+export const MAX_ACTIVITY_EVENTS = 50;
+
+/** Add one event to the run's state. */
+export function applyActivityEvent(
+  prev: AgentActivityState,
+  event: AgentActivityEvent,
+): AgentActivityState {
+  const next: AgentActivityState = {
+    ...prev,
+    eventCount: prev.eventCount + 1,
+    events: [...prev.events.slice(-(MAX_ACTIVITY_EVENTS - 1)), event],
+    startedAt: prev.startedAt ?? event.timestamp,
+  };
+
+  switch (event.type) {
+    case 'plan_progress':
+      if (event.data?.plan) next.plan = event.data.plan;
+      break;
+
+    case 'tool_call':
+      next.currentAction = {
+        toolName: event.metadata?.toolName || 'action',
+        content: event.content,
+      };
+      break;
+
+    case 'tool_result':
+      next.currentAction = null;
+      break;
+
+    case 'error':
+      next.hasError = true;
+      next.lastError = event.content;
+      next.currentAction = null;
+      break;
+
+    case 'complete':
+      next.isComplete = true;
+      next.currentAction = null;
+      next.latestResponse = null;
+      break;
+
+    case 'source_found': {
+      const url = event.metadata?.url;
+      if (url && !prev.sources.some((source) => source.url === url)) {
+        next.sources = [
+          ...prev.sources,
+          {
+            url,
+            title: event.metadata?.title || '',
+            domain: event.metadata?.domain || new URL(url).hostname,
+            snippet: event.content?.slice(0, 200) || '',
+            timestamp: event.timestamp,
+          },
+        ];
+      }
+      break;
+    }
+
+    case 'response':
+      next.latestResponse = event.content;
+      break;
+  }
+
+  return next;
+}
+
+/** An event as the session-status route stores it. */
+interface PersistedAgentEvent {
+  type: string;
+  content: string;
+  timestamp: number;
+  metadata?: AgentActivityEvent['metadata'];
+}
+
+/** What `GET` on a session's status answers. */
+export interface AgentSessionStatus {
+  recentEvents?: PersistedAgentEvent[];
+  session?: {
+    plan?: { items?: PlanItem[] };
+    status?: string;
+    result?: string;
+    stats?: { creditsCharged?: number };
+  };
+}
+
+function eventTypeOf(type: string): AgentActivityEventType {
+  switch (type) {
+    case 'action':
+      return 'tool_call';
+    case 'observation':
+      return 'tool_result';
+    case 'threat_detected':
+      return 'threat';
+    case 'thinking':
+    case 'response':
+    case 'error':
+    case 'complete':
+    case 'screenshot':
+    case 'plan_progress':
+    case 'file_change':
+    case 'source_found':
+      return type;
+    // `user_message`, `system_message`, `plan_update` and anything newer.
+    default:
+      return 'system';
+  }
+}
+
+/** Seed the state with what the run had done before this screen subscribed to it. */
+export function hydrateActivity(
+  prev: AgentActivityState,
+  status: AgentSessionStatus,
+  sessionId: string,
+): AgentActivityState {
+  const events = (Array.isArray(status.recentEvents) ? status.recentEvents : [])
+    .map(
+      (entry): AgentActivityEvent => ({
+        type: eventTypeOf(entry.type),
+        content: entry.content,
+        timestamp: entry.timestamp,
+        sessionId,
+        metadata: entry.metadata,
+      }),
+    )
+    .slice(-MAX_ACTIVITY_EVENTS);
+  const session = status.session;
+  const planItems = Array.isArray(session?.plan?.items) ? session.plan.items : [];
+  const failed = session?.status === 'failed';
+  const credits = session?.stats?.creditsCharged;
+
+  return {
+    ...prev,
+    events,
+    eventCount: events.length,
+    startedAt: events[0]?.timestamp || prev.startedAt,
+    plan:
+      planItems.length > 0
+        ? {
+            items: planItems,
+            completed: planItems.filter((item) => item.status === 'completed').length,
+            total: planItems.length,
+          }
+        : prev.plan,
+    isComplete: session?.status === 'completed' || session?.status === 'cancelled',
+    hasError: failed,
+    lastError: failed ? session?.result || prev.lastError : prev.lastError,
+    latestResponse: session?.result || prev.latestResponse,
+    creditsCharged: typeof credits === 'number' ? credits : prev.creditsCharged,
+  };
+}

package/src/runtime/thread/automation-labels.ts

@@ -0,0 +1,79 @@
+import type { Translate } from '../../lib/copy';
+import type { AutomationTrigger } from '../types';
+
+/**
+ * A scheduled task's trigger as words.
+ *
+ * Drawn by the thread's scheduled-task card, and by every host that lists the person's tasks, so
+ * the words live beside the type rather than in either. Pure: the translator is a parameter.
+ */
+
+function cronDayList(field: string): number[] | null {
+  const days: number[] = [];
+  for (const part of field.split(',')) {
+    const range = part.match(/^(\d)(?:-(\d))?$/);
+    if (!range) return null;
+    const from = Number(range[1]);
+    const to = range[2] === undefined ? from : Number(range[2]);
+    if (from > 6 || to > 6 || to < from) return null;
+    for (let day = from; day <= to; day += 1) days.push(day);
+  }
+  // Cron accepts 7 for Sunday in some dialects; the scheduler here writes 0.
+  const unique = [...new Set(days)].sort((a, b) => a - b);
+  return unique.length > 0 ? unique : null;
+}
+
+/**
+ * A cron expression as a sentence, for the shapes the app itself writes.
+ *
+ * `scheduleToCron` on the API produces exactly three forms from the create
+ * dialog — `*\/N * * * *` for an interval, `M H * * *` for every day and
+ * `M H * * 1,3,5` for chosen days — and those are what a person expects to
+ * read back as "Every hour" or "Mondays at 09:00", not as five fields (#537).
+ * Anything else (a hand-written structured schedule) is returned verbatim
+ * rather than guessed at: a wrong sentence is worse than a cron string.
+ */
+export function cronLabel(cron: string, t: Translate): string {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) return cron;
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = fields as [
+    string,
+    string,
+    string,
+    string,
+    string,
+  ];
+  if (dayOfMonth !== '*' || month !== '*') return cron;
+
+  const interval = minute.match(/^\*\/(\d+)$/);
+  if (interval && hour === '*' && dayOfWeek === '*') {
+    const minutes = Number(interval[1]);
+    if (minutes === 60) return t('automations.cron.everyHour');
+    if (minutes > 60 && minutes % 60 === 0)
+      return t('automations.cron.everyHours', { count: minutes / 60 });
+    return t('automations.cron.everyMinutes', { count: minutes });
+  }
+
+  if (!/^\d{1,2}$/.test(minute) || !/^\d{1,2}$/.test(hour)) return cron;
+  if (Number(minute) > 59 || Number(hour) > 23) return cron;
+  const time = `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;
+  if (dayOfWeek === '*') return t('automations.cron.dailyAt', { time });
+  const days = cronDayList(dayOfWeek);
+  if (!days) return cron;
+  if (days.length === 7) return t('automations.cron.dailyAt', { time });
+  if (days.length === 5 && days.every((day, index) => day === index + 1)) {
+    return t('automations.cron.weekdaysAt', { time });
+  }
+  if (days.length === 2 && days[0] === 0 && days[1] === 6)
+    return t('automations.cron.weekendsAt', { time });
+  const names = days.map((day) => t(`automations.cron.dayPlural.${day}`));
+  return t('automations.cron.daysAt', { days: names.join(', '), time });
+}
+
+export function triggerLabel(trigger: AutomationTrigger, t: Translate): string {
+  if (trigger.type === 'manual') return t('automations.trigger.manual');
+  if (trigger.type === 'event') {
+    return `${trigger.appId ?? t('automations.trigger.anyApp')} · ${trigger.eventType ?? t('automations.trigger.anyEvent')}`;
+  }
+  return `${trigger.cron ? cronLabel(trigger.cron, t) : t('automations.trigger.unscheduled')} · ${trigger.timezone ?? 'UTC'}`;
+}

package/src/runtime/thread/conversation-export.ts

@@ -0,0 +1,135 @@
+import type { Message } from '../types';
+import { extractSources } from './thought-utils';
+
+/**
+ * A conversation as a Markdown document.
+ *
+ * Pure, and deliberately so: the header's menu item is the only thing that
+ * asks for this, and what it hands over is the same `messages` array the
+ * screen is streaming into. Everything about DELIVERY — a download on web, the
+ * share sheet on a phone — lives in `conversation-share.ts`, so this module can
+ * be tested against a string and nothing else.
+ *
+ * ## What is kept and what is left out
+ *
+ *  - Roles, as headings. The person is `## You` (or the translation handed in)
+ *    and the answer is `## Alia`, or the agent's own name when the thread is
+ *    with one, or the delegated agent's name on a turn that came from one.
+ *  - The text, verbatim. An answer is already Markdown — fenced code blocks,
+ *    lists, tables — so it is pasted as it is rather than re-rendered, which is
+ *    what makes a code block survive the round trip.
+ *  - Images, as image links. A multi-part user turn carries them as
+ *    `image_url` parts, and Markdown has a spelling for exactly that.
+ *  - Sources, as a list of links under the answer that used them. They are
+ *    read out of `toolInvocations` — the same jsonb the message is stored with
+ *    — by the same `extractSources` the thread shows them from, so the export
+ *    cites what the screen cites.
+ *  - Thinking is OMITTED. It is the model's scratchpad, shown in a side panel
+ *    on request; a document of the conversation is a document of what was
+ *    said.
+ *  - `system` turns are omitted too: they are not part of the exchange.
+ */
+export interface ConversationExportOptions {
+  /** The conversation's title, as the document's heading. */
+  title: string;
+  messages: readonly Message[];
+  /** When the document was made — the header states it. */
+  exportedAt: Date;
+  /** The name Alia answers under here; the heading for assistant turns. */
+  assistantName?: string;
+  /** The heading for the person's own turns, in their language. */
+  userLabel?: string;
+}
+
+const DEFAULT_ASSISTANT = 'Alia';
+const DEFAULT_USER = 'You';
+
+/** `YYYY-MM-DD` in the reader's own timezone, not the UTC one `toISOString` gives. */
+export function localDate(date: Date): string {
+  const pad = (n: number) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/**
+ * The body of one message as Markdown: its text, then its images.
+ *
+ * A part the exporter does not know is dropped rather than stringified — an
+ * unknown part in a saved message is a shape from a later version of the app,
+ * and `[object Object]` in the middle of a document helps nobody.
+ */
+function messageBody(content: Message['content']): string {
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+
+  const text: string[] = [];
+  const images: string[] = [];
+  for (const part of content) {
+    if (part.type === 'text' && typeof part.text === 'string') {
+      text.push(part.text);
+    } else if (part.type === 'image_url') {
+      const url = (part.image_url as { url?: unknown } | undefined)?.url;
+      if (typeof url === 'string' && url !== '') images.push(url);
+    }
+  }
+
+  const lines = [text.join('').trim()];
+  images.forEach((url, i) => lines.push(`![Image ${i + 1}](${url})`));
+  return lines.filter((line) => line !== '').join('\n\n');
+}
+
+/** The heading a turn is written under. */
+function heading(message: Message, assistantName: string, userLabel: string): string {
+  if (message.role === 'user') return userLabel;
+  return message.agentInfo?.name || assistantName;
+}
+
+export function buildConversationMarkdown({
+  title,
+  messages,
+  exportedAt,
+  assistantName = DEFAULT_ASSISTANT,
+  userLabel = DEFAULT_USER,
+}: ConversationExportOptions): string {
+  const sections: string[] = [
+    `# ${title.trim() || DEFAULT_ASSISTANT}`,
+    `_Exported ${localDate(exportedAt)}_`,
+  ];
+
+  for (const message of messages) {
+    if (message.role !== 'user' && message.role !== 'assistant') continue;
+
+    const body = messageBody(message.content);
+    const sources = message.role === 'assistant' ? extractSources(message.toolInvocations) : [];
+    // An assistant placeholder that never got its answer, or a turn whose
+    // only content was a part the exporter dropped: nothing to write under
+    // the heading, so no heading.
+    if (body === '' && sources.length === 0) continue;
+
+    const parts = [`## ${heading(message, assistantName, userLabel)}`];
+    if (body !== '') parts.push(body);
+    if (sources.length > 0) {
+      parts.push(['### Sources', ...sources.map((s) => `- [${s.title}](${s.url})`)].join('\n'));
+    }
+    sections.push(parts.join('\n\n'));
+  }
+
+  return `${sections.join('\n\n')}\n`;
+}
+
+/**
+ * A file name for the document: the title, made safe for a file system, with
+ * the date so two exports of one thread do not overwrite each other.
+ */
+export function exportFilename(title: string, exportedAt: Date): string {
+  // NFD splits an accented letter into letter + combining mark, and the range
+  // is the combining marks block, spelled as a range and not as `\p{M}`: a
+  // property escape throws at RUNTIME on Hermes, where this code runs.
+  const slug = title
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60);
+  return `${slug || 'conversation'}-${localDate(exportedAt)}.md`;
+}

package/src/runtime/thread/message-days.ts

@@ -0,0 +1,120 @@
+/**
+ * Where a thread changes day, and which day it changed to.
+ *
+ * This is the DERIVED boundary, and the only one drawn from a timestamp: the
+ * clock passed midnight, and nobody decided it. A thread's other boundary — "a
+ * new conversation starts here" — is a seam between two conversations, read
+ * from which one each message belongs to, so it is not computed here and never
+ * from elapsed time. "N hours passed, draw a line" lies the day somebody comes
+ * back a week later to continue the same idea.
+ *
+ * ## The timezone is the client's, and that is the whole difficulty
+ *
+ * `createdAt` arrives as an ISO instant, which names no day: 23:40 on the 4th
+ * in Madrid and 22:40 on the 4th in London are the same instant, and 12:00 UTC
+ * is the 1st in Niue and the 2nd in Kiritimati. A separator computed from the
+ * UTC calendar is therefore wrong for most of the planet for part of every day,
+ * and wrong in the way nobody reports: the line lands an hour off, or a
+ * conversation that ran through local midnight shows none at all.
+ *
+ * So the day of an instant is read through `Date`'s LOCAL accessors, which is
+ * the device's own timezone — the one the person reading the thread is in.
+ *
+ * ## A message with no timestamp draws no line
+ *
+ * Everything the server sends carries `createdAt`; a message the client has
+ * only just appended may not, if it has not made the round trip. Those are
+ * skipped rather than assumed to be today, because assuming would draw a line
+ * that a reload then removes — and a separator that appears and disappears is
+ * worse than one that arrives a moment late.
+ */
+
+/** What a separator says. `today` and `yesterday` are named so the caller can translate them. */
+export type DaySeparatorLabel =
+  | { readonly kind: 'today' }
+  | { readonly kind: 'yesterday' }
+  | { readonly kind: 'date'; readonly text: string };
+
+export interface DaySeparator {
+  /** The id of the message this separator sits directly above. */
+  readonly messageId: string;
+  readonly label: DaySeparatorLabel;
+}
+
+/** The two fields a separator is derived from. */
+interface DatedMessage {
+  readonly id: string;
+  readonly createdAt?: string;
+}
+
+/** The local calendar day of an instant, as a key that compares equal only within one day. */
+function localDayKey(date: Date): string {
+  return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+}
+
+/** The instant a value names, or `null` if it names none. */
+function instant(value: string | undefined): Date | null {
+  if (value === undefined) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+/**
+ * How many local days back `date` is from `now`.
+ *
+ * Counted between local CALENDAR days rather than by subtracting milliseconds:
+ * a day is not 24 hours on the two days a year a timezone shifts, and an hour
+ * of error on those days would relabel "yesterday" as a date.
+ */
+function daysBefore(date: Date, now: Date): number {
+  const startOfDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const startOfNow = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  return Math.round((startOfNow.getTime() - startOfDate.getTime()) / 86_400_000);
+}
+
+function labelFor(date: Date, now: Date, locale: string): DaySeparatorLabel {
+  const back = daysBefore(date, now);
+  if (back === 0) return { kind: 'today' };
+  if (back === 1) return { kind: 'yesterday' };
+  return {
+    kind: 'date',
+    text: new Intl.DateTimeFormat(locale, {
+      weekday: 'short',
+      day: 'numeric',
+      month: 'short',
+      // Only when it is not this year. A year on every line is noise; a year on
+      // none of them is a thread that silently spans two.
+      ...(date.getFullYear() === now.getFullYear() ? {} : { year: 'numeric' }),
+    }).format(date),
+  };
+}
+
+/**
+ * The separators a message list needs, in order.
+ *
+ * One per CHANGE of local day, so two messages on the same day produce none and
+ * a pair that straddles local midnight produces one. There is no separator above
+ * the first message: it would say "today" on top of every conversation anyone is
+ * currently having, which is a label for a boundary that is not there.
+ */
+export function daySeparators(
+  messages: readonly DatedMessage[],
+  now: Date,
+  locale: string,
+): DaySeparator[] {
+  const separators: DaySeparator[] = [];
+  let previousKey: string | null = null;
+
+  for (const message of messages) {
+    const date = instant(message.createdAt);
+    if (date === null) continue;
+
+    const key = localDayKey(date);
+    if (previousKey !== null && key !== previousKey) {
+      separators.push({ messageId: message.id, label: labelFor(date, now, locale) });
+    }
+    previousKey = key;
+  }
+
+  return separators;
+}

package/src/runtime/thread/message-processor.ts

@@ -0,0 +1,93 @@
+/**
+ * Message Processor - Platform-specific message processing
+ *
+ * This module handles platform-specific processing of AI responses.
+ * Different platforms (Web/Mobile App vs Telegram) have different capabilities,
+ * so we process messages differently for each.
+ */
+
+import { TITLE_STRIP_RE } from './title-tags';
+
+export type Platform = 'app' | 'telegram';
+
+export interface ProcessedMessage {
+  text: string;
+  components?: any[]; // Visual components for the app (COMPACTLIST, BANNER, etc.)
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Process a message for the Web/Mobile App
+ * - Removes Telegram-specific tags ([REACT], [TGIMAGE], [TGLINKS], [TGDOC])
+ * - Preserves app-specific components ([COMPACTLIST], [BANNER], [COMPARISON], etc.)
+ */
+function processForApp(content: string): ProcessedMessage {
+  // Remove Telegram-specific tags and title tags
+  const cleanedText = content
+    .replace(/\[(?:ALIA_)?REACT:[^\]]+\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?TGIMAGE[^\]]*\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?TGLINKS[^\]]*\][\s\S]*?\[\/(?:ALIA_)?TGLINKS\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?TGDOC[^\]]*\]\s*/g, '')
+    .replace(TITLE_STRIP_RE, '')
+    .trim();
+
+  // App-specific components like [COMPACTLIST], [BANNER], etc. are kept
+  // They will be rendered by the Markdown component
+  return {
+    text: cleanedText,
+    components: [], // Could extract components here if needed
+  };
+}
+
+/**
+ * Process a message for Telegram
+ * - Removes app-specific components ([COMPACTLIST], [BANNER], etc.)
+ * - Preserves Telegram-specific tags for bot processing
+ */
+function processForTelegram(content: string): ProcessedMessage {
+  // Remove app-specific visual components (not supported in Telegram)
+  const cleanedText = content
+    .replace(/\[(?:ALIA_)?COMPACTLIST[^\]]*\][\s\S]*?\[\/(?:ALIA_)?COMPACTLIST\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?BANNER[^\]]*\][\s\S]*?\[\/(?:ALIA_)?BANNER\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?COMPARISON[^\]]*\][\s\S]*?\[\/(?:ALIA_)?COMPARISON\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?TIMELINE[^\]]*\][\s\S]*?\[\/(?:ALIA_)?TIMELINE\]\s*/g, '')
+    .replace(/\[(?:ALIA_)?IMAGE[^\]]*\]/g, '')
+    .replace(/\[(?:ALIA_)?CREDIBILITY[^\]]*\]/g, '')
+    .replace(TITLE_STRIP_RE, '')
+    .trim();
+
+  // Telegram tags like [REACT], [TGIMAGE], etc. are kept
+  // They will be processed by the Telegram bot
+  return {
+    text: cleanedText,
+  };
+}
+
+/**
+ * Main message processor - Routes to platform-specific processor
+ */
+export function processMessage(content: string, platform: Platform): ProcessedMessage {
+  switch (platform) {
+    case 'app':
+      return processForApp(content);
+    case 'telegram':
+      return processForTelegram(content);
+    default:
+      // Fallback: remove all special tags
+      return {
+        text: content
+          .replace(/\[(?:ALIA_)?REACT:[^\]]+\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?TGIMAGE[^\]]*\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?TGLINKS[^\]]*\][\s\S]*?\[\/(?:ALIA_)?TGLINKS\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?TGDOC[^\]]*\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?COMPACTLIST[^\]]*\][\s\S]*?\[\/(?:ALIA_)?COMPACTLIST\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?BANNER[^\]]*\][\s\S]*?\[\/(?:ALIA_)?BANNER\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?COMPARISON[^\]]*\][\s\S]*?\[\/(?:ALIA_)?COMPARISON\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?TIMELINE[^\]]*\][\s\S]*?\[\/(?:ALIA_)?TIMELINE\]\s*/g, '')
+          .replace(/\[(?:ALIA_)?IMAGE[^\]]*\]/g, '')
+          .replace(/\[(?:ALIA_)?CREDIBILITY[^\]]*\]/g, '')
+          .replace(TITLE_STRIP_RE, '')
+          .trim(),
+      };
+  }
+}