@wenathlan/getry 2.0.165 → 2.0.166

package/utils.ts

@@ -0,0 +1,263 @@
+/**
+ * utils — shared helpers for v1 v5 gateway replica
+ * all identifiers lowercase no underscore no emoji per skill
+ * related logics grouped in this one file 0 to 95 logics
+ */
+
+import { randomInt } from "node:crypto";
+import {
+  THINKINGLEVELS,
+  budgetof,
+  defaultthinkinglevel,
+  islevel,
+  listlevels,
+  type ThinkingLevel,
+  type ThinkingLevelName,
+} from "@wenathlan/getry/thinking";
+
+/** cors headers — open cors for all gateway routes */
+export const corsheaders: Record<string, string> = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods":
+    "get,post,put,patch,delete,head,options,connect,trace,propfind,proppatch,mkcol,copy,move,lock,unlock,search,purge,link,unlink,report,checkout,checkin,checkout,version-control,label,merge,baseline-control,mkactivity,mkworkspace,update,subscribe,unsubscribe,notify,poll,bind,rebind,unbind,reindex",
+  "access-control-allow-headers":
+    "content-type,authorization,x-token,x-chat-id,x-user-id,x-session-id,x-request-id,x-thinking-level,x-model,x-tools,accept",
+  "access-control-max-age": "86400",
+  "access-control-expose-headers": "x-request-id,x-session-id",
+};
+
+/** content type constants */
+export const ctjson = "application/json";
+export const ctsse = "text/event-stream";
+export const ctplain = "text/plain";
+export const ctndjson = "application/x-ndjson";
+export const ctoctet = "application/octet-stream";
+
+/** max duration — near infinite 2 power 31 minus 1 */
+export const maxdurationconst = 2147483647;
+
+/** default max tokens — conservative per request 32768 */
+export const defaultmaxtokens = 32768;
+
+/** randombase36 — cryptographically secure base36 string of n chars
+ * node crypto randomint keeps every character uniformly distributed
+ * code scanning js insecure randomness safe — never math random */
+export function randombase36(n: number): string {
+  const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
+  let out = "";
+  for (let i = 0; i < n; i += 1) out += alphabet[randomInt(alphabet.length)];
+  return out;
+}
+
+/** securerandom — cryptographically secure uniform float in 0 1
+ * replacement for math random in every security sensitive path
+ * jitter backoff session ids key selection all use this */
+export function securerandom(): number {
+  return randomInt(1, 2 ** 48) / 2 ** 48;
+}
+
+/** genid — generate a unique chatcmpl id
+ * timestamp plus 8 chars of secure base36 entropy */
+export function genid(prefix = "chatcmpl"): string {
+  return `${prefix}-${Date.now().toString(36)}${randombase36(8)}`;
+}
+
+/** getip — extract client ip from request headers */
+export function getip(req: Request): string {
+  const headers = req.headers;
+  return (
+    headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
+    headers.get("x-real-ip") ||
+    headers.get("cf-connecting-ip") ||
+    headers.get("x-client-ip") ||
+    "unknown"
+  );
+}
+
+/** handlecors — handle options preflight returns response or null */
+export function handlecors(req: Request): Response | null {
+  if (req.method.toUpperCase() === "OPTIONS") {
+    return new Response(null, { status: 204, headers: corsheaders });
+  }
+  return null;
+}
+
+/** json headers */
+export function jsonheaders(): Record<string, string> {
+  return { ...corsheaders, "content-type": ctjson };
+}
+
+/** detectcontenttype — read accept header returns format */
+export function detectcontenttype(req: Request): "sse" | "ndjson" | "json" | "plain" | "octet" {
+  const accept = (req.headers.get("accept") || "").toLowerCase();
+  if (accept.includes(ctndjson)) return "ndjson";
+  if (accept.includes("text/event-stream")) return "sse";
+  if (accept.includes(ctplain)) return "plain";
+  if (accept.includes(ctoctet)) return "octet";
+  return "json";
+}
+
+/** clamp — bound a number between min and max
+ * only nan falls back: infinity is a boundable value (plus infinity clamps
+ * to max minus infinity to min) — treating it like nan silently replaced
+ * extreme inputs with the fallback */
+export function clamp(n: unknown, min: number, max: number, fallback = 0): number {
+  const v = typeof n === "string" ? parseFloat(n) : typeof n === "number" ? n : fallback;
+  if (Number.isNaN(v)) return fallback;
+  if (!Number.isFinite(v)) return v > 0 ? max : min;
+  return Math.max(min, Math.min(max, v));
+}
+
+/** automaxtokens — clamp max tokens 1 to 98304 */
+export function automaxtokens(n: unknown, fallback = defaultmaxtokens): number {
+  const v = typeof n === "string" ? parseInt(n, 10) : typeof n === "number" ? n : fallback;
+  if (!Number.isFinite(v) || v === 0) return fallback;
+  return clamp(v, 1, 98304, fallback);
+}
+
+/** autotemp — clamp temperature 0 to 2 */
+export function autotemp(n: unknown, fallback = 0.7): number {
+  return clamp(n, 0, 2, fallback);
+}
+
+/** autotopp — clamp top p 0 to 1 */
+export function autotopp(n: unknown, fallback = 0.9): number {
+  return clamp(n, 0, 1, fallback);
+}
+
+/** autofrequencypenalty */
+export function autofrequencypenalty(n: unknown, fallback = 0): number {
+  return clamp(n, -2, 2, fallback);
+}
+
+/** autopresencepenalty */
+export function autopresencepenalty(n: unknown, fallback = 0): number {
+  return clamp(n, -2, 2, fallback);
+}
+
+/** auton — clamp n 1 to 10 */
+export function auton(n: unknown, fallback = 1): number {
+  return clamp(n, 1, 10, fallback);
+}
+
+/** autoseed — nonnegative int bounded
+ * absolute value floors toward zero: abs before floor — floor before abs
+ * rounded negatives away from zero (-12.9 became 13 while 12.9 was 12) */
+export function autoseed(n: unknown, fallback = 0): number {
+  const v = typeof n === "string" ? parseInt(n, 10) : typeof n === "number" ? n : fallback;
+  if (!Number.isFinite(v)) return fallback;
+  return clamp(Math.floor(Math.abs(v)), 0, 2147483647, fallback);
+}
+
+/** autothinking — normalize thinking level string to the live ladder owned
+ * by the getry engine (pr16, the registerable fold): the rung vocabulary
+ * answers the owner's registered levels (any count — never a fixed 7) and
+ * the default rung answers the owner's defaultthinkinglevel — never a
+ * second declaration. */
+export function autothinking(level?: unknown): ThinkingLevelName {
+  if (!level || typeof level !== "string") return defaultthinkinglevel();
+  const l = String(level).toLowerCase().trim();
+  if (islevel(l)) return l;
+  if (l === "disabled" || l === "off" || l === "false") return "none";
+  if (l === "minimum") return "minimal";
+  if (l === "med" || l === "mid") return "medium";
+  if (l === "extra" || l === "ultra") return "xhigh";
+  if (l === "maximum" || l === "full" || l === "all") return "max";
+  return defaultthinkinglevel();
+}
+
+/** thinking budgets — the token budgets of the live ladder derived from
+ * the getry engine (the one owner of the reasoning ladder, pr16): never a
+ * local copy, the map answers the owner's registered rungs at load time
+ * and budgetof answers the live truth at call time. */
+export const thinkingbudgets: Record<string, number> = Object.fromEntries(
+  listlevels().map((rung) => [rung.level, rung.budget]),
+);
+
+/** the seed ladder re-exported for the hosts that inspect the family
+ * default — the live truth answers listlevels() on the engine. */
+export const thinkingseed: ThinkingLevel[] = THINKINGLEVELS;
+
+/** thinkingbudget — get token budget for a level */
+export function thinkingbudget(level?: string): number {
+  return budgetof(autothinking(level));
+}
+
+/** makethinker — create a thinking budget object */
+export function makethinker(level?: string) {
+  const lvl = autothinking(level);
+  if (lvl === "none") return { type: "disabled" as const };
+  return { type: "enabled" as const, budget: budgetof(lvl) };
+}
+
+/** safestringify — json stringify that never throws */
+export function safestringify(obj: unknown): string {
+  try {
+    return JSON.stringify(obj);
+  } catch {
+    return String(obj);
+  }
+}
+
+/** safejsonparse — json parse that never throws returns null on failure */
+export function safejsonparse<T = unknown>(s: string): T | null {
+  try {
+    return JSON.parse(s) as T;
+  } catch {
+    return null;
+  }
+}
+
+/** levenshtein — fuzzy string distance for parameter name matching */
+export function levenshtein(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+
+/** esttokens — cjk aware token estimate */
+export function esttokens(text: string): number {
+  if (!text) return 0;
+  let ascii = 0;
+  let cjk = 0;
+  for (const ch of text) {
+    const code = ch.codePointAt(0) || 0;
+    if (code >= 0x3000 && code <= 0x9fff) cjk++;
+    else if (code >= 0x4e00 && code <= 0x9fff) cjk++;
+    else if (code >= 0xac00 && code <= 0xd7af) cjk++;
+    else ascii++;
+  }
+  return Math.ceil(ascii / 4 + cjk / 2);
+}
+
+/** truncatemessages — truncate message history to fit context window */
+export function truncatemessages(messages: unknown[], maxtokens: number): unknown[] {
+  const result: unknown[] = [];
+  let total = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i] as Record<string, unknown>;
+    const content = typeof msg.content === "string" ? msg.content : safestringify(msg.content);
+    const tokens = esttokens(content) + 4;
+    if (total + tokens > maxtokens) break;
+    result.unshift(msg);
+    total += tokens;
+  }
+  return result;
+}
+
+// the devthink meta-model identity and the intelligencerank interface
+// previously lived here as helpers for the deleted gatewayvN.ts files —
+// that context now lives exactly once: the type surface in types.ts
+// (intelligencerank, modeldef.rank) and the user definitions in
+// config.mjs (one context one file — nothing duplicated in utils)

package/validate.ts

@@ -0,0 +1,61 @@
+/**
+ * validate — the pure gateway definition validator of the getry family.
+ *
+ * The ownership move (wave/ownership.gateway step 3) folded the whole
+ * configuration loader family into the server owner, and the pure
+ * validator landed beside the hono transport it never needed. This module
+ * is the corrected seat: the checks are pure logic over the definition
+ * object (no transport, no filesystem, no server imports), so every
+ * consumer of the family — the server owner that re-exports it, the
+ * devthink config bridge the browser graph rides, the configloader test
+ * lane — resolves the same single owner without ever dragging the
+ * transport stack into a module graph that must stay browser-pure.
+ *
+ * The contract is verbatim the server face: one definition in, one list
+ * of human readable problems out — empty when valid, synchronous always.
+ */
+import type { gatewaydefinition } from "./types.js";
+
+/** validateconfig — check a gateway definition for common errors
+ * returns a list of human readable problems — empty when valid */
+export function validateconfig(def: gatewaydefinition): string[] {
+  const problems: string[] = [];
+  if (!def.versions || Object.keys(def.versions).length === 0) {
+    problems.push("no versions defined — add at least one version to versions map");
+    return problems;
+  }
+  for (const [id, cfg] of Object.entries(def.versions)) {
+    const prefix = `version ${id}:`;
+    if (!cfg.id) problems.push(`${prefix} missing id`);
+    if (cfg.id !== id) problems.push(`${prefix} id mismatch — map key is ${id} but id is ${cfg.id}`);
+    if (!cfg.providername) problems.push(`${prefix} missing providername`);
+    if (!cfg.upstreams || cfg.upstreams.length === 0) problems.push(`${prefix} no upstreams configured`);
+    if (!cfg.auth) problems.push(`${prefix} missing auth config`);
+    if (!cfg.models || cfg.models.length === 0) problems.push(`${prefix} no models configured`);
+    if (!cfg.metamodel?.id) problems.push(`${prefix} missing metamodel id`);
+    // rotation models must exist in the catalog — the catalog may itself be
+    // missing (already reported above) so the lookup guards against it
+    if (cfg.rotation?.models) {
+      const ids = new Set((cfg.models ?? []).map((m) => m.id));
+      for (const rm of cfg.rotation.models) {
+        if (!ids.has(rm)) problems.push(`${prefix} rotation model ${rm} not in models catalog`);
+      }
+    }
+    // defaultmodel must exist
+    if (
+      cfg.defaultmodel &&
+      !(cfg.models ?? []).find((m) => m.id === cfg.defaultmodel) &&
+      cfg.defaultmodel !== cfg.metamodel?.id
+    ) {
+      problems.push(`${prefix} defaultmodel ${cfg.defaultmodel} not in models catalog`);
+    }
+    // auth env var must be set when required from env — a version with a
+    // missing auth block already carries its problem above; the dereference
+    // below used to crash the whole validation with a type error instead of
+    // reporting the remaining problems
+    if (cfg.auth?.required && cfg.auth?.keysources?.includes("env") && !cfg.auth?.envvar) {
+      problems.push(`${prefix} auth requires env keys but envvar is not set`);
+    }
+  }
+  return problems;
+}