openmausbot 0.1.68 → 0.1.70

package/dist-server/drivers/agents-proxy.js

@@ -49,6 +49,8 @@ var MAX_CREATED_PER_TURN = 4;
 var createdThisTurn = 0;
 var MAX_ROOM_POSTS_PER_TURN = 3;
 var roomPostsThisTurn = 0;
+var MAX_THREADS_PER_TURN = 5;
+var threadsOpenedThisTurn = 0;
 var delegationTaskIdsThisTurn = /* @__PURE__ */ new Set();
 var WEEKDAYS = [
   "monday",
@@ -62,7 +64,7 @@ var WEEKDAYS = [
 var ROUTINE_SCHEDULE_SCHEMA = {
   type: "object",
   additionalProperties: false,
-  description: 'Either {"type":"once","at":RFC3339} for one future run, {"type":"weekly","time":"HH:MM","weekdays":[...]} for chosen days, {"type":"daily","time":"HH:MM"} for every day, or {"type":"interval","every_minutes":15,"starts_at":RFC3339} to repeat from an optional starting point.',
+  description: 'Either {"type":"once","at":RFC3339} for one future run, {"type":"weekly","time":"HH:MM","weekdays":[...]} for chosen days, {"type":"daily","time":"HH:MM"} for every day, or {"type":"interval","every_minutes":15} to repeat. Intervals can optionally be limited with weekdays, window_start + window_end, and ends_at.',
   properties: {
     type: {
       type: "string",
@@ -80,7 +82,7 @@ var ROUTINE_SCHEDULE_SCHEMA = {
     weekdays: {
       type: "array",
       items: { type: "string", enum: WEEKDAYS },
-      description: "Only for type weekly: which days the routine runs, in the computer's local timezone."
+      description: "For type weekly: required run days. For type interval: optional allowed days. Values use the computer's local timezone."
     },
     every_minutes: {
       type: "integer",
@@ -91,6 +93,30 @@ var ROUTINE_SCHEDULE_SCHEMA = {
     starts_at: {
       type: "string",
       description: "Optional for type interval: RFC3339 date-time with an explicit timezone offset that anchors the cadence. Omit to start one interval after confirmation."
+    },
+    window_start: {
+      type: "string",
+      description: "Optional for type interval, together with window_end: local 24-hour HH:MM when runs may begin, inclusive."
+    },
+    window_end: {
+      type: "string",
+      description: "Optional for type interval, together with window_start: local 24-hour HH:MM when the allowed window ends, exclusive. It must be later on the same day."
+    },
+    ends_at: {
+      type: "string",
+      description: "Optional for type interval: inclusive RFC3339 date-time cutoff with an explicit timezone offset."
+    },
+    every_day: {
+      type: "boolean",
+      description: "Only for an interval update: true removes an existing weekday restriction."
+    },
+    all_day: {
+      type: "boolean",
+      description: "Only for an interval update: true removes an existing time-window restriction."
+    },
+    never_ends: {
+      type: "boolean",
+      description: "Only for an interval update: true removes an existing end cutoff."
     }
   },
   required: ["type"]
@@ -107,7 +133,7 @@ var SHORT_WEEKDAYS = {
   sat: "saturday",
   sun: "sunday"
 };
-var SUPPORTED_SCHEDULES = 'Supported schedules: {"type":"once","at":"2026-09-01T09:00:00+05:30"} (future RFC3339 with explicit offset), {"type":"weekly","time":"09:00","weekdays":["monday","friday"]}, {"type":"daily","time":"09:00"}, or {"type":"interval","every_minutes":15}.';
+var SUPPORTED_SCHEDULES = 'Supported schedules: {"type":"once","at":"2026-09-01T09:00:00+05:30"} (future RFC3339 with explicit offset), {"type":"weekly","time":"09:00","weekdays":["monday","friday"]}, {"type":"daily","time":"09:00"}, or {"type":"interval","every_minutes":15,"weekdays":["monday","friday"],"window_start":"09:00","window_end":"17:00"}.';
 function normalizeScheduleInput(args) {
   let raw = args.schedule;
   if (typeof raw === "string") {
@@ -119,7 +145,7 @@ function normalizeScheduleInput(args) {
   }
   if (!jsonRecord(raw)) return { error: `The schedule must be a JSON object. ${SUPPORTED_SCHEDULES}` };
   const type = typeof raw.type === "string" ? raw.type.trim().toLowerCase() : "";
-  const fields = type === "once" ? ["type", "at"] : type === "weekly" || type === "daily" ? ["type", "time", "weekdays"] : type === "interval" ? ["type", "every_minutes", "everyMinutes", "starts_at", "anchorAt"] : null;
+  const fields = type === "once" ? ["type", "at"] : type === "weekly" || type === "daily" ? ["type", "time", "weekdays"] : type === "interval" ? ["type", "every_minutes", "everyMinutes", "starts_at", "anchorAt", "weekdays", "every_day", "window_start", "window_end", "window", "all_day", "ends_at", "endsAt", "never_ends"] : null;
   const unsupported = fields && Object.keys(raw).find((key) => raw[key] != null && !fields.includes(key));
   if (unsupported) {
     return { error: `Unsupported ${type} schedule field "${unsupported}". Weekly and daily times use the computer's timezone from list_routines. ${SUPPORTED_SCHEDULES}` };
@@ -152,6 +178,14 @@ function normalizeScheduleInput(args) {
     return { schedule: { type: "weekly", time, weekdays: normalized } };
   }
   if (type === "interval") {
+    for (const flag of ["every_day", "all_day", "never_ends"]) {
+      if (raw[flag] != null && typeof raw[flag] !== "boolean") {
+        return { error: `"${flag}" must be true or false.` };
+      }
+    }
+    if (raw.window != null && (!jsonRecord(raw.window) || Object.keys(raw.window).some((key) => key !== "start" && key !== "end") || typeof raw.window.start !== "string" || typeof raw.window.end !== "string")) {
+      return { error: '"window" must contain "start" and "end" in HH:MM, for example {"start":"09:00","end":"17:00"}.' };
+    }
     const rawMinutes = raw.every_minutes ?? raw.everyMinutes;
     const everyMinutes = Number(rawMinutes);
     if (!Number.isInteger(everyMinutes) || everyMinutes < 5 || everyMinutes > 1440) {
@@ -161,11 +195,59 @@ function normalizeScheduleInput(args) {
     if (rawStart !== void 0 && (typeof rawStart !== "string" || !rawStart.trim())) {
       return { error: '"starts_at" must be an RFC3339 date-time with an explicit timezone offset.' };
     }
+    if (raw.every_day === true && Array.isArray(raw.weekdays) && raw.weekdays.length > 0) {
+      return { error: 'Choose interval "weekdays" or "every_day", not both.' };
+    }
+    let intervalWeekdays;
+    if (raw.every_day === true) {
+      intervalWeekdays = null;
+    } else if (raw.weekdays !== void 0) {
+      if (!Array.isArray(raw.weekdays) || raw.weekdays.length === 0) {
+        return { error: 'Interval "weekdays" must contain at least one full weekday name.' };
+      }
+      intervalWeekdays = [];
+      for (const day of raw.weekdays) {
+        const lower = String(day).trim().toLowerCase();
+        const full = WEEKDAYS.includes(lower) ? lower : Object.hasOwn(SHORT_WEEKDAYS, lower) ? SHORT_WEEKDAYS[lower] : void 0;
+        if (!full) return { error: `Unsupported weekday "${String(day)}". Use full names: ${WEEKDAYS.join(", ")}.` };
+        if (!intervalWeekdays.includes(full)) intervalWeekdays.push(full);
+      }
+    }
+    const rawWindow = jsonRecord(raw.window) ? raw.window : void 0;
+    const windowStart = raw.window_start ?? rawWindow?.start;
+    const windowEnd = raw.window_end ?? rawWindow?.end;
+    if (raw.all_day === true && (windowStart !== void 0 || windowEnd !== void 0)) {
+      return { error: 'Choose window_start + window_end or "all_day", not both.' };
+    }
+    let window;
+    if (raw.all_day === true) {
+      window = null;
+    } else if (windowStart !== void 0 || windowEnd !== void 0) {
+      if (typeof windowStart !== "string" || !windowStart.trim() || typeof windowEnd !== "string" || !windowEnd.trim()) {
+        return { error: 'An interval time window needs both "window_start" and "window_end" in 24-hour HH:MM.' };
+      }
+      window = { start: windowStart.trim(), end: windowEnd.trim() };
+    }
+    const rawEnd = raw.ends_at ?? raw.endsAt;
+    if (raw.never_ends === true && rawEnd !== void 0) {
+      return { error: 'Choose "ends_at" or "never_ends", not both.' };
+    }
+    let endsAt;
+    if (raw.never_ends === true) endsAt = null;
+    else if (rawEnd !== void 0) {
+      if (typeof rawEnd !== "string" || !rawEnd.trim()) {
+        return { error: '"ends_at" must be an RFC3339 date-time with an explicit timezone offset.' };
+      }
+      endsAt = rawEnd.trim();
+    }
     return {
       schedule: {
         type: "interval",
         everyMinutes,
-        ...typeof rawStart === "string" ? { anchorAt: rawStart.trim() } : {}
+        ...typeof rawStart === "string" ? { anchorAt: rawStart.trim() } : {},
+        ...intervalWeekdays !== void 0 ? { weekdays: intervalWeekdays } : {},
+        ...window !== void 0 ? { window } : {},
+        ...endsAt !== void 0 ? { endsAt } : {}
       }
     };
   }
@@ -262,6 +344,36 @@ var TOOLS = [
       required: ["task_id"]
     }
   },
+  {
+    name: "list_threads",
+    description: "See your own threads and the threads you opened on teammates, newest first: each with its bot, title, state (running, waiting on the person, queued, or idle), whether the person has unread there, and the delegation id if it was a handoff. Use it to check how the threads you started are going before reporting to the person; write a thread's title as #Title when you mention it. A teammate's other threads are never listed \u2014 only the ones you opened. This is a read: it starts nothing and changes nothing.",
+    inputSchema: { type: "object", additionalProperties: false, properties: {} }
+  },
+  {
+    name: "close_thread",
+    description: "Mark a thread you opened (or one of your own) as finished once you have read its result: it goes idle in the person's sidebar with a note saying you closed it. Nothing is deleted \u2014 deleting stays the person's decision \u2014 and a thread that is still running cannot be closed; wait for it or leave it. Use the thread id from list_threads or from the start_thread result. If a close is refused, do not retry it.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: { thread_id: { type: "string", description: "The thread id from list_threads or start_thread." } },
+      required: ["thread_id"]
+    }
+  },
+  {
+    name: "start_thread",
+    description: `Open a new thread: one conversation with its own history and its own run, shown to the person as a row under the bot it belongs to. Leave bot_id out to open it on yourself, for a separate job that should run on its own ("review each pull request" \u2014 one thread per pull request) instead of inside this conversation. Give bot_id (from list_bots) to open it on a teammate: that is a handoff into a fresh thread, which starts after your current turn ends and whose result is delivered here, like delegate_bot. The title becomes the row's name, so make it short and specific; write it as #Title when you mention it to the person. Do not use it for a question you need answered right now (ask_bot), for one task where the teammate's usual conversation is fine (delegate_bot), or for a note nobody has to act on. If a call is refused, do not retry it: say what you still wanted opened.`,
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: { type: "string", description: `The thread's name: one short line, at most 80 characters, specific enough to tell it apart from the others (for example "QA: PR #412 login fix").` },
+        message: { type: "string", description: "The complete first message of the thread \u2014 everything the run needs, since it will not see this conversation." },
+        bot_id: { type: "string", description: "Optional: the teammate's id from list_bots. Leave out to open the thread on yourself." },
+        folder: { type: "string", description: "Optional: the name of one of that bot's existing folders to file the thread under. Leave out unless the person named one." }
+      },
+      required: ["title", "message"]
+    }
+  },
   {
     name: "post_to_room",
     description: "Put one message into a shared room you belong to, for example when the user asks you to tell the team something. Get group_id from list_rooms. This posts and returns: no room member's turn starts, nobody replies, and nothing comes back except confirmation \u2014 so never use it to ask a question or hand out work (use ask_bot or delegate_bot for those). Post once, say it in full, and tell the user what you posted. If a post is refused, do not retry it: say what you wanted to post in your reply instead.",
@@ -472,6 +584,12 @@ async function api(path, init) {
   if (!res.ok) throw new Error(String(body.error ?? `HTTP ${res.status}`));
   return body;
 }
+function ordinal(n) {
+  const rem100 = n % 100;
+  if (rem100 >= 11 && rem100 <= 13) return `${n}th`;
+  const rem10 = n % 10;
+  return `${n}${rem10 === 1 ? "st" : rem10 === 2 ? "nd" : rem10 === 3 ? "rd" : "th"}`;
+}
 function jsonRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -680,6 +798,71 @@ Judge progress by this activity, not by waiting: real work keeps producing lines
     }
     return { text: `Task ${taskId} ended without a reply \u2014 ${String(r.status ?? "unknown")}${r.result ? `: ${String(r.result)}` : ""}.`, isError: true };
   }
+  if (name === "list_threads") {
+    const query = new URLSearchParams({ fromBotId: BOT_ID, fromThreadId: THREAD_ID });
+    const r = await api(`/api/internal/threads?${query.toString()}`);
+    if (r.error) return { text: `Couldn't list threads: ${String(r.error)}`, isError: true };
+    const threads = Array.isArray(r.threads) ? r.threads.filter(jsonRecord) : [];
+    if (!threads.length) return { text: "No threads yet: you have none of your own beyond this one, and you have not opened any on a teammate." };
+    const stateWord = { running: "running", "waiting-on-you": "waiting on the person", queued: "queued", idle: "idle" };
+    const lines = threads.map((thread) => {
+      const where = thread.own === true ? "yours" : `on @${String(thread.botName)}`;
+      const state = stateWord[String(thread.state)] ?? String(thread.state);
+      const unread = thread.unread === true ? ", unread for the person" : "";
+      const handoff = typeof thread.delegationId === "string" && thread.delegationId ? ` [delegation id: ${thread.delegationId}]` : "";
+      return `- #${String(thread.title)} (${where}, ${state}${unread}) [thread id: ${String(thread.threadId)}]${handoff}`;
+    });
+    return { text: `Threads, newest first:
+${lines.join("\n")}` };
+  }
+  if (name === "close_thread") {
+    const threadId = String(args.thread_id ?? "").trim();
+    if (!threadId) return { text: "close_thread needs the thread_id from list_threads or start_thread.", isError: true };
+    const r = await api(`/api/internal/threads/${encodeURIComponent(threadId)}/close`, { method: "POST", body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID }) });
+    if (r.error) return { text: `Couldn't close that thread: ${String(r.error)}`, isError: true };
+    return { text: `Closed #${String(r.title)}${r.botName ? ` on @${String(r.botName)}` : ""}. It stays in the person's sidebar, idle, with a note that you closed it.` };
+  }
+  if (name === "start_thread") {
+    const title = String(args.title ?? "").trim();
+    const message = String(args.message ?? "").trim();
+    if (!title || !message) return { text: "start_thread needs title (one short line) and message (the complete first message).", isError: true };
+    if (threadsOpenedThisTurn >= MAX_THREADS_PER_TURN) {
+      return {
+        text: `You have already opened ${MAX_THREADS_PER_TURN} threads this turn, which is the limit. Do not retry \u2014 finish your turn and tell the person which threads you still wanted to open, so they can open them or ask you again.`,
+        isError: true
+      };
+    }
+    const toBotId = typeof args.bot_id === "string" ? args.bot_id.trim() : "";
+    const folder = typeof args.folder === "string" ? args.folder.trim() : "";
+    const body = { fromBotId: BOT_ID, fromThreadId: THREAD_ID, title, message, depth: DEPTH };
+    if (toBotId) body.toBotId = toBotId;
+    if (folder) body.folder = folder;
+    const r = await api("/api/internal/threads", { method: "POST", body: JSON.stringify(body) });
+    if (r.error && r.state !== "failed") return { text: `Couldn't open that thread: ${String(r.error)}`, isError: true };
+    threadsOpenedThisTurn += 1;
+    const threadTitle = String(r.title ?? title);
+    const threadId = String(r.threadId ?? "");
+    const where = r.self === true ? "on yourself" : `on @${String(r.botName ?? "that bot")}`;
+    const opened = `Opened thread #${threadTitle} ${where} [thread id: ${threadId}].`;
+    if (r.self === true) {
+      if (r.state === "running") {
+        return { text: `${opened} It is running now, in parallel with this conversation, and its result stays in that thread \u2014 it will not be delivered here. Mention it to the person as #${threadTitle}; use list_threads in a later turn to see how it is going.` };
+      }
+      if (r.state === "queued") {
+        const position = Number(r.position) || 1;
+        const limit = Number(r.limit) || 0;
+        return { text: `${opened} You are at your limit of ${limit} threads running at once, so it is ${ordinal(position)} in line and starts as soon as one of them finishes \u2014 nothing more to do. Mention it to the person as #${threadTitle}.` };
+      }
+      return { text: `${opened} It could not start: ${String(r.error ?? "unknown reason")}. The thread exists but nothing is running in it; tell the person.`, isError: true };
+    }
+    const delegationId = typeof r.delegationId === "string" ? r.delegationId.trim() : "";
+    if (delegationId) delegationTaskIdsThisTurn.add(delegationId);
+    const approval = r.approvalRequired === true ? " The person must approve this handoff first; their card appears after your turn ends." : "";
+    const timing = r.state === "queued" ? ` @${String(r.botName ?? "that bot")} can run ${Number(r.limit) || 0} threads at once and they are all spoken for, so it waits ${ordinal(Number(r.position) || 1)} in line for a free slot after this turn ends.` : " It starts when this turn ends, like any handoff.";
+    return {
+      text: `${opened}${timing}${approval} Its result will be delivered to this conversation automatically (delegation id: ${delegationId || "unknown"}). Acknowledge it, mention it to the person as #${threadTitle}, and finish your turn; do not check or wait for it in this turn.`
+    };
+  }
   if (name === "create_bot") {
     const botName = String(args.name ?? "").trim();
     const role = String(args.role ?? "").trim();