@ashx-j/lunr 0.2.21 → 0.2.23

package/dist/node-runtime/chunk-IMLCWLPI.js

@@ -0,0 +1,9 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/runtime-scope.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var runtimeScope = new AsyncLocalStorage();
+
+export {
+  runtimeScope
+};

package/dist/node-runtime/chunk-KKUTQQV7.js

@@ -0,0 +1,144 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getShellConfig,
+  killProcessTree
+} from "./chunk-CSFI6YXL.js";
+
+// packages/coding-agent/dist/core/process-registry.js
+import { spawn } from "node:child_process";
+var isWin32 = process.platform === "win32", EXIT_NOISE_GATE_MS = 3e3, EXIT_TTL_MS = 300 * 1e3, MAX_TRACKED = 100, processes = /* @__PURE__ */ new Map();
+function register(pid, command, cwd, sessionId) {
+  if (pid) {
+    if (processes.size >= MAX_TRACKED) {
+      let oldest;
+      for (let [p, entry] of processes) {
+        if (entry.status === "exited") {
+          oldest = { pid: p, entry };
+          break;
+        }
+        (!oldest || entry.startedAt < oldest.entry.startedAt) && (oldest = { pid: p, entry });
+      }
+      oldest && processes.delete(oldest.pid);
+    }
+    processes.set(pid, { pid, command, cwd, startedAt: Date.now(), status: "running", sessionId });
+  }
+}
+function unregister(pid) {
+  pid && processes.delete(pid);
+}
+function markExited(pid, exitCode) {
+  if (!pid)
+    return;
+  let entry = processes.get(pid);
+  if (!entry)
+    return;
+  if (Date.now() - entry.startedAt < EXIT_NOISE_GATE_MS) {
+    processes.delete(pid);
+    return;
+  }
+  entry.status = "exited", entry.exitCode = exitCode ?? void 0, entry.exitedAt = Date.now();
+}
+function list(sessionId) {
+  return prune(), [...processes.values()].filter((p) => sessionId === void 0 || p.sessionId === sessionId);
+}
+function prune() {
+  for (let [pid, entry] of processes) {
+    if (entry.status === "exited") {
+      (!entry.exitedAt || Date.now() - entry.exitedAt > EXIT_TTL_MS) && processes.delete(pid);
+      continue;
+    }
+    isAlive(pid) || markExited(pid, null);
+  }
+}
+function isAlive(pid) {
+  try {
+    return process.kill(pid, 0), !0;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function kill(pid) {
+  processes.has(pid) && (killProcessTree(pid), isAlive(pid) || markExited(pid, null));
+}
+function killAll(sessionId) {
+  for (let [pid, entry] of processes)
+    if (!(sessionId !== void 0 && entry.sessionId !== sessionId)) {
+      try {
+        killProcessTree(pid);
+      } catch {
+      }
+      isAlive(pid) || markExited(pid, null);
+    }
+}
+function pause(pid) {
+  if (isWin32)
+    throw new Error("Pause/resume is unsupported on Windows.");
+  if (!processes.has(pid))
+    throw new Error(`Process ${pid} is not tracked.`);
+  try {
+    process.kill(pid, "SIGSTOP");
+    let entry = processes.get(pid);
+    entry && (entry.status = "paused");
+  } catch {
+    processes.delete(pid);
+  }
+}
+function resume(pid) {
+  if (isWin32)
+    throw new Error("Pause/resume is unsupported on Windows.");
+  if (!processes.has(pid))
+    throw new Error(`Process ${pid} is not tracked.`);
+  try {
+    process.kill(pid, "SIGCONT");
+    let entry = processes.get(pid);
+    entry && (entry.status = "running");
+  } catch {
+    processes.delete(pid);
+  }
+}
+function restart(pid) {
+  let entry = processes.get(pid);
+  if (entry) {
+    try {
+      killProcessTree(pid);
+    } catch {
+    }
+    processes.delete(pid);
+    try {
+      let shellConfig = getShellConfig(), child = spawn(shellConfig.shell, [...shellConfig.args, entry.command], {
+        cwd: entry.cwd,
+        detached: !0,
+        stdio: "ignore",
+        windowsHide: !0
+      });
+      if (child.pid)
+        return register(child.pid, entry.command, entry.cwd, entry.sessionId), child.unref(), child.pid;
+    } catch {
+    }
+  }
+}
+function isWindows() {
+  return isWin32;
+}
+function clearRegistry(sessionId) {
+  if (sessionId === void 0) {
+    processes.clear();
+    return;
+  }
+  for (let [pid, entry] of processes)
+    entry.sessionId === sessionId && processes.delete(pid);
+}
+
+export {
+  register,
+  unregister,
+  markExited,
+  list,
+  kill,
+  killAll,
+  pause,
+  resume,
+  restart,
+  isWindows,
+  clearRegistry
+};

package/dist/node-runtime/chunk-LFZDVKSP.js

@@ -0,0 +1,521 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  FORWARDED_COMMANDS,
+  MOBILE_COMMANDS
+} from "./chunk-EKVFP6YF.js";
+import {
+  conversationBinding,
+  createPicker
+} from "./chunk-DD5YWFSJ.js";
+import {
+  computeContextBreakdown
+} from "./chunk-TQGPP4SC.js";
+import {
+  findExactModelReferenceMatch
+} from "./chunk-OFKSVRV7.js";
+import {
+  SessionManager
+} from "./chunk-XLTL257W.js";
+import {
+  runtimeScope
+} from "./chunk-IMLCWLPI.js";
+
+// packages/coding-agent/dist/gateway/commands.js
+var MODEL_CACHE_TTL_MS = 300 * 1e3, SESSIONS_CACHE_TTL_MS = 300 * 1e3, MAX_MODEL_LIST_LINES = 15, PROVIDER_PER_PAGE = 10;
+var MAX_MODELS_PER_PROVIDER = 50, MODEL_ID_MAX = 38, MODEL_CACHE_CAP = 100, SESSIONS_CACHE_CAP = 100, modelCache = /* @__PURE__ */ new Map(), sessionsCache = /* @__PURE__ */ new Map();
+function evictLRU(map, cap) {
+  for (; map.size > cap; ) {
+    let first = map.keys().next().value;
+    first !== void 0 && map.delete(first);
+  }
+}
+function getCachedModels(key) {
+  let cached = modelCache.get(key);
+  if (cached) {
+    if (Date.now() > cached.expires) {
+      modelCache.delete(key);
+      return;
+    }
+    return modelCache.delete(key), modelCache.set(key, cached), cached.models;
+  }
+}
+function setCachedModels(key, models) {
+  modelCache.set(key, { models, expires: Date.now() + MODEL_CACHE_TTL_MS }), evictLRU(modelCache, MODEL_CACHE_CAP);
+}
+function getCachedSessions(key) {
+  let cached = sessionsCache.get(key);
+  if (cached) {
+    if (Date.now() > cached.expires) {
+      sessionsCache.delete(key);
+      return;
+    }
+    return sessionsCache.delete(key), sessionsCache.set(key, cached), cached.sessions;
+  }
+}
+function setCachedSessions(key, sessions) {
+  sessionsCache.set(key, { sessions, expires: Date.now() + SESSIONS_CACHE_TTL_MS }), evictLRU(sessionsCache, SESSIONS_CACHE_CAP);
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function prefixLines(text, prefix) {
+  return text.split(`
+`).map((line, index) => (index === 0 ? prefix : "  ") + line).join(`
+`);
+}
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+}
+function formatRelativeTime(date) {
+  let seconds = Math.max(0, Math.floor((Date.now() - date.getTime()) / 1e3));
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  let minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  let hours = Math.floor(minutes / 60);
+  return hours < 24 ? `${hours}h ago` : `${Math.floor(hours / 24)}d ago`;
+}
+function formatModelList(models, maxLines = MAX_MODEL_LIST_LINES) {
+  if (models.length === 0)
+    return ["No models available."];
+  let byProvider = /* @__PURE__ */ new Map();
+  for (let model of models) {
+    let list = byProvider.get(model.provider) ?? [];
+    list.push(model), byProvider.set(model.provider, list);
+  }
+  let providers = [...byProvider.keys()].sort(), lines = [], index = 1;
+  for (let provider of providers) {
+    let list = (byProvider.get(provider) ?? []).sort((a, b) => a.id.localeCompare(b.id));
+    for (let model of list)
+      lines.push(`${index}) ${provider}/${model.id}`), index++;
+  }
+  return lines.length <= maxLines ? lines : [
+    `${models.length} models across ${providers.length} providers.`,
+    "Use /model <provider/id> or /model <query>.",
+    ...providers.map((p) => `- ${p}`)
+  ];
+}
+function groupModelsByProvider(models) {
+  let byProvider = /* @__PURE__ */ new Map();
+  for (let model of models) {
+    let list = byProvider.get(model.provider) ?? [];
+    list.push(model), byProvider.set(model.provider, list);
+  }
+  for (let list of byProvider.values())
+    list.sort((a, b) => a.id.localeCompare(b.id));
+  return byProvider;
+}
+function truncateModelId(id) {
+  let lastSlash = id.lastIndexOf("/"), name = lastSlash >= 0 ? id.slice(lastSlash + 1) : id;
+  return truncate(name, MODEL_ID_MAX);
+}
+async function refreshAndCacheModels(session, key) {
+  let runtime = session.modelRuntime;
+  await runtime.refresh();
+  let models = [...await runtime.getAvailable()].sort((a, b) => a.provider.localeCompare(b.provider) || a.id.localeCompare(b.id));
+  return setCachedModels(key, models), models;
+}
+async function setModelAndReply(ctx, model) {
+  let session = ctx.session;
+  try {
+    await session.setModel(model);
+  } catch (error) {
+    if ((error instanceof Error ? error.message : String(error)).includes("No API key")) {
+      await ctx.reply(`No API key for ${model.provider}.`);
+      return;
+    }
+    throw error;
+  }
+  await ctx.reply(`Model \u2192 ${model.provider}/${model.id} (thinking level re-clamped to ${session.thinkingLevel})`);
+}
+var newCommand = {
+  name: "new",
+  aliases: ["reset"],
+  description: "start a fresh session for this chat",
+  // lunr: busy-session /new must bypass the guard (same as /stop).
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    await ctx.bridge.reset(ctx.key), await ctx.reply("Session reset \u2014 next message starts a fresh session.");
+  }
+}, undoCommand = {
+  name: "undo",
+  description: "rewind the session tree before the last user turn",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let { userText } = await ctx.bridge.undo(ctx.key), text = userText ? ` "${truncate(userText, 60)}"` : "";
+    await ctx.reply(`Undone \u2014 rewound before${text}. /redo to restore.`);
+  }
+}, redoCommand = {
+  name: "redo",
+  description: "restore the last undone turn",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    await ctx.bridge.redo(ctx.key), await ctx.reply("Redone.");
+  }
+}, stopCommand = {
+  name: "stop",
+  description: "abort the running turn",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    await ctx.bridge.abort(ctx.key), await ctx.reply("Stopped.");
+  }
+}, statusCommand = {
+  name: "status",
+  description: "session status",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    let status = ctx.bridge.getStatus(ctx.key), age = status.createdAt ? `${Math.max(0, Math.round((Date.now() - Date.parse(status.createdAt)) / 1e3))}s` : "no session yet";
+    await ctx.reply(`${ctx.event.source.platform} \xB7 session age ${age} \xB7 ${status.busy ? "busy" : "idle"} \xB7 queue ${status.queueDepth}
+Project: ${conversationBinding(ctx.key)?.cwd ?? "not selected"}`);
+  }
+}, whoamiCommand = {
+  name: "whoami",
+  description: "your ids and session key",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    let { userId, chatId } = ctx.event.source;
+    await ctx.reply(`userId: ${userId}
+chatId: ${chatId}
+key: ${ctx.key}`);
+  }
+}, helpCommand = {
+  name: "help",
+  description: "this message",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    await ctx.reply(formatHelpText());
+  }
+}, modelCommand = {
+  name: "model",
+  description: "list or switch models",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, arg = ctx.args.trim();
+    if (!arg) {
+      let models2 = getCachedModels(ctx.key) ?? await refreshAndCacheModels(session, ctx.key), byProvider = groupModelsByProvider(models2), current = session.model, currentRef = current ? `${current.provider}/${current.id}` : "", providerItems = [...byProvider.keys()].sort().map((provider) => ({
+        label: `${current?.provider === provider ? "\u2713 " : ""}${provider} (${byProvider.get(provider)?.length ?? 0})`,
+        value: provider
+      })), pickerOpts = {
+        replyTo: ctx.event.messageId,
+        threadId: ctx.event.source.threadId
+      };
+      if (!(await createPicker(ctx.adapter, ctx.event.source, {
+        kind: "model",
+        sessionKey: ctx.key,
+        invokerId: ctx.event.source.userId,
+        items: providerItems,
+        perPage: PROVIDER_PER_PAGE,
+        title: "Pick a model provider",
+        async resolve(item) {
+          if (item.value === "__back__")
+            return { done: !1, items: providerItems, title: "Pick a model provider" };
+          if (!item.value.includes("/")) {
+            let provider = item.value, list = byProvider.get(provider) ?? [], capped = list.slice(0, MAX_MODELS_PER_PROVIDER), note = list.length > MAX_MODELS_PER_PROVIDER ? ` \u2014 ${list.length - MAX_MODELS_PER_PROVIDER} more available` : "", modelItems = [];
+            for (let m of capped) {
+              let ref = `${provider}/${m.id}`;
+              modelItems.push({
+                label: `${currentRef === ref ? "\u2713 " : ""}${truncateModelId(m.id)}`,
+                value: ref
+              });
+            }
+            return modelItems.unshift({ label: "\u25C0 Back", value: "__back__" }), {
+              done: !1,
+              items: modelItems,
+              title: `${provider} (${list.length})${note}`,
+              breadcrumbs: provider
+            };
+          }
+          let exact2 = findExactModelReferenceMatch(item.value, models2);
+          if (!exact2)
+            return { done: !0, text: "That model is no longer available." };
+          try {
+            await session.setModel(exact2);
+          } catch (error) {
+            if ((error instanceof Error ? error.message : String(error)).includes("No API key"))
+              return { done: !0, text: `No API key for ${exact2.provider}.` };
+            throw error;
+          }
+          return {
+            done: !0,
+            text: `\u263E Model \u2192 ${exact2.provider}/${exact2.id} (thinking level re-clamped to ${session.thinkingLevel})`
+          };
+        }
+      }, pickerOpts)).success) {
+        let currentText = `${current?.provider ?? "none"}/${current?.id ?? "none"}`, lines = formatModelList(models2);
+        await ctx.reply([`Current: ${currentText}`, ...lines, "Use /model <n> or /model <provider/id>"].join(`
+`));
+      }
+      return;
+    }
+    let numeric = Number.parseInt(arg, 10);
+    if (!Number.isNaN(numeric) && /^\d+$/.test(arg)) {
+      let cached = getCachedModels(ctx.key);
+      if (!cached || numeric < 1 || numeric > cached.length) {
+        await ctx.reply("Invalid selection \u2014 run /model to see the current list.");
+        return;
+      }
+      await setModelAndReply(ctx, cached[numeric - 1]);
+      return;
+    }
+    let models = getCachedModels(ctx.key) ?? await refreshAndCacheModels(session, ctx.key), exact = findExactModelReferenceMatch(arg, models);
+    if (exact) {
+      await setModelAndReply(ctx, exact);
+      return;
+    }
+    let query = arg.toLowerCase(), matches = models.filter((m) => m.id.toLowerCase().includes(query) || `${m.provider}/${m.id}`.toLowerCase().includes(query) || (m.name?.toLowerCase().includes(query) ?? !1));
+    if (matches.length === 0) {
+      await ctx.reply(`No model matches "${arg}".`);
+      return;
+    }
+    if (matches.length > 1) {
+      await ctx.reply(formatModelList(matches).join(`
+`));
+      return;
+    }
+    await setModelAndReply(ctx, matches[0]);
+  }
+}, sessionsCommand = {
+  name: "sessions",
+  description: "list or switch sessions",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, arg = ctx.args.trim(), currentFile = session.sessionManager?.getSessionFile();
+    if (!arg) {
+      let all = await SessionManager.list(process.cwd());
+      all.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+      let sessions = all.slice(0, 10);
+      setCachedSessions(ctx.key, sessions);
+      let items = sessions.map((s) => ({
+        label: `${s.path === currentFile ? "\u263E " : ""}${s.name ? truncate(s.name, 30) : truncate(s.firstMessage, 30) || "(empty)"}`,
+        value: s.path
+      }));
+      if (!(await createPicker(ctx.adapter, ctx.event.source, {
+        kind: "sessions",
+        sessionKey: ctx.key,
+        invokerId: ctx.event.source.userId,
+        items,
+        perPage: 8,
+        title: "Pick a session",
+        async resolve(item) {
+          await ctx.bridge.switchSession(ctx.key, item.value);
+          let switched2 = await ctx.bridge.getSession(ctx.key), name2 = switched2?.sessionManager?.getSessionName() ?? "unnamed", count2 = switched2?.sessionManager?.getEntries().length ?? 0;
+          return { done: !0, text: `\u263E Switched to "${name2}" (${count2} msgs). History continues here.` };
+        }
+      }, { replyTo: ctx.event.messageId, threadId: ctx.event.source.threadId })).success) {
+        let lines = sessions.map((s, i) => {
+          let marker = s.path === currentFile ? " \u263E" : "", label = s.name ? truncate(s.name, 40) : truncate(s.firstMessage, 40) || "(empty)";
+          return `${i + 1}) ${label}${marker} \xB7 ${formatRelativeTime(s.modified)} \xB7 ${s.messageCount} msgs`;
+        });
+        await ctx.reply([`Sessions for ${process.cwd()}`, ...lines, "Use /sessions <n> or /sessions <id-prefix>"].join(`
+`));
+      }
+      return;
+    }
+    let path, numeric = Number.parseInt(arg, 10), cached = getCachedSessions(ctx.key);
+    if (!Number.isNaN(numeric) && /^\d+$/.test(arg)) {
+      if (!cached || numeric < 1 || numeric > cached.length) {
+        await ctx.reply("Invalid selection \u2014 run /sessions to see the current list.");
+        return;
+      }
+      path = cached[numeric - 1].path;
+    } else {
+      let matches = (cached ?? await SessionManager.list(process.cwd())).filter((s) => s.id.startsWith(arg) || s.path.startsWith(arg));
+      if (matches.length === 0) {
+        await ctx.reply(`No session matches "${arg}".`);
+        return;
+      }
+      if (matches.length > 1) {
+        await ctx.reply(`Multiple sessions match "${arg}" \u2014 use a longer prefix.`);
+        return;
+      }
+      path = matches[0].path;
+    }
+    if (!path) {
+      await ctx.reply("No session selected.");
+      return;
+    }
+    await ctx.bridge.switchSession(ctx.key, path);
+    let switched = await ctx.bridge.getSession(ctx.key), name = switched?.sessionManager?.getSessionName() ?? "unnamed", count = switched?.sessionManager?.getEntries().length ?? 0;
+    await ctx.reply(`Switched to "${name}" (${count} msgs). History continues here.`);
+  }
+}, titleCommand = {
+  name: "title",
+  aliases: ["name"],
+  description: "name the current session",
+  bypassBusy: !0,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, name = ctx.args.trim();
+    if (!name) {
+      let current = session.sessionManager?.getSessionName();
+      await ctx.reply(current ? `Session title: ${current}` : "(unnamed)");
+      return;
+    }
+    session.setSessionName(name);
+    let readBack = session.sessionManager?.getSessionName() ?? name;
+    await ctx.reply(`Session titled "${readBack}".`);
+  }
+}, contextCommand = {
+  name: "context",
+  description: "estimated context window breakdown",
+  bypassBusy: !0,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, model = session.model;
+    if (!model) {
+      await ctx.reply("No model selected.");
+      return;
+    }
+    let contextWindow = model.contextWindow ?? 0;
+    if (contextWindow <= 0) {
+      await ctx.reply("Context window unknown for this model.");
+      return;
+    }
+    let tools = session.getActiveToolNames().map((name) => session.getToolDefinition(name)).filter((d) => d !== void 0), breakdown = computeContextBreakdown({
+      systemPrompt: session.systemPrompt,
+      tools,
+      messages: session.messages,
+      contextWindow
+    }), usage = session.getContextUsage(), tokens = usage?.tokens ?? breakdown.total, percent = usage?.percent ?? (contextWindow > 0 ? tokens / contextWindow * 100 : 0), messageTokens = breakdown.user + breakdown.assistantText + breakdown.thinking + breakdown.toolCalls + breakdown.toolResults + breakdown.summaries, stats = session.getSessionStats();
+    await ctx.reply([
+      `Context: ${tokens.toLocaleString("en-US")} / ${contextWindow.toLocaleString("en-US")} tokens (${Math.round(percent)}%)`,
+      `  system ${breakdown.systemPrompt.toLocaleString("en-US")} \xB7 tools ${breakdown.toolDefinitions.toLocaleString("en-US")} \xB7 messages ${messageTokens.toLocaleString("en-US")}`,
+      `Session: ${stats.totalMessages} messages \xB7 ${stats.userMessages} turns \xB7 model ${model.provider}/${model.id}`
+    ].join(`
+`));
+  }
+}, compactCommand = {
+  name: "compact",
+  description: "summarize and compress session context",
+  bypassBusy: !0,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, instructions = ctx.args.trim() || void 0;
+    try {
+      let result = await session.compact(instructions), before = result.tokensBefore.toLocaleString("en-US"), after = result.estimatedTokensAfter !== void 0 ? `~${result.estimatedTokensAfter.toLocaleString("en-US")}` : "~?";
+      await ctx.reply(`Compacted: ${before} \u2192 ${after} tokens.`);
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Nothing to compact") || message.includes("Already compacted") || message.includes("No model selected")) {
+        await ctx.reply(message);
+        return;
+      }
+      throw error;
+    }
+  }
+}, thinkingCommand = {
+  name: "thinking",
+  aliases: ["effort", "reasoning"],
+  description: "get or set the thinking level",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, levels = session.getAvailableThinkingLevels();
+    if (!session.supportsThinking()) {
+      await ctx.reply(`Model ${session.model?.provider ?? "none"}/${session.model?.id ?? "none"} doesn't support thinking.`);
+      return;
+    }
+    let arg = ctx.args.trim().toLowerCase();
+    if (!arg) {
+      let current = session.thinkingLevel, items = levels.map((level) => ({
+        label: `${level === current ? "\u2713 " : ""}${level}`,
+        value: level
+      }));
+      (await createPicker(ctx.adapter, ctx.event.source, {
+        kind: "thinking",
+        sessionKey: ctx.key,
+        invokerId: ctx.event.source.userId,
+        items,
+        perPage: levels.length,
+        title: "Pick a thinking level",
+        async resolve(item) {
+          let level = item.value;
+          return session.setThinkingLevel(level), { done: !0, text: `\u263E Thinking \u2192 ${level}` };
+        }
+      }, { replyTo: ctx.event.messageId, threadId: ctx.event.source.threadId })).success || await ctx.reply(`Level: ${current} \u2014 available: ${levels.join(", ")}`);
+      return;
+    }
+    if (!levels.includes(arg)) {
+      await ctx.reply(`Invalid level. Available: ${levels.join(", ")}`);
+      return;
+    }
+    session.setThinkingLevel(arg), await ctx.reply(`Thinking \u2192 ${arg}`);
+  }
+}, CHAT_COMMANDS = [
+  newCommand,
+  undoCommand,
+  redoCommand,
+  stopCommand,
+  statusCommand,
+  whoamiCommand,
+  helpCommand,
+  modelCommand,
+  sessionsCommand,
+  titleCommand,
+  contextCommand,
+  compactCommand,
+  thinkingCommand
+];
+function botCommandSpecs() {
+  return [
+    ...new Map([...CHAT_COMMANDS, ...MOBILE_COMMANDS, ...FORWARDED_COMMANDS].map((c) => [
+      c.name,
+      { name: c.name, description: c.description }
+    ])).values()
+  ];
+}
+function formatHelpText() {
+  let lines = ["lunR gateway commands:"];
+  for (let cmd of CHAT_COMMANDS) {
+    let names = [cmd.name, ...cmd.aliases ?? []].map((a) => `/${a}`).join(" | ");
+    lines.push(`${names} \u2014 ${cmd.description}`);
+  }
+  for (let cmd of botCommandSpecs())
+    CHAT_COMMANDS.some((c) => c.name === cmd.name) || lines.push(`/${cmd.name} \xB7 ${cmd.description}`);
+  return lines.push(""), lines.push("Tap to pick: /model, /thinking, /sessions (run without args to see buttons)."), lines.join(`
+`);
+}
+async function runChatCommand(cmd, ctx) {
+  if (!cmd.bypassBusy && ctx.bridge.getStatus(ctx.key).busy)
+    return await ctx.reply("\u23F3 busy \u2014 /stop first or wait"), !0;
+  if (cmd.needsSession) {
+    let session = await ctx.bridge.getSession(ctx.key);
+    if (!session)
+      return await ctx.reply("No session yet \u2014 send a message first."), !0;
+    ctx.session = session;
+  }
+  try {
+    let settingsManager = ctx.session?.settingsManager;
+    return (settingsManager ? await runtimeScope.run({ settingsManager, modelRuntime: ctx.session?.modelRuntime, thinking: () => ctx.session.thinkingLevel }, () => cmd.handler(ctx)) : await cmd.handler(ctx)) ?? !0;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    return await ctx.adapter.send(ctx.event.source.chatId, `\u26A0 ${oneLine(message)}`, {
+      replyTo: ctx.event.messageId,
+      threadId: ctx.event.source.threadId
+    }), !0;
+  }
+}
+async function sendCommandReply(adapter, event, text) {
+  await adapter.send(event.source.chatId, prefixLines(text, "\u263E "), {
+    replyTo: event.messageId,
+    threadId: event.source.threadId
+  });
+}
+
+export {
+  CHAT_COMMANDS,
+  botCommandSpecs,
+  formatHelpText,
+  runChatCommand,
+  sendCommandReply
+};