experimental-ash 0.23.0 → 0.24.0

package/dist/src/execution/task-mode.d.ts

@@ -2,8 +2,8 @@
  * Creates the invariant error raised when task-mode execution attempts to
  * park instead of finishing inside the current invocation.
  *
- * Thrown by `continuousEntry` and `workflow-entry.ts` when the harness
- * returns `next: null` in task mode. The message is stable so callers can
- * assert against it in tests.
+ * Thrown by `workflow-entry.ts` when the harness returns `next: null`
+ * in task mode. The message is stable so callers can assert against it
+ * in tests.
  */
 export declare function createTaskModeWaitError(): Error;

package/dist/src/execution/task-mode.js

@@ -3,9 +3,9 @@ const TASK_MODE_WAIT_ERROR_MESSAGE = "Task mode cannot wait for follow-up input
  * Creates the invariant error raised when task-mode execution attempts to
  * park instead of finishing inside the current invocation.
  *
- * Thrown by `continuousEntry` and `workflow-entry.ts` when the harness
- * returns `next: null` in task mode. The message is stable so callers can
- * assert against it in tests.
+ * Thrown by `workflow-entry.ts` when the harness returns `next: null`
+ * in task mode. The message is stable so callers can assert against it
+ * in tests.
  */
 export function createTaskModeWaitError() {
     return new Error(TASK_MODE_WAIT_ERROR_MESSAGE);

package/dist/src/execution/turn-workflow.d.ts

@@ -0,0 +1,41 @@
+import type { HookPayload, SessionCapabilities } from "#channel/types.js";
+import type { HarnessSession } from "#harness/types.js";
+import type { RunMode } from "#run-mode.js";
+export interface TurnResultPayload {
+    readonly action: "done" | "park";
+    readonly kind: "turn-result";
+    readonly output?: string;
+    readonly serializedContext: Record<string, unknown>;
+    readonly session: HarnessSession;
+}
+export interface TurnErrorPayload {
+    readonly error: unknown;
+    readonly kind: "turn-error";
+}
+export type TurnCompletionPayload = TurnResultPayload | TurnErrorPayload;
+export interface TurnWorkflowInput {
+    readonly capabilities: SessionCapabilities | undefined;
+    readonly completionToken: string;
+    readonly delivery: HookPayload;
+    readonly mode: RunMode;
+    readonly parentWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly session: HarnessSession;
+}
+/**
+ * Short-lived workflow that owns one runtime turn for the durable
+ * driver.
+ *
+ * `parentWritable` is received from the driver input object and
+ * threaded into every step so the child's writes land directly on the
+ * driver run's stream.
+ */
+export declare function turnWorkflow(input: TurnWorkflowInput): Promise<void>;
+/**
+ * Completes a driver-owned one-shot hook with the result of the child
+ * turn workflow.
+ */
+export declare function notifyDriverStep(input: {
+    readonly completionToken: string;
+    readonly payload: TurnCompletionPayload;
+}): Promise<void>;

package/dist/src/execution/turn-workflow.js

@@ -0,0 +1,96 @@
+import { hasPendingInputBatch } from "#harness/input-requests.js";
+import { hasPendingRuntimeActionBatch } from "#harness/runtime-actions.js";
+import { awaitAuthorizationAndResolve } from "#execution/await-authorization-orchestrator.js";
+import { createTaskModeWaitError } from "#execution/task-mode.js";
+import { normalizeSerializableError } from "#execution/workflow-errors.js";
+import { turnStep } from "#execution/workflow-steps.js";
+/**
+ * Short-lived workflow that owns one runtime turn for the durable
+ * driver.
+ *
+ * `parentWritable` is received from the driver input object and
+ * threaded into every step so the child's writes land directly on the
+ * driver run's stream.
+ */
+export async function turnWorkflow(input) {
+    "use workflow";
+    let currentSession = input.session;
+    let currentSerializedContext = input.serializedContext;
+    let currentInput = input.delivery;
+    const parentWritable = input.parentWritable;
+    try {
+        while (true) {
+            const result = await turnStep({
+                input: currentInput,
+                parentWritable,
+                serializedContext: currentSerializedContext,
+                session: currentSession,
+            });
+            currentSession = result.session;
+            currentSerializedContext = result.serializedContext;
+            if (result.action === "done") {
+                await notifyDriverStep({
+                    completionToken: input.completionToken,
+                    payload: {
+                        action: "done",
+                        kind: "turn-result",
+                        output: result.output ?? "",
+                        serializedContext: currentSerializedContext,
+                        session: currentSession,
+                    },
+                });
+                return;
+            }
+            if (result.action === "park") {
+                if (hasPendingRuntimeActionBatch(currentSession) ||
+                    (hasPendingInputBatch(currentSession) && input.capabilities?.requestInput === true) ||
+                    input.mode === "conversation") {
+                    await notifyDriverStep({
+                        completionToken: input.completionToken,
+                        payload: {
+                            action: "park",
+                            kind: "turn-result",
+                            serializedContext: currentSerializedContext,
+                            session: currentSession,
+                        },
+                    });
+                    return;
+                }
+                throw createTaskModeWaitError();
+            }
+            if (result.action === "await-authorization") {
+                const resolved = await awaitAuthorizationAndResolve({
+                    parentWritable,
+                    pendingAuths: result.pendingAuths,
+                    pendingToolCalls: result.pendingToolCalls,
+                    serializedContext: currentSerializedContext,
+                    session: currentSession,
+                });
+                currentSession = resolved.session;
+                currentSerializedContext = resolved.serializedContext;
+                currentInput = undefined;
+                continue;
+            }
+            currentInput = undefined;
+        }
+    }
+    catch (error) {
+        await notifyDriverStep({
+            completionToken: input.completionToken,
+            payload: {
+                error: normalizeSerializableError(error),
+                kind: "turn-error",
+            },
+        });
+        throw error;
+    }
+}
+/**
+ * Completes a driver-owned one-shot hook with the result of the child
+ * turn workflow.
+ */
+export async function notifyDriverStep(input) {
+    "use step";
+    const { resumeHook } = await import("#compiled/@workflow/core/runtime.js");
+    await resumeHook(input.completionToken, input.payload);
+}

package/dist/src/execution/workflow-entry.js

@@ -1,15 +1,13 @@
-import { createHook, getWorkflowMetadata } from "#compiled/@workflow/core/index.js";
+import { createHook, getWorkflowMetadata, getWritable, } from "#compiled/@workflow/core/index.js";
 import { SUBAGENT_ADAPTER_KIND } from "#execution/subagent-adapter.js";
 import { ChannelKey } from "#context/keys.js";
 import { deserializeContext } from "#context/serialize.js";
-import { hasPendingInputBatch } from "#harness/input-requests.js";
 import { coalesceDeliveries } from "#harness/messages.js";
 import { hasProxyInputRequests } from "#harness/proxy-input-requests.js";
 import { accumulateRuntimeActionResults, hasPendingRuntimeActionBatch, } from "#harness/runtime-actions.js";
 import { toErrorMessage } from "#shared/errors.js";
-import { awaitAuthorizationAndResolve } from "#execution/await-authorization-orchestrator.js";
-import { createTaskModeWaitError } from "#execution/task-mode.js";
-import { createSessionStep, dispatchPendingRuntimeActionsStep, durableRunStep, emitTerminalSessionFailureStep, routeProxiedDeliverStep, runProxyInputRequestStep, } from "#execution/workflow-steps.js";
+import { normalizeSerializableError, rebuildSerializableError, } from "#execution/workflow-errors.js";
+import { createSessionStep, dispatchTurnStep, dispatchPendingRuntimeActionsStep, emitTerminalSessionFailureStep, routeProxiedDeliverStep, runProxyInputRequestStep, } from "#execution/workflow-steps.js";
 /**
  * Long-lived workflow entrypoint for the durable runtime.
  *
@@ -30,6 +28,7 @@ export async function workflowEntry(input) {
     // failure emitter can stamp it onto the `session.failed` event
     // even if `createSessionStep` itself throws.
     input.serializedContext["ash.sessionId"] = sessionId;
+    const driverWritable = getWritable();
     try {
         const session = await createSessionStep({
             compiledArtifactsSource: serializedBundle.source,
@@ -37,8 +36,9 @@ export async function workflowEntry(input) {
             nodeId: serializedBundle.nodeId,
             sessionId,
         });
-        return await runWorkflowLoop({
+        return await runDriverLoop({
             capabilities,
+            driverWritable,
             initialInput: {
                 kind: "deliver",
                 payloads: [{ message: input.input.message, modelContext: input.input.modelContext }],
@@ -61,6 +61,7 @@ export async function workflowEntry(input) {
         // itself cannot import `internal/logging.ts` (node:util gate).
         await emitTerminalSessionFailureStep({
             error: normalizeSerializableError(error),
+            parentWritable: driverWritable,
             serializedContext: input.serializedContext,
         });
         await notifyDelegatedParentStep({
@@ -70,34 +71,19 @@ export async function workflowEntry(input) {
         throw error;
     }
 }
-/**
- * Reduces an arbitrary throwable to a shape that survives the
- * serialization the workflow devkit performs on step inputs.
- *
- * Native `Error` objects do not cross the step boundary cleanly —
- * their stack, cause chain, and non-enumerable `message` / `name`
- * fields are dropped by structured clone. We project the error onto
- * a plain object whose own properties the downstream step can inspect
- * via the same `util.inspect` dump the logger uses.
- */
-function normalizeSerializableError(error) {
-    if (!(error instanceof Error)) {
-        return error;
-    }
-    return {
-        // Enumerable own properties (HTTP statusCode, responseBody, etc.)
-        // fan out first so the pinned fields below win on collision.
-        ...error,
-        message: error.message,
-        name: error.name,
-        stack: error.stack,
-        cause: error.cause === undefined ? undefined : normalizeSerializableError(error.cause),
-    };
-}
-async function runWorkflowLoop(input) {
+async function runDriverLoop(input) {
     let currentSession = input.session;
     let currentSerializedContext = input.serializedContext;
-    let currentResult = await runTurn(currentSerializedContext, currentSession, input.initialInput, input.mode, input.capabilities);
+    let turnGeneration = 0;
+    let currentResult = await dispatchAndAwaitTurn({
+        capabilities: input.capabilities,
+        delivery: input.initialInput,
+        mode: input.mode,
+        parentWritable: input.driverWritable,
+        serializedContext: currentSerializedContext,
+        session: currentSession,
+        turnGeneration: ++turnGeneration,
+    });
     const bufferedDeliveries = [];
     currentSession = currentResult.session;
     currentSerializedContext = currentResult.serializedContext;
@@ -112,7 +98,7 @@ async function runWorkflowLoop(input) {
     // `ctx.session.setContinuationToken(...)` (e.g. Slack auto-anchor on
     // first post). `currentSession.continuationToken` already reflects
     // the latest token thanks to `reconcileSessionContinuationToken`
-    // inside `durableRunStep`, so creating the park hook here lands at
+    // inside `turnStep`, so creating the park hook here lands at
     // the right token from the start.
     if (!currentSession.continuationToken) {
         throw new Error("Cannot park: no continuation token available. The channel must " +
@@ -153,6 +139,7 @@ async function runWorkflowLoop(input) {
         while (true) {
             if (hasPendingRuntimeActionBatch(currentSession)) {
                 currentSession = await dispatchPendingRuntimeActionsStep({
+                    parentWritable: input.driverWritable,
                     serializedContext: currentSerializedContext,
                     session: currentSession,
                 });
@@ -161,6 +148,7 @@ async function runWorkflowLoop(input) {
                     getNextPromise,
                     consumeNext,
                     rekeyHook,
+                    parentWritable: input.driverWritable,
                     serializedContext: currentSerializedContext,
                     session: currentSession,
                 });
@@ -169,10 +157,18 @@ async function runWorkflowLoop(input) {
                 }
                 currentSession = runtimeResults.session;
                 currentSerializedContext = runtimeResults.serializedContext;
-                currentResult = await runTurn(currentSerializedContext, currentSession, {
-                    kind: "runtime-action-result",
-                    results: runtimeResults.results,
-                }, input.mode, input.capabilities);
+                currentResult = await dispatchAndAwaitTurn({
+                    capabilities: input.capabilities,
+                    delivery: {
+                        kind: "runtime-action-result",
+                        results: runtimeResults.results,
+                    },
+                    mode: input.mode,
+                    parentWritable: input.driverWritable,
+                    serializedContext: currentSerializedContext,
+                    session: currentSession,
+                    turnGeneration: ++turnGeneration,
+                });
             }
             else {
                 const nextDeliver = await waitForNextDeliver({
@@ -185,6 +181,7 @@ async function runWorkflowLoop(input) {
                 }
                 const remainder = await routeDeliverForChildren({
                     auth: nextDeliver.auth,
+                    parentWritable: input.driverWritable,
                     payloads: nextDeliver.payloads,
                     session: currentSession,
                 });
@@ -193,11 +190,19 @@ async function runWorkflowLoop(input) {
                     // model turn to run right now.
                     continue;
                 }
-                currentResult = await runTurn(currentSerializedContext, currentSession, {
-                    auth: nextDeliver.auth,
-                    kind: "deliver",
-                    payloads: [remainder],
-                }, input.mode, input.capabilities);
+                currentResult = await dispatchAndAwaitTurn({
+                    capabilities: input.capabilities,
+                    delivery: {
+                        auth: nextDeliver.auth,
+                        kind: "deliver",
+                        payloads: [remainder],
+                    },
+                    mode: input.mode,
+                    parentWritable: input.driverWritable,
+                    serializedContext: currentSerializedContext,
+                    session: currentSession,
+                    turnGeneration: ++turnGeneration,
+                });
             }
             currentSession = currentResult.session;
             currentSerializedContext = currentResult.serializedContext;
@@ -217,59 +222,41 @@ async function runWorkflowLoop(input) {
     }
     return { output: "" };
 }
-/**
- * Runs one full turn: loops `durableRunStep` until the harness parks or
- * signals done. Tool-loop continuations (`action: "continue"`) stay
- * inside this loop so each runtime resume maps to exactly one turn.
- */
-async function runTurn(serializedContext, session, input, mode, capabilities) {
-    let currentSession = session;
-    let currentInput = input;
-    let currentSerializedContext = serializedContext;
-    while (true) {
-        const result = await durableRunStep(currentSerializedContext, currentSession, currentInput);
-        currentSession = result.session;
-        currentSerializedContext = result.serializedContext;
-        if (result.action === "done") {
-            return result;
-        }
-        if (result.action === "park") {
-            if (hasPendingRuntimeActionBatch(currentSession)) {
-                return result;
-            }
-            if (hasPendingInputBatch(currentSession) && capabilities?.requestInput === true) {
-                return result;
-            }
-            if (mode === "conversation") {
-                return result;
-            }
-            throw createTaskModeWaitError();
-        }
-        if (result.action === "await-authorization") {
-            // Drive the interactive-OAuth authorization cycle in the
-            // workflow body so `createHook` is called outside a step
-            // (required for stable callback tokens across replay) and
-            // awaiting the hook suspends the run.
-            const resolved = await awaitAuthorizationAndResolve({
-                pendingToolCalls: result.pendingToolCalls,
-                pendingAuths: result.pendingAuths,
-                serializedContext: currentSerializedContext,
-                session: currentSession,
-            });
-            currentSession = resolved.session;
-            currentSerializedContext = resolved.serializedContext;
-            currentInput = undefined;
-            continue;
+async function dispatchAndAwaitTurn(input) {
+    const completionToken = `ash://turn/${input.session.sessionId}/${input.turnGeneration}`;
+    const completion = createHook({ token: completionToken });
+    try {
+        await dispatchTurnStep({
+            capabilities: input.capabilities,
+            completionToken,
+            delivery: input.delivery,
+            mode: input.mode,
+            parentWritable: input.parentWritable,
+            serializedContext: input.serializedContext,
+            session: input.session,
+        });
+        const payload = await awaitHookPayload(completion);
+        if (payload.kind === "turn-error") {
+            throw rebuildSerializableError(payload.error);
         }
-        currentInput = undefined;
+        return payload;
+    }
+    finally {
+        await disposeHook(completion);
+    }
+}
+async function awaitHookPayload(hook) {
+    for await (const value of hook) {
+        return value;
     }
+    throw new Error("Turn completion hook closed before delivering a result.");
 }
 async function waitForPendingRuntimeActionResults(input) {
     let currentSession = input.session;
     // The proxied HITL step persists adapter-state mutations on the
     // context (e.g. Slack's `pendingRequests` cache) and returns the
     // updated serialized context. We thread that forward so subsequent
-    // deliveries and the eventual post-wait `durableRunStep` observe
+    // deliveries and the eventual post-wait `turnStep` observe
     // the cached state instead of re-deserializing a stale snapshot.
     let currentSerializedContext = input.serializedContext;
     const results = await accumulateRuntimeActionResults({
@@ -292,6 +279,7 @@ async function waitForPendingRuntimeActionResults(input) {
                     // parent↔child deadlock this branch exists to prevent.
                     const remainder = await routeDeliverForChildren({
                         auth: value.auth,
+                        parentWritable: input.parentWritable,
                         payloads: value.payloads,
                         session: currentSession,
                     });
@@ -312,6 +300,7 @@ async function waitForPendingRuntimeActionResults(input) {
                 // parent's adapter, record the routing entry, and keep waiting.
                 const proxyResult = await runProxyInputRequestStep({
                     hookPayload: value,
+                    parentWritable: input.parentWritable,
                     serializedContext: currentSerializedContext,
                     session: currentSession,
                 });
@@ -350,6 +339,7 @@ async function routeDeliverForChildren(input) {
     }
     const routed = await routeProxiedDeliverStep({
         auth: input.auth,
+        parentWritable: input.parentWritable,
         payload: coalesced,
         session: input.session,
     });

package/dist/src/execution/workflow-errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Serializes and rebuilds workflow errors across hook and step
+ * boundaries.
+ */
+/**
+ * Reduces an arbitrary throwable to a shape that survives the
+ * serialization the workflow devkit performs on step inputs.
+ */
+export declare function normalizeSerializableError(error: unknown): unknown;
+/**
+ * Rebuilds an {@link Error} from the normalized hook payload sent by a
+ * child workflow.
+ */
+export declare function rebuildSerializableError(error: unknown): Error;

package/dist/src/execution/workflow-errors.js

@@ -0,0 +1,54 @@
+/**
+ * Serializes and rebuilds workflow errors across hook and step
+ * boundaries.
+ */
+/**
+ * Reduces an arbitrary throwable to a shape that survives the
+ * serialization the workflow devkit performs on step inputs.
+ */
+export function normalizeSerializableError(error) {
+    if (!(error instanceof Error)) {
+        return error;
+    }
+    const ownProperties = Object.fromEntries(Object.entries(error));
+    return {
+        ...ownProperties,
+        cause: error.cause === undefined ? undefined : normalizeSerializableError(error.cause),
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+    };
+}
+/**
+ * Rebuilds an {@link Error} from the normalized hook payload sent by a
+ * child workflow.
+ */
+export function rebuildSerializableError(error) {
+    if (!isRecord(error)) {
+        return new Error(String(error));
+    }
+    const message = typeof error.message === "string" ? error.message : String(error);
+    const rebuilt = new Error(message);
+    if (typeof error.name === "string") {
+        rebuilt.name = error.name;
+    }
+    if (typeof error.stack === "string") {
+        rebuilt.stack = error.stack;
+    }
+    if ("cause" in error) {
+        rebuilt.cause = isRecord(error.cause)
+            ? rebuildSerializableError(error.cause)
+            : error.cause;
+    }
+    const mutable = rebuilt;
+    for (const [key, value] of Object.entries(error)) {
+        if (key === "message" || key === "name" || key === "stack" || key === "cause") {
+            continue;
+        }
+        mutable[key] = value;
+    }
+    return rebuilt;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}

package/dist/src/execution/workflow-runtime.d.ts

@@ -1,17 +1,48 @@
+import type { Run } from "#compiled/@workflow/core/runtime.js";
+import type { WorkflowFunction, WorkflowMetadata } from "#compiled/@workflow/core/runtime/start.js";
 import type { Runtime } from "#channel/types.js";
 import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+export declare const LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE = "deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()";
+/**
+ * Workflow function names whose bundled id is stable across deployments
+ * (no `@<pkg.version>` stamp). The bundler reads this set when emitting
+ * the workflow id so cross-deployment routing — `start(ref, args, {
+ * deploymentId: "latest" })` — finds the same workflow on a newer
+ * deployment even when the ash version differs.
+ *
+ * Both halves of the contract (bundler output and runtime reference
+ * template) read this single set so they cannot drift.
+ */
+export declare const STABLE_WORKFLOW_NAMES: ReadonlySet<string>;
 /**
  * Stable workflow reference used by `start()` to locate the workflow
- * entrypoint registered by the Workflow DevKit builder.
+ * entrypoint registered by the Workflow DevKit builder. The id omits
+ * the package version stamp so the long-lived driver can rotate across
+ * deployments without rewriting the registry key.
  */
 export declare const workflowEntryReference: {
     workflowId: string;
 };
 /**
- * Creates a workflow-backed runtime where a single long-lived workflow
- * spans the entire session.
+ * Stable workflow reference used by the driver to dispatch per-turn
+ * child workflow runs. The id omits the package version stamp so
+ * `start(turnWorkflowReference, args, { deploymentId: "latest" })`
+ * routes to the latest deployment's turn workflow even when the ash
+ * version differs from the caller's deployment.
+ */
+export declare const turnWorkflowReference: {
+    workflowId: string;
+};
+/**
+ * Creates a workflow-backed runtime whose long-lived driver owns the
+ * session stream and dispatches each turn as a child workflow run.
  */
 export declare function createWorkflowRuntime(config: {
     readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
     readonly nodeId?: string;
 }): Runtime;
+/**
+ * Starts a workflow on the latest deployment when the active world supports
+ * it, while preserving local/dev worlds that do not implement latest routing.
+ */
+export declare function startWorkflowPreferLatest<TArgs extends unknown[], TResult>(workflow: WorkflowFunction<TArgs, TResult> | WorkflowMetadata, args: TArgs): Promise<Run<unknown> | Run<TResult>>;

package/dist/src/execution/workflow-runtime.js

@@ -6,17 +6,46 @@ import { getCompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-
 import { buildRunContext } from "#execution/runtime-context.js";
 import { RuntimeNoActiveSessionError } from "#execution/runtime-errors.js";
 const WORKFLOW_ENTRY_NAME = "workflowEntry";
+const TURN_WORKFLOW_NAME = "turnWorkflow";
 const ASH_PACKAGE_INFO = resolveInstalledPackageInfo();
+export const LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE = "deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()";
+/**
+ * Workflow function names whose bundled id is stable across deployments
+ * (no `@<pkg.version>` stamp). The bundler reads this set when emitting
+ * the workflow id so cross-deployment routing — `start(ref, args, {
+ * deploymentId: "latest" })` — finds the same workflow on a newer
+ * deployment even when the ash version differs.
+ *
+ * Both halves of the contract (bundler output and runtime reference
+ * template) read this single set so they cannot drift.
+ */
+export const STABLE_WORKFLOW_NAMES = new Set([
+    WORKFLOW_ENTRY_NAME,
+    TURN_WORKFLOW_NAME,
+]);
+const STABLE_ID_BASE = ASH_PACKAGE_INFO.name;
 /**
  * Stable workflow reference used by `start()` to locate the workflow
- * entrypoint registered by the Workflow DevKit builder.
+ * entrypoint registered by the Workflow DevKit builder. The id omits
+ * the package version stamp so the long-lived driver can rotate across
+ * deployments without rewriting the registry key.
  */
 export const workflowEntryReference = {
-    workflowId: `workflow//${ASH_PACKAGE_INFO.name}@${ASH_PACKAGE_INFO.version}//${WORKFLOW_ENTRY_NAME}`,
+    workflowId: `workflow//${STABLE_ID_BASE}//${WORKFLOW_ENTRY_NAME}`,
+};
+/**
+ * Stable workflow reference used by the driver to dispatch per-turn
+ * child workflow runs. The id omits the package version stamp so
+ * `start(turnWorkflowReference, args, { deploymentId: "latest" })`
+ * routes to the latest deployment's turn workflow even when the ash
+ * version differs from the caller's deployment.
+ */
+export const turnWorkflowReference = {
+    workflowId: `workflow//${STABLE_ID_BASE}//${TURN_WORKFLOW_NAME}`,
 };
 /**
- * Creates a workflow-backed runtime where a single long-lived workflow
- * spans the entire session.
+ * Creates a workflow-backed runtime whose long-lived driver owns the
+ * session stream and dispatches each turn as a child workflow run.
  */
 export function createWorkflowRuntime(config) {
     return {
@@ -27,20 +56,15 @@ export function createWorkflowRuntime(config) {
             });
             const ctx = buildRunContext({ bundle, run: input });
             const serializedContext = serializeContext(ctx);
-            const run = await start(workflowEntryReference, [
+            const run = await startWorkflowPreferLatest(workflowEntryReference, [
                 {
                     input: input.input,
                     serializedContext,
                 },
             ]);
-            const result = (async () => {
-                const wfResult = (await run.returnValue);
-                return { status: "completed", output: wfResult.output };
-            })();
             return {
                 continuationToken: input.continuationToken ?? run.runId,
                 events: parseNdjsonStream(getRun(run.runId).getReadable()),
-                result,
                 sessionId: run.runId,
             };
         },
@@ -69,6 +93,24 @@ export function createWorkflowRuntime(config) {
         },
     };
 }
+/**
+ * Starts a workflow on the latest deployment when the active world supports
+ * it, while preserving local/dev worlds that do not implement latest routing.
+ */
+export async function startWorkflowPreferLatest(workflow, args) {
+    try {
+        return await start(workflow, args, { deploymentId: "latest" });
+    }
+    catch (error) {
+        if (!isLatestDeploymentUnsupportedError(error)) {
+            throw error;
+        }
+        return await start(workflow, args);
+    }
+}
+function isLatestDeploymentUnsupportedError(error) {
+    return error instanceof Error && error.message.includes(LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE);
+}
 function normalizeWorkflowHook(value) {
     if (value === null || typeof value !== "object" || !("runId" in value)) {
         throw new Error("Workflow hook did not include a run id.");