Message → transport.send() or transport.edit()
  ↓
prepareMessageWithDebug(text, ctx)
  ├─ formatDebugFooter(ctx)
  │  ├─ if (ctx.isAdmin) → return formatted footer
  │  └─ else → return null
  └─ if (footer) → append to text

send: async (ctx, text) => {
  const { text: finalText, parseMode } = prepareMessageWithDebug(text, ctx);
  //                                      ↑ Adds footer here
  return sendTelegramMessage(ctx.token, ctx.chatId, finalText, parseMode);
}

export function formatDebugFooter(ctx: TelegramContext): string | null {
  if (!ctx.isAdmin) {
    return null;  // ← This is why footer doesn't show
  }
  // Format and return footer...
}

function computeIsAdmin(username?: string, adminUsername?: string): boolean {
  if (!username || !adminUsername) {
    return false;  // ← Missing adminUsername causes failure
  }
  return normalizeUsername(username) === normalizeUsername(adminUsername);
  // Removes leading @ and compares case-insensitively
}

cloudflare-agent.ts:818  → During loading: stepTracker.getDebugContext()
cloudflare-agent.ts:921  → Before response: Detailed DebugContext

cloudflare-agent.ts:1344 → During loading: buildDebugContext(stepTracker)
cloudflare-agent.ts:1368 → Before response: buildDebugContext(stepTracker)

(info) [WEBHOOK] Message received {
  "username":"duyet",
  ...
}

ctx.isAdmin = (username === adminUsername)
            = ("duyet" === undefined)  ← adminUsername not set!
            = false  ← No footer

# In your .env or Cloudflare secrets
TELEGRAM_ADMIN_USERNAME=duyet
 
# Deploy
bun run deploy:telegram

const ctx = createTelegramContext(
  token,
  webhookCtx,
  env.TELEGRAM_ADMIN_USERNAME,  // ← Pass this
  requestId,
  parseMode
);

const ctx = createTelegramContext(
  env.TELEGRAM_BOT_TOKEN,
  webhookCtx,
  env.TELEGRAM_ADMIN_USERNAME,  // ← Must not be undefined
  requestId
);

(log) {
  displayMessage: 'State updated',
  id: 'FAgyjrmzpRXx_LURS8hBl',
  payload: {},
  timestamp: 1765739728961,
  type: 'state:update'
}
(log) {
  displayMessage: 'State updated',
  id: 'G060kn9Dj8GGPSQINg9oe',
  ...
}

// Compact "State updated" to single line
compactStateUpdate(log)
// Output: [state] msgs:20 | t:728961
 
// Compress large context objects
compactDebugContext(context)
// Output: { messages: [<2 items>], messageCount: 20 }
 
// Transform entire log for readability
compactLog(log, { abbreviate: true })

(log) {
  displayMessage: 'State updated',
  id: 'FAgyjrmzpRXx_LURS8hBl',
  payload: {},
  timestamp: 1765739728961,
  type: 'state:update'
}

(log) [state] msgs:20 | t:728961

const logger = createLogger();
const compactedContext = compactDebugContext(largeContext, {
  abbreviate: true,
  hideRefs: true
});
logger.debug('[AGENT] Context:', compactedContext);
 
// Output:
// [AGENT] Context: { messages: [{role: 'user'}, {role: 'assistant'}], messageCount: 42 }

import {
  compactLog,
  compactStateUpdate,
  createCompactMiddleware
} from '@duyetbot/observability';
 
// Option 1: Compact individual logs
console.log(compactLog(logObject));
 
// Option 2: Use in middleware
const middleware = createCompactMiddleware({ abbreviate: true });
middleware(logObject);  // Returns compact form

// Suppress repetitive state update logs
const logger = createLogger({
  filter: (log) => {
    // Skip verbose state updates
    if (log.type === 'state:update') return false;
    return true;
  }
});
 
// Or compact them instead
const compactLogger = createLogger({
  middleware: createCompactMiddleware()
});

interface DebugContext {
  // Routing info (empty for direct chat)
  routingFlow: Array<{
    agent: string;
    durationMs: number;
    status: 'running' | 'completed' | 'error';
    tokenUsage?: TokenUsage;
  }>;
 
  // Total execution time
  totalDurationMs: number;
 
  // Model, trace, tokens, errors
  metadata?: {
    model?: string;
    traceId?: string;
    tokenUsage?: TokenUsage;
    lastToolError?: string;
  };
 
  // Execution chain (thinking → tools → results)
  steps?: ExecutionStep[];
 
  // Worker info for orchestrator
  workers?: WorkerDebugInfo[];
}