@ken-jo/agent-connector 0.1.0

package/dist/chunk-BCHWFTV4.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import {
+  ensureDir,
+  telemetryPath
+} from "./chunk-TRQKHP7D.js";
+
+// src/telemetry/store.ts
+import { appendFileSync, existsSync, readFileSync } from "fs";
+import { dirname } from "path";
+
+// src/telemetry/types.ts
+var CONFIDENCE_RANK = {
+  heuristic: 0,
+  "tokenizer-approx": 1,
+  "tokenizer-calibrated": 2,
+  "tokenizer-exact": 3,
+  "host-native": 4
+};
+function worstConfidence(a, b) {
+  return CONFIDENCE_RANK[b] < CONFIDENCE_RANK[a] ? b : a;
+}
+
+// src/telemetry/store.ts
+function telemetryDisabled() {
+  return process.env.AGENT_CONNECTOR_TELEMETRY === "0";
+}
+function newRecordId(seq) {
+  return `${Date.now()}-${seq}`;
+}
+var NdjsonStore = class {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  append(record) {
+    if (telemetryDisabled()) return;
+    ensureDir(dirname(this.path));
+    appendFileSync(this.path, `${JSON.stringify(record)}
+`, "utf8");
+  }
+  query(filter) {
+    if (!existsSync(this.path)) return [];
+    let text;
+    try {
+      text = readFileSync(this.path, "utf8");
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      let record;
+      try {
+        record = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (matches(record, filter)) out.push(record);
+    }
+    return out;
+  }
+  rollup(by, filter) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const record of this.query(filter)) {
+      const key = groupKey(record, by);
+      const existing = groups.get(key);
+      if (existing === void 0) {
+        groups.set(key, {
+          key,
+          calls: 1,
+          inputTokens: record.inputTokens,
+          outputTokens: record.outputTokens,
+          totalTokens: record.inputTokens + record.outputTokens,
+          confidence: record.confidenceSource,
+          lastTs: record.ts
+        });
+      } else {
+        existing.calls += 1;
+        existing.inputTokens += record.inputTokens;
+        existing.outputTokens += record.outputTokens;
+        existing.totalTokens += record.inputTokens + record.outputTokens;
+        existing.confidence = worstConfidence(
+          existing.confidence,
+          record.confidenceSource
+        );
+        if (record.ts > existing.lastTs) existing.lastTs = record.ts;
+      }
+    }
+    return [...groups.values()];
+  }
+  close() {
+  }
+};
+function matches(record, filter) {
+  if (filter.connectorId !== void 0 && record.connectorId !== filter.connectorId) {
+    return false;
+  }
+  if (filter.projectKey !== void 0 && record.projectKey !== filter.projectKey) {
+    return false;
+  }
+  if (filter.sessionId !== void 0 && record.sessionId !== filter.sessionId) {
+    return false;
+  }
+  if (filter.toolName !== void 0 && record.toolName !== filter.toolName) {
+    return false;
+  }
+  if (filter.sinceMs !== void 0 && record.ts < filter.sinceMs) {
+    return false;
+  }
+  return true;
+}
+function groupKey(record, by) {
+  switch (by) {
+    case "tool":
+      return record.toolName;
+    case "session":
+      return record.sessionId;
+    case "project":
+      return record.projectDir;
+  }
+}
+function openStore(opts) {
+  const path = opts?.path ?? telemetryPath("ndjson");
+  return new NdjsonStore(path);
+}
+
+// src/telemetry/tokenizer.ts
+import { createRequire } from "module";
+var requireCjs = createRequire(import.meta.url);
+var encoderState;
+var HEURISTIC_CHARS_PER_TOKEN = 4;
+function loadEncoder() {
+  if (encoderState !== void 0) return encoderState;
+  try {
+    const mod = requireCjs("gpt-tokenizer/encoding/o200k_base");
+    if (mod && typeof mod.encode === "function") {
+      encoderState = { encode: mod.encode.bind(mod) };
+    } else {
+      encoderState = null;
+    }
+  } catch {
+    encoderState = null;
+  }
+  return encoderState;
+}
+function heuristicCount(text) {
+  return {
+    tokens: Math.ceil(text.length / HEURISTIC_CHARS_PER_TOKEN),
+    source: "heuristic"
+  };
+}
+function bpeSource(family) {
+  return family === "openai" ? "tokenizer-exact" : "tokenizer-approx";
+}
+var DefaultTokenizer = class {
+  count(text, family) {
+    const encoder = loadEncoder();
+    if (!encoder) return heuristicCount(text);
+    try {
+      return { tokens: encoder.encode(text).length, source: bpeSource(family) };
+    } catch {
+      return heuristicCount(text);
+    }
+  }
+  countValue(value, family) {
+    return this.count(canonicalString(value), family);
+  }
+};
+function canonicalString(value) {
+  if (typeof value === "string") return value;
+  const json = JSON.stringify(value);
+  return json ?? "";
+}
+var SHARED_TOKENIZER = new DefaultTokenizer();
+function getTokenizer() {
+  return SHARED_TOKENIZER;
+}
+function inferModelFamily(clientName, hint) {
+  if (hint !== "auto") return hint;
+  const name = clientName.toLowerCase();
+  if (name.includes("claude") || name.includes("anthropic")) return "anthropic";
+  if (name.includes("codex") || name.includes("gpt") || name.includes("openai")) {
+    return "openai";
+  }
+  return "generic";
+}
+
+export {
+  worstConfidence,
+  newRecordId,
+  openStore,
+  getTokenizer,
+  inferModelFamily
+};
+//# sourceMappingURL=chunk-BCHWFTV4.js.map

package/dist/chunk-BCHWFTV4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/telemetry/store.ts","../src/telemetry/types.ts","../src/telemetry/tokenizer.ts"],"sourcesContent":["/**\n * telemetry/store — the default NDJSON {@link TelemetryStore} implementation.\n *\n * Local-first, dependency-free persistence. One JSON object per line; appends\n * are atomic enough for concurrent multi-host writers (a single `appendFileSync`\n * of a `<line>\\n` chunk is written in one `write(2)` for small payloads, so\n * interleaving across processes does not corrupt individual records). A\n * SQLite/WAL backend is a drop-in upgrade behind the same interface.\n *\n * Telemetry stores AGGREGATE COUNTS ONLY — raw tool arguments/results are never\n * persisted (enforced by the {@link ToolEventRecord} shape, which carries no\n * content fields).\n *\n * Global kill switch: AGENT_CONNECTOR_TELEMETRY=0 makes `append` a no-op so a\n * disabled telemetry layer can never touch disk or break a host's tool call.\n */\n\nimport { appendFileSync, existsSync, readFileSync } from \"node:fs\";\nimport { dirname } from \"node:path\";\n\nimport { ensureDir, telemetryPath } from \"../core/paths.js\";\nimport { worstConfidence } from \"./types.js\";\nimport type {\n  QueryFilter,\n  RollupRow,\n  TelemetryStore,\n  ToolEventRecord,\n} from \"./types.js\";\n\n/** Options for {@link openStore}. */\nexport interface OpenStoreOptions {\n  /** Override the NDJSON file path. Defaults to telemetryPath(\"ndjson\"). */\n  path?: string;\n}\n\n// Confidence ranking + worst-of comparison live in ./types (the single source\n// of truth) so a new ConfidenceSource value orders correctly everywhere.\n\n/** Is `process.env.AGENT_CONNECTOR_TELEMETRY` an explicit off switch? */\nfunction telemetryDisabled(): boolean {\n  return process.env.AGENT_CONNECTOR_TELEMETRY === \"0\";\n}\n\n/**\n * A unique-enough record id. Combines the wall clock with a caller-supplied\n * sequence so two records written in the same millisecond still differ.\n */\nexport function newRecordId(seq: number): string {\n  return `${Date.now()}-${seq}`;\n}\n\nclass NdjsonStore implements TelemetryStore {\n  private readonly path: string;\n\n  constructor(path: string) {\n    this.path = path;\n  }\n\n  append(record: ToolEventRecord): void {\n    if (telemetryDisabled()) return;\n    ensureDir(dirname(this.path));\n    appendFileSync(this.path, `${JSON.stringify(record)}\\n`, \"utf8\");\n  }\n\n  query(filter: QueryFilter): ToolEventRecord[] {\n    if (!existsSync(this.path)) return [];\n\n    let text: string;\n    try {\n      text = readFileSync(this.path, \"utf8\");\n    } catch {\n      return [];\n    }\n\n    const out: ToolEventRecord[] = [];\n    for (const line of text.split(\"\\n\")) {\n      const trimmed = line.trim();\n      if (trimmed === \"\") continue;\n\n      let record: ToolEventRecord;\n      try {\n        record = JSON.parse(trimmed) as ToolEventRecord;\n      } catch {\n        continue; // skip malformed lines\n      }\n\n      if (matches(record, filter)) out.push(record);\n    }\n    return out;\n  }\n\n  rollup(by: \"tool\" | \"session\" | \"project\", filter: QueryFilter): RollupRow[] {\n    const groups = new Map<string, RollupRow>();\n\n    for (const record of this.query(filter)) {\n      const key = groupKey(record, by);\n      const existing = groups.get(key);\n      if (existing === undefined) {\n        groups.set(key, {\n          key,\n          calls: 1,\n          inputTokens: record.inputTokens,\n          outputTokens: record.outputTokens,\n          totalTokens: record.inputTokens + record.outputTokens,\n          confidence: record.confidenceSource,\n          lastTs: record.ts,\n        });\n      } else {\n        existing.calls += 1;\n        existing.inputTokens += record.inputTokens;\n        existing.outputTokens += record.outputTokens;\n        existing.totalTokens += record.inputTokens + record.outputTokens;\n        existing.confidence = worstConfidence(\n          existing.confidence,\n          record.confidenceSource,\n        );\n        if (record.ts > existing.lastTs) existing.lastTs = record.ts;\n      }\n    }\n\n    return [...groups.values()];\n  }\n\n  close(): void {\n    /* no-op for the NDJSON backend */\n  }\n}\n\n/** Does a record satisfy every set field of the filter? */\nfunction matches(record: ToolEventRecord, filter: QueryFilter): boolean {\n  if (\n    filter.connectorId !== undefined &&\n    record.connectorId !== filter.connectorId\n  ) {\n    return false;\n  }\n  if (\n    filter.projectKey !== undefined &&\n    record.projectKey !== filter.projectKey\n  ) {\n    return false;\n  }\n  if (filter.sessionId !== undefined && record.sessionId !== filter.sessionId) {\n    return false;\n  }\n  if (filter.toolName !== undefined && record.toolName !== filter.toolName) {\n    return false;\n  }\n  if (filter.sinceMs !== undefined && record.ts < filter.sinceMs) {\n    return false;\n  }\n  return true;\n}\n\n/** Resolve the grouping key value for a record under the requested dimension. */\nfunction groupKey(\n  record: ToolEventRecord,\n  by: \"tool\" | \"session\" | \"project\",\n): string {\n  switch (by) {\n    case \"tool\":\n      return record.toolName;\n    case \"session\":\n      return record.sessionId;\n    case \"project\":\n      return record.projectDir;\n  }\n}\n\n/**\n * Open the default local telemetry store. NDJSON backend; no native deps. The\n * returned store is safe to use even when telemetry is disabled — `append`\n * becomes a no-op and reads of a missing file return empty results.\n */\nexport function openStore(opts?: OpenStoreOptions): TelemetryStore {\n  const path = opts?.path ?? telemetryPath(\"ndjson\");\n  return new NdjsonStore(path);\n}\n","/**\n * telemetry/types — runtime telemetry contracts.\n *\n * The framework measures the MCP server's OWN bytes (tool args in, tool result\n * out, tool-definition schemas) and tokenizes them locally — the only signal\n * identical across every host (no host reports per-tool usage to a server).\n * Records are aggregate counts only; raw arguments/results are NEVER stored.\n */\n\nimport type { PlatformId } from \"../core/types.js\";\n\n/** Provenance of a token count — surfaced so \"estimate\" is never read as \"exact\". */\nexport type ConfidenceSource =\n  | \"tokenizer-exact\" // real BPE for a matching model family\n  | \"tokenizer-calibrated\" // approx adjusted by a sampled Anthropic count_tokens factor\n  | \"tokenizer-approx\" // real BPE used as a documented approximation (e.g. Anthropic)\n  | \"heuristic\" // chars/4 fallback\n  | \"host-native\"; // a host actually reported usage (e.g. Gemini AfterModel)\n\n/**\n * Confidence ranking, least-trustworthy (0) → most-trustworthy. The single\n * source of truth for ordering {@link ConfidenceSource} values; every\n * worst-of comparison across the telemetry subsystem (store rollup, both\n * leaderboards, report, measure) reads through {@link rankOf} /\n * {@link worstConfidence} so a new value orders correctly everywhere.\n *\n *   heuristic < tokenizer-approx < tokenizer-calibrated < tokenizer-exact < host-native\n *\n * `tokenizer-calibrated` sits between the raw approximation and an exact\n * family-matched BPE count: it is an approximation nudged toward truth by a\n * sampled real count_tokens factor, so it is more trustworthy than bare approx\n * but still not the exact encoding for the target family.\n */\nexport const CONFIDENCE_RANK: Record<ConfidenceSource, number> = {\n  heuristic: 0,\n  \"tokenizer-approx\": 1,\n  \"tokenizer-calibrated\": 2,\n  \"tokenizer-exact\": 3,\n  \"host-native\": 4,\n};\n\n/** Trust rank of a single {@link ConfidenceSource} (higher = more trustworthy). */\nexport function rankOf(c: ConfidenceSource): number {\n  return CONFIDENCE_RANK[c];\n}\n\n/** Return whichever source is the worse (least-confident) of the two. */\nexport function worstConfidence(\n  a: ConfidenceSource,\n  b: ConfidenceSource,\n): ConfidenceSource {\n  return CONFIDENCE_RANK[b] < CONFIDENCE_RANK[a] ? b : a;\n}\n\nexport type ModelFamily = \"openai\" | \"anthropic\" | \"generic\";\n\nexport interface TokenCount {\n  tokens: number;\n  source: ConfidenceSource;\n}\n\n/** Pluggable tokenizer. Default impl uses gpt-tokenizer; fallback is chars/4. */\nexport interface Tokenizer {\n  /** Count tokens for a string under the given model family. */\n  count(text: string, family: ModelFamily): TokenCount;\n  /** Count tokens for an arbitrary JSON value (serialized canonically first). */\n  countValue(value: unknown, family: ModelFamily): TokenCount;\n}\n\n/**\n * What a record measures. DISTINCT origins that must never be summed:\n *   • `call`       — one per-MCP `tools/call` round-trip (serve-proxy bytes).\n *   • `tool_defs`  — the one-time `tools/list` schema overhead (serve-proxy).\n *   • `model_turn` — a WHOLE-CONVERSATION host-native turn reported by the host\n *     (e.g. Gemini/Antigravity AfterModel `usageMetadata`). This is NOT per-MCP:\n *     it covers the entire model turn, so the MCP leaderboard EXCLUDES it (just\n *     as it treats `tool_defs` specially) and it is surfaced as its own labeled\n *     section rather than added to the per-MCP `call` totals or to the\n *     usage-reader host-scan numbers.\n *   • `hook`       — one RUNTIME hook dispatch through the home-bin `hook`\n *     entrypoint (src/runtime/hook-entrypoint). The framework tokenizes the\n *     inbound normalized event payload the handler reads (input) and what the\n *     handler returns that becomes context/decision (output). The per-item\n *     `toolName` is the hook EVENT name (e.g. \"SessionStart\"). This is the\n *     developer-axis \"hook\" surface — measured live, like `call`.\n */\nexport type EventScope = \"call\" | \"tool_defs\" | \"model_turn\" | \"hook\";\n\n/**\n * Which of the FIVE developer-axis surfaces a record (or footprint) belongs to.\n * `server`/`hook` are RUNTIME-measured surfaces that produce {@link ToolEventRecord}\n * store rows; `command`/`skill`/`subagent` are STATIC footprints computed from the\n * registered connector (the host loads them as context — we never intercept them,\n * so they are NEVER written as usage rows). OPTIONAL on the record so rows written\n * before this field existed (every legacy serve-proxy row) read as `server`.\n */\nexport type SurfaceKind = \"server\" | \"hook\" | \"command\" | \"skill\" | \"subagent\";\n\n/**\n * The install scope a wrapped server was deployed under, narrowed to the two\n * dimensions that matter for slicing telemetry: a `user`-global install vs a\n * `project`-local one. The framework's broader {@link InstallScope}\n * (`system|user|project|profile|managed`) is mapped down to this at wrap time —\n * everything that is not project-local reads as `user`. Optional on the record\n * so rows written before this field existed are treated as \"unknown\".\n */\nexport type TelemetryInstallScope = \"user\" | \"project\";\n\n/**\n * How the real MCP server underneath the proxy was launched. `npx`/`bunx`/`uvx`\n * are ephemeral package runners; `node`/`bun`/`deno` are interpreters running a\n * local script; `binary` is a resolved executable on PATH; `http` marks a remote\n * server reached over the network (no local launch); `unknown` is the honest\n * fallback. Optional on the record so older rows read as \"unknown\".\n */\nexport type LaunchMethod =\n  | \"npx\"\n  | \"bunx\"\n  | \"uvx\"\n  | \"node\"\n  | \"binary\"\n  | \"http\"\n  | \"unknown\";\n\n/**\n * One telemetry row. Aggregate counts only — no content. `projectKey` is the\n * hashed stable project identity (git remote || normalized abs path); `projectDir`\n * is kept human-readable for reports but is the same partition.\n */\nexport interface ToolEventRecord {\n  /** Monotonic-ish unique id (e.g. `${ts}-${seq}`). */\n  id: string;\n  /** Epoch milliseconds. */\n  ts: number;\n  connectorId: string;\n  toolName: string;\n  scope: EventScope;\n  hostPlatform: PlatformId;\n  sessionId: string;\n  projectKey: string;\n  projectDir: string;\n  inputTokens: number;\n  outputTokens: number;\n  confidenceSource: ConfidenceSource;\n  isError: boolean;\n  /**\n   * The (narrowed) install scope the wrapped server was deployed under — a\n   * slicing dimension for global(user) vs project usage. OPTIONAL: rows written\n   * before this field existed lack it and must be read as \"unknown\".\n   */\n  installScope?: TelemetryInstallScope;\n  /**\n   * How the real server was launched (npx/bunx/uvx/node/binary/http) — the\n   * \"launch-method\" slicing dimension. OPTIONAL: older rows lack it → \"unknown\".\n   */\n  launchMethod?: LaunchMethod;\n  /**\n   * Which developer-axis surface produced this row. OPTIONAL and\n   * backward-compatible: rows written before this field existed (every legacy\n   * serve-proxy `call`/`tool_defs` row) lack it and MUST be read as `server`.\n   * Runtime rows stamp it explicitly (`server` for the proxy, `hook` for the\n   * hook runtime); the static command/skill/subagent surfaces never produce\n   * store rows (they are reported as footprints — see surface-footprint.ts).\n   */\n  surfaceKind?: SurfaceKind;\n}\n\nexport interface QueryFilter {\n  connectorId?: string;\n  projectKey?: string;\n  sessionId?: string;\n  toolName?: string;\n  /** Lower bound epoch ms (inclusive). */\n  sinceMs?: number;\n}\n\n/** A grouped rollup row for reports. */\nexport interface RollupRow {\n  /** The grouping key value (tool name, session id, or project dir). */\n  key: string;\n  calls: number;\n  inputTokens: number;\n  outputTokens: number;\n  totalTokens: number;\n  /** Worst (least-confident) source seen in the group, for honest labeling. */\n  confidence: ConfidenceSource;\n  lastTs: number;\n}\n\n/**\n * Local-first telemetry store. The default NDJSON implementation appends one\n * line per record (append is atomic enough for concurrent multi-host writers);\n * a SQLite/WAL implementation is a drop-in upgrade behind this same interface.\n */\nexport interface TelemetryStore {\n  append(record: ToolEventRecord): void;\n  query(filter: QueryFilter): ToolEventRecord[];\n  /** Group + aggregate by tool | session | project. */\n  rollup(by: \"tool\" | \"session\" | \"project\", filter: QueryFilter): RollupRow[];\n  close(): void;\n}\n","/**\n * telemetry/tokenizer — the default {@link Tokenizer} implementation.\n *\n * Token counts are the only signal that is identical across every host: no host\n * reports a server's per-tool usage back to the server, so the framework\n * tokenizes its OWN bytes locally. We use gpt-tokenizer's `o200k_base` encoding\n * (the GPT-4o / o1 BPE) for all families:\n *   • openai    → exact BPE for the target family            → \"tokenizer-exact\"\n *   • anthropic → o200k_base used as a documented stand-in   → \"tokenizer-approx\"\n *   • generic   → o200k_base used as a generic approximation → \"tokenizer-approx\"\n *\n * gpt-tokenizer is loaded LAZILY on first use, inside a try/catch. If the module\n * (or its BPE data) fails to load we degrade to a chars/4 heuristic that never\n * throws, so telemetry can never break a host's tool call.\n *\n * Pure + side-effect-free apart from the one-time lazy encoder load. No IO.\n */\n\nimport { createRequire } from \"node:module\";\n\nimport type {\n  ConfidenceSource,\n  ModelFamily,\n  TokenCount,\n  Tokenizer,\n} from \"./types.js\";\n\n/**\n * A CommonJS `require` bound to this module's URL. gpt-tokenizer ships its\n * encoding entry points as CJS (the package `exports` `require` condition maps\n * `./encoding/*` to `./cjs/encoding/*.js`), so we resolve them synchronously via\n * createRequire — this keeps the {@link Tokenizer} surface synchronous and works\n * under ESM / NodeNext without baking an absolute path.\n */\nconst requireCjs = createRequire(import.meta.url);\n\n/** Minimal shape we use from a gpt-tokenizer encoding module. */\ninterface EncodingModule {\n  encode(text: string): number[];\n}\n\n/**\n * Lazy-load state for the shared o200k_base encoder.\n *   - undefined → not attempted yet\n *   - null      → load attempted and failed (stick to the heuristic)\n *   - object    → loaded encoder\n */\nlet encoderState: EncodingModule | null | undefined;\n\n/** Average characters-per-token for the chars/4 fallback heuristic. */\nconst HEURISTIC_CHARS_PER_TOKEN = 4;\n\n/**\n * Lazily import the o200k_base encoding. Returns the encoder, or null if the\n * module/data could not be loaded (in which case callers use the heuristic).\n *\n * The dynamic import resolves to `gpt-tokenizer/esm/encoding/o200k_base.js` via\n * the package `exports` map and exposes a named `encode(text) => number[]`.\n */\nfunction loadEncoder(): EncodingModule | null {\n  if (encoderState !== undefined) return encoderState;\n  try {\n    // Synchronous require keeps count() a sync function (per the Tokenizer\n    // interface). The package's `require` export condition resolves this to\n    // gpt-tokenizer/cjs/encoding/o200k_base.js, which exports a named `encode`.\n    const mod = requireCjs(\"gpt-tokenizer/encoding/o200k_base\") as {\n      encode?: (text: string) => number[];\n    };\n    if (mod && typeof mod.encode === \"function\") {\n      encoderState = { encode: mod.encode.bind(mod) };\n    } else {\n      encoderState = null;\n    }\n  } catch {\n    encoderState = null;\n  }\n  return encoderState;\n}\n\n/** Heuristic chars/4 count — used when no encoder is available. Never throws. */\nfunction heuristicCount(text: string): TokenCount {\n  return {\n    tokens: Math.ceil(text.length / HEURISTIC_CHARS_PER_TOKEN),\n    source: \"heuristic\",\n  };\n}\n\n/**\n * Confidence label for a successful BPE count: exact only for the OpenAI family\n * (the encoding actually matches), approximate for everything else.\n */\nfunction bpeSource(family: ModelFamily): ConfidenceSource {\n  return family === \"openai\" ? \"tokenizer-exact\" : \"tokenizer-approx\";\n}\n\n/**\n * The default tokenizer. A single shared instance is fine: the encoder is\n * stateless across calls and lazy-loaded once.\n */\nclass DefaultTokenizer implements Tokenizer {\n  count(text: string, family: ModelFamily): TokenCount {\n    const encoder = loadEncoder();\n    if (!encoder) return heuristicCount(text);\n    try {\n      return { tokens: encoder.encode(text).length, source: bpeSource(family) };\n    } catch {\n      // A per-call encode failure (e.g. a pathological input) still degrades\n      // gracefully rather than breaking the host's tool call.\n      return heuristicCount(text);\n    }\n  }\n\n  countValue(value: unknown, family: ModelFamily): TokenCount {\n    return this.count(canonicalString(value), family);\n  }\n}\n\n/**\n * Canonical string form of an arbitrary JSON value for counting.\n * `undefined` (and anything that JSON.stringify drops to undefined, e.g. a bare\n * function or symbol) serializes to the empty string.\n */\nfunction canonicalString(value: unknown): string {\n  if (typeof value === \"string\") return value;\n  const json = JSON.stringify(value);\n  return json ?? \"\";\n}\n\nconst SHARED_TOKENIZER: Tokenizer = new DefaultTokenizer();\n\n/** Return the default {@link Tokenizer} (shared singleton). */\nexport function getTokenizer(): Tokenizer {\n  return SHARED_TOKENIZER;\n}\n\n/**\n * Infer the {@link ModelFamily} for token counting.\n *\n * An explicit hint other than \"auto\" wins outright. Otherwise we sniff the\n * client/host name: Anthropic/Claude → anthropic, OpenAI/GPT/Codex → openai,\n * Gemini and everything unrecognized → generic.\n */\nexport function inferModelFamily(\n  clientName: string,\n  hint: \"auto\" | ModelFamily,\n): ModelFamily {\n  if (hint !== \"auto\") return hint;\n  const name = clientName.toLowerCase();\n  if (name.includes(\"claude\") || name.includes(\"anthropic\")) return \"anthropic\";\n  if (\n    name.includes(\"codex\") ||\n    name.includes(\"gpt\") ||\n    name.includes(\"openai\")\n  ) {\n    return \"openai\";\n  }\n  // gemini and all others fall through to the generic approximation.\n  return \"generic\";\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-DBQMX75U.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+// src/core/interpolate.ts
+var ENV_REF_RE = /\$\{env:([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+function resolveEnvRefs(input, env = process.env) {
+  return input.replace(ENV_REF_RE, (_m, name, def) => {
+    const v = env[name];
+    if (v != null && v !== "") return v;
+    return def ?? "";
+  });
+}
+function resolveEnvRefsDeep(value, env = process.env) {
+  if (typeof value === "string") return resolveEnvRefs(value, env);
+  if (Array.isArray(value)) {
+    return value.map((v) => resolveEnvRefsDeep(v, env));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = resolveEnvRefsDeep(v, env);
+    return out;
+  }
+  return value;
+}
+function rewriteEnvRefs(input, render) {
+  return input.replace(
+    ENV_REF_RE,
+    (_m, name, def) => render(name, def)
+  );
+}
+
+export {
+  resolveEnvRefs,
+  resolveEnvRefsDeep,
+  rewriteEnvRefs
+};
+//# sourceMappingURL=chunk-DBQMX75U.js.map

package/dist/chunk-DBQMX75U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/interpolate.ts"],"sourcesContent":["/**\n * core/interpolate — universal ${env:VAR} interpolation.\n *\n * The developer writes one portable syntax in their connector config:\n *   \"${env:ACME_KEY}\"            → value of process.env.ACME_KEY\n *   \"${env:ACME_URL:-https://x}\" → value, or the default after \":-\" if unset/empty\n *\n * Two consumers:\n *   • resolveEnvRefs / resolveEnvRefsDeep — resolve to literals at INSTALL time,\n *     for hosts with NO native interpolation (e.g. Codex TOML).\n *   • rewriteEnvRefs — translate to a host's NATIVE interpolation token (e.g.\n *     Cursor/VS Code \"${env:VAR}\", Claude \"${VAR}\") so secrets are never baked\n *     into config files. Adapters choose which to use.\n */\n\n/** Matches ${env:NAME} and ${env:NAME:-default}. NAME is [A-Za-z_][A-Za-z0-9_]*. */\nexport const ENV_REF_RE = /\\$\\{env:([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\\}/g;\n\n/** Resolve every ${env:VAR} in `input` to a literal from `env`. */\nexport function resolveEnvRefs(\n  input: string,\n  env: NodeJS.ProcessEnv = process.env,\n): string {\n  return input.replace(ENV_REF_RE, (_m, name: string, def?: string) => {\n    const v = env[name];\n    if (v != null && v !== \"\") return v;\n    return def ?? \"\";\n  });\n}\n\n/** Recursively resolve ${env:VAR} in all strings of a JSON-ish value. */\nexport function resolveEnvRefsDeep<T>(value: T, env: NodeJS.ProcessEnv = process.env): T {\n  if (typeof value === \"string\") return resolveEnvRefs(value, env) as unknown as T;\n  if (Array.isArray(value)) {\n    return value.map((v) => resolveEnvRefsDeep(v, env)) as unknown as T;\n  }\n  if (value && typeof value === \"object\") {\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(value)) out[k] = resolveEnvRefsDeep(v, env);\n    return out as T;\n  }\n  return value;\n}\n\n/**\n * Translate every ${env:VAR(:-default)} via `render` into a host-native token.\n * The renderer receives the var name and optional default and returns the\n * replacement string (e.g. `(name) => \"${\" + name + \"}\"` for Claude).\n */\nexport function rewriteEnvRefs(\n  input: string,\n  render: (name: string, def?: string) => string,\n): string {\n  return input.replace(ENV_REF_RE, (_m, name: string, def?: string) =>\n    render(name, def),\n  );\n}\n\n/** True if the string contains at least one ${env:...} reference. */\nexport function hasEnvRef(input: string): boolean {\n  ENV_REF_RE.lastIndex = 0;\n  return ENV_REF_RE.test(input);\n}\n"],"mappings":";;;AAgBO,IAAM,aAAa;AAGnB,SAAS,eACd,OACA,MAAyB,QAAQ,KACzB;AACR,SAAO,MAAM,QAAQ,YAAY,CAAC,IAAI,MAAc,QAAiB;AACnE,UAAM,IAAI,IAAI,IAAI;AAClB,QAAI,KAAK,QAAQ,MAAM,GAAI,QAAO;AAClC,WAAO,OAAO;AAAA,EAChB,CAAC;AACH;AAGO,SAAS,mBAAsB,OAAU,MAAyB,QAAQ,KAAQ;AACvF,MAAI,OAAO,UAAU,SAAU,QAAO,eAAe,OAAO,GAAG;AAC/D,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,MAAM,IAAI,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAAA,EACpD;AACA,MAAI,SAAS,OAAO,UAAU,UAAU;AACtC,UAAM,MAA+B,CAAC;AACtC,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,KAAK,EAAG,KAAI,CAAC,IAAI,mBAAmB,GAAG,GAAG;AAC9E,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAOO,SAAS,eACd,OACA,QACQ;AACR,SAAO,MAAM;AAAA,IAAQ;AAAA,IAAY,CAAC,IAAI,MAAc,QAClD,OAAO,MAAM,GAAG;AAAA,EAClB;AACF;","names":[]}

package/dist/chunk-EXLS7BSI.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import {
+  ensureDir
+} from "./chunk-TRQKHP7D.js";
+
+// src/core/yaml.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { parse, stringify } from "yaml";
+function readYaml(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = parse(readFileSync(path, "utf8"));
+    return parsed == null ? null : parsed;
+  } catch {
+    return null;
+  }
+}
+function writeYaml(path, data, dryRun = false) {
+  if (dryRun) return;
+  ensureDir(dirname(path));
+  writeFileSync(path, stringify(data), "utf8");
+}
+
+export {
+  readYaml,
+  writeYaml
+};
+//# sourceMappingURL=chunk-EXLS7BSI.js.map

package/dist/chunk-EXLS7BSI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/yaml.ts"],"sourcesContent":["/**\n * core/yaml — minimal YAML config IO.\n *\n * The YAML analog of BaseAdapter's JSON helpers (readJson/writeJson). Adapters\n * whose native config is YAML (Goose's config.yaml, Hermes's config.yaml) cannot\n * use the JSON helpers, so they reach for these two functions instead — same\n * existsSync-guard / parse-failure-tolerant / dryRun-respecting contract, just\n * over the `yaml` package's parse()/stringify() rather than JSON.parse/stringify.\n *\n * Deliberately tiny: read-or-null and ensureDir+write. All merge/upsert/idempotency\n * logic lives in each adapter (the shapes differ per platform), exactly as the\n * JSON adapters layer their own upsert on top of writeJson.\n */\n\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { dirname } from \"node:path\";\n\nimport { parse, stringify } from \"yaml\";\n\nimport { ensureDir } from \"./paths.js\";\n\n/**\n * Read and parse a YAML file. Returns `null` when the file is missing OR when it\n * fails to parse (mirrors BaseAdapter.readJson's fail-soft behavior so a corrupt\n * file degrades to \"treat as absent\" rather than throwing mid-install).\n */\nexport function readYaml<T = Record<string, unknown>>(path: string): T | null {\n  if (!existsSync(path)) return null;\n  try {\n    const parsed = parse(readFileSync(path, \"utf8\")) as T | null | undefined;\n    // An empty YAML document parses to null/undefined — normalize to null.\n    return parsed == null ? null : parsed;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Serialize `data` to YAML and write it to `path`, creating parent dirs as\n * needed. Honors `dryRun` (no write). Mirrors BaseAdapter.writeJson's signature.\n */\nexport function writeYaml(path: string, data: unknown, dryRun = false): void {\n  if (dryRun) return;\n  ensureDir(dirname(path));\n  writeFileSync(path, stringify(data), \"utf8\");\n}\n"],"mappings":";;;;;;AAcA,SAAS,YAAY,cAAc,qBAAqB;AACxD,SAAS,eAAe;AAExB,SAAS,OAAO,iBAAiB;AAS1B,SAAS,SAAsC,MAAwB;AAC5E,MAAI,CAAC,WAAW,IAAI,EAAG,QAAO;AAC9B,MAAI;AACF,UAAM,SAAS,MAAM,aAAa,MAAM,MAAM,CAAC;AAE/C,WAAO,UAAU,OAAO,OAAO;AAAA,EACjC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAMO,SAAS,UAAU,MAAc,MAAe,SAAS,OAAa;AAC3E,MAAI,OAAQ;AACZ,YAAU,QAAQ,IAAI,CAAC;AACvB,gBAAc,MAAM,UAAU,IAAI,GAAG,MAAM;AAC7C;","names":[]}