1
export class RegionRouter {
2
  private regions: RegionConfig[];
3

4
  resolve(clientRegion: string): RegionConfig {
5
    const healthy = this.regions.filter(r => r.status === "active");
6
    if (healthy.length === 0) return this.findClosest(clientRegion);
7
    return this.findClosest(clientRegion, healthy) || healthy[0];
8
  }
9

10
  async healthCheck(): Promise<Record<string, "active" | "degraded" | "down">> {
11
    // Fetch /health từ mỗi region với 5s timeout
12
    // Nếu OK → active, nếu error → degraded/down
13
  }
14

15
  markDown(regionName: string): void {
16
    const r = this.regions.find(r => r.name === regionName);
17
    if (r) { r.status = "down"; }
18
  }
19

20
  private findClosest(region: string, pool?: RegionConfig[]): RegionConfig | undefined {
21
    // Continent mapping: us- → americas, eu- → europe, ap- → asia-pacific
22
  }
23
}

1
const router = new RegionRouter([
2
  { name: "us-east-1", endpoint: "https://agent-us.example.com", weight: 50, priority: 0, status: "active" },
3
  { name: "eu-west-1", endpoint: "https://agent-eu.example.com", weight: 30, priority: 1, status: "active" },
4
  { name: "ap-southeast-1", endpoint: "https://agent-ap.example.com", weight: 20, priority: 2, status: "active" },
5
]);

1
export interface SessionSnapshot {
2
  sessionId: string;
3
  conversation: Array<{ role: string; content: string; timestamp: number }>;
4
  state: Record<string, unknown>;
5
  version: number;           // Monotonic — conflict resolution
6
  lastActiveRegion: string;
7
  lastActiveAt: number;
8
}
9

10
export class GlobalStateStore {
11
  private store = new Map<string, SessionSnapshot>();
12
  private currentRegion: string;
13

14
  async checkpoint(sessionId: string, snapshot: Partial<SessionSnapshot>): Promise<void> {
15
    // version-wins conflict resolution
16
    const existing = this.store.get(sessionId);
17
    if (existing && snapshot.version! <= existing.version) return;
18

19
    this.store.set(sessionId, {
20
      ...snapshot as SessionSnapshot,
21
      lastActiveRegion: this.currentRegion,
22
      lastActiveAt: Date.now(),
23
    });
24
  }
25

26
  async restore(sessionId: string): Promise<SessionSnapshot | null> {
27
    const snapshot = this.store.get(sessionId);
28
    if (!snapshot) return null;
29
    if (Date.now() - snapshot.lastActiveAt > 3600_000) {
30
      this.store.delete(sessionId); // TTL expired
31
      return null;
32
    }
33
    return snapshot;
34
  }
35

36
  startPeriodicCheckpoint(sessionId: string, getSnapshot: () => any): () => void {
37
    const interval = setInterval(() => this.checkpoint(sessionId, getSnapshot()), 5000);
38
    return () => clearInterval(interval);
39
  }
40

41
  async stats(): Promise<{ totalSessions: number; activeSessions: number; byRegion: Record<string, number> }> {
42
    // Thống kê session theo region
43
  }
44
}

1
// Replace in-memory map với DynamoDB
2
export class DynamoGlobalState extends GlobalStateStore {
3
  async checkpoint(sessionId: string, snapshot: any): Promise<void> {
4
    await this.docClient.send(new PutCommand({
5
      TableName: "agent-sessions",
6
      Item: { pk: `session#${sessionId}`, ...snapshot, ttl: Math.floor(Date.now()/1000) + 3600 },
7
      ConditionExpression: "attribute_not_exists(version) OR version < :v",
8
      ExpressionAttributeValues: { ":v": snapshot.version },
9
    }));
10
  }
11
}

1
export class CacheReplicator {
2
  async broadcast(key: string, value: string, ttlMs: number): Promise<void> {
3
    const entry = { key, value, ttlMs, sourceRegion: this.regionName, timestamp: Date.now() };
4

5
    await Promise.allSettled(
6
      this.peerEndpoints.map(ep =>
7
        fetch(`${ep}/cache/warmup`, {
8
          method: "POST", body: JSON.stringify(entry),
9
          signal: AbortSignal.timeout(2000),
10
        }).catch(() => {})
11
      )
12
    );
13
  }
14

15
  async receiveWarmup(entry: CacheWarmupEntry): Promise<void> {
16
    const age = Date.now() - entry.timestamp;
17
    if (age > 30_000) return; // Bỏ stale entries
18
    await this.sourceCache.set(entry.key, JSON.parse(entry.value), entry.ttlMs - age);
19
  }
20
}

1
export class FailoverManager {
2
  initiateFailover(reason: string): FailoverEvent {
3
    const healthy = this.router.getStatus().regions
4
      .filter(r => r.status === "active" && r.name !== this.currentRegion);
5
    if (healthy.length === 0) throw new Error("No healthy regions");
6

7
    const target = healthy.sort((a, b) => a.priority - b.priority)[0];
8

9
    // Final checkpoint tất cả active sessions
10
    for (const session of this.globalState.listActiveSessions()) {
11
      this.globalState.checkpoint(session.sessionId, { ...session, version: session.version + 1 });
12
    }
13

14
    this.currentRegion = target.name;
15
    return { fromRegion: this.currentRegion, toRegion: target.name, reason, timestamp: Date.now() };
16
  }
17

18
  dryRunFailover(): { targetRegion: string; sessionCount: number } {
19
    // Không switch — chỉ báo sẽ chuyển đi đâu
20
  }
21

22
  async restoreSession(sessionId: string): Promise<boolean> {
23
    const snapshot = await this.globalState.restore(sessionId);
24
    if (!snapshot) return false;
25
    // Khôi phục conversation + state
26
    return true;
27
  }
28

29
  startHealthChecks(intervalMs = 30000): void {
30
    setInterval(async () => {
31
      const status = await this.router.healthCheck();
32
      if (status[this.currentRegion] === "down") {
33
        this.initiateFailover("health-check-failure");
34
      }
35
    }, intervalMs);
36
  }
37
}

1
export class CheckpointAwareAgent {
2
  startSession(sessionId: string): CheckpointContext {
3
    const ctx = { sessionId, conversation: [], state: {}, version: 1 };
4
    this.stopCheckpoint = this.globalState.startPeriodicCheckpoint(sessionId, () => ctx);
5
    return ctx;
6
  }
7

8
  async handleToolCall(ctx: CheckpointContext, tool: string, result: unknown): Promise<void> {
9
    ctx.conversation.push({ role: "tool", content: JSON.stringify(result).slice(0, 1000), timestamp: Date.now() });
10
    ctx.version++;
11

12
    if (["create_issue", "update_issue"].includes(tool)) {
13
      await this.globalState.checkpoint(ctx.sessionId, ctx);
14
    }
15
  }
16

17
  async endSession(ctx: CheckpointContext): Promise<void> {
18
    this.stopCheckpoint?.();
19
    await this.globalState.checkpoint(ctx.sessionId, ctx);
20
  }
21
}