agentmon/hooks/copilot/handler.js

#!/usr/bin/env node
import { randomUUID } from "node:crypto";
import { hostname } from "node:os";
const INGEST_URL = process.env.AGENTMON_INGEST_URL || "http://localhost:8080";
const FRAMEWORK = process.env.AGENTMON_FRAMEWORK || "copilot";
const HOST = process.env.AGENTMON_HOST || hostname();
const BATCH_SIZE = 10;
const FLUSH_MS = 2e3;
const FETCH_TIMEOUT_MS = 500;
let buffer = [];
let flushTimer = null;
let isFlushing = false;
const activeRuns = /* @__PURE__ */ new Map();
const activeSpans = /* @__PURE__ */ new Map();
function isRecord(value) {
  return value !== null && typeof value === "object" && !Array.isArray(value);
}
function pickString(...values) {
  for (const value of values) {
    if (typeof value === "string" && value.trim() !== "") {
      return value;
    }
  }
  return void 0;
}
function pickNumber(...values) {
  for (const value of values) {
    if (typeof value === "number" && Number.isFinite(value)) {
      return value;
    }
  }
  return void 0;
}
function truncate(value, limit) {
  if (value === void 0 || value === null) {
    return void 0;
  }
  const text = typeof value === "string" ? value : safeJSONStringify(value);
  if (!text) {
    return void 0;
  }
  if (text.length <= limit) {
    return text;
  }
  return text.slice(0, limit) + "...";
}
function safeJSONStringify(value) {
  try {
    return JSON.stringify(value);
  } catch {
    return String(value);
  }
}
function getSessionKey(input) {
  return pickString(
    input.sessionId,
    input.session_id,
    input.conversationId,
    input.conversation_id
  );
}
function getUsage(input) {
  const usage = isRecord(input.usage) ? input.usage : isRecord(input.tokens) ? input.tokens : isRecord(input.llm_usage) ? input.llm_usage : void 0;
  if (!usage)
    return void 0;
  const result = {};
  if (usage.input_tokens !== void 0)
    result.input_tokens = usage.input_tokens;
  if (usage.prompt_tokens !== void 0)
    result.input_tokens = usage.prompt_tokens;
  if (usage.output_tokens !== void 0)
    result.output_tokens = usage.output_tokens;
  if (usage.completion_tokens !== void 0)
    result.output_tokens = usage.completion_tokens;
  if (usage.total_tokens !== void 0)
    result.total_tokens = usage.total_tokens;
  if (usage.cost !== void 0)
    result.total_cost = usage.cost;
  return Object.keys(result).length > 0 ? result : void 0;
}
function buildEnvelope(type, sessionKey, opts = {}) {
  const correlation = {};
  if (sessionKey) {
    correlation.session_id = sessionKey;
  }
  if (opts.runId) {
    correlation.run_id = opts.runId;
  }
  if (opts.spanId) {
    correlation.span_id = opts.spanId;
  }
  if (opts.parentSpanId) {
    correlation.parent_span_id = opts.parentSpanId;
  }
  const envelope = {
    schema: { name: "agentmon.event", version: 1 },
    event: {
      id: randomUUID(),
      type,
      ts: (/* @__PURE__ */ new Date()).toISOString(),
      source: {
        framework: FRAMEWORK,
        client_id: HOST,
        host: HOST
      }
    }
  };
  if (Object.keys(correlation).length > 0) {
    envelope.correlation = correlation;
  }
  if (opts.attributes && Object.keys(opts.attributes).length > 0) {
    envelope.attributes = opts.attributes;
  }
  if (opts.payload && Object.keys(opts.payload).length > 0) {
    envelope.payload = opts.payload;
  }
  return envelope;
}
function scheduleFlush() {
  if (!flushTimer) {
    flushTimer = setTimeout(() => {
      void flush();
    }, FLUSH_MS);
  }
}
function enqueue(event) {
  buffer.push(event);
  if (buffer.length >= BATCH_SIZE) {
    void flush();
  } else {
    scheduleFlush();
  }
}
async function postBatch(batch) {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
  try {
    await fetch(`${INGEST_URL}/v1/events`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(batch),
      signal: controller.signal
    });
  } finally {
    clearTimeout(timeout);
  }
}
async function flush() {
  if (flushTimer) {
    clearTimeout(flushTimer);
    flushTimer = null;
  }
  if (isFlushing || buffer.length === 0) {
    return;
  }
  isFlushing = true;
  const batch = buffer.splice(0, BATCH_SIZE);
  try {
    await postBatch(batch);
  } catch {
    console.debug(`[agentmon] failed to flush ${batch.length} events`);
  } finally {
    isFlushing = false;
    if (buffer.length > 0) {
      if (buffer.length >= BATCH_SIZE) {
        void flush();
      } else {
        scheduleFlush();
      }
    }
  }
}
async function handleSessionStart(input) {
  const sessionKey = getSessionKey(input) || randomUUID();
  const runId = randomUUID();
  activeRuns.set(sessionKey, runId);
  enqueue(buildEnvelope("session.start", sessionKey));
  enqueue(buildEnvelope("run.start", sessionKey, {
    runId,
    payload: {
      prompt_preview: truncate(input.prompt, 200)
    }
  }));
  await flush();
}
async function handleSessionEnd(input) {
  const sessionKey = getSessionKey(input);
  const runId = sessionKey ? activeRuns.get(sessionKey) : void 0;
  const usage = getUsage(input);
  const duration = pickNumber(input.duration_ms, input.elapsed_ms);
  if (runId) {
    enqueue(buildEnvelope("run.end", sessionKey, {
      runId,
      payload: {
        status: "success",
        duration_ms: duration,
        ...usage && { usage }
      }
    }));
  }
  enqueue(buildEnvelope("session.end", sessionKey, {
    payload: usage ? { usage } : void 0
  }));
  activeRuns.delete(sessionKey || "");
  activeSpans.clear();
  await flush();
}
async function handlePromptSubmit(input) {
  const sessionKey = getSessionKey(input);
  const runId = sessionKey ? activeRuns.get(sessionKey) : void 0;
  const prompt = pickString(input.prompt, input.text, input.message);
  if (runId && prompt) {
    enqueue(buildEnvelope("run.end", sessionKey, {
      runId,
      payload: {
        status: "success",
        duration_ms: pickNumber(input.elapsed_ms, input.duration_ms)
      }
    }));
  }
  const newRunId = randomUUID();
  if (sessionKey) {
    activeRuns.set(sessionKey, newRunId);
  }
  enqueue(buildEnvelope("run.start", sessionKey, {
    runId: newRunId,
    payload: {
      prompt_preview: truncate(prompt, 200)
    }
  }));
  await flush();
}
async function handleToolStart(input) {
  const sessionKey = getSessionKey(input);
  const runId = sessionKey ? activeRuns.get(sessionKey) : void 0;
  const toolName = pickString(input.tool, input.tool_name, input.name) || "unknown";
  const toolInput = isRecord(input.input) ? input.input : {};
  const spanId = randomUUID();
  if (sessionKey) {
    activeSpans.set(sessionKey + ":" + toolName, spanId);
  }
  enqueue(buildEnvelope("span.start", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "tool",
      name: toolName
    },
    payload: {
      input: truncate(toolInput, 200)
    }
  }));
  await flush();
}
async function handleToolEnd(input) {
  const sessionKey = getSessionKey(input);
  const runId = sessionKey ? activeRuns.get(sessionKey) : void 0;
  const toolName = pickString(input.tool, input.tool_name, input.name) || "unknown";
  const spanKey = sessionKey ? sessionKey + ":" + toolName : void 0;
  const spanId = spanKey ? activeSpans.get(spanKey) : void 0;
  const result = isRecord(input.result) ? input.result : isRecord(input.output) ? input.output : {};
  const success = !result.error && input.success !== false;
  const duration = pickNumber(input.duration_ms, input.elapsed_ms);
  const usage = getUsage(input);
  enqueue(buildEnvelope("span.end", sessionKey, {
    runId,
    spanId,
    attributes: {
      span_kind: "tool",
      name: toolName
    },
    payload: {
      status: success ? "success" : "error",
      result_preview: truncate(result.output ?? result.error ?? result, 500),
      duration_ms: duration,
      ...usage && { usage }
    }
  }));
  activeSpans.delete(spanKey || "");
  await flush();
}
const handler = async () => {
  const args = process.argv.slice(2);
  const hookType = args[0] || "unknown";
  let input = {};
  try {
    const stdin = await readStdin();
    if (stdin) {
      input = JSON.parse(stdin);
    }
  } catch {
    input = {};
  }
  try {
    switch (hookType) {
      case "start":
        await handleSessionStart(input);
        break;
      case "stop":
        await handleSessionEnd(input);
        break;
      case "prompt":
        await handlePromptSubmit(input);
        break;
      case "tool-start":
        await handleToolStart(input);
        break;
      case "tool-end":
        await handleToolEnd(input);
        break;
      default:
        console.debug(`[agentmon] unknown hook type: ${hookType}`);
    }
  } catch (err) {
    console.debug("[agentmon] handler error:", err);
  }
};
async function readStdin() {
  return new Promise((resolve) => {
    let data = "";
    process.stdin.on("data", (chunk) => data += chunk);
    process.stdin.on("end", () => resolve(data));
    process.stdin.on("error", () => resolve(""));
    setTimeout(() => resolve(data), 100);
  });
}
handler();