@craftsamo/telegram-tools 0.2.0 → 0.3.0

package/dist/mcp.js

@@ -2984,7 +2984,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve7.call(this, root, ref);
+      let _sch = resolve5.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -3011,7 +3011,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve7(root, ref) {
+    function resolve5(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3875,7 +3875,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve7(baseURI, relativeURI, options) {
+    function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -4266,7 +4266,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve7,
+      resolve: resolve5,
       resolveComponent,
       equal,
       serialize,
@@ -4681,7 +4681,7 @@ var require_core = __commonJS({
       errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
         if (!errors || errors.length === 0)
           return "No errors";
-        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
+        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
       }
       $dataMetaSchema(metaSchema, keywordsJsonPointers) {
         const rules = this.RULES.all;
@@ -12325,7 +12325,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve7) {
+function isRecursive(inst, stack, resolve5) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -12335,7 +12335,7 @@ function isRecursive(inst, stack, resolve7) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve7);
+      const answer = isRecursive(child, stack, resolve5);
       if (answer > result)
         result = answer;
     }
@@ -12346,7 +12346,7 @@ function isRecursive(inst, stack, resolve7) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve7) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve5) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -12410,7 +12410,7 @@ function isRecursive(inst, stack, resolve7) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve7 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve5 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -16608,8 +16608,8 @@ function ko_default() {
 }
 
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -28587,12 +28587,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve5) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve7();
+        resolve5();
       } else {
-        this._stdout.once("drain", resolve7);
+        this._stdout.once("drain", resolve5);
       }
     });
   }
@@ -28639,7 +28639,7 @@ function abortError(signal) {
 }
 function exec(argv, options) {
   const { signal } = options;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve5, reject) => {
     if (signal?.aborted) {
       reject(abortError(signal));
       return;
@@ -28698,7 +28698,7 @@ function exec(argv, options) {
     }
     const finish = () => settle2(() => {
       const { code, killedBy } = exitedWith ?? { code: null, killedBy: null };
-      resolve7({
+      resolve5({
         code: code ?? -1,
         stdout,
         stderr,
@@ -28872,9 +28872,9 @@ var StepErrors = class {
 
 // src/core/describe.ts
 var MAX_VALUE_LENGTH = 200;
-function cut(text, limit) {
-  const points = Array.from(text);
-  return points.length > limit ? `${points.slice(0, limit - 1).join("")}\u2026` : text;
+function cut(text2, limit) {
+  const points = Array.from(text2);
+  return points.length > limit ? `${points.slice(0, limit - 1).join("")}\u2026` : text2;
 }
 
 // src/core/facts.ts
@@ -28889,6 +28889,10 @@ function packageRoot(bundleUrl) {
   return dirname(dirname(fileURLToPath(bundleUrl)));
 }
 
+// src/entry/settings.ts
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute as isAbsolute3, join, resolve as resolvePath, sep as sep2 } from "node:path";
+
 // src/project.ts
 var PROJECT = {
   /** The plugin, MCP server and program name. */
@@ -28903,89 +28907,94 @@ var PROJECT = {
   toolsets: ["account", "chats", "sync", "files", "sends", "actions"],
   /** The toolsets on when a setting names none. */
   defaultToolsets: ["account", "chats", "sync", "sends"],
+  /** The package's own settings, which the tools themselves read: each snake_case name and its type, with bounds when it needs them. */
+  options: {
+    /** Where every account's state lives. */
+    state_dir: "path",
+    /** Where received files are saved. */
+    download_dir: "path",
+    /** The largest received file a call may download, in megabytes. */
+    download_max_mb: { type: "number", integer: true, min: 1, max: 2e3 },
+    /** The directories files may be sent from, besides the working directory. */
+    send_dirs: "paths",
+    /** Whether messages that disappear are kept; read by the sync service's commands. */
+    keep_disappearing: "boolean",
+    /** Whether channels are listed and their messages received; read by the sync service's commands. */
+    channels: "boolean"
+  },
   /** The environment variables the tools read besides the settings, which Codex forwards to the server after them. */
   toolVariables: []
 };
 
-// src/entry/download-dir.ts
-import { resolve as resolve2 } from "node:path";
-
 // src/entry/directory.ts
 import { homedir } from "node:os";
-import { isAbsolute as isAbsolute2, join, resolve, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute2, resolve } from "node:path";
+var DOWNLOADS_DIR = "Downloads";
+var DEFAULT_DOWNLOAD_MAX_MB = 100;
 function homeDir(env) {
   const envHome = env.HOME;
   if (envHome && isAbsolute2(envHome)) return envHome;
   return homedir();
 }
-function resolveGivenDirectory(given, home) {
-  const text = given.text.trim();
-  const expanded = text === "~" ? home : text.startsWith("~/") || text.startsWith(`~${sep2}`) ? join(home, text.slice(2)) : text;
-  if (!text || !isAbsolute2(expanded)) {
-    throw new ToolError("invalid_argument", `${given.source} must be an absolute path.`);
-  }
-  return resolve(expanded);
+function defaultStateDir(name, env, home) {
+  const xdg = env.XDG_STATE_HOME;
+  return xdg && isAbsolute2(xdg) ? resolve(xdg, name) : resolve(home, ".local", "state", name);
 }
-
-// src/entry/download-dir.ts
-var DOWNLOADS_DIR = "Downloads";
-function resolveDownloadDir(given, env, profile) {
+function text(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function resolveDirectorySettings(options, env, profile) {
   const home = homeDir(env);
-  return given !== void 0 ? resolveGivenDirectory(given, home) : resolve2(home, DOWNLOADS_DIR, profile.name);
+  const maxMb = options.download_max_mb;
+  const sendDirs = options.send_dirs;
+  return {
+    state_dir: text(options.state_dir) ?? defaultStateDir(profile.name, env, home),
+    download_dir: text(options.download_dir) ?? resolve(home, DOWNLOADS_DIR, profile.name),
+    download_max_mb: typeof maxMb === "number" ? maxMb : DEFAULT_DOWNLOAD_MAX_MB,
+    send_dirs: Array.isArray(sendDirs) ? [...sendDirs] : []
+  };
 }
 
 // src/entry/profile.ts
 var PROJECT_PROFILE = {
   name: PROJECT.name,
   envPrefix: PROJECT.envPrefix,
-  toolsets: { names: PROJECT.toolsets, defaults: PROJECT.defaultToolsets }
+  toolsets: { names: PROJECT.toolsets, defaults: PROJECT.defaultToolsets },
+  options: PROJECT.options
 };
 
-// src/entry/send-dirs.ts
-function resolveSendDirs(given, env) {
-  const home = homeDir(env);
-  return given.map((directory) => resolveGivenDirectory(directory, home));
-}
-
-// src/entry/state-dir.ts
-import { isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
-function resolveStateDir(given, env, profile) {
-  const home = homeDir(env);
-  if (given !== void 0) return resolveGivenDirectory(given, home);
-  const xdg = env.XDG_STATE_HOME;
-  if (xdg && isAbsolute3(xdg)) {
-    return resolve3(xdg, profile.name);
-  }
-  return resolve3(home, ".local", "state", profile.name);
-}
-
 // src/entry/settings.ts
 var CONFIRM_MODES = ["harness", "elicitation"];
 var ALL_TOOLSETS = "all";
 var TRUE_VALUES = ["1", "true"];
 var FALSE_VALUES = ["0", "false"];
-var DEFAULT_DOWNLOAD_MAX_MB = 100;
-var MAX_DOWNLOAD_MB = 2e3;
 var OPTIONS = {
   toolsets: { flag: "--toolsets", envSuffix: "TOOLSETS" },
   read_only: { flag: "--read-only", envSuffix: "READ_ONLY", boolean: true },
   tools: { flag: "--tools", envSuffix: "TOOLS" },
   exclude_tools: { flag: "--exclude-tools", envSuffix: "EXCLUDE_TOOLS" },
-  confirm: { flag: "--confirm", envSuffix: "CONFIRM" },
-  state_dir: { flag: "--state-dir", envSuffix: "STATE_DIR" },
-  download_dir: { flag: "--download-dir", envSuffix: "DOWNLOAD_DIR" },
-  download_max_mb: { flag: "--download-max-mb", envSuffix: "DOWNLOAD_MAX_MB" },
-  send_dirs: { flag: "--send-dirs", envSuffix: "SEND_DIRS" },
-  keep_disappearing: { flag: "--keep-disappearing", envSuffix: "KEEP_DISAPPEARING", boolean: true },
-  channels: { flag: "--channels", envSuffix: "CHANNELS", boolean: true }
+  confirm: { flag: "--confirm", envSuffix: "CONFIRM" }
 };
-var SERVICE_OPTION_NAMES = ["keep_disappearing", "channels"];
+function profileOptions(profile) {
+  return profile.options ?? {};
+}
+function settingOptions(profile) {
+  const toolOptions = Object.entries(profileOptions(profile)).map(([name, spec]) => [
+    name,
+    {
+      flag: `--${name.replace(/_/g, "-")}`,
+      envSuffix: name.toUpperCase(),
+      ...optionType(spec) === "boolean" && { boolean: true }
+    }
+  ]);
+  return { ...OPTIONS, ...Object.fromEntries(toolOptions) };
+}
 function envName(name, profile) {
-  return `${profile.envPrefix}_${OPTIONS[name].envSuffix}`;
+  return `${profile.envPrefix}_${settingOptions(profile)[name].envSuffix}`;
 }
-function readFlags(argv) {
+function readFlags(argv, profile) {
   const byFlag = new Map(
-    Object.keys(OPTIONS).map((name) => [OPTIONS[name].flag, { name, ...OPTIONS[name] }])
+    Object.entries(settingOptions(profile)).map(([name, option]) => [option.flag, { name, ...option }])
   );
   const given = {};
   for (let i = 0; i < argv.length; i++) {
@@ -29020,9 +29029,9 @@ function checkToolsets(names, source, toolsets) {
   return names.length ? names : void 0;
 }
 function parseBoolean(value, source) {
-  const text = value.trim().toLowerCase();
-  if (TRUE_VALUES.includes(text)) return true;
-  if (FALSE_VALUES.includes(text)) return false;
+  const text2 = value.trim().toLowerCase();
+  if (TRUE_VALUES.includes(text2)) return true;
+  if (FALSE_VALUES.includes(text2)) return false;
   throw new ToolError(
     "invalid_argument",
     `Unknown value "${value}" in ${source}; use one of ${[...TRUE_VALUES, ...FALSE_VALUES].join(", ")}.`
@@ -29038,44 +29047,106 @@ function parseConfirm(value, source) {
   }
   return mode;
 }
-function listedDirectories(given) {
-  return given === void 0 ? [] : splitList(given.text).map((text) => ({ text, source: given.source }));
-}
-function downloadMaxMb(value, source) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > MAX_DOWNLOAD_MB) {
-    throw new ToolError("invalid_argument", `${source} must be an integer from 1 to ${MAX_DOWNLOAD_MB}.`);
+function parseNumber(value, source) {
+  const trimmed = value.trim();
+  const parsed = trimmed === "" ? Number.NaN : Number(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new ToolError("invalid_argument", `Unknown number "${value}" in ${source}; use a finite number.`);
   }
-  return value;
+  return parsed;
 }
-function downloadMaxMbText({ text, source }) {
-  const trimmed = text.trim();
-  return downloadMaxMb(/^\d+$/.test(trimmed) ? Number(trimmed) : Number.NaN, source);
+function absolutePath(text2, source, env) {
+  const home = env.HOME !== void 0 && isAbsolute3(env.HOME) ? env.HOME : homedir2();
+  const expanded = text2 === "~" || text2.startsWith("~/") || text2.startsWith(`~${sep2}`) ? join(home, text2.slice(1)) : text2;
+  if (!isAbsolute3(expanded)) throw new ToolError("invalid_argument", `${source} must be an absolute path.`);
+  return resolvePath(expanded);
 }
-function downloadSettings(given, env, profile) {
-  const value = given ?? ((name) => envText(name, env, profile));
-  const max = value("download_max_mb");
-  return {
-    download_dir: resolveDownloadDir(value("download_dir"), env, profile),
-    download_max_mb: max === void 0 ? DEFAULT_DOWNLOAD_MAX_MB : downloadMaxMbText(max)
-  };
+function absolutePaths(items, source, env) {
+  return items.length > 0 ? items.map((item) => absolutePath(item, source, env)) : void 0;
 }
 function envText(name, env, profile) {
   const variable = envName(name, profile);
-  const text = env[variable];
-  return text === void 0 || text.trim() === "" ? void 0 : { text, source: variable };
+  const text2 = env[variable];
+  return text2 === void 0 || text2.trim() === "" ? void 0 : { text: text2, source: variable };
 }
 function flagOrEnvText(flags, name, env, profile) {
   const flagged = flags[name];
   return flagged !== void 0 ? { text: flagged, source: OPTIONS[name].flag } : envText(name, env, profile);
 }
+function optionType(spec) {
+  return typeof spec === "string" ? spec : spec.type;
+}
+function itemCount(count) {
+  return count === 1 ? "1 item" : `${count} items`;
+}
+function numberBoundsError({ integer: integer2, min, max }, source) {
+  const range = min !== void 0 && max !== void 0 ? ` from ${min} to ${max}` : min !== void 0 ? ` of at least ${min}` : max !== void 0 ? ` of at most ${max}` : "";
+  return new ToolError("invalid_argument", `${source} must be ${integer2 ? "a whole number" : "a number"}${range}.`);
+}
+function countBoundsError({ min, max }, source) {
+  const range = min !== void 0 && max !== void 0 ? `from ${min} to ${max} items` : min !== void 0 ? `at least ${itemCount(min)}` : `at most ${itemCount(max)}`;
+  return new ToolError("invalid_argument", `${source} must list ${range}.`);
+}
+function withinBounds(spec, value, source) {
+  if (value === void 0 || typeof spec === "string") return value;
+  const bounds = spec;
+  const { integer: integer2, min, max } = bounds;
+  if (typeof value === "number") {
+    if (integer2 && !Number.isInteger(value) || min !== void 0 && value < min || max !== void 0 && value > max) {
+      throw numberBoundsError(bounds, source);
+    }
+  } else if (typeof value === "object" && (min !== void 0 && value.length < min || max !== void 0 && value.length > max)) {
+    throw countBoundsError(bounds, source);
+  }
+  return value;
+}
+function parseOptionText(spec, given, env) {
+  return withinBounds(spec, parseTypedText(optionType(spec), given, env), given.source);
+}
+function parseTypedText(kind, given, env) {
+  switch (kind) {
+    case "text":
+      return nonBlank(given.text);
+    case "boolean":
+      return parseBoolean(given.text, given.source);
+    case "number":
+      return parseNumber(given.text, given.source);
+    case "list": {
+      const items = splitList(given.text);
+      return items.length > 0 ? items : void 0;
+    }
+    case "path": {
+      const text2 = nonBlank(given.text);
+      return text2 === void 0 ? void 0 : absolutePath(text2, given.source, env);
+    }
+    case "paths":
+      return absolutePaths(splitList(given.text), given.source, env);
+  }
+}
+function optionsFrom(flags, env, profile) {
+  const options = {};
+  for (const [name, spec] of Object.entries(profileOptions(profile))) {
+    if (flags[name] !== void 0) {
+      const parsed = parseOptionText(spec, { text: flags[name], source: settingOptions(profile)[name].flag }, env);
+      if (parsed !== void 0) options[name] = parsed;
+      continue;
+    }
+    const fromEnv = envText(name, env, profile);
+    if (fromEnv !== void 0) {
+      const parsed = parseOptionText(spec, fromEnv, env);
+      if (parsed !== void 0) options[name] = parsed;
+    }
+  }
+  return options;
+}
 function parseSettings(argv, env, profile = PROJECT_PROFILE) {
-  const flags = readFlags(argv);
+  const flags = readFlags(argv, profile);
   const value = (name) => flagOrEnvText(flags, name, env, profile);
+  const options = optionsFrom(flags, env, profile);
   const settings = {
     confirm: "harness",
-    state_dir: resolveStateDir(value("state_dir"), env, profile),
-    ...downloadSettings(value, env, profile),
-    send_dirs: resolveSendDirs(listedDirectories(value("send_dirs")), env)
+    options,
+    ...resolveDirectorySettings(options, env, profile)
   };
   const toolsets = value("toolsets");
   if (toolsets) settings.toolsets = checkToolsets(splitList(toolsets.text), toolsets.source, profile.toolsets);
@@ -29087,25 +29158,12 @@ function parseSettings(argv, env, profile = PROJECT_PROFILE) {
   if (excluded) settings.exclude_tools = splitList(excluded.text);
   const confirm = value("confirm");
   if (confirm) settings.confirm = parseConfirm(confirm.text.trim(), confirm.source);
-  for (const name of SERVICE_OPTION_NAMES) {
-    const given = value(name);
-    if (given) settings[name] = parseBoolean(given.text, given.source);
-  }
   return settings;
 }
-var TOOL_OPTION_NAMES = [
-  "toolsets",
-  "read_only",
-  "tools",
-  "exclude_tools",
-  "state_dir",
-  "download_dir",
-  "download_max_mb",
-  "send_dirs",
-  ...SERVICE_OPTION_NAMES
-];
-var LANGUAGE_OPTION = "language";
-var PLUGIN_OPTION_NAMES = [...TOOL_OPTION_NAMES, LANGUAGE_OPTION];
+function nonBlank(text2) {
+  const trimmed = text2?.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
 
 // src/core/account/read.ts
 import { existsSync as existsSync2, statSync } from "node:fs";
@@ -29121,8 +29179,8 @@ function quoteBadLabel(value) {
   const truncated = value.length > MAX_BAD_LABEL_PREVIEW ? `${value.slice(0, MAX_BAD_LABEL_PREVIEW)}\u2026` : value;
   return JSON.stringify(truncated);
 }
-function isLabel(text) {
-  return typeof text === "string" && LABEL_PATTERN.test(text);
+function isLabel(text2) {
+  return typeof text2 === "string" && LABEL_PATTERN.test(text2);
 }
 function checkLabel(label) {
   if (!isLabel(label)) {
@@ -29361,10 +29419,10 @@ var MILLISECOND_DIGITS = 3;
 var MIN_YEAR = 1e3;
 var MAX_HOUR = 23;
 var MAX_MINUTE = 59;
-function badTime(text, name) {
+function badTime(text2, name) {
   return new ToolError(
     "invalid_argument",
-    `${name} is not a time: ${JSON.stringify(text)}. Use RFC 3339 with an offset (2026-11-07T14:03:12+09:00), or a date or time without one (2026-11-07, 2026-11-07T14:03), which reads as local time.`
+    `${name} is not a time: ${JSON.stringify(text2)}. Use RFC 3339 with an offset (2026-11-07T14:03:12+09:00), or a date or time without one (2026-11-07, 2026-11-07T14:03), which reads as local time.`
   );
 }
 function isCalendarDay(year, month, day) {
@@ -29372,21 +29430,21 @@ function isCalendarDay(year, month, day) {
   date5.setUTCFullYear(year, month - 1, day);
   return date5.getUTCFullYear() === year && date5.getUTCMonth() === month - 1 && date5.getUTCDate() === day;
 }
-function parseTimeArgument(text, name) {
-  const match = TIME_PATTERN.exec(text.trim());
-  if (!match) throw badTime(text, name);
+function parseTimeArgument(text2, name) {
+  const match = TIME_PATTERN.exec(text2.trim());
+  if (!match) throw badTime(text2, name);
   const [, year, month, day, hour = "0", minute = "0", second = "0", fraction = "", zulu, sign, offsetHour, offsetMin] = match;
   const [y, mon, d, h, mi, s] = [year, month, day, hour, minute, second].map(Number);
   const ms = Number(fraction.padEnd(MILLISECOND_DIGITS, "0").slice(0, MILLISECOND_DIGITS));
   if (y < MIN_YEAR || !isCalendarDay(y, mon, d) || h > MAX_HOUR || mi > MAX_MINUTE || s > MAX_MINUTE) {
-    throw badTime(text, name);
+    throw badTime(text2, name);
   }
   if (sign === void 0 && zulu === void 0) return new Date(y, mon - 1, d, h, mi, s, ms).getTime();
   const wall = Date.UTC(y, mon - 1, d, h, mi, s, ms);
   if (zulu) return wall;
   const offsetH = Number(offsetHour);
   const offsetM = Number(offsetMin);
-  if (offsetH > MAX_HOUR || offsetM > MAX_MINUTE) throw badTime(text, name);
+  if (offsetH > MAX_HOUR || offsetM > MAX_MINUTE) throw badTime(text2, name);
   const offset = (offsetH * MINUTES_PER_HOUR + offsetM) * MS_PER_MINUTE;
   return sign === "-" ? wall + offset : wall - offset;
 }
@@ -29605,23 +29663,23 @@ function encodeCursor(value) {
 function notACursor(name) {
   return new ToolError("invalid_argument", `${name} is not a cursor this tool returned.`);
 }
-function decodeCursor(text, name) {
-  const bytes = Buffer3.from(text, "base64url");
-  if (bytes.toString("base64url") !== text) throw notACursor(name);
+function decodeCursor(text2, name) {
+  const bytes = Buffer3.from(text2, "base64url");
+  if (bytes.toString("base64url") !== text2) throw notACursor(name);
   try {
     return JSON.parse(bytes.toString("utf8"));
   } catch {
     throw notACursor(name);
   }
 }
-function readCursor(text, name, schema) {
-  const parsed = schema.safeParse(decodeCursor(text, name));
+function readCursor(text2, name, schema) {
+  const parsed = schema.safeParse(decodeCursor(text2, name));
   if (!parsed.success) throw notACursor(name);
   return parsed.data;
 }
 var HIGH_SURROGATE = /[\uD800-\uDBFF]$/;
-function cutText(text, keep) {
-  return text.length <= keep ? text : text.slice(0, keep).replace(HIGH_SURROGATE, "");
+function cutText(text2, keep) {
+  return text2.length <= keep ? text2 : text2.slice(0, keep).replace(HIGH_SURROGATE, "");
 }
 function jsonLength(value) {
   return JSON.stringify(value).length;
@@ -29711,15 +29769,15 @@ var ERROR_CODES = {
 function isErrorCode(value) {
   return typeof value === "string" && Object.hasOwn(ERROR_CODES, value);
 }
-function maskPhoneNumbers(text) {
-  return text.replace(PHONE_NUMBER, "[number]");
+function maskPhoneNumbers(text2) {
+  return text2.replace(PHONE_NUMBER, "[number]");
 }
 function cut2(message) {
   return maskPhoneNumbers(message).trim().slice(0, MAX_DETAIL_LENGTH);
 }
 function detail(message) {
-  const text = cut2(message);
-  return text ? `: ${text}` : "";
+  const text2 = cut2(message);
+  return text2 ? `: ${text2}` : "";
 }
 function afterWriteError(method, effect, reason) {
   return effect === "write" ? new ToolError("uncertain", `${method} may have taken effect (${reason}). ${UNCERTAIN_ADVICE}`) : new ToolError("upstream_error", `${method} failed (${reason}).`);
@@ -29897,19 +29955,19 @@ var ServiceConnection = class _ServiceConnection {
     socket.on("error", (error62) => {
       this.endReason ??= `the connection to the service broke${error62.code ? ` (${error62.code})` : ""}`;
     });
-    this.closed = new Promise((resolve7) => {
+    this.closed = new Promise((resolve5) => {
       socket.once("close", () => {
         this.endReason ??= "the service closed the connection";
         const lost = { lost: this.endReason };
         for (const settle2 of [...this.pending.values()]) settle2(lost);
-        resolve7();
+        resolve5();
       });
     });
   }
   /** Connects to the service's socket; rejects as `upstream_error` when nothing is listening there. */
   static connect(socketPath, options = {}) {
     const { timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS, signal, maxLineLength = DEFAULT_MAX_LINE_LENGTH } = options;
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal?.aborted) {
         reject(abortError(signal));
         return;
@@ -29931,7 +29989,7 @@ var ServiceConnection = class _ServiceConnection {
       };
       const onConnect = () => {
         detach();
-        resolve7(new _ServiceConnection(socket, maxLineLength));
+        resolve5(new _ServiceConnection(socket, maxLineLength));
       };
       const onFailure = () => stop(new ToolError("upstream_error", NOT_RUNNING_MESSAGE));
       const onAbort = () => stop(abortError(signal));
@@ -29954,7 +30012,7 @@ var ServiceConnection = class _ServiceConnection {
    */
   call(method, params, options) {
     const { effect, timeoutMs = DEFAULT_CALL_TIMEOUT_MS, signal } = options;
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal?.aborted) {
         reject(abortError(signal));
         return;
@@ -29983,7 +30041,7 @@ var ServiceConnection = class _ServiceConnection {
         clearTimeout(timer);
         signal?.removeEventListener("abort", onAbort);
         try {
-          resolve7(produce());
+          resolve5(produce());
         } catch (error62) {
           reject(error62);
         }
@@ -30303,10 +30361,10 @@ function replyTo(parsed, related) {
   if (reply.chat !== void 0) entry2.chat = reply.chat;
   if (reply.topic !== void 0) entry2.topic = reply.topic;
   if (reply.quote !== void 0) entry2.quote = reply.quote;
-  const text = repliedText(parsed, related)?.text;
-  if (text !== void 0) {
-    entry2.text = cutText(text, REPLY_TEXT_LENGTH);
-    if (entry2.text.length < text.length) entry2.text_cut = true;
+  const text2 = repliedText(parsed, related)?.text;
+  if (text2 !== void 0) {
+    entry2.text = cutText(text2, REPLY_TEXT_LENGTH);
+    if (entry2.text.length < text2.length) entry2.text_cut = true;
   }
   return entry2;
 }
@@ -30375,25 +30433,25 @@ function texts(entry2) {
   ];
 }
 function messageTextLength(entry2) {
-  return texts(entry2).reduce((total, text) => total + text.length, 0);
+  return texts(entry2).reduce((total, text2) => total + text2.length, 0);
 }
 function cutMessage(entry2, keep) {
   let room = keep;
   let cut3 = false;
-  const take = (text) => {
-    const kept = cutText(text, room);
-    room = Math.max(0, room - text.length);
-    if (kept.length < text.length) cut3 = true;
+  const take = (text2) => {
+    const kept = cutText(text2, room);
+    room = Math.max(0, room - text2.length);
+    if (kept.length < text2.length) cut3 = true;
     return kept;
   };
   const cutEntry = { ...entry2 };
   if (entry2.text !== void 0) cutEntry.text = take(entry2.text);
   if (entry2.reply_to) {
-    const { quote, text } = entry2.reply_to;
+    const { quote, text: text2 } = entry2.reply_to;
     cutEntry.reply_to = {
       ...entry2.reply_to,
       ...quote === void 0 ? {} : { quote: take(quote) },
-      ...text === void 0 ? {} : { text: take(text) }
+      ...text2 === void 0 ? {} : { text: take(text2) }
     };
   }
   if (entry2.earlier_versions)
@@ -30642,8 +30700,8 @@ function fetchResult(read, stored) {
 }
 
 // src/core/fold.ts
-function foldCase(text) {
-  return text.normalize("NFKC").toUpperCase().toLowerCase().replace(/ς/g, "\u03C3");
+function foldCase(text2) {
+  return text2.normalize("NFKC").toUpperCase().toLowerCase().replace(/ς/g, "\u03C3");
 }
 
 // src/core/chat/filter.ts
@@ -30782,8 +30840,8 @@ function foldedFileName(media) {
   return isRecord(info) && typeof info.name === "string" ? foldCase(info.name) : void 0;
 }
 function matchesAllWords(row, words2) {
-  const text = foldCase(row.body ?? "");
-  const unmatched = words2.filter((word) => !text.includes(word));
+  const text2 = foldCase(row.body ?? "");
+  const unmatched = words2.filter((word) => !text2.includes(word));
   if (unmatched.length === 0) return true;
   const name = row.media === null ? void 0 : foldedFileName(row.media);
   return name !== void 0 && unmatched.every((word) => name.includes(word));
@@ -31342,7 +31400,7 @@ async function openMessageFolder(downloadDir, folder) {
 
 // src/core/file/incoming.ts
 import { lstat as lstat4, realpath as realpath3 } from "node:fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute6, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute6, resolve as resolve2 } from "node:path";
 
 // src/core/file/place.ts
 import { createHash as createHash3, randomBytes } from "node:crypto";
@@ -31360,11 +31418,11 @@ var ANIMATED_STICKER = "an animated sticker (.tgs), which cannot be inspected";
 function unreadableArchive(label) {
   return `an archive that cannot be inspected (${label})`;
 }
-function words(text) {
-  return text.split(/\s+/).filter((word) => word !== "");
+function words(text2) {
+  return text2.split(/\s+/).filter((word) => word !== "");
 }
-function ascii(text) {
-  return Array.from(text, (character) => character.charCodeAt(0));
+function ascii(text2) {
+  return Array.from(text2, (character) => character.charCodeAt(0));
 }
 function at(offset, bytes) {
   return { offset, bytes };
@@ -31581,7 +31639,7 @@ function parseOctal(field) {
   }
   return digits > 0 ? value : void 0;
 }
-function parseNumber(field) {
+function parseNumber2(field) {
   const first = field[0];
   if (first === void 0 || (first & BASE256_FLAG) === 0) return parseOctal(field);
   if (first === BASE256_NEGATIVE) return void 0;
@@ -31620,11 +31678,11 @@ function parseHeader(block) {
     path[prefix.length] = "/".charCodeAt(0);
     path.set(name, prefix.length + 1);
   }
-  return { path, size: parseNumber(block.subarray(SIZE_START, SIZE_END)), type: block[TYPE_OFFSET] };
+  return { path, size: parseNumber2(block.subarray(SIZE_START, SIZE_END)), type: block[TYPE_OFFSET] };
 }
-function parseDecimal(text) {
-  if (!/^[0-9]{1,15}$/.test(text)) return void 0;
-  return Number(text);
+function parseDecimal(text2) {
+  if (!/^[0-9]{1,15}$/.test(text2)) return void 0;
+  return Number(text2);
 }
 function parsePaxRecords(data, maxRecords = Infinity) {
   const records = [];
@@ -31814,8 +31872,8 @@ var EXTENSIONS = {
 };
 var KIND_PATTERN = /^[a-z]{1,16}$/;
 var UNKNOWN_KIND = "file";
-function byteLength(text) {
-  return Buffer5.byteLength(text);
+function byteLength(text2) {
+  return Buffer5.byteLength(text2);
 }
 function extensionOf2(type) {
   return type == null ? "" : EXTENSIONS[type.split(";")[0].trim().toLowerCase()] ?? "";
@@ -31983,7 +32041,7 @@ async function openDownloaded(incoming, path) {
 }
 async function discardDownload(incoming, path) {
   if (!isAbsolute6(path)) return;
-  const folder = dirname3(resolve4(path));
+  const folder = dirname3(resolve2(path));
   if (dirname3(folder) !== incoming) return;
   await discard(folder).catch(() => {
   });
@@ -32084,8 +32142,8 @@ function fitListings(result) {
 var MAX_NAME_CHARACTERS = 255;
 var CUT_MARK = "\u2026";
 var HIDDEN_CHARACTERS = /[\u0000-\u001F\u007F-\u009F\u00AD\u034F\u061C\u115F\u1160\u17B4\u17B5\u180B-\u180F\u200B-\u200F\u2028-\u202E\u2060-\u206F\u3164\uFE00-\uFE0D\uFEFF\uFFA0\uFFF9-\uFFFC\u{1D173}-\u{1D17A}\u{E0000}-\u{E007F}]/gu;
-function cleanName(text) {
-  const cleaned = text.normalize("NFC").replace(HIDDEN_CHARACTERS, "?");
+function cleanName(text2) {
+  const cleaned = text2.normalize("NFC").replace(HIDDEN_CHARACTERS, "?");
   const characters = Array.from(cleaned);
   if (characters.length <= MAX_NAME_CHARACTERS) return cleaned;
   return characters.slice(0, MAX_NAME_CHARACTERS - CUT_MARK.length).join("") + CUT_MARK;
@@ -32258,9 +32316,9 @@ function decodeUtf8Lossy(bytes) {
   return LOSSY_UTF8.decode(bytes);
 }
 function decodeCp437(bytes) {
-  let text = "";
-  for (const byte of bytes) text += byte < ASCII_END ? String.fromCharCode(byte) : CP437_HIGH[byte - ASCII_END];
-  return text;
+  let text2 = "";
+  for (const byte of bytes) text2 += byte < ASCII_END ? String.fromCharCode(byte) : CP437_HIGH[byte - ASCII_END];
+  return text2;
 }
 
 // src/core/archive/tar.ts
@@ -33237,7 +33295,7 @@ var telegramFileSave = createFileSave();
 
 // src/core/file/send/tool.ts
 import { realpath as realpath6 } from "node:fs/promises";
-import { join as join10, resolve as resolve6 } from "node:path";
+import { join as join10, resolve as resolve4 } from "node:path";
 
 // src/core/telegram/action-checks.ts
 var LINK_PREVIEW = "webpage";
@@ -33319,14 +33377,14 @@ function storedReactions(json2) {
 function ownReaction(reactions) {
   return reactions.find((reaction2) => reaction2.mine)?.emoji;
 }
-function checkEditable({ kind, body, captioned }, text) {
+function checkEditable({ kind, body, captioned }, text2) {
   if (kind === "service" || body === null && !captioned) {
     throw new ToolError("invalid_argument", "This message has no text or caption to edit; nothing was edited.");
   }
-  if (body === text) {
+  if (body === text2) {
     throw new ToolError("invalid_argument", "The text is the same as the message's; nothing to edit.");
   }
-  if (captioned && text.length > CAPTION_MAX_UNITS) {
+  if (captioned && text2.length > CAPTION_MAX_UNITS) {
     throw new ToolError(
       "invalid_argument",
       `A caption must be at most ${CAPTION_MAX_UNITS} characters; nothing was edited.`
@@ -33335,8 +33393,8 @@ function checkEditable({ kind, body, captioned }, text) {
 }
 
 // src/core/message/arguments.ts
-function checkedText(text) {
-  const trimmed = text.trim();
+function checkedText(text2) {
+  const trimmed = text2.trim();
   if (trimmed === "") throw new ToolError("invalid_argument", "text is blank; give the text to send.");
   if (trimmed.length > TEXT_MAX_UNITS) {
     throw new ToolError(
@@ -33394,8 +33452,8 @@ var Window = class {
   get tail() {
     return this.#tail;
   }
-  sees(text) {
-    const all = this.#tail + text;
+  sees(text2) {
+    const all = this.#tail + text2;
     this.#tail = all.slice(-TAIL_LENGTH);
     return MARKER.test(all);
   }
@@ -33405,13 +33463,13 @@ var PrivateKeyScan = class {
   #withoutNuls;
   /** Feeds the next chunk; whether a marker starts anywhere in the bytes so far. */
   sees(chunk) {
-    const text = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString("latin1");
+    const text2 = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString("latin1");
     const before = this.#plain.tail;
-    const plain2 = this.#plain.sees(text);
-    if (this.#withoutNuls === void 0 && text.includes(NUL)) {
+    const plain2 = this.#plain.sees(text2);
+    if (this.#withoutNuls === void 0 && text2.includes(NUL)) {
       this.#withoutNuls = new Window(before);
     }
-    const stripped = this.#withoutNuls?.sees(text.replaceAll(NUL, "")) ?? false;
+    const stripped = this.#withoutNuls?.sees(text2.replaceAll(NUL, "")) ?? false;
     return plain2 || stripped;
   }
 };
@@ -33727,7 +33785,7 @@ async function hashResolved({ shown, resolved }, budget, signal) {
 }
 
 // src/core/file/send/resolve-files.ts
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 
 // src/core/outgoing/roots.ts
 import { realpath as realpath4 } from "node:fs/promises";
@@ -33765,7 +33823,7 @@ async function allowedRoots({ cwd, sendDirs, home, forbidden }) {
 
 // src/core/outgoing/resolve.ts
 import { lstat as lstat6, realpath as realpath5 } from "node:fs/promises";
-import { basename as basename2, resolve as resolve5, sep as sep4 } from "node:path";
+import { basename as basename2, resolve as resolve3, sep as sep4 } from "node:path";
 var UNRESOLVABLE = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "ELOOP"]);
 var UNREADABLE = /* @__PURE__ */ new Set(["EACCES", "EPERM"]);
 async function realPathOf(path, shown) {
@@ -33780,7 +33838,7 @@ async function realPathOf(path, shown) {
 }
 async function resolveOutgoing(path, { cwd, roots, forbidden, home }) {
   const shown = JSON.stringify(path);
-  const real = await realPathOf(resolve5(cwd, path), shown);
+  const real = await realPathOf(resolve3(cwd, path), shown);
   const stats = await lstat6(real, { bigint: true });
   if (!stats.isFile()) throw new ToolError("invalid_argument", `${shown} is not a regular file.`);
   if (stats.nlink > 1n) throw hardLinked(shown);
@@ -33812,7 +33870,7 @@ async function resolveOutgoing(path, { cwd, roots, forbidden, home }) {
 var FALLBACK_KIND = "file";
 async function resolveFiles(files, ctx) {
   const forbidden = [ctx.stateDir, ctx.ownDir].filter((directory) => directory !== void 0);
-  const home = homedir2();
+  const home = homedir3();
   const roots = await allowedRoots({ cwd: ctx.cwd, sendDirs: ctx.sendDirs ?? [], home, forbidden });
   const seen = /* @__PURE__ */ new Set();
   const resolvedFiles = [];
@@ -34025,12 +34083,12 @@ var DUPLICATE_NOTE = "An earlier delivery of this same call had already gone out
 var DUPLICATE_UNKNOWN_ID_NOTE = `${DUPLICATE_NOTE} Its id is not known yet; \`telegram_chat_read\` shows it once the service receives it.`;
 
 // src/core/message/uncertain.ts
-function sentLike(paths, chat, text, startedAt) {
+function sentLike(paths, chat, text2, startedAt) {
   const rows = readMirror(
     paths,
     (mirror) => mirror.prepare(
       "SELECT id, ts FROM messages WHERE chat = ? AND from_me = 1 AND body = ? AND ts >= ? ORDER BY ts DESC, id DESC LIMIT ?"
-    ).all(chat, text, startedAt - SENT_LOOKBACK_MS, MAX_SENT_LIKE)
+    ).all(chat, text2, startedAt - SENT_LOOKBACK_MS, MAX_SENT_LIKE)
   );
   return rows.map(({ id, ts }) => ({ id, time: formatLocalTime(ts) }));
 }
@@ -34050,8 +34108,8 @@ function withFound(error62, find, describe3) {
     details: { ...error62.details, sent_like_this: found }
   });
 }
-function withSentLike(error62, paths, chat, text, startedAt) {
-  return withFound(error62, () => sentLike(paths, chat, text, startedAt), sentence);
+function withSentLike(error62, paths, chat, text2, startedAt) {
+  return withFound(error62, () => sentLike(paths, chat, text2, startedAt), sentence);
 }
 
 // src/core/file/send/uncertain.ts
@@ -34082,7 +34140,7 @@ function cannotBeSent(shown, refusal) {
   return new ToolError("forbidden", `${shown} cannot be sent: ${why}.`, { cause: refusal });
 }
 async function fileTarget(path, cwd) {
-  const absolute = resolve6(cwd, path);
+  const absolute = resolve4(cwd, path);
   return realpath6(absolute).catch(() => absolute);
 }
 async function stageAll(files, folder, budget, signal) {
@@ -34486,10 +34544,10 @@ var telegramMessageDelete = defineTool({
 });
 
 // src/core/message/edit-prepare.ts
-function prepareEdit(mirror, chatId, id, text) {
+function prepareEdit(mirror, chatId, id, text2) {
   const { chat, message } = findOwnMessage(mirror, chatId, id, "edit");
   if (!message) throw deletedMessage();
-  checkEditable({ ...message, captioned: message.media !== null && takesCaption(message.media.type) }, text);
+  checkEditable({ ...message, captioned: message.media !== null && takesCaption(message.media.type) }, text2);
   return { chat, message };
 }
 
@@ -34512,22 +34570,22 @@ var telegramMessageEdit = defineTool({
   input: editInput,
   output: editOutput,
   async describe(args, ctx) {
-    const text = checkedText(args.text);
+    const text2 = checkedText(args.text);
     const chat = requireChatId(args.chat, MESSAGE_EDIT_TOOL_ID);
     const paths = await pickPaths(ctx, args.account);
-    const target = readMirror(paths, (mirror) => prepareEdit(mirror, chat, args.id, text));
+    const target = readMirror(paths, (mirror) => prepareEdit(mirror, chat, args.id, text2));
     return {
       ...describeAction(EDIT_HEADLINES, target.chat, args.id, target.message),
-      text: { label: "New text", body: text }
+      text: { label: "New text", body: text2 }
     };
   },
   targets: (args, ctx) => actionTargets(MESSAGE_EDIT_TOOL_ID, args, ctx),
   async execute(args, ctx) {
     const chat = requireChatId(args.chat, MESSAGE_EDIT_TOOL_ID);
-    const text = checkedText(args.text);
+    const text2 = checkedText(args.text);
     const paths = await pickPaths(ctx, args.account);
-    readMirror(paths, (mirror) => prepareEdit(mirror, chat, args.id, text));
-    const params = { chat, id: args.id, text };
+    readMirror(paths, (mirror) => prepareEdit(mirror, chat, args.id, text2));
+    const params = { chat, id: args.id, text: text2 };
     const edited = await callService(paths.socket, SERVICE_REQUESTS.edit, params, {
       effect: "write",
       signal: ctx.signal,
@@ -34723,7 +34781,7 @@ var telegramMessageSend = defineTool({
   input: input5,
   output: output5,
   async describe(args, ctx) {
-    const text = checkedText(args.text);
+    const text2 = checkedText(args.text);
     const chat = requireChatId(args.chat, MESSAGE_SEND_TOOL_ID);
     const paths = await pickPaths(ctx, args.account);
     const { row, title } = readMirror(paths, (mirror) => {
@@ -34735,17 +34793,17 @@ var telegramMessageSend = defineTool({
         headline: { text: "About to send a message to {chat}", values: { chat: row.name } }
       },
       facts: [chatFact(row.kind), ...topicFacts(args.topic, title), ...replyFacts(args.reply_to)],
-      text: { label: "Message text", body: text }
+      text: { label: "Message text", body: text2 }
     };
   },
   targets: (args, ctx) => chatTargets(MESSAGE_SEND_TOOL_ID, args, ctx),
   async execute(args, ctx) {
     const chat = requireChatId(args.chat, MESSAGE_SEND_TOOL_ID);
-    const text = checkedText(args.text);
+    const text2 = checkedText(args.text);
     const paths = await pickPaths(ctx, args.account);
     const params = {
       chat,
-      text,
+      text: text2,
       ...args.topic !== void 0 && { topic: args.topic },
       ...args.reply_to !== void 0 && { reply_to: args.reply_to }
     };
@@ -34758,7 +34816,7 @@ var telegramMessageSend = defineTool({
       });
       return sendResult(chat, sent);
     } catch (error62) {
-      throw isToolError(error62) && error62.code === "uncertain" ? withSentLike(error62, paths, chat, text, startedAt) : error62;
+      throw isToolError(error62) && error62.code === "uncertain" ? withSentLike(error62, paths, chat, text2, startedAt) : error62;
     }
   }
 });
@@ -35584,7 +35642,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error62) {
@@ -35601,7 +35659,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve5, reject) => {
       const earlyReject = (error62) => {
         reject(error62);
       };
@@ -35679,7 +35737,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve7(parseResult.data);
+            resolve5(parseResult.data);
           }
         } catch (error62) {
           reject(error62);
@@ -35941,12 +35999,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve7, interval);
+      const timeoutId = setTimeout(resolve5, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -36762,23 +36820,52 @@ function elicitationConfirm(server, signal) {
 
 // src/mcp/roots.ts
 import { statSync as statSync2 } from "node:fs";
+import { isAbsolute as isAbsolute7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var FILE_URI_PROTOCOL = "file:";
+var SANDBOX_STATE_META = "codex/sandbox-state-meta";
+var TURN_METADATA = "x-codex-turn-metadata";
+function existingDirectory(dir) {
+  try {
+    return statSync2(dir, { throwIfNoEntry: false })?.isDirectory() ? dir : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function localDirectory(uri) {
   try {
     const url2 = new URL(uri);
-    if (url2.protocol !== FILE_URI_PROTOCOL) return void 0;
-    const dir = fileURLToPath2(url2);
-    return statSync2(dir, { throwIfNoEntry: false })?.isDirectory() ? dir : void 0;
+    return url2.protocol === FILE_URI_PROTOCOL ? existingDirectory(fileURLToPath2(url2)) : void 0;
   } catch {
     return void 0;
   }
 }
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function usableDirectory(candidate, ownDir, allowPath = false) {
+  if (typeof candidate !== "string") return void 0;
+  const dir = allowPath && isAbsolute7(candidate) ? existingDirectory(candidate) : localDirectory(candidate);
+  if (dir === void 0 || ownDir !== void 0 && await isWithin(dir, ownDir)) return void 0;
+  return dir;
+}
+async function callDirectory(meta3, ownDir) {
+  if (!isRecord2(meta3)) return void 0;
+  const sandbox = meta3[SANDBOX_STATE_META];
+  if (isRecord2(sandbox)) {
+    const dir = await usableDirectory(sandbox.sandboxCwd, ownDir, true);
+    if (dir !== void 0) return dir;
+  }
+  const turn = meta3[TURN_METADATA];
+  if (!isRecord2(turn) || !isRecord2(turn.workspaces)) return void 0;
+  const workspaces = Object.keys(turn.workspaces);
+  return workspaces.length === 1 ? usableDirectory(workspaces[0], ownDir, true) : void 0;
+}
 async function firstUsableRoot(server, ownDir, signal) {
   const { roots } = await server.listRoots(void 0, { signal });
   for (const root of roots) {
-    const dir = localDirectory(root.uri);
-    if (dir !== void 0 && !(ownDir !== void 0 && await isWithin(dir, ownDir))) return dir;
+    const dir = await usableDirectory(root.uri, ownDir);
+    if (dir !== void 0) return dir;
   }
   return void 0;
 }
@@ -36789,7 +36876,9 @@ function createWorkingDirResolver(server, fallback, ownDir) {
     cached2 = void 0;
     generation++;
   });
-  return async (signal) => {
+  return async (signal, meta3) => {
+    const callDir = await callDirectory(meta3, ownDir);
+    if (callDir !== void 0) return callDir;
     if (!server.getClientCapabilities()?.roots) return fallback();
     if (cached2 !== void 0) return cached2;
     const started = generation;
@@ -36830,7 +36919,7 @@ function createServer(specs, settings, options = {}) {
 `));
   const server = new Server(
     { name: PROJECT.name, version: options.version ?? DEFAULT_VERSION },
-    { capabilities: { tools: {} } }
+    { capabilities: { tools: {}, experimental: { [SANDBOX_STATE_META]: {} } } }
   );
   const workingDir = createWorkingDirResolver(server, options.cwd ?? (() => process.cwd()), options.ownDir);
   const toolsets = options.toolsets ?? PROJECT_PROFILE.toolsets;
@@ -36843,13 +36932,14 @@ function createServer(specs, settings, options = {}) {
     try {
       const confirm = settings.confirm === "elicitation" ? elicitationConfirm(server, extra.signal) : void 0;
       const ctx = {
-        cwd: await workingDir(extra.signal),
+        cwd: await workingDir(extra.signal, request.params._meta),
         ownDir: options.ownDir,
         stateDir: settings.state_dir,
         downloadDir: settings.download_dir,
         downloadMaxMb: settings.download_max_mb,
         sendDirs: settings.send_dirs,
         programName: PROJECT.name,
+        options: settings.options,
         signal: extra.signal,
         ...confirm && { confirm }
       };
@@ -36875,7 +36965,7 @@ async function main() {
     const settings = parseSettings(process.argv.slice(2), process.env);
     server = createServer(ALL_TOOLS, settings, {
       ownDir: packageRoot(import.meta.url),
-      version: true ? "0.2.0" : void 0
+      version: true ? "0.3.0" : void 0
     });
   } catch (error62) {
     if (!isToolError(error62)) throw error62;