@capybara-hq/kernel 0.1.0-rc.21 → 0.1.0-rc.22

package/dist/config/schema.js

@@ -1,5 +1,5 @@
 import { isIP } from "node:net";
-import { DOCUMENT_MEDIA_TYPES, IMAGE_MEDIA_TYPES, validateAllowHost, } from "@capybara-hq/plugin-sdk";
+import { DEV_HOSTS, DOCUMENT_MEDIA_TYPES, IMAGE_MEDIA_TYPES, tierAtMost, validateAllowHost, } from "@capybara-hq/plugin-sdk";
 import { z } from "zod";
 import { LOG_FORMATS, LOG_LEVELS } from "../log.js";
 import { noProxyEntryProblem, proxyUrlProblem } from "../net/proxy.js";
@@ -965,10 +965,24 @@ export const KernelConfigSchema = z.object({
             .int()
             .min(0)
             .refine((n) => n === 0 || n >= 10_000, "0 (no limit) or at least 10,000")
-            .default(5_000_000)
+            .default(0)
             .meta(meta({
             hot: true,
-            description: "Tokens (input, output and cache) all sub-agents of the tree under a person's message may use together; at the cap running sub-agents stop and new dispatches are refused. 0 means no limit; otherwise at least 10,000. Organizations can be given their own value in subagentLimitOverrides",
+            description: "Tokens (input, output and cache) all sub-agents of the tree under a person's message may use together; at the cap running sub-agents stop and new dispatches are refused. 0 (the default) means no limit; otherwise at least 10,000. Organizations can be given their own value in subagentLimitOverrides",
+        })),
+    })
+        .prefault({}),
+    skills: z
+        .object({
+        catalogBudgetChars: z
+            .number()
+            .int()
+            .min(1_000)
+            .max(1_000_000)
+            .default(16_000)
+            .meta(meta({
+            hot: true,
+            description: "Characters the skills catalog lines with descriptions may take in a conversation's skills snapshot (about 4 characters per token). At run start the skills are ranked (the agent's own and the ones it shared, builtin, the organization's own, then plugin skills; by name within each) and keep their descriptions while the running total fits; the rest are listed by name only. Recorded in the snapshot, so a change applies from the next snapshot a run start writes",
         })),
     })
         .prefault({}),
@@ -1030,6 +1044,46 @@ export const KernelConfigSchema = z.object({
             .prefault({}),
     })
         .prefault({}),
+    schedules: z
+        .object({
+        minIntervalFloorMinutes: z
+            .number()
+            .int()
+            .positive()
+            .default(5)
+            .meta(meta({
+            hot: true,
+            description: "Smallest value an organization may set for the minimum gap between two fire times of a scheduled task, in minutes; a lower org value is clamped up to it",
+        })),
+        maxTasksPerMemberCap: z
+            .number()
+            .int()
+            .positive()
+            .default(100)
+            .meta(meta({
+            hot: true,
+            description: "Largest number of scheduled tasks per member an organization may allow; a higher org value is clamped down to it",
+        })),
+        maxTasksPerOrgCap: z
+            .number()
+            .int()
+            .positive()
+            .default(2000)
+            .meta(meta({
+            hot: true,
+            description: "Largest number of scheduled tasks per organization an organization may allow; a higher org value is clamped down to it",
+        })),
+        maxRunsPerHourCap: z
+            .number()
+            .int()
+            .positive()
+            .default(600)
+            .meta(meta({
+            hot: true,
+            description: "Largest number of scheduled task runs per organization per hour an organization may allow; a higher org value is clamped down to it",
+        })),
+    })
+        .prefault({}),
     sandbox: z
         .object({
         image: z
@@ -1151,10 +1205,14 @@ export const KernelConfigSchema = z.object({
                 description: "Minutes a device's instance may run continuously before it is suspended even while in use (skipped while a command is running)",
             })),
             egress: z
-                .enum(["none", "allowlist", "open"])
+                .enum(["none", "allowlist"], {
+                error: (iss) => iss.input === "open"
+                    ? 'sandbox.limits.egress no longer takes "open": open egress is the open sandbox tier now; set sandbox.tiers.max to "open" (and egress to "allowlist")'
+                    : undefined,
+            })
                 .default("allowlist")
                 .meta(meta({
-                description: "Outbound network from cloud device instances: none, allowlist (only allowHosts) or open; applies to instances created after the change, existing ones keep theirs until destroyed",
+                description: 'Outbound network of sandboxed devices: none (no tier reaches the network, the kill switch) or allowlist (strict reaches allowHosts, dev adds devHosts, open reaches any public host). Open egress is the open tier: set sandbox.tiers.max to "open"',
             })),
             allowHosts: z
                 .array(z.string())
@@ -1169,6 +1227,48 @@ export const KernelConfigSchema = z.object({
                 .meta(meta({
                 description: "Hosts cloud device instances may reach when egress is allowlist: lowercase hostnames, optional leading '*.', no IPs, ports or internal-only names; applies to instances created after the change",
             })),
+            devHosts: z
+                .array(z.string())
+                .default([...DEV_HOSTS])
+                .superRefine((hosts, ctx) => {
+                hosts.forEach((h, i) => {
+                    for (const message of validateAllowHost(h)) {
+                        ctx.addIssue({ code: "custom", path: [i], message: `${h}: ${message}` });
+                    }
+                });
+            })
+                .meta(meta({
+                description: "Hosts the dev sandbox tier adds to the allowlist (package registries, source hosts, tool downloads) when egress is allowlist; same format as allowHosts",
+            })),
+        })
+            .prefault({}),
+        tiers: z
+            .object({
+            max: z
+                .enum(["strict", "dev", "open"])
+                .default("dev")
+                .meta(meta({
+                hot: true,
+                description: "Highest sandbox tier any organization may reach: strict (the allowlist only), dev (adds devHosts and local development affordances) or open (any public host); organizations and devices choose at most this",
+            })),
+            default: z
+                .enum(["strict", "dev", "open"])
+                .default("dev")
+                .meta(meta({
+                hot: true,
+                description: "Sandbox tier of a device whose owner chose none, unless its organization sets its own default; at most sandbox.tiers.max",
+            })),
+            allowUnsandboxed: z
+                .boolean()
+                .default(true)
+                .meta(meta({
+                hot: true,
+                description: "Whether a local device may run commands without a sandbox (its owner's local choice); it only applies where the organization's ceiling is open, and an organization may forbid it",
+            })),
+        })
+            .refine((t) => tierAtMost(t.default, t.max), {
+            message: "sandbox.tiers.default must not be above sandbox.tiers.max",
+            path: ["default"],
         })
             .prefault({}),
     })

package/dist/conversations/conversations.service.d.ts

@@ -9,7 +9,9 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
 import type { KernelLogger } from "../log.js";
 import { ProviderRegistry } from "../runtime/providers.js";
+import type { ScheduleMarker } from "../schedules/types.js";
 import { type RenderedInvocation, SkillInvoker } from "../skills/invoke.js";
+import { type ApprovalRecord, ApprovalsService } from "../tools/approvals.service.js";
 import { ConnectorContent } from "../tools/connector-content.js";
 import { type QuestionRecord, QuestionsService } from "../tools/questions.service.js";
 import { ConversationAccess } from "./access.js";
@@ -46,6 +48,8 @@ export interface ConversationView {
      * sub-agent's is null: it works in its root conversation's.
      */
     deviceId: string | null;
+    /** The scheduled task that created it (a `new`-mode task's run); null otherwise (spec §4). */
+    scheduledTaskId: string | null;
     /**
      * What the latest run is doing: `running` (queued or running), `waiting` (an approval or a
      * question), else null. Only the list queries compute it; other responses carry null.
@@ -101,6 +105,17 @@ export interface SubagentView {
     pendingApprovalIds: string[];
     pendingQuestionIds: string[];
 }
+/**
+ * What a message skipped (reply-while-question spec §8.1, network ask-to-allow spec §6.7): its
+ * author's pending questions and network asks, and the highest seq the network skips wrote per
+ * conversation (a sub-agent's ask is in its own conversation).
+ */
+export interface ReplySkips {
+    questions: QuestionRecord[];
+    network: ApprovalRecord[];
+    seqs: ReadonlyMap<string, number>;
+}
+export declare const NO_REPLY_SKIPS: ReplySkips;
 /** 会话服务用到的运行控制：投递运行（RunQueue）与跨副本中止（RunAbort）。 */
 export interface RunControl {
     /** 有未消费的消息且没有进行中的运行时投递一轮运行；返回 runId 或 null。 */
@@ -185,6 +200,15 @@ export interface UserMessageInput {
      */
     im?: ImSenderContext;
 }
+/**
+ * Message options only kernel callers pass (a scheduled task's fire, scheduled tasks spec §6), never
+ * an HTTP body: the schedule marker the `user_message` carries and a zone that beats every other
+ * source of the message's `timeZone` (`readMessageContext`).
+ */
+export interface InternalMessageOptions {
+    schedule?: ScheduleMarker;
+    timeZoneOverride?: string;
+}
 /**
  * 会话：只有所有者可见；每次访问都实时复核 agent 对所有者仍可用（spec 3.6 R5），
  * 不可用时会话也按不存在处理（`conversation.not_found`）。
@@ -211,6 +235,8 @@ export declare class ConversationsService {
     private readonly devices;
     /** A starter's message skips the run's pending questions (reply-while-question spec §8.1). */
     private readonly questions;
+    /** ... and its pending network asks (network ask-to-allow spec §6.7). */
+    private readonly approvals;
     private readonly events;
     readonly txHost: TransactionHost;
     constructor(db: KernelDb, eventLog: EventLog, agents: Pick<AgentLookup, "get">, access: Pick<ConversationAccess, "isAccessible">, 
@@ -229,7 +255,9 @@ export declare class ConversationsService {
     /** The device a new conversation is bound to (environments spec §4.1 item 1). */
     devices: Pick<ConversationDevices, "forNew">, 
     /** A starter's message skips the run's pending questions (reply-while-question spec §8.1). */
-    questions: Pick<QuestionsService, "skipPendingIn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
+    questions: Pick<QuestionsService, "skipPendingIn">, 
+    /** ... and its pending network asks (network ask-to-allow spec §6.7). */
+    approvals: Pick<ApprovalsService, "skipNetworkIn">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost);
     /**
      * 不阻塞地调用一次 `ensureRun`（打开 SSE、读事件时）：它幂等，并顺带清理孤儿运行，
      * 会话不会因为某次运行结束后的投递失败而永远停在「运行中」。失败只记日志。
@@ -250,10 +278,12 @@ export declare class ConversationsService {
      * `agent.not_found` and nothing is written. Queues a run afterwards, like `postUserMessage`.
      * `events` are every event the create wrote, in seq order from seq 1 (a `model_switched` before
      * the message when the send switched), so a client can seed the new conversation's log whole.
+     * `internal` (kernel callers only): a scheduled task's marker, which also sets
+     * `conversations.scheduled_task_id`, and its zone override.
      */
     createWithMessage(orgId: string, accountId: string, agentId: string, input: UserMessageInput & {
         clientMessageId: string;
-    }, pick?: NewConversationDevice): Promise<{
+    }, pick?: NewConversationDevice, internal?: InternalMessageOptions): Promise<{
         conversation: ConversationView;
         event: ConversationEvent;
         events: ConversationEvent[];
@@ -418,18 +448,21 @@ export declare class ConversationsService {
     /**
      * Skips, in the caller's transaction (it wrote `accountId`'s message at `messageSeq` and holds the
      * conversation row lock), the pending questions that message closes (reply-while-question spec
-     * §8.1). The queue's "send now" uses it as the direct send does; announce after the commit with
-     * {@link announceSkipped}.
+     * §8.1) and the pending network asks of the author's runs, here and in the sub-agents'
+     * conversations (network ask-to-allow spec §6.7). The queue's "send now" uses it as the direct
+     * send does; announce after the commit with {@link announceSkipped}. `toSeq` is the highest seq
+     * written in this conversation (null: none).
      */
-    skipQuestionsIn(conversationId: string, accountId: string, messageSeq: number): Promise<{
-        records: QuestionRecord[];
+    skipWaitsIn(conversationId: string, accountId: string, messageSeq: number): Promise<{
+        skipped: ReplySkips;
         toSeq: number | null;
     }>;
     /**
-     * After the commit: announces each skipped question (`question.answered`, outcome `skipped`), so
-     * its run resumes (waits) and its IM card updates (channel jobs).
+     * After the commit: announces each skipped question (`question.answered`, outcome `skipped`) and
+     * network ask (`approval.decided`, status `skipped`; a sub-agent's conversation is notified
+     * first), so its run resumes (waits) and its IM card updates (channel jobs).
      */
-    announceSkipped(records: readonly QuestionRecord[]): Promise<void>;
+    announceSkipped(skipped: ReplySkips): Promise<void>;
     /**
      * Writes the message (preceded by its `model_switched` when it switches) inside `t` and updates
      * `conversations.selection`; returns the events written, in seq order (the `user_message`

package/dist/conversations/conversations.service.js

@@ -24,6 +24,7 @@ import { ProviderRegistry } from "../runtime/providers.js";
 import { RunControl as RunControlService } from "../runtime/run-control.js";
 import { rootConversationOf } from "../runtime/subagents/child.js";
 import { SkillInvoker } from "../skills/invoke.js";
+import { ApprovalsService } from "../tools/approvals.service.js";
 import { ConnectorContent } from "../tools/connector-content.js";
 import { QuestionsService } from "../tools/questions.service.js";
 import { ConversationAccess, parentReachable } from "./access.js";
@@ -56,6 +57,7 @@ function activitySql(ref) {
   )`;
 }
 const notFound = () => new ApiError("conversation.not_found", "Conversation not found");
+export const NO_REPLY_SKIPS = { questions: [], network: [], seqs: new Map() };
 export { userMessageIdemKey } from "./idem-keys.js";
 const COLUMNS = [
     "id",
@@ -72,6 +74,7 @@ const COLUMNS = [
     "subagent_type",
     "archived_at",
     "device_id",
+    "scheduled_task_id",
 ];
 function toView(r) {
     return {
@@ -89,6 +92,7 @@ function toView(r) {
         subagentType: r.subagent_type,
         archivedAt: r.archived_at,
         deviceId: r.device_id,
+        scheduledTaskId: r.scheduled_task_id,
         activity: r.activity ?? null,
     };
 }
@@ -133,6 +137,7 @@ let ConversationsService = class ConversationsService {
     background;
     devices;
     questions;
+    approvals;
     events;
     txHost;
     constructor(db, eventLog, agents, access, 
@@ -151,7 +156,9 @@ let ConversationsService = class ConversationsService {
     /** The device a new conversation is bound to (environments spec §4.1 item 1). */
     devices, 
     /** A starter's message skips the run's pending questions (reply-while-question spec §8.1). */
-    questions, events, txHost) {
+    questions, 
+    /** ... and its pending network asks (network ask-to-allow spec §6.7). */
+    approvals, events, txHost) {
         this.db = db;
         this.eventLog = eventLog;
         this.agents = agents;
@@ -165,6 +172,7 @@ let ConversationsService = class ConversationsService {
         this.background = background;
         this.devices = devices;
         this.questions = questions;
+        this.approvals = approvals;
         this.events = events;
         this.txHost = txHost;
     }
@@ -207,8 +215,10 @@ let ConversationsService = class ConversationsService {
      * `agent.not_found` and nothing is written. Queues a run afterwards, like `postUserMessage`.
      * `events` are every event the create wrote, in seq order from seq 1 (a `model_switched` before
      * the message when the send switched), so a client can seed the new conversation's log whole.
+     * `internal` (kernel callers only): a scheduled task's marker, which also sets
+     * `conversations.scheduled_task_id`, and its zone override.
      */
-    async createWithMessage(orgId, accountId, agentId, input, pick = {}) {
+    async createWithMessage(orgId, accountId, agentId, input, pick = {}, internal = {}) {
         const agent = await this.agents.get(orgId, agentId, accountId);
         const prior = await this.findCreated(orgId, accountId, agentId, input.clientMessageId);
         if (prior)
@@ -218,7 +228,7 @@ let ConversationsService = class ConversationsService {
         const extra = await this.resolveExtra(orgId, accountId, input);
         const invoked = await this.prepareSkill(orgId, agentId, undefined, agent.definition, input);
         const id = randomUUID();
-        const all = await this.createIn({ id, orgId, accountId, agentId, deviceId }, input, next, extra, invoked);
+        const all = await this.createIn({ id, orgId, accountId, agentId, deviceId }, input, next, extra, invoked, internal);
         const written = all?.at(-1);
         if (!all || !written) {
             const raced = await this.findCreated(orgId, accountId, agentId, input.clientMessageId);
@@ -232,7 +242,7 @@ let ConversationsService = class ConversationsService {
     }
     /** The conversation row and its first message (undefined: a concurrent retry committed first). */
     // its own transaction: the caller notifies and publishes after the commit
-    async createIn(conv, input, next, extra, invoked) {
+    async createIn(conv, input, next, extra, invoked, internal) {
         const { id, orgId, accountId } = conv;
         const row = await this.db
             .insertInto("conversations")
@@ -243,6 +253,7 @@ let ConversationsService = class ConversationsService {
             account_id: accountId,
             device_id: conv.deviceId,
             create_request_id: input.clientMessageId,
+            scheduled_task_id: internal.schedule?.taskId ?? null,
         })
             .onConflict((oc) => oc
             .columns(["org_id", "account_id", "create_request_id"])
@@ -255,8 +266,7 @@ let ConversationsService = class ConversationsService {
             return undefined;
         const blocks = await this.bindIn(orgId, id, accountId, input.files ?? []);
         // a new conversation has no run yet, so nothing to skip
-        return (await this.writeMessage(orgId, id, accountId, input, next, extra, blocks, invoked))
-            .events;
+        return (await this.writeMessage(orgId, id, accountId, input, next, extra, blocks, invoked, internal)).events;
     }
     /**
      * The conversation (and its first event) an earlier first send with this id created. The id used
@@ -494,14 +504,14 @@ let ConversationsService = class ConversationsService {
       SELECT page.agent_id, page.latest_at, v.definition ->> 'name' AS agent_name,
         a.profile_avatar, a.profile_updated_at, cs.id, cs.org_id, cs.account_id, cs.title, cs.title_source, cs.selection, cs.last_seq,
         cs.created_at, cs.updated_at, cs.parent_conversation_id, cs.subagent_type,
-        cs.archived_at, cs.device_id, cs.activity
+        cs.archived_at, cs.device_id, cs.scheduled_task_id, cs.activity
       FROM page
       JOIN capybara.agents a ON a.id = page.agent_id
       JOIN capybara.agent_versions v ON v.agent_id = a.id AND v.version = a.current_version
       CROSS JOIN LATERAL (
         SELECT c.id, c.org_id, c.account_id, c.title, c.title_source, c.selection, c.last_seq,
           c.created_at, c.updated_at, c.parent_conversation_id, c.subagent_type,
-          c.archived_at, c.device_id, ${activitySql("c")} AS activity
+          c.archived_at, c.device_id, c.scheduled_task_id, ${activitySql("c")} AS activity
         FROM capybara.conversations c
         WHERE c.org_id = ${orgId} AND c.account_id = ${accountId} AND c.kind = 'chat'
           AND c.deleted_at IS NULL AND ${archivedFilter} ${searchFilter} ${stateFilter}
@@ -798,18 +808,25 @@ let ConversationsService = class ConversationsService {
     /**
      * Skips, in the caller's transaction (it wrote `accountId`'s message at `messageSeq` and holds the
      * conversation row lock), the pending questions that message closes (reply-while-question spec
-     * §8.1). The queue's "send now" uses it as the direct send does; announce after the commit with
-     * {@link announceSkipped}.
+     * §8.1) and the pending network asks of the author's runs, here and in the sub-agents'
+     * conversations (network ask-to-allow spec §6.7). The queue's "send now" uses it as the direct
+     * send does; announce after the commit with {@link announceSkipped}. `toSeq` is the highest seq
+     * written in this conversation (null: none).
      */
-    async skipQuestionsIn(conversationId, accountId, messageSeq) {
-        return this.questions.skipPendingIn(conversationId, accountId, messageSeq);
+    async skipWaitsIn(conversationId, accountId, messageSeq) {
+        const q = await this.questions.skipPendingIn(conversationId, accountId, messageSeq);
+        const n = await this.approvals.skipNetworkIn(conversationId, accountId);
+        const here = n.seqs.get(conversationId);
+        const toSeq = q.toSeq === null && here === undefined ? null : Math.max(q.toSeq ?? 0, here ?? 0);
+        return { skipped: { questions: q.records, network: n.records, seqs: n.seqs }, toSeq };
     }
     /**
-     * After the commit: announces each skipped question (`question.answered`, outcome `skipped`), so
-     * its run resumes (waits) and its IM card updates (channel jobs).
+     * After the commit: announces each skipped question (`question.answered`, outcome `skipped`) and
+     * network ask (`approval.decided`, status `skipped`; a sub-agent's conversation is notified
+     * first), so its run resumes (waits) and its IM card updates (channel jobs).
      */
-    async announceSkipped(records) {
-        for (const q of records) {
+    async announceSkipped(skipped) {
+        for (const q of skipped.questions) {
             await this.events.emit("question.answered", {
                 id: q.id,
                 orgId: q.orgId,
@@ -818,6 +835,18 @@ let ConversationsService = class ConversationsService {
                 outcome: "skipped",
             });
         }
+        for (const [conversationId, seq] of skipped.seqs) {
+            await this.eventLog.notify(conversationId, seq);
+        }
+        for (const a of skipped.network) {
+            await this.events.emit("approval.decided", {
+                id: a.id,
+                orgId: a.orgId,
+                conversationId: a.conversationId,
+                runId: a.runId,
+                status: "skipped",
+            });
+        }
     }
     /**
      * Writes the message (preceded by its `model_switched` when it switches) inside `t` and updates
@@ -826,7 +855,7 @@ let ConversationsService = class ConversationsService {
      * questions its author may answer (reply-while-question spec §8.1): `skipped` and the highest
      * seq their events took. The caller notifies and emits `question.answered` after commit.
      */
-    async writeMessage(orgId, conversationId, accountId, input, next, extra, blocks, invoked) {
+    async writeMessage(orgId, conversationId, accountId, input, next, extra, blocks, invoked, internal = {}) {
         const events = [];
         if (next !== null) {
             events.push({
@@ -843,13 +872,14 @@ let ConversationsService = class ConversationsService {
             senderName: input.senderName,
             browser: { timeZone: input.timeZone, locale: input.locale },
             im: input.im,
+            timeZoneOverride: internal.timeZoneOverride,
         });
-        events.push(this.userMessage(accountId, input, extra, blocks, invoked, context));
+        events.push(this.userMessage(accountId, input, extra, blocks, invoked, context, internal.schedule));
         const { events: written, fresh } = await this.eventLog.appendInReport(conversationId, events);
         const message = written.at(-1);
         const skips = fresh.at(-1) === true
-            ? await this.skipQuestionsIn(conversationId, accountId, message.seq)
-            : { records: [], toSeq: null };
+            ? await this.skipWaitsIn(conversationId, accountId, message.seq)
+            : { skipped: NO_REPLY_SKIPS, toSeq: null };
         if (next !== null) {
             const t = this.db.db;
             // the cache follows the log (a retried message's switch may be an old, deduped event that a
@@ -860,7 +890,7 @@ let ConversationsService = class ConversationsService {
                 .where("id", "=", conversationId)
                 .execute();
         }
-        return { events: written, skipped: skips.records, skippedToSeq: skips.toSeq };
+        return { events: written, skipped: skips.skipped, skippedToSeq: skips.toSeq };
     }
     /**
      * Renders the message's skill invocation (phase D), or undefined when it has none. Resolved
@@ -905,7 +935,7 @@ let ConversationsService = class ConversationsService {
             return [];
         return this.attachments.bindForMessage(orgId, conversationId, accountId, files);
     }
-    userMessage(accountId, input, extra, fileBlocks, invoked, context) {
+    userMessage(accountId, input, extra, fileBlocks, invoked, context, schedule) {
         // a skill invocation's rendered text replaces the typed arguments as content[0]
         const text = invoked?.text ?? input.text;
         return {
@@ -926,6 +956,7 @@ let ConversationsService = class ConversationsService {
                 ...(input.clientMessageId !== undefined && { clientMessageId: input.clientMessageId }),
                 ...(input.retryOf !== undefined && { retryOf: input.retryOf }),
                 ...(invoked !== undefined && { skill: invoked.skill }),
+                ...(schedule !== undefined && { schedule }),
             },
         };
     }
@@ -988,7 +1019,7 @@ __decorate([
 ], ConversationsService.prototype, "postIn", null);
 __decorate([
     Transactional({ propagation: "mandatory" })
-], ConversationsService.prototype, "skipQuestionsIn", null);
+], ConversationsService.prototype, "skipWaitsIn", null);
 __decorate([
     Transactional({ propagation: "mandatory" })
 ], ConversationsService.prototype, "writeMessage", null);
@@ -1010,7 +1041,8 @@ ConversationsService = __decorate([
     __param(10, Inject(BackgroundTaskStopper)),
     __param(11, Inject(ConversationDevices)),
     __param(12, Inject(QuestionsService)),
-    __param(13, Inject(KernelEvents)),
-    __param(14, Inject(TransactionHost))
+    __param(13, Inject(ApprovalsService)),
+    __param(14, Inject(KernelEvents)),
+    __param(15, Inject(TransactionHost))
 ], ConversationsService);
 export { ConversationsService };