@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-WQQON3SV.js

@@ -0,0 +1,473 @@
+import {
+  parseModelRef
+} from "./chunk-RJIZEJ42.js";
+
+// src/core/model-availability-calendar.ts
+function logicalCalendarTarget(providerId, model) {
+  if (providerId !== "omniroute") return { providerId, model };
+  const slash = model.indexOf("/");
+  return slash > 0 && slash < model.length - 1 ? { providerId: model.slice(0, slash), model: model.slice(slash + 1) } : { providerId, model };
+}
+var WEEKDAYS = {
+  Sun: 0,
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6
+};
+function minuteOfDay(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) return void 0;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour > 23 || minute > 59) return void 0;
+  return hour * 60 + minute;
+}
+function clockAt(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(date);
+    const weekday = parts.find((part) => part.type === "weekday")?.value;
+    const hour = Number(parts.find((part) => part.type === "hour")?.value);
+    const minute = Number(parts.find((part) => part.type === "minute")?.value);
+    if (!weekday || WEEKDAYS[weekday] === void 0 || !Number.isFinite(hour + minute))
+      return void 0;
+    return { day: WEEKDAYS[weekday], minute: hour * 60 + minute };
+  } catch {
+    return void 0;
+  }
+}
+function targetMatches(rule, providerId, model) {
+  if (rule.provider && rule.provider !== providerId) return false;
+  if (rule.model && rule.model !== model) return false;
+  return Boolean(rule.provider || rule.model);
+}
+function timeMatches(rule, day, minute) {
+  const start = minuteOfDay(rule.start);
+  const end = minuteOfDay(rule.end);
+  if (start === void 0 || end === void 0) return false;
+  const days = rule.days?.length ? new Set(rule.days) : void 0;
+  if (start === end) return !days || days.has(day);
+  if (start < end) return (!days || days.has(day)) && minute >= start && minute < end;
+  if (minute >= start) return !days || days.has(day);
+  const previousDay = (day + 6) % 7;
+  return minute < end && (!days || days.has(previousDay));
+}
+function evaluateModelCalendar(rules, providerId, model, at = /* @__PURE__ */ new Date()) {
+  ({ providerId, model } = logicalCalendarTarget(providerId, model));
+  const allowRules = [];
+  let allowMatched = false;
+  for (const rule of rules ?? []) {
+    if (rule.enabled === false || !targetMatches(rule, providerId, model)) continue;
+    const clock = clockAt(at, rule.timezone);
+    if (!clock || minuteOfDay(rule.start) === void 0 || minuteOfDay(rule.end) === void 0)
+      continue;
+    if (rule.mode === "allow_only") {
+      allowRules.push(rule);
+      if (timeMatches(rule, clock.day, clock.minute)) allowMatched = true;
+    } else if (timeMatches(rule, clock.day, clock.minute)) {
+      return { allowed: false, rule };
+    }
+  }
+  if (allowRules.length > 0 && !allowMatched) return { allowed: false, rule: allowRules[0] };
+  return { allowed: true };
+}
+
+// src/core/fallback-profile-manager.ts
+function hasText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function asRefList(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function asProfileName(value) {
+  return hasText(value) ? value : void 0;
+}
+function providerHasKey(entry) {
+  if (!entry) return false;
+  if (hasText(entry.apiKey)) return true;
+  if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => hasText(k?.apiKey))) return true;
+  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => hasText(process.env[v])))
+    return true;
+  return false;
+}
+function visibleProviderModels(config, providerId, providerModels) {
+  const entry = config.providers?.[providerId];
+  return Array.isArray(entry?.models) ? [...entry.models] : providerModels;
+}
+function buildProfiles(config) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [name, chain] of Object.entries(config.fallbackProfiles ?? {})) {
+    if (Array.isArray(chain) && chain.length > 0) {
+      entries.set(name, Object.freeze([...chain]));
+    }
+  }
+  return entries;
+}
+var FallbackProfileManager = class {
+  /** Immutable snapshot of config.fallbackProfiles for the active config. */
+  profiles;
+  /** Active frozen config snapshot for provider lookups. */
+  config;
+  /** Optional shared runtime status tracker. */
+  statusTracker;
+  constructor(config, opts) {
+    this.config = config;
+    this.profiles = buildProfiles(config);
+    this.statusTracker = opts?.statusTracker;
+  }
+  /**
+   * Bind (or replace) the shared runtime status tracker.
+   * Called by the boot path after the tracker is created.
+   */
+  setStatusTracker(tracker) {
+    this.statusTracker = tracker;
+  }
+  // ── Profile existence ──────────────────────────────────────────────────
+  hasProfile(name) {
+    return this.profiles.has(name);
+  }
+  listProfiles() {
+    return Object.freeze([...this.profiles.keys()]);
+  }
+  /**
+   * The profile the session has selected (`config.fallbackProfile`, set by
+   * `/fallback profile use <name>`), or undefined when none is selected or the
+   * name no longer resolves to a defined profile.
+   *
+   * Consulted by every resolution entry point when the caller does not name a
+   * profile itself. Without this the leader — which passes no profile — could
+   * never use a named profile at all: `config.fallbackProfiles` was reachable
+   * only by copying a chain into `fallbackModels`.
+   */
+  activeProfileName() {
+    const name = asProfileName(this.config.fallbackProfile);
+    return name && this.profiles.has(name) ? name : void 0;
+  }
+  // ── Resolution ─────────────────────────────────────────────────────────
+  /**
+   * Resolve a named fallback profile to a validated, provider-filtered chain.
+   *
+   * Returns an empty chain when the profile doesn't exist, or when every entry
+   * is excluded, quarantined, or blacked out.
+   *
+   * Filtering is intentionally identical to {@link resolveRefs} (the explicit
+   * `fallbackModels` path): the self-exclusion, the runtime status tracker,
+   * and the availability calendar — nothing else. Anything a named profile
+   * drops, an explicit chain drops too, and vice versa. Profiles used to apply
+   * two extra filters (provider "usability" and the `providers[].models`
+   * snapshot) that the explicit path did not, which silently rerouted roles
+   * pinned to a profile onto a different model than the one configured.
+   *
+   * @param name - Profile name from config.fallbackProfiles.
+   * @param defaultProvider - Used when an entry has no explicit provider.
+   * @param exclude - Optional { providerId, model } to skip (avoid self-fallback).
+   */
+  resolve(name, opts = {}) {
+    const defaultProvider = opts.defaultProvider ?? this.config.provider;
+    const chain = this.profiles.get(name);
+    if (!chain) return FREEZER_EMPTY;
+    const excludeKey = opts.exclude ? `${opts.exclude.providerId}/${opts.exclude.model}` : void 0;
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of chain) {
+      const parsed = parseModelRef(ref);
+      if (!parsed.model) continue;
+      const providerId = parsed.provider ?? defaultProvider;
+      const key = `${providerId}/${parsed.model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (excludeKey && key === excludeKey) continue;
+      if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
+      if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
+        continue;
+      resolved.push({
+        providerId,
+        model: parsed.model,
+        providerSwitched: providerId !== (opts.exclude?.providerId ?? this.config.provider)
+      });
+    }
+    return Object.freeze(resolved);
+  }
+  /**
+   * Resolve the effective fallback chain for a session: explicit fallbackModels
+   * first, then named profile, then smart default (unless disabled).
+   *
+   * Mirrors the previous `effectiveFallbackChain()` logic but centralized.
+   */
+  resolveEffective(opts = {}) {
+    const bridge = this.resolveBridge(opts.exclude);
+    let selected = FREEZER_EMPTY;
+    const explicitRefs = asRefList(opts.fallbackModels);
+    const profileName = asProfileName(opts.fallbackProfile) ?? this.activeProfileName();
+    if (explicitRefs && explicitRefs.length > 0) {
+      const resolved = this.resolveRefs(explicitRefs, opts.exclude);
+      if (resolved.length > 0) selected = resolved;
+    }
+    if (selected.length === 0 && profileName) {
+      const resolved = this.resolve(profileName, { exclude: opts.exclude });
+      if (resolved.length > 0) selected = resolved;
+    }
+    if (selected.length === 0 && opts.fallbackAuto !== false) {
+      selected = this.smartDefault(opts.exclude);
+    }
+    if (bridge.length === 0) return selected;
+    if (selected.length === 0) return bridge;
+    const seen = new Set(bridge.map((entry) => `${entry.providerId}/${entry.model}`));
+    return Object.freeze([
+      ...bridge,
+      ...selected.filter((entry) => !seen.has(`${entry.providerId}/${entry.model}`))
+    ]);
+  }
+  /** Resolve the optional, fully-qualified emergency continuity route. */
+  resolveBridge(exclude) {
+    const ref = this.config.fallbackBridge?.trim();
+    if (!ref) return FREEZER_EMPTY;
+    const parsed = parseModelRef(ref);
+    if (!parsed.provider || !parsed.model) return FREEZER_EMPTY;
+    return this.resolveRefs([ref], exclude);
+  }
+  /**
+   * Resolve every usable configured target as a bounded last-resort chain.
+   * Normal smart defaults stay bounded; callers append this only after the
+   * preferred chain and only when automatic fallback is enabled. The cap
+   * ({@link MAX_LAST_RESORT_CANDIDATES}) prevents a config with many providers
+   * from producing a degenerate chain of doomed requests during a systemic
+   * outage — by this point the smart default, bridge, and default profile
+   * have already failed.
+   */
+  resolveAllConfigured(exclude) {
+    return this.smartDefault(exclude, this.lastResortCap());
+  }
+  /**
+   * Effective cap for the last-resort append. Reads the user-configurable
+   * {@link Config.fallbackMaxLastResortCandidates} when set and valid;
+   * otherwise falls back to the compiled-in default
+   * {@link MAX_LAST_RESORT_CANDIDATES}.
+   */
+  lastResortCap() {
+    const configured = this.config.fallbackMaxLastResortCandidates;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 0) {
+      return Math.floor(configured);
+    }
+    return MAX_LAST_RESORT_CANDIDATES;
+  }
+  /**
+   * Build the complete fallback candidate chain shared by the agent-loop
+   * extension and the one-shot orchestrator. Centralizes the bridge → primary →
+   * selected → default-profile → all-configured ladder and the fromExplicitSource
+   * gate so both consumers produce identical ordering and depth semantics.
+   *
+   * Layering (each step deduped against all prior):
+   *  1. Bridge (emergency continuity route).
+   *  2. Configured primary, when the live context drifted from it.
+   *  3. The selected chain (explicit refs → named profile → smart default),
+   *     via {@link resolveEffective}.
+   *  4. The "default" profile — extra depth, ONLY when the chain was auto-derived.
+   *  5. Every other configured provider — last resort, ONLY when the chain was
+   *     auto-derived AND `effectiveFallbackAuto` is true.
+   *
+   * Returns the empty chain when `closedWorld` is true and no explicit
+   * refs/profile resolved — a model allowlist never leaks to unlisted models.
+   *
+   * @internal caller-aware options (primary, closedWorld) are accepted because
+   *   the agent loop has context the manager does not own; the resolution
+   *   pipeline itself is identical for both callers.
+   */
+  resolveCandidates(current, opts = {}) {
+    const configuredPrimary = opts.primary ?? {
+      providerId: this.config.provider,
+      model: this.config.model
+    };
+    const configFallbackAuto = this.config.fallbackAuto;
+    const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
+    const explicitRefs = asRefList(opts.fallbackModels) ?? asRefList(this.config.fallbackModels);
+    const profileName = asProfileName(opts.fallbackProfile) ?? this.activeProfileName();
+    const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && this.resolveRefs(explicitRefs, current).length > 0;
+    const profileUsable = profileName !== void 0 && this.hasProfile(profileName) && this.resolve(profileName, { exclude: current }).length > 0;
+    const fromExplicitSource = explicitUsable || profileUsable;
+    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : profileName ? this.resolve(profileName, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
+      fallbackModels: explicitRefs,
+      fallbackProfile: profileName,
+      fallbackAuto: effectiveFallbackAuto,
+      exclude: current
+    });
+    const candidates = [];
+    if (opts.closedWorld) {
+      candidates.push(...selectedChain);
+    } else {
+      candidates.push(...this.resolveBridge(current));
+      if (!(configuredPrimary.providerId === current.providerId && configuredPrimary.model === current.model)) {
+        candidates.push({
+          providerId: configuredPrimary.providerId,
+          model: configuredPrimary.model,
+          providerSwitched: configuredPrimary.providerId !== current.providerId
+        });
+      }
+      candidates.push(...selectedChain);
+      if (!fromExplicitSource && effectiveFallbackAuto && profileName !== "default") {
+        candidates.push(...this.resolve("default", { exclude: current }));
+      }
+      if (!fromExplicitSource && effectiveFallbackAuto) {
+        const cap = this.lastResortCap();
+        if (cap > 0) {
+          const usedKeys = new Set(
+            candidates.map((c) => `${c.providerId}/${c.model}`)
+          );
+          const lastResort = this.smartDefault(current, Number.POSITIVE_INFINITY).filter((c) => !usedKeys.has(`${c.providerId}/${c.model}`)).slice(0, cap);
+          candidates.push(...lastResort);
+        }
+      }
+    }
+    return dedupeChain(candidates, current);
+  }
+  // ── Provider availability (read-only) ──────────────────────────────────
+  checkProvider(providerId) {
+    const entry = this.config.providers?.[providerId];
+    const isPrimary = providerId === this.config.provider;
+    const hasKey = providerHasKey(entry) || isPrimary && hasText(this.config.apiKey);
+    const hasEndpoint = hasText(entry?.baseUrl) || isPrimary && hasText(this.config.baseUrl);
+    const hasModels = Array.isArray(entry?.models) && entry.models.length > 0 || isPrimary && hasText(this.config.model);
+    return Object.freeze({
+      providerId,
+      hasKey,
+      hasEndpoint,
+      hasModels,
+      usable: hasKey || hasEndpoint
+    });
+  }
+  // ── Rebuild on config change ───────────────────────────────────────────
+  /**
+   * Atomically replace the active immutable snapshot while preserving this
+   * service identity for every injected consumer.
+   */
+  reload(newConfig) {
+    this.config = newConfig;
+    this.profiles = buildProfiles(newConfig);
+  }
+  // ── Internal helpers ───────────────────────────────────────────────────
+  /**
+   * Resolve an array of model ref strings (from explicit fallbackModels config).
+   * Public so consumers like one-shot-llm can use it directly.
+   */
+  resolveRefs(refs, exclude) {
+    const excludeKey = exclude ? `${exclude.providerId}/${exclude.model}` : void 0;
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      const parsed = parseModelRef(ref);
+      if (!parsed.model) continue;
+      const providerId = parsed.provider ?? this.config.provider;
+      const key = `${providerId}/${parsed.model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (excludeKey && key === excludeKey) continue;
+      if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
+      if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
+        continue;
+      resolved.push({
+        providerId,
+        model: parsed.model,
+        providerSwitched: providerId !== (exclude?.providerId ?? this.config.provider)
+      });
+    }
+    return Object.freeze(resolved);
+  }
+  /**
+   * Derive a smart default chain from configured providers when nothing
+   * explicit is set. Same-provider alternatives first, then cross-provider.
+   * Limited to 4 entries to avoid burning through models on a transient blip.
+   */
+  smartDefault(exclude, maxCandidates = 4) {
+    const leaderProvider = this.config.provider;
+    const leaderModel = this.config.model;
+    const providers = this.config.providers ?? {};
+    const favoriteSet = new Set(
+      (asRefList(this.config.favoriteModels) ?? []).map((ref) => {
+        const p = parseModelRef(ref);
+        return `${p.provider ?? leaderProvider}/${p.model}`;
+      })
+    );
+    const hasFavorites = favoriteSet.size > 0;
+    const favoritesOnly = this.config.favoriteModelsOnly === true;
+    const seen = /* @__PURE__ */ new Set();
+    const favorites = [];
+    const sameProvider = [];
+    const crossProvider = [];
+    const excludeKey = exclude ? `${exclude.providerId}/${exclude.model}` : void 0;
+    const ids = Object.keys(providers).sort(
+      (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
+    );
+    for (const id of ids) {
+      const entry = providers[id];
+      if (!this.checkProvider(id).usable) continue;
+      const models = visibleProviderModels(this.config, id, entry?.models ?? []);
+      for (const model of models) {
+        if (id === leaderProvider && model === leaderModel) continue;
+        const ref = `${id}/${model}`;
+        if (seen.has(ref)) continue;
+        seen.add(ref);
+        if (excludeKey && ref === excludeKey) continue;
+        if (this.statusTracker && !this.statusTracker.isAvailable(id, model)) continue;
+        if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, id, model).allowed)
+          continue;
+        if (favoriteSet.has(ref)) {
+          favorites.push(ref);
+          continue;
+        }
+        if (favoritesOnly && hasFavorites) continue;
+        (id === leaderProvider ? sameProvider : crossProvider).push(ref);
+      }
+    }
+    const ordered = [...favorites, ...sameProvider, ...crossProvider];
+    const all = Number.isFinite(maxCandidates) ? ordered.slice(0, Math.max(0, maxCandidates)) : [...ordered];
+    const firstCrossProvider = ordered.find((ref) => {
+      const parsed = parseModelRef(ref);
+      return (parsed.provider ?? leaderProvider) !== leaderProvider;
+    });
+    if (all.length > 0 && firstCrossProvider && !all.some((ref) => {
+      const parsed = parseModelRef(ref);
+      return (parsed.provider ?? leaderProvider) !== leaderProvider;
+    })) {
+      all[all.length - 1] = firstCrossProvider;
+    }
+    return Object.freeze(
+      all.map((ref) => {
+        const p = parseModelRef(ref);
+        return {
+          providerId: p.provider ?? leaderProvider,
+          model: p.model,
+          providerSwitched: (p.provider ?? leaderProvider) !== (exclude?.providerId ?? leaderProvider)
+        };
+      })
+    );
+  }
+};
+var MAX_LAST_RESORT_CANDIDATES = 12;
+var FREEZER_EMPTY = Object.freeze([]);
+function dedupeChain(entries, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const currentKey = `${current.providerId}/${current.model}`;
+  return Object.freeze(
+    entries.filter((entry) => {
+      const key = `${entry.providerId}/${entry.model}`;
+      if (key === currentKey || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
+  );
+}
+
+export {
+  logicalCalendarTarget,
+  evaluateModelCalendar,
+  FallbackProfileManager
+};
+//# sourceMappingURL=chunk-WQQON3SV.js.map

package/dist/chunk-WQTOVMGV.js

@@ -0,0 +1,119 @@
+// src/utils/tool-description-mode.ts
+var DEFAULT_TOOL_DESCRIPTION_MODE = "extend";
+var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
+function normalizeToolDescriptionMode(value) {
+  if (typeof value !== "string") return void 0;
+  const raw = value.trim().toLowerCase();
+  if (raw === "extend" || raw === "extended" || raw === "full") return "extend";
+  if (raw === "simple" || raw === "short" || raw === "brief") return "simple";
+  return void 0;
+}
+function resolveToolDescriptionMode(modes, toolName) {
+  return normalizeToolDescriptionMode(modes?.[toolName]) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
+}
+function simplifyToolDescription(text, opts = {}) {
+  const maxSentences = Math.max(1, opts.maxSentences ?? 2);
+  const maxChars = Math.max(40, opts.maxChars ?? 180);
+  const normalized = text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  const sentences = normalized.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [normalized];
+  const selected = [];
+  for (const sentence of sentences) {
+    selected.push(sentence.trim());
+    const candidate = selected.join(" ");
+    if (selected.length >= maxSentences || candidate.length >= maxChars) break;
+  }
+  const summary = selected.join(" ").trim() || normalized;
+  if (summary.length <= maxChars) return summary;
+  const hardLimit = maxChars - 4;
+  const boundary = findWordBoundary(summary, hardLimit);
+  return `${summary.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd()} ...`;
+}
+function applyToolDescriptionModeToTool(tool, mode) {
+  const existingOriginal = getOriginalDescription(tool);
+  if (mode === "extend" && !existingOriginal) return tool;
+  const original = existingOriginal ?? {
+    description: tool.description,
+    usageHint: tool.usageHint
+  };
+  const next = mode === "simple" ? withDescription(tool, {
+    description: simplifyToolDescription(original.description),
+    usageHint: original.usageHint === void 0 ? void 0 : simplifyToolDescription(original.usageHint)
+  }) : withDescription(tool, original);
+  return attachOriginalDescription(next, original);
+}
+function setToolDescriptionMode(registry, name, mode) {
+  if (typeof registry.setDescriptionMode === "function") {
+    return registry.setDescriptionMode(name, mode);
+  }
+  if (!registry.get(name) || typeof registry.wrap !== "function") return false;
+  registry.wrap(
+    name,
+    (tool) => applyToolDescriptionModeToTool(tool, mode),
+    "tool-description-mode"
+  );
+  return true;
+}
+function getToolDescriptionMode(registry, name) {
+  return registry.getDescriptionMode?.(name) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
+}
+function applyToolDescriptionModes(registry, modes) {
+  if (typeof registry.applyDescriptionModes === "function") {
+    return registry.applyDescriptionModes(modes);
+  }
+  const entries = Object.entries(modes ?? {});
+  const missing = [];
+  let applied = 0;
+  for (const [name, rawMode] of entries) {
+    const mode = normalizeToolDescriptionMode(rawMode);
+    if (!mode) continue;
+    if (setToolDescriptionMode(registry, name, mode)) applied++;
+    else missing.push(name);
+  }
+  return { applied, missing };
+}
+function getOriginalDescription(tool) {
+  return tool[ORIGINAL_TOOL_DESCRIPTION];
+}
+function attachOriginalDescription(tool, original) {
+  Object.defineProperty(tool, ORIGINAL_TOOL_DESCRIPTION, {
+    configurable: true,
+    enumerable: false,
+    value: original,
+    writable: true
+  });
+  return tool;
+}
+function withDescription(tool, next) {
+  const copy = {
+    ...tool,
+    description: next.description,
+    usageHint: next.usageHint
+  };
+  if (next.usageHint === void 0) {
+    delete copy.usageHint;
+  }
+  return copy;
+}
+function findWordBoundary(text, limit) {
+  const semantic = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(", ", limit)
+  );
+  if (semantic > 40) return semantic + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space > 40 ? space : limit;
+}
+
+export {
+  DEFAULT_TOOL_DESCRIPTION_MODE,
+  normalizeToolDescriptionMode,
+  resolveToolDescriptionMode,
+  simplifyToolDescription,
+  applyToolDescriptionModeToTool,
+  setToolDescriptionMode,
+  getToolDescriptionMode,
+  applyToolDescriptionModes
+};
+//# sourceMappingURL=chunk-WQTOVMGV.js.map