1
type LogLevel = "debug" | "info" | "warn" | "error";
2

3
interface LogEvent {
4
  timestamp: string;
5
  level: LogLevel;
6
  sessionId: string;
7
  event: string;
8
  data: Record<string, unknown>;
9
  duration_ms?: number;
10
  error?: string;
11
}
12

13
export class AgentLogger {
14
  private sessionId: string;
15
  private startTime: number;
16
  private events: LogEvent[] = [];
17

18
  constructor(sessionId?: string) {
19
    this.sessionId = sessionId || crypto.randomUUID();
20
    this.startTime = Date.now();
21
  }
22

23
  private log(level: LogLevel, event: string, data: Record<string, unknown>, error?: string) {
24
    const entry: LogEvent = {
25
      timestamp: new Date().toISOString(),
26
      level, event, data,
27
      sessionId: this.sessionId,
28
      duration_ms: Date.now() - this.startTime,
29
    };
30
    if (error) entry.error = error;
31
    console.log(JSON.stringify(entry));
32
    this.events.push(entry);
33
  }
34

35
  info(event: string, data = {}) { this.log("info", event, data); }
36
  warn(event: string, data = {}) { this.log("warn", event, data); }
37
  error(event: string, data = {}, error?: string) { this.log("error", event, data, error); }
38

39
  getEvents() { return this.events; }
40
  getSessionStats() {
41
    return {
42
      sessionId: this.sessionId,
43
      totalEvents: this.events.length,
44
      errors: this.events.filter(e => e.level === "error").length,
45
      duration_ms: Date.now() - this.startTime,
46
    };
47
  }
48
}

1
[INFO] Tool called: search_issues

1
{"timestamp":"2026-06-13T01:23:45Z","level":"info","event":"tool_call",
2
 "data":{"tool":"search_issues","duration_ms":340}}

1
export class ToolTracer {
2
  private logger: AgentLogger;
3

4
  static readonly MODEL_PRICES: Record<string, { input: number; output: number }> = {
5
    "claude-sonnet-4-20250514": { input: 0.003, output: 0.015 },
6
    "claude-haiku-3-20250313": { input: 0.00025, output: 0.00125 },
7
    "gpt-4o-mini": { input: 0.00015, output: 0.0006 },
8
    "gpt-4o": { input: 0.0025, output: 0.01 },
9
    "deepseek-chat": { input: 0.00027, output: 0.0011 },
10
  };
11

12
  constructor(logger: AgentLogger) { this.logger = logger; }
13

14
  static estimateTokens(text: string): number {
15
    const words = text.split(/\s+/).length;
16
    const chars = text.length;
17
    return Math.ceil((words + chars / 4) / 2);
18
  }
19

20
  static estimateCost(model: string, inputTokens: number, outputTokens: number): number {
21
    const prices = ToolTracer.MODEL_PRICES[model];
22
    if (!prices) return 0;
23
    return (inputTokens / 1000) * prices.input + (outputTokens / 1000) * prices.output;
24
  }
25

26
  async traceToolCall<T>(
27
    toolName: string, input: Record<string, unknown>,
28
    callFn: () => Promise<T>,
29
    options: { model?: string; maxRetries?: number } = {}
30
  ): Promise<{ result: T; traceId: string; durationMs: number }> {
31
    const traceId = crypto.randomUUID().slice(0, 8);
32
    const startTime = Date.now();
33

34
    this.logger.info("tool_call_start", { tool: toolName, traceId });
35

36
    let lastError: Error | null = null;
37
    const maxAttempts = options.maxRetries || 1;
38

39
    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
40
      try {
41
        const result = await callFn();
42
        const durationMs = Date.now() - startTime;
43
        const inputTokens = ToolTracer.estimateTokens(JSON.stringify(input));
44
        const cost = options.model
45
          ? ToolTracer.estimateCost(options.model, inputTokens, 0)
46
          : 0;
47

48
        this.logger.info("tool_call_complete", {
49
          tool: toolName, traceId,
50
          duration_ms: durationMs,
51
          costUsd: parseFloat(cost.toFixed(6)),
52
        });
53

54
        return { result, traceId, durationMs };
55
      } catch (error) {
56
        lastError = error instanceof Error ? error : new Error(String(error));
57
        this.logger.warn("tool_call_retry", { tool: toolName, traceId, attempt });
58

59
        if (attempt >= maxAttempts) {
60
          this.logger.error("tool_call_failed", { tool: toolName, traceId });
61
          throw lastError;
62
        }
63
        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt - 1)));
64
      }
65
    }
66
    throw lastError!;
67
  }
68
}

1
interface ToolPattern {
2
  tool: string;
3
  inputHash: string;
4
  timestamp: number;
5
}
6

7
export class LoopDetector {
8
  private history: ToolPattern[] = [];
9
  private windowSize: number;
10
  private maxRepeats: number;
11

12
  constructor(windowSize = 10, maxRepeats = 3) {
13
    this.windowSize = windowSize;
14
    this.maxRepeats = maxRepeats;
15
  }
16

17
  private hashInput(input: Record<string, unknown>): string {
18
    return crypto.createHash("sha256").update(JSON.stringify(input)).digest("hex");
19
  }
20

21
  record(tool: string, input: Record<string, unknown>): boolean {
22
    const pattern: ToolPattern = {
23
      tool, inputHash: this.hashInput(input), timestamp: Date.now(),
24
    };
25
    this.history.push(pattern);
26
    if (this.history.length > this.windowSize) this.history.shift();
27
    return this.checkLoop();
28
  }
29

30
  private checkLoop(): boolean {
31
    if (this.history.length < 2) return false;
32
    const last = this.history[this.history.length - 1];
33
    const repeats = this.history.filter(h => h.tool === last.tool && h.inputHash === last.inputHash).length;
34
    return repeats >= this.maxRepeats;
35
  }
36

37
  getSuggestion(): string {
38
    const counts = new Map<string, number>();
39
    for (const h of this.history) {
40
      const key = `${h.tool}:${h.inputHash}`;
41
      counts.set(key, (counts.get(key) || 0) + 1);
42
    }
43
    const top = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
44
    if (top && top[1] >= this.maxRepeats) {
45
      return `⚠️ Loop: tool "${top[0].split(":")[0]}" called ${top[1]} times with same input`;
46
    }
47
    return "No loop detected.";
48
  }
49
}

1
const detector = new LoopDetector(15, 4);
2

3
async function safeCall(tool: string, input: any, fn: () => Promise<any>) {
4
  if (detector.record(tool, input)) {
5
    throw new Error(`Infinite loop: ${tool}`);
6
  }
7
  return fn();
8
}

1
export class AgentMetrics {
2
  private counters = new Map<string, number>();
3
  private histograms = new Map<string, number[]>();
4

5
  increment(counter: string, value = 1) {
6
    this.counters.set(counter, (this.counters.get(counter) || 0) + value);
7
  }
8

9
  recordDuration(metric: string, ms: number) {
10
    if (!this.histograms.has(metric)) this.histograms.set(metric, []);
11
    this.histograms.get(metric)!.push(ms);
12
    if (this.histograms.get(metric)!.length > 1000) this.histograms.get(metric)!.shift();
13
  }
14

15
  toPrometheus(): string {
16
    const lines: string[] = [];
17
    // Tool calls
18
    for (const [k, v] of this.counters) {
19
      if (k.startsWith("tool_call:")) {
20
        lines.push(`agent_tool_calls_total{tool="${k.replace("tool_call:", "")}"} ${v}`);
21
      }
22
    }
23
    // Error rate
24
    const total = [...this.counters.entries()]
25
      .filter(([k]) => k.startsWith("tool_call:")).reduce((s, [, v]) => s + v, 0);
26
    const errors = this.counters.get("errors") || 0;
27
    lines.push(`agent_error_rate ${total > 0 ? (errors / total).toFixed(4) : 0}`);
28
    // Cost
29
    lines.push(`agent_total_cost_usd ${(this.counters.get("total_cost_usd") || 0).toFixed(6)}`);
30
    return lines.join("\n");
31
  }
32
}

1
app.get("/metrics", (req, res) => {
2
  res.set("Content-Type", "text/plain");
3
  res.send(metrics.toPrometheus());
4
});

1
export class SessionStore {
2
  private sessions = new Map<string, { logger: AgentLogger; lastActivity: number }>();
3
  private ttlMs: number;
4

5
  constructor(ttlMs = 30 * 60_000) {
6
    this.ttlMs = ttlMs;
7
    setInterval(() => this.cleanup(), 5 * 60_000);
8
  }
9

10
  create(id?: string): AgentLogger {
11
    const logger = new AgentLogger(id);
12
    this.sessions.set(logger["sessionId"], { logger, lastActivity: Date.now() });
13
    return logger;
14
  }
15

16
  get(id: string): AgentLogger | undefined {
17
    const r = this.sessions.get(id);
18
    if (r) { r.lastActivity = Date.now(); return r.logger; }
19
  }
20

21
  getDashboardData() {
22
    return {
23
      activeSessions: this.sessions.size,
24
      sessions: [...this.sessions.values()].map(s => ({
25
        events: s.logger.getEvents().length,
26
        errors: s.logger.getEvents().filter(e => e.level === "error").length,
27
        stats: s.logger.getSessionStats(),
28
      })),
29
    };
30
  }
31

32
  private cleanup() {
33
    const now = Date.now();
34
    for (const [id, r] of this.sessions) {
35
      if (now - r.lastActivity > this.ttlMs) this.sessions.delete(id);
36
    }
37
  }
38
}