@ken-jo/agent-connector 0.1.0

package/dist/chunk-YNZU6PAV.js

@@ -0,0 +1,800 @@
+#!/usr/bin/env node
+import {
+  getTokenizer,
+  inferModelFamily,
+  newRecordId,
+  openStore,
+  worstConfidence
+} from "./chunk-BCHWFTV4.js";
+import {
+  log
+} from "./chunk-KHO5WNTP.js";
+import {
+  LineBuffer,
+  idKey,
+  isObject,
+  spawnChild
+} from "./chunk-WCETQWWK.js";
+import {
+  REGISTERED_PLATFORM_IDS,
+  detectRuntimeHost,
+  loadAdapter
+} from "./chunk-XUCWLJY5.js";
+import {
+  loadRegisteredConnector
+} from "./chunk-LTT56GI3.js";
+import {
+  detectLaunchMethod
+} from "./chunk-MEH7GC7R.js";
+import {
+  dataRoot,
+  ensureDir,
+  projectIdentity
+} from "./chunk-TRQKHP7D.js";
+
+// src/telemetry/measure.ts
+var MODALITY_ESTIMATE = {
+  image: 85,
+  audio: 85,
+  resource: 85
+};
+var UNKNOWN_BLOCK_ESTIMATE = 85;
+function combineSources(sources) {
+  let worst = "host-native";
+  for (const s of sources) worst = worstConfidence(worst, s);
+  return worst;
+}
+function isObject2(v) {
+  return typeof v === "object" && v !== null;
+}
+function isTextBlock(block) {
+  return block.type === "text";
+}
+function measureToolCall(args, result, family, tok = getTokenizer()) {
+  const input = tok.countValue(args, family);
+  const output = measureResult(result, family, tok);
+  return {
+    inputTokens: input.tokens,
+    outputTokens: output.tokens,
+    source: worstConfidence(input.source, output.source)
+  };
+}
+function measureResult(result, family, tok) {
+  if (!isObject2(result)) {
+    return tok.countValue(result, family);
+  }
+  const res = result;
+  const sources = [];
+  let tokens = 0;
+  if (Array.isArray(res.content)) {
+    for (const raw of res.content) {
+      if (!isObject2(raw)) continue;
+      const block = raw;
+      if (isTextBlock(block)) {
+        const text = typeof block.text === "string" ? block.text : "";
+        const c = tok.count(text, family);
+        tokens += c.tokens;
+        sources.push(c.source);
+      } else {
+        const key = typeof block.type === "string" ? block.type : "";
+        tokens += MODALITY_ESTIMATE[key] ?? UNKNOWN_BLOCK_ESTIMATE;
+        sources.push("tokenizer-approx");
+      }
+    }
+  } else if (res.content !== void 0) {
+    const c = tok.countValue(res.content, family);
+    tokens += c.tokens;
+    sources.push(c.source);
+  }
+  if (res.structuredContent !== void 0) {
+    const c = tok.countValue(res.structuredContent, family);
+    tokens += c.tokens;
+    sources.push(c.source);
+  }
+  if (sources.length === 0) {
+    return tok.countValue(result, family);
+  }
+  return { tokens, source: combineSources(sources) };
+}
+function measureToolDefs(tools, family, tok = getTokenizer()) {
+  return tok.countValue(tools, family);
+}
+function measureHook(eventPayload, handlerReturn, family, tok = getTokenizer()) {
+  const input = tok.countValue(eventPayload, family);
+  const output = tok.countValue(handlerReturn, family);
+  return {
+    inputTokens: input.tokens,
+    outputTokens: output.tokens,
+    source: worstConfidence(input.source, output.source)
+  };
+}
+
+// src/runtime/hook-entrypoint.ts
+var ALLOW = { exitCode: 0 };
+function eventToolName(evt) {
+  const name = evt.toolName;
+  return typeof name === "string" ? name : void 0;
+}
+function parseStdin(stdin) {
+  const trimmed = stdin.trim();
+  if (trimmed === "") return {};
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return {};
+  }
+}
+function compileMatcher(matcher) {
+  if (!matcher || matcher === "") return null;
+  try {
+    return new RegExp(matcher);
+  } catch {
+    return null;
+  }
+}
+function normalizeResponse(value) {
+  if (value == null || typeof value !== "object") return { decision: "allow" };
+  return value;
+}
+function resolveHookHostPlatform(platformId, evt) {
+  const override = process.env.AGENT_CONNECTOR_HOST;
+  if (override !== void 0 && REGISTERED_PLATFORM_IDS.has(override)) {
+    return override;
+  }
+  if (REGISTERED_PLATFORM_IDS.has(platformId)) {
+    return platformId;
+  }
+  const fromEvent = evt.hostPlatform;
+  if (typeof fromEvent === "string" && REGISTERED_PLATFORM_IDS.has(fromEvent)) {
+    return fromEvent;
+  }
+  return "unknown";
+}
+function recordHookTelemetry(opts, connector, evt, response) {
+  if (process.env.AGENT_CONNECTOR_TELEMETRY === "0") return;
+  try {
+    const family = inferModelFamily("", connector.telemetry.modelFamilyHint);
+    const measurement = measureHook(evt, response, family, getTokenizer());
+    const sessionId = typeof evt.sessionId === "string" ? evt.sessionId : "";
+    const evtProjectDir = evt.projectDir;
+    const projectDir = typeof evtProjectDir === "string" && evtProjectDir !== "" ? evtProjectDir : process.cwd();
+    const id = projectIdentity(projectDir);
+    const store = openStore({});
+    try {
+      store.append({
+        id: newRecordId(0),
+        ts: Date.now(),
+        connectorId: opts.connectorId,
+        toolName: opts.event,
+        // for a hook row the per-item name IS the event
+        scope: "hook",
+        surfaceKind: "hook",
+        hostPlatform: resolveHookHostPlatform(opts.platformId, evt),
+        sessionId,
+        projectKey: id.key,
+        projectDir: id.dir,
+        inputTokens: measurement.inputTokens,
+        outputTokens: measurement.outputTokens,
+        confidenceSource: measurement.source,
+        isError: false
+      });
+    } finally {
+      store.close();
+    }
+  } catch {
+  }
+}
+async function runHook(opts) {
+  const { platformId, event, connectorId, stdin } = opts;
+  try {
+    const connector = await loadRegisteredConnector(connectorId);
+    const adapter = await loadAdapter(platformId);
+    if (!adapter || !adapter.parseEvent || !adapter.formatReply) {
+      return ALLOW;
+    }
+    const raw = parseStdin(stdin);
+    const evt = adapter.parseEvent(event, raw);
+    evt.connectorId = connectorId;
+    const definition = connector.hooks[event];
+    if (!definition || typeof definition.handler !== "function") {
+      return ALLOW;
+    }
+    const toolName = eventToolName(evt);
+    if (toolName !== void 0) {
+      const re = compileMatcher(definition.matcher);
+      if (re && !re.test(toolName)) return ALLOW;
+    }
+    const handlerResult = await definition.handler(
+      // The adapter parsed `evt` as exactly this event's payload type; the
+      // HooksConfig handler for the same event expects that payload.
+      evt
+    );
+    const response = normalizeResponse(handlerResult);
+    recordHookTelemetry(opts, connector, evt, response);
+    const reply = adapter.formatReply(event, response);
+    return {
+      exitCode: reply.exitCode,
+      ...reply.stdout !== void 0 ? { stdout: reply.stdout } : {},
+      ...reply.stderr !== void 0 ? { stderr: reply.stderr } : {}
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error(`hook ${platformId}/${event} (${connectorId}) failed:`, message);
+    return failOpenOrPreserveDeny(opts, message);
+  }
+}
+async function failOpenOrPreserveDeny(opts, errorMessage) {
+  if (opts.event !== "PreToolUse") return ALLOW;
+  try {
+    const connector = await loadRegisteredConnector(opts.connectorId);
+    const adapter = await loadAdapter(opts.platformId);
+    if (!adapter?.parseEvent || !adapter.formatReply) return ALLOW;
+    const definition = connector.hooks.PreToolUse;
+    if (!definition || typeof definition.handler !== "function") return ALLOW;
+    const raw = parseStdin(opts.stdin);
+    const evt = adapter.parseEvent("PreToolUse", raw);
+    evt.connectorId = opts.connectorId;
+    const toolName = eventToolName(evt);
+    if (toolName !== void 0) {
+      const re = compileMatcher(definition.matcher);
+      if (re && !re.test(toolName)) return ALLOW;
+    }
+    const response = normalizeResponse(await definition.handler(evt));
+    if (response.decision !== "deny") return ALLOW;
+    const reply = adapter.formatReply("PreToolUse", response);
+    return {
+      exitCode: reply.exitCode,
+      ...reply.stdout !== void 0 ? { stdout: reply.stdout } : {},
+      ...reply.stderr !== void 0 ? { stderr: reply.stderr } : { stderr: errorMessage }
+    };
+  } catch {
+    return ALLOW;
+  }
+}
+
+// src/runtime/serve.ts
+import { randomUUID } from "crypto";
+
+// src/telemetry/calibration.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function isCalibrationEnabled() {
+  const families = (process.env.AGENT_CONNECTOR_CALIBRATE || "").split(",").map((s) => s.trim()).filter((s) => s !== "");
+  const key = (process.env.ANTHROPIC_API_KEY || "").trim();
+  return families.includes("anthropic") && key !== "";
+}
+function calibrationPath() {
+  return join(dataRoot(), "calibration.json");
+}
+var RATIO_MIN = 0.2;
+var RATIO_MAX = 5;
+function clampRatio(ratio) {
+  if (!Number.isFinite(ratio) || ratio <= 0) return null;
+  if (ratio < RATIO_MIN) return RATIO_MIN;
+  if (ratio > RATIO_MAX) return RATIO_MAX;
+  return ratio;
+}
+function loadFactors() {
+  const path = calibrationPath();
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object") return {};
+    const out = {};
+    for (const [family, value] of Object.entries(parsed)) {
+      if (value === null || typeof value !== "object") continue;
+      const rec = value;
+      const factor = rec["factor"];
+      const samples = rec["samples"];
+      if (typeof factor === "number" && Number.isFinite(factor) && factor > 0 && typeof samples === "number" && Number.isFinite(samples) && samples >= 0) {
+        out[family] = {
+          factor,
+          samples
+        };
+      }
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function recordSample(family, ratio) {
+  const clamped = clampRatio(ratio);
+  if (clamped === null) return;
+  try {
+    const factors = loadFactors();
+    const prior = factors[family];
+    let next;
+    if (prior === void 0 || prior.samples <= 0) {
+      next = { factor: clamped, samples: 1 };
+    } else {
+      const samples = prior.samples + 1;
+      const factor = prior.factor + (clamped - prior.factor) / samples;
+      next = { factor, samples };
+    }
+    const updated = { ...factors, [family]: next };
+    const path = calibrationPath();
+    ensureDir(dataRoot());
+    writeFileSync(path, `${JSON.stringify(updated, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+var DEFAULT_ANTHROPIC_MODEL = "claude-3-5-sonnet-latest";
+var COUNT_TOKENS_URL = "https://api.anthropic.com/v1/messages/count_tokens";
+async function countTokensAnthropic(text, model = DEFAULT_ANTHROPIC_MODEL) {
+  const apiKey = (process.env.ANTHROPIC_API_KEY || "").trim();
+  if (apiKey === "") return null;
+  try {
+    const res = await fetch(COUNT_TOKENS_URL, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: text }]
+      })
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    const n = body.input_tokens;
+    if (typeof n === "number" && Number.isFinite(n) && n >= 0) {
+      return n;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var SAMPLE_EVERY = 20;
+var MAX_SAMPLES_PER_MINUTE = 10;
+var callCounter = 0;
+var windowStartMs = 0;
+var samplesThisWindow = 0;
+function shouldSample(now = Date.now()) {
+  if (now - windowStartMs >= 6e4) {
+    windowStartMs = now;
+    samplesThisWindow = 0;
+  }
+  callCounter += 1;
+  if (callCounter % SAMPLE_EVERY !== 0) return false;
+  if (samplesThisWindow >= MAX_SAMPLES_PER_MINUTE) return false;
+  samplesThisWindow += 1;
+  return true;
+}
+function applyCalibration(approxTokens, family, factors = loadFactors()) {
+  if (family === "anthropic") {
+    const f = factors[family];
+    if (f !== void 0 && f.samples > 0 && Number.isFinite(f.factor) && f.factor > 0) {
+      return {
+        tokens: Math.max(0, Math.round(approxTokens * f.factor)),
+        source: "tokenizer-calibrated"
+      };
+    }
+  }
+  return { tokens: approxTokens, source: "tokenizer-approx" };
+}
+function modelForFamily(_family) {
+  return DEFAULT_ANTHROPIC_MODEL;
+}
+
+// src/telemetry/proxy.ts
+function canonicalArgs(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+async function runServeProxy(opts) {
+  const {
+    connectorId,
+    command,
+    args,
+    store,
+    tokenizer,
+    modelFamilyHint,
+    hostPlatform,
+    sessionId,
+    projectKey,
+    projectDir,
+    measureToolDefs: shouldMeasureToolDefs,
+    installScope,
+    launchMethod
+  } = opts;
+  const measuringEnabled = process.env.AGENT_CONNECTOR_TELEMETRY !== "0";
+  const calibrationEnabled = isCalibrationEnabled();
+  const child = spawnChild(command, args, {
+    stdio: ["pipe", "pipe", "inherit"],
+    env: process.env
+  });
+  let family = inferModelFamily("", modelFamilyHint);
+  const pending = /* @__PURE__ */ new Map();
+  let seq = 0;
+  let toolDefsMeasured = false;
+  function baseRecord() {
+    return {
+      id: newRecordId(seq++),
+      ts: Date.now(),
+      connectorId,
+      hostPlatform,
+      sessionId,
+      projectKey,
+      projectDir,
+      ...installScope !== void 0 ? { installScope } : {},
+      ...launchMethod !== void 0 ? { launchMethod } : {}
+    };
+  }
+  function onClientMessage(msg) {
+    const method = msg.method;
+    if (method === "initialize") {
+      const params = isObject(msg.params) ? msg.params : void 0;
+      const clientInfo = params && isObject(params["clientInfo"]) ? params["clientInfo"] : void 0;
+      const clientName = clientInfo && typeof clientInfo["name"] === "string" ? clientInfo["name"] : "";
+      family = inferModelFamily(clientName, modelFamilyHint);
+      return;
+    }
+    if (method === "tools/call") {
+      const key = idKey(msg.id);
+      if (key === null) return;
+      const params = isObject(msg.params) ? msg.params : void 0;
+      const toolName = params && typeof params["name"] === "string" ? params["name"] : "unknown";
+      const callArgs = params ? params["arguments"] : void 0;
+      pending.set(key, { toolName, args: callArgs });
+    }
+  }
+  function onServerMessage(msg) {
+    const key = idKey(msg.id);
+    if (key === null) return;
+    const pendingCall = pending.get(key);
+    if (pendingCall !== void 0) {
+      pending.delete(key);
+      recordToolCall(pendingCall, msg);
+      return;
+    }
+    if (shouldMeasureToolDefs && !toolDefsMeasured) {
+      const result = isObject(msg.result) ? msg.result : void 0;
+      const tools = result ? result["tools"] : void 0;
+      if (Array.isArray(tools)) {
+        recordToolDefs(tools);
+      }
+    }
+  }
+  function recordToolCall(call, response) {
+    const hasError = response.error !== void 0;
+    const result = response.result;
+    const resultForMeasure = hasError ? {} : result;
+    const measurement = measureToolCall(
+      call.args,
+      resultForMeasure,
+      family,
+      tokenizer
+    );
+    let inputTokens = measurement.inputTokens;
+    let outputTokens = measurement.outputTokens;
+    let confidenceSource = measurement.source;
+    if (calibrationEnabled && family === "anthropic") {
+      try {
+        ({ inputTokens, outputTokens, confidenceSource } = calibrateCounts(
+          measurement.inputTokens,
+          measurement.outputTokens,
+          measurement.source
+        ));
+        maybeSampleCalibration(call.args, measurement.inputTokens);
+      } catch {
+      }
+    }
+    const resultIsError = isObject(result) && result["isError"] === true;
+    store.append({
+      ...baseRecord(),
+      toolName: call.toolName,
+      scope: "call",
+      inputTokens,
+      outputTokens,
+      confidenceSource,
+      isError: hasError || resultIsError
+    });
+  }
+  function calibrateCounts(rawIn, rawOut, rawSource) {
+    if (rawSource !== "tokenizer-approx") {
+      return { inputTokens: rawIn, outputTokens: rawOut, confidenceSource: rawSource };
+    }
+    const cin = applyCalibration(rawIn, family);
+    const cout = applyCalibration(rawOut, family);
+    const calibrated = cin.source === "tokenizer-calibrated" || cout.source === "tokenizer-calibrated";
+    return {
+      inputTokens: cin.tokens,
+      outputTokens: cout.tokens,
+      confidenceSource: calibrated ? "tokenizer-calibrated" : "tokenizer-approx"
+    };
+  }
+  function maybeSampleCalibration(args2, approxInputTokens) {
+    if (approxInputTokens <= 0) return;
+    if (!shouldSample()) return;
+    const text = canonicalArgs(args2);
+    if (text === "") return;
+    void countTokensAnthropic(text, modelForFamily(family)).then((exact) => {
+      if (exact !== null && exact > 0) {
+        recordSample(family, exact / approxInputTokens);
+      }
+    }).catch(() => {
+    });
+  }
+  function recordToolDefs(tools) {
+    toolDefsMeasured = true;
+    const count = measureToolDefs(tools, family, tokenizer);
+    store.append({
+      ...baseRecord(),
+      toolName: "*",
+      scope: "tool_defs",
+      inputTokens: count.tokens,
+      outputTokens: 0,
+      confidenceSource: count.source,
+      isError: false
+    });
+  }
+  function handleLine(line, direction) {
+    if (!measuringEnabled) return;
+    let msg;
+    try {
+      const parsed = JSON.parse(line);
+      if (!isObject(parsed)) return;
+      msg = parsed;
+    } catch {
+      return;
+    }
+    try {
+      if (direction === "client") onClientMessage(msg);
+      else onServerMessage(msg);
+    } catch {
+    }
+  }
+  const clientLines = new LineBuffer((line) => handleLine(line, "client"));
+  const serverLines = new LineBuffer((line) => handleLine(line, "server"));
+  process.stdin.on("data", (chunk) => {
+    if (child.stdin && child.stdin.writable) {
+      const ok = child.stdin.write(chunk);
+      if (!ok) {
+        process.stdin.pause();
+        child.stdin.once("drain", () => process.stdin.resume());
+      }
+    }
+    if (measuringEnabled) {
+      try {
+        clientLines.push(chunk);
+      } catch {
+      }
+    }
+  });
+  process.stdin.on("end", () => {
+    if (child.stdin && !child.stdin.destroyed) child.stdin.end();
+  });
+  if (child.stdout) {
+    const childStdout = child.stdout;
+    childStdout.on("data", (chunk) => {
+      const ok = process.stdout.write(chunk);
+      if (!ok) {
+        childStdout.pause();
+        process.stdout.once("drain", () => childStdout.resume());
+      }
+      if (measuringEnabled) {
+        try {
+          serverLines.push(chunk);
+        } catch {
+        }
+      }
+    });
+  }
+  const forwardSignal = (signal) => {
+    try {
+      if (!child.killed) child.kill(signal);
+    } catch {
+    }
+  };
+  const onSigint = () => forwardSignal("SIGINT");
+  const onSigterm = () => forwardSignal("SIGTERM");
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  return await new Promise((resolve) => {
+    const finish = (code) => {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGTERM", onSigterm);
+      try {
+        store.close();
+      } catch {
+      }
+      resolve(code);
+    };
+    child.on("error", () => {
+      finish(126);
+    });
+    child.on("close", (code, signal) => {
+      if (typeof code === "number") {
+        finish(code);
+        return;
+      }
+      if (signal) {
+        const num = signalToNumber(signal);
+        finish(num === void 0 ? 1 : 128 + num);
+        return;
+      }
+      finish(1);
+    });
+  });
+}
+function signalToNumber(signal) {
+  const table = {
+    SIGINT: 2,
+    SIGQUIT: 3,
+    SIGKILL: 9,
+    SIGTERM: 15
+  };
+  return table[signal];
+}
+
+// src/runtime/serve.ts
+function resolveSessionId(env = process.env) {
+  return env.AGENT_CONNECTOR_SESSION || env.CLAUDE_SESSION_ID || env.CODEX_THREAD_ID || env.CURSOR_TRACE_ID || env.MCP_SESSION_ID || `proc-${randomUUID()}`;
+}
+async function runServe(opts) {
+  const { connectorId, serverCommand, serverArgs, installScope, hostPlatformOverride } = opts;
+  const connector = await loadRegisteredConnector(connectorId);
+  const id = projectIdentity(process.cwd());
+  const hostPlatform = hostPlatformOverride !== void 0 && REGISTERED_PLATFORM_IDS.has(hostPlatformOverride) ? hostPlatformOverride : detectRuntimeHost().platform;
+  const sessionId = resolveSessionId();
+  const launchMethod = detectLaunchMethod(serverCommand, serverArgs);
+  const store = openStore({});
+  const tok = getTokenizer();
+  return runServeProxy({
+    connectorId,
+    command: serverCommand,
+    args: serverArgs,
+    store,
+    tokenizer: tok,
+    modelFamilyHint: connector.telemetry.modelFamilyHint,
+    hostPlatform,
+    sessionId,
+    projectKey: id.key,
+    projectDir: id.dir,
+    measureToolDefs: connector.telemetry.measureToolDefs,
+    installScope,
+    launchMethod
+  });
+}
+
+// src/runtime/usage-event.ts
+var NOOP = { exitCode: 0, recorded: false };
+function isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function toNonNegInt(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return Math.floor(n);
+}
+function firstStr(obj, keys) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === "string" && v.trim() !== "") return v;
+  }
+  return void 0;
+}
+function tokenField(meta, keys) {
+  for (const k of keys) {
+    if (k in meta) return toNonNegInt(meta[k]);
+  }
+  return 0;
+}
+function findUsageMetadata(root) {
+  for (const k of ["usageMetadata", "usage_metadata"]) {
+    if (isObject3(root[k])) return root[k];
+  }
+  for (const k of ["response", "modelResponse", "model_response"]) {
+    const nested = root[k];
+    if (isObject3(nested)) {
+      for (const mk of ["usageMetadata", "usage_metadata"]) {
+        if (isObject3(nested[mk])) return nested[mk];
+      }
+    }
+  }
+  return void 0;
+}
+var KNOWN_PLATFORMS = /* @__PURE__ */ new Set([
+  "claude-code",
+  "codex",
+  "cursor",
+  "vscode-copilot",
+  "jetbrains-copilot",
+  "copilot-cli",
+  "gemini-cli",
+  "opencode",
+  "kilo",
+  "kilo-cli",
+  "warp",
+  "hermes",
+  "openclaw",
+  "zed",
+  "antigravity",
+  "antigravity-cli",
+  "kiro",
+  "qwen-code",
+  "kimi",
+  "pi",
+  "omp",
+  "droid",
+  "roo-code",
+  "trae",
+  "amp",
+  "codebuff",
+  "mux",
+  "crush",
+  "goose",
+  "synthetic",
+  "unknown"
+]);
+function asPlatformId(id) {
+  return KNOWN_PLATFORMS.has(id) ? id : "unknown";
+}
+async function runUsageEvent(opts) {
+  try {
+    const trimmed = opts.stdin.trim();
+    if (trimmed === "") return NOOP;
+    let raw;
+    try {
+      raw = JSON.parse(trimmed);
+    } catch {
+      return NOOP;
+    }
+    if (!isObject3(raw)) return NOOP;
+    const meta = findUsageMetadata(raw);
+    if (meta === void 0) return NOOP;
+    const promptTokens = tokenField(meta, ["promptTokenCount", "prompt_token_count"]);
+    const candidates = tokenField(meta, ["candidatesTokenCount", "candidates_token_count"]);
+    const cached = tokenField(meta, ["cachedContentTokenCount", "cached_content_token_count"]);
+    const thoughts = tokenField(meta, ["thoughtsTokenCount", "thoughts_token_count"]);
+    const inputTokens = Math.max(0, promptTokens - Math.min(cached, promptTokens));
+    const outputTokens = candidates + thoughts;
+    if (inputTokens === 0 && outputTokens === 0) return NOOP;
+    const sessionId = firstStr(raw, ["session_id", "sessionId", "conversationId", "conversation_id"]) ?? "";
+    const cwd = firstStr(raw, ["cwd", "workspace", "projectDir", "project_dir"]) ?? process.cwd();
+    const id = projectIdentity(cwd);
+    const record = {
+      id: newRecordId(0),
+      ts: Date.now(),
+      connectorId: opts.connectorId,
+      toolName: "*",
+      scope: "model_turn",
+      hostPlatform: asPlatformId(opts.platformId),
+      sessionId,
+      projectKey: id.key,
+      projectDir: id.dir,
+      inputTokens,
+      outputTokens,
+      confidenceSource: "host-native",
+      isError: false
+    };
+    const store = openStore({});
+    try {
+      store.append(record);
+    } finally {
+      try {
+        store.close();
+      } catch {
+      }
+    }
+    return { exitCode: 0, recorded: true };
+  } catch {
+    return NOOP;
+  }
+}
+
+export {
+  runHook,
+  runServe,
+  runUsageEvent
+};
+//# sourceMappingURL=chunk-YNZU6PAV.js.map