@agent-native/core 0.220.0 → 0.220.1-nightly-20261024183236

package/dist/action.d.ts

@@ -23,8 +23,26 @@ export interface ActionAutomationContext {
     triggerName: string;
     policyId?: string;
 }
+export declare const DEFAULT_TOOL_RESULT_CHARS = 50000;
+/**
+ * The most characters of a pretty-printed result the agent keeps for a call:
+ * the action's own limit, else the agent-wide limit, else the default, bounded
+ * by any hard limit. The agent loop and actions that fit their own results
+ * resolve it here so they cannot disagree.
+ */
+export declare function resolveToolMaxResultChars(action: {
+    maxResultChars?: number;
+}, limits?: {
+    maxResultChars?: number;
+    hardMaxResultChars?: number;
+}): number;
 export interface ActionRunContext {
     send?: (event: AgentChatEvent) => void;
+    /**
+     * Result cap the agent loop enforces on this call, from
+     * `resolveToolMaxResultChars`. Absent outside the agent loop.
+     */
+    maxResultChars?: number;
     userEmail?: string;
     /**
      * Request headers for server-only actions that must delegate to an

package/dist/action.js

@@ -48,6 +48,21 @@ export async function recordInvalidActionCall(entry, args, ctx, error) {
     }
     return true;
 }
+export const DEFAULT_TOOL_RESULT_CHARS = 50_000;
+/**
+ * The most characters of a pretty-printed result the agent keeps for a call:
+ * the action's own limit, else the agent-wide limit, else the default, bounded
+ * by any hard limit. The agent loop and actions that fit their own results
+ * resolve it here so they cannot disagree.
+ */
+export function resolveToolMaxResultChars(action, limits) {
+    const configured = action.maxResultChars ??
+        limits?.maxResultChars ??
+        DEFAULT_TOOL_RESULT_CHARS;
+    return typeof limits?.hardMaxResultChars === "number"
+        ? Math.min(configured, limits.hardMaxResultChars)
+        : configured;
+}
 export class ActionContractError extends Error {
     actionContractError = true;
     errorCode;

package/dist/agent/production-agent.js

@@ -9,7 +9,7 @@ import { parseA2AAgentActivityPart } from "../a2a/activity.js";
 import { actionCallIsRetrySafe, actionChangeResource, classifyActionCall, } from "../action-call-classification.js";
 import { runOutsideActionInvocation, vouchedOutcome } from "../action-frame.js";
 import { ACTION_CHAT_UI_RECORD_CHANGE_RENDERER, normalizeActionChangeResult, } from "../action-ui.js";
-import { AgentConnectionRequiredError, describeToolParameterSignature, isActionContractError, isActionHiddenFromEveryAgentSurface, isAgentActionStopError, isAgentConnectionRequiredError, actionCallIntent, ActionInputValidationError, invocationEffect, runPreparedActionCall, boundActionCallIntent, preparedCallArguments, preparedCallNeedsApproval, recordInvalidActionCall, stripUnsupportedSchemaKeywords, } from "../action.js";
+import { AgentConnectionRequiredError, describeToolParameterSignature, isActionContractError, isActionHiddenFromEveryAgentSurface, isAgentActionStopError, isAgentConnectionRequiredError, actionCallIntent, ActionInputValidationError, invocationEffect, runPreparedActionCall, boundActionCallIntent, preparedCallArguments, preparedCallNeedsApproval, recordInvalidActionCall, resolveToolMaxResultChars, stripUnsupportedSchemaKeywords, } from "../action.js";
 import { getAppConfig } from "../app-config/index.js";
 import { MAX_BACKGROUND_RUN_CONTINUATIONS, MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS, MAX_TURN_WALL_CLOCK_MS, } from "../app-config/run-lifecycle-invariants.js";
 import { readAppState } from "../application-state/script-helpers.js";
@@ -1239,6 +1239,7 @@ const VISIBLE_RETRY_THRESHOLD_MS = 10_000;
  */
 const FOREGROUND_FIRST_MODEL_EVENT_TIMEOUT_MS = 25_000;
 const EMPTY_FINAL_RESPONSE_RETRY_LIMIT = 2;
+const MAX_CONSECUTIVE_MAX_TOKENS_CONTINUATIONS = 3;
 const TRUNCATED_TOOL_CALL_RETRY_LIMIT = 2;
 const MAIN_CHAT_INTERNAL_CONTINUATION_LIMIT = 6;
 const RUN_BUDGET_EXHAUSTED_ERROR_CODE = "run_budget_exhausted";
@@ -5151,6 +5152,8 @@ export async function runAgentLoop(opts) {
     const blockedA2ATargets = new Map();
     let finalGuardRetries = 0;
     let emptyFinalResponseRetries = 0;
+    let preserveReasoningEffortForEmptyResponseRetries = false;
+    let consecutiveMaxTokensContinuations = 0;
     let truncatedToolCallRetries = 0;
     let iterations = 0;
     let endedAtLoopLimit = false;
@@ -5888,21 +5891,42 @@ export async function runAgentLoop(opts) {
                 send({ type: "text", text });
         };
         if (toolCallParts.length === 0) {
+            const hasEmptyFinalResponse = collectTextParts(assistantContentForHistory).trim().length === 0 &&
+                streamedAssistantText.trim().length === 0;
             if (followUpResults.length > 0)
                 messages.push({ role: "user", content: followUpResults });
             if (terminalStopReason === "max_tokens") {
-                flushUnstreamedAssistantText();
-                appendAgentLoopContinuation(messages, "max_tokens");
-                continue;
+                if (hasEmptyFinalResponse) {
+                    preserveReasoningEffortForEmptyResponseRetries = true;
+                }
+                else if (consecutiveMaxTokensContinuations <
+                    MAX_CONSECUTIVE_MAX_TOKENS_CONTINUATIONS) {
+                    consecutiveMaxTokensContinuations += 1;
+                    flushUnstreamedAssistantText();
+                    appendAgentLoopContinuation(messages, "max_tokens");
+                    continue;
+                }
+                else {
+                    flushUnstreamedAssistantText();
+                    terminalActionStop = {
+                        message: "This response kept reaching the output-token limit after several continuations and may be incomplete. Ask for a shorter or narrower answer.",
+                        errorCode: "max_tokens_continuation_limit",
+                    };
+                    sendTerminalActionStop(terminalActionStop);
+                    break;
+                }
+            }
+            else {
+                consecutiveMaxTokensContinuations = 0;
             }
-            const hasEmptyFinalResponse = collectTextParts(assistantContentForHistory).trim().length === 0 &&
-                streamedAssistantText.trim().length === 0;
             if (followUpResults.length > 0 && terminalStopReason === "tool_use") {
                 if (streamedAssistantText)
                     send({ type: "clear" });
                 continue;
             }
-            if (followUpResults.length > 0 && hasEmptyFinalResponse) {
+            if (followUpResults.length > 0 &&
+                hasEmptyFinalResponse &&
+                terminalStopReason !== "max_tokens") {
                 flushUnstreamedAssistantText();
                 continue;
             }
@@ -5910,9 +5934,13 @@ export async function runAgentLoop(opts) {
                 completedFollowUpSuggestions = undefined;
                 if (emptyFinalResponseRetries < EMPTY_FINAL_RESPONSE_RETRY_LIMIT) {
                     emptyFinalResponseRetries += 1;
+                    const previousMaxOutputTokens = resolveMaxOutputTokensForEngine(engine.name, effectiveMaxOutputTokens, model);
                     effectiveMaxOutputTokens =
                         resolveEmptyResponseRetryMaxOutputTokens(model);
-                    effectiveReasoningEffort = stepDownReasoningEffort(effectiveReasoningEffort);
+                    if (!preserveReasoningEffortForEmptyResponseRetries ||
+                        effectiveMaxOutputTokens <= previousMaxOutputTokens) {
+                        effectiveReasoningEffort = stepDownReasoningEffort(effectiveReasoningEffort);
+                    }
                     send({ type: "clear" });
                     appendAgentLoopContinuation(messages, "max_tokens");
                     continue;
@@ -6006,6 +6034,8 @@ export async function runAgentLoop(opts) {
                 }
             }
             emptyFinalResponseRetries = 0;
+            preserveReasoningEffortForEmptyResponseRetries = false;
+            consecutiveMaxTokensContinuations = 0;
             effectiveMaxOutputTokens = opts.maxOutputTokens;
             effectiveReasoningEffort = opts.reasoningEffort;
             if (loopBreakerCloseout)
@@ -6014,6 +6044,8 @@ export async function runAgentLoop(opts) {
         }
         finalGuardRetries = 0;
         emptyFinalResponseRetries = 0;
+        preserveReasoningEffortForEmptyResponseRetries = false;
+        consecutiveMaxTokensContinuations = 0;
         const toolCallTruncatedByOutputCap = terminalStopReason === "max_tokens";
         if (toolCallTruncatedByOutputCap) {
             if (truncatedToolCallRetries < TRUNCATED_TOOL_CALL_RETRY_LIMIT) {
@@ -6600,14 +6632,8 @@ export async function runAgentLoop(opts) {
                     };
                 }
             }
-            const DEFAULT_TOOL_RESULT_CHARS = 50_000;
             const toolTimeoutMs = toolTimeoutMsFor(actionEntry);
-            const configuredToolMaxResultChars = actionEntry.maxResultChars ??
-                opts.toolLimits?.maxResultChars ??
-                DEFAULT_TOOL_RESULT_CHARS;
-            const toolMaxResultChars = typeof opts.toolLimits?.hardMaxResultChars === "number"
-                ? Math.min(configuredToolMaxResultChars, opts.toolLimits.hardMaxResultChars)
-                : configuredToolMaxResultChars;
+            const toolMaxResultChars = resolveToolMaxResultChars(actionEntry, opts.toolLimits);
             const executionFence = currentExecutionFence();
             const logicalExecutionStepId = logicalExecutionStepIds.get(originalToolCall);
             const interruptedStep = executionFence && toolCallJournal
@@ -7201,6 +7227,7 @@ export async function runAgentLoop(opts) {
                             signal,
                             actionName: toolCall.name,
                             toolCallId: toolCall.id,
+                            maxResultChars: toolMaxResultChars,
                             ...(wasApproved ? { approvedToolCallKey: approvalKey } : {}),
                         };
                         actionInvoked = true;

package/dist/agent/run-manager.js

@@ -5,6 +5,7 @@ import { recordAgentRun } from "../observability/metrics.js";
 import { parseServiceIdentityEmail } from "../org/service-identity.js";
 import { ServicePrincipalRefusedError } from "../org/service-principal-guard.js";
 import { captureError } from "../server/capture-error.js";
+import { isNonProgressEventType } from "../shared/progress-events.js";
 import { EXECUTION_LEASE_LOST_ABORT_REASON } from "./abort-reasons.js";
 import { isLlmCredentialError, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./engine/credential-errors.js";
 import { classifyTerminalErrorCode, describeErrorWithCauses, isProviderConnectionError, } from "./engine/error-detail.js";
@@ -86,6 +87,7 @@ export function resolveRunNoProgressTimeoutMs(params) {
         return ceiling;
     return override === 0 ? 0 : Math.min(override, ceiling);
 }
+const MAX_CONSECUTIVE_EMPTY_MODEL_CALLS = 3;
 function inFlightWorkDelta(event) {
     switch (event.type) {
         case "tool_start":
@@ -577,6 +579,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             chunkAbort = new AbortController();
             armChunkSoftTimeout();
             lastRealProgressAt = Date.now();
+            consecutiveEmptyModelCalls = 0;
             return chunkAbort.signal;
         },
     };
@@ -888,8 +891,6 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         scheduleProgressWrite();
     };
     const shouldBumpProgressForEvent = (event) => {
-        if (event.type === "stream_keepalive")
-            return false;
         if (event.type === "clear") {
             for (const [key, bytes] of preparingActivityBytes) {
                 const toolKey = preparingActivityTools.get(key) ?? key;
@@ -897,8 +898,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             }
             preparingActivityBytes.clear();
             preparingActivityTools.clear();
-            return false;
         }
+        if (isNonProgressEventType(event.type))
+            return false;
         if (event.type === "activity" && isPreparingActionActivityEvent(event)) {
             const toolKey = event.tool?.trim() || event.label.trim();
             const activityKey = `${toolKey}:${event.id?.trim() || "no-id"}`;
@@ -954,6 +956,11 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         return true;
     };
     let lastRealProgressAt = Date.now();
+    // Every completed model call refreshes the silence clock (its result is still
+    // being processed), so a loop of calls that produce no text, tool call or
+    // result is caught by counting consecutive empty calls instead.
+    let consecutiveEmptyModelCalls = 0;
+    let modelCallHadProgress = false;
     let inFlightWorkCount = 0;
     let inFlightMarkerSince = null;
     let inFlightMarkerWrite = Promise.resolve();
@@ -1163,7 +1170,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         if (inFlightWorkCount > 0)
             return;
         const silentForMs = Date.now() - lastRealProgressAt;
-        if (silentForMs < noProgressTimeoutMs)
+        const emptyCallLoop = consecutiveEmptyModelCalls > MAX_CONSECUTIVE_EMPTY_MODEL_CALLS;
+        if (!emptyCallLoop && silentForMs < noProgressTimeoutMs)
             return;
         const lastEventType = run.events.at(-1)?.event.type;
         if (!chunkAbort) {
@@ -1410,8 +1418,20 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         trackInFlightWork(runEvent.event);
         if (shouldBumpProgressForEvent(runEvent.event)) {
             lastRealProgressAt = Date.now();
+            consecutiveEmptyModelCalls = 0;
+            modelCallHadProgress = true;
             bumpProgressIfDue();
         }
+        else if (runEvent.event.type === "model_stream") {
+            if (runEvent.event.status === "start") {
+                modelCallHadProgress = false;
+            }
+            else {
+                lastRealProgressAt = Date.now();
+                if (!modelCallHadProgress)
+                    consecutiveEmptyModelCalls++;
+            }
+        }
     };
     const queueRunEvent = (pendingWrite, runEvent) => {
         let resolve;

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/client/sse-event-processor.d.ts

@@ -297,6 +297,13 @@ export type PreparingActionState = {
     entries?: Map<string, PreparingActionEntry>;
     toolEntries?: Map<string, PreparingActionEntry>;
 };
+/**
+ * The browser's durable liveness cursor must mirror the server's
+ * `last_progress_at` predicate. The stream watchdog intentionally has a
+ * broader background policy, so it cannot be reused for this cursor: raw
+ * keepalives and repeated zero-byte preparation are not proof of real work.
+ */
+export declare function isDurableProgressEvent(ev: SSEEvent, actionPreparationProgress?: boolean): boolean;
 /**
  * Locate the tool call an `approval_required` event refers to.
  *

package/dist/client/sse-event-processor.js

@@ -1,6 +1,7 @@
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "../agent/engine/credential-errors.js";
 import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE, PROVIDER_TRANSIENT_REJECTION_ERROR_CODE, } from "../agent/engine/error-detail.js";
 import { normalizeConnectRequiredResult } from "../shared/connect-required.js";
+import { isNonProgressEventType } from "../shared/progress-events.js";
 import { toolInputsMatch } from "../shared/tool-inputs.js";
 import { emitChatFirstOpenApp } from "./chat-first-state.js";
 import { formatChatErrorText, normalizeChatError } from "./error-format.js";
@@ -205,8 +206,8 @@ function isMeaningfulProgressEvent(ev, actionPreparationProgress, options) {
  * broader background policy, so it cannot be reused for this cursor: raw
  * keepalives and repeated zero-byte preparation are not proof of real work.
  */
-function isDurableProgressEvent(ev, actionPreparationProgress) {
-    if (ev.type === "stream_keepalive" || ev.type === "clear")
+export function isDurableProgressEvent(ev, actionPreparationProgress) {
+    if (isNonProgressEventType(ev.type))
         return false;
     if (ev.type === "activity" && isPreparingActionActivity(ev)) {
         return actionPreparationProgress === true;

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
     configured?: undefined;
+    error?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/integrations/google-docs-poller.d.ts

@@ -17,4 +17,12 @@ export declare function stopGoogleDocsWatchChannel(accessToken: string, channelI
 export declare function processChanges(options: GoogleDocsPollerOptions): Promise<void>;
 export declare function handlePushNotification(): Promise<void>;
 export declare function startGoogleDocsPoller(options: GoogleDocsPollerOptions): Promise<void>;
-export declare function stopGoogleDocsPoller(): Promise<void>;
+/**
+ * Stops polling and watch renewal, then retires the shared Drive watch.
+ * With `shuttingDown`, it instead waits for a poll in flight to finish and
+ * leaves the watch registered for the servers still running, or the next
+ * start, to renew or replace.
+ */
+export declare function stopGoogleDocsPoller(options?: {
+    shuttingDown?: boolean;
+}): Promise<void>;

package/dist/integrations/google-docs-poller.js

@@ -663,26 +663,37 @@ function startPollLoop(options, intervalMs) {
         pollerStartTimer = null;
         pollerJob = startIntervalJob(poll, { intervalMs });
     }, 5000);
+    pollerStartTimer.unref?.();
     const email = getServiceAccountEmail();
     if (process.env.DEBUG) {
         console.log(`[google-docs] Poll loop started (interval: ${intervalMs / 1000}s, service account: ${email ?? "not configured"})`);
     }
 }
-export async function stopGoogleDocsPoller() {
+/**
+ * Stops polling and watch renewal, then retires the shared Drive watch.
+ * With `shuttingDown`, it instead waits for a poll in flight to finish and
+ * leaves the watch registered for the servers still running, or the next
+ * start, to renew or replace.
+ */
+export async function stopGoogleDocsPoller(options = {}) {
     pollerGeneration += 1;
     activeOptions = null;
     if (pollerStartTimer) {
         clearTimeout(pollerStartTimer);
         pollerStartTimer = null;
     }
-    if (pollerJob) {
-        pollerJob.stop();
-        pollerJob = null;
-    }
     if (watchRenewalTimer) {
         clearTimeout(watchRenewalTimer);
         watchRenewalTimer = null;
     }
+    const running = pollerJob;
+    pollerJob = null;
+    if (options.shuttingDown) {
+        await running?.stop();
+        return;
+    }
+    // Disabling doesn't wait on a slow poll; the stop ends its scheduling.
+    void running?.stop();
     try {
         const stopResult = await stopWatch();
         if (stopResult.status === "retry") {

package/dist/integrations/pending-tasks-retry-job.d.ts

@@ -14,4 +14,4 @@ export declare function retryStuckPendingTasks(input?: string | PendingTasksSwee
 export declare function startPendingTasksRetryJob(options?: {
     webhookBaseUrl?: string;
 }): void;
-export declare function stopPendingTasksRetryJob(): void;
+export declare function stopPendingTasksRetryJob(): Promise<void>;

package/dist/integrations/pending-tasks-retry-job.js

@@ -1,4 +1,5 @@
 import { getDbExec } from "../db/client.js";
+import { registerBackgroundJobStop } from "../server/background-jobs.js";
 import { startIntervalJob, } from "../server/interval-job.js";
 import { hasActiveIntegrationCampaign } from "./integration-campaigns-store.js";
 import { configuredIntegrationDurableDispatchScopes, dispatchPendingIntegrationTask, isIntegrationDurableDispatchEnabledForTask, } from "./integration-durable-dispatch.js";
@@ -242,16 +243,19 @@ export function startPendingTasksRetryJob(options) {
         });
     }, 10_000);
     startupTimer.unref?.();
+    registerBackgroundJobStop(stopPendingTasksRetryJob);
     if (process.env.DEBUG) {
         console.log(`[integrations] Pending-tasks retry job started (every ${RETRY_INTERVAL_MS / 1000}s)`);
     }
 }
-export function stopPendingTasksRetryJob() {
+export async function stopPendingTasksRetryJob() {
     if (startupTimer) {
         clearTimeout(startupTimer);
         startupTimer = null;
     }
-    job?.stop();
+    const running = job;
     job = null;
     activeWebhookBaseUrl = undefined;
+    if (running)
+        await running.stop();
 }

package/dist/integrations/plugin.js

@@ -8,6 +8,7 @@ import { getOrgContext } from "../org/context.js";
 import { loadResourcesForPrompt } from "../server/agent-chat-plugin.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { getSession } from "../server/auth.js";
+import { registerBackgroundJobStop } from "../server/background-jobs.js";
 import { FRAMEWORK_ROUTE_PREFIX } from "../server/core-routes-plugin.js";
 import { resolveSecret } from "../server/credential-provider.js";
 import { getH3App, markDefaultPluginProvided, } from "../server/framework-request-handler.js";
@@ -41,13 +42,13 @@ import { dispatchPendingIntegrationTask, INTEGRATION_CAMPAIGN_PROCESSOR_FIELD, I
 import { forgetIntegrationMemory, integrationMemoryActions, listIntegrationMemory, rememberForIntegrationScope, } from "./integration-memory.js";
 import { extractBearerToken, verifyInternalToken } from "./internal-token.js";
 import { setMountedChannels, } from "./mounted-channels.js";
-import { retryStuckPendingTasks, startPendingTasksRetryJob, } from "./pending-tasks-retry-job.js";
+import { retryStuckPendingTasks, startPendingTasksRetryJob, stopPendingTasksRetryJob, } from "./pending-tasks-retry-job.js";
 import { claimPendingTask, getNextPendingTaskForThread, getPendingTask, insertPendingTask, isDuplicateEventError, MAX_PENDING_TASK_ATTEMPTS, MAX_RECOVERABLE_PENDING_TASK_AGE_MS, markTaskCompleted, markTaskDeliveryRetryable, markTaskFailed, markTaskRetryable, stageTaskDeliveryPayload, } from "./pending-tasks-store.js";
 import { claimNextComputerCommand, claimNextRemoteCommand, enqueueComputerCommand, enqueueRemoteCommand as enqueueRemoteCommandRow, isRemoteCommandKind, listRemoteCommandsForOwner, updateRemoteCommandResult, } from "./remote-commands-store.js";
 import { authenticateRemoteDeviceToken, createRemoteDevice, getRemoteComputerCapabilities, getRemoteExecutionCapabilities, getRemoteDeviceForOwner, listRemoteDevicesForOwner, revokeRemoteDeviceForOwner, toPublicRemoteDevice, unregisterRemoteDevice, updateRemoteDeviceDetails, } from "./remote-devices-store.js";
-import { startRemotePushDeliveryJob } from "./remote-push-delivery-job.js";
+import { startRemotePushDeliveryJob, stopRemotePushDeliveryJob, } from "./remote-push-delivery-job.js";
 import { listRemotePushNotificationsForOwner, listRemotePushRegistrationsForOwner, queueRemotePushNotifications, toPublicRemotePushRegistration, unregisterRemotePushRegistrationForOwner, upsertRemotePushRegistration, } from "./remote-push-store.js";
-import { startRemoteCommandsRetryJob } from "./remote-retry-job.js";
+import { startRemoteCommandsRetryJob, stopRemoteCommandsRetryJob, } from "./remote-retry-job.js";
 import { insertRemoteRunEvents, listRemoteRunEvents, } from "./remote-run-events-store.js";
 import { integrationRequestContext, resolveIntegrationRequestScope, } from "./request-scope.js";
 import { listIntegrationScopes, saveIntegrationScope } from "./scope-store.js";
@@ -176,6 +177,17 @@ function startA2AContinuationRetryJob(adapters) {
         });
     }, 10_000);
     a2aContinuationStartupTimer.unref?.();
+    registerBackgroundJobStop(stopA2AContinuationRetryJob);
+}
+async function stopA2AContinuationRetryJob() {
+    if (a2aContinuationStartupTimer) {
+        clearTimeout(a2aContinuationStartupTimer);
+        a2aContinuationStartupTimer = null;
+    }
+    const running = a2aContinuationJob;
+    a2aContinuationJob = null;
+    if (running)
+        await running.stop();
 }
 export const BUILT_IN_INTEGRATION_ADAPTER_FACTORIES = Object.freeze([
     { platform: "slack", create: slackAdapter },
@@ -2749,8 +2761,10 @@ export function createIntegrationsPlugin(options) {
             startA2AContinuationRetryJob(adapterMap);
             startRemoteCommandsRetryJob();
             startRemotePushDeliveryJob();
+            let googleDocsStartTimer = null;
             if (adapterMap.has("google-docs")) {
-                setTimeout(() => {
+                googleDocsStartTimer = setTimeout(() => {
+                    googleDocsStartTimer = null;
                     void runGoogleDocsPollerTransition(async () => {
                         const config = await getIntegrationConfig("google-docs");
                         const ownerEmail = config?.owner?.trim();
@@ -2763,7 +2777,24 @@ export function createIntegrationsPlugin(options) {
                         await startGoogleDocsPoller(createGoogleDocsPollerOptions(ownerEmail));
                     });
                 }, 2000);
-            }
+                googleDocsStartTimer.unref?.();
+            }
+            const stopIntegrationBackgroundJobs = async () => {
+                await Promise.all([
+                    stopPendingTasksRetryJob(),
+                    stopA2AContinuationRetryJob(),
+                    stopRemoteCommandsRetryJob(),
+                    stopRemotePushDeliveryJob(),
+                ]);
+                if (googleDocsStartTimer) {
+                    clearTimeout(googleDocsStartTimer);
+                    googleDocsStartTimer = null;
+                }
+                if (adapterMap.has("google-docs")) {
+                    await runGoogleDocsPollerTransition(() => stopGoogleDocsPoller({ shuttingDown: true }));
+                }
+            };
+            registerBackgroundJobStop(stopIntegrationBackgroundJobs);
         }
         if (process.env.DEBUG)
             console.log(`[integrations] Mounted integration routes for: ${adapters.map((a) => a.platform).join(", ")}`);

package/dist/integrations/remote-push-delivery-job.d.ts

@@ -1,3 +1,3 @@
 export declare function runRemotePushDelivery(): Promise<void>;
 export declare function startRemotePushDeliveryJob(): void;
-export declare function stopRemotePushDeliveryJob(): void;
+export declare function stopRemotePushDeliveryJob(): Promise<void>;

package/dist/integrations/remote-push-delivery-job.js

@@ -1,3 +1,4 @@
+import { registerBackgroundJobStop } from "../server/background-jobs.js";
 import { startIntervalJob, } from "../server/interval-job.js";
 import { deliverPendingRemotePushNotifications } from "./remote-push-delivery.js";
 const DELIVERY_INTERVAL_MS = 60_000;
@@ -23,12 +24,15 @@ export function startRemotePushDeliveryJob() {
         });
     }, 10_000);
     startupTimer.unref?.();
+    registerBackgroundJobStop(stopRemotePushDeliveryJob);
 }
-export function stopRemotePushDeliveryJob() {
+export async function stopRemotePushDeliveryJob() {
     if (startupTimer) {
         clearTimeout(startupTimer);
         startupTimer = null;
     }
-    job?.stop();
+    const running = job;
     job = null;
+    if (running)
+        await running.stop();
 }

package/dist/integrations/remote-retry-job.d.ts

@@ -3,4 +3,4 @@ export declare function retryRemoteCommands(): Promise<{
     failed: number;
 }>;
 export declare function startRemoteCommandsRetryJob(): void;
-export declare function stopRemoteCommandsRetryJob(): void;
+export declare function stopRemoteCommandsRetryJob(): Promise<void>;

package/dist/integrations/remote-retry-job.js

@@ -1,3 +1,4 @@
+import { registerBackgroundJobStop } from "../server/background-jobs.js";
 import { startIntervalJob, } from "../server/interval-job.js";
 import { retryStaleRemoteCommands } from "./remote-commands-store.js";
 const RETRY_INTERVAL_MS = 60_000;
@@ -29,12 +30,15 @@ export function startRemoteCommandsRetryJob() {
         });
     }, 10_000);
     startupTimer.unref?.();
+    registerBackgroundJobStop(stopRemoteCommandsRetryJob);
 }
-export function stopRemoteCommandsRetryJob() {
+export async function stopRemoteCommandsRetryJob() {
     if (startupTimer) {
         clearTimeout(startupTimer);
         startupTimer = null;
     }
-    job?.stop();
+    const running = job;
     job = null;
+    if (running)
+        await running.stop();
 }

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -13,10 +13,10 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     resourceId: string;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

package/dist/notifications/routes.d.ts

@@ -1,8 +1,8 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
-    updated?: undefined;
     error?: undefined;
     ok?: undefined;
+    updated?: undefined;
 } | {
     count?: undefined;
     updated: number;
@@ -10,12 +10,12 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     ok?: undefined;
 } | {
     count?: undefined;
-    updated?: undefined;
     error: string;
     ok?: undefined;
+    updated?: undefined;
 } | {
     count?: undefined;
-    updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
+    updated?: undefined;
 }>>;

package/dist/observability/routes.d.ts

@@ -27,43 +27,43 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
+    ok?: undefined;
     error: string;
     message: string;
     summary?: undefined;
     spans?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
+    ok?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
+} | {
     error?: undefined;
     ok?: undefined;
-} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
+} | {
     error?: undefined;
     ok?: undefined;
-} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
-    error?: undefined;
-    ok?: undefined;
 } | {
+    ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     error: any;
-    ok?: undefined;
 } | {
+    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
-    error?: undefined;
     ok: boolean;
 }>>;