@kkelly-offical/kkcode 0.1.7 → 0.2.3-preview.1

package/src/observability/metrics.mjs

@@ -1,137 +1,165 @@
-import { EVENT_TYPES } from "../core/constants.mjs"
-
-function createHistogram() {
-  const values = []
-  return {
-    record(v) { values.push(v) },
-    snapshot() {
-      if (values.length === 0) return { count: 0, sum: 0, min: 0, max: 0, avg: 0, p50: 0, p99: 0 }
-      const sorted = [...values].sort((a, b) => a - b)
-      const sum = sorted.reduce((s, v) => s + v, 0)
-      const count = sorted.length
-      return {
-        count,
-        sum,
-        min: sorted[0],
-        max: sorted[count - 1],
-        avg: sum / count,
-        p50: sorted[Math.max(0, Math.ceil(count * 0.5) - 1)] || 0,
-        p99: sorted[Math.max(0, Math.ceil(count * 0.99) - 1)] || 0
-      }
-    },
-    reset() { values.length = 0 }
-  }
-}
-
-export function createMetricsCollector() {
-  const counters = new Map()
-  const histograms = new Map()
-  const turnStarts = new Map()
-  const stageStarts = new Map()
-
-  function inc(name, amount = 1) {
-    counters.set(name, (counters.get(name) || 0) + amount)
-  }
-
-  function hist(name) {
-    if (!histograms.has(name)) histograms.set(name, createHistogram())
-    return histograms.get(name)
-  }
-
-  const MAX_OPEN_ENTRIES = 500
-
-  function pruneStaleMap(map) {
-    if (map.size <= MAX_OPEN_ENTRIES) return
-    const cutoff = Date.now() - 30 * 60 * 1000 // 30 min
-    for (const [k, v] of map) {
-      if (v < cutoff) map.delete(k)
-    }
-    // If still over limit, drop oldest half
-    if (map.size > MAX_OPEN_ENTRIES) {
-      let toDrop = Math.floor(map.size / 2)
-      for (const k of map.keys()) {
-        if (toDrop-- <= 0) break
-        map.delete(k)
-      }
-    }
-  }
-
-  function handleEvent(event) {
-    const { type, payload, turnId, sessionId } = event
-
-    if (type === EVENT_TYPES.TURN_START) {
-      inc("turn_count")
-      if (turnId) {
-        turnStarts.set(turnId, event.timestamp)
-        pruneStaleMap(turnStarts)
-      }
-    }
-
-    if (type === EVENT_TYPES.TURN_FINISH) {
-      if (turnId && turnStarts.has(turnId)) {
-        hist("turn_duration_ms").record(event.timestamp - turnStarts.get(turnId))
-        turnStarts.delete(turnId)
-      }
-    }
-
-    if (type === EVENT_TYPES.TURN_ERROR) {
-      inc("error_count")
-    }
-
-    if (type === EVENT_TYPES.TOOL_START) {
-      inc("tool_call_count")
-    }
-
-    if (type === EVENT_TYPES.TOOL_ERROR) {
-      inc("tool_error_count")
-    }
-
-    if (type === EVENT_TYPES.TURN_USAGE_UPDATE) {
-      if (payload?.input) inc("token_input", payload.input)
-      if (payload?.output) inc("token_output", payload.output)
-      if (payload?.cacheRead) inc("token_cache_read", payload.cacheRead)
-    }
-
-    if (type === EVENT_TYPES.LONGAGENT_STAGE_STARTED) {
-      const key = payload?.stageId || sessionId
-      if (key) {
-        stageStarts.set(key, event.timestamp)
-        pruneStaleMap(stageStarts)
-      }
-    }
-
-    if (type === EVENT_TYPES.LONGAGENT_STAGE_FINISHED) {
-      const key = payload?.stageId || sessionId
-      if (key && stageStarts.has(key)) {
-        hist("longagent_stage_duration_ms").record(event.timestamp - stageStarts.get(key))
-        stageStarts.delete(key)
-      }
-      if (payload?.retryCount > 0) {
-        inc("longagent_task_retries", payload.retryCount)
-      }
-    }
-
-    if (type === EVENT_TYPES.LONGAGENT_GATE_CHECKED) {
-      inc("gate_check_count")
-      if (payload?.status === "pass") inc("gate_pass_count")
-    }
-  }
-
-  function getSnapshot() {
-    const counterSnapshot = new Map(counters)
-    const histogramSnapshot = new Map()
-    for (const [name, h] of histograms) {
-      histogramSnapshot.set(name, h.snapshot())
-    }
-    return { counters: counterSnapshot, histograms: histogramSnapshot }
-  }
-
-  function reset() {
-    counters.clear()
-    histograms.clear()
-    turnStarts.clear()
-    stageStarts.clear()
-  }
-
-  return { handleEvent, getSnapshot, reset }
-}
+import { EVENT_TYPES } from "../core/constants.mjs"
+
+function createHistogram() {
+  const values = []
+  return {
+    record(v) { values.push(v) },
+    snapshot() {
+      if (values.length === 0) return { count: 0, sum: 0, min: 0, max: 0, avg: 0, p50: 0, p99: 0 }
+      const sorted = [...values].sort((a, b) => a - b)
+      const sum = sorted.reduce((s, v) => s + v, 0)
+      const count = sorted.length
+      return {
+        count,
+        sum,
+        min: sorted[0],
+        max: sorted[count - 1],
+        avg: sum / count,
+        p50: sorted[Math.max(0, Math.ceil(count * 0.5) - 1)] || 0,
+        p99: sorted[Math.max(0, Math.ceil(count * 0.99) - 1)] || 0
+      }
+    },
+    reset() { values.length = 0 }
+  }
+}
+
+export function createMetricsCollector() {
+  const counters = new Map()
+  const histograms = new Map()
+  const turnStarts = new Map()
+  const stageStarts = new Map()
+
+  function inc(name, amount = 1) {
+    counters.set(name, (counters.get(name) || 0) + amount)
+  }
+
+  function hist(name) {
+    if (!histograms.has(name)) histograms.set(name, createHistogram())
+    return histograms.get(name)
+  }
+
+  const MAX_OPEN_ENTRIES = 500
+
+  function pruneStaleMap(map) {
+    if (map.size <= MAX_OPEN_ENTRIES) return
+    const cutoff = Date.now() - 30 * 60 * 1000 // 30 min
+    for (const [k, v] of map) {
+      if (v < cutoff) map.delete(k)
+    }
+    // If still over limit, drop oldest half
+    if (map.size > MAX_OPEN_ENTRIES) {
+      let toDrop = Math.floor(map.size / 2)
+      for (const k of map.keys()) {
+        if (toDrop-- <= 0) break
+        map.delete(k)
+      }
+    }
+  }
+
+  function handleEvent(event) {
+    const { type, payload, turnId, sessionId } = event
+
+    if (type === EVENT_TYPES.ROUTE_DECISION) {
+      inc("route_decision_count")
+      if (payload?.changed) inc("route_changed_count")
+      if (payload?.suggestion === "longagent") inc("route_longagent_suggestion_count")
+      if (payload?.continuedTransaction) inc("route_continuation_count")
+      if (payload?.stayedLocal) inc("route_stayed_local_count")
+      if (payload?.deferredLongagent) inc("route_deferred_longagent_count")
+      if (payload?.overEscalatedToLongagent) inc("route_over_escalated_longagent_count")
+      if (Array.isArray(payload?.evidence)) {
+        for (const item of payload.evidence) {
+          const key = String(item || "").trim().replace(/[^\w]+/g, "_")
+          if (key) inc(`route_evidence_${key}`)
+        }
+      }
+    }
+
+    if (type === EVENT_TYPES.AGENT_CONTINUATION_INTERRUPTED) {
+      inc("agent_continuation_interrupted_count")
+    }
+
+    if (type === EVENT_TYPES.AGENT_CONTINUATION_RESUMED) {
+      inc("agent_continuation_resumed_count")
+    }
+
+    if (type === EVENT_TYPES.TURN_START) {
+      inc("turn_count")
+      if (turnId) {
+        turnStarts.set(turnId, event.timestamp)
+        pruneStaleMap(turnStarts)
+      }
+    }
+
+    if (type === EVENT_TYPES.TURN_FINISH) {
+      if (turnId && turnStarts.has(turnId)) {
+        hist("turn_duration_ms").record(event.timestamp - turnStarts.get(turnId))
+        turnStarts.delete(turnId)
+      }
+    }
+
+    if (type === EVENT_TYPES.TURN_ERROR) {
+      inc("error_count")
+    }
+
+    if (type === EVENT_TYPES.TOOL_START) {
+      inc("tool_call_count")
+    }
+
+    if (type === EVENT_TYPES.TOOL_ERROR) {
+      inc("tool_error_count")
+    }
+
+    if (type === EVENT_TYPES.TURN_USAGE_UPDATE) {
+      if (payload?.input) inc("token_input", payload.input)
+      if (payload?.output) inc("token_output", payload.output)
+      if (payload?.cacheRead) inc("token_cache_read", payload.cacheRead)
+    }
+
+    if (type === EVENT_TYPES.AGENT_CONTINUATION_RESUMED) {
+      inc("agent_continuation_count")
+    }
+
+    if (type === EVENT_TYPES.LONGAGENT_STAGE_STARTED) {
+      const key = payload?.stageId || sessionId
+      if (key) {
+        stageStarts.set(key, event.timestamp)
+        pruneStaleMap(stageStarts)
+      }
+    }
+
+    if (type === EVENT_TYPES.LONGAGENT_STAGE_FINISHED) {
+      const key = payload?.stageId || sessionId
+      if (key && stageStarts.has(key)) {
+        hist("longagent_stage_duration_ms").record(event.timestamp - stageStarts.get(key))
+        stageStarts.delete(key)
+      }
+      if (payload?.retryCount > 0) {
+        inc("longagent_task_retries", payload.retryCount)
+      }
+    }
+
+    if (type === EVENT_TYPES.LONGAGENT_GATE_CHECKED) {
+      inc("gate_check_count")
+      if (payload?.status === "pass") inc("gate_pass_count")
+    }
+  }
+
+  function getSnapshot() {
+    const counterSnapshot = new Map(counters)
+    const histogramSnapshot = new Map()
+    for (const [name, h] of histograms) {
+      histogramSnapshot.set(name, h.snapshot())
+    }
+    return { counters: counterSnapshot, histograms: histogramSnapshot }
+  }
+
+  function reset() {
+    counters.clear()
+    histograms.clear()
+    turnStarts.clear()
+    stageStarts.clear()
+  }
+
+  return { handleEvent, getSnapshot, reset }
+}

package/src/observability/tracer.mjs

@@ -1,137 +1,137 @@
-import { EVENT_TYPES } from "../core/constants.mjs"
-import { randomUUID } from "node:crypto"
-
-function newSpanId() {
-  return `span_${randomUUID().slice(0, 12)}`
-}
-
-export function createTracer(options = {}) {
-  const maxTraces = options.maxTraces || 100
-  const maxOpenSpans = options.maxOpenSpans || 500
-  const traces = []
-  const openSpans = new Map()
-  const phaseSpan = { current: null }
-  let currentTraceId = null
-
-  function pruneOpenSpans() {
-    if (openSpans.size <= maxOpenSpans) return
-    // Close oldest spans as "expired"
-    let toDrop = Math.floor(openSpans.size / 2)
-    for (const [key, span] of openSpans) {
-      if (toDrop-- <= 0) break
-      closeSpan(span, "expired")
-      openSpans.delete(key)
-    }
-  }
-
-  function startSpan(name, attributes = {}, parentSpanId = null, timestamp = null) {
-    if (!currentTraceId) currentTraceId = `trace_${randomUUID().slice(0, 12)}`
-    const span = {
-      traceId: currentTraceId,
-      spanId: newSpanId(),
-      parentSpanId,
-      name,
-      startTime: timestamp || Date.now(),
-      endTime: null,
-      duration: null,
-      attributes,
-      status: "ok"
-    }
-    return span
-  }
-
-  function closeSpan(span, status = "ok", timestamp = null) {
-    span.endTime = timestamp || Date.now()
-    span.duration = span.endTime - span.startTime
-    span.status = status
-    traces.push(span)
-    if (traces.length > maxTraces) traces.shift()
-  }
-
-  function handleEvent(event) {
-    const { type, payload, turnId, sessionId, timestamp } = event
-
-    if (type === EVENT_TYPES.TURN_START) {
-      const key = `turn:${turnId}`
-      if (turnId && openSpans.has(key)) {
-        closeSpan(openSpans.get(key), "error", timestamp)
-        openSpans.delete(key)
-      }
-      const span = startSpan("turn", { turnId, sessionId }, null, timestamp)
-      if (turnId) openSpans.set(key, span)
-      pruneOpenSpans()
-    }
-
-    if (type === EVENT_TYPES.TURN_FINISH) {
-      const key = `turn:${turnId}`
-      const span = openSpans.get(key)
-      if (span) {
-        closeSpan(span, "ok", timestamp)
-        openSpans.delete(key)
-      }
-    }
-
-    if (type === EVENT_TYPES.TURN_ERROR) {
-      const key = `turn:${turnId}`
-      const span = openSpans.get(key)
-      if (span) {
-        span.attributes.error = payload?.error || "unknown"
-        closeSpan(span, "error", timestamp)
-        openSpans.delete(key)
-      }
-    }
-
-    if (type === EVENT_TYPES.LONGAGENT_STAGE_STARTED) {
-      const stageId = payload?.stageId
-      if (stageId) {
-        const span = startSpan("stage", { stageId, sessionId }, null, timestamp)
-        openSpans.set(`stage:${stageId}`, span)
-        pruneOpenSpans()
-      }
-    }
-
-    if (type === EVENT_TYPES.LONGAGENT_STAGE_FINISHED) {
-      const stageId = payload?.stageId
-      const key = `stage:${stageId}`
-      const span = openSpans.get(key)
-      if (span) {
-        span.attributes.successCount = payload?.successCount
-        span.attributes.failCount = payload?.failCount
-        closeSpan(span, payload?.allSuccess ? "ok" : "error", timestamp)
-        openSpans.delete(key)
-      }
-    }
-
-    if (type === EVENT_TYPES.LONGAGENT_PHASE_CHANGED) {
-      if (phaseSpan.current) {
-        closeSpan(phaseSpan.current, "ok", timestamp)
-      }
-      const span = startSpan("phase", {
-        phase: payload?.phase || payload?.newPhase,
-        sessionId
-      }, null, timestamp)
-      phaseSpan.current = span
-    }
-  }
-
-  function getTraces() {
-    const result = [...traces]
-    if (phaseSpan.current) result.push({ ...phaseSpan.current, status: "open" })
-    return result
-  }
-
-  function exportTraces(format = "json") {
-    const all = getTraces()
-    if (format === "json") return JSON.stringify(all, null, 2)
-    return JSON.stringify(all)
-  }
-
-  function reset() {
-    traces.length = 0
-    openSpans.clear()
-    phaseSpan.current = null
-    currentTraceId = null
-  }
-
-  return { handleEvent, getTraces, exportTraces, reset }
-}
+import { EVENT_TYPES } from "../core/constants.mjs"
+import { randomUUID } from "node:crypto"
+
+function newSpanId() {
+  return `span_${randomUUID().slice(0, 12)}`
+}
+
+export function createTracer(options = {}) {
+  const maxTraces = options.maxTraces || 100
+  const maxOpenSpans = options.maxOpenSpans || 500
+  const traces = []
+  const openSpans = new Map()
+  const phaseSpan = { current: null }
+  let currentTraceId = null
+
+  function pruneOpenSpans() {
+    if (openSpans.size <= maxOpenSpans) return
+    // Close oldest spans as "expired"
+    let toDrop = Math.floor(openSpans.size / 2)
+    for (const [key, span] of openSpans) {
+      if (toDrop-- <= 0) break
+      closeSpan(span, "expired")
+      openSpans.delete(key)
+    }
+  }
+
+  function startSpan(name, attributes = {}, parentSpanId = null, timestamp = null) {
+    if (!currentTraceId) currentTraceId = `trace_${randomUUID().slice(0, 12)}`
+    const span = {
+      traceId: currentTraceId,
+      spanId: newSpanId(),
+      parentSpanId,
+      name,
+      startTime: timestamp || Date.now(),
+      endTime: null,
+      duration: null,
+      attributes,
+      status: "ok"
+    }
+    return span
+  }
+
+  function closeSpan(span, status = "ok", timestamp = null) {
+    span.endTime = timestamp || Date.now()
+    span.duration = span.endTime - span.startTime
+    span.status = status
+    traces.push(span)
+    if (traces.length > maxTraces) traces.shift()
+  }
+
+  function handleEvent(event) {
+    const { type, payload, turnId, sessionId, timestamp } = event
+
+    if (type === EVENT_TYPES.TURN_START) {
+      const key = `turn:${turnId}`
+      if (turnId && openSpans.has(key)) {
+        closeSpan(openSpans.get(key), "error", timestamp)
+        openSpans.delete(key)
+      }
+      const span = startSpan("turn", { turnId, sessionId }, null, timestamp)
+      if (turnId) openSpans.set(key, span)
+      pruneOpenSpans()
+    }
+
+    if (type === EVENT_TYPES.TURN_FINISH) {
+      const key = `turn:${turnId}`
+      const span = openSpans.get(key)
+      if (span) {
+        closeSpan(span, "ok", timestamp)
+        openSpans.delete(key)
+      }
+    }
+
+    if (type === EVENT_TYPES.TURN_ERROR) {
+      const key = `turn:${turnId}`
+      const span = openSpans.get(key)
+      if (span) {
+        span.attributes.error = payload?.error || "unknown"
+        closeSpan(span, "error", timestamp)
+        openSpans.delete(key)
+      }
+    }
+
+    if (type === EVENT_TYPES.LONGAGENT_STAGE_STARTED) {
+      const stageId = payload?.stageId
+      if (stageId) {
+        const span = startSpan("stage", { stageId, sessionId }, null, timestamp)
+        openSpans.set(`stage:${stageId}`, span)
+        pruneOpenSpans()
+      }
+    }
+
+    if (type === EVENT_TYPES.LONGAGENT_STAGE_FINISHED) {
+      const stageId = payload?.stageId
+      const key = `stage:${stageId}`
+      const span = openSpans.get(key)
+      if (span) {
+        span.attributes.successCount = payload?.successCount
+        span.attributes.failCount = payload?.failCount
+        closeSpan(span, payload?.allSuccess ? "ok" : "error", timestamp)
+        openSpans.delete(key)
+      }
+    }
+
+    if (type === EVENT_TYPES.LONGAGENT_PHASE_CHANGED) {
+      if (phaseSpan.current) {
+        closeSpan(phaseSpan.current, "ok", timestamp)
+      }
+      const span = startSpan("phase", {
+        phase: payload?.phase || payload?.newPhase,
+        sessionId
+      }, null, timestamp)
+      phaseSpan.current = span
+    }
+  }
+
+  function getTraces() {
+    const result = [...traces]
+    if (phaseSpan.current) result.push({ ...phaseSpan.current, status: "open" })
+    return result
+  }
+
+  function exportTraces(format = "json") {
+    const all = getTraces()
+    if (format === "json") return JSON.stringify(all, null, 2)
+    return JSON.stringify(all)
+  }
+
+  function reset() {
+    traces.length = 0
+    openSpans.clear()
+    phaseSpan.current = null
+    currentTraceId = null
+  }
+
+  return { handleEvent, getTraces, exportTraces, reset }
+}