diff --git a/.changeset/workflows-local-explorer-step-output.md b/.changeset/workflows-local-explorer-step-output.md
new file mode 100644
index 0000000000..26e707b2ca
--- /dev/null
+++ b/.changeset/workflows-local-explorer-step-output.md
@@ -0,0 +1,7 @@
+---
+"miniflare": minor
+---
+
+Add full step output retrieval to the Workflows local explorer
+
+The Workflows instance details response truncates streamed step outputs to a short preview (or a placeholder for binary streams). Mirroring the production `/step` endpoint, the local explorer now exposes `GET /workflows/{workflow_name}/instances/{instance_id}/step`, which returns a flat `{ status, error, output }` body for a single step. The explorer UI fetches this on demand when a step whose inline preview was truncated is expanded.
diff --git a/packages/local-explorer-ui/src/__tests__/workflows/step-helpers.test.ts b/packages/local-explorer-ui/src/__tests__/workflows/step-helpers.test.ts
index a62630f894..25f34b5d38 100644
--- a/packages/local-explorer-ui/src/__tests__/workflows/step-helpers.test.ts
+++ b/packages/local-explorer-ui/src/__tests__/workflows/step-helpers.test.ts
@@ -1,4 +1,5 @@
 import { describe, test } from "vitest";
+import { isTruncatedStreamPreview } from "../../components/workflows/helpers";
 import {
 	getStepDisplayName,
 	getStepKey,
@@ -106,3 +107,31 @@ describe("getRestartFromStepParam", () => {
 		});
 	});
 });
+
+describe("isTruncatedStreamPreview", () => {
+	test("detects a truncated text preview", ({ expect }) => {
+		expect(isTruncatedStreamPreview("some output[truncated output]")).toBe(
+			true
+		);
+	});
+
+	test("detects a binary stream placeholder", ({ expect }) => {
+		expect(
+			isTruncatedStreamPreview("[ReadableStream (binary): 2048 bytes]")
+		).toBe(true);
+	});
+
+	test("detects an incomplete stream placeholder", ({ expect }) => {
+		expect(isTruncatedStreamPreview("[ReadableStream: 100 bytes]")).toBe(true);
+	});
+
+	test("returns false for a complete inline value", ({ expect }) => {
+		expect(isTruncatedStreamPreview("hello world")).toBe(false);
+	});
+
+	test("returns false for non-string values", ({ expect }) => {
+		expect(isTruncatedStreamPreview({ foo: "bar" })).toBe(false);
+		expect(isTruncatedStreamPreview(undefined)).toBe(false);
+		expect(isTruncatedStreamPreview(42)).toBe(false);
+	});
+});
diff --git a/packages/local-explorer-ui/src/components/workflows/CopyButton.tsx b/packages/local-explorer-ui/src/components/workflows/CopyButton.tsx
index df859c69f5..98484ada79 100644
--- a/packages/local-explorer-ui/src/components/workflows/CopyButton.tsx
+++ b/packages/local-explorer-ui/src/components/workflows/CopyButton.tsx
@@ -4,9 +4,11 @@ import { useState, type JSX } from "react";
 export function CopyButton({
 	text,
 	label = "Copy",
+	disabled = false,
 }: {
 	text: string;
 	label?: string;
+	disabled?: boolean;
 }): JSX.Element {
 	const [copied, setCopied] = useState(false);
 
@@ -19,7 +21,8 @@ export function CopyButton({
 
 	return (
 		<button
-			className="inline-flex size-7 cursor-pointer items-center justify-center rounded-md text-kumo-subtle transition-colors hover:bg-kumo-fill"
+			className="inline-flex size-7 cursor-pointer items-center justify-center rounded-md text-kumo-subtle transition-colors hover:bg-kumo-fill disabled:cursor-not-allowed disabled:opacity-40"
+			disabled={disabled}
 			onClick={handleCopy}
 			title={label}
 		>
diff --git a/packages/local-explorer-ui/src/components/workflows/StepRow.tsx b/packages/local-explorer-ui/src/components/workflows/StepRow.tsx
index c92c512a8f..6ab3497dfa 100644
--- a/packages/local-explorer-ui/src/components/workflows/StepRow.tsx
+++ b/packages/local-explorer-ui/src/components/workflows/StepRow.tsx
@@ -1,8 +1,13 @@
 import { Loader, Tooltip } from "@cloudflare/kumo";
 import { ArrowClockwiseIcon, CheckIcon, PlusIcon } from "@phosphor-icons/react";
-import { memo, type JSX } from "react";
+import { memo, useEffect, useState, type JSX } from "react";
+import { workflowsGetStepOutput } from "../../api";
 import { CopyButton } from "./CopyButton";
-import { formatDuration, formatJson } from "./helpers";
+import {
+	formatDuration,
+	formatJson,
+	isTruncatedStreamPreview,
+} from "./helpers";
 import { ScrollableCodeBlock } from "./ScrollableCodeBlock";
 import { Timestamp } from "./Timestamp";
 import type { StepData } from "./types";
@@ -73,11 +78,15 @@ export const StepRow = memo(function StepRow({
 	isExpanded,
 	onToggleExpanded,
 	onRestartFromStep,
+	workflowName,
+	instanceId,
 }: {
 	step: StepData;
 	isExpanded: boolean;
 	onToggleExpanded: () => void;
 	onRestartFromStep?: (step: StepData) => void;
+	workflowName?: string;
+	instanceId?: string;
 }): JSX.Element {
 	const hasDetails =
 		step.type === "step" ||
@@ -151,7 +160,13 @@ export const StepRow = memo(function StepRow({
 				<div className="-mx-1 -mb-1">
 					<div className="mt-1 h-2 rounded-t-lg border-t border-kumo-fill" />
 					<div className="px-4 pt-3 pb-4">
-						{step.type === "step" && <StepDoDetails step={step} />}
+						{step.type === "step" && (
+							<StepDoDetails
+								step={step}
+								workflowName={workflowName}
+								instanceId={instanceId}
+							/>
+						)}
 						{step.type === "waitForEvent" && (
 							<WaitForEventDetails step={step} />
 						)}
@@ -165,24 +180,139 @@ export const StepRow = memo(function StepRow({
 function StepCodeCard({
 	label,
 	content,
+	loading = false,
+	note,
 }: {
 	label: string;
 	content: string;
+	loading?: boolean;
+	note?: string;
 }): JSX.Element {
 	return (
 		<div>
 			<h5 className="mb-2 text-sm font-medium text-kumo-default">{label}</h5>
 			<div className="relative overflow-hidden rounded-lg border border-kumo-fill bg-kumo-base">
-				<ScrollableCodeBlock content={content} />
+				{loading ? (
+					<div className="flex items-center gap-2 p-3 text-sm text-kumo-subtle">
+						<Loader size={14} />
+						Loading full output…
+					</div>
+				) : (
+					<ScrollableCodeBlock content={content} />
+				)}
 				<div className="absolute top-1.5 right-1.5">
-					<CopyButton text={content} label={`Copy ${label.toLowerCase()}`} />
+					<CopyButton
+						text={content}
+						label={`Copy ${label.toLowerCase()}`}
+						disabled={loading}
+					/>
 				</div>
 			</div>
+			{note && <p className="mt-1 text-xs text-kumo-subtle">{note}</p>}
 		</div>
 	);
 }
 
-function StepDoDetails({ step }: { step: StepData }): JSX.Element {
+type FullOutputState =
+	| { status: "idle" }
+	| { status: "loading" }
+	| { status: "loaded"; text: string; note?: string }
+	| { status: "error" };
+
+function bytesToBase64(bytes: Uint8Array): string {
+	let binary = "";
+	const chunkSize = 0x8000;
+	for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+		binary += String.fromCharCode(
+			...bytes.subarray(offset, offset + chunkSize)
+		);
+	}
+	return btoa(binary);
+}
+
+// Lazily fetch the full output when the inline value is only a truncated stream
+// preview. Streamed outputs come back as octet-stream bytes, else flat JSON.
+function useFullStepOutput(
+	step: StepData,
+	workflowName?: string,
+	instanceId?: string
+): FullOutputState {
+	const needsFetch =
+		step.success === true && isTruncatedStreamPreview(step.output);
+	const [state, setState] = useState<FullOutputState>({ status: "idle" });
+
+	useEffect(() => {
+		if (!needsFetch || !workflowName || !instanceId || !step.name) {
+			return;
+		}
+		let active = true;
+		setState({ status: "loading" });
+		void workflowsGetStepOutput({
+			path: { workflow_name: workflowName, instance_id: instanceId },
+			query: { name: step.name, type: "step" },
+			parseAs: "arrayBuffer",
+			throwOnError: false,
+		})
+			.then((res) => {
+				if (!active) {
+					return;
+				}
+				const buffer = res.data as unknown as ArrayBuffer | undefined;
+				if (!res.response.ok || !buffer) {
+					setState({ status: "error" });
+					return;
+				}
+				const bytes = new Uint8Array(buffer);
+				const contentType = res.response.headers.get("content-type") ?? "";
+				if (contentType.includes("application/octet-stream")) {
+					try {
+						const text = new TextDecoder("utf-8", { fatal: true }).decode(
+							bytes
+						);
+						setState({ status: "loaded", text });
+					} catch {
+						setState({
+							status: "loaded",
+							text: bytesToBase64(bytes),
+							note: `Binary output (${bytes.byteLength} bytes), base64-encoded`,
+						});
+					}
+					return;
+				}
+				const parsed = JSON.parse(new TextDecoder().decode(bytes)) as {
+					result?: { output?: unknown };
+				};
+				setState({
+					status: "loaded",
+					text: formatJson(parsed.result?.output),
+				});
+			})
+			.catch(() => {
+				if (active) {
+					setState({ status: "error" });
+				}
+			});
+		return () => {
+			active = false;
+		};
+	}, [needsFetch, workflowName, instanceId, step.name]);
+
+	return needsFetch ? state : { status: "idle" };
+}
+
+function StepDoDetails({
+	step,
+	workflowName,
+	instanceId,
+}: {
+	step: StepData;
+	workflowName?: string;
+	instanceId?: string;
+}): JSX.Element {
+	const fullOutput = useFullStepOutput(step, workflowName, instanceId);
+	const isTruncated =
+		step.success === true && isTruncatedStreamPreview(step.output);
+
 	// Get error text from last failed attempt
 	const failedAttempt =
 		step.success === false && step.attempts
@@ -191,10 +321,27 @@ function StepDoDetails({ step }: { step: StepData }): JSX.Element {
 	const errorText = failedAttempt?.error
 		? `${failedAttempt.error.name}: ${failedAttempt.error.message}`
 		: null;
-	const outputText =
-		step.success === true && step.output !== undefined
-			? formatJson(step.output)
-			: null;
+
+	// Resolve the output card: full fetched value when the inline output is a
+	// truncated stream preview, otherwise the inline value.
+	let outputLoading = false;
+	let outputNote: string | undefined;
+	let outputText: string | null = null;
+	if (step.success === true) {
+		if (isTruncated) {
+			if (fullOutput.status === "loaded") {
+				outputText = fullOutput.text;
+				outputNote = fullOutput.note;
+			} else if (fullOutput.status === "error") {
+				outputText = formatJson(step.output);
+			} else {
+				outputLoading = true;
+				outputText = "";
+			}
+		} else if (step.output !== undefined) {
+			outputText = formatJson(step.output);
+		}
+	}
 
 	// Left side: output or error. Right side: config.
 	const leftLabel = errorText ? "Error" : "Output";
@@ -207,7 +354,12 @@ function StepDoDetails({ step }: { step: StepData }): JSX.Element {
 			<div
 				className={configContent ? "grid grid-cols-1 gap-4 md:grid-cols-2" : ""}
 			>
-				<StepCodeCard label={leftLabel} content={leftContent} />
+				<StepCodeCard
+					label={leftLabel}
+					content={leftContent}
+					loading={!errorText && outputLoading}
+					note={errorText ? undefined : outputNote}
+				/>
 				{configContent && (
 					<StepCodeCard label="Config" content={configContent} />
 				)}
diff --git a/packages/local-explorer-ui/src/components/workflows/helpers.ts b/packages/local-explorer-ui/src/components/workflows/helpers.ts
index d296605698..13248faa4d 100644
--- a/packages/local-explorer-ui/src/components/workflows/helpers.ts
+++ b/packages/local-explorer-ui/src/components/workflows/helpers.ts
@@ -55,6 +55,16 @@ export function timeAgo(dateString: string | undefined): string {
 	return `${days}d ago`;
 }
 
+const STREAM_PREVIEW_TRUNCATED_MARKER = "[truncated output]";
+
+export function isTruncatedStreamPreview(value: unknown): value is string {
+	return (
+		typeof value === "string" &&
+		(value.endsWith(STREAM_PREVIEW_TRUNCATED_MARKER) ||
+			value.startsWith("[ReadableStream"))
+	);
+}
+
 export function formatJson(value: unknown): string {
 	if (value === null || value === undefined) {
 		return "N/A";
diff --git a/packages/local-explorer-ui/src/routes/workflows/$workflowName/$instanceId.tsx b/packages/local-explorer-ui/src/routes/workflows/$workflowName/$instanceId.tsx
index 931f347886..99a4574a3a 100644
--- a/packages/local-explorer-ui/src/routes/workflows/$workflowName/$instanceId.tsx
+++ b/packages/local-explorer-ui/src/routes/workflows/$workflowName/$instanceId.tsx
@@ -244,9 +244,13 @@ const STEP_TYPE_FILTERS = [
 const StepHistory = memo(function StepHistory({
 	steps,
 	onRestartFromStep,
+	workflowName,
+	instanceId,
 }: {
 	steps: InstanceDetails["steps"];
 	onRestartFromStep?: (step: StepData) => void;
+	workflowName: string;
+	instanceId: string;
 }) {
 	const stepList = steps ?? [];
 	const [search, setSearch] = useState("");
@@ -361,6 +365,8 @@ const StepHistory = memo(function StepHistory({
 									isExpanded={expandedStepKeys.has(key)}
 									onToggleExpanded={() => toggleStepExpanded(key)}
 									onRestartFromStep={onRestartFromStep}
+									workflowName={workflowName}
+									instanceId={instanceId}
 								/>
 							);
 						})
@@ -840,6 +846,8 @@ function InstanceDetailView() {
 					<StepHistory
 						steps={details.steps}
 						onRestartFromStep={handleRestartFromStep}
+						workflowName={params.workflowName}
+						instanceId={instanceId}
 					/>
 				</div>
 			</div>
diff --git a/packages/miniflare/scripts/openapi-filter-config.ts b/packages/miniflare/scripts/openapi-filter-config.ts
index d0968087c3..22653d4a02 100644
--- a/packages/miniflare/scripts/openapi-filter-config.ts
+++ b/packages/miniflare/scripts/openapi-filter-config.ts
@@ -1222,6 +1222,107 @@ const config = {
 					tags: ["Workflows"],
 				},
 			},
+			"/workflows/{workflow_name}/instances/{instance_id}/step": {
+				get: {
+					description:
+						"Returns the full output (or error) of a single step. Unlike the instance details endpoint, streamed step outputs are returned in full rather than truncated to a preview.",
+					operationId: "workflows-get-step-output",
+					parameters: [
+						{
+							in: "path",
+							name: "workflow_name",
+							required: true,
+							schema: {
+								$ref: "#/components/schemas/workflows_workflow-name",
+							},
+						},
+						{
+							in: "path",
+							name: "instance_id",
+							required: true,
+							schema: {
+								$ref: "#/components/schemas/workflows_instance-id",
+							},
+						},
+						{
+							in: "query",
+							name: "name",
+							required: true,
+							schema: {
+								type: "string",
+								minLength: 1,
+								description:
+									"Exact step name from the instance logs response, including the generated counter suffix.",
+							},
+						},
+						{
+							in: "query",
+							name: "type",
+							required: true,
+							schema: {
+								type: "string",
+								enum: ["step", "waitForEvent"],
+								description:
+									"Step type to disambiguate step.do and waitForEvent entries that share the same name.",
+							},
+						},
+						{
+							in: "query",
+							name: "attempt",
+							schema: {
+								type: "integer",
+								exclusiveMinimum: 0,
+								description:
+									"Specific attempt number to retrieve output or error for.",
+							},
+						},
+					],
+					responses: {
+						"200": {
+							content: {
+								"application/json": {
+									schema: {
+										allOf: [
+											{
+												$ref: "#/components/schemas/workers_api-response-common",
+											},
+											{
+												properties: {
+													result: {
+														$ref: "#/components/schemas/workflows_step-output",
+													},
+												},
+												type: "object",
+											},
+										],
+									},
+								},
+								"application/octet-stream": {
+									schema: {
+										type: "string",
+										format: "binary",
+										description:
+											"Raw bytes of the ReadableStream returned from step.do.",
+									},
+								},
+							},
+							description: "Get Workflow Step Output response.",
+						},
+						"4XX": {
+							content: {
+								"application/json": {
+									schema: {
+										$ref: "#/components/schemas/workers_api-response-common-failure",
+									},
+								},
+							},
+							description: "Get Workflow Step Output response failure.",
+						},
+					},
+					summary: "Get Workflow Step Output",
+					tags: ["Workflows"],
+				},
+			},
 			"/workflows/{workflow_name}/instances/{instance_id}/events/{event_type}":
 				{
 					post: {
@@ -1867,6 +1968,34 @@ const config = {
 				},
 				required: ["columns", "rows"],
 			},
+			"workflows_step-output": {
+				type: "object",
+				description:
+					"Flat status-shaped output of a single step. `status` is the source of truth; `error` and `output` are populated when relevant. When the step returned a ReadableStream the response is served as application/octet-stream instead of this JSON body.",
+				properties: {
+					status: {
+						type: "string",
+						enum: ["running", "waiting", "complete", "errored"],
+						description:
+							"The step status. 'running' with a non-null error means the step is retrying after a failed attempt.",
+					},
+					error: {
+						type: "object",
+						nullable: true,
+						properties: {
+							name: { type: "string" },
+							message: { type: "string" },
+						},
+						description: "Error details when the step errored, otherwise null.",
+					},
+					output: {
+						nullable: true,
+						description:
+							"The step output value, or null while running/waiting or when errored.",
+					},
+				},
+				required: ["status", "error", "output"],
+			},
 		},
 	},
 } satisfies FilterConfig;
diff --git a/packages/miniflare/src/workers/local-explorer/explorer.worker.ts b/packages/miniflare/src/workers/local-explorer/explorer.worker.ts
index e9b4b12786..1a22ebd049 100644
--- a/packages/miniflare/src/workers/local-explorer/explorer.worker.ts
+++ b/packages/miniflare/src/workers/local-explorer/explorer.worker.ts
@@ -19,6 +19,7 @@ import {
 	zWorkersKvNamespaceListNamespacesData,
 	zObservabilityQueryData,
 	zWorkflowsChangeInstanceStatusData,
+	zWorkflowsGetStepOutputData,
 	zWorkflowsListInstancesData,
 } from "./generated/zod.gen";
 import openApiSpec from "./openapi.local.json";
@@ -47,6 +48,7 @@ import {
 	deleteWorkflowInstance,
 	getWorkflowDetails,
 	getWorkflowInstanceDetails,
+	getWorkflowStepOutput,
 	listWorkflowInstances,
 	listWorkflows,
 	sendWorkflowInstanceEvent,
@@ -323,6 +325,18 @@ app.get("/api/workflows/:workflow_name/instances/:instance_id", (c) =>
 	)
 );
 
+app.get(
+	"/api/workflows/:workflow_name/instances/:instance_id/step",
+	validateQuery(zWorkflowsGetStepOutputData.shape.query),
+	(c) =>
+		getWorkflowStepOutput(
+			c,
+			c.req.param("workflow_name"),
+			c.req.param("instance_id"),
+			c.req.valid("query")
+		)
+);
+
 app.patch(
 	"/api/workflows/:workflow_name/instances/:instance_id/status",
 	validateRequestBody(zWorkflowsChangeInstanceStatusData.shape.body),
diff --git a/packages/miniflare/src/workers/local-explorer/generated/index.ts b/packages/miniflare/src/workers/local-explorer/generated/index.ts
index 4533d80886..0e6cd0e1ae 100644
--- a/packages/miniflare/src/workers/local-explorer/generated/index.ts
+++ b/packages/miniflare/src/workers/local-explorer/generated/index.ts
@@ -199,6 +199,11 @@ export type {
 	WorkflowsGetInstanceDetailsErrors,
 	WorkflowsGetInstanceDetailsResponse,
 	WorkflowsGetInstanceDetailsResponses,
+	WorkflowsGetStepOutputData,
+	WorkflowsGetStepOutputError,
+	WorkflowsGetStepOutputErrors,
+	WorkflowsGetStepOutputResponse,
+	WorkflowsGetStepOutputResponses,
 	WorkflowsGetWorkflowDetailsData,
 	WorkflowsGetWorkflowDetailsError,
 	WorkflowsGetWorkflowDetailsErrors,
@@ -222,6 +227,7 @@ export type {
 	WorkflowsSendInstanceEventErrors,
 	WorkflowsSendInstanceEventResponse,
 	WorkflowsSendInstanceEventResponses,
+	WorkflowsStepOutput,
 	WorkflowsWorkflow,
 	WorkflowsWorkflowDetails,
 	WorkflowsWorkflowName,
diff --git a/packages/miniflare/src/workers/local-explorer/generated/types.gen.ts b/packages/miniflare/src/workers/local-explorer/generated/types.gen.ts
index bbe24d8029..82cc97cfb4 100644
--- a/packages/miniflare/src/workers/local-explorer/generated/types.gen.ts
+++ b/packages/miniflare/src/workers/local-explorer/generated/types.gen.ts
@@ -778,6 +778,27 @@ export type ObservabilityQueryResult = {
 	rows: Array<Array<unknown>>;
 };
 
+/**
+ * Flat status-shaped output of a single step. `status` is the source of truth; `error` and `output` are populated when relevant. When the step returned a ReadableStream the response is served as application/octet-stream instead of this JSON body.
+ */
+export type WorkflowsStepOutput = {
+	/**
+	 * The step status. 'running' with a non-null error means the step is retrying after a failed attempt.
+	 */
+	status: "running" | "waiting" | "complete" | "errored";
+	/**
+	 * Error details when the step errored, otherwise null.
+	 */
+	error: {
+		name?: string;
+		message?: string;
+	} | null;
+	/**
+	 * The step output value, or null while running/waiting or when errored.
+	 */
+	output: unknown;
+};
+
 export type R2ResultInfoWritable = {
 	[key: string]: unknown;
 };
@@ -1792,6 +1813,51 @@ export type WorkflowsChangeInstanceStatusResponses = {
 export type WorkflowsChangeInstanceStatusResponse =
 	WorkflowsChangeInstanceStatusResponses[keyof WorkflowsChangeInstanceStatusResponses];
 
+export type WorkflowsGetStepOutputData = {
+	body?: never;
+	path: {
+		workflow_name: WorkflowsWorkflowName;
+		instance_id: WorkflowsInstanceId;
+	};
+	query: {
+		/**
+		 * Exact step name from the instance logs response, including the generated counter suffix.
+		 */
+		name: string;
+		/**
+		 * Step type to disambiguate step.do and waitForEvent entries that share the same name.
+		 */
+		type: "step" | "waitForEvent";
+		/**
+		 * Specific attempt number to retrieve output or error for.
+		 */
+		attempt?: number;
+	};
+	url: "/workflows/{workflow_name}/instances/{instance_id}/step";
+};
+
+export type WorkflowsGetStepOutputErrors = {
+	/**
+	 * Get Workflow Step Output response failure.
+	 */
+	"4XX": WorkersApiResponseCommonFailure;
+};
+
+export type WorkflowsGetStepOutputError =
+	WorkflowsGetStepOutputErrors[keyof WorkflowsGetStepOutputErrors];
+
+export type WorkflowsGetStepOutputResponses = {
+	/**
+	 * Get Workflow Step Output response.
+	 */
+	200: WorkersApiResponseCommon & {
+		result?: WorkflowsStepOutput;
+	};
+};
+
+export type WorkflowsGetStepOutputResponse =
+	WorkflowsGetStepOutputResponses[keyof WorkflowsGetStepOutputResponses];
+
 export type WorkflowsSendInstanceEventData = {
 	/**
 	 * Optional JSON payload for the event.
diff --git a/packages/miniflare/src/workers/local-explorer/generated/zod.gen.ts b/packages/miniflare/src/workers/local-explorer/generated/zod.gen.ts
index 29cf7fd6b1..a43755e9b4 100644
--- a/packages/miniflare/src/workers/local-explorer/generated/zod.gen.ts
+++ b/packages/miniflare/src/workers/local-explorer/generated/zod.gen.ts
@@ -519,6 +519,20 @@ export const zObservabilityQueryResult = z.object({
 	rows: z.array(z.array(z.unknown())),
 });
 
+/**
+ * Flat status-shaped output of a single step. `status` is the source of truth; `error` and `output` are populated when relevant. When the step returned a ReadableStream the response is served as application/octet-stream instead of this JSON body.
+ */
+export const zWorkflowsStepOutput = z.object({
+	status: z.enum(["running", "waiting", "complete", "errored"]),
+	error: z
+		.object({
+			name: z.string().optional(),
+			message: z.string().optional(),
+		})
+		.nullable(),
+	output: z.unknown(),
+});
+
 export const zR2ResultInfoWritable = z.record(z.unknown());
 
 export const zWorkersNamespaceWritable = z.object({
@@ -1121,6 +1135,28 @@ export const zWorkflowsChangeInstanceStatusResponse =
 		})
 	);
 
+export const zWorkflowsGetStepOutputData = z.object({
+	body: z.never().optional(),
+	path: z.object({
+		workflow_name: zWorkflowsWorkflowName,
+		instance_id: zWorkflowsInstanceId,
+	}),
+	query: z.object({
+		name: z.string().min(1),
+		type: z.enum(["step", "waitForEvent"]),
+		attempt: z.number().int().optional(),
+	}),
+});
+
+/**
+ * Get Workflow Step Output response.
+ */
+export const zWorkflowsGetStepOutputResponse = zWorkersApiResponseCommon.and(
+	z.object({
+		result: zWorkflowsStepOutput.optional(),
+	})
+);
+
 export const zWorkflowsSendInstanceEventData = z.object({
 	body: z.unknown().optional(),
 	path: z.object({
diff --git a/packages/miniflare/src/workers/local-explorer/openapi.local.json b/packages/miniflare/src/workers/local-explorer/openapi.local.json
index 700e8af3e6..37720e7e61 100644
--- a/packages/miniflare/src/workers/local-explorer/openapi.local.json
+++ b/packages/miniflare/src/workers/local-explorer/openapi.local.json
@@ -1863,6 +1863,102 @@
 				"tags": ["Workflows"]
 			}
 		},
+		"/workflows/{workflow_name}/instances/{instance_id}/step": {
+			"get": {
+				"description": "Returns the full output (or error) of a single step. Unlike the instance details endpoint, streamed step outputs are returned in full rather than truncated to a preview.",
+				"operationId": "workflows-get-step-output",
+				"parameters": [
+					{
+						"in": "path",
+						"name": "workflow_name",
+						"required": true,
+						"schema": {
+							"$ref": "#/components/schemas/workflows_workflow-name"
+						}
+					},
+					{
+						"in": "path",
+						"name": "instance_id",
+						"required": true,
+						"schema": {
+							"$ref": "#/components/schemas/workflows_instance-id"
+						}
+					},
+					{
+						"in": "query",
+						"name": "name",
+						"required": true,
+						"schema": {
+							"type": "string",
+							"minLength": 1,
+							"description": "Exact step name from the instance logs response, including the generated counter suffix."
+						}
+					},
+					{
+						"in": "query",
+						"name": "type",
+						"required": true,
+						"schema": {
+							"type": "string",
+							"enum": ["step", "waitForEvent"],
+							"description": "Step type to disambiguate step.do and waitForEvent entries that share the same name."
+						}
+					},
+					{
+						"in": "query",
+						"name": "attempt",
+						"schema": {
+							"type": "integer",
+							"exclusiveMinimum": 0,
+							"description": "Specific attempt number to retrieve output or error for."
+						}
+					}
+				],
+				"responses": {
+					"200": {
+						"content": {
+							"application/json": {
+								"schema": {
+									"allOf": [
+										{
+											"$ref": "#/components/schemas/workers_api-response-common"
+										},
+										{
+											"properties": {
+												"result": {
+													"$ref": "#/components/schemas/workflows_step-output"
+												}
+											},
+											"type": "object"
+										}
+									]
+								}
+							},
+							"application/octet-stream": {
+								"schema": {
+									"type": "string",
+									"format": "binary",
+									"description": "Raw bytes of the ReadableStream returned from step.do."
+								}
+							}
+						},
+						"description": "Get Workflow Step Output response."
+					},
+					"4XX": {
+						"content": {
+							"application/json": {
+								"schema": {
+									"$ref": "#/components/schemas/workers_api-response-common-failure"
+								}
+							}
+						},
+						"description": "Get Workflow Step Output response failure."
+					}
+				},
+				"summary": "Get Workflow Step Output",
+				"tags": ["Workflows"]
+			}
+		},
 		"/workflows/{workflow_name}/instances/{instance_id}/events/{event_type}": {
 			"post": {
 				"description": "Sends an event to a workflow instance.",
@@ -3400,6 +3496,35 @@
 					}
 				},
 				"required": ["columns", "rows"]
+			},
+			"workflows_step-output": {
+				"type": "object",
+				"description": "Flat status-shaped output of a single step. `status` is the source of truth; `error` and `output` are populated when relevant. When the step returned a ReadableStream the response is served as application/octet-stream instead of this JSON body.",
+				"properties": {
+					"status": {
+						"type": "string",
+						"enum": ["running", "waiting", "complete", "errored"],
+						"description": "The step status. 'running' with a non-null error means the step is retrying after a failed attempt."
+					},
+					"error": {
+						"type": "object",
+						"nullable": true,
+						"properties": {
+							"name": {
+								"type": "string"
+							},
+							"message": {
+								"type": "string"
+							}
+						},
+						"description": "Error details when the step errored, otherwise null."
+					},
+					"output": {
+						"nullable": true,
+						"description": "The step output value, or null while running/waiting or when errored."
+					}
+				},
+				"required": ["status", "error", "output"]
 			}
 		}
 	}
diff --git a/packages/miniflare/src/workers/local-explorer/resources/workflows.ts b/packages/miniflare/src/workers/local-explorer/resources/workflows.ts
index f626a48d5a..34def1f9a1 100644
--- a/packages/miniflare/src/workers/local-explorer/resources/workflows.ts
+++ b/packages/miniflare/src/workers/local-explorer/resources/workflows.ts
@@ -8,6 +8,7 @@ import type { AppContext } from "../common";
 import type { Env } from "../explorer.worker";
 import type {
 	WorkflowsChangeInstanceStatusData,
+	WorkflowsGetStepOutputData,
 	WorkflowsWorkflow,
 } from "../generated";
 import type { zWorkflowsListInstancesData } from "../generated/zod.gen";
@@ -15,6 +16,7 @@ import type {
 	RestartFromStep,
 	WorkflowInstanceTerminateOptions,
 } from "@cloudflare/workflows-shared/src/binding";
+import type { StepOutputResult } from "@cloudflare/workflows-shared/src/engine";
 import type { z } from "zod";
 
 // ============================================================================
@@ -60,6 +62,11 @@ interface EngineStub {
 			metadata: Record<string, unknown>;
 		}>
 	>;
+	getStepOutput(options: {
+		name: string;
+		type: "step" | "waitForEvent";
+		attempt?: number;
+	}): Promise<StepOutputResult>;
 }
 
 // InstanceEvent enum values
@@ -156,6 +163,21 @@ const STATUS_NAMES: Record<number, string> = {
 // Helper Functions
 // ============================================================================
 
+/**
+ * Resolve the Engine DO stub for an instance. A 64-char hex string is treated
+ * as a raw DO ID (idFromString); anything else is the instance ID the engine
+ * created the DO from (idFromName).
+ */
+function resolveEngineStub(
+	engineNamespace: DurableObjectNamespace,
+	instanceId: string
+): EngineStub {
+	const stubId = /^[0-9a-f]{64}$/i.test(instanceId)
+		? engineNamespace.idFromString(instanceId)
+		: engineNamespace.idFromName(instanceId);
+	return engineNamespace.get(stubId) as unknown as EngineStub;
+}
+
 /**
  * Get the Engine DO namespace for a workflow.
  * Returns the raw DurableObjectNamespace, allowing direct access via
@@ -589,10 +611,7 @@ export async function getWorkflowInstanceDetails(
 /**
  * Get instance details via the Engine DO directly.
  *
- * Accepts either a real instance ID or a hex DO ID:
- * - Real instance ID (e.g. "my-instance"): uses idFromName() — same mapping
- *   the workflow engine used to create the DO.
- * - Hex DO ID (64-char hex string): uses idFromString() for direct access.
+ * Accepts either a real instance ID or a hex DO ID (see resolveEngineStub).
  */
 async function executeGetInstanceDetails(
 	engineNamespace: DurableObjectNamespace,
@@ -600,11 +619,7 @@ async function executeGetInstanceDetails(
 	c: AppContext
 ): Promise<Response> {
 	try {
-		const isHexId = /^[0-9a-f]{64}$/i.test(instanceId);
-		const stubId = isHexId
-			? engineNamespace.idFromString(instanceId)
-			: engineNamespace.idFromName(instanceId);
-		const stub = engineNamespace.get(stubId) as unknown as EngineStub;
+		const stub = resolveEngineStub(engineNamespace, instanceId);
 
 		const metadata = await stub.getInstanceMetadata();
 
@@ -780,6 +795,95 @@ async function executeGetInstanceDetails(
 	}
 }
 
+type StepOutputQuery = NonNullable<WorkflowsGetStepOutputData["query"]>;
+
+export async function getWorkflowStepOutput(
+	c: AppContext,
+	workflowName: string,
+	instanceId: string,
+	query: StepOutputQuery
+): Promise<Response> {
+	if (query.attempt !== undefined && query.type === "waitForEvent") {
+		return errorResponse(
+			400,
+			10001,
+			"'attempt' is not supported when type is 'waitForEvent'."
+		);
+	}
+
+	const engineNamespace = getEngineNamespace(c.env, workflowName);
+
+	if (engineNamespace) {
+		try {
+			const stub = resolveEngineStub(engineNamespace, instanceId);
+
+			const result = await stub.getStepOutput({
+				name: query.name,
+				type: query.type,
+				attempt: query.attempt,
+			});
+
+			// A ReadableStream output is streamed back as raw bytes
+			if (result.output instanceof ReadableStream) {
+				return new Response(result.output, {
+					status: 200,
+					headers: { "Content-Type": "application/octet-stream" },
+				});
+			}
+
+			return c.json(
+				wrapResponse({
+					status: result.status,
+					error: result.error,
+					output: result.output,
+				})
+			);
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : "Instance not found";
+			if (message.includes("instance.step_not_found")) {
+				return errorResponse(
+					404,
+					WORKFLOW_ERROR_NOT_FOUND,
+					`Step '${query.name}' not found for instance '${instanceId}'.`
+				);
+			}
+			if (
+				message.includes("instance.not_found") ||
+				message === "Engine was never started"
+			) {
+				return errorResponse(
+					404,
+					WORKFLOW_ERROR_NOT_FOUND,
+					`Workflow instance '${instanceId}' not found.`
+				);
+			}
+			return errorResponse(500, 10001, message);
+		}
+	}
+
+	const ownerMiniflare = await findWorkflowOwner(c, workflowName);
+	if (ownerMiniflare) {
+		const params = new URLSearchParams();
+		params.set("name", query.name);
+		params.set("type", query.type);
+		if (query.attempt !== undefined) {
+			params.set("attempt", String(query.attempt));
+		}
+		const peerPath = `/workflows/${encodeURIComponent(workflowName)}/instances/${encodeURIComponent(instanceId)}/step?${params.toString()}`;
+		const response = await fetchFromPeer(ownerMiniflare, peerPath);
+		if (response) {
+			return response;
+		}
+	}
+
+	return errorResponse(
+		404,
+		WORKFLOW_ERROR_NOT_FOUND,
+		`Workflow '${workflowName}' not found.`
+	);
+}
+
 /**
  * Create a new workflow instance.
  *
diff --git a/packages/miniflare/src/workers/local-explorer/route-names.ts b/packages/miniflare/src/workers/local-explorer/route-names.ts
index e5ed4b3390..a779370228 100644
--- a/packages/miniflare/src/workers/local-explorer/route-names.ts
+++ b/packages/miniflare/src/workers/local-explorer/route-names.ts
@@ -24,6 +24,7 @@ const ROUTE_PATTERNS: [RegExp, string][] = [
 		/^\/workflows\/[^/]+\/instances\/[^/]+\/status$/,
 		"workflows.instance.status",
 	],
+	[/^\/workflows\/[^/]+\/instances\/[^/]+\/step$/, "workflows.instance.step"],
 	[/^\/workflows\/[^/]+\/instances\/[^/]+$/, "workflows.instance"],
 	[/^\/workflows\/[^/]+\/instances$/, "workflows.instances"],
 	[/^\/workflows\/[^/]+$/, "workflows.details"],
diff --git a/packages/workflows-shared/src/engine.ts b/packages/workflows-shared/src/engine.ts
index a6e96855e1..dc78ef1c37 100644
--- a/packages/workflows-shared/src/engine.ts
+++ b/packages/workflows-shared/src/engine.ts
@@ -112,6 +112,23 @@ export type EngineLogs = {
 	logs: Log[];
 };
 
+export type StepOutputResult = {
+	status: string;
+	error: { name: string; message: string } | null;
+	output: unknown;
+};
+
+function toStepError(raw: unknown): { name: string; message: string } | null {
+	if (raw !== null && typeof raw === "object") {
+		const e = raw as { name?: unknown; message?: unknown };
+		return {
+			name: typeof e.name === "string" ? e.name : "Error",
+			message: typeof e.message === "string" ? e.message : "",
+		};
+	}
+	return null;
+}
+
 const ENGINE_STATUS_KEY = "ENGINE_STATUS";
 
 const EVENT_MAP_PREFIX = "EVENT_MAP";
@@ -550,6 +567,139 @@ export class Engine extends DurableObject<Env> {
 		};
 	}
 
+	async getStepOutput(options: {
+		name: string;
+		type: "step" | "waitForEvent";
+		attempt?: number;
+	}): Promise<StepOutputResult> {
+		const { name, type, attempt } = options;
+		const startEvent =
+			type === "step" ? InstanceEvent.STEP_START : InstanceEvent.WAIT_START;
+
+		const matchingStep = this.ctx.storage.sql
+			.exec<{ groupKey: string | null }>(
+				"SELECT groupKey FROM states WHERE target = ? AND event = ? LIMIT 1",
+				name,
+				startEvent
+			)
+			.toArray()[0];
+		if (matchingStep === undefined || matchingStep.groupKey === null) {
+			throw createWorkflowError("Step not found", "instance.step_not_found");
+		}
+		const groupKey = matchingStep.groupKey;
+
+		const rows = [
+			...this.ctx.storage.sql.exec<{ event: InstanceEvent; metadata: string }>(
+				"SELECT event, metadata FROM states WHERE groupKey = ? ORDER BY id ASC",
+				groupKey
+			),
+		].map((row) => ({
+			event: row.event,
+			metadata: JSON.parse(row.metadata) as Record<string, unknown>,
+		}));
+
+		const errored = instanceStatusName(InstanceStatus.Errored);
+		const complete = instanceStatusName(InstanceStatus.Complete);
+
+		if (attempt !== undefined) {
+			const terminal = rows.find(
+				(r) =>
+					(r.event === InstanceEvent.ATTEMPT_SUCCESS ||
+						r.event === InstanceEvent.ATTEMPT_FAILURE) &&
+					r.metadata.attempt === attempt
+			);
+			if (terminal === undefined) {
+				const started = rows.some(
+					(r) =>
+						r.event === InstanceEvent.ATTEMPT_START &&
+						r.metadata.attempt === attempt
+				);
+				if (!started) {
+					throw createWorkflowError(
+						"Step not found",
+						"instance.step_not_found"
+					);
+				}
+				return {
+					status: instanceStatusName(InstanceStatus.Running),
+					error: null,
+					output: null,
+				};
+			}
+			if (terminal.event === InstanceEvent.ATTEMPT_FAILURE) {
+				return {
+					status: errored,
+					error: toStepError(terminal.metadata.error),
+					output: null,
+				};
+			}
+			// Successful attempt: the single stored value is shared across attempts.
+		}
+
+		if (type === "waitForEvent") {
+			const waitComplete = rows.find(
+				(r) => r.event === InstanceEvent.WAIT_COMPLETE
+			);
+			if (waitComplete) {
+				const meta = waitComplete.metadata as { payload?: unknown };
+				return { status: complete, error: null, output: meta.payload ?? null };
+			}
+			const timedOut = rows.find(
+				(r) => r.event === InstanceEvent.WAIT_TIMED_OUT
+			);
+			if (timedOut) {
+				return {
+					status: errored,
+					error: toStepError(timedOut.metadata),
+					output: null,
+				};
+			}
+			return {
+				status: instanceStatusName(InstanceStatus.Waiting),
+				error: null,
+				output: null,
+			};
+		}
+
+		const stepSuccess = rows.find(
+			(r) => r.event === InstanceEvent.STEP_SUCCESS
+		);
+		if (stepSuccess) {
+			const streamOutput = stepSuccess.metadata.streamOutput as
+				| { cacheKey: string; meta: StreamOutputMeta }
+				| undefined;
+			if (streamOutput) {
+				const stream = this.replayStreamFromMeta(streamOutput);
+				if (stream !== undefined) {
+					return { status: complete, error: null, output: stream };
+				}
+			}
+			return {
+				status: complete,
+				error: null,
+				output: stepSuccess.metadata.result ?? null,
+			};
+		}
+
+		const stepFailed = rows.some((r) => r.event === InstanceEvent.STEP_FAILURE);
+		if (stepFailed) {
+			const lastAttemptFailure = [...rows]
+				.reverse()
+				.find((r) => r.event === InstanceEvent.ATTEMPT_FAILURE);
+			return {
+				status: errored,
+				error: toStepError(lastAttemptFailure?.metadata.error),
+				output: null,
+			};
+		}
+
+		return {
+			status: instanceStatusName(InstanceStatus.Running),
+			error: null,
+			output: null,
+		};
+	}
+
 	async setStatus(
 		accountId: number,
 		instanceId: string,
diff --git a/packages/workflows-shared/tests/engine.test.ts b/packages/workflows-shared/tests/engine.test.ts
index b0f6304d77..a39ed67e36 100644
--- a/packages/workflows-shared/tests/engine.test.ts
+++ b/packages/workflows-shared/tests/engine.test.ts
@@ -6,11 +6,18 @@ import workerdUnsafe from "workerd:unsafe";
 import { DEFAULT_STEP_LIMIT, InstanceEvent, InstanceStatus } from "../src";
 import { ABORT_REASONS, isAbortError } from "../src/lib/errors";
 import { setTestWorkflowCallback } from "./test-entry";
-import { runWorkflow, runWorkflowAndAwait } from "./utils";
+import {
+	decodeUtf8,
+	encodeUtf8,
+	readStreamBytes,
+	runWorkflow,
+	runWorkflowAndAwait,
+} from "./utils";
 import type {
 	DatabaseInstance,
 	DatabaseVersion,
 	DatabaseWorkflow,
+	Engine,
 	EngineLogs,
 } from "../src/engine";
 import type {
@@ -2305,3 +2312,208 @@ describe("Rollback", () => {
 		expect(countOf(logs, InstanceEvent.ROLLBACK_START)).toBe(0);
 	});
 });
+
+describe("Engine - getStepOutput", () => {
+	it("returns the full text stream output (not truncated)", async ({
+		expect,
+	}) => {
+		// Exceeds the 1024-char preview used by readDetailedLogs
+		const payload = "abcde".repeat(1000);
+		const payloadBytes = encodeUtf8(payload);
+
+		const engineStub = await runWorkflow(
+			"STREAM-GET-STEP-OUTPUT-TEXT",
+			async (_event, step) => {
+				const stream = await step.do("stream step", async () => {
+					return new ReadableStream<Uint8Array>({
+						start(controller) {
+							controller.enqueue(payloadBytes);
+							controller.close();
+						},
+					});
+				});
+				return decodeUtf8(
+					await readStreamBytes(stream as ReadableStream<Uint8Array>)
+				);
+			}
+		);
+
+		await vi.waitUntil(
+			async () => {
+				const logs = (await engineStub.readLogs()) as EngineLogs;
+				return logs.logs.some(
+					(val) => val.event === InstanceEvent.WORKFLOW_SUCCESS
+				);
+			},
+			{ timeout: 5000 }
+		);
+
+		await runInDurableObject(engineStub, async (engine) => {
+			const result = await (engine as Engine).getStepOutput({
+				name: "stream step-1",
+				type: "step",
+			});
+			expect(result.status).toBe("complete");
+			expect(result.error).toBeNull();
+			expect(result.output).toBeInstanceOf(ReadableStream);
+			const bytes = await readStreamBytes(
+				result.output as ReadableStream<Uint8Array>
+			);
+			expect(decodeUtf8(bytes)).toBe(payload);
+		});
+	});
+
+	it("streams full binary output as raw bytes", async ({ expect }) => {
+		const payloadBytes = new Uint8Array([0xff, 0xfe, 0x00, 0x01, 0x80, 0xc0]);
+
+		const engineStub = await runWorkflow(
+			"STREAM-GET-STEP-OUTPUT-BINARY",
+			async (_event, step) => {
+				const stream = await step.do("stream step", async () => {
+					return new ReadableStream<Uint8Array>({
+						start(controller) {
+							controller.enqueue(payloadBytes);
+							controller.close();
+						},
+					});
+				});
+				await readStreamBytes(stream as ReadableStream<Uint8Array>);
+				return "done";
+			}
+		);
+
+		await vi.waitUntil(
+			async () => {
+				const logs = (await engineStub.readLogs()) as EngineLogs;
+				return logs.logs.some(
+					(val) => val.event === InstanceEvent.WORKFLOW_SUCCESS
+				);
+			},
+			{ timeout: 5000 }
+		);
+
+		await runInDurableObject(engineStub, async (engine) => {
+			const result = await (engine as Engine).getStepOutput({
+				name: "stream step-1",
+				type: "step",
+			});
+			expect(result.status).toBe("complete");
+			expect(result.output).toBeInstanceOf(ReadableStream);
+			const bytes = await readStreamBytes(
+				result.output as ReadableStream<Uint8Array>
+			);
+			expect(Array.from(bytes)).toEqual(Array.from(payloadBytes));
+		});
+	});
+
+	it("throws step_not_found for an unknown step", async ({ expect }) => {
+		const engineStub = await runWorkflow(
+			"STREAM-GET-STEP-OUTPUT-MISSING",
+			async (_event, step) => {
+				await step.do("stream step", async () => "ok");
+				return "done";
+			}
+		);
+
+		await vi.waitUntil(
+			async () => {
+				const logs = (await engineStub.readLogs()) as EngineLogs;
+				return logs.logs.some(
+					(val) => val.event === InstanceEvent.WORKFLOW_SUCCESS
+				);
+			},
+			{ timeout: 5000 }
+		);
+
+		await runInDurableObject(engineStub, async (engine) => {
+			await expect(
+				(engine as Engine).getStepOutput({
+					name: "does not exist-1",
+					type: "step",
+				})
+			).rejects.toThrow(/instance\.step_not_found/);
+		});
+	});
+
+	it("returns the waitForEvent payload as output", async ({ expect }) => {
+		const engineStub = await runWorkflow(
+			"GET-STEP-OUTPUT-WAIT",
+			async (_event, step) => {
+				return await step.waitForEvent("awaited event", {
+					type: "my-event",
+					timeout: "10 seconds",
+				});
+			}
+		);
+
+		await vi.waitUntil(
+			async () => {
+				const logs = (await engineStub.readLogs()) as EngineLogs;
+				return logs.logs.some((val) => val.event === InstanceEvent.WAIT_START);
+			},
+			{ timeout: 5000 }
+		);
+
+		await engineStub.receiveEvent({
+			type: "my-event",
+			timestamp: new Date(),
+			payload: { hello: "world" },
+		});
+
+		await vi.waitUntil(
+			async () => {
+				const logs = (await engineStub.readLogs()) as EngineLogs;
+				return logs.logs.some(
+					(val) => val.event === InstanceEvent.WORKFLOW_SUCCESS
+				);
+			},
+			{ timeout: 5000 }
+		);
+
+		await runInDurableObject(engineStub, async (engine) => {
+			const result = await (engine as Engine).getStepOutput({
+				name: "awaited event-1",
+				type: "waitForEvent",
+			});
+			expect(result.status).toBe("complete");
+			expect(result.error).toBeNull();
+			expect(result.output).toEqual({ hello: "world" });
+		});
+	});
+
+	it("returns the attempt error for a failed attempt", async ({ expect }) => {
+		const engineStub = await runWorkflow(
+			"GET-STEP-OUTPUT-ATTEMPT-FAILURE",
+			async (_event, step) => {
+				await step.do(
+					"failing step",
+					{ retries: { limit: 0, delay: 0 } },
+					async () => {
+						throw new Error("boom");
+					}
+				);
+			}
+		);
+
+		await vi.waitUntil(
+			async () => {
+				const logs = (await engineStub.readLogs()) as EngineLogs;
+				return logs.logs.some(
+					(val) => val.event === InstanceEvent.WORKFLOW_FAILURE
+				);
+			},
+			{ timeout: 5000 }
+		);
+
+		await runInDurableObject(engineStub, async (engine) => {
+			const result = await (engine as Engine).getStepOutput({
+				name: "failing step-1",
+				type: "step",
+				attempt: 1,
+			});
+			expect(result.status).toBe("errored");
+			expect(result.output).toBeNull();
+			expect(result.error?.message).toContain("boom");
+		});
+	});
+});
diff --git a/packages/workflows-shared/tests/utils.ts b/packages/workflows-shared/tests/utils.ts
index b1e92d0c5b..8b81b65422 100644
--- a/packages/workflows-shared/tests/utils.ts
+++ b/packages/workflows-shared/tests/utils.ts
@@ -21,6 +21,39 @@ export async function settlePendingWorkflows(): Promise<void> {
 	pendingInits.length = 0;
 }
 
+export function encodeUtf8(str: string): Uint8Array {
+	return new TextEncoder().encode(str);
+}
+
+export function decodeUtf8(bytes: Uint8Array): string {
+	return new TextDecoder().decode(bytes);
+}
+
+export async function readStreamBytes(
+	stream: ReadableStream<Uint8Array>
+): Promise<Uint8Array> {
+	const chunks: Uint8Array[] = [];
+	const reader = stream.getReader();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) {
+			break;
+		}
+		chunks.push(value);
+	}
+	let totalLength = 0;
+	for (const chunk of chunks) {
+		totalLength += chunk.byteLength;
+	}
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return result;
+}
+
 export async function runWorkflow(
 	instanceId: string,
 	callback: (event: unknown, step: WorkflowStep) => Promise<unknown>