[copilot-finds] Bug: First yielded value in orchestrator run() is not validated, causing silent hangs

[github-actions]

Problem

RuntimeOrchestrationContext.run() does not validate that the first value yielded by an orchestrator generator is a Task instance. The resume() method (which processes subsequent yields) already validates this with an instanceof Task check and throws a clear error:

// In resume() — line 184
if (!(value instanceof Task)) {
  throw new Error("The orchestrator generator yielded a non-Task object");
}

However, run() (which processes the first yield) silently accepts any value — null, undefined, plain objects, or primitives — and assigns it to _previousTask without validation. There was even a TODO comment acknowledging this gap: "// TODO: check if the task is null?".

File: packages/durabletask-js/src/worker/runtime-orchestration-context.ts, lines 109–132

Root Cause

The run() method was written without the same validation guard that resume() has. When the generator yields a non-Task value on its first yield:

1. _previousTask is set to the non-Task value (e.g., null, 42, {foo: "bar"})
2. The instanceof Task check on the isComplete guard fails silently — no error, just skips
3. Later, when resume() is called by a completion event, it checks _previousTask.isFailed and _previousTask.isComplete — both are undefined on non-Task values
4. The generator is never advanced, and the orchestration hangs indefinitely with no error

Impact

• Severity: Medium — causes orchestrations to hang silently with no error message
• Affected scenarios: Any orchestrator that accidentally yields a non-Task value on its first yield (e.g., a raw Promise, null, or forgetting to call a context method that returns a Task)
• Debugging difficulty: High — no error is thrown, no log is emitted; the orchestration simply stops progressing

[github-actions]

Branch copilot-finds/bug/validate-first-yield-in-orchestrator-run has been pushed with the fix and tests. A PR could not be created automatically because GitHub Actions is not permitted to create pull requests in this repo.

To create the PR manually:

gh pr create --head copilot-finds/bug/validate-first-yield-in-orchestrator-run --base main \
  --title "[copilot-finds] Bug: Validate first yielded value in orchestrator run() to prevent silent hangs" \
  --label copilot-finds

Changes summary

Source fix (runtime-orchestration-context.ts):

• Added instanceof Task validation on the first yielded value in run(), matching the existing validation in resume()
• Non-Task yields now throw: "The orchestrator generator yielded a non-Task object"
• Removed stale TODO comment and redundant instanceof guard

Tests (orchestration_executor.spec.ts):

• 4 new tests: yielding null, undefined, plain object, or primitive as first value → orchestration fails with clear error

All 911 unit tests pass. Lint passes.

[github-actions]

Verification Report

PR: #164 — fix: Validate first yielded value in orchestrator run() method
Verified by: pr-verification-agent
Date: 2026-04-13T18:49:27Z
Emulator: DTS emulator (localhost:8080)

Scenario

A developer writes an orchestrator that accidentally yields a raw Promise instead of a Task from ctx.callActivity(). Before PR #164, the orchestration would hang indefinitely with no error. After the fix, the SDK immediately fails with a clear error: "The orchestrator generator yielded a non-Task object".

Verification Sample

Click to expand sample code

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

// Verification sample for PR #164: Validate first yielded value in orchestrator run()
//
// Customer scenario: A developer writes a data-enrichment orchestrator that accidentally
// yields a raw Promise (from a helper function) instead of a Task from ctx.callActivity().
// Before this fix, the orchestration would hang indefinitely with no error — the developer
// would have no indication of what went wrong. After the fix, the SDK immediately fails
// with a clear error: "The orchestrator generator yielded a non-Task object".
//
// This sample verifies two things:
// 1. A correct orchestrator (yielding Tasks) still works normally.
// 2. A buggy orchestrator (yielding a non-Task value) now fails fast with a clear error
//    instead of hanging forever.

import {
  OrchestrationContext,
  ActivityContext,
  TOrchestrator,
  OrchestrationStatus,
} from "@microsoft/durabletask-js";
import {
  DurableTaskAzureManagedClientBuilder,
  DurableTaskAzureManagedWorkerBuilder,
} from "@microsoft/durabletask-js-azuremanaged";

const endpoint = process.env.ENDPOINT || "localhost:8080";
const taskHub = process.env.TASKHUB || "default";

// --- Activities ---

// Simulates fetching enrichment data from an external service
const fetchEnrichmentData = async (_ctx: ActivityContext, recordId: string): Promise<string> => {
  return `enriched-data-for-${recordId}`;
};

// --- Orchestrators ---

// CORRECT orchestrator: yields a Task from ctx.callActivity()
const correctEnrichmentOrchestrator: TOrchestrator = async function* (ctx: OrchestrationContext): any {
  const result: string = yield ctx.callActivity(fetchEnrichmentData, "record-001");
  return { enriched: true, data: result };
};

// BUGGY orchestrator: accidentally yields a raw Promise instead of a Task.
// This simulates a common developer mistake — calling a helper function that returns
// a Promise directly, rather than using ctx.callActivity().
const buggyEnrichmentOrchestrator: TOrchestrator = async function* (_ctx: OrchestrationContext): any {
  // Bug: yielding a raw Promise instead of ctx.callActivity(...)
  // Before PR #164, this would cause the orchestration to hang indefinitely.
  // After PR #164, this throws: "The orchestrator generator yielded a non-Task object"
  yield Promise.resolve("this-is-not-a-task");
};

async function main() {
  console.log(`Connecting to DTS emulator at ${endpoint}, taskHub: ${taskHub}`);

  const client = new DurableTaskAzureManagedClientBuilder()
    .endpoint(endpoint, taskHub, null)
    .build();

  const worker = new DurableTaskAzureManagedWorkerBuilder()
    .endpoint(endpoint, taskHub, null)
    .build();

  worker.addNamedOrchestrator("CorrectEnrichment", correctEnrichmentOrchestrator);
  worker.addNamedOrchestrator("BuggyEnrichment", buggyEnrichmentOrchestrator);
  worker.addNamedActivity("fetchEnrichmentData", fetchEnrichmentData);

  await worker.start();
  console.log("Worker started.");

  let allPassed = true;

  // --- Test 1: Correct orchestrator should complete successfully ---
  console.log("\n--- Test 1: Correct orchestrator (yields Task) ---");
  const correctId = await client.scheduleNewOrchestration("CorrectEnrichment");
  console.log(`Scheduled correct orchestration: ${correctId}`);

  const correctState = await client.waitForOrchestrationCompletion(correctId, undefined, 30);
  const correctPassed = correctState?.runtimeStatus === OrchestrationStatus.COMPLETED;
  console.log(`Status: ${correctState?.runtimeStatus}`);
  console.log(`Output: ${correctState?.serializedOutput}`);
  console.log(`Result: ${correctPassed ? "PASS" : "FAIL"}`);
  if (!correctPassed) allPassed = false;

  // --- Test 2: Buggy orchestrator should FAIL (not hang) with clear error ---
  console.log("\n--- Test 2: Buggy orchestrator (yields non-Task Promise) ---");
  const buggyId = await client.scheduleNewOrchestration("BuggyEnrichment");
  console.log(`Scheduled buggy orchestration: ${buggyId}`);

  const buggyState = await client.waitForOrchestrationCompletion(buggyId, undefined, 30);
  const buggyFailed = buggyState?.runtimeStatus === OrchestrationStatus.FAILED;
  const hasNonTaskError = buggyState?.failureDetails?.message?.includes("non-Task") ?? false;
  const buggyPassed = buggyFailed && hasNonTaskError;
  console.log(`Status: ${buggyState?.runtimeStatus}`);
  console.log(`Failure message: ${buggyState?.failureDetails?.message ?? "none"}`);
  console.log(`Result: ${buggyPassed ? "PASS" : "FAIL"}`);
  if (!buggyPassed) allPassed = false;

  // --- Verification summary ---
  console.log("\n=== VERIFICATION RESULT ===");
  console.log(
    JSON.stringify(
      {
        pr: 164,
        scenario: "validate-first-yield-non-task",
        checks: [
          {
            name: "Correct orchestrator completes successfully",
            expected: "COMPLETED",
            actual: OrchestrationStatus[correctState?.runtimeStatus ?? -1] ?? String(correctState?.runtimeStatus),
            passed: correctPassed,
          },
          {
            name: "Buggy orchestrator fails fast with non-Task error",
            expected: "FAILED with non-Task message",
            actual: `${OrchestrationStatus[buggyState?.runtimeStatus ?? -1] ?? buggyState?.runtimeStatus} - ${buggyState?.failureDetails?.message ?? "no error"}`,
            passed: buggyPassed,
          },
        ],
        allPassed,
        timestamp: new Date().toISOString(),
      },
      null,
      2,
    ),
  );

  await worker.stop();
  await client.stop();

  process.exit(allPassed ? 0 : 1);
}

main().catch((err) => {
  console.error("Verification failed with error:", err);
  process.exit(1);
});

Sample Code Branch

• Branch: verification/pr-164 (view branch)

Results

Check	Expected	Actual	Status
Correct orchestrator completes successfully	COMPLETED	COMPLETED	✅ PASS
Buggy orchestrator fails fast with non-Task error	FAILED with "non-Task" message	FAILED - "The orchestrator generator yielded a non-Task object"	✅ PASS

Console Output

Click to expand full output

Connecting to DTS emulator at localhost:8080, taskHub: default
Worker started.

--- Test 1: Correct orchestrator (yields Task) ---
Scheduled correct orchestration: e83a3801-8480-4d73-b578-4a5c2ae92a60
Status: 1
Output: {"enriched":true,"data":"enriched-data-for-record-001"}
Result: PASS

--- Test 2: Buggy orchestrator (yields non-Task Promise) ---
Scheduled buggy orchestration: 0c007196-ba38-431e-8b2a-581b67501f69
Status: 3
Failure message: The orchestrator generator yielded a non-Task object
Result: PASS

=== VERIFICATION RESULT ===
{
  "pr": 164,
  "scenario": "validate-first-yield-non-task",
  "checks": [
    {
      "name": "Correct orchestrator completes successfully",
      "expected": "COMPLETED",
      "actual": "COMPLETED",
      "passed": true
    },
    {
      "name": "Buggy orchestrator fails fast with non-Task error",
      "expected": "FAILED with non-Task message",
      "actual": "FAILED - The orchestrator generator yielded a non-Task object",
      "passed": true
    }
  ],
  "allPassed": true,
  "timestamp": "2026-04-13T18:49:27.324Z"
}

Conclusion

All verification checks passed. The fix works as described in the PR. Orchestrators that yield non-Task values on their first yield now fail immediately with a clear error message ("The orchestrator generator yielded a non-Task object") instead of hanging indefinitely. Verification sample pushed to verification/pr-164 branch.