@ykurilov/agent-chat-background 0.0.0-stage → 0.55.0

package/dist/index.js

@@ -0,0 +1,756 @@
+import {
+  NOTICE_STATUSES,
+  RUNNING_STATUSES,
+  isFinishedStatus,
+  isRunningStatus,
+  meetsCondition,
+  patchEntries,
+  withoutEmptyFields
+} from "./chunk-4XFSUFM6.js";
+
+// src/background-tool.ts
+function backgroundTool(definition) {
+  return definition;
+}
+function turnFields(model) {
+  return { ownerId: model.ownerId, chatId: model.chatId, messageId: model.messageId ?? "", channel: model.channel ?? "web" };
+}
+var TOO_MANY_TASKS = (max) => `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u043D\u043E\u0433\u043E \u0444\u043E\u043D\u043E\u0432\u044B\u0445 \u0437\u0430\u0434\u0430\u0447: \u043E\u0434\u043D\u043E\u0432\u0440\u0435\u043C\u0435\u043D\u043D\u043E \u0438\u0434\u0451\u0442 \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${max}. \u0414\u043E\u0436\u0434\u0438\u0442\u0435\u0441\u044C, \u043F\u043E\u043A\u0430 \u043E\u0434\u043D\u0430 \u0438\u0437 \u043D\u0438\u0445 \u0437\u0430\u043A\u043E\u043D\u0447\u0438\u0442\u0441\u044F, \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438\u0442\u0435 \u043D\u0435\u043D\u0443\u0436\u043D\u0443\u044E (cancel_task).`;
+function backgroundToolForTurn(name, definition, model, service) {
+  return {
+    description: definition.description,
+    inputSchema: definition.inputSchema,
+    ...definition.needsApproval !== void 0 && { needsApproval: definition.needsApproval },
+    ...definition.metadata !== void 0 && { metadata: definition.metadata },
+    async execute(input, options) {
+      const title = definition.title(input);
+      const started = await service.runner().start({ ...turnFields(model), toolCallId: options.toolCallId, kind: "tool", name, input, title }, service.maxRunningPerUser);
+      if (started.status === "too_many_tasks") return { status: "too_many_tasks", message: TOO_MANY_TASKS(service.maxRunningPerUser) };
+      return { status: "started", taskId: started.taskId, title };
+    }
+  };
+}
+async function runBackgroundTool(definition, record, control) {
+  const result = await definition.run(record.input, {
+    ownerId: record.ownerId,
+    chatId: record.chatId,
+    signal: control.signal,
+    reportProgress: control.reportProgress
+  });
+  return { status: "done", result };
+}
+
+// src/background-tasks.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/helper-task.ts
+import { jsonSchema } from "ai";
+var HELPER_TOOL_PREFIX = "helper_";
+var TITLE_MAX_LENGTH = 80;
+var helperInput = jsonSchema({
+  type: "object",
+  properties: { task: { type: "string", description: "\u0417\u0430\u0434\u0430\u043D\u0438\u0435 \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A\u0443: \u0447\u0442\u043E \u0441\u0434\u0435\u043B\u0430\u0442\u044C \u0438 \u0447\u0442\u043E \u0432\u0435\u0440\u043D\u0443\u0442\u044C" } },
+  required: ["task"],
+  additionalProperties: false
+});
+function backgroundHelpers(port) {
+  const helpers = port?.helpers ?? {};
+  return Object.fromEntries(Object.entries(helpers).filter(([, helper]) => helper.background === true));
+}
+function helperModelOutput(output) {
+  const progress = output;
+  if (progress?.status === "background") {
+    return { type: "text", value: `\u041F\u043E\u043C\u043E\u0449\u043D\u0438\u043A \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u0432 \u0444\u043E\u043D\u0435${progress.taskId ? ` (\u0437\u0430\u0434\u0430\u0447\u0430 ${progress.taskId})` : ""}: \u0438\u0442\u043E\u0433 \u043F\u0440\u0438\u0434\u0451\u0442 \u043F\u043E\u0437\u0436\u0435.` };
+  }
+  return { type: "text", value: `\u041F\u043E\u043C\u043E\u0449\u043D\u0438\u043A \u043D\u0435 \u0441\u043F\u0440\u0430\u0432\u0438\u043B\u0441\u044F: ${progress?.error ?? "\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430"}` };
+}
+function helperToolForTurn(name, helper, model, service) {
+  return {
+    description: helper.description,
+    inputSchema: helperInput,
+    toModelOutput: ({ output }) => helperModelOutput(output),
+    async execute({ task }, options) {
+      const started = await service.runner().start(
+        { ...turnFields(model), toolCallId: options.toolCallId, kind: "helper", name, input: { task }, title: titleOf(task) },
+        service.maxRunningPerUser
+      );
+      if (started.status === "too_many_tasks") {
+        const message = TOO_MANY_TASKS(service.maxRunningPerUser);
+        return { task, steps: [], text: message, status: "failed", error: message };
+      }
+      return { task, steps: [], text: "", status: "background", taskId: started.taskId };
+    }
+  };
+}
+async function runHelperTask(port, helper, record, control) {
+  const { task } = record.input;
+  let lastProgress = record.progress;
+  const model = await port.helperModel(record.name, record.ownerId, record.chatId);
+  const result = await port.runHelper({
+    name: record.name,
+    helper,
+    task,
+    model,
+    ...record.helperMessages && { priorMessages: record.helperMessages },
+    abortSignal: control.signal,
+    async onStep(step) {
+      lastProgress = step.progress;
+      await control.saveStep({ helperMessages: step.messages, progress: step.progress });
+    }
+  });
+  const progress = { ...lastProgress ?? { task, steps: [] }, text: result.text, status: result.status };
+  switch (result.status) {
+    case "done":
+      return { status: "done", result: result.text, helperMessages: result.messages, progress };
+    case "failed":
+      return { status: "failed", error: result.text, helperMessages: result.messages, progress: { ...progress, error: result.text } };
+    case "awaiting_approval":
+      return { status: "awaiting_approval", helperMessages: result.messages, progress: lastProgress ?? progress };
+  }
+}
+function titleOf(task) {
+  const line = task.trim().replace(/\s+/g, " ");
+  return line.length <= TITLE_MAX_LENGTH ? line : `${line.slice(0, TITLE_MAX_LENGTH - 1)}\u2026`;
+}
+
+// src/task-delivery.ts
+var NOTICE_RESULT_MAX_LENGTH = 5e4;
+var isQuiet = (task) => task.status === "canceled" || task.status === "awaiting_approval";
+function createTaskDelivery(deps) {
+  const { store, leaseOwner } = deps;
+  const pending = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const again = /* @__PURE__ */ new Set();
+  const chatKey = (ownerId, chatId) => `${ownerId}\0${chatId}`;
+  async function deliverOnce(ownerId, chatId) {
+    const tasks = (await store.listUndelivered(ownerId, chatId)).filter((task) => task.leaseOwner === leaseOwner);
+    const delivered = [];
+    for (const group of await batchesOf(ownerId, tasks)) {
+      const result = await deps.port().deliverNotices({
+        ownerId,
+        chatId,
+        notices: group.tasks.map(noticeOf),
+        wakeAgent: !group.tasks.every(isQuiet),
+        deliveryKey: group.key
+      });
+      if (result.status === "busy") return "wait";
+      if (result.status === "chat_gone") {
+        const left = tasks.filter((task) => !delivered.includes(task.id));
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        for (const task of left) {
+          await store.update(
+            ownerId,
+            task.id,
+            { status: "canceled", finishedAt: task.finishedAt ?? now, deliveredAt: now, leaseOwner: void 0, leaseUntil: void 0 },
+            { leaseOwner, statuses: NOTICE_STATUSES }
+          );
+        }
+        return "done";
+      }
+      const ids = group.tasks.map((task) => task.id);
+      await store.markDelivered(ids, group.key, (/* @__PURE__ */ new Date()).toISOString());
+      delivered.push(...ids);
+    }
+    return "done";
+  }
+  async function batchesOf(ownerId, tasks) {
+    const batches = /* @__PURE__ */ new Map();
+    for (const task of tasks) if (task.deliveryKey) batches.set(task.deliveryKey, [...batches.get(task.deliveryKey) ?? [], task]);
+    const fresh = tasks.filter((task) => !task.deliveryKey);
+    for (const group of [fresh.filter(isQuiet), fresh.filter((task) => !isQuiet(task))]) {
+      if (group.length === 0) continue;
+      const key = group.map(deliveryKeyOf).join("+");
+      const kept = [];
+      for (const task of group) if (await store.update(ownerId, task.id, { deliveryKey: key }, { leaseOwner })) kept.push(task);
+      if (kept.length > 0) batches.set(key, kept);
+    }
+    const quietFirst = (group) => group.every(isQuiet) ? 0 : 1;
+    return [...batches].map(([key, group]) => ({ key, tasks: group })).sort((a, b) => quietFirst(a.tasks) - quietFirst(b.tasks));
+  }
+  function drain(ownerId, chatId) {
+    const key = chatKey(ownerId, chatId);
+    const running = inFlight.get(key);
+    if (running) {
+      again.add(key);
+      return running;
+    }
+    const work = (async () => {
+      try {
+        let outcome;
+        do {
+          again.delete(key);
+          outcome = await deliverOnce(ownerId, chatId).catch((error) => {
+            deps.port().logError(error);
+            return "wait";
+          });
+        } while (again.has(key));
+        if (outcome === "done") pending.delete(key);
+      } finally {
+        inFlight.delete(key);
+      }
+    })();
+    inFlight.set(key, work);
+    return work;
+  }
+  return {
+    request(ownerId, chatId) {
+      pending.set(chatKey(ownerId, chatId), { ownerId, chatId });
+      return drain(ownerId, chatId);
+    },
+    chatFree(ownerId, chatId) {
+      if (pending.has(chatKey(ownerId, chatId))) void drain(ownerId, chatId);
+    },
+    async retryPending() {
+      await Promise.all([...pending.values()].map(({ ownerId, chatId }) => drain(ownerId, chatId)));
+    },
+    forget(ownerId, chatId) {
+      pending.delete(chatKey(ownerId, chatId));
+    },
+    async idle() {
+      await Promise.allSettled([...inFlight.values()]);
+    }
+  };
+}
+function deliveryKeyOf(task) {
+  const approvalId = task.status === "awaiting_approval" ? task.progress?.pendingApproval?.approvalId : void 0;
+  return approvalId ? `task:${task.id}:approval:${approvalId}` : `task:${task.id}`;
+}
+function noticeOf(task) {
+  const base = { taskId: task.id, title: task.title };
+  switch (task.status) {
+    case "done":
+      return {
+        kind: "task_done",
+        ...base,
+        ...task.result !== void 0 && { result: noticeResult(task.result) },
+        // Помощник брал чужой текст: чат с этим итогом живые демонстрации не запускает.
+        ...task.progress?.externalContent && { externalContent: true }
+      };
+    case "failed":
+      return { kind: "task_failed", ...base, error: task.error ?? "\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430" };
+    case "timed_out":
+      return { kind: "task_timed_out", ...base, ...task.error && { error: task.error } };
+    case "canceled":
+      return { kind: "task_canceled", ...base };
+    case "awaiting_approval": {
+      const pendingApproval = task.progress?.pendingApproval;
+      return {
+        kind: "task_awaiting_approval",
+        ...base,
+        ...pendingApproval && { approval: { approvalId: pendingApproval.approvalId, toolName: pendingApproval.toolName, input: pendingApproval.input } }
+      };
+    }
+    default:
+      return { kind: "task_interrupted", ...base };
+  }
+}
+function noticeResult(result) {
+  const text = typeof result === "string" ? result : JSON.stringify(result);
+  if (text.length <= NOTICE_RESULT_MAX_LENGTH) return text;
+  const tail = `
+\u2026 (\u0438\u0442\u043E\u0433 \u043E\u0431\u0440\u0435\u0437\u0430\u043D: \u0432\u0441\u0435\u0433\u043E ${text.length} \u0437\u043D\u0430\u043A\u043E\u0432)`;
+  return text.slice(0, NOTICE_RESULT_MAX_LENGTH - tail.length) + tail;
+}
+
+// src/task-runner.ts
+import { randomUUID } from "crypto";
+
+// src/keyed-lock.ts
+function createKeyedLock() {
+  const tails = /* @__PURE__ */ new Map();
+  return (key, work) => {
+    const result = (tails.get(key) ?? Promise.resolve()).then(work);
+    const tail = result.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    tails.set(key, tail);
+    void tail.then(() => {
+      if (tails.get(key) === tail) tails.delete(key);
+    });
+    return result;
+  };
+}
+
+// src/task-runner.ts
+var MAX_ATTEMPTS = 3;
+var CANCELABLE_STATUSES = [...RUNNING_STATUSES, "awaiting_approval"];
+function createTaskRunner(deps) {
+  const { store, leaseOwner: me, leaseMs, delivery } = deps;
+  const leases = /* @__PURE__ */ new Map();
+  const taskLock = createKeyedLock();
+  const ownerLock = createKeyedLock();
+  let stopped = false;
+  let recovering;
+  const now = () => (/* @__PURE__ */ new Date()).toISOString();
+  const leaseUntil = (from) => new Date(Date.parse(from) + leaseMs).toISOString();
+  const stillMine = { leaseOwner: me, statuses: RUNNING_STATUSES };
+  const tasksChanged = (ownerId, chatId) => deps.port().events.emit({ type: "tasks-changed", ownerId, chatId });
+  const logError = (error) => deps.port().logError(error);
+  function stopRun(run, reason) {
+    run.stopped = true;
+    run.finishing = true;
+    clearTimeout(run.timer);
+    run.controller.abort(new Error(reason));
+  }
+  async function writeOutcome(record, outcome) {
+    const at = now();
+    const patch = { ...outcome, ...isFinishedStatus(outcome.status) && { finishedAt: at }, leaseUntil: leaseUntil(at) };
+    if (!await store.update(record.ownerId, record.id, patch, stillMine)) {
+      leases.delete(record.id);
+      return;
+    }
+    leases.set(record.id, { ownerId: record.ownerId, chatId: record.chatId });
+    tasksChanged(record.ownerId, record.chatId);
+    void delivery.request(record.ownerId, record.chatId);
+  }
+  async function finish(run, outcome) {
+    if (run.finishing) return;
+    run.finishing = true;
+    clearTimeout(run.timer);
+    if (outcome.status === "timed_out") run.controller.abort(new Error(outcome.error));
+    await taskLock(run.record.id, async () => {
+      if (run.stopped) return;
+      try {
+        await writeOutcome(run.record, outcome);
+      } catch (error) {
+        leases.delete(run.record.id);
+        logError(error);
+      }
+    });
+  }
+  function progressWriter(run) {
+    let latest;
+    let writing = false;
+    return (text) => {
+      latest = text;
+      if (writing) return;
+      writing = true;
+      void (async () => {
+        try {
+          while (latest !== void 0 && !run.finishing) {
+            const next = latest;
+            latest = void 0;
+            const progress = { task: run.record.title, steps: [], text: next, status: "running" };
+            if (await store.update(run.record.ownerId, run.record.id, { progress }, stillMine)) tasksChanged(run.record.ownerId, run.record.chatId);
+          }
+        } catch (error) {
+          logError(error);
+        } finally {
+          writing = false;
+        }
+      })();
+    };
+  }
+  function launch(record, plan) {
+    const run = { record, controller: new AbortController(), finishing: false, stopped: false };
+    leases.set(record.id, { ownerId: record.ownerId, chatId: record.chatId, run });
+    run.timer = setTimeout(() => void finish(run, { status: "timed_out", error: `\u0417\u0430\u0434\u0430\u0447\u0430 \u043D\u0435 \u0443\u043B\u043E\u0436\u0438\u043B\u0430\u0441\u044C \u0432 ${formatDuration(plan.timeoutMs)}` }), plan.timeoutMs);
+    run.timer.unref?.();
+    const control = {
+      signal: run.controller.signal,
+      reportProgress: progressWriter(run),
+      async saveStep(patch) {
+        if (run.finishing) return;
+        if (!await store.update(record.ownerId, record.id, { ...patch, leaseUntil: leaseUntil(now()) }, stillMine)) {
+          leases.delete(record.id);
+          stopRun(run, "\u0430\u0440\u0435\u043D\u0434\u0430 \u0437\u0430\u0434\u0430\u0447\u0438 \u043F\u043E\u0442\u0435\u0440\u044F\u043D\u0430");
+          throw run.controller.signal.reason;
+        }
+        tasksChanged(record.ownerId, record.chatId);
+      }
+    };
+    void Promise.resolve().then(() => plan.work(record, control)).then(
+      (outcome) => finish(run, outcome),
+      (error) => finish(run, { status: "failed", error: messageOf(error) })
+    );
+  }
+  async function finishWithout(record, outcome) {
+    await taskLock(record.id, () => writeOutcome(record, outcome));
+  }
+  async function recoverOnce() {
+    for (const stale of await store.listExpired(now())) {
+      if (stopped) return;
+      if (leases.has(stale.id)) continue;
+      try {
+        const at = now();
+        const claimed = await store.claim(stale.id, me, leaseUntil(at), at);
+        if (claimed) await resume(stale.status, claimed);
+      } catch (error) {
+        logError(error);
+      }
+    }
+  }
+  async function resume(prior, claimed) {
+    if (!isRunningStatus(prior)) {
+      leases.set(claimed.id, { ownerId: claimed.ownerId, chatId: claimed.chatId });
+      await delivery.request(claimed.ownerId, claimed.chatId);
+      return;
+    }
+    const plan = deps.plan(claimed);
+    if (typeof plan === "string") return finishWithout(claimed, { status: "failed", error: plan });
+    if (claimed.attempt > MAX_ATTEMPTS) return finishWithout(claimed, { status: "interrupted" });
+    if (prior === "running" && !plan.rerunAfterRestart) return finishWithout(claimed, { status: "interrupted" });
+    launch(claimed, plan);
+    tasksChanged(claimed.ownerId, claimed.chatId);
+  }
+  return {
+    start(task, maxRunningPerUser) {
+      return ownerLock(task.ownerId, async () => {
+        if (await store.countActive(task.ownerId) >= maxRunningPerUser) return { status: "too_many_tasks" };
+        const plan = deps.plan({ ...task, id: "", status: "queued", attempt: 0, createdAt: "" });
+        if (typeof plan === "string") throw new Error(plan);
+        const createdAt = now();
+        const id = randomUUID();
+        await store.create({ ...task, id, status: "queued", attempt: 0, createdAt, leaseOwner: me, leaseUntil: leaseUntil(createdAt) });
+        const claimed = await store.claim(id, me, leaseUntil(createdAt), createdAt);
+        if (!claimed) throw new Error(`\u0417\u0430\u0434\u0430\u0447\u0430 ${id} \u043D\u0435 \u0432\u0437\u044F\u0442\u0430 \u0432 \u0440\u0430\u0431\u043E\u0442\u0443 \u0441\u0440\u0430\u0437\u0443 \u043F\u043E\u0441\u043B\u0435 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F`);
+        launch(claimed, plan);
+        tasksChanged(task.ownerId, task.chatId);
+        return { status: "started", taskId: id };
+      });
+    },
+    cancel(ownerId, chatId, taskId, by) {
+      return taskLock(taskId, async () => {
+        const task = await store.get(ownerId, taskId);
+        if (!task || task.chatId !== chatId) return "not_found";
+        if (isFinishedStatus(task.status)) return "already_finished";
+        const at = now();
+        const canceled = by === "human" ? (
+          // Пометка «отменена» в чате: доставит эта копия, агент не проснётся.
+          { status: "canceled", finishedAt: at, leaseOwner: me, leaseUntil: leaseUntil(at), deliveredAt: void 0, deliveryKey: void 0 }
+        ) : (
+          // Отменил сам агент: он и так знает, сообщать нечего.
+          { status: "canceled", finishedAt: at, deliveredAt: at, leaseOwner: void 0, leaseUntil: void 0, deliveryKey: void 0 }
+        );
+        if (!await store.update(ownerId, taskId, canceled, { statuses: CANCELABLE_STATUSES })) return "already_finished";
+        const run = leases.get(taskId)?.run;
+        if (run) stopRun(run, "\u0437\u0430\u0434\u0430\u0447\u0430 \u043E\u0442\u043C\u0435\u043D\u0435\u043D\u0430");
+        if (by === "human") {
+          leases.set(taskId, { ownerId, chatId });
+          void delivery.request(ownerId, chatId);
+        } else {
+          leases.delete(taskId);
+        }
+        tasksChanged(ownerId, chatId);
+        return "canceled";
+      });
+    },
+    answerApproval(ownerId, chatId, taskId, approvalId, decision) {
+      return taskLock(taskId, async () => {
+        const task = await store.get(ownerId, taskId);
+        const pending = task?.progress?.pendingApproval;
+        if (!task || task.chatId !== chatId || task.status !== "awaiting_approval" || !pending) return "not_found";
+        if (pending.approvalId !== approvalId) return "stale";
+        const plan = deps.plan(task);
+        if (typeof plan === "string") return "not_found";
+        const { pendingApproval: _answered, ...progress } = task.progress;
+        const response = { type: "tool-approval-response", approvalId, approved: decision === "allow" };
+        const resumed = await store.update(
+          ownerId,
+          taskId,
+          {
+            status: "running",
+            helperMessages: [...task.helperMessages ?? [], { role: "tool", content: [response] }],
+            progress: { ...progress, status: "running" },
+            deliveredAt: void 0,
+            deliveryKey: void 0,
+            leaseOwner: me,
+            leaseUntil: leaseUntil(now())
+          },
+          { statuses: ["awaiting_approval"], pendingApprovalId: approvalId }
+        );
+        if (!resumed) return (await store.get(ownerId, taskId))?.status === "awaiting_approval" ? "stale" : "not_found";
+        launch(resumed, plan);
+        tasksChanged(ownerId, chatId);
+        return "resumed";
+      });
+    },
+    async chatDeleted(ownerId, chatId) {
+      for (const [taskId, lease] of leases) {
+        if (lease.ownerId !== ownerId || lease.chatId !== chatId) continue;
+        if (lease.run) stopRun(lease.run, "\u0447\u0430\u0442 \u0443\u0434\u0430\u043B\u0451\u043D");
+        leases.delete(taskId);
+      }
+      delivery.forget(ownerId, chatId);
+      await store.deleteForChat(ownerId, chatId);
+    },
+    recoverExpired() {
+      recovering ??= recoverOnce().finally(() => {
+        recovering = void 0;
+      });
+      return recovering;
+    },
+    async renewLeases() {
+      const until = leaseUntil(now());
+      await Promise.all(
+        [...leases].map(async ([taskId, lease]) => {
+          let renewed;
+          try {
+            renewed = await store.renewLease(taskId, me, until);
+          } catch (error) {
+            logError(error);
+            return;
+          }
+          if (renewed || leases.get(taskId) !== lease) return;
+          leases.delete(taskId);
+          if (lease.run) stopRun(lease.run, "\u0430\u0440\u0435\u043D\u0434\u0430 \u0437\u0430\u0434\u0430\u0447\u0438 \u043F\u043E\u0442\u0435\u0440\u044F\u043D\u0430");
+        })
+      );
+    },
+    async stop() {
+      stopped = true;
+      const held = [...leases.entries()];
+      leases.clear();
+      for (const [, lease] of held) if (lease.run) stopRun(lease.run, "\u0441\u043B\u0443\u0436\u0431\u0430 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430");
+      const at = now();
+      await Promise.all(held.map(([taskId]) => store.renewLease(taskId, me, at).catch(logError)));
+    }
+  };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function formatDuration(ms) {
+  return ms >= 6e4 && ms % 6e4 === 0 ? `${ms / 6e4} \u043C\u0438\u043D` : `${Math.ceil(ms / 1e3)} \u0441`;
+}
+
+// src/task-tools.ts
+import { jsonSchema as jsonSchema2 } from "ai";
+var CHECK_TASKS = "check_tasks";
+var CANCEL_TASK = "cancel_task";
+function backgroundInstructions(maxRunningPerUser) {
+  return [
+    "\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438. \u041D\u0435\u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0440\u0430\u0431\u043E\u0442\u0430\u044E\u0442 \u0432 \u0444\u043E\u043D\u0435: \u0432\u044B\u0437\u043E\u0432 \u0441\u0440\u0430\u0437\u0443 \u043E\u0442\u0432\u0435\u0447\u0430\u0435\u0442 \xABstarted\xBB \u0441 taskId, \u0438\u0442\u043E\u0433 \u043F\u0440\u0438\u0434\u0451\u0442 \u043F\u043E\u0437\u0436\u0435 \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u044B\u043C \u0441\u043B\u0443\u0436\u0435\u0431\u043D\u044B\u043C \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435\u043C.",
+    "\u041D\u0435 \u0436\u0434\u0438 \u0438\u0442\u043E\u0433\u0430 \u0438 \u043D\u0435 \u0437\u0430\u043F\u0443\u0441\u043A\u0430\u0439 \u0442\u0443 \u0436\u0435 \u0437\u0430\u0434\u0430\u0447\u0443 \u043F\u043E\u0432\u0442\u043E\u0440\u043D\u043E: \u0441\u043A\u0430\u0436\u0438 \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044E, \u0447\u0442\u043E \u0437\u0430\u0434\u0430\u0447\u0430 \u0437\u0430\u043F\u0443\u0449\u0435\u043D\u0430, \u0438 \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0439 \u0440\u0430\u0437\u0433\u043E\u0432\u043E\u0440.",
+    `\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0437\u0430\u0434\u0430\u0447 \u044D\u0442\u043E\u0433\u043E \u0447\u0430\u0442\u0430 \u2014 ${CHECK_TASKS}. \u041E\u0442\u043C\u0435\u043D\u0438\u0442\u044C \u0437\u0430\u0434\u0430\u0447\u0443 \u2014 ${CANCEL_TASK} \u0441 \u0435\u0451 taskId.`,
+    `\u0423 \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F \u043E\u0434\u043D\u043E\u0432\u0440\u0435\u043C\u0435\u043D\u043D\u043E \u0438\u0434\u0451\u0442 \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${maxRunningPerUser} \u0437\u0430\u0434\u0430\u0447; \u043F\u0440\u0438 \u043E\u0442\u0432\u0435\u0442\u0435 \xABtoo_many_tasks\xBB \u043F\u0440\u0435\u0434\u043B\u043E\u0436\u0438 \u0434\u043E\u0436\u0434\u0430\u0442\u044C\u0441\u044F \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438\u0442\u044C \u043E\u0434\u043D\u0443 \u0438\u0437 \u043D\u0438\u0445.`
+  ].join("\n");
+}
+function taskToolsForTurn(model, service) {
+  const { ownerId, chatId } = model;
+  return {
+    [CHECK_TASKS]: {
+      description: "\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u044D\u0442\u043E\u0433\u043E \u0447\u0430\u0442\u0430: \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u0435, \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435, \u0445\u043E\u0434.",
+      inputSchema: jsonSchema2({ type: "object", properties: {}, additionalProperties: false }),
+      async execute() {
+        const tasks = await service.store.listForChat(ownerId, chatId);
+        return {
+          tasks: tasks.map((task) => ({
+            taskId: task.id,
+            title: task.title,
+            status: task.status,
+            startedAt: task.startedAt ?? task.createdAt,
+            ...task.finishedAt && { finishedAt: task.finishedAt },
+            ...task.progress?.text && { progress: task.progress.text },
+            ...task.error && { error: task.error }
+          }))
+        };
+      }
+    },
+    [CANCEL_TASK]: {
+      description: "\u041E\u0442\u043C\u0435\u043D\u0438\u0442\u044C \u0444\u043E\u043D\u043E\u0432\u0443\u044E \u0437\u0430\u0434\u0430\u0447\u0443 \u044D\u0442\u043E\u0433\u043E \u0447\u0430\u0442\u0430 \u043F\u043E taskId.",
+      inputSchema: jsonSchema2({
+        type: "object",
+        properties: { taskId: { type: "string" } },
+        required: ["taskId"],
+        additionalProperties: false
+      }),
+      async execute({ taskId }) {
+        return { status: await service.runner().cancel(ownerId, chatId, taskId, "agent"), taskId };
+      }
+    }
+  };
+}
+
+// src/background-tasks.ts
+var DEFAULT_MAX_RUNNING_PER_USER = 3;
+var DEFAULT_TIMEOUT_MS = 30 * 6e4;
+var DEFAULT_LEASE_MS = 3e4;
+var MIN_LEASE_MS = 3e3;
+var TOOL_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
+function createBackgroundTasks(options) {
+  const { store } = options;
+  const tools = options.tools ?? {};
+  const maxRunningPerUser = options.maxRunningPerUser ?? DEFAULT_MAX_RUNNING_PER_USER;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
+  checkOptions(tools, maxRunningPerUser, timeoutMs, leaseMs);
+  const leaseOwner = randomUUID2();
+  let port;
+  const requirePort = () => {
+    if (!port) throw new Error("\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u043D\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u044B \u043A \u0441\u043B\u0443\u0436\u0431\u0435 \u0447\u0430\u0442\u0430: \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u0438\u0445 \u0432 createChatServer \u2014 \u044F\u0434\u0440\u043E \u0432\u044B\u0437\u043E\u0432\u0435\u0442 attach");
+    return port;
+  };
+  function plan(record) {
+    if (record.kind === "tool") {
+      const definition = tools[record.name];
+      if (!definition) return `\u0424\u043E\u043D\u043E\u0432\u043E\u0433\u043E \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0430 \xAB${record.name}\xBB \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435\u0442 \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445 \u0441\u043B\u0443\u0436\u0431\u044B`;
+      return {
+        work: (task, control) => runBackgroundTool(definition, task, control),
+        rerunAfterRestart: definition.rerunAfterRestart === true,
+        timeoutMs: definition.timeoutMs ?? timeoutMs
+      };
+    }
+    const helper = backgroundHelpers(port)[record.name];
+    if (!helper) return `\u0424\u043E\u043D\u043E\u0432\u043E\u0433\u043E \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A\u0430 \xAB${record.name}\xBB \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435\u0442 \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445 \u0441\u043B\u0443\u0436\u0431\u044B`;
+    return { work: (task, control) => runHelperTask(requirePort(), helper, task, control), rerunAfterRestart: true, timeoutMs };
+  }
+  const delivery = createTaskDelivery({ store, leaseOwner, port: requirePort });
+  const runner = createTaskRunner({ store, leaseOwner, leaseMs, port: requirePort, delivery, plan });
+  const service = { store, maxRunningPerUser, runner: () => (requirePort(), runner) };
+  let timer;
+  let unsubscribe;
+  let recovering = false;
+  let renewing;
+  let sweeping;
+  function tick() {
+    renewing ??= runner.renewLeases().finally(() => {
+      renewing = void 0;
+    });
+    sweeping ??= (async () => {
+      await delivery.retryPending();
+      if (recovering) await runner.recoverExpired().catch((error) => port?.logError(error));
+    })().finally(() => {
+      sweeping = void 0;
+    });
+  }
+  return {
+    instructions: backgroundInstructions(maxRunningPerUser),
+    get toolNames() {
+      return [...Object.keys(tools), ...Object.keys(backgroundHelpers(port)).map((name) => HELPER_TOOL_PREFIX + name), CHECK_TASKS, CANCEL_TASK];
+    },
+    tools(model) {
+      const set = {};
+      for (const [name, definition] of Object.entries(tools)) set[name] = backgroundToolForTurn(name, definition, model, service);
+      for (const [name, helper] of Object.entries(backgroundHelpers(port))) set[HELPER_TOOL_PREFIX + name] = helperToolForTurn(name, helper, model, service);
+      return { ...set, ...taskToolsForTurn(model, service) };
+    },
+    attach(attached) {
+      if (port) throw new Error("\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0443\u0436\u0435 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u044B \u043A \u0441\u043B\u0443\u0436\u0431\u0435 \u0447\u0430\u0442\u0430: \u043E\u0434\u0438\u043D \u044D\u043A\u0437\u0435\u043C\u043F\u043B\u044F\u0440 \u2014 \u043E\u0434\u043D\u0430 \u0441\u043B\u0443\u0436\u0431\u0430");
+      port = attached;
+      unsubscribe = attached.events.subscribe((event) => {
+        if (event.type === "turn-finished") delivery.chatFree(event.ownerId, event.chatId);
+      });
+      timer = setInterval(tick, Math.floor(leaseMs / 3));
+      timer.unref?.();
+    },
+    async listForChat(ownerId, chatId) {
+      return (await store.listForChat(ownerId, chatId)).map(viewOf);
+    },
+    cancel: (ownerId, chatId, taskId) => service.runner().cancel(ownerId, chatId, taskId, "human"),
+    answerApproval: (ownerId, chatId, taskId, approvalId, decision) => service.runner().answerApproval(ownerId, chatId, taskId, approvalId, decision),
+    chatDeleted: (ownerId, chatId) => service.runner().chatDeleted(ownerId, chatId),
+    async recover() {
+      requirePort();
+      recovering = true;
+      await runner.recoverExpired();
+    },
+    async flush() {
+      clearInterval(timer);
+      unsubscribe?.();
+      recovering = false;
+      await Promise.all([renewing, sweeping]);
+      await runner.stop();
+      await delivery.idle();
+    }
+  };
+}
+function checkOptions(tools, maxRunningPerUser, timeoutMs, leaseMs) {
+  if (!Number.isInteger(maxRunningPerUser) || maxRunningPerUser < 1) throw new Error("\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: maxRunningPerUser \u2014 \u0446\u0435\u043B\u043E\u0435 \u0447\u0438\u0441\u043B\u043E \u043E\u0442 1");
+  if (!(timeoutMs > 0)) throw new Error("\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: timeoutMs \u2014 \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0443\u043B\u044F");
+  if (!(leaseMs >= MIN_LEASE_MS)) throw new Error(`\u0424\u043E\u043D\u043E\u0432\u044B\u0435 \u0437\u0430\u0434\u0430\u0447\u0438: leaseMs \u2014 \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${MIN_LEASE_MS} \u043C\u0441`);
+  for (const [name, definition] of Object.entries(tools)) {
+    if (!TOOL_NAME.test(name)) throw new Error(`\u0424\u043E\u043D\u043E\u0432\u044B\u0439 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 \xAB${name}\xBB: \u0438\u043C\u044F \u2014 \u043B\u0430\u0442\u0438\u043D\u0438\u0446\u0430, \u0446\u0438\u0444\u0440\u044B, \xAB_\xBB \u0438 \xAB-\xBB, \u0434\u043E 64 \u0437\u043D\u0430\u043A\u043E\u0432`);
+    if (name === CHECK_TASKS || name === CANCEL_TASK || name.startsWith(HELPER_TOOL_PREFIX)) {
+      throw new Error(`\u0424\u043E\u043D\u043E\u0432\u044B\u0439 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 \xAB${name}\xBB: \u0438\u043C\u044F \u0437\u0430\u043D\u044F\u0442\u043E \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0430\u043C\u0438 \u0444\u043E\u043D\u0430 \u0438\u043B\u0438 \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A\u043E\u0432`);
+    }
+    if (definition.timeoutMs !== void 0 && !(definition.timeoutMs > 0)) throw new Error(`\u0424\u043E\u043D\u043E\u0432\u044B\u0439 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 \xAB${name}\xBB: timeoutMs \u2014 \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0443\u043B\u044F`);
+  }
+}
+function viewOf(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    kind: task.kind,
+    name: task.name,
+    status: task.status,
+    startedAt: task.startedAt ?? task.createdAt,
+    ...task.finishedAt && { finishedAt: task.finishedAt },
+    ...task.progress && { progress: task.progress }
+  };
+}
+
+// src/store/memory.ts
+var copy = (record) => withoutEmptyFields(structuredClone(record));
+var byCreatedAt = (left, right) => left.createdAt.localeCompare(right.createdAt);
+function memoryTaskStore() {
+  const tasks = /* @__PURE__ */ new Map();
+  const owned = (ownerId, taskId) => {
+    const task = tasks.get(taskId);
+    return task && task.ownerId === ownerId ? task : void 0;
+  };
+  const isFree = (task, leaseOwner, now) => task.leaseOwner === leaseOwner || task.leaseUntil === void 0 || task.leaseUntil < now;
+  return {
+    async create(task) {
+      tasks.set(task.id, copy(task));
+    },
+    async get(ownerId, taskId) {
+      const task = owned(ownerId, taskId);
+      return task ? copy(task) : null;
+    },
+    async update(ownerId, taskId, patch, when) {
+      const task = owned(ownerId, taskId);
+      if (!task || !meetsCondition(task, when)) return null;
+      const changed = { ...task };
+      for (const [key, value] of patchEntries(structuredClone(patch))) changed[key] = value;
+      const next = withoutEmptyFields(changed);
+      tasks.set(taskId, next);
+      return copy(next);
+    },
+    async listForChat(ownerId, chatId) {
+      return [...tasks.values()].filter((task) => task.ownerId === ownerId && task.chatId === chatId).sort(byCreatedAt).map(copy);
+    },
+    async countActive(ownerId) {
+      return [...tasks.values()].filter((task) => task.ownerId === ownerId && isRunningStatus(task.status)).length;
+    },
+    async claim(taskId, leaseOwner, leaseUntil, now) {
+      const task = tasks.get(taskId);
+      if (!task || task.deliveredAt !== void 0 || !isFree(task, leaseOwner, now)) return null;
+      const next = isRunningStatus(task.status) ? { ...task, status: "running", attempt: task.attempt + 1, startedAt: task.startedAt ?? now, leaseOwner, leaseUntil } : { ...task, leaseOwner, leaseUntil };
+      tasks.set(taskId, next);
+      return copy(next);
+    },
+    async renewLease(taskId, leaseOwner, leaseUntil) {
+      const task = tasks.get(taskId);
+      if (!task || task.deliveredAt !== void 0 || task.leaseOwner !== leaseOwner) return false;
+      tasks.set(taskId, { ...task, leaseUntil });
+      return true;
+    },
+    async listExpired(now) {
+      return [...tasks.values()].filter((task) => task.deliveredAt === void 0 && (task.leaseUntil === void 0 || task.leaseUntil < now)).map(copy);
+    },
+    async listUndelivered(ownerId, chatId) {
+      return [...tasks.values()].filter((task) => task.ownerId === ownerId && task.chatId === chatId && task.deliveredAt === void 0).filter((task) => NOTICE_STATUSES.includes(task.status)).sort(byCreatedAt).map(copy);
+    },
+    async markDelivered(taskIds, deliveryKey, at) {
+      for (const taskId of taskIds) {
+        const task = tasks.get(taskId);
+        if (!task || task.deliveryKey !== deliveryKey || !NOTICE_STATUSES.includes(task.status)) continue;
+        const { leaseOwner: _owner, leaseUntil: _until, ...rest } = task;
+        tasks.set(taskId, { ...rest, deliveredAt: at });
+      }
+    },
+    async deleteForChat(ownerId, chatId) {
+      for (const [taskId, task] of tasks) if (task.ownerId === ownerId && task.chatId === chatId) tasks.delete(taskId);
+    }
+  };
+}
+export {
+  backgroundTool,
+  createBackgroundTasks,
+  memoryTaskStore
+};
+//# sourceMappingURL=index.js.map