@agent-native/core 0.204.0 → 0.204.1-nightly-20261008065100

package/dist/jobs/background-automation-runner.js

@@ -10,12 +10,14 @@ import { buildAssistantMessage, buildUserMessage, extractThreadMeta, foldAssista
 import { attachToolSearch } from "../agent/tool-search.js";
 import { lookupOwnerAccount, resolveAutomationExecutionIdentity, } from "../automations/service.js";
 import { createThread, getThread, updateThreadData, withThreadDataLock, } from "../chat-threads/store.js";
+import { automationOutcomeMessagesForUser } from "../localization/automation-outcome-messages.js";
 import { queryOrgMembers } from "../org/context.js";
 import { organizationIdFromResourceOwner, organizationResourceOwner, } from "../resources/store.js";
 import { captureError } from "../server/capture-error.js";
 import { BuilderCredentialLookupError, CredentialStoreUnavailableError, } from "../server/credential-provider.js";
 import { runWithRequestContext, } from "../server/request-context.js";
 import { normalizeReasoningEffortForRequest } from "../shared/reasoning-effort.js";
+import automationNoOpAction, { AUTOMATION_NO_OP_TOOL, automationNoOpSchema, } from "./actions/automation-no-op.js";
 import { applyAutomationFailure, automationOwnerKind, classifyAutomationFailure, CONFIG_INVALID_ERROR_CODE, MISSING_TOOLS_ERROR_CODE, OWNER_MISSING_ERROR_CODE, pausedMessage, withDeliveryNote, } from "./automation-outcome.js";
 import { recoveredFactoryOwnerOrgId, } from "./frontmatter.js";
 import { attachAutomationRunThread, finishAutomationRun, startAutomationRun, } from "./run-history.js";
@@ -352,7 +354,7 @@ export async function runBackgroundAutomation(options, deps) {
         !(failure.precondition && !transition.pause));
         throw err;
     }
-    await recordRunOutcome(historyId, "success");
+    await recordRunOutcome(historyId, result.status, result.status === "skipped" ? result.reason : undefined);
     return result;
 }
 async function recordRunThread(historyId, threadId, runId) {
@@ -445,6 +447,45 @@ async function recordRunOutcome(historyId, status, error, errorCode, notify = tr
         console.error(`[automations] Could not record run ${historyId} as ${status}:`, err);
     }
 }
+async function confirmAutomationWork(automation, ownerEmail, run, responseText, actions, noOpReason) {
+    const events = run.events ?? [];
+    const hasConfirmedAction = events.some(({ event }) => event.type === "tool_done" &&
+        !event.isError &&
+        event.completedSideEffect === true &&
+        actions[event.tool]?.confirmsAutomationWork !== false);
+    const lastFailedTool = [...events]
+        .reverse()
+        .find(({ event }) => event.type === "tool_done" && event.isError);
+    if (noOpReason && !hasConfirmedAction && !lastFailedTool) {
+        return { status: "skipped", reason: noOpReason };
+    }
+    const { deliveryPlatform, deliveryDestination } = automation.meta;
+    if ((!noOpReason || hasConfirmedAction) &&
+        deliveryPlatform &&
+        deliveryDestination &&
+        responseText.trim()) {
+        const { getDefaultAdapter } = await import("../integrations/adapters/index.js");
+        const adapter = getDefaultAdapter(deliveryPlatform);
+        if (!adapter?.sendMessageToTarget) {
+            throw new BackgroundAutomationRunError(`Automation delivery is not supported for ${deliveryPlatform}`, CONFIG_INVALID_ERROR_CODE);
+        }
+        await adapter.sendMessageToTarget(adapter.formatAgentResponse(responseText), {
+            destination: deliveryDestination,
+            threadRef: automation.meta.deliveryThreadRef ?? null,
+            tenantId: automation.meta.deliveryTenantId,
+        });
+        return { status: "success" };
+    }
+    if (hasConfirmedAction)
+        return { status: "success" };
+    const messages = await automationOutcomeMessagesForUser(ownerEmail);
+    const detail = lastFailedTool?.event.type === "tool_done"
+        ? lastFailedTool.event.result
+        : undefined;
+    throw new BackgroundAutomationRunError(`${deliveryPlatform && deliveryDestination ? messages.emptyDelivery : messages.noWork}${detail ? ` ${detail}` : ""}`, lastFailedTool?.event.type === "tool_done"
+        ? (lastFailedTool.event.errorCode ?? "automation_no_confirmed_work")
+        : "automation_no_confirmed_work");
+}
 /**
  * Everything below runs before any thread or `agent_runs` row exists, so an
  * automation that cannot run fails here, once, instead of leaving a "Job:"
@@ -514,7 +555,38 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
         orgId,
     }, async () => {
         assertHardDeadline(options.hardDeadlineAt);
-        const baseActions = await deps.getActions(automation);
+        let noOpReason;
+        const messages = await automationOutcomeMessagesForUser(ownerEmail);
+        const baseActions = {
+            ...(await deps.getActions(automation)),
+            [AUTOMATION_NO_OP_TOOL]: {
+                ...automationNoOpAction,
+                agentTool: true,
+                confirmsAutomationWork: false,
+                tool: {
+                    ...automationNoOpAction.tool,
+                    description: messages.noOpInstruction,
+                    parameters: {
+                        ...automationNoOpAction.tool.parameters,
+                        type: "object",
+                        properties: {
+                            ...automationNoOpAction.tool.parameters?.properties,
+                            reason: {
+                                ...automationNoOpAction.tool.parameters?.properties
+                                    ?.reason,
+                                type: "string",
+                                description: messages.noOpReason,
+                            },
+                        },
+                    },
+                },
+                run: async (args, ctx) => {
+                    const result = await automationNoOpAction.run(automationNoOpSchema.parse(args), ctx);
+                    noOpReason = result.reason;
+                    return result;
+                },
+            },
+        };
         assertHardDeadline(options.hardDeadlineAt);
         assertRequestedMcpToolsAvailable(automation, baseActions);
         const configuredInitialTools = deps.getInitialToolNames?.(automation);
@@ -524,6 +596,10 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
                 ...(automation.meta.mcpTools ?? []),
             ])
             : undefined;
+        if (initialToolNames &&
+            !initialToolNames.includes(AUTOMATION_NO_OP_TOOL)) {
+            initialToolNames.push(AUTOMATION_NO_OP_TOOL);
+        }
         const actions = initialToolNames
             ? attachToolSearch({ ...baseActions })
             : baseActions;
@@ -535,7 +611,7 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
         assertHardDeadline(options.hardDeadlineAt);
         const model = await resolveBackgroundAutomationModel(engine, automation.meta.model, deps);
         assertHardDeadline(options.hardDeadlineAt);
-        const systemPrompt = await deps.getSystemPrompt(ownerEmail);
+        const systemPrompt = `${await deps.getSystemPrompt(ownerEmail)}\n\n${messages.noOpInstruction}`;
         assertHardDeadline(options.hardDeadlineAt);
         const thread = await createThread(ownerEmail, {
             title: threadTitle,
@@ -553,6 +629,7 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
         const softTimeoutMs = resolveBackgroundAutomationSoftTimeoutMs();
         const usageRef = { current: null };
         let responseText = "";
+        let outcome;
         let hardAbortTimer = null;
         let hardTimedOut = false;
         assertHardDeadline(options.hardDeadlineAt);
@@ -631,12 +708,25 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
                     clearTimeout(hardAbortTimer);
                     hardAbortTimer = null;
                 }
-                const persistFailure = backgroundAutomationPersistFailure({
+                let persistFailure = backgroundAutomationPersistFailure({
                     run,
                     hardTimedOut,
                     hardTimeoutMs,
                 });
                 try {
+                    responseText = collectFinalResponseTextFromAgentEvents((run.events ?? []).map((entry) => entry.event), { fallbackToPreToolText: false });
+                    if (!persistFailure && run.status === "completed") {
+                        try {
+                            outcome = await confirmAutomationWork(automation, ownerEmail, run, responseText, actions, noOpReason);
+                        }
+                        catch (error) {
+                            const failure = classifyAutomationFailure(error);
+                            persistFailure = {
+                                message: failure.message,
+                                errorCode: failure.code,
+                            };
+                        }
+                    }
                     await persistBackgroundAutomationTurn({
                         threadId: thread.id,
                         threadTitle,
@@ -652,6 +742,11 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
                 if (hardTimedOut)
                     return;
                 if (persistFailure) {
+                    run.continuationTerminalEvent = {
+                        type: "error",
+                        error: persistFailure.message,
+                        errorCode: persistFailure.errorCode,
+                    };
                     reject(new BackgroundAutomationRunError(persistFailure.message, persistFailure.errorCode));
                     return;
                 }
@@ -661,7 +756,6 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
                         `Background automation ended with status: ${run.status} and recorded no error detail`, cause?.errorCode ?? `background_automation_${run.status}`));
                     return;
                 }
-                responseText = collectFinalResponseTextFromAgentEvents((run.events ?? []).map((entry) => entry.event));
                 resolve();
             }, {
                 softTimeoutMs,
@@ -722,20 +816,9 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
                 // Usage attribution must not break an otherwise successful run.
             }
         }
-        if (responseText.trim() &&
-            automation.meta.deliveryPlatform &&
-            automation.meta.deliveryDestination) {
-            const { getDefaultAdapter } = await import("../integrations/adapters/index.js");
-            const adapter = getDefaultAdapter(automation.meta.deliveryPlatform);
-            if (!adapter?.sendMessageToTarget) {
-                throw new BackgroundAutomationRunError(`Automation delivery is not supported for ${automation.meta.deliveryPlatform}`, CONFIG_INVALID_ERROR_CODE);
-            }
-            await adapter.sendMessageToTarget(adapter.formatAgentResponse(responseText), {
-                destination: automation.meta.deliveryDestination,
-                threadRef: automation.meta.deliveryThreadRef ?? null,
-                tenantId: automation.meta.deliveryTenantId,
-            });
+        if (!outcome) {
+            throw new BackgroundAutomationRunError(messages.noWork, "automation_no_confirmed_work");
         }
-        return { responseText, runId };
+        return { ...outcome, responseText, runId };
     });
 }

package/dist/jobs/run-history.d.ts

@@ -1,5 +1,5 @@
 import { type MigrationEntry } from "../db/migrations.js";
-export type AutomationRunStatus = "running" | "success" | "error" | "interrupted";
+export type AutomationRunStatus = "running" | "success" | "error" | "interrupted" | "skipped";
 export interface AutomationRun {
     id: string;
     owner: string;

package/dist/jobs/run-history.js

@@ -18,7 +18,7 @@ registerEvent({
         orgId: z.string().nullable(),
         runId: z.string().nullable(),
         threadId: z.string().nullable(),
-        status: z.enum(["success", "error", "interrupted"]),
+        status: z.enum(["success", "error", "interrupted", "skipped"]),
         error: z.string().nullable(),
         errorCode: z.string().nullable(),
         durationMs: z.number().nullable(),
@@ -575,7 +575,7 @@ export async function finishAutomationRun(id, status, error, errorCode, options
     });
     const row = existing.rows?.[0];
     const finishedAt = Date.now();
-    const shouldQueueFailureAlert = status !== "success" &&
+    const shouldQueueFailureAlert = (status === "error" || status === "interrupted") &&
         options.notify !== false &&
         Boolean(row?.notification_email);
     const claimGuard = options.expectedClaimedAt !== undefined;
@@ -589,7 +589,9 @@ export async function finishAutomationRun(id, status, error, errorCode, options
             status,
             finishedAt,
             error?.slice(0, MAX_ERROR_LENGTH) ?? null,
-            errorCode?.slice(0, MAX_ERROR_CODE_LENGTH) ?? null,
+            status === "skipped"
+                ? null
+                : (errorCode?.slice(0, MAX_ERROR_CODE_LENGTH) ?? null),
             shouldQueueFailureAlert ? "evaluating" : null,
             shouldQueueFailureAlert ? finishedAt : null,
             id,
@@ -611,7 +613,9 @@ export async function finishAutomationRun(id, status, error, errorCode, options
             threadId: row.thread_id == null ? null : stringifyValue(row.thread_id),
             status,
             error: error?.slice(0, MAX_ERROR_LENGTH) ?? null,
-            errorCode: errorCode?.slice(0, MAX_ERROR_CODE_LENGTH) ?? null,
+            errorCode: status === "skipped"
+                ? null
+                : (errorCode?.slice(0, MAX_ERROR_CODE_LENGTH) ?? null),
             durationMs: startedAt === null ? null : Math.max(0, finishedAt - startedAt),
         }, { owner: stringifyValue(row.owner) });
     }

package/dist/jobs/scheduler.js

@@ -267,7 +267,7 @@ async function processRecurringJobsWithLease(deps) {
                         });
                         continue;
                     }
-                    await recordIdentityFailure(candidate.resource, candidate.meta, candidate.body, now, identity.reason);
+                    await recordIdentityFailure(candidate.resource, candidate.meta, candidate.body, now, identity.reason, identity.code);
                     continue;
                 }
                 if (isReservedIdentityBlocked(identity.identity.userEmail)) {
@@ -386,23 +386,32 @@ async function recoverStaleAutomationHistory(owner, path, now) {
     }
 }
 export const jobRunCutOffReason = backgroundRunCutOffReason;
-async function recordIdentityFailure(resource, meta, body, now, reason, historyId) {
+async function recordIdentityFailure(resource, meta, body, now, reason, errorCode = "owner_unverifiable", historyId) {
     const jobName = resource.path.replace(/^jobs\//, "").replace(/\.md$/, "");
     console.warn(`[recurring-jobs] Skipping job "${jobName}": ${reason}. ` +
         `User/membership no longer valid — leaving cron entry for admin review.`);
     const alreadyRecorded = meta.lastError === reason && hasRecentIdentityFailure(meta, now);
     meta.lastCheck = now.toISOString();
-    meta.lastStatus = "skipped";
+    meta.lastStatus = "error";
     meta.lastError = reason;
+    meta.lastErrorCode = errorCode;
     if (!alreadyRecorded)
-        await updateResource(resource, meta, body);
+        await updateResource(resource, meta, body, { lastErrorCode: errorCode });
     if (historyId) {
-        await finishAutomationRun(historyId, "error", `Automation did not run: ${reason}. No delivery was confirmed.`);
+        await finishAutomationRun(historyId, "error", `Automation did not run: ${reason}. No delivery was confirmed.`, errorCode);
     }
-    return { status: "skipped", error: reason };
+    return { status: "error", error: reason };
 }
 function hasRecentIdentityFailure(meta, now) {
-    if (meta.lastStatus !== "skipped" || !meta.lastCheck || !meta.lastError) {
+    if (meta.lastStatus !== "error" ||
+        !meta.lastErrorCode ||
+        ![
+            OWNER_MISSING_ERROR_CODE,
+            CONFIG_INVALID_ERROR_CODE,
+            "owner_unverifiable",
+        ].includes(meta.lastErrorCode) ||
+        !meta.lastCheck ||
+        !meta.lastError) {
         return false;
     }
     const lastCheckMs = Date.parse(meta.lastCheck);
@@ -571,7 +580,7 @@ async function executeJob(resource, meta, body, deps, now, options = {}) {
     // failure; leave the cron entry alone so an admin can purge after
     // investigation.
     if (!identity.ok) {
-        return recordIdentityFailure(resource, meta, body, now, identity.reason, options.historyId);
+        return recordIdentityFailure(resource, meta, body, now, identity.reason, identity.code, options.historyId);
     }
     const jobUserEmail = identity.identity.userEmail;
     const jobOrgId = identity.identity.orgId;
@@ -693,12 +702,16 @@ async function executeJob(resource, meta, body, deps, now, options = {}) {
         }, deps);
         await recordExecutionOutcome(resource, {
             lastRun: meta.lastRun,
-            lastStatus: "success",
-            lastError: undefined,
+            lastStatus: result.status,
+            lastError: result.status === "skipped" ? result.reason : undefined,
             advanceSchedule: options.advanceSchedule,
         });
-        console.log(`[recurring-jobs] Job "${jobName}" completed.`);
-        return { status: "success", runId: result.runId };
+        console.log(`[recurring-jobs] Job "${jobName}" ${result.status}.`);
+        return {
+            status: result.status,
+            runId: result.runId,
+            ...(result.status === "skipped" ? { error: result.reason } : {}),
+        };
     }
     catch (err) {
         const failure = classifyAutomationFailure(err);

package/dist/localization/automation-outcome-messages.d.ts

@@ -0,0 +1,22 @@
+import { type BuiltinLocaleCode } from "./shared.js";
+export declare const AUTOMATION_OUTCOME_MESSAGES: Record<BuiltinLocaleCode, {
+    noWork: string;
+    emptyDelivery: string;
+    emailNotSent: string;
+    noOpInstruction: string;
+    noOpReason: string;
+}>;
+export declare function automationOutcomeMessagesForLocale(locale: string): {
+    noWork: string;
+    emptyDelivery: string;
+    emailNotSent: string;
+    noOpInstruction: string;
+    noOpReason: string;
+};
+export declare function automationOutcomeMessagesForUser(userEmail: string | null | undefined): Promise<{
+    noWork: string;
+    emptyDelivery: string;
+    emailNotSent: string;
+    noOpInstruction: string;
+    noOpReason: string;
+}>;

package/dist/localization/automation-outcome-messages.js

@@ -0,0 +1,90 @@
+import { getUserSetting } from "../settings/user-settings.js";
+import { DEFAULT_LOCALE, isLocaleCode, LOCALIZATION_SETTING_KEY, normalizeLocalizationPreference, } from "./shared.js";
+export const AUTOMATION_OUTCOME_MESSAGES = {
+    "en-US": {
+        noOpInstruction: "If nothing needs doing, call automation-no-op with a short reason. Failed tools, sends, or missing credentials are errors, not no-ops.",
+        noOpReason: "A short reason why no action or report was needed (1–500 characters).",
+        emailNotSent: "The email was not sent by a delivery provider.",
+        noWork: "The automation ended without a confirmed action. Configure a delivery destination for read-only reports.",
+        emptyDelivery: "The automation produced no message for its configured delivery destination.",
+    },
+    "es-ES": {
+        noOpInstruction: "Si no hay nada que hacer, llama a automation-no-op con un motivo breve. Las herramientas o los envíos fallidos y las credenciales ausentes son errores, no casos sin trabajo.",
+        noOpReason: "Motivo breve por el que no se necesitaba ninguna acción ni informe (1–500 caracteres).",
+        emailNotSent: "El correo no fue enviado por un proveedor de entrega.",
+        noWork: "La automatización terminó sin una acción confirmada. Configura un destino de entrega para los informes de solo lectura.",
+        emptyDelivery: "La automatización no produjo ningún mensaje para su destino de entrega configurado.",
+    },
+    "fr-FR": {
+        noOpInstruction: "Si rien n’est à faire, appelez automation-no-op avec une courte raison. Les échecs d’outils ou d’envoi et les identifiants manquants sont des erreurs, pas une absence de travail.",
+        noOpReason: "Courte raison pour laquelle aucune action ni aucun rapport n’était nécessaire (1–500 caractères).",
+        emailNotSent: "L’e-mail n’a pas été envoyé par un fournisseur de messagerie.",
+        noWork: "L’automatisation s’est terminée sans action confirmée. Configurez une destination de livraison pour les rapports en lecture seule.",
+        emptyDelivery: "L’automatisation n’a produit aucun message pour sa destination de livraison configurée.",
+    },
+    "de-DE": {
+        noOpInstruction: "Wenn nichts zu tun ist, rufen Sie automation-no-op mit einer kurzen Begründung auf. Fehlgeschlagene Tools oder Zustellungen und fehlende Zugangsdaten sind Fehler, keine Fälle ohne Handlungsbedarf.",
+        noOpReason: "Kurze Begründung, warum keine Aktion oder kein Bericht nötig war (1–500 Zeichen).",
+        emailNotSent: "Die E-Mail wurde von keinem Zustellanbieter versendet.",
+        noWork: "Die Automatisierung endete ohne bestätigte Aktion. Konfigurieren Sie ein Zustellungsziel für schreibgeschützte Berichte.",
+        emptyDelivery: "Die Automatisierung hat keine Nachricht für ihr konfiguriertes Zustellungsziel erzeugt.",
+    },
+    "pt-BR": {
+        noOpInstruction: "Se não houver nada a fazer, chame automation-no-op com um motivo breve. Falhas de ferramentas ou envios e credenciais ausentes são erros, não ausência de trabalho.",
+        noOpReason: "Motivo breve pelo qual nenhuma ação ou relatório era necessário (1–500 caracteres).",
+        emailNotSent: "O e-mail não foi enviado por um provedor de entrega.",
+        noWork: "A automação terminou sem uma ação confirmada. Configure um destino de entrega para relatórios somente de leitura.",
+        emptyDelivery: "A automação não produziu nenhuma mensagem para seu destino de entrega configurado.",
+    },
+    "zh-CN": {
+        noOpInstruction: "如果没有需要执行的工作，请调用 automation-no-op 并提供简短原因。工具失败、发送失败或缺少凭据属于错误，不是无需操作。",
+        noOpReason: "简要说明为何无需执行操作或发送报告（1–500 个字符）。",
+        emailNotSent: "电子邮件未通过邮件服务提供商发送。",
+        noWork: "自动化结束时没有已确认的操作。请为只读报告配置发送目标。",
+        emptyDelivery: "自动化未生成要发送到已配置目标的消息。",
+    },
+    "zh-TW": {
+        noOpInstruction: "如果沒有需要執行的工作，請呼叫 automation-no-op 並提供簡短原因。工具失敗、傳送失敗或缺少憑證屬於錯誤，不是無需操作。",
+        noOpReason: "簡要說明為何無需執行操作或傳送報告（1–500 個字元）。",
+        emailNotSent: "電子郵件未透過郵件服務供應商傳送。",
+        noWork: "自動化結束時沒有已確認的操作。請為唯讀報告設定傳送目標。",
+        emptyDelivery: "自動化未產生要傳送到已設定目標的訊息。",
+    },
+    "ja-JP": {
+        noOpInstruction: "対応が不要な場合は、短い理由を添えて automation-no-op を呼び出してください。ツールや送信の失敗、認証情報の不足はエラーであり、対応不要には該当しません。",
+        noOpReason: "操作やレポートが不要だった短い理由（1～500文字）。",
+        emailNotSent: "メールは配信プロバイダーから送信されませんでした。",
+        noWork: "自動化は操作が確認されないまま終了しました。読み取り専用のレポートには配信先を設定してください。",
+        emptyDelivery: "自動化は設定された配信先へのメッセージを生成しませんでした。",
+    },
+    "ko-KR": {
+        noOpInstruction: "할 일이 없으면 짧은 이유와 함께 automation-no-op을 호출하세요. 도구 또는 전송 실패와 자격 증명 누락은 작업 없음이 아닌 오류입니다.",
+        noOpReason: "작업이나 보고서가 필요하지 않았던 짧은 이유(1–500자).",
+        emailNotSent: "이메일이 전송 제공업체를 통해 전송되지 않았습니다.",
+        noWork: "확인된 작업 없이 자동화가 종료되었습니다. 읽기 전용 보고서에는 전송 대상을 설정하세요.",
+        emptyDelivery: "자동화가 설정된 전송 대상에 보낼 메시지를 생성하지 않았습니다.",
+    },
+    "hi-IN": {
+        noOpInstruction: "यदि कुछ करने की आवश्यकता नहीं है, तो संक्षिप्त कारण के साथ automation-no-op कॉल करें। विफल टूल, विफल भेजने की कोशिश या अनुपलब्ध क्रेडेंशियल त्रुटियाँ हैं, काम न होने की स्थिति नहीं।",
+        noOpReason: "किसी कार्रवाई या रिपोर्ट की आवश्यकता न होने का संक्षिप्त कारण (1–500 अक्षर)।",
+        emailNotSent: "ईमेल किसी डिलीवरी प्रदाता द्वारा नहीं भेजा गया।",
+        noWork: "ऑटोमेशन किसी पुष्ट कार्रवाई के बिना समाप्त हो गया। केवल पढ़ने वाली रिपोर्ट के लिए डिलीवरी गंतव्य कॉन्फ़िगर करें।",
+        emptyDelivery: "ऑटोमेशन ने अपने कॉन्फ़िगर किए गए डिलीवरी गंतव्य के लिए कोई संदेश नहीं बनाया।",
+    },
+    "ar-SA": {
+        noOpInstruction: "إذا لم يكن هناك ما يجب فعله، استدعِ automation-no-op مع سبب موجز. فشل الأدوات أو الإرسال أو غياب بيانات الاعتماد أخطاء، وليس حالات لا تتطلب عملاً.",
+        noOpReason: "سبب موجز لعدم الحاجة إلى إجراء أو تقرير (1–500 حرف).",
+        emailNotSent: "لم تُرسل رسالة البريد الإلكتروني عبر مزوّد تسليم.",
+        noWork: "انتهت الأتمتة دون إجراء مؤكد. اضبط وجهة تسليم للتقارير المخصصة للقراءة فقط.",
+        emptyDelivery: "لم تنتج الأتمتة أي رسالة لوجهة التسليم المحددة.",
+    },
+};
+export function automationOutcomeMessagesForLocale(locale) {
+    return AUTOMATION_OUTCOME_MESSAGES[isLocaleCode(locale) ? locale : DEFAULT_LOCALE];
+}
+export async function automationOutcomeMessagesForUser(userEmail) {
+    const preference = normalizeLocalizationPreference(userEmail
+        ? await getUserSetting(userEmail, LOCALIZATION_SETTING_KEY)
+        : undefined);
+    return automationOutcomeMessagesForLocale(preference.locale);
+}

package/dist/localization/default-messages.d.ts

@@ -1018,9 +1018,11 @@ declare const messages: {
         scheduleUnavailableLocalTitle: string;
         scheduleUnavailableDisabled: string;
         scheduleUnavailableNoScheduler: string;
+        scheduleUnavailableMissingSecret: string;
         scheduleUnavailableLocal: string;
         scheduleUnavailableDisabledFix: string;
         scheduleUnavailableLocalFix: string;
+        scheduleUnavailableMissingSecretFix: string;
         scheduleUnavailableFixLabel: string;
         scheduleUnavailableFixLabelOpen: string;
     };

package/dist/localization/default-messages.js

@@ -940,11 +940,13 @@ const messages = {
         scheduleUnknownDetail: "The scheduler status check failed, so the next run times below are unconfirmed. Reload to check again.",
         scheduleUnavailableTitle: "Schedules won't run in this deploy",
         scheduleUnavailableLocalTitle: "Schedules don't run in local development",
-        scheduleUnavailableDisabled: "This app was built with recurring jobs turned off, so no scheduled automation will fire. Event- and webhook-triggered automations and Run now still work.",
-        scheduleUnavailableNoScheduler: "This hosting target has no durable scheduler, so no scheduled automation will fire. Event- and webhook-triggered automations and Run now still work.",
+        scheduleUnavailableDisabled: "This app was built with recurring jobs turned off, so no scheduled automation will fire. Webhook-triggered automations and Run now still work.",
+        scheduleUnavailableNoScheduler: "This deploy has no scheduler, so scheduled automations won't fire, event-triggered automations stay queued, and crashed runs aren't recovered. Webhook-triggered automations and Run now still work.",
+        scheduleUnavailableMissingSecret: "This deploy has a scheduler, but {{secret}} isn't set, so every scheduler request is rejected. Scheduled automations won't fire, event-triggered automations stay queued, and crashed runs aren't recovered. Webhook-triggered automations and Run now still work.",
         scheduleUnavailableLocal: "Schedules stay off on a dev machine unless you opt in. Event- and webhook-triggered automations and Run now still work.",
         scheduleUnavailableDisabledFix: "To enable recurring jobs, set AGENT_NATIVE_DISABLE_RECURRING_JOBS=false in the build environment.",
         scheduleUnavailableLocalFix: "Set AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS=true to run schedules on this machine.",
+        scheduleUnavailableMissingSecretFix: "Set {{secret}} in this deployment's environment variables, then redeploy.",
         scheduleUnavailableFixLabel: "Show more",
         scheduleUnavailableFixLabelOpen: "Show less",
     },

package/dist/mcp/build-server.js

@@ -24,6 +24,14 @@ import { MCP_APP_REQUEST_ORIGIN_CSP_SOURCE } from "./embed-app.js";
 import { hasMcpOAuthScope, parseMcpOAuthOrgIdClaim, verifyMcpOAuthAccessToken, } from "./oauth-token.js";
 import { mcpToolInputSchema } from "./tool-input-schema.js";
 const PRESERVE_MCP_OBJECT_RESULT = Symbol("preserveMcpObjectResult");
+// A GET action is a query, so its result is the payload the model asked for
+// even when it declares readOnly: false because the read also repairs or caches
+// (Slides get-deck). Collapsing that result into a write confirmation leaves
+// the model with only "<title> is ready.".
+function returnsQueryPayload(entry) {
+    return (entry.readOnly === true ||
+        (entry.http !== false && entry.http?.method === "GET"));
+}
 function hasVerifiedMcpUserIdentity(identity) {
     return (identity?.identityAssurance === "user" &&
         Boolean(identity.userEmail?.trim()));
@@ -237,15 +245,10 @@ export function validateMcpDirectoryProfile(config, sourceActions = config.produ
     if (unprofiledWidgetReadAction) {
         throw new McpDirectoryProfileValidationError(`[agent-native] MCP directory widget read "${unprofiledWidgetReadAction}" must be listed in its scoped read category.`);
     }
-    const widgetTargetNames = Object.keys(profile?.widgetTargets ?? {});
     if (profile && profile.widgets !== false && profile.widgetTargets) {
-        const missingTarget = widgetActionNames.find((name) => !profile?.widgetTargets?.[name]);
-        const unknownTarget = widgetTargetNames.find((name) => !widgetActionNames.includes(name));
-        if (missingTarget || unknownTarget) {
-            throw new McpDirectoryProfileValidationError(`[agent-native] MCP directory widget target resolvers must match the listed widget actions (missing: ${missingTarget ?? "none"}; unknown: ${unknownTarget ?? "none"}).`);
-        }
-        if (widgetActionNames.length > 0 && !profile?.widgetTargets) {
-            throw new McpDirectoryProfileValidationError("[agent-native] MCP directory widgets require a server-owned target resolver for every widget action.");
+        const unknownTarget = Object.keys(profile.widgetTargets).find((name) => !widgetActionNames.includes(name));
+        if (unknownTarget) {
+            throw new McpDirectoryProfileValidationError(`[agent-native] MCP directory widget target "${unknownTarget}" must name a listed action with an mcpApp resource. Listed widget actions without a target resolver serve as plain tools.`);
         }
     }
     for (const name of widgetReadOnlyActions) {
@@ -1095,7 +1098,7 @@ function safeUiSegment(value, fallback) {
     return normalized || fallback;
 }
 const MCP_APP_RESOURCE_SHELL_VERSION = "shell-v65";
-const MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION = "shell-v67";
+const MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION = "shell-v68";
 export function getMcpDirectoryWidgetResourceUri(appId, fallback = "agent-native") {
     const app = safeUiSegment(appId, fallback);
     return (versionMcpAppResourceUri(`ui://${app}/${MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION}`, MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION)?.uri ?? `ui://${app}/${MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION}`);
@@ -1307,6 +1310,14 @@ async function resolveMcpAppResource(config, actionName, entry, requestMeta) {
     const resource = entry.mcpApp?.resource;
     if (!resource)
         return null;
+    // Directory widgets open a host pane on every call, so only the profile's
+    // widgetTargets (create/present tools) attach one; a read tool whose action
+    // still carries mcpApp.resource for the non-directory surface must not.
+    const widgetTargets = config.directoryProfile?.widgetTargets;
+    if (config.catalogMode === "directory" &&
+        (!widgetTargets || !Object.hasOwn(widgetTargets, actionName))) {
+        return null;
+    }
     const resolvedUri = getMcpAppResourceUri(config, actionName, entry);
     if (!resolvedUri)
         return null;
@@ -2251,7 +2262,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 const isAppOnlyVisibility = Array.isArray(toolVisibility) &&
                     toolVisibility.length > 0 &&
                     toolVisibility.every((v) => v === "app");
-                const structuredResult = (entry.readOnly === true ||
+                const structuredResult = (returnsQueryPayload(entry) ||
                     entry.mcpApp?.structuredContent === true) &&
                     actionResultForClient &&
                     typeof actionResultForClient === "object"
@@ -2272,7 +2283,7 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                 const text = mcpAppResource
                     ? conciseMcpAppToolText(name, textResultForClient, structuredContent)
                     : conciseToolResultText(name, textResultForClient, {
-                        preserveObjectResult: entry.readOnly === true ||
+                        preserveObjectResult: returnsQueryPayload(entry) ||
                             entry[PRESERVE_MCP_OBJECT_RESULT] ===
                                 true,
                     });