Fix wrapOrchestrator to drive classic v3 orchestrators via async generator

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: YunchuWang

packages/azure-functions-durable/src/orchestration-context.ts

@@ -207,18 +207,22 @@ export type ClassicOrchestrator = (
 export function wrapOrchestrator(handler: TOrchestrator | ClassicOrchestrator): TOrchestrator {
   if (typeof handler === "function" && handler.length === 1) {
     const classic = handler as ClassicOrchestrator;
-    const wrapped = function* (
+    // The core engine only drives orchestrators whose invocation returns an ASYNC generator
+    // (it gates on Symbol.asyncIterator). Classic v3 orchestrators are SYNC generators, so the
+    // wrapper must itself be an async generator that delegates to the classic one via `yield*`;
+    // that forwards each core Task to the engine and pipes sent results back into the classic body.
+    const wrapped = async function* (
       ctx: OrchestrationContext,
       input: unknown,
-    ): Generator<Task<unknown>, unknown, unknown> {
+    ): AsyncGenerator<Task<unknown>, unknown, unknown> {
       const df = new DurableOrchestrationContext(ctx, input);
       const result = classic({ df });
       if (isGenerator(result)) {
         return yield* result;
       }
       return result;
     };
-    return wrapped as TOrchestrator;
+    return wrapped as unknown as TOrchestrator;
   }
   return handler as TOrchestrator;
 }

packages/azure-functions-durable/test/unit/orchestration-context.spec.ts

@@ -171,7 +171,7 @@ describe("wrapOrchestrator", () => {
     expect(wrapOrchestrator(native)).toBe(native);
   });
 
-  it("wraps a single-parameter classic orchestrator and drives it through context.df", () => {
+  it("wraps a single-parameter classic orchestrator and drives it through context.df", async () => {
     const classic = function* (
       context: ClassicOrchestrationContext,
     ): Generator<Task<unknown>, string, unknown> {
@@ -185,14 +185,19 @@ describe("wrapOrchestrator", () => {
     expect(wrapped).not.toBe(classic);
 
     const { ctx, raw } = createFakeCoreContext();
-    const gen = wrapped(ctx, "INPUT") as Generator<unknown, unknown, unknown>;
-
-    const firstYield = gen.next();
+    // The engine gates on Symbol.asyncIterator: the wrapper MUST return an async generator or the
+    // core executor never drives it (it would complete immediately with the raw return value).
+    const gen = wrapped(ctx, "INPUT") as AsyncGenerator<unknown, unknown, unknown>;
+    expect(typeof (gen as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator]).toBe(
+      "function",
+    );
+
+    const firstYield = await gen.next();
     expect(raw.callActivity).toHaveBeenCalledWith("a", "INPUT");
     expect(firstYield.value).toBe("callActivity-task");
     expect(firstYield.done).toBe(false);
 
-    const final = gen.next("ACTIVITY_RESULT");
+    const final = await gen.next("ACTIVITY_RESULT");
     expect(final.done).toBe(true);
     expect(final.value).toBe("done:ACTIVITY_RESULT");
   });