fix(serverless-hono): withWaitUntil must not destroy global state when context has no waitUntil (#1214)

* fix(serverless-hono): withWaitUntil must not destroy global state when context has no waitUntil

Two bugs in withWaitUntil:

1. The else branch unconditionally set ___voltagent_wait_until = undefined
   even when the global already held a value from an outer scope. This
   silently killed background tasks (observability, logging) in middleware
   chains where an inner handler passed {} as context.

2. Errors thrown by context.waitUntil (e.g. DataCloneError in Cloudflare
   Workers) propagated to callers. The test suite expected them to be
   swallowed; wrapping the call in try/catch aligns implementation with
   that contract.

Fix:
- Remove the else branch entirely. When context has no waitUntil the
  global is left untouched.
- Wrap the bound waitUntil call in try/catch to swallow errors.
- Simplify the cleanup function to always restore previousWaitUntil
  unconditionally (no currentWaitUntil guard needed).

All 11 tests in wait-until-wrapper.spec.ts now pass.

Fixes #1203

* chore: add changeset

---------

Co-authored-by: octo-patch <octo-patch@github.com>
Co-authored-by: Omer Aplak <omeraplak@gmail.com>

Author: 3 people

.changeset/rude-pianos-marry.md

@@ -0,0 +1,5 @@
+---
+"@voltagent/serverless-hono": patch
+---
+
+fix(serverless-hono): withWaitUntil must not destroy global state when context has no waitUntil

packages/serverless-hono/src/utils/wait-until-wrapper.ts

@@ -34,20 +34,21 @@ export function withWaitUntil(context?: WaitUntilContext | null): () => void {
 
   if (currentWaitUntil && typeof currentWaitUntil === "function") {
     // Bind to context to avoid "Illegal invocation" errors
-    // And allow errors (like DataCloneError) to propagate so caller can handle fallback
-    globals.___voltagent_wait_until = currentWaitUntil.bind(context);
-  } else {
-    globals.___voltagent_wait_until = undefined;
+    // Wrap in try/catch so errors (like DataCloneError) are swallowed and don't break the caller
+    const boundWaitUntil = currentWaitUntil.bind(context);
+    globals.___voltagent_wait_until = (promise: Promise<unknown>) => {
+      try {
+        boundWaitUntil(promise);
+      } catch {
+        // Swallow errors to avoid breaking the caller
+      }
+    };
   }
+  // No else branch — don't touch global when context has no waitUntil,
+  // to avoid destroying a previously set value from an outer scope
 
-  // Return cleanup function
+  // Return cleanup function that always restores the previous state
   return () => {
-    if (currentWaitUntil) {
-      if (previousWaitUntil) {
-        globals.___voltagent_wait_until = previousWaitUntil;
-      } else {
-        globals.___voltagent_wait_until = undefined;
-      }
-    }
+    globals.___voltagent_wait_until = previousWaitUntil;
   };
 }