diff --git a/src/main/java/com/google/mockwebserver/BaseMockResponse.java b/src/main/java/com/google/mockwebserver/BaseMockResponse.java
new file mode 100644
index 0000000..a12abf5
--- /dev/null
+++ b/src/main/java/com/google/mockwebserver/BaseMockResponse.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.mockwebserver;
+
+import static com.google.mockwebserver.MockWebServer.ASCII;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Base scripted response to be replayed by {@link MockWebServer}.
+ */
+abstract class BaseMockResponse<T extends BaseMockResponse<T>> {
+    protected static final String CONTENT_LENGTH = "Content-Length";
+
+    private String status = "HTTP/1.1 200 OK";
+    private List<String> headers = new ArrayList<String>();
+    private int bytesPerSecond = Integer.MAX_VALUE;
+    private SocketPolicy socketPolicy = SocketPolicy.KEEP_OPEN;
+
+    protected BaseMockResponse() {
+    }
+
+    @Override
+    protected Object clone() throws CloneNotSupportedException {
+        final BaseMockResponse<?> result = (BaseMockResponse<?>) super.clone();
+        result.headers = new ArrayList<String>(result.headers);
+        return result;
+    }
+
+    /**
+     * Returns the HTTP response line, such as "HTTP/1.1 200 OK".
+     */
+    public String getStatus() {
+        return status;
+    }
+
+    public T setResponseCode(int code) {
+        this.status = "HTTP/1.1 " + code + " OK";
+        return self();
+    }
+
+    public T setStatus(String status) {
+        this.status = status;
+        return self();
+    }
+
+    /**
+     * Returns the HTTP headers, such as "Content-Length: 0".
+     */
+    public List<String> getHeaders() {
+        return headers;
+    }
+
+    public T clearHeaders() {
+        headers.clear();
+        return self();
+    }
+
+    public T addHeader(String header) {
+        headers.add(header);
+        return self();
+    }
+
+    public T addHeader(String name, Object value) {
+        return addHeader(name + ": " + String.valueOf(value));
+    }
+
+    public T setHeader(String name, Object value) {
+        removeHeader(name);
+        return addHeader(name, value);
+    }
+
+    public T removeHeader(String name) {
+        name += ": ";
+        for (Iterator<String> i = headers.iterator(); i.hasNext();) {
+            String header = i.next();
+            if (name.regionMatches(true, 0, header, 0, name.length())) {
+                i.remove();
+            }
+        }
+        return self();
+    }
+
+    public SocketPolicy getSocketPolicy() {
+        return socketPolicy;
+    }
+
+    public T setSocketPolicy(SocketPolicy socketPolicy) {
+        this.socketPolicy = socketPolicy;
+        return self();
+    }
+
+    public int getBytesPerSecond() {
+        return bytesPerSecond;
+    }
+
+    /**
+     * Set simulated network speed, in bytes per second.
+     */
+    public T setBytesPerSecond(int bytesPerSecond) {
+        this.bytesPerSecond = bytesPerSecond;
+        return self();
+    }
+
+    @Override public String toString() {
+        return status;
+    }
+
+    /**
+     * Write complete response, including all headers and the given body.
+     * Handles applying {@link #setBytesPerSecond(int)} limits.
+     */
+    protected void writeResponse(InputStream body, OutputStream out) throws IOException {
+        out.write((getStatus() + "\r\n").getBytes(ASCII));
+        for (String header : getHeaders()) {
+            out.write((header + "\r\n").getBytes(ASCII));
+        }
+        out.write(("\r\n").getBytes(ASCII));
+        out.flush();
+
+        // Stream data in MTU-sized increments
+        final byte[] buffer = new byte[1452];
+        final long delayMs;
+        if (bytesPerSecond == Integer.MAX_VALUE) {
+            delayMs = 0;
+        } else {
+            delayMs = (1000 * buffer.length) / bytesPerSecond;
+        }
+
+        int read;
+        long sinceDelay = 0;
+        while ((read = body.read(buffer)) != -1) {
+            out.write(buffer, 0, read);
+            out.flush();
+
+            sinceDelay += read;
+            if (sinceDelay >= buffer.length && delayMs > 0) {
+                sinceDelay %= buffer.length;
+                try {
+                    Thread.sleep(delayMs);
+                } catch (InterruptedException e) {
+                    throw new AssertionError();
+                }
+            }
+        }
+    }
+
+    /**
+     * Write complete response. Usually implemented by calling
+     * {@link #writeResponse(InputStream, OutputStream)} with the
+     * implementation-specific body.
+     */
+    public abstract void writeResponse(OutputStream out) throws IOException;
+
+    /**
+     * Return concrete {@code this} to enable builder-style methods.
+     */
+    protected abstract T self();
+}
diff --git a/src/main/java/com/google/mockwebserver/MockResponse.java b/src/main/java/com/google/mockwebserver/MockResponse.java
index 64eb8f3..8f11996 100644
--- a/src/main/java/com/google/mockwebserver/MockResponse.java
+++ b/src/main/java/com/google/mockwebserver/MockResponse.java
@@ -21,132 +21,35 @@
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
+import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
 
 /**
- * A scripted response to be replayed by the mock web server.
+ * A scripted response to be replayed by {@link MockWebServer}.
  */
-public final class MockResponse implements Cloneable {
-    private static final String EMPTY_BODY_HEADER = "Content-Length: 0";
+public class MockResponse extends BaseMockResponse<MockResponse> implements Cloneable {
     private static final String CHUNKED_BODY_HEADER = "Transfer-encoding: chunked";
 
-    private String status = "HTTP/1.1 200 OK";
-    private List<String> headers = new ArrayList<String>();
-    private InputStream body;
-    private long bodyLength;
-    private int bytesPerSecond = Integer.MAX_VALUE;
-    private SocketPolicy socketPolicy = SocketPolicy.KEEP_OPEN;
+    private byte[] body;
 
     public MockResponse() {
-        headers.add(EMPTY_BODY_HEADER);
+        this.body = new byte[0];
+        addHeader(CONTENT_LENGTH, 0);
     }
 
-    @Override public MockResponse clone() {
+    @Override
+    public MockResponse clone() {
         try {
-            MockResponse result = (MockResponse) super.clone();
-            result.headers = new ArrayList<String>(result.headers);
-            return result;
+            return (MockResponse) super.clone();
         } catch (CloneNotSupportedException e) {
             throw new AssertionError();
         }
     }
 
-    /**
-     * Returns the HTTP response line, such as "HTTP/1.1 200 OK".
-     */
-    public String getStatus() {
-        return status;
-    }
-
-    public MockResponse setResponseCode(int code) {
-        this.status = "HTTP/1.1 " + code + " OK";
-        return this;
-    }
-
-    public MockResponse setStatus(String status) {
-        this.status = status;
-        return this;
-    }
-
-    /**
-     * Returns the HTTP headers, such as "Content-Length: 0".
-     */
-    public List<String> getHeaders() {
-        return headers;
-    }
-
-    public MockResponse clearHeaders() {
-        headers.clear();
-        return this;
-    }
-
-    public MockResponse addHeader(String header) {
-        headers.add(header);
-        return this;
-    }
-
-    public MockResponse addHeader(String name, Object value) {
-        return addHeader(name + ": " + String.valueOf(value));
-    }
-
-    public MockResponse setHeader(String name, Object value) {
-        removeHeader(name);
-        return addHeader(name, value);
-    }
-
-    public MockResponse removeHeader(String name) {
-        name += ": ";
-        for (Iterator<String> i = headers.iterator(); i.hasNext();) {
-            String header = i.next();
-            if (name.regionMatches(true, 0, header, 0, name.length())) {
-                i.remove();
-            }
-        }
-        return this;
-    }
-
-    /**
-     * Returns a {@code byte[]} containing the raw HTTP payload. This is less
-     * efficient than {@link #getBodyStream()}.
-     */
-    public byte[] getBody() {
-        try {
-            return readFullyNoClose(body);
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    /**
-     * Returns an input stream containing the raw HTTP payload.
-     */
-    public InputStream getBodyStream() {
-        return body;
-    }
-
-    /**
-     * Returns length of raw HTTP payload.
-     */
-    public long getBodyLength() {
-        return bodyLength;
-    }
-
-    public MockResponse setBody(InputStream body, long bodyLength) {
-        if (this.body == null) {
-            headers.remove(EMPTY_BODY_HEADER);
-        }
-        this.headers.add("Content-Length: " + bodyLength);
-        this.body = body;
-        this.bodyLength = bodyLength;
-        return this;
-    }
-
     public MockResponse setBody(byte[] body) {
-        return setBody(new ByteArrayInputStream(body), body.length);
+        this.body = body;
+        setHeader(CONTENT_LENGTH, body.length);
+        return this;
     }
 
     public MockResponse setBody(String body) {
@@ -157,9 +60,13 @@
         }
     }
 
+    public byte[] getBody() {
+        return body;
+    }
+
     public MockResponse setChunkedBody(byte[] body, int maxChunkSize) throws IOException {
-        headers.remove(EMPTY_BODY_HEADER);
-        headers.add(CHUNKED_BODY_HEADER);
+        removeHeader(CONTENT_LENGTH);
+        addHeader(CHUNKED_BODY_HEADER);
 
         ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
         int pos = 0;
@@ -173,9 +80,7 @@
         }
         bytesOut.write("0\r\n\r\n".getBytes(ASCII)); // last chunk + empty trailer + crlf
 
-        body = bytesOut.toByteArray();
-        this.body = new ByteArrayInputStream(body);
-        this.bodyLength = body.length;
+        this.body = bytesOut.toByteArray();
         return this;
     }
 
@@ -183,38 +88,13 @@
         return setChunkedBody(body.getBytes(ASCII), maxChunkSize);
     }
 
-    public SocketPolicy getSocketPolicy() {
-        return socketPolicy;
-    }
-
-    public MockResponse setSocketPolicy(SocketPolicy socketPolicy) {
-        this.socketPolicy = socketPolicy;
+    @Override
+    protected MockResponse self() {
         return this;
     }
 
-    public int getBytesPerSecond() {
-        return bytesPerSecond;
-    }
-
-    /**
-     * Set simulated network speed, in bytes per second.
-     */
-    public MockResponse setBytesPerSecond(int bytesPerSecond) {
-        this.bytesPerSecond = bytesPerSecond;
-        return this;
-    }
-
-    @Override public String toString() {
-        return status;
-    }
-
-    private static byte[] readFullyNoClose(InputStream in) throws IOException {
-        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
-        byte[] buffer = new byte[1024];
-        int count;
-        while ((count = in.read(buffer)) != -1) {
-            bytes.write(buffer, 0, count);
-        }
-        return bytes.toByteArray();
+    @Override
+    public void writeResponse(OutputStream out) throws IOException {
+        super.writeResponse(new ByteArrayInputStream(body), out);
     }
 }
diff --git a/src/main/java/com/google/mockwebserver/MockStreamResponse.java b/src/main/java/com/google/mockwebserver/MockStreamResponse.java
new file mode 100644
index 0000000..9db1c3c
--- /dev/null
+++ b/src/main/java/com/google/mockwebserver/MockStreamResponse.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.mockwebserver;
+
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * A scripted response to be replayed by {@link MockWebServer}. This specific
+ * variant uses an {@link InputStream} as its data source. Each instance can
+ * only be consumed once.
+ */
+public class MockStreamResponse extends BaseMockResponse<MockStreamResponse> {
+    private InputStream body;
+
+    public MockStreamResponse() {
+        body = new ByteArrayInputStream(new byte[0]);
+        addHeader(CONTENT_LENGTH, 0);
+    }
+
+    public MockStreamResponse setBody(InputStream body, long bodyLength) {
+        // Release any existing body
+        if (this.body != null) {
+            closeQuietly(this.body);
+        }
+
+        this.body = body;
+        setHeader(CONTENT_LENGTH, bodyLength);
+        return this;
+    }
+
+    @Override
+    public void writeResponse(OutputStream out) throws IOException {
+        if (body == null) {
+            throw new IllegalStateException("Stream already consumed");
+        }
+
+        try {
+            super.writeResponse(body, out);
+        } finally {
+            closeQuietly(body);
+        }
+        body = null;
+    }
+
+    @Override
+    protected MockStreamResponse self() {
+        return this;
+    }
+
+    private static void closeQuietly(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (RuntimeException rethrown) {
+                throw rethrown;
+            } catch (Exception ignored) {
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/google/mockwebserver/MockWebServer.java b/src/main/java/com/google/mockwebserver/MockWebServer.java
index 6173c88..b774eff 100644
--- a/src/main/java/com/google/mockwebserver/MockWebServer.java
+++ b/src/main/java/com/google/mockwebserver/MockWebServer.java
@@ -51,6 +51,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSocket;
 import javax.net.ssl.SSLSocketFactory;
@@ -68,8 +69,8 @@
     private static final Logger logger = Logger.getLogger(MockWebServer.class.getName());
     private final BlockingQueue<RecordedRequest> requestQueue
             = new LinkedBlockingQueue<RecordedRequest>();
-    private final BlockingQueue<MockResponse> responseQueue
-            = new LinkedBlockingDeque<MockResponse>();
+    private final BlockingQueue<BaseMockResponse<?>> responseQueue
+            = new LinkedBlockingDeque<BaseMockResponse<?>>();
     private final Set<Socket> openClientSockets
             = Collections.newSetFromMap(new ConcurrentHashMap<Socket, Boolean>());
     private boolean singleResponse;
@@ -158,8 +159,12 @@
         return requestCount.get();
     }
 
-    public void enqueue(MockResponse response) {
-        responseQueue.add(response.clone());
+    public void enqueue(BaseMockResponse<?> response) {
+        if (response instanceof MockResponse) {
+            responseQueue.add(((MockResponse) response).clone());
+        } else {
+            responseQueue.add(response);
+        }
     }
 
     /**
@@ -236,7 +241,7 @@
                     } catch (SocketException ignored) {
                         continue;
                     }
-                    MockResponse peek = responseQueue.peek();
+                    BaseMockResponse<?> peek = responseQueue.peek();
                     if (peek != null && peek.getSocketPolicy() == DISCONNECT_AT_START) {
                         responseQueue.take();
                         socket.close();
@@ -274,7 +279,7 @@
                     if (tunnelProxy) {
                         createTunnel();
                     }
-                    MockResponse response = responseQueue.peek();
+                    BaseMockResponse<?> response = responseQueue.peek();
                     if (response != null && response.getSocketPolicy() == FAIL_HANDSHAKE) {
                         processHandshakeFailure(raw, sequenceNumber++);
                         return;
@@ -312,7 +317,7 @@
              */
             private void createTunnel() throws IOException, InterruptedException {
                 while (true) {
-                    MockResponse connect = responseQueue.peek();
+                    BaseMockResponse<?> connect = responseQueue.peek();
                     if (!processOneRequest(raw, raw.getInputStream(), raw.getOutputStream())) {
                         throw new IllegalStateException("Tunnel without any CONNECT!");
                     }
@@ -332,8 +337,8 @@
                 if (request == null) {
                     return false;
                 }
-                MockResponse response = dispatch(request);
-                writeResponse(out, response);
+                BaseMockResponse<?> response = dispatch(request);
+                response.writeResponse(out);
                 if (response.getSocketPolicy() == SocketPolicy.DISCONNECT_AT_END) {
                     in.close();
                     out.close();
@@ -450,7 +455,7 @@
     /**
      * Returns a response to satisfy {@code request}.
      */
-    private MockResponse dispatch(RecordedRequest request) throws InterruptedException {
+    private BaseMockResponse<?> dispatch(RecordedRequest request) throws InterruptedException {
         if (responseQueue.isEmpty()) {
             throw new IllegalStateException("Unexpected request: " + request);
         }
@@ -471,44 +476,6 @@
         }
     }
 
-    private void writeResponse(OutputStream out, MockResponse response) throws IOException {
-        out.write((response.getStatus() + "\r\n").getBytes(ASCII));
-        for (String header : response.getHeaders()) {
-            out.write((header + "\r\n").getBytes(ASCII));
-        }
-        out.write(("\r\n").getBytes(ASCII));
-        out.flush();
-
-        final InputStream in = response.getBodyStream();
-        final int bytesPerSecond = response.getBytesPerSecond();
-
-        // Stream data in MTU-sized increments
-        final byte[] buffer = new byte[1452];
-        final long delayMs;
-        if (bytesPerSecond == Integer.MAX_VALUE) {
-            delayMs = 0;
-        } else {
-            delayMs = (1000 * buffer.length) / bytesPerSecond;
-        }
-
-        int read;
-        long sinceDelay = 0;
-        while ((read = in.read(buffer)) != -1) {
-            out.write(buffer, 0, read);
-            out.flush();
-
-            sinceDelay += read;
-            if (sinceDelay >= buffer.length && delayMs > 0) {
-                sinceDelay %= buffer.length;
-                try {
-                    Thread.sleep(delayMs);
-                } catch (InterruptedException e) {
-                    throw new AssertionError();
-                }
-            }
-        }
-    }
-
     /**
      * Transfer bytes from {@code in} to {@code out} until either {@code length}
      * bytes have been transferred or {@code in} is exhausted.