@poolzin/pool-bot 2026.3.4 → 2026.3.6

package/dist/agents/tools/pdf-tool.js

@@ -0,0 +1,508 @@
+import path from "node:path";
+import { complete } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { resolveUserPath } from "../../utils.js";
+import { getDefaultLocalRoots, loadWebMedia } from "../../web/media.js";
+import { ensureAuthProfileStore, listProfilesForProvider } from "../auth-profiles.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
+import { getApiKeyForModel, requireApiKey, resolveEnvApiKey } from "../model-auth.js";
+import { runWithImageModelFallback } from "../model-fallback.js";
+import { resolveConfiguredModelRef } from "../model-selection.js";
+import { ensurePoolbotModelsJson } from "../models-config.js";
+import { discoverAuthStorage, discoverModels } from "../pi-model-discovery.js";
+import { normalizeWorkspaceDir } from "../workspace-dir.js";
+import { resolveProviderVisionModelFromConfig } from "./image-tool.helpers.js";
+import { anthropicAnalyzePdf, geminiAnalyzePdf } from "./pdf-native-providers.js";
+import { extractPdfContent, normalizeMimeType, resolveInputFileLimits, } from "../../media/input-files.js";
+import { coercePdfAssistantText, coercePdfModelConfig, parsePageRange, providerSupportsNativePdf, resolvePdfToolMaxTokens, } from "./pdf-tool.helpers.js";
+const DEFAULT_PROMPT = "Analyze the PDF document.";
+const ANTHROPIC_PDF_PRIMARY = "anthropic/claude-opus-4-6";
+const ANTHROPIC_PDF_FALLBACK = "anthropic/claude-opus-4-5";
+const DEFAULT_MAX_PDFS = 10;
+export const __testing = {
+    coercePdfAssistantText,
+    resolvePdfToolMaxTokens,
+};
+function resolveDefaultModelRef(cfg) {
+    if (cfg) {
+        const resolved = resolveConfiguredModelRef({
+            cfg,
+            defaultProvider: DEFAULT_PROVIDER,
+            defaultModel: DEFAULT_MODEL,
+        });
+        return { provider: resolved.provider, model: resolved.model };
+    }
+    return { provider: DEFAULT_PROVIDER, model: DEFAULT_MODEL };
+}
+function hasAuthForProvider(params) {
+    if (resolveEnvApiKey(params.provider)?.apiKey) {
+        return true;
+    }
+    const store = ensureAuthProfileStore(params.agentDir, {
+        allowKeychainPrompt: false,
+    });
+    return listProfilesForProvider(store, params.provider).length > 0;
+}
+/**
+ * Resolve the effective PDF model config for the `pdf` tool.
+ *
+ * - Prefer explicit config (`agents.defaults.pdfModel`).
+ * - Otherwise, try to "pair" the primary model with a PDF-capable model:
+ *   - same provider (best effort)
+ *   - fall back to OpenAI/Anthropic when available
+ */
+export function resolvePdfModelConfigForTool(params) {
+    const explicit = coercePdfModelConfig(params.cfg);
+    if (explicit.primary?.trim() || (explicit.fallbacks?.length ?? 0) > 0) {
+        return explicit;
+    }
+    const primary = resolveDefaultModelRef(params.cfg);
+    const openaiOk = hasAuthForProvider({
+        provider: "openai",
+        agentDir: params.agentDir,
+    });
+    const anthropicOk = hasAuthForProvider({
+        provider: "anthropic",
+        agentDir: params.agentDir,
+    });
+    const fallbacks = [];
+    const addFallback = (modelRef) => {
+        const ref = (modelRef ?? "").trim();
+        if (!ref) {
+            return;
+        }
+        if (fallbacks.includes(ref)) {
+            return;
+        }
+        fallbacks.push(ref);
+    };
+    const providerVisionFromConfig = resolveProviderVisionModelFromConfig({
+        cfg: params.cfg,
+        provider: primary.provider,
+    });
+    const providerOk = hasAuthForProvider({
+        provider: primary.provider,
+        agentDir: params.agentDir,
+    });
+    let preferred = null;
+    if (providerOk && providerVisionFromConfig) {
+        preferred = providerVisionFromConfig;
+    }
+    else if (primary.provider === "openai" && openaiOk) {
+        preferred = "openai/gpt-5-mini";
+    }
+    else if (primary.provider === "anthropic" && anthropicOk) {
+        preferred = ANTHROPIC_PDF_PRIMARY;
+    }
+    if (preferred?.trim()) {
+        if (openaiOk) {
+            addFallback("openai/gpt-5-mini");
+        }
+        if (anthropicOk) {
+            addFallback(ANTHROPIC_PDF_FALLBACK);
+        }
+        // Don't duplicate primary in fallbacks.
+        const pruned = fallbacks.filter((ref) => ref !== preferred);
+        return {
+            primary: preferred,
+            ...(pruned.length > 0 ? { fallbacks: pruned } : {}),
+        };
+    }
+    // Cross-provider fallback when we can't pair with the primary provider.
+    if (openaiOk) {
+        if (anthropicOk) {
+            addFallback(ANTHROPIC_PDF_FALLBACK);
+        }
+        return {
+            primary: "openai/gpt-5-mini",
+            ...(fallbacks.length ? { fallbacks } : {}),
+        };
+    }
+    if (anthropicOk) {
+        return {
+            primary: ANTHROPIC_PDF_PRIMARY,
+            fallbacks: [ANTHROPIC_PDF_FALLBACK],
+        };
+    }
+    return null;
+}
+function pickMaxBytes(cfg, maxBytesMb) {
+    if (typeof maxBytesMb === "number" && Number.isFinite(maxBytesMb) && maxBytesMb > 0) {
+        return Math.floor(maxBytesMb * 1024 * 1024);
+    }
+    const configured = cfg?.agents?.defaults?.mediaMaxMb;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+        return Math.floor(configured * 1024 * 1024);
+    }
+    return undefined;
+}
+function buildPdfContext(prompt, extractedText, images) {
+    const content = [];
+    // Build text block: prompt + extracted text
+    const textBlock = extractedText.trim()
+        ? `${prompt}\n\n--- Extracted PDF Text ---\n${extractedText}\n--- End Extracted PDF Text ---`
+        : prompt;
+    content.push({ type: "text", text: textBlock });
+    // Add rendered page images
+    for (const img of images) {
+        content.push({ type: "image", data: img.data, mimeType: img.mimeType });
+    }
+    return {
+        messages: [
+            {
+                role: "user",
+                content,
+                timestamp: Date.now(),
+            },
+        ],
+    };
+}
+async function resolveSandboxedPdfPath(params) {
+    const normalize = (p) => (p.startsWith("file://") ? p.slice("file://".length) : p);
+    const filePath = normalize(params.pdfPath);
+    try {
+        const resolved = params.sandbox.bridge.resolvePath({
+            filePath,
+            cwd: params.sandbox.root,
+        });
+        return { resolved: resolved.hostPath };
+    }
+    catch (err) {
+        const name = path.basename(filePath);
+        const candidateRel = path.join("media", "inbound", name);
+        try {
+            const stat = await params.sandbox.bridge.stat({
+                filePath: candidateRel,
+                cwd: params.sandbox.root,
+            });
+            if (!stat) {
+                throw err;
+            }
+        }
+        catch {
+            throw err;
+        }
+        const out = params.sandbox.bridge.resolvePath({
+            filePath: candidateRel,
+            cwd: params.sandbox.root,
+        });
+        return { resolved: out.hostPath, rewrittenFrom: filePath };
+    }
+}
+async function runPdfPrompt(params) {
+    // Overlay pdfModelConfig onto cfg.agents.defaults.imageModel so
+    // runWithImageModelFallback reads our PDF-specific model cascade.
+    const effectiveCfg = params.cfg
+        ? {
+            ...params.cfg,
+            agents: {
+                ...params.cfg.agents,
+                defaults: {
+                    ...params.cfg.agents?.defaults,
+                    imageModel: params.pdfModelConfig,
+                },
+            },
+        }
+        : undefined;
+    await ensurePoolbotModelsJson(effectiveCfg, params.agentDir);
+    const authStorage = discoverAuthStorage(params.agentDir);
+    const modelRegistry = discoverModels(authStorage, params.agentDir);
+    const result = await runWithImageModelFallback({
+        cfg: effectiveCfg,
+        modelOverride: params.modelOverride,
+        run: async (provider, modelId) => {
+            const model = modelRegistry.find(provider, modelId);
+            if (!model) {
+                throw new Error(`Unknown model: ${provider}/${modelId}`);
+            }
+            const apiKeyInfo = await getApiKeyForModel({
+                model,
+                cfg: effectiveCfg,
+                agentDir: params.agentDir,
+            });
+            const apiKey = requireApiKey(apiKeyInfo, model.provider);
+            authStorage.setRuntimeApiKey(model.provider, apiKey);
+            // Native path: send raw PDF bytes to providers with native document support.
+            if (providerSupportsNativePdf(model.provider)) {
+                const pdfs = params.pdfBuffers.map((buf) => ({
+                    base64: buf.toString("base64"),
+                }));
+                if (model.provider === "anthropic") {
+                    const text = await anthropicAnalyzePdf({
+                        apiKey,
+                        modelId: model.id,
+                        prompt: params.prompt,
+                        pdfs,
+                        maxTokens: resolvePdfToolMaxTokens(model.maxTokens),
+                        baseUrl: model.baseUrl,
+                    });
+                    return { text, provider: model.provider, model: model.id };
+                }
+                if (model.provider === "google") {
+                    const text = await geminiAnalyzePdf({
+                        apiKey,
+                        modelId: model.id,
+                        prompt: params.prompt,
+                        pdfs,
+                        baseUrl: model.baseUrl,
+                    });
+                    return { text, provider: model.provider, model: model.id };
+                }
+            }
+            // Non-native fallback: extract text + optional page images, then send
+            // via pi-ai complete().
+            const limits = resolveInputFileLimits();
+            let allText = "";
+            let allImages = [];
+            for (const buf of params.pdfBuffers) {
+                const extracted = await extractPdfContent({
+                    buffer: buf,
+                    limits,
+                    pageNumbers: params.pageNumbers,
+                });
+                if (extracted.text) {
+                    allText += (allText ? "\n\n" : "") + extracted.text;
+                }
+                allImages.push(...extracted.images);
+            }
+            // If model doesn't support images, proceed text-only (don't error).
+            if (!model.input?.includes("image")) {
+                allImages = [];
+            }
+            const context = buildPdfContext(params.prompt, allText, allImages);
+            const message = await complete(model, context, {
+                apiKey,
+                maxTokens: resolvePdfToolMaxTokens(model.maxTokens),
+            });
+            const text = coercePdfAssistantText({
+                message,
+                provider: model.provider,
+                model: model.id,
+            });
+            return { text, provider: model.provider, model: model.id };
+        },
+    });
+    return {
+        text: result.result.text,
+        provider: result.result.provider,
+        model: result.result.model,
+        attempts: result.attempts.map((attempt) => ({
+            provider: attempt.provider,
+            model: attempt.model,
+            error: attempt.error,
+        })),
+    };
+}
+export function createPdfTool(options) {
+    const agentDir = options?.agentDir?.trim();
+    if (!agentDir) {
+        const explicit = coercePdfModelConfig(options?.config);
+        if (explicit.primary?.trim() || (explicit.fallbacks?.length ?? 0) > 0) {
+            throw new Error("createPdfTool requires agentDir when enabled");
+        }
+        return null;
+    }
+    const pdfModelConfig = resolvePdfModelConfigForTool({
+        cfg: options?.config,
+        agentDir,
+    });
+    if (!pdfModelConfig) {
+        return null;
+    }
+    const description = "Analyze one or more PDF documents. Use pdf for a single path/URL, or pdfs for multiple (up to 10). Optionally specify pages to limit analysis to specific page ranges.";
+    const localRoots = (() => {
+        const roots = getDefaultLocalRoots();
+        const workspaceDir = normalizeWorkspaceDir(options?.workspaceDir);
+        if (!workspaceDir) {
+            return roots;
+        }
+        return Array.from(new Set([...roots, workspaceDir]));
+    })();
+    return {
+        label: "PDF",
+        name: "pdf",
+        description,
+        parameters: Type.Object({
+            prompt: Type.Optional(Type.String()),
+            pdf: Type.Optional(Type.String({ description: "Single PDF path or URL." })),
+            pdfs: Type.Optional(Type.Array(Type.String(), {
+                description: "Multiple PDF paths or URLs (up to 10).",
+            })),
+            pages: Type.Optional(Type.String({
+                description: 'Page range to analyze, e.g. "1-5", "3", "1-3,7-9". Omit to analyze all pages.',
+            })),
+            model: Type.Optional(Type.String()),
+            maxBytesMb: Type.Optional(Type.Number()),
+        }),
+        execute: async (_toolCallId, args) => {
+            const record = args && typeof args === "object" ? args : {};
+            // MARK: - Normalize pdf + pdfs input and dedupe while preserving order
+            const pdfCandidates = [];
+            if (typeof record.pdf === "string") {
+                pdfCandidates.push(record.pdf);
+            }
+            if (Array.isArray(record.pdfs)) {
+                pdfCandidates.push(...record.pdfs.filter((v) => typeof v === "string"));
+            }
+            const seenPdfs = new Set();
+            const pdfInputs = [];
+            for (const candidate of pdfCandidates) {
+                const trimmedCandidate = candidate.trim();
+                const normalizedForDedupe = trimmedCandidate.startsWith("@")
+                    ? trimmedCandidate.slice(1).trim()
+                    : trimmedCandidate;
+                if (!normalizedForDedupe || seenPdfs.has(normalizedForDedupe)) {
+                    continue;
+                }
+                seenPdfs.add(normalizedForDedupe);
+                pdfInputs.push(trimmedCandidate);
+            }
+            if (pdfInputs.length === 0) {
+                throw new Error("pdf required");
+            }
+            // MARK: - Enforce max PDFs cap (hardcoded)
+            if (pdfInputs.length > DEFAULT_MAX_PDFS) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Too many PDFs: ${pdfInputs.length} provided, maximum is ${DEFAULT_MAX_PDFS}. Please reduce the number of PDFs.`,
+                        },
+                    ],
+                    details: { error: "too_many_pdfs", count: pdfInputs.length, max: DEFAULT_MAX_PDFS },
+                };
+            }
+            // MARK: - Parse pages param
+            const pagesRaw = typeof record.pages === "string" && record.pages.trim() ? record.pages.trim() : undefined;
+            const pageNumbers = pagesRaw ? parsePageRange(pagesRaw, 9999) : undefined;
+            const promptRaw = typeof record.prompt === "string" && record.prompt.trim()
+                ? record.prompt.trim()
+                : DEFAULT_PROMPT;
+            const modelOverride = typeof record.model === "string" && record.model.trim() ? record.model.trim() : undefined;
+            const maxBytesMb = typeof record.maxBytesMb === "number" ? record.maxBytesMb : undefined;
+            const maxBytes = pickMaxBytes(options?.config, maxBytesMb);
+            const sandboxConfig = options?.sandbox && options?.sandbox.root.trim()
+                ? { root: options.sandbox.root.trim(), bridge: options.sandbox.bridge }
+                : null;
+            // MARK: - Load and resolve each PDF
+            const loadedPdfs = [];
+            for (const pdfRawInput of pdfInputs) {
+                const trimmed = pdfRawInput.trim();
+                const pdfRaw = trimmed.startsWith("@") ? trimmed.slice(1).trim() : trimmed;
+                if (!pdfRaw) {
+                    throw new Error("pdf required (empty string in array)");
+                }
+                // Validate scheme: allow file://, http(s)://, and bare paths.
+                // Reject data: URLs (too large for PDFs) and unsupported schemes.
+                const looksLikeWindowsDrivePath = /^[a-zA-Z]:[\\/]/.test(pdfRaw);
+                const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(pdfRaw);
+                const isFileUrl = /^file:/i.test(pdfRaw);
+                const isHttpUrl = /^https?:\/\//i.test(pdfRaw);
+                const isDataUrl = /^data:/i.test(pdfRaw);
+                if (isDataUrl) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Data URLs are not supported for PDFs. Use a file path or an http(s) URL instead.`,
+                            },
+                        ],
+                        details: { error: "unsupported_pdf_reference", pdf: pdfRawInput },
+                    };
+                }
+                if (hasScheme && !looksLikeWindowsDrivePath && !isFileUrl && !isHttpUrl) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Unsupported PDF reference: ${pdfRawInput}. Use a file path, a file:// URL, or an http(s) URL.`,
+                            },
+                        ],
+                        details: {
+                            error: "unsupported_pdf_reference",
+                            pdf: pdfRawInput,
+                        },
+                    };
+                }
+                if (sandboxConfig && isHttpUrl) {
+                    throw new Error("Sandboxed PDF tool does not allow remote URLs.");
+                }
+                const resolvedPdf = (() => {
+                    if (sandboxConfig) {
+                        return pdfRaw;
+                    }
+                    if (pdfRaw.startsWith("~")) {
+                        return resolveUserPath(pdfRaw);
+                    }
+                    return pdfRaw;
+                })();
+                const resolvedPathInfo = sandboxConfig
+                    ? await resolveSandboxedPdfPath({
+                        sandbox: sandboxConfig,
+                        pdfPath: resolvedPdf,
+                    })
+                    : {
+                        resolved: resolvedPdf.startsWith("file://")
+                            ? resolvedPdf.slice("file://".length)
+                            : resolvedPdf,
+                    };
+                const resolvedPath = resolvedPathInfo.resolved;
+                const media = sandboxConfig
+                    ? await loadWebMedia(resolvedPath ?? resolvedPdf, {
+                        maxBytes,
+                        sandboxValidated: true,
+                        optimizeImages: false,
+                        readFile: (filePath) => sandboxConfig.bridge.readFile({ filePath, cwd: sandboxConfig.root }),
+                    })
+                    : await loadWebMedia(resolvedPath ?? resolvedPdf, {
+                        maxBytes,
+                        localRoots,
+                        optimizeImages: false,
+                    });
+                const mime = normalizeMimeType(("contentType" in media && media.contentType) || "");
+                if (mime !== "application/pdf") {
+                    throw new Error(`Expected PDF, got: ${("contentType" in media && media.contentType) || "unknown"}`);
+                }
+                loadedPdfs.push({
+                    buffer: media.buffer,
+                    resolvedPdf,
+                    ...(resolvedPathInfo.rewrittenFrom
+                        ? { rewrittenFrom: resolvedPathInfo.rewrittenFrom }
+                        : {}),
+                });
+            }
+            // MARK: - Run PDF prompt with all loaded PDFs
+            const result = await runPdfPrompt({
+                cfg: options?.config,
+                agentDir,
+                pdfModelConfig,
+                modelOverride,
+                prompt: promptRaw,
+                pdfBuffers: loadedPdfs.map((p) => p.buffer),
+                pageNumbers,
+            });
+            const pdfDetails = loadedPdfs.length === 1
+                ? {
+                    pdf: loadedPdfs[0].resolvedPdf,
+                    ...(loadedPdfs[0].rewrittenFrom
+                        ? { rewrittenFrom: loadedPdfs[0].rewrittenFrom }
+                        : {}),
+                }
+                : {
+                    pdfs: loadedPdfs.map((p) => ({
+                        pdf: p.resolvedPdf,
+                        ...(p.rewrittenFrom ? { rewrittenFrom: p.rewrittenFrom } : {}),
+                    })),
+                };
+            return {
+                content: [{ type: "text", text: result.text }],
+                details: {
+                    model: `${result.provider}/${result.model}`,
+                    ...pdfDetails,
+                    ...(pageNumbers ? { pages: pageNumbers } : {}),
+                    attempts: result.attempts,
+                },
+            };
+        },
+    };
+}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.3.4",
-  "commit": "8f59018950a00bf223a194a5e8af854aed69c342",
-  "builtAt": "2026-03-04T11:23:48.618Z"
+  "version": "2026.3.6",
+  "commit": "def3163876b28829de26ed4eb0c2166b051434ae",
+  "builtAt": "2026-03-06T12:13:28.765Z"
 }

package/dist/cron/normalize.js

@@ -351,6 +351,9 @@ export function normalizeCronJobInput(raw, options = DEFAULT_OPTIONS) {
     if (isRecord(base.delivery)) {
         next.delivery = coerceDelivery(base.delivery);
     }
+    if (isRecord(base.onFailure)) {
+        next.onFailure = coerceDelivery(base.onFailure);
+    }
     if ("isolation" in next) {
         delete next.isolation;
     }

package/dist/cron/service/jobs.js

@@ -68,6 +68,22 @@ function assertDeliverySupport(job) {
         throw new Error('cron channel delivery config is only supported for sessionTarget="isolated"');
     }
 }
+function assertFailureAlertSupport(job) {
+    if (!job.onFailure) {
+        return;
+    }
+    if (job.onFailure.mode === "webhook") {
+        const target = normalizeHttpWebhookUrl(job.onFailure.to);
+        if (!target) {
+            throw new Error("cron onFailure webhook requires onFailure.to to be a valid http(s) URL");
+        }
+        job.onFailure.to = target;
+        return;
+    }
+    if (job.sessionTarget !== "isolated") {
+        throw new Error('cron onFailure announce config is only supported for sessionTarget="isolated"');
+    }
+}
 export function findJobOrThrow(state, id) {
     const job = state.store?.jobs.find((j) => j.id === id);
     if (!job) {
@@ -285,12 +301,14 @@ export function createJob(state, input) {
         wakeMode: input.wakeMode,
         payload: input.payload,
         delivery: input.delivery,
+        onFailure: input.onFailure,
         state: {
             ...input.state,
         },
     };
     assertSupportedJobSpec(job);
     assertDeliverySupport(job);
+    assertFailureAlertSupport(job);
     job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
     return job;
 }
@@ -352,6 +370,12 @@ export function applyJobPatch(job, patch) {
     if (job.sessionTarget === "main" && job.delivery?.mode !== "webhook") {
         job.delivery = undefined;
     }
+    if (patch.onFailure) {
+        job.onFailure = mergeCronFailureAlert(job.onFailure, patch.onFailure);
+    }
+    if (job.sessionTarget === "main" && job.onFailure?.mode !== "webhook") {
+        job.onFailure = undefined;
+    }
     if (patch.state) {
         job.state = { ...job.state, ...patch.state };
     }
@@ -363,6 +387,7 @@ export function applyJobPatch(job, patch) {
     }
     assertSupportedJobSpec(job);
     assertDeliverySupport(job);
+    assertFailureAlertSupport(job);
 }
 function mergeCronPayload(existing, patch) {
     if (patch.kind !== existing.kind) {
@@ -488,6 +513,29 @@ function mergeCronDelivery(existing, patch) {
     }
     return next;
 }
+function mergeCronFailureAlert(existing, patch) {
+    const next = {
+        mode: existing?.mode ?? "none",
+        channel: existing?.channel,
+        to: existing?.to,
+        bestEffort: existing?.bestEffort,
+    };
+    if (typeof patch.mode === "string") {
+        next.mode = patch.mode === "deliver" ? "announce" : patch.mode;
+    }
+    if ("channel" in patch) {
+        const channel = typeof patch.channel === "string" ? patch.channel.trim() : "";
+        next.channel = channel ? channel : undefined;
+    }
+    if ("to" in patch) {
+        const to = typeof patch.to === "string" ? patch.to.trim() : "";
+        next.to = to ? to : undefined;
+    }
+    if (typeof patch.bestEffort === "boolean") {
+        next.bestEffort = patch.bestEffort;
+    }
+    return next;
+}
 export function isJobDue(job, nowMs, opts) {
     if (!job.state) {
         job.state = {};

package/dist/gateway/protocol/schema/cron.js

@@ -99,6 +99,7 @@ export const CronJobSchema = Type.Object({
     wakeMode: Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")]),
     payload: CronPayloadSchema,
     delivery: Type.Optional(CronDeliverySchema),
+    onFailure: Type.Optional(CronDeliverySchema),
     state: CronJobStateSchema,
 }, { additionalProperties: false });
 export const CronListParamsSchema = Type.Object({
@@ -117,6 +118,7 @@ export const CronAddParamsSchema = Type.Object({
     wakeMode: Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")]),
     payload: CronPayloadSchema,
     delivery: Type.Optional(CronDeliverySchema),
+    onFailure: Type.Optional(CronDeliverySchema),
 }, { additionalProperties: false });
 export const CronJobPatchSchema = Type.Object({
     name: Type.Optional(NonEmptyString),
@@ -130,6 +132,7 @@ export const CronJobPatchSchema = Type.Object({
     wakeMode: Type.Optional(Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")])),
     payload: Type.Optional(CronPayloadPatchSchema),
     delivery: Type.Optional(CronDeliveryPatchSchema),
+    onFailure: Type.Optional(CronDeliveryPatchSchema),
     state: Type.Optional(Type.Partial(CronJobStateSchema)),
 }, { additionalProperties: false });
 export const CronUpdateParamsSchema = Type.Union([