getpatter 0.6.4 → 0.6.6

package/dist/index.mjs

@@ -57,7 +57,7 @@ import {
   openclawPostCallNotifier,
   resolveLogRoot,
   startSpan
-} from "./chunk-7IIV3BY4.mjs";
+} from "./chunk-YJX2EKON.mjs";
 import {
   OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
@@ -106,6 +106,57 @@ init_esm_shims();
 // src/client.ts
 init_esm_shims();
 
+// src/telephony/twilio.ts
+init_esm_shims();
+var Carrier2 = class {
+  kind = "twilio";
+  accountSid;
+  authToken;
+  constructor(opts = {}) {
+    const sid = opts.accountSid ?? process.env.TWILIO_ACCOUNT_SID;
+    const tok = opts.authToken ?? process.env.TWILIO_AUTH_TOKEN;
+    if (!sid) {
+      throw new Error(
+        "Twilio carrier requires accountSid. Pass { accountSid: 'AC...' } or set TWILIO_ACCOUNT_SID in the environment."
+      );
+    }
+    if (!tok) {
+      throw new Error(
+        "Twilio carrier requires authToken. Pass { authToken: '...' } or set TWILIO_AUTH_TOKEN in the environment."
+      );
+    }
+    this.accountSid = sid;
+    this.authToken = tok;
+  }
+};
+
+// src/telephony/telnyx.ts
+init_esm_shims();
+var Carrier3 = class {
+  kind = "telnyx";
+  apiKey;
+  connectionId;
+  publicKey;
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.TELNYX_API_KEY;
+    const conn = opts.connectionId ?? process.env.TELNYX_CONNECTION_ID;
+    const pub = opts.publicKey ?? process.env.TELNYX_PUBLIC_KEY;
+    if (!key) {
+      throw new Error(
+        "Telnyx carrier requires apiKey. Pass { apiKey: '...' } or set TELNYX_API_KEY in the environment."
+      );
+    }
+    if (!conn) {
+      throw new Error(
+        "Telnyx carrier requires connectionId. Pass { connectionId: '...' } or set TELNYX_CONNECTION_ID in the environment."
+      );
+    }
+    this.apiKey = key;
+    this.connectionId = conn;
+    this.publicKey = pub;
+  }
+};
+
 // src/engines/openai.ts
 init_esm_shims();
 var Realtime = class {
@@ -324,6 +375,566 @@ function validateAllToolSchemas(tools) {
   }
 }
 
+// src/telemetry/index.ts
+init_esm_shims();
+
+// src/telemetry/client.ts
+init_esm_shims();
+
+// src/telemetry/consent.ts
+init_esm_shims();
+
+// src/telemetry/env.ts
+init_esm_shims();
+var CI_ENV_VARS = [
+  "CI",
+  "CONTINUOUS_INTEGRATION",
+  "GITHUB_ACTIONS",
+  "GITLAB_CI",
+  "TRAVIS",
+  "CIRCLECI",
+  "APPVEYOR",
+  "TF_BUILD",
+  "TEAMCITY_VERSION",
+  "BUILDKITE",
+  "DRONE",
+  "JENKINS_URL",
+  "HUDSON_URL",
+  "BAMBOO_BUILDKEY",
+  "CODEBUILD_BUILD_ID"
+];
+var TEST_ENV_VARS = ["VITEST", "JEST_WORKER_ID"];
+function isTruthy(value) {
+  if (value === void 0) return false;
+  const v = value.trim().toLowerCase();
+  return v !== "" && v !== "0" && v !== "false" && v !== "no" && v !== "off";
+}
+function isCi() {
+  return CI_ENV_VARS.some((name) => isTruthy(process.env[name]));
+}
+function isTest() {
+  if (TEST_ENV_VARS.some((name) => process.env[name] !== void 0)) return true;
+  const node = (process.env.NODE_ENV ?? "").trim().toLowerCase();
+  const patter = (process.env.PATTER_ENV ?? "").trim().toLowerCase();
+  return node === "test" || patter === "test";
+}
+
+// src/telemetry/install-id.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var RUN_ID = randomUUID().replace(/-/g, "");
+var HEX32 = /^[0-9a-f]{32}$/;
+var VERSION_RE = /^[0-9][0-9a-z.+-]{0,31}$/;
+var cachedInstallId = null;
+function runId() {
+  return RUN_ID;
+}
+function statePath() {
+  const base = process.env.PATTER_TELEMETRY_STATE_DIR || process.env.XDG_STATE_HOME;
+  const root = base && base.length > 0 ? base : path.join(os.homedir(), ".getpatter");
+  return path.join(root, "install-id");
+}
+function installId() {
+  if (cachedInstallId !== null) return cachedInstallId;
+  const p = statePath();
+  try {
+    const existing = fs.readFileSync(p, "utf8").trim();
+    if (HEX32.test(existing)) {
+      cachedInstallId = existing;
+      return cachedInstallId;
+    }
+  } catch {
+  }
+  const newId = randomUUID().replace(/-/g, "");
+  try {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, newId, "utf8");
+    cachedInstallId = newId;
+  } catch {
+    cachedInstallId = RUN_ID;
+  }
+  return cachedInstallId;
+}
+function versionPath() {
+  return path.join(path.dirname(statePath()), "version");
+}
+function previousVersion(current) {
+  const p = versionPath();
+  let prev = "";
+  try {
+    prev = fs.readFileSync(p, "utf8").trim();
+  } catch {
+    prev = "";
+  }
+  try {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, current, "utf8");
+  } catch {
+  }
+  return VERSION_RE.test(prev) ? prev : "";
+}
+function daysSinceInstallBucket() {
+  let mtimeMs;
+  try {
+    mtimeMs = fs.statSync(statePath()).mtimeMs;
+  } catch {
+    return "0";
+  }
+  const days = Math.max(0, Math.floor((Date.now() - mtimeMs) / 864e5));
+  if (days === 0) return "0";
+  if (days <= 7) return "1_7";
+  if (days <= 30) return "8_30";
+  return "30_plus";
+}
+function firstRunPath() {
+  return path.join(path.dirname(statePath()), "first-run");
+}
+function isFirstRun() {
+  const p = firstRunPath();
+  try {
+    if (fs.existsSync(p)) return false;
+  } catch {
+    return false;
+  }
+  try {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, "1", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function optOutPath() {
+  return path.join(path.dirname(statePath()), "telemetry-disabled");
+}
+function isOptedOut() {
+  try {
+    return fs.existsSync(optOutPath());
+  } catch {
+    return false;
+  }
+}
+
+// src/telemetry/consent.ts
+function isEnabled(flag) {
+  if (isTruthy(process.env.DO_NOT_TRACK)) return false;
+  if (isTruthy(process.env.PATTER_TELEMETRY_DISABLED)) return false;
+  if (isOptedOut()) return false;
+  if (flag === false) return false;
+  if (isCi() || isTest()) return false;
+  return true;
+}
+
+// src/telemetry/events.ts
+init_esm_shims();
+import * as os2 from "os";
+
+// src/telemetry/stack.ts
+init_esm_shims();
+var STACK_VENDORS = /* @__PURE__ */ new Set([
+  "openai",
+  "anthropic",
+  "google",
+  "cerebras",
+  "groq",
+  "deepgram",
+  "elevenlabs",
+  "cartesia",
+  "whisper",
+  "soniox",
+  "assemblyai",
+  "speechmatics",
+  "lmnt",
+  "rime",
+  "inworld",
+  "telnyx",
+  "other"
+]);
+var VENDOR_ALIASES = {
+  cartesia_stt: "cartesia",
+  cartesia_tts: "cartesia",
+  openai_tts: "openai",
+  openai_transcribe: "openai",
+  elevenlabs_ws: "elevenlabs",
+  telnyx_stt: "telnyx",
+  telnyx_tts: "telnyx"
+};
+var RAW_UNSAFE_RE = /[^a-z0-9._-]/;
+var DATE_SUFFIX_RE = /-\d{8}$/;
+function vendorOf(providerKey) {
+  if (!providerKey) return "other";
+  const v = VENDOR_ALIASES[providerKey] ?? providerKey;
+  return STACK_VENDORS.has(v) ? v : "other";
+}
+function modelToken(vendor, rawModel) {
+  if (!rawModel) return `${vendor}-other`;
+  const m = rawModel.trim().toLowerCase();
+  if (m.length > 40 || RAW_UNSAFE_RE.test(m)) return `${vendor}-other`;
+  const token = m.replace(/_/g, "-").replace(DATE_SUFFIX_RE, "").replace(/^[-.]+|[-.]+$/g, "");
+  return token ? `${vendor}-${token}` : `${vendor}-other`;
+}
+function readProviderKey(obj) {
+  const ctor = obj?.constructor;
+  const key = ctor?.providerKey;
+  return typeof key === "string" && key ? key : null;
+}
+function readModel(obj) {
+  const rec = obj;
+  for (const attr of ["model", "modelId", "_model"]) {
+    const v = rec?.[attr];
+    if (typeof v === "string" && v) return v;
+  }
+  return "";
+}
+function layerDims(obj, providerField, modelField) {
+  if (obj === null || obj === void 0) return {};
+  const vendor = vendorOf(readProviderKey(obj));
+  return { [providerField]: vendor, [modelField]: modelToken(vendor, readModel(obj)) };
+}
+function stackDimensions(stt, tts, llm) {
+  return {
+    ...layerDims(stt, "stt_provider", "stt_model"),
+    ...layerDims(tts, "tts_provider", "tts_model"),
+    ...layerDims(llm, "llm_provider", "llm_model")
+  };
+}
+
+// src/telemetry/events.ts
+var SCHEMA_VERSION = 5;
+var EVENT_SDK_INITIALIZED = "sdk_initialized";
+var EVENT_FIRST_RUN = "first_run";
+var EVENT_CLI_COMMAND = "cli_command";
+var EVENT_FEATURE_USED = "feature_used";
+var EVENT_AGENT_CONFIGURED = "agent_configured";
+var EVENT_CALL_STARTED = "call_started";
+var EVENT_CALL_COMPLETED = "call_completed";
+var ALLOWED_EVENTS = /* @__PURE__ */ new Set([
+  EVENT_SDK_INITIALIZED,
+  EVENT_FIRST_RUN,
+  EVENT_CLI_COMMAND,
+  EVENT_FEATURE_USED,
+  EVENT_AGENT_CONFIGURED,
+  EVENT_CALL_STARTED,
+  EVENT_CALL_COMPLETED
+]);
+var DIMENSION_VALUES = {
+  carrier: /* @__PURE__ */ new Set(["twilio", "telnyx", "plivo", "none"]),
+  tunnel: /* @__PURE__ */ new Set(["static", "configured", "none"]),
+  engine: /* @__PURE__ */ new Set(["realtime", "convai", "pipeline"]),
+  provider: /* @__PURE__ */ new Set([
+    "openai",
+    "elevenlabs",
+    "deepgram",
+    "cartesia",
+    "cerebras",
+    "anthropic",
+    "google",
+    "whisper",
+    "other"
+  ]),
+  // agent_configured dimensions
+  custom_tool_count_bucket: /* @__PURE__ */ new Set(["0", "1", "2_3", "4_6", "7_12", "13_plus"]),
+  integration: /* @__PURE__ */ new Set(["openclaw", "mcp", "hermes", "other", "none"]),
+  integration_kind: /* @__PURE__ */ new Set(["consult", "mcp", "none"]),
+  mcp_server_count_bucket: /* @__PURE__ */ new Set(["0", "1", "2_3", "4_plus"]),
+  // call_started / call_completed: inbound vs outbound — a core usage split.
+  direction: /* @__PURE__ */ new Set(["inbound", "outbound", "none"]),
+  // cli_command: which CLI subcommand was invoked (never args/flags values).
+  cli_command: /* @__PURE__ */ new Set(["dashboard", "eval", "telemetry", "none", "other"]),
+  // call_completed: the call's terminal outcome
+  outcome: /* @__PURE__ */ new Set(["completed", "error", "no_answer", "busy", "failed"]),
+  // call_completed: terminal error code (mirrors ErrorCode, plus "other"). Never
+  // the error message.
+  error_code: /* @__PURE__ */ new Set([
+    "config",
+    "connection",
+    "auth",
+    "timeout",
+    "rate_limit",
+    "webhook_verification",
+    "input_validation",
+    "provider_error",
+    "provision",
+    "internal",
+    "other"
+  ]),
+  // feature_used (pipeline): per-layer vendor of the composed stack. A
+  // providerKey not on the closed allowlist collapses to "other"; an absent layer
+  // is omitted (the value set keeps "none" only as a safety token).
+  stt_provider: /* @__PURE__ */ new Set([...STACK_VENDORS, "none"]),
+  tts_provider: /* @__PURE__ */ new Set([...STACK_VENDORS, "none"]),
+  llm_provider: /* @__PURE__ */ new Set([...STACK_VENDORS, "none"]),
+  // sdk_initialized: anonymous deploy-shape (presence-only env/file probes).
+  invoked_by_agent: /* @__PURE__ */ new Set(["claude", "cursor", "copilot", "gemini", "windsurf", "other", "none"]),
+  serverless: /* @__PURE__ */ new Set(["lambda", "cloud_run", "vercel", "azure_functions", "none"]),
+  cloud: /* @__PURE__ */ new Set(["aws", "gcp", "azure", "fly", "none"]),
+  package_manager: /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun", "pip", "uv", "poetry", "pipenv", "conda", "none"]),
+  days_since_install_bucket: /* @__PURE__ */ new Set(["0", "1_7", "8_30", "30_plus"]),
+  // agent_configured: feature-adoption (Realtime tuning).
+  noise_reduction: /* @__PURE__ */ new Set(["near_field", "far_field", "none"]),
+  turn_detection: /* @__PURE__ */ new Set(["default", "custom", "none"]),
+  // call_completed: how many conversational turns the call had.
+  turn_count_bucket: /* @__PURE__ */ new Set(["0", "1", "2_3", "4_6", "7_12", "13_plus"])
+};
+var NUMERIC_DIMENSIONS = /* @__PURE__ */ new Set([
+  "builtin_tool_count",
+  "latency_ms",
+  "duration_seconds",
+  "cost_usd"
+]);
+var STRING_DIMENSIONS = /* @__PURE__ */ new Set([
+  "stt_model",
+  "tts_model",
+  "llm_model",
+  "previous_sdk_version"
+]);
+var MODEL_TOKEN_RE = /^[a-z0-9][a-z0-9.-]{0,40}$/;
+var BOOL_DIMENSIONS = /* @__PURE__ */ new Set([
+  "container",
+  "preambles_used",
+  "per_tool_timeouts_set",
+  "llm_fallback_configured"
+]);
+var ALLOWED_DIMENSIONS = /* @__PURE__ */ new Set([
+  ...Object.keys(DIMENSION_VALUES),
+  ...NUMERIC_DIMENSIONS,
+  ...STRING_DIMENSIONS,
+  ...BOOL_DIMENSIONS
+]);
+function osFamily() {
+  const p = os2.platform();
+  if (p === "win32") return "windows";
+  return p || "unknown";
+}
+function arch2() {
+  const a = os2.arch();
+  if (a === "x64") return "x86_64";
+  if (a === "arm64") return "arm64";
+  return "other";
+}
+function runtimeVersion() {
+  const parts = (process.versions.node ?? "0.0").split(".");
+  return `${parts[0] ?? "0"}.${parts[1] ?? "0"}`;
+}
+function buildEvent(name, opts) {
+  if (!ALLOWED_EVENTS.has(name)) {
+    throw new Error(`unknown telemetry event: ${name}`);
+  }
+  const event = {
+    event: name,
+    schema_version: SCHEMA_VERSION,
+    run_id: runId(),
+    install_id: installId(),
+    sdk: "typescript",
+    sdk_version: opts.sdkVersion,
+    os: osFamily(),
+    arch: arch2(),
+    runtime: "node",
+    runtime_version: runtimeVersion(),
+    ci: isCi() || isTest()
+  };
+  for (const [key, raw] of Object.entries(opts.dimensions ?? {})) {
+    if (!ALLOWED_DIMENSIONS.has(key) || raw === null || raw === void 0) {
+      continue;
+    }
+    let value = raw;
+    const allowed = DIMENSION_VALUES[key];
+    if (allowed && !(typeof value === "string" && allowed.has(value))) {
+      value = "other";
+    } else if (STRING_DIMENSIONS.has(key)) {
+      if (!(typeof value === "string" && MODEL_TOKEN_RE.test(value))) {
+        continue;
+      }
+    } else if (BOOL_DIMENSIONS.has(key) && typeof value !== "boolean") {
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      event[key] = value;
+    }
+  }
+  return event;
+}
+
+// src/telemetry/client.ts
+var DEFAULT_ENDPOINT = "https://telemetry.getpatter.com/v1/ingest";
+var TIMEOUT_MS = 3e3;
+var BUFFER_MAX = 256;
+var noticeShown = false;
+var liveClients = /* @__PURE__ */ new Set();
+var exitHookRegistered = false;
+function showNoticeOnce() {
+  if (noticeShown) return;
+  noticeShown = true;
+  getLogger().info(
+    "Anonymous usage telemetry is on (no PII, no call content). Collected: a random anonymous install id, SDK version, language, OS family, runtime version, coarse feature flags, the composed stack (provider + model per layer), tool counts, integration category, and per-call duration, latency, cost, and error codes (no call content, no message text). Disable with PATTER_TELEMETRY_DISABLED=1, DO_NOT_TRACK=1, or telemetry: false. Details: https://docs.getpatter.com/telemetry"
+  );
+}
+function registerExitHook() {
+  if (exitHookRegistered) return;
+  exitHookRegistered = true;
+  process.once("beforeExit", () => {
+    for (const ref of [...liveClients]) {
+      const client = ref.deref();
+      if (client) void client.close();
+      else liveClients.delete(ref);
+    }
+  });
+}
+var TelemetryClient = class {
+  sdkVersion;
+  enabledFlag;
+  endpoint;
+  debug;
+  buffer = [];
+  flushing = false;
+  closed = false;
+  selfRef = new WeakRef(this);
+  constructor(options) {
+    this.sdkVersion = options.sdkVersion;
+    this.enabledFlag = isEnabled(options.flag);
+    this.endpoint = options.endpoint ?? process.env.PATTER_TELEMETRY_ENDPOINT ?? DEFAULT_ENDPOINT;
+    this.debug = isTruthy(process.env.PATTER_TELEMETRY_DEBUG);
+    if (this.enabledFlag && !this.debug) {
+      showNoticeOnce();
+      registerExitHook();
+      liveClients.add(this.selfRef);
+    }
+  }
+  get enabled() {
+    return this.enabledFlag;
+  }
+  /** Enqueue an event. Fire-and-forget; never throws, never blocks. */
+  record(name, dimensions) {
+    if (!this.enabledFlag || this.closed) return;
+    let event;
+    try {
+      event = buildEvent(name, { sdkVersion: this.sdkVersion, dimensions });
+    } catch (err) {
+      getLogger().debug("telemetry buildEvent failed", err);
+      return;
+    }
+    if (this.debug) {
+      try {
+        process.stderr.write(`[patter telemetry] ${JSON.stringify(event)}
+`);
+      } catch {
+      }
+      return;
+    }
+    try {
+      if (this.buffer.length >= BUFFER_MAX) this.buffer.shift();
+      this.buffer.push(event);
+      this.scheduleFlush();
+    } catch (err) {
+      getLogger().debug("telemetry enqueue failed", err);
+    }
+  }
+  /**
+   * Schedule a flush of any buffered events. Events recorded before the server
+   * is running (e.g. at `new Patter(...)`) sit in the buffer; call this once the
+   * server is up so they ship promptly. Cheap when disabled or buffer is empty.
+   */
+  flushPending() {
+    if (!this.enabledFlag || this.debug) return;
+    try {
+      this.scheduleFlush();
+    } catch (err) {
+      getLogger().debug("telemetry flushPending failed", err);
+    }
+  }
+  /** Flush remaining events (graceful shutdown). Never throws. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    liveClients.delete(this.selfRef);
+    if (!this.enabledFlag || this.debug) return;
+    try {
+      await this.flush();
+    } catch (err) {
+      getLogger().debug("telemetry close flush failed", err);
+    }
+  }
+  scheduleFlush() {
+    if (this.flushing) return;
+    this.flushing = true;
+    void this.flush().finally(() => {
+      this.flushing = false;
+    });
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const events = this.buffer.splice(0, this.buffer.length);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    timer.unref?.();
+    try {
+      await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(events),
+        signal: controller.signal
+      });
+    } catch (err) {
+      getLogger().debug("telemetry flush failed", err);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/telemetry/environment.ts
+init_esm_shims();
+import * as fs2 from "fs";
+var env = process.env;
+function invokedByAgent() {
+  if ("CLAUDECODE" in env || "CLAUDE_CODE" in env || "CLAUDE_CODE_ENTRYPOINT" in env)
+    return "claude";
+  if ("CURSOR_TRACE_ID" in env || "CURSOR_AGENT" in env) return "cursor";
+  if ("GITHUB_COPILOT_AGENT" in env || "COPILOT_AGENT_ID" in env) return "copilot";
+  if ("GEMINI_CLI" in env || "GEMINI_AGENT" in env) return "gemini";
+  if ("WINDSURF" in env || "WINDSURF_AGENT" in env) return "windsurf";
+  if ("AIDER" in env || "OPENAI_AGENT" in env) return "other";
+  return "none";
+}
+function inContainer() {
+  try {
+    if (fs2.existsSync("/.dockerenv")) return true;
+  } catch {
+  }
+  if (env.KUBERNETES_SERVICE_HOST) return true;
+  try {
+    const blob = fs2.readFileSync("/proc/1/cgroup", "utf8");
+    return blob.includes("docker") || blob.includes("containerd") || blob.includes("kubepods");
+  } catch {
+    return false;
+  }
+}
+function serverless() {
+  if (env.AWS_LAMBDA_FUNCTION_NAME) return "lambda";
+  if (env.K_SERVICE) return "cloud_run";
+  if (env.VERCEL) return "vercel";
+  if (env.AZURE_FUNCTIONS_ENVIRONMENT || env.FUNCTIONS_WORKER_RUNTIME) return "azure_functions";
+  return "none";
+}
+function cloud() {
+  if (env.AWS_REGION || env.AWS_EXECUTION_ENV || env.AWS_LAMBDA_FUNCTION_NAME) return "aws";
+  if (env.K_SERVICE || env.GOOGLE_CLOUD_PROJECT || env.GCP_PROJECT) return "gcp";
+  if (env.WEBSITE_INSTANCE_ID || env.AZURE_FUNCTIONS_ENVIRONMENT) return "azure";
+  if (env.FLY_APP_NAME) return "fly";
+  return "none";
+}
+function packageManager() {
+  const ua = env.npm_config_user_agent ?? "";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("bun")) return "bun";
+  if (ua.startsWith("npm")) return "npm";
+  return "none";
+}
+
 // src/_speech-events.ts
 init_esm_shims();
 var logger = getLogger();
@@ -628,6 +1239,79 @@ function closeParkedConnections(slot) {
     }
   }
 }
+function carrierFamily(carrier) {
+  if (carrier instanceof Carrier2) return "twilio";
+  if (carrier instanceof Carrier3) return "telnyx";
+  if (carrier instanceof Carrier) return "plivo";
+  return "none";
+}
+function telemetryEngineFamily(opts) {
+  if (opts.engine) {
+    return opts.engine.constructor.name.toLowerCase().includes("convai") ? "convai" : "realtime";
+  }
+  if (opts.provider === "elevenlabs_convai") return "convai";
+  if (opts.provider === "pipeline") return "pipeline";
+  if (opts.provider === "openai_realtime") return "realtime";
+  if (opts.stt || opts.tts) return "pipeline";
+  return "realtime";
+}
+function telemetryProviderFamily(family) {
+  if (family === "realtime") return "openai";
+  if (family === "convai") return "elevenlabs";
+  return "other";
+}
+function telemetryBucketCustomTools(n) {
+  if (n <= 0) return "0";
+  if (n === 1) return "1";
+  if (n <= 3) return "2_3";
+  if (n <= 6) return "4_6";
+  if (n <= 12) return "7_12";
+  return "13_plus";
+}
+function telemetryBucketMcp(n) {
+  if (n <= 0) return "0";
+  if (n === 1) return "1";
+  if (n <= 3) return "2_3";
+  return "4_plus";
+}
+function telemetryIntegration(opts) {
+  const nMcp = opts.mcpServers?.length ?? 0;
+  if (nMcp > 0) {
+    return { integration: "mcp", integrationKind: "mcp", mcpBucket: telemetryBucketMcp(nMcp) };
+  }
+  if (opts.consult) {
+    let isOpenclaw = false;
+    const oc = opts.consult.openaiCompatible;
+    if (oc) {
+      const model = oc.model ?? "";
+      const baseUrl = oc.baseUrl ?? "";
+      isOpenclaw = model.startsWith("openclaw/") || baseUrl.includes(":18789");
+    }
+    return {
+      integration: isOpenclaw ? "openclaw" : "other",
+      integrationKind: "consult",
+      mcpBucket: "0"
+    };
+  }
+  return { integration: "none", integrationKind: "none", mcpBucket: "0" };
+}
+function telemetryEnvironmentDims() {
+  try {
+    const dims = {
+      invoked_by_agent: invokedByAgent(),
+      container: inContainer(),
+      serverless: serverless(),
+      cloud: cloud(),
+      package_manager: packageManager(),
+      days_since_install_bucket: daysSinceInstallBucket()
+    };
+    const prev = previousVersion(VERSION);
+    if (prev) dims.previous_sdk_version = prev;
+    return dims;
+  } catch {
+    return {};
+  }
+}
 var Patter = class {
   localConfig;
   embeddedServer = null;
@@ -648,6 +1332,14 @@ var Patter = class {
    * ``Cannot use both tunnel: true and webhookUrl``.
    */
   tunnelOwnsWebhookUrl = false;
+  /**
+   * Anonymous usage telemetry (opt-out, default ON). Separate from
+   * ``./observability`` (user-facing OTel). Fire-and-forget and fail-safe — it
+   * can never block or break a call. See ``./telemetry``.
+   */
+  telemetry;
+  telemetrySeenEngines = /* @__PURE__ */ new Set();
+  telemetrySeenAgentShapes = /* @__PURE__ */ new Set();
   /**
    * Pre-rendered first-message TTS audio per outbound call_id. Populated
    * by :meth:`call` when ``agent.prewarmFirstMessage`` is true; consumed
@@ -853,6 +1545,22 @@ var Patter = class {
       openaiKey: options.openaiKey,
       persistRoot: resolvePersistRoot(options.persist)
     };
+    this.telemetry = new TelemetryClient({
+      sdkVersion: VERSION,
+      flag: options.telemetry
+    });
+    const initDims = {
+      carrier: carrierFamily(carrier),
+      tunnel: tunnel instanceof Static ? "static" : options.tunnel ? "configured" : "none",
+      ...telemetryEnvironmentDims()
+    };
+    if (this.telemetry.enabled) {
+      try {
+        if (isFirstRun()) this.telemetry.record("first_run", initDims);
+      } catch {
+      }
+    }
+    this.telemetry.record("sdk_initialized", initDims);
     this._tunnelReady = new Promise((resolve, reject) => {
       this._tunnelReadyResolve = resolve;
       this._tunnelReadyReject = reject;
@@ -872,6 +1580,55 @@ var Patter = class {
   // === Agent definition ===
   /** Resolve user-supplied agent options against engine defaults and return the merged config. */
   agent(opts) {
+    const family = telemetryEngineFamily(opts);
+    const stack = stackDimensions(opts.stt, opts.tts, opts.llm);
+    const featureKey = family + "|" + Object.entries(stack).sort().map(([k, v]) => `${k}=${v}`).join(",");
+    if (!this.telemetrySeenEngines.has(featureKey)) {
+      this.telemetrySeenEngines.add(featureKey);
+      this.telemetry.record("feature_used", {
+        engine: family,
+        provider: telemetryProviderFamily(family),
+        ...stack
+      });
+    }
+    const builtin = opts.consult ? 1 : 0;
+    const customBucket = telemetryBucketCustomTools(opts.tools?.length ?? 0);
+    const { integration, integrationKind, mcpBucket } = telemetryIntegration(opts);
+    const engineObj = opts.engine;
+    const nr = opts.openaiRealtimeNoiseReduction ?? engineObj?.noiseReduction;
+    const noiseReduction = nr === "near_field" || nr === "far_field" ? nr : "none";
+    const td = opts.realtimeTurnDetection ?? engineObj?.turnDetection;
+    const turnDetection = td != null ? "custom" : "none";
+    const preamblesUsed = Boolean(opts.toolCallPreambles);
+    const perToolTimeoutsSet = Array.isArray(opts.tools) && opts.tools.some((t) => t.timeoutMs !== void 0);
+    const llmFallbackConfigured = typeof opts.llm?.getAvailability === "function";
+    const shapeKey = [
+      builtin,
+      customBucket,
+      integration,
+      integrationKind,
+      mcpBucket,
+      noiseReduction,
+      turnDetection,
+      preamblesUsed,
+      perToolTimeoutsSet,
+      llmFallbackConfigured
+    ].join("|");
+    if (!this.telemetrySeenAgentShapes.has(shapeKey)) {
+      this.telemetrySeenAgentShapes.add(shapeKey);
+      this.telemetry.record("agent_configured", {
+        builtin_tool_count: builtin,
+        custom_tool_count_bucket: customBucket,
+        integration,
+        integration_kind: integrationKind,
+        mcp_server_count_bucket: mcpBucket,
+        noise_reduction: noiseReduction,
+        turn_detection: turnDetection,
+        preambles_used: preamblesUsed,
+        per_tool_timeouts_set: perToolTimeoutsSet,
+        llm_fallback_configured: llmFallbackConfigured
+      });
+    }
     let working = { ...opts };
     if (opts.engine) {
       if (opts.provider) {
@@ -1061,6 +1818,7 @@ var Patter = class {
       opts.dashboardToken ?? "",
       opts.allowInsecureDashboard ?? false
     );
+    this.embeddedServer.telemetry = this.telemetry;
     this.embeddedServer.popPrewarmAudio = this.popPrewarmAudio;
     this.embeddedServer.popPrewarmedConnections = this.popPrewarmedConnections;
     this.embeddedServer.recordPrewarmWaste = this.recordPrewarmWaste;
@@ -1070,6 +1828,7 @@ var Patter = class {
         await waitForTunnelPubliclyReachable(webhookUrl);
       }
       this._readyResolve(webhookUrl);
+      this.telemetry.flushPending();
     } catch (err) {
       const e = err instanceof Error ? err : new Error(String(err));
       this._readyReject(e);
@@ -1078,7 +1837,7 @@ var Patter = class {
   }
   /** Run the agent in interactive terminal-test mode (no real telephony). */
   async test(opts) {
-    const { TestSession: TestSession2 } = await import("./test-mode-4QLLWYVV.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-XFOADUNE.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -1752,6 +2511,7 @@ var Patter = class {
    * entries leak across ``serve`` / ``disconnect`` cycles. See FIX #93.
    */
   async disconnect() {
+    this.telemetry.flushPending();
     for (const handle of this.prewarmTtlTimers.values()) {
       clearTimeout(handle);
     }
@@ -2329,6 +3089,7 @@ var PatterTool = class {
   maxDurationSec;
   recording;
   started = false;
+  hermesTelemetryEmitted = false;
   /** Cached in-progress (or completed) start promise so concurrent execute()
    *  callers all await the same boot sequence instead of each racing into
    *  phone.serve(). Reset to null on failure so callers can retry after a
@@ -2485,6 +3246,20 @@ var PatterTool = class {
    * the same wire contract.
    */
   hermesHandler() {
+    if (!this.hermesTelemetryEmitted) {
+      this.hermesTelemetryEmitted = true;
+      try {
+        const tel = this.phone.telemetry;
+        tel?.record("agent_configured", {
+          builtin_tool_count: 0,
+          custom_tool_count_bucket: "0",
+          integration: "hermes",
+          integration_kind: "none",
+          mcp_server_count_bucket: "0"
+        });
+      } catch {
+      }
+    }
     return async (args) => {
       try {
         const result = await this.execute(args);
@@ -7539,6 +8314,310 @@ var LLM5 = class extends GoogleLLMProvider {
   }
 };
 
+// src/llm/openai-compatible.ts
+init_esm_shims();
+import { createHash } from "crypto";
+var DEFAULT_TIMEOUT_S = 60;
+function hashCaller(caller) {
+  if (!caller) return void 0;
+  return createHash("sha256").update(caller, "utf8").digest("hex").slice(0, 16);
+}
+var OpenAICompatibleLLMProvider = class {
+  /**
+   * Stable pricing/dashboard key — read by stream-handler/metrics. Typed as
+   * ``string`` (not the narrowed literal) so the Hermes / OpenClaw presets can
+   * override it with their own key while still extending this class.
+   */
+  static providerKey = "openai_compatible";
+  /** Resolved bearer; undefined for keyless gateways. */
+  apiKey;
+  model;
+  baseUrl;
+  timeoutMs;
+  extraHeaders;
+  sessionUserPrefix;
+  sessionIdHeader;
+  sessionIdPrefix;
+  sessionKeyHeader;
+  sessionKey;
+  sessionKeyFactory;
+  temperature;
+  maxTokens;
+  responseFormat;
+  parallelToolCalls;
+  toolChoice;
+  seed;
+  topP;
+  frequencyPenalty;
+  presencePenalty;
+  stop;
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error(
+        'OpenAICompatibleLLMProvider requires a baseUrl (e.g. "http://127.0.0.1:11434/v1").'
+      );
+    }
+    if (!options.model) {
+      throw new Error("OpenAICompatibleLLMProvider requires a model.");
+    }
+    this.apiKey = options.apiKey ?? (options.apiKeyEnv ? process.env[options.apiKeyEnv] : void 0);
+    this.model = options.model;
+    this.baseUrl = options.baseUrl;
+    this.timeoutMs = (options.timeout ?? DEFAULT_TIMEOUT_S) * 1e3;
+    this.extraHeaders = options.extraHeaders;
+    this.sessionUserPrefix = options.sessionUserPrefix;
+    this.sessionIdHeader = options.sessionIdHeader;
+    this.sessionIdPrefix = options.sessionIdPrefix;
+    this.sessionKeyHeader = options.sessionKeyHeader;
+    this.sessionKey = options.sessionKey;
+    let sessionKeyFactory = options.sessionKeyFactory;
+    if (!sessionKeyFactory && options.sessionKeyFrom === "caller_hash") {
+      sessionKeyFactory = (ctx) => ctx.callerHash ? `patter-caller-${ctx.callerHash}` : void 0;
+    } else if (options.sessionKeyFrom !== void 0 && options.sessionKeyFrom !== "caller_hash") {
+      throw new Error(
+        `sessionKeyFrom must be 'caller_hash' or undefined, got ${JSON.stringify(
+          options.sessionKeyFrom
+        )}`
+      );
+    }
+    this.sessionKeyFactory = sessionKeyFactory;
+    this.temperature = options.temperature;
+    this.maxTokens = options.maxTokens;
+    this.responseFormat = options.responseFormat;
+    this.parallelToolCalls = options.parallelToolCalls;
+    this.toolChoice = options.toolChoice;
+    this.seed = options.seed;
+    this.topP = options.topP;
+    this.frequencyPenalty = options.frequencyPenalty;
+    this.presencePenalty = options.presencePenalty;
+    this.stop = options.stop;
+  }
+  /**
+   * Assemble the request headers. ``User-Agent`` is set first so any
+   * ``extraHeaders`` (and the per-call session headers) layer on top without
+   * silently dropping the SDK attribution, and the ``Authorization`` header is
+   * only added when a key is present (keyless gateways omit it).
+   *
+   * The two session headers are emitted INDEPENDENTLY, each gated on its own
+   * config (decoupled from ``sessionUserPrefix`` and from each other):
+   *  - ``sessionIdHeader`` (+ ``callId``) → ``` `${sessionIdPrefix}${callId}` ```
+   *  - ``sessionKeyHeader`` (+ ``sessionKey``) → the static ``sessionKey`` value.
+   * ``sessionKey`` is a credential-grade memory scope and is never logged.
+   */
+  buildHeaders(callId, caller, callee) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": `getpatter/${VERSION}`,
+      ...this.extraHeaders ?? {}
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    if (this.sessionIdHeader && callId) {
+      headers[this.sessionIdHeader] = `${this.sessionIdPrefix ?? ""}${callId}`;
+    }
+    if (this.sessionKeyHeader) {
+      const sessionKeyValue = this.resolveSessionKey(callId, caller, callee);
+      if (sessionKeyValue) {
+        headers[this.sessionKeyHeader] = sessionKeyValue;
+      }
+    }
+    return headers;
+  }
+  /**
+   * Resolve the ``sessionKeyHeader`` VALUE for this call. When a
+   * ``sessionKeyFactory`` is configured it is called with a
+   * {@link SessionContext} (the raw ``caller`` plus its non-reversible
+   * {@link hashCaller}) and its return value wins — a falsy return omits the
+   * header. Otherwise the static ``sessionKey`` is used. Never logged.
+   */
+  resolveSessionKey(callId, caller, callee) {
+    if (this.sessionKeyFactory) {
+      const ctx = {
+        callId,
+        caller,
+        callee,
+        callerHash: hashCaller(caller)
+      };
+      return this.sessionKeyFactory(ctx);
+    }
+    return this.sessionKey;
+  }
+  /**
+   * Pre-call DNS / TLS warmup for the configured endpoint. Best-effort:
+   * 5 s timeout, all exceptions swallowed at debug level. The ``Authorization``
+   * header is only sent when a key is present so the operator-grade bearer is
+   * never echoed for keyless gateways (and the key is never logged).
+   */
+  async warmup() {
+    try {
+      const headers = {};
+      if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+      await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(
+        `OpenAI-compatible LLM warmup failed (best-effort): ${String(err)}`
+      );
+    }
+  }
+  /**
+   * Build the request body. Mirrors the base OpenAI provider's sampling-kwarg
+   * assembly and additionally sets ``user`` for session continuity when
+   * ``sessionUserPrefix`` is set AND a ``callId`` is available — so the default
+   * (prefix unset) behaviour is byte-identical to the base provider.
+   */
+  buildBody(messages, tools, callId) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (this.temperature !== void 0) body.temperature = this.temperature;
+    if (this.maxTokens !== void 0) body.max_completion_tokens = this.maxTokens;
+    if (this.responseFormat !== void 0) body.response_format = this.responseFormat;
+    if (this.parallelToolCalls !== void 0) body.parallel_tool_calls = this.parallelToolCalls;
+    if (this.toolChoice !== void 0) body.tool_choice = this.toolChoice;
+    if (this.seed !== void 0) body.seed = this.seed;
+    if (this.topP !== void 0) body.top_p = this.topP;
+    if (this.frequencyPenalty !== void 0) body.frequency_penalty = this.frequencyPenalty;
+    if (this.presencePenalty !== void 0) body.presence_penalty = this.presencePenalty;
+    if (this.stop !== void 0) body.stop = this.stop;
+    if (tools) body.tools = tools;
+    if (this.sessionUserPrefix !== void 0 && callId) {
+      body.user = `${this.sessionUserPrefix}${callId}`;
+    }
+    return body;
+  }
+  /** Stream Patter-format LLM chunks from the configured chat completions API. */
+  async *stream(messages, tools, opts) {
+    const callId = opts?.callId;
+    const caller = opts?.caller;
+    const callee = opts?.callee;
+    const body = this.buildBody(messages, tools, callId);
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.buildHeaders(callId, caller, callee),
+      body: JSON.stringify(body),
+      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(this.timeoutMs))
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(
+        `OpenAI-compatible API error: ${response.status} ${errText}`
+      );
+      throw new PatterConnectionError(
+        `LLM API returned ${response.status}: ${errText.slice(0, 200)}`
+      );
+    }
+    yield* parseOpenAISseStream(response);
+  }
+};
+var LLM6 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "openai_compatible";
+};
+
+// src/llm/custom.ts
+init_esm_shims();
+var LLM7 = class extends OpenAICompatibleLLMProvider {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "custom";
+};
+
+// src/llm/hermes.ts
+init_esm_shims();
+var BASE_URL = "http://127.0.0.1:8642/v1";
+var DEFAULT_MODEL5 = "hermes-agent";
+var API_KEY_ENV = "API_SERVER_KEY";
+var MODEL_ENV = "API_SERVER_MODEL_NAME";
+var SESSION_USER_PREFIX = "patter-call-";
+var SESSION_ID_HEADER = "X-Hermes-Session-Id";
+var SESSION_ID_PREFIX = "patter-call-";
+var SESSION_KEY_HEADER = "X-Hermes-Session-Key";
+var DEFAULT_TIMEOUT_S2 = 120;
+var LLM8 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "hermes";
+  constructor(opts = {}) {
+    const model = opts.model ?? process.env[MODEL_ENV] ?? DEFAULT_MODEL5;
+    const options = {
+      apiKey: opts.apiKey,
+      apiKeyEnv: API_KEY_ENV,
+      baseUrl: opts.baseUrl ?? BASE_URL,
+      model,
+      timeout: opts.timeout ?? DEFAULT_TIMEOUT_S2,
+      sessionUserPrefix: SESSION_USER_PREFIX,
+      sessionIdHeader: SESSION_ID_HEADER,
+      sessionIdPrefix: SESSION_ID_PREFIX,
+      sessionKeyHeader: SESSION_KEY_HEADER,
+      sessionKey: opts.sessionKey,
+      sessionKeyFrom: opts.sessionKeyFrom,
+      sessionKeyFactory: opts.sessionKeyFactory,
+      extraHeaders: opts.extraHeaders,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
+    };
+    super(options);
+  }
+};
+
+// src/llm/openclaw.ts
+init_esm_shims();
+var BASE_URL2 = "http://127.0.0.1:18789/v1";
+var API_KEY_ENV2 = "OPENCLAW_API_KEY";
+var SESSION_HEADER = "x-openclaw-session-key";
+var SESSION_USER_PREFIX2 = "patter-call-";
+var DEFAULT_TIMEOUT_S3 = 120;
+var OPENCLAW_AGENT_RE = /^[A-Za-z0-9._:/-]+$/;
+var LLM9 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "openclaw";
+  constructor(opts) {
+    const agent = opts?.agent;
+    if (!agent || !OPENCLAW_AGENT_RE.test(agent)) {
+      throw new Error(
+        `Invalid OpenClaw agent id: ${JSON.stringify(agent)}. Allowed characters: letters, digits, dot, underscore, colon, slash, dash.`
+      );
+    }
+    const model = agent.includes("/") || agent.includes(":") ? agent : `openclaw/${agent}`;
+    const options = {
+      apiKey: opts.apiKey,
+      apiKeyEnv: API_KEY_ENV2,
+      baseUrl: opts.baseUrl ?? BASE_URL2,
+      model,
+      timeout: opts.timeout ?? DEFAULT_TIMEOUT_S3,
+      sessionUserPrefix: SESSION_USER_PREFIX2,
+      // Wire-identical to the prior behaviour: header value is the raw call id
+      // (empty prefix), and OpenClaw's gateway also derives the session from
+      // the ``user`` field above. No separate memory-scope header.
+      sessionIdHeader: SESSION_HEADER,
+      sessionIdPrefix: "",
+      extraHeaders: opts.extraHeaders,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
+    };
+    super(options);
+  }
+};
+
 // src/providers/deepfilternet-filter.ts
 init_esm_shims();
 function log() {
@@ -7771,57 +8850,6 @@ var KrispVivaFilter = class {
   }
 };
 
-// src/telephony/twilio.ts
-init_esm_shims();
-var Carrier2 = class {
-  kind = "twilio";
-  accountSid;
-  authToken;
-  constructor(opts = {}) {
-    const sid = opts.accountSid ?? process.env.TWILIO_ACCOUNT_SID;
-    const tok = opts.authToken ?? process.env.TWILIO_AUTH_TOKEN;
-    if (!sid) {
-      throw new Error(
-        "Twilio carrier requires accountSid. Pass { accountSid: 'AC...' } or set TWILIO_ACCOUNT_SID in the environment."
-      );
-    }
-    if (!tok) {
-      throw new Error(
-        "Twilio carrier requires authToken. Pass { authToken: '...' } or set TWILIO_AUTH_TOKEN in the environment."
-      );
-    }
-    this.accountSid = sid;
-    this.authToken = tok;
-  }
-};
-
-// src/telephony/telnyx.ts
-init_esm_shims();
-var Carrier3 = class {
-  kind = "telnyx";
-  apiKey;
-  connectionId;
-  publicKey;
-  constructor(opts = {}) {
-    const key = opts.apiKey ?? process.env.TELNYX_API_KEY;
-    const conn = opts.connectionId ?? process.env.TELNYX_CONNECTION_ID;
-    const pub = opts.publicKey ?? process.env.TELNYX_PUBLIC_KEY;
-    if (!key) {
-      throw new Error(
-        "Telnyx carrier requires apiKey. Pass { apiKey: '...' } or set TELNYX_API_KEY in the environment."
-      );
-    }
-    if (!conn) {
-      throw new Error(
-        "Telnyx carrier requires connectionId. Pass { connectionId: '...' } or set TELNYX_CONNECTION_ID in the environment."
-      );
-    }
-    this.apiKey = key;
-    this.connectionId = conn;
-    this.publicKey = pub;
-  }
-};
-
 // src/public-api.ts
 init_esm_shims();
 var DEFAULT_GUARDRAIL_REPLACEMENT = "I'm sorry, I can't respond to that.";
@@ -7888,9 +8916,9 @@ function tool(opts) {
 
 // src/chat-context.ts
 init_esm_shims();
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function generateId() {
-  return randomUUID().replace(/-/g, "").slice(0, 12);
+  return randomUUID2().replace(/-/g, "").slice(0, 12);
 }
 function createMessage(role, content, options) {
   return Object.freeze({
@@ -8305,8 +9333,8 @@ var IVRActivity = class {
 
 // src/audio/background-audio.ts
 init_esm_shims();
-import { promises as fs } from "fs";
-import path from "path";
+import { promises as fs3 } from "fs";
+import path2 from "path";
 import { fileURLToPath } from "url";
 var BuiltinAudioClip = {
   CITY_AMBIENCE: "city-ambience.ogg",
@@ -8319,8 +9347,8 @@ var BuiltinAudioClip = {
 };
 function builtinClipPath(clip) {
   const meta = typeof import.meta !== "undefined" ? import.meta : void 0;
-  const here = meta?.url ? path.dirname(fileURLToPath(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
-  return path.resolve(here, "..", "resources", "audio", clip);
+  const here = meta?.url ? path2.dirname(fileURLToPath(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  return path2.resolve(here, "..", "resources", "audio", clip);
 }
 var INT16_MIN = -32768;
 var INT16_MAX = 32767;
@@ -8489,7 +9517,7 @@ var BackgroundAudioPlayer = class {
         return source.decode(source.path);
       case "builtin": {
         const p = builtinClipPath(source.clip);
-        const header = await fs.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
+        const header = await fs3.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
         if (header.toString("ascii") !== "OggS") {
           throw new Error(`Bundled clip ${source.clip} is not a valid Ogg file`);
         }
@@ -8536,8 +9564,8 @@ var TwilioAdapter = class _TwilioAdapter {
     this.baseUrl = opts.region ? `https://api.${opts.region}.twilio.com/2010-04-01` : TWILIO_API_BASE;
     this.authHeader = `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
   }
-  async request(method, path2, body) {
-    const url = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path2}`;
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path3}`;
     const headers = { Authorization: this.authHeader };
     if (body) headers["Content-Type"] = "application/x-www-form-urlencoded";
     const response = await fetch(url, {
@@ -8548,7 +9576,7 @@ var TwilioAdapter = class _TwilioAdapter {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Twilio ${method} ${path2} failed: ${response.status} ${text}`);
+      throw new Error(`Twilio ${method} ${path3} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -8566,8 +9594,8 @@ var TwilioAdapter = class _TwilioAdapter {
     const country = encodeURIComponent(opts.countryCode);
     const queryParts = ["PageSize=1"];
     if (opts.areaCode) queryParts.push(`AreaCode=${encodeURIComponent(opts.areaCode)}`);
-    const path2 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
-    const available = await this.request("GET", path2);
+    const path3 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
+    const available = await this.request("GET", path3);
     const first = available.available_phone_numbers?.[0]?.phone_number;
     if (!first) {
       throw new Error(`TwilioAdapter: no numbers available for country ${opts.countryCode}`);
@@ -8667,7 +9695,7 @@ var TwilioAdapter = class _TwilioAdapter {
 
 // src/providers/telnyx-adapter.ts
 init_esm_shims();
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var TELNYX_API_BASE = "https://api.telnyx.com/v2";
 var TelnyxAdapter = class {
   apiKey;
@@ -8678,8 +9706,8 @@ var TelnyxAdapter = class {
     this.apiKey = apiKey;
     this.connectionId = connectionId;
   }
-  async request(method, path2, body) {
-    const url = `${this.baseUrl}${path2}`;
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}${path3}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`
     };
@@ -8692,7 +9720,7 @@ var TelnyxAdapter = class {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Telnyx ${method} ${path2} failed: ${response.status} ${text}`);
+      throw new Error(`Telnyx ${method} ${path3} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -8776,7 +9804,7 @@ var TelnyxAdapter = class {
     if (!callControlId) throw new Error("TelnyxAdapter: callControlId is required");
     const encoded = encodeURIComponent(callControlId);
     const body = {
-      command_id: opts.commandId ?? randomUUID2()
+      command_id: opts.commandId ?? randomUUID3()
     };
     try {
       await this.request(
@@ -9050,6 +10078,12 @@ var TelnyxTTS = class {
 
 // src/observability/index.ts
 init_esm_shims();
+
+// src/index.ts
+var hermes = Object.freeze({ LLM: LLM8 });
+var openclaw = Object.freeze({ LLM: LLM9 });
+var openaiCompatible = Object.freeze({ LLM: LLM6 });
+var custom = Object.freeze({ LLM: LLM7 });
 export {
   AllProvidersFailedError,
   LLM2 as AnthropicLLM,
@@ -9065,6 +10099,7 @@ export {
   LLM4 as CerebrasLLM,
   ChatContext,
   CloudflareTunnel,
+  LLM7 as CustomLLM,
   DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING,
   DTMF_EVENTS,
@@ -9088,6 +10123,7 @@ export {
   LLM5 as GoogleLLM,
   LLM3 as GroqLLM,
   Guardrail,
+  LLM8 as HermesLLM,
   IVRActivity,
   TTS7 as InworldTTS,
   KrispFrameDuration,
@@ -9098,6 +10134,8 @@ export {
   MetricsStore,
   MinWordsStrategy,
   Ngrok,
+  LLM6 as OpenAICompatibleLLM,
+  OpenAICompatibleLLMProvider,
   LLM as OpenAILLM,
   OpenAILLMProvider,
   Realtime as OpenAIRealtime,
@@ -9111,6 +10149,7 @@ export {
   STT3 as OpenAITranscribeSTT,
   OpenAITranscriptionModel,
   OpenAIVoice,
+  LLM9 as OpenClawLLM,
   PRICING_LAST_UPDATED,
   PRICING_VERSION,
   PartialStreamError,
@@ -9179,6 +10218,7 @@ export {
   createResampler24kTo16k,
   createResampler24kTo8k,
   createResampler8kTo16k,
+  custom,
   deepgram,
   defineTool,
   elevenlabs,
@@ -9190,6 +10230,8 @@ export {
   geminiLive,
   getLogger,
   guardrail,
+  hashCaller,
+  hermes,
   initTracing,
   isRemoteUrl,
   isTracingEnabled,
@@ -9202,7 +10244,9 @@ export {
   mountDashboard,
   mulawToPcm16,
   notifyDashboard,
+  openaiCompatible,
   openaiTts,
+  openclaw,
   openclawConsult,
   openclawPostCallNotifier,
   pcm16ToMulaw,