@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-FNXVT7HF.js

@@ -0,0 +1,52 @@
+// src/utils/perf-profile.ts
+var daemonDefaults = false;
+function useDaemonPerfDefaults() {
+  daemonDefaults = true;
+}
+function getPerfProfile() {
+  const explicit = process.env.WRONGSTACK_PERF_PROFILE ?? process.env.WSTACK_PERF_PROFILE;
+  if (explicit === void 0 || explicit.trim() === "") {
+    return daemonDefaults ? "frugal" : "balanced";
+  }
+  const raw = explicit.trim().toLowerCase();
+  if (raw === "frugal" || raw === "cimri" || raw === "low" || raw === "eco") {
+    return "frugal";
+  }
+  return "balanced";
+}
+function isFrugalPerf() {
+  return getPerfProfile() === "frugal";
+}
+function indexParallelBatchSize(availableCores) {
+  const cores = Math.max(1, Math.floor(availableCores) || 1);
+  if (isFrugalPerf()) {
+    return Math.min(4, cores);
+  }
+  return Math.min(cores * 4, 40);
+}
+function sqliteCachePragmas() {
+  if (isFrugalPerf()) {
+    return { cacheSizeKiB: 16384, mmapBytes: 64 * 1024 * 1024 };
+  }
+  return { cacheSizeKiB: 131072, mmapBytes: 512 * 1024 * 1024 };
+}
+function SageCachePragmas() {
+  if (isFrugalPerf()) {
+    return { cacheSizeKiB: 8192, mmapBytes: 32 * 1024 * 1024 };
+  }
+  return { cacheSizeKiB: 65536, mmapBytes: 256 * 1024 * 1024 };
+}
+function tuiStreamFlushMs() {
+  return isFrugalPerf() ? 150 : 100;
+}
+
+export {
+  useDaemonPerfDefaults,
+  getPerfProfile,
+  isFrugalPerf,
+  indexParallelBatchSize,
+  sqliteCachePragmas,
+  SageCachePragmas,
+  tuiStreamFlushMs
+};
+//# sourceMappingURL=chunk-FNXVT7HF.js.map

package/dist/chunk-FSWCWSTS.js

@@ -0,0 +1,395 @@
+// src/utils/tool-wire-compact.ts
+var TOOL_DESCRIPTION_MAX_CHARS = 400;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
+var compactCache = /* @__PURE__ */ new WeakMap();
+function compactToolDefinitionForWire(tool, opts = {}) {
+  const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    const cached = compactCache.get(tool);
+    if (cached) return cached;
+  }
+  const compact = {
+    name: tool.name,
+    description: compactDescription(
+      tool.description ?? "",
+      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
+    ),
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
+    )
+  };
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    compactCache.set(tool, compact);
+  }
+  return compact;
+}
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+    }
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
+      );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
+    }
+  }
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
+}
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
+}
+function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
+  const compact = compactSchemaNode(schema, maxDescriptionChars);
+  return isRecord(compact) ? compact : { type: "object", properties: {} };
+}
+function compactSchemaNode(node, maxDescriptionChars) {
+  if (Array.isArray(node)) {
+    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
+  }
+  if (!isRecord(node)) return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "description" && typeof value === "string") {
+      out[key] = compactDescription(value, maxDescriptionChars);
+    } else {
+      out[key] = compactSchemaNode(value, maxDescriptionChars);
+    }
+  }
+  return out;
+}
+function compactDescription(text, maxChars) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  if (maxChars <= 20) return normalized.slice(0, maxChars);
+  const hardLimit = maxChars - 12;
+  const boundary = findSemanticBoundary(normalized, hardLimit);
+  const head = normalized.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd();
+  return `${head} ...`;
+}
+function findSemanticBoundary(text, limit) {
+  const punctuation = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(": ", limit)
+  );
+  if (punctuation >= Math.floor(limit * 0.45)) return punctuation + 1;
+  const comma = text.lastIndexOf(", ", limit);
+  if (comma >= Math.floor(limit * 0.6)) return comma + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space >= Math.floor(limit * 0.6) ? space : limit;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var CAL_ALPHA = 0.3;
+var CALIBRATION_GLOBAL_KEY = "__global__";
+var _cals = /* @__PURE__ */ new Map();
+function calState(key) {
+  let state = _cals.get(key);
+  if (!state) {
+    state = { ratio: 1, count: 0, prevEst: 0 };
+    _cals.set(key, state);
+  }
+  return state;
+}
+var MIN_SAMPLES_FOR_CALIBRATION = 3;
+var MODEL_FAMILY_RATIO = {
+  // Anthropic: ~3.8-4.0 chars/token depending on model
+  claude: 3.8,
+  // OpenAI: ~4.0 chars/token
+  "gpt-4": 4,
+  "gpt-3.5": 4,
+  // Google: ~3.5 chars/token
+  gemini: 3.5,
+  // DeepSeek: ~3.5 chars/token
+  deepseek: 3.5
+};
+var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var _estimateCacheOrder = [];
+var ESTIMATE_CACHE_MAX_SIZE = 5e4;
+function estimateCacheKey(source) {
+  let h = 5381;
+  for (let i = 0; i < source.length; i++) {
+    h = (h << 5) + h + source.charCodeAt(i) | 0;
+  }
+  return `${source.length}:${h >>> 0}`;
+}
+function getCachedEstimate(source, compute) {
+  const key = estimateCacheKey(source);
+  const existing = ESTIMATE_CACHE.get(key);
+  if (existing !== void 0) return existing;
+  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
+    while (ESTIMATE_CACHE.size > Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) {
+      const oldest = _estimateCacheOrder.shift();
+      if (oldest !== void 0) ESTIMATE_CACHE.delete(oldest);
+    }
+  }
+  const estimate = compute(source);
+  ESTIMATE_CACHE.set(key, estimate);
+  _estimateCacheOrder.push(key);
+  return estimate;
+}
+function estimateToolInputTokens(input) {
+  if (typeof input === "string") return RoughTokenEstimate(input);
+  if (input === null || typeof input !== "object") {
+    return RoughTokenEstimate(String(input));
+  }
+  return getCachedEstimate(JSON.stringify(input), (key) => RoughTokenEstimate(key));
+}
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  return getCachedEstimate(JSON.stringify(content), (key) => RoughTokenEstimate(key));
+}
+function estimateTextTokens(text) {
+  return RoughTokenEstimate(text);
+}
+function computeMessageTokens(msg) {
+  if (typeof msg.content === "string") return estimateTextTokens(msg.content);
+  let total = 0;
+  for (const b of msg.content) {
+    if (b.type === "text") total += estimateTextTokens(b.text);
+    else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+    else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
+    else total += RoughTokenEstimate(JSON.stringify(b));
+  }
+  return total;
+}
+function estimateMessageTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m._estTokens === "number" && m._estTokens > 0) {
+      total += m._estTokens;
+      continue;
+    }
+    total += computeMessageTokens(m);
+  }
+  return total;
+}
+function realAnchoredInputTokens(messages, anchorTokens, anchorMsgCount) {
+  if (typeof anchorTokens !== "number" || anchorTokens <= 0) return null;
+  if (typeof anchorMsgCount !== "number" || anchorMsgCount < 0) return null;
+  if (messages.length < anchorMsgCount) return null;
+  const delta = anchorMsgCount === messages.length ? 0 : estimateMessageTokens(messages.slice(anchorMsgCount));
+  return anchorTokens + delta;
+}
+function estimateToolDefTokens(tool) {
+  const cached = tool._estDefTokens;
+  if (typeof cached === "number" && cached > 0) return cached;
+  const compact = compactToolDefinitionForWire(tool);
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
+}
+function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  let messagesTokens = 0;
+  if (typeof messages === "string") {
+    messagesTokens = RoughTokenEstimate(messages);
+  } else if (Array.isArray(messages)) {
+    for (const m of messages) {
+      if (typeof m === "object" && m !== null && "content" in m) {
+        const cached = m._estTokens;
+        if (typeof cached === "number" && cached > 0) {
+          messagesTokens += cached;
+          continue;
+        }
+        const content = m.content;
+        if (typeof content === "string") {
+          messagesTokens += RoughTokenEstimate(content);
+        } else if (Array.isArray(content)) {
+          for (const b of content) {
+            if (typeof b === "object" && b !== null) {
+              if (b.type === "text") {
+                messagesTokens += RoughTokenEstimate(b.text);
+              } else {
+                messagesTokens += RoughTokenEstimate(JSON.stringify(b));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let systemTokens = 0;
+  if (typeof systemPrompt === "string") {
+    systemTokens = RoughTokenEstimate(systemPrompt);
+  } else if (Array.isArray(systemPrompt)) {
+    for (const b of systemPrompt) {
+      if (typeof b === "object" && b !== null && b.type === "text") {
+        systemTokens += RoughTokenEstimate(b.text);
+      }
+    }
+  }
+  let toolsTokens = 0;
+  for (const t of tools) {
+    toolsTokens += estimateToolDefTokens(t);
+  }
+  const total = messagesTokens + systemTokens + toolsTokens;
+  calState(calibrationKey).prevEst = total;
+  return {
+    messages: messagesTokens,
+    systemPrompt: systemTokens,
+    tools: toolsTokens,
+    total
+  };
+}
+function recordActualUsage(actualInputTokens, estimatedInputTokens, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  if (actualInputTokens <= 0) return;
+  const cal = calState(calibrationKey);
+  const est = estimatedInputTokens ?? cal.prevEst;
+  if (est <= 0) return;
+  const sampleRatio = actualInputTokens / est;
+  if (cal.count === 0) {
+    cal.ratio = sampleRatio;
+  } else {
+    cal.ratio = CAL_ALPHA * sampleRatio + (1 - CAL_ALPHA) * cal.ratio;
+  }
+  cal.ratio = Math.min(1.5, Math.max(0.5, cal.ratio));
+  cal.count++;
+}
+function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const cal = calState(calibrationKey);
+  return {
+    ratio: cal.ratio,
+    count: cal.count,
+    calibrated: cal.count >= MIN_SAMPLES_FOR_CALIBRATION
+  };
+}
+function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const result = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
+  const cal = calState(calibrationKey);
+  if (cal.count >= MIN_SAMPLES_FOR_CALIBRATION) {
+    const safeRatio = Math.min(1.5, Math.max(0.5, cal.ratio));
+    return {
+      messages: Math.round(result.messages * safeRatio),
+      systemPrompt: Math.round(result.systemPrompt * safeRatio),
+      tools: Math.round(result.tools * safeRatio),
+      total: Math.round(result.total * safeRatio)
+    };
+  }
+  const fallbackRatio = getModelFamilyRatio(calibrationKey);
+  if (fallbackRatio !== null) {
+    return {
+      messages: Math.round(result.messages * fallbackRatio),
+      systemPrompt: Math.round(result.systemPrompt * fallbackRatio),
+      tools: Math.round(result.tools * fallbackRatio),
+      total: Math.round(result.total * fallbackRatio)
+    };
+  }
+  return result;
+}
+var DENSITY_SAMPLE_PER_BLOCK = 4096;
+var DENSITY_SAMPLE_TOTAL_CAP = 2e6;
+function textDensityMultiplier(messages) {
+  let sampled = 0;
+  let nonAscii = 0;
+  let maxRun = 0;
+  const consider = (s) => {
+    const n = Math.min(s.length, DENSITY_SAMPLE_PER_BLOCK);
+    let run = 0;
+    for (let i = 0; i < n; i++) {
+      const c = s.charCodeAt(i);
+      if (c > 127) nonAscii++;
+      if (c === 32 || c === 9 || c === 10 || c === 13) {
+        if (run > maxRun) maxRun = run;
+        run = 0;
+      } else {
+        run++;
+      }
+    }
+    if (run > maxRun) maxRun = run;
+    sampled += n;
+  };
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      consider(m.content);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") consider(b.text);
+        else if (b.type === "tool_result" && typeof b.content === "string") consider(b.content);
+        else if (b.type === "thinking") consider(b.thinking);
+      }
+    }
+    if (sampled >= DENSITY_SAMPLE_TOTAL_CAP) break;
+  }
+  if (sampled === 0) return 1;
+  const nonAsciiRatio = nonAscii / sampled;
+  let charsPerToken = 3.5 - 2 * nonAsciiRatio;
+  if (maxRun > 2e3 && nonAsciiRatio < 0.1) charsPerToken = Math.min(charsPerToken, 3);
+  const multiplier = 3.5 / Math.max(1.4, charsPerToken);
+  return Math.min(2.5, Math.max(1, multiplier));
+}
+function estimateRequestTokensUpperBound(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const base = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
+  const density = Array.isArray(messages) ? textDensityMultiplier(messages) : 1;
+  const cal = calState(calibrationKey);
+  const calCeiling = cal.count >= MIN_SAMPLES_FOR_CALIBRATION ? Math.min(1.5, Math.max(1, cal.ratio)) : 1;
+  const mult = Math.max(density, calCeiling);
+  if (mult <= 1) return base;
+  return {
+    messages: Math.ceil(base.messages * mult),
+    systemPrompt: Math.ceil(base.systemPrompt * mult),
+    tools: Math.ceil(base.tools * mult),
+    total: Math.ceil(base.total * mult)
+  };
+}
+function getModelFamilyRatio(calibrationKey) {
+  const lower = calibrationKey.toLowerCase();
+  for (const [family, ratio] of Object.entries(MODEL_FAMILY_RATIO)) {
+    if (lower.includes(family)) return ratio / 3.5;
+  }
+  return null;
+}
+function resetCalibration(calibrationKey) {
+  if (calibrationKey === void 0) {
+    _cals.clear();
+    return;
+  }
+  _cals.delete(calibrationKey);
+}
+
+export {
+  compactToolDefinitionForWire,
+  normalizeTopLevelToolSchema,
+  compactSchemaDescriptions,
+  estimateToolInputTokens,
+  estimateToolResultTokens,
+  estimateTextTokens,
+  computeMessageTokens,
+  estimateMessageTokens,
+  realAnchoredInputTokens,
+  estimateToolDefTokens,
+  estimateRequestTokens,
+  recordActualUsage,
+  getCalibrationState,
+  estimateRequestTokensCalibrated,
+  estimateRequestTokensUpperBound,
+  resetCalibration
+};
+//# sourceMappingURL=chunk-FSWCWSTS.js.map