Building Always-On AI Agents: From Passive Chatbots to Autonomous Services

  RegistryBrokerClient,
  type ChatHistoryEntry 
} from '@hashgraphonline/standards-sdk';

interface SessionState {
  lastChecked: number;
  messageCount: number;
}
class ServiceAgent {
  private client: RegistryBrokerClient;
  private myUaid: string;
  private activeSessions: Map<string, SessionState> = new Map();
  private running: boolean = false;
  constructor(uaid: string, brokerUrl: string) {
    this.myUaid = uaid;
    this.client = new RegistryBrokerClient({ baseUrl: brokerUrl });
  }
  async start(): Promise<void> {
    console.log(Service agent starting: ${this.myUaid});
    console.log(Online at ${new Date().toISOString()});
this.running = true;

while (this.running) {
  try {
    await this.pollActiveSessions();
  } catch (error) {
    console.error(&#39;Polling error:&#39;, error);
    // Continue running despite errors
  }

  // Wait before next poll cycle
  await this.delay(2000);
}

  }
  stop(): void {
    console.log('Service agent shutting down...');
    this.running = false;
  }
  private async pollActiveSessions(): Promise<void> {
    for (const [sessionId, state] of this.activeSessions) {
      const history = await this.client.chat.getHistory(sessionId);
      const allMessages = history.history ?? [];
  // Find messages newer than our last check
  const newMessages = allMessages.filter(
    entry =&gt; new Date(entry.timestamp).getTime() &gt; state.lastChecked
  );

  // Process only user messages (we sent the agent ones)
  const userMessages = newMessages.filter(m =&gt; m.role === &#39;user&#39;);

  for (const message of userMessages) {
    await this.handleMessage(sessionId, message);
  }

  // Update state
  state.lastChecked = Date.now();
  state.messageCount = allMessages.length;
}

  }
  async handleMessage(
    sessionId: string, 
    message: ChatHistoryEntry
  ): Promise<void> {
    // Override this in subclasses for custom behavior
    console.log(New message in ${sessionId}: ${message.content});
  }
  registerSession(sessionId: string): void {
    if (!this.activeSessions.has(sessionId)) {
      this.activeSessions.set(sessionId, {
        lastChecked: Date.now(),
        messageCount: 0,
      });
      console.log(Tracking session: ${sessionId});
    }
  }

class SentinelAgent extends ServiceAgent {
  private alertThreshold: number;

  constructor(
    uaid: string, 
    brokerUrl: string, 
    alertThreshold: number = 5
  ) {
    super(uaid, brokerUrl);
    this.alertThreshold = alertThreshold;
  }
  async handleMessage(
    sessionId: string,
    message: ChatHistoryEntry
  ): Promise<void> {
    const content = message.content.toUpperCase();
console.log(`[SENTINEL] Analyzing: ${content.substring(0, 50)}...`);

// Pattern matching for critical signals
if (this.isCriticalSignal(content)) {
  console.warn(&#39;&gt;&gt;&gt; CRITICAL SIGNAL DETECTED&#39;);
  await this.triggerEmergencyProtocol(sessionId, content);
} else if (this.isRoutineCheck(content)) {
  await this.acknowledgeRoutine(sessionId);
}

  }
  private isCriticalSignal(content: string): boolean {
    const criticalPatterns = [
      'CRITICAL_FAILURE',
      'SECURITY_BREACH',
      'PRICE_DUMP',
      'SYSTEM_DOWN',
      'UNAUTHORIZED_ACCESS',
    ];
    return criticalPatterns.some(pattern => content.includes(pattern));
  }
  private isRoutineCheck(content: string): boolean {
    return content.includes('STATUS') || content.includes('HEALTH_CHECK');
  }
  private async triggerEmergencyProtocol(
    sessionId: string,
    content: string
  ): Promise<void> {
    // 1. Log the incident
    console.log(Emergency triggered at ${new Date().toISOString()});
    console.log(Content: ${content});
// 2. Call external alerting system
await this.notifyPagerDuty(content);

// 3. Send acknowledgment through the broker
await this.client.chat.sendMessage({
  sessionId: sessionId,
  message: &#39;ACK. Emergency protocols initiated. On-call team summoned.&#39;,
});

  }
  private async acknowledgeRoutine(sessionId: string): Promise<void> {
    const status = {
      status: 'healthy',
      uptime: process.uptime(),
      timestamp: new Date().toISOString(),
      activeSessions: this.activeSessions.size,
    };
await this.client.chat.sendMessage({
  sessionId,
  message: `Status report: ${JSON.stringify(status)}`,
});

  }
  private async notifyPagerDuty(content: string): Promise<void> {
    // In production, integrate with your actual alerting system
    console.log([PAGERDUTY] Sending alert: ${content.substring(0, 100)});
// Example: fetch(&#39;https://events.pagerduty.com/v2/enqueue&#39;, { ... })

async function main() {
  const agent = new SentinelAgent(
    process.env.AGENT_UAID!,
    process.env.REGISTRY_BROKER_BASE_URL ?? 'https://hol.org/registry/api/v1',
  );
  // Register sessions to monitor
  // In practice, these come from your session management layer
  const sessionsToMonitor = process.env.MONITOR_SESSIONS?.split(',') ?? [];
  for (const sessionId of sessionsToMonitor) {
    agent.registerSession(sessionId.trim());
  }
  // Handle shutdown gracefully
  process.on('SIGTERM', () => agent.stop());
  process.on('SIGINT', () => agent.stop());
  // Start the event loop
  await agent.start();
}

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist ./dist
CMD ["node", "dist/sentinel.js"]

// Emit metrics
setInterval(() => {
  console.log(JSON.stringify({
    type: 'agent_metrics',
    activeSessions: activeSessions.size,
    uptimeSeconds: process.uptime(),
    memoryMB: process.memoryUsage().heapUsed / 1024 / 1024,
    timestamp: new Date().toISOString(),
  }));
}, 60000);

async pollWithRetry(sessionId: string, retries: number = 3): Promise<void> {
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      return await this.pollSession(sessionId);
    } catch (error) {
      console.warn(`Poll attempt ${attempt + 1} failed:`, error);
      await this.delay(1000 * (attempt + 1)); // Exponential backoff
    }
  }
  console.error(`Session ${sessionId} unreachable after ${retries} attempts`);
}