@poolzin/pool-bot 2026.2.0 → 2026.2.1

package/dist/config/zod-schema.providers-core.js

@@ -25,6 +25,7 @@ export const TelegramTopicSchema = z
 export const TelegramGroupSchema = z
     .object({
     requireMention: z.boolean().optional(),
+    groupPolicy: GroupPolicySchema.optional(),
     tools: ToolPolicySchema,
     toolsBySender: ToolPolicyBySenderSchema,
     skills: z.array(z.string()).optional(),
@@ -108,6 +109,7 @@ export const TelegramAccountSchemaBase = z
     reactionLevel: z.enum(["off", "ack", "minimal", "extensive"]).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
     linkPreview: z.boolean().optional(),
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const TelegramAccountSchema = TelegramAccountSchemaBase.superRefine((value, ctx) => {
@@ -131,6 +133,38 @@ export const TelegramConfigSchema = TelegramAccountSchemaBase.extend({
         message: 'channels.telegram.dmPolicy="open" requires channels.telegram.allowFrom to include "*"',
     });
     validateTelegramCustomCommands(value, ctx);
+    const baseWebhookUrl = typeof value.webhookUrl === "string" ? value.webhookUrl.trim() : "";
+    const baseWebhookSecret = typeof value.webhookSecret === "string" ? value.webhookSecret.trim() : "";
+    if (baseWebhookUrl && !baseWebhookSecret) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "channels.telegram.webhookUrl requires channels.telegram.webhookSecret",
+            path: ["webhookSecret"],
+        });
+    }
+    if (!value.accounts) {
+        return;
+    }
+    for (const [accountId, account] of Object.entries(value.accounts)) {
+        if (!account) {
+            continue;
+        }
+        if (account.enabled === false) {
+            continue;
+        }
+        const accountWebhookUrl = typeof account.webhookUrl === "string" ? account.webhookUrl.trim() : "";
+        if (!accountWebhookUrl) {
+            continue;
+        }
+        const accountSecret = typeof account.webhookSecret === "string" ? account.webhookSecret.trim() : "";
+        if (!accountSecret && !baseWebhookSecret) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "channels.telegram.accounts.*.webhookUrl requires channels.telegram.webhookSecret or channels.telegram.accounts.*.webhookSecret",
+                path: ["accounts", accountId, "webhookSecret"],
+            });
+        }
+    }
 });
 export const DiscordDmSchema = z
     .object({
@@ -160,6 +194,7 @@ export const DiscordGuildChannelSchema = z
     enabled: z.boolean().optional(),
     users: z.array(z.union([z.string(), z.number()])).optional(),
     systemPrompt: z.string().optional(),
+    includeThreadStarter: z.boolean().optional(),
     autoThread: z.boolean().optional(),
 })
     .strict();
@@ -215,6 +250,7 @@ export const DiscordAccountSchema = z
         events: z.boolean().optional(),
         moderation: z.boolean().optional(),
         channels: z.boolean().optional(),
+        presence: z.boolean().optional(),
     })
         .strict()
         .optional(),
@@ -228,6 +264,7 @@ export const DiscordAccountSchema = z
         approvers: z.array(z.union([z.string(), z.number()])).optional(),
         agentFilter: z.array(z.string()).optional(),
         sessionFilter: z.array(z.string()).optional(),
+        cleanupAfterResolve: z.boolean().optional(),
     })
         .strict()
         .optional(),
@@ -238,6 +275,14 @@ export const DiscordAccountSchema = z
     })
         .strict()
         .optional(),
+    pluralkit: z
+        .object({
+        enabled: z.boolean().optional(),
+        token: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const DiscordConfigSchema = DiscordAccountSchema.extend({
@@ -303,6 +348,7 @@ export const GoogleChatAccountSchema = z
         .optional(),
     dm: GoogleChatDmSchema.optional(),
     typingIndicator: z.enum(["none", "message", "reaction"]).optional(),
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const GoogleChatConfigSchema = GoogleChatAccountSchema.extend({
@@ -410,6 +456,7 @@ export const SlackAccountSchema = z
     dm: SlackDmSchema.optional(),
     channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const SlackConfigSchema = SlackAccountSchema.extend({
@@ -486,6 +533,7 @@ export const SignalAccountSchemaBase = z
         .optional(),
     reactionLevel: z.enum(["off", "ack", "minimal", "extensive"]).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const SignalAccountSchema = SignalAccountSchemaBase.superRefine((value, ctx) => {
@@ -508,6 +556,96 @@ export const SignalConfigSchema = SignalAccountSchemaBase.extend({
         message: 'channels.signal.dmPolicy="open" requires channels.signal.allowFrom to include "*"',
     });
 });
+export const IrcGroupSchema = z
+    .object({
+    requireMention: z.boolean().optional(),
+    tools: ToolPolicySchema,
+    toolsBySender: ToolPolicyBySenderSchema,
+    skills: z.array(z.string()).optional(),
+    enabled: z.boolean().optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    systemPrompt: z.string().optional(),
+})
+    .strict();
+export const IrcNickServSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    service: z.string().optional(),
+    password: z.string().optional(),
+    passwordFile: z.string().optional(),
+    register: z.boolean().optional(),
+    registerEmail: z.string().optional(),
+})
+    .strict();
+export const IrcAccountSchemaBase = z
+    .object({
+    name: z.string().optional(),
+    capabilities: z.array(z.string()).optional(),
+    markdown: MarkdownConfigSchema,
+    enabled: z.boolean().optional(),
+    configWrites: z.boolean().optional(),
+    host: z.string().optional(),
+    port: z.number().int().min(1).max(65535).optional(),
+    tls: z.boolean().optional(),
+    nick: z.string().optional(),
+    username: z.string().optional(),
+    realname: z.string().optional(),
+    password: z.string().optional(),
+    passwordFile: z.string().optional(),
+    nickserv: IrcNickServSchema.optional(),
+    channels: z.array(z.string()).optional(),
+    dmPolicy: DmPolicySchema.optional().default("pairing"),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+    groups: z.record(z.string(), IrcGroupSchema.optional()).optional(),
+    mentionPatterns: z.array(z.string()).optional(),
+    historyLimit: z.number().int().min(0).optional(),
+    dmHistoryLimit: z.number().int().min(0).optional(),
+    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
+    textChunkLimit: z.number().int().positive().optional(),
+    chunkMode: z.enum(["length", "newline"]).optional(),
+    blockStreaming: z.boolean().optional(),
+    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+    mediaMaxMb: z.number().positive().optional(),
+    heartbeat: ChannelHeartbeatVisibilitySchema,
+    responsePrefix: z.string().optional(),
+})
+    .strict();
+export const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) => {
+    requireOpenAllowFrom({
+        policy: value.dmPolicy,
+        allowFrom: value.allowFrom,
+        ctx,
+        path: ["allowFrom"],
+        message: 'channels.irc.dmPolicy="open" requires channels.irc.allowFrom to include "*"',
+    });
+    if (value.nickserv?.register && !value.nickserv.registerEmail?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["nickserv", "registerEmail"],
+            message: "channels.irc.nickserv.register=true requires channels.irc.nickserv.registerEmail",
+        });
+    }
+});
+export const IrcConfigSchema = IrcAccountSchemaBase.extend({
+    accounts: z.record(z.string(), IrcAccountSchema.optional()).optional(),
+}).superRefine((value, ctx) => {
+    requireOpenAllowFrom({
+        policy: value.dmPolicy,
+        allowFrom: value.allowFrom,
+        ctx,
+        path: ["allowFrom"],
+        message: 'channels.irc.dmPolicy="open" requires channels.irc.allowFrom to include "*"',
+    });
+    if (value.nickserv?.register && !value.nickserv.registerEmail?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["nickserv", "registerEmail"],
+            message: "channels.irc.nickserv.register=true requires channels.irc.nickserv.registerEmail",
+        });
+    }
+});
 export const IMessageAccountSchemaBase = z
     .object({
     name: z.string().optional(),
@@ -544,6 +682,7 @@ export const IMessageAccountSchemaBase = z
         .optional())
         .optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const IMessageAccountSchema = IMessageAccountSchemaBase.superRefine((value, ctx) => {
@@ -615,6 +754,7 @@ export const BlueBubblesAccountSchemaBase = z
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
     groups: z.record(z.string(), BlueBubblesGroupConfigSchema.optional()).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    responsePrefix: z.string().optional(),
 })
     .strict();
 export const BlueBubblesAccountSchema = BlueBubblesAccountSchemaBase.superRefine((value, ctx) => {
@@ -679,6 +819,7 @@ export const MSTeamsConfigSchema = z
     chunkMode: z.enum(["length", "newline"]).optional(),
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
     mediaAllowHosts: z.array(z.string()).optional(),
+    mediaAuthAllowHosts: z.array(z.string()).optional(),
     requireMention: z.boolean().optional(),
     historyLimit: z.number().int().min(0).optional(),
     dmHistoryLimit: z.number().int().min(0).optional(),
@@ -690,6 +831,7 @@ export const MSTeamsConfigSchema = z
     /** SharePoint site ID for file uploads in group chats/channels (e.g., "contoso.sharepoint.com,guid1,guid2") */
     sharePointSiteId: z.string().optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
+    responsePrefix: z.string().optional(),
 })
     .strict()
     .superRefine((value, ctx) => {

package/dist/config/zod-schema.session.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ElevatedAllowFromSchema } from "./zod-schema.agent-runtime.js";
 import { GroupChatSchema, InboundDebounceSchema, NativeCommandsSettingSchema, QueueSchema, TtsConfigSchema, } from "./zod-schema.core.js";
 const SessionResetConfigSchema = z
     .object({
@@ -94,6 +95,8 @@ export const CommandsSchema = z
     debug: z.boolean().optional(),
     restart: z.boolean().optional(),
     useAccessGroups: z.boolean().optional(),
+    ownerAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    allowFrom: ElevatedAllowFromSchema.optional(),
 })
     .strict()
     .optional()

package/dist/cron/delivery.js

@@ -0,0 +1,57 @@
+function normalizeChannel(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed;
+}
+function normalizeTo(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function resolveCronDeliveryPlan(job) {
+    const payload = job.payload.kind === "agentTurn" ? job.payload : null;
+    const delivery = job.delivery;
+    const hasDelivery = delivery && typeof delivery === "object";
+    const rawMode = hasDelivery ? delivery.mode : undefined;
+    const normalizedMode = typeof rawMode === "string" ? rawMode.trim().toLowerCase() : rawMode;
+    const mode = normalizedMode === "announce"
+        ? "announce"
+        : normalizedMode === "none"
+            ? "none"
+            : normalizedMode === "deliver"
+                ? "announce"
+                : undefined;
+    const payloadChannel = normalizeChannel(payload?.channel);
+    const payloadTo = normalizeTo(payload?.to);
+    const deliveryChannel = normalizeChannel(delivery?.channel);
+    const deliveryTo = normalizeTo(delivery?.to);
+    const channel = deliveryChannel ?? payloadChannel ?? "last";
+    const to = deliveryTo ?? payloadTo;
+    if (hasDelivery) {
+        const resolvedMode = mode ?? "announce";
+        return {
+            mode: resolvedMode,
+            channel,
+            to,
+            source: "delivery",
+            requested: resolvedMode === "announce",
+        };
+    }
+    const legacyMode = payload?.deliver === true ? "explicit" : payload?.deliver === false ? "off" : "auto";
+    const hasExplicitTarget = Boolean(to);
+    const requested = legacyMode === "explicit" || (legacyMode === "auto" && hasExplicitTarget);
+    return {
+        mode: requested ? "announce" : "none",
+        channel,
+        to,
+        source: "payload",
+        requested,
+    };
+}

package/dist/cron/isolated-agent/delivery-target.js

@@ -5,6 +5,7 @@ import { resolveOutboundTarget, resolveSessionDeliveryTarget, } from "../../infr
 export async function resolveDeliveryTarget(cfg, agentId, jobPayload) {
     const requestedChannel = typeof jobPayload.channel === "string" ? jobPayload.channel : "last";
     const explicitTo = typeof jobPayload.to === "string" ? jobPayload.to : undefined;
+    const allowMismatchedLastTo = requestedChannel === "last";
     const sessionCfg = cfg.session;
     const mainSessionKey = resolveAgentMainSessionKey({ cfg, agentId });
     const storePath = resolveStorePath(sessionCfg?.store, { agentId });
@@ -14,7 +15,7 @@ export async function resolveDeliveryTarget(cfg, agentId, jobPayload) {
         entry: main,
         requestedChannel,
         explicitTo,
-        allowMismatchedLastTo: true,
+        allowMismatchedLastTo,
     });
     let fallbackChannel;
     if (!preliminary.channel) {
@@ -32,15 +33,28 @@ export async function resolveDeliveryTarget(cfg, agentId, jobPayload) {
             requestedChannel,
             explicitTo,
             fallbackChannel,
-            allowMismatchedLastTo: true,
+            allowMismatchedLastTo,
             mode: preliminary.mode,
         })
         : preliminary;
     const channel = resolved.channel ?? fallbackChannel ?? DEFAULT_CHAT_CHANNEL;
     const mode = resolved.mode;
     const toCandidate = resolved.to;
+    // Only carry threadId when delivering to the same recipient as the session's
+    // last conversation. This prevents stale thread IDs (e.g. from a Telegram
+    // supergroup topic) from being sent to a different target (e.g. a private
+    // chat) where they would cause API errors.
+    const threadId = resolved.threadId && resolved.to && resolved.to === resolved.lastTo
+        ? resolved.threadId
+        : undefined;
     if (!toCandidate) {
-        return { channel, to: undefined, accountId: resolved.accountId, mode };
+        return {
+            channel,
+            to: undefined,
+            accountId: resolved.accountId,
+            threadId,
+            mode,
+        };
     }
     const docked = resolveOutboundTarget({
         channel,
@@ -53,6 +67,7 @@ export async function resolveDeliveryTarget(cfg, agentId, jobPayload) {
         channel,
         to: docked.ok ? docked.to : undefined,
         accountId: resolved.accountId,
+        threadId,
         mode,
         error: docked.ok ? undefined : docked.error,
     };

package/dist/cron/isolated-agent/helpers.js

@@ -2,24 +2,39 @@ import { DEFAULT_HEARTBEAT_ACK_MAX_CHARS, stripHeartbeatToken, } from "../../aut
 import { truncateUtf16Safe } from "../../utils.js";
 export function pickSummaryFromOutput(text) {
     const clean = (text ?? "").trim();
-    if (!clean)
+    if (!clean) {
         return undefined;
+    }
     const limit = 2000;
     return clean.length > limit ? `${truncateUtf16Safe(clean, limit)}…` : clean;
 }
 export function pickSummaryFromPayloads(payloads) {
     for (let i = payloads.length - 1; i >= 0; i--) {
         const summary = pickSummaryFromOutput(payloads[i]?.text);
-        if (summary)
+        if (summary) {
             return summary;
+        }
     }
     return undefined;
 }
 export function pickLastNonEmptyTextFromPayloads(payloads) {
     for (let i = payloads.length - 1; i >= 0; i--) {
         const clean = (payloads[i]?.text ?? "").trim();
-        if (clean)
+        if (clean) {
             return clean;
+        }
+    }
+    return undefined;
+}
+export function pickLastDeliverablePayload(payloads) {
+    for (let i = payloads.length - 1; i >= 0; i--) {
+        const payload = payloads[i];
+        const text = (payload?.text ?? "").trim();
+        const hasMedia = Boolean(payload?.mediaUrl) || (payload?.mediaUrls?.length ?? 0) > 0;
+        const hasChannelData = Object.keys(payload?.channelData ?? {}).length > 0;
+        if (text || hasMedia || hasChannelData) {
+            return payload;
+        }
     }
     return undefined;
 }
@@ -28,13 +43,15 @@ export function pickLastNonEmptyTextFromPayloads(payloads) {
  * Returns true if delivery should be skipped because there's no real content.
  */
 export function isHeartbeatOnlyResponse(payloads, ackMaxChars) {
-    if (payloads.length === 0)
+    if (payloads.length === 0) {
         return true;
+    }
     return payloads.every((payload) => {
         // If there's media, we should deliver regardless of text content.
         const hasMedia = (payload.mediaUrls?.length ?? 0) > 0 || Boolean(payload.mediaUrl);
-        if (hasMedia)
+        if (hasMedia) {
             return false;
+        }
         // Use heartbeat mode to check if text is just HEARTBEAT_OK or short ack.
         const result = stripHeartbeatToken(payload.text, {
             mode: "heartbeat",