relmio 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -7,6 +7,31 @@ checks the registry separately after publication.
 
 ## Unreleased
 
+## [0.8.0] - 2026-08-26
+
+### Added
+
+- Let trusted local backends and development servers receive Chat Adapter turns
+  as opt-in Server-Sent Events, with progress and text deltas followed by one
+  explicit terminal outcome so a completed response is distinguishable from a
+  redacted failure.
+- Let the setup-token-protected local wizard tester show that incremental
+  response flow after a short-lived encrypted credential handoff, without a
+  direct browser-to-adapter request.
+- Refresh the hosted chat experience and local installer presentation, and
+  adopt the Harbor Gate abstract mark across Relmio surfaces.
+
+### Changed
+
+- Document the streaming contract, local tester behavior, and its limits in the
+  canonical endpoint/reference guides and generated hosted documentation.
+
+### Security
+
+- Keep the Chat Adapter experimental, loopback-only, and limited to trusted
+  local backends or development servers; it rejects browser origins and is not
+  an OpenAI `/v1` endpoint or a substitute for an OpenAI Platform API key.
+
 ## [0.7.0] - 2026-08-16
 
 ### Added

package/README.md

@@ -18,13 +18,18 @@ final confirmation before it writes files or deploys a VPS sidecar.
 | --- | --- | --- |
 | Local OpenAI gateway | OpenAI-compatible `/v1` | Your OpenAI Platform API key |
 | Codex App Server | Experimental JSON-RPC/WebSocket | ChatGPT sign-in and a high-trust local capability |
-| Codex Chat Adapter | Experimental `POST /chat` | ChatGPT sign-in and a bearer for trusted local backends |
+| Codex Chat Adapter | Experimental `POST /chat` (JSON or opt-in SSE) | ChatGPT sign-in and a bearer for trusted local backends |
 | n8n sidecar | Private Docker-network `/v1` bridge | A local ChatGPT sign-in file, never a host port |
 
 ChatGPT sign-in does not become an OpenAI Platform API key. Codex transports
 are not generic `/v1` services and should never be exposed on a LAN or public
 network.
 
+The experimental Chat Adapter's SSE stream succeeds only after its
+`terminal: completed` event. Its local tester stays behind the setup-token-
+protected wizard and uses a short-lived encrypted credential handoff, never a
+direct browser-to-adapter request.
+
 ## ChatGPT sign-in lifetime
 
 ChatGPT/Codex sign-in tokens expire, but the official Codex client refreshes

package/docs/brand.md

@@ -12,11 +12,12 @@ applications.
 
 ![Relmio mark](images/brand/relmio-mark.svg)
 
-Two independent lanes converge around a right-facing negative-space arrow. The
-shape represents an authenticated upstream connection being relayed through a
-single compatible interface.
+The **Harbor Gate** mark uses two distinct boundaries around an open passage.
+Its teal entry stands upright while the ink route bends outward, representing
+a local credential boundary and a controlled path for requests and responses.
+The silhouette stays recognizable at favicon size without provider branding.
 
-The mark was developed from the checked-in generated concept source at
+The abstract mark was developed from the checked-in generated concept source at
 [`images/brand/relmio-concept-source.png`](images/brand/relmio-concept-source.png)
 and redrawn as compact SVG geometry for reliable rendering at small sizes.
 

package/docs/images/brand/relmio-mark.svg

@@ -5,12 +5,6 @@
   aria-labelledby="relmio-mark-title"
 >
   <title id="relmio-mark-title">Relmio mark</title>
-  <path
-    fill="#137c74"
-    d="M7 8h19l31 24H41L26 20v10L7 17Z"
-  />
-  <path
-    fill="#12211f"
-    d="M7 47l19-13v10l15-12h16L26 56H7Z"
-  />
+  <path fill="#137c74" d="M8 13 28 5v38c0 4-2 7-6 9L8 59Z" />
+  <path fill="#12211f" d="M36 5l11 5c6 3 9 8 9 15v9c0 3 1 5 3 7l3 3c3 3 3 8 0 11s-8 3-11 0L40 44c-3-3-4-6-4-10Z" />
 </svg>

package/docs/local-endpoints.md

@@ -236,7 +236,7 @@ Protocol: Relmio Codex Chat HTTP
 ```
 
 After completing the same official Codex device-code sign-in, a local backend
-can start a conversation with. Read the bearer rather than placing it in a
+can start a conversation. Read the bearer rather than placing it in a
 shell command:
 
 ```bash
@@ -261,6 +261,24 @@ text:
 }
 ```
 
+To verify incremental delivery, request Relmio's versioned event stream. The
+stream emits `start`, `progress`, zero or more `delta` events, and exactly one
+`terminal` event. A completed terminal includes the `conversationId`; a failed
+terminal is preceded by a redacted `error` event:
+
+```bash
+read -r -s RELMIO_CODEX_CHAT_KEY
+printf '\n'
+printf 'Authorization: Bearer %s\n' "$RELMIO_CODEX_CHAT_KEY" |
+  curl --no-buffer --fail-with-body --silent --show-error \
+    --request POST http://127.0.0.1:14501/chat \
+    --header @- \
+    --header "Accept: text/event-stream" \
+    --header "Content-Type: application/json" \
+    --data '{"input":"What is a robot? Answer in two short sentences."}'
+unset RELMIO_CODEX_CHAT_KEY
+```
+
 Send that `conversationId` with the next `input` to continue the same
 conversation. The adapter initializes the official App Server, starts or
 resumes the thread, runs a read-only conversational turn, and returns the
@@ -301,7 +319,9 @@ This reduces accidental credential transit and storage exposure. It is not
 encryption at rest or end-to-end encryption, and it cannot protect against a
 compromised browser, extension, or local machine. The tester rejects redirects,
 non-loopback URLs, malformed or oversized data, concurrent key use, and
-adapter failures with redacted messages.
+adapter failures with redacted messages. Assistant text appears incrementally
+while the adapter is working; the tester reports success only after the
+completed terminal event arrives.
 
 ## Network and container boundary
 

package/docs/reference.md

@@ -26,6 +26,23 @@ printf 'Authorization: Bearer %s\n' "$RELMIO_CHAT_CLIENT_CREDENTIAL" |
     --data '{"input":"Reply with exactly: adapter works"}'
 ```
 
+Stream a conversation and inspect its explicit terminal state:
+
+```bash
+printf 'Authorization: Bearer %s\n' "$RELMIO_CHAT_CLIENT_CREDENTIAL" |
+  curl --no-buffer --fail-with-body --silent --show-error \
+    --request POST "$RELMIO_CHAT_BASE_URL/chat" \
+    --header @- \
+    --header "Accept: text/event-stream" \
+    --header "Content-Type: application/json" \
+    --data '{"input":"What is love? Answer conversationally."}'
+```
+
+The event order is `start`, `progress`, zero or more `delta` events, then one
+`terminal`. Only `terminal: completed` is success. A failed terminal is
+preceded by a redacted `error` event and must not be treated as a partial
+answer.
+
 Copy the returned `conversationId`, then send a continuation:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relmio",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Install private local OpenAI API and Codex endpoints with explicit provider credential boundaries, plus the existing isolated n8n sidecar.",
   "keywords": [
     "relmio",

package/src/gateway/codex-chat.js

@@ -1,4 +1,4 @@
-import { createHash, timingSafeEqual } from "node:crypto";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import { spawn } from "node:child_process";
 import { createServer } from "node:http";
 import { pathToFileURL } from "node:url";
@@ -12,6 +12,7 @@ const MAX_PROTOCOL_STDOUT_BYTES = 256 * 1024;
 const MAX_PROTOCOL_STDERR_BYTES = 64 * 1024;
 const TURN_TIMEOUT_MS = 120_000;
 const TERMINATION_GRACE_MS = 2_000;
+const KEEPALIVE_INTERVAL_MS = 15_000;
 const CONVERSATIONAL_INSTRUCTION =
   "Provide a conversational answer only. Do not inspect or edit files, run commands, call tools, or access external resources.";
 
@@ -65,6 +66,70 @@ function sendError(response, status, code) {
   sendJson(response, status, { error: { code } });
 }
 
+function acceptsEventStream(request) {
+  if (headerOccurrences(request, "accept") > 1) {
+    return false;
+  }
+  const value = request.headers.accept;
+  return (
+    typeof value === "string" &&
+    value
+      .split(",")
+      .some((entry) => entry.trim().split(";", 1)[0] === "text/event-stream")
+  );
+}
+
+function startEventStream(response, keepaliveIntervalMs) {
+  let ended = false;
+  response.writeHead(200, {
+    "Cache-Control": "no-store",
+    Connection: "keep-alive",
+    "Content-Encoding": "none",
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "X-Accel-Buffering": "no",
+    "X-Content-Type-Options": "nosniff",
+    "X-Relmio-Stream": "v1",
+  });
+  const send = (event, data) => {
+    if (ended || response.writableEnded || response.destroyed) {
+      return;
+    }
+    response.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+  const keepalive = setInterval(() => {
+    if (!ended && !response.writableEnded && !response.destroyed) {
+      response.write(": keepalive\n\n");
+    }
+  }, keepaliveIntervalMs);
+  keepalive.unref?.();
+  send("start", { requestId: randomUUID() });
+  return {
+    send,
+    complete(result) {
+      if (ended) return;
+      send("terminal", {
+        outcome: "completed",
+        conversationId: result.conversationId,
+      });
+      ended = true;
+      clearInterval(keepalive);
+      response.end();
+    },
+    fail(code = "upstream_failed", retryable = true) {
+      if (ended) return;
+      send("error", { code, retryable });
+      send("terminal", { outcome: "failed" });
+      ended = true;
+      clearInterval(keepalive);
+      response.end();
+    },
+    dispose() {
+      ended = true;
+      clearInterval(keepalive);
+    },
+  };
+}
+
 function hasValidBearer(request, verifier) {
   if (headerOccurrences(request, "authorization") !== 1) {
     return false;
@@ -196,6 +261,8 @@ function createAppServerOperation({
   input,
   conversationId,
   packageVersion,
+  onEvent,
+  onFailure,
   signal,
   spawnProcess,
   terminationGraceMs,
@@ -241,6 +308,7 @@ function createAppServerOperation({
     let finalOutput = null;
     let latestDeltaItemId = null;
     let deltaBytes = 0;
+    let emittedDeltaBytes = 0;
     const deltaOutputs = new Map();
     let phase = "initializing";
     let outcome = null;
@@ -298,6 +366,9 @@ function createAppServerOperation({
         return;
       }
       outcome = { error, result };
+      if (error) {
+        onFailure?.(error.message === "timeout" ? "timeout" : "upstream_failed");
+      }
       signal?.removeEventListener?.("abort", abortOperation);
       clearTimeout(timeout);
       timeout = undefined;
@@ -316,6 +387,7 @@ function createAppServerOperation({
     };
     const startThread = () => {
       phase = "thread";
+      onEvent?.("progress", { phase: "starting_thread" });
       write({
         id: 1,
         method: conversationId ? "thread/resume" : "thread/start",
@@ -337,6 +409,7 @@ function createAppServerOperation({
     };
     const startTurn = () => {
       phase = "turn";
+      onEvent?.("progress", { phase: "starting_turn" });
       write({
         id: 2,
         method: "turn/start",
@@ -418,11 +491,13 @@ function createAppServerOperation({
           return;
         }
         deltaBytes += partBytes;
+        emittedDeltaBytes += partBytes;
         latestDeltaItemId = params.itemId;
         deltaOutputs.set(
           params.itemId,
           `${deltaOutputs.get(params.itemId) ?? ""}${params.delta}`,
         );
+        onEvent?.("delta", { text: params.delta });
         return;
       }
       if (message.method === "item/completed") {
@@ -468,6 +543,9 @@ function createAppServerOperation({
           failProtocol();
           return;
         }
+        if (emittedDeltaBytes === 0) {
+          onEvent?.("delta", { text: output });
+        }
         settle(null, { conversationId: threadId, output });
         return;
       }
@@ -552,6 +630,7 @@ function createAppServerOperation({
         },
       },
     });
+    onEvent?.("progress", { phase: "initializing" });
   });
 }
 
@@ -603,6 +682,7 @@ export async function startCodexChatGateway({
   spawnProcess = spawn,
   terminationGraceMs = TERMINATION_GRACE_MS,
   turnTimeoutMs = TURN_TIMEOUT_MS,
+  keepaliveIntervalMs = KEEPALIVE_INTERVAL_MS,
 } = {}) {
   if (!isLoopbackListenHost(host)) {
     throw new TypeError("Codex Chat must listen on a literal loopback-safe host.");
@@ -627,6 +707,13 @@ export async function startCodexChatGateway({
   ) {
     throw new TypeError("The Codex Chat turn timeout is invalid.");
   }
+  if (
+    !Number.isSafeInteger(keepaliveIntervalMs) ||
+    keepaliveIntervalMs < 1 ||
+    keepaliveIntervalMs > 60_000
+  ) {
+    throw new TypeError("The Codex Chat keepalive interval is invalid.");
+  }
   const verifier = validateTokenVerifier(tokenVerifier);
   const safePackageVersion = validatePackageVersion(packageVersion);
   let activeOperation = false;
@@ -673,6 +760,7 @@ export async function startCodexChatGateway({
     activeOperation = true;
     const controller = new AbortController();
     let disconnected = false;
+    let eventStream;
     const onDisconnect = () => {
       if (request.aborted || !response.writableEnded) {
         disconnected = true;
@@ -686,9 +774,16 @@ export async function startCodexChatGateway({
         if (disconnected) {
           throw new Error("unavailable");
         }
+        if (acceptsEventStream(request)) {
+          eventStream = startEventStream(response, keepaliveIntervalMs);
+        }
         return createAppServerOperation({
           ...chat,
           packageVersion: safePackageVersion,
+          onEvent: eventStream?.send,
+          onFailure: eventStream
+            ? (code) => eventStream.fail(code)
+            : undefined,
           signal: controller.signal,
           spawnProcess,
           terminationGraceMs,
@@ -697,13 +792,18 @@ export async function startCodexChatGateway({
       })
       .then((result) => {
         if (!disconnected && !response.writableEnded) {
-          sendJson(response, 200, result);
+          if (eventStream) eventStream.complete(result);
+          else sendJson(response, 200, result);
         }
       })
       .catch((error) => {
         if (disconnected || response.writableEnded) {
           return;
         }
+        if (eventStream) {
+          eventStream.fail();
+          return;
+        }
         const status = error?.status;
         const code = error?.code;
         if (status === 413 || status === 499 || code === "invalid_json" || code === "invalid_request") {
@@ -713,6 +813,7 @@ export async function startCodexChatGateway({
         sendError(response, 503, "unavailable");
       })
       .finally(() => {
+        eventStream?.dispose();
         activeOperation = false;
       });
   });

package/src/services/local-chat-test.js

@@ -15,7 +15,7 @@ const MAX_ENDPOINT_LENGTH = 64;
 const MAX_CIPHERTEXT_LENGTH = 4_096;
 const MAX_INPUT_LENGTH = 8_192;
 const MAX_CONVERSATION_ID_LENGTH = 160;
-const MAX_RESPONSE_BYTES = 16 * 1_024;
+const MAX_RESPONSE_BYTES = 512 * 1_024;
 const MAX_OUTPUT_LENGTH = 12 * 1_024;
 
 function requestError(message, statusCode = 400) {
@@ -173,6 +173,130 @@ function parseAdapterResponse(text) {
   };
 }
 
+function parseEventBlock(block) {
+  const dataLines = [];
+  let event;
+  for (const line of block.split(/\r?\n/u)) {
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (!event || dataLines.length === 0) {
+    throw adapterError();
+  }
+  let data;
+  try {
+    data = JSON.parse(dataLines.join("\n"));
+  } catch {
+    throw adapterError();
+  }
+  if (!isPlainObject(data)) {
+    throw adapterError();
+  }
+  return { event, data };
+}
+
+async function consumeAdapterStream(response, onEvent) {
+  if (
+    !/^text\/event-stream(?:\s*;|$)/iu.test(
+      response.headers?.get?.("content-type") ?? "",
+    ) ||
+    response.headers?.get?.("x-relmio-stream") !== "v1"
+  ) {
+    throw adapterError();
+  }
+  const reader = response.body?.getReader?.();
+  if (!reader) {
+    throw adapterError();
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let bytes = 0;
+  let conversationId;
+  let failed = false;
+  let output = "";
+  let terminal = false;
+  const processBlock = (block) => {
+    if (!block.trim() || block.trimStart().startsWith(":")) {
+      return;
+    }
+    const { event, data } = parseEventBlock(block);
+    if (event === "start") {
+      return;
+    }
+    if (event === "progress") {
+      onEvent("progress", { phase: "working" });
+      return;
+    }
+    if (event === "delta") {
+      if (
+        typeof data.text !== "string" ||
+        data.text.length === 0 ||
+        data.text.includes("\0") ||
+        output.length + data.text.length > MAX_OUTPUT_LENGTH
+      ) {
+        throw adapterError();
+      }
+      output += data.text;
+      onEvent("delta", { text: data.text });
+      return;
+    }
+    if (event === "error") {
+      failed = true;
+      return;
+    }
+    if (event === "terminal") {
+      if (terminal || !["completed", "failed"].includes(data.outcome)) {
+        throw adapterError();
+      }
+      terminal = true;
+      failed ||= data.outcome !== "completed";
+      if (!failed) {
+        if (!isBoundedText(data.conversationId, MAX_CONVERSATION_ID_LENGTH)) {
+          throw adapterError();
+        }
+        conversationId = data.conversationId;
+      }
+      return;
+    }
+    throw adapterError();
+  };
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > MAX_RESPONSE_BYTES) {
+        throw adapterError();
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const blocks = buffer.split(/\r?\n\r?\n/u);
+      buffer = blocks.pop() ?? "";
+      for (const block of blocks) processBlock(block);
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) processBlock(buffer);
+  } catch (error) {
+    try {
+      await reader.cancel();
+    } catch {
+      // The adapter stream may already be closed after a malformed terminal.
+    }
+    throw error;
+  } finally {
+    reader.releaseLock?.();
+  }
+
+  if (failed || !terminal || !conversationId || output.length === 0) {
+    throw adapterError();
+  }
+  return { conversationId, output };
+}
+
 function isTimeout(error) {
   return error?.name === "AbortError" || error?.name === "TimeoutError";
 }
@@ -265,8 +389,12 @@ export function createLocalChatTestService({
       }
     },
 
-    async message(untrustedRequest) {
+    async message(untrustedRequest, options = {}) {
       const request = validateMessageRequest(untrustedRequest);
+      const onEvent =
+        typeof options.onEvent === "function" ? options.onEvent : null;
+      const externalSignal =
+        options.signal instanceof AbortSignal ? options.signal : null;
       const session = getLiveSession(request.keyId);
       if (session.inFlight) {
         throw requestError("Wait for the current test message to finish.", 409);
@@ -275,6 +403,7 @@ export function createLocalChatTestService({
       let encryptedCredential;
       let decryptedCredential;
       let authorization;
+      let abortFromCaller;
       let timeout;
       try {
         encryptedCredential = decodeCiphertext(request.encryptedCredential);
@@ -302,6 +431,14 @@ export function createLocalChatTestService({
         let response;
         try {
           session.abortController = new AbortController();
+          abortFromCaller = () => session.abortController?.abort();
+          if (externalSignal?.aborted) {
+            abortFromCaller();
+          } else {
+            externalSignal?.addEventListener("abort", abortFromCaller, {
+              once: true,
+            });
+          }
           timeout = setTimeout(
             () => session.abortController?.abort(),
             requestTimeoutMs,
@@ -309,7 +446,7 @@ export function createLocalChatTestService({
           response = await fetchImpl(`${request.endpointBaseUrl}/chat`, {
             method: "POST",
             headers: {
-              Accept: "application/json",
+              Accept: onEvent ? "text/event-stream" : "application/json",
               Authorization: authorization,
               "Content-Type": "application/json",
             },
@@ -328,9 +465,12 @@ export function createLocalChatTestService({
         if (!response?.ok || response.status < 200 || response.status >= 300) {
           throw adapterError();
         }
-        return parseAdapterResponse(await readBoundedResponse(response));
+        return onEvent
+          ? await consumeAdapterStream(response, onEvent)
+          : parseAdapterResponse(await readBoundedResponse(response));
       } finally {
         clearTimeout(timeout);
+        externalSignal?.removeEventListener("abort", abortFromCaller);
         authorization = undefined;
         encryptedCredential?.fill(0);
         decryptedCredential?.fill(0);

package/src/ui/local.css

@@ -6,6 +6,29 @@
   scroll-behavior: smooth;
 }
 
+.local-wizard .local-eyebrow {
+  margin: 0 0 0.4rem;
+  color: var(--accent-deep);
+  font: 800 0.6875rem/1.2 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.local-wizard .rail {
+  padding: 1rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: color-mix(in srgb, var(--surface) 78%, transparent);
+}
+
+.local-wizard .steps li {
+  min-height: 2.5rem;
+}
+
+.local-wizard .steps li[aria-current="step"] em {
+  color: var(--text);
+}
+
 .local-wizard .status-row {
   margin-bottom: 1rem;
 }
@@ -369,10 +392,14 @@
   display: grid;
   gap: 1rem;
   margin-top: 1.25rem;
-  padding: 1rem;
+  padding: clamp(1rem, 2vw, 1.5rem);
   border: 1px solid var(--accent-border);
   border-radius: var(--radius);
-  background: var(--accent-soft);
+  background:
+    linear-gradient(color-mix(in srgb, var(--accent) 5%, transparent) 1px, transparent 1px),
+    linear-gradient(90deg, color-mix(in srgb, var(--accent) 5%, transparent) 1px, transparent 1px),
+    var(--accent-soft);
+  background-size: 28px 28px;
 }
 
 .chat-tester-heading {
@@ -395,6 +422,42 @@
   margin: 0;
 }
 
+.chat-tester-route {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr) auto minmax(0, 1fr);
+  align-items: center;
+  gap: 0.625rem;
+  padding: 0.75rem;
+  border: 1px solid var(--accent-border);
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--surface) 92%, transparent);
+}
+
+.chat-tester-route > span {
+  display: grid;
+  gap: 0.2rem;
+  min-width: 0;
+}
+
+.chat-tester-route strong,
+.chat-tester-route small {
+  overflow-wrap: anywhere;
+}
+
+.chat-tester-route strong {
+  font-size: 0.8125rem;
+}
+
+.chat-tester-route small {
+  color: var(--text-muted);
+  font: 0.6875rem/1.3 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+
+.chat-tester-route i {
+  color: var(--accent-deep);
+  font-style: normal;
+}
+
 .chat-tester-form fieldset {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -460,6 +523,16 @@
   background: var(--accent-soft);
 }
 
+.chat-tester-turn-incomplete {
+  border-color: var(--warning-border);
+  border-style: dashed;
+  background: var(--warning-soft);
+}
+
+.chat-tester-turn-incomplete strong {
+  color: var(--warning);
+}
+
 .chat-tester-turn strong {
   display: block;
   margin-bottom: 0.25rem;
@@ -497,6 +570,14 @@
     flex-direction: column;
   }
 
+  .chat-tester-route {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .chat-tester-route i {
+    transform: rotate(90deg);
+  }
+
   .review-details div {
     grid-template-columns: minmax(0, 1fr);
     gap: 0.2rem;

package/src/ui/local.html

@@ -10,7 +10,7 @@
     <title>Relmio | Local Endpoint Setup</title>
     <link
       rel="icon"
-      href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Cpath fill='%23137c74' d='M7 8h19l31 24H41L26 20v10L7 17Z'/%3E%3Cpath fill='%2312211f' d='M7 47l19-13v10l15-12h16L26 56H7Z'/%3E%3C/svg%3E"
+      href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Cpath fill='%23137c74' d='M8 13 28 5v38c0 4-2 7-6 9L8 59Z'/%3E%3Cpath fill='%2312211f' d='M36 5l11 5c6 3 9 8 9 15v9c0 3 1 5 3 7l3 3c3 3 3 8 0 11s-8 3-11 0L40 44c-3-3-4-6-4-10Z'/%3E%3C/svg%3E"
     />
     <link rel="stylesheet" href="/styles.css" />
     <link rel="stylesheet" href="/local.css" />
@@ -28,8 +28,8 @@
           aria-hidden="true"
           focusable="false"
         >
-          <path fill="#137c74" d="M7 8h19l31 24H41L26 20v10L7 17Z" />
-          <path fill="#12211f" d="M7 47l19-13v10l15-12h16L26 56H7Z" />
+          <path fill="#137c74" d="M8 13 28 5v38c0 4-2 7-6 9L8 59Z" />
+          <path fill="#12211f" d="M36 5l11 5c6 3 9 8 9 15v9c0 3 1 5 3 7l3 3c3 3 3 8 0 11s-8 3-11 0L40 44c-3-3-4-6-4-10Z" />
         </svg>
         <span>Relmio</span>
       </div>
@@ -90,9 +90,10 @@
     <main id="main-content" class="shell" tabindex="-1">
       <aside class="rail" aria-label="Local setup progress and safety">
         <section class="intro" aria-labelledby="page-title">
-          <h1 id="page-title">Run Relmio on localhost</h1>
+          <p class="local-eyebrow">Local pre-flight</p>
+          <h1 id="page-title">One boundary at a time</h1>
           <p class="lede">
-            Choose the official credential path that matches your client. All
+            Run Relmio on localhost. Choose the official credential path that matches your client. All
             three options run in hardened Docker containers and bind only to
             <code>127.0.0.1</code>.
           </p>
@@ -519,7 +520,7 @@
         >
           <div class="chat-tester-heading">
             <div>
-              <p class="section-label">Local-only tester</p>
+              <p class="section-label">Streaming verification console</p>
               <h3 id="chat-tester-title">Test this local Chat Adapter</h3>
               <p>
                 Relmio sends this browser only to its same-origin local wizard.
@@ -535,6 +536,14 @@
             </button>
           </div>
 
+          <div class="chat-tester-route" aria-label="Request route">
+            <span><strong>Browser</strong><small>Same origin</small></span>
+            <i aria-hidden="true">→</i>
+            <span><strong>Wizard relay</strong><small>Encrypted session</small></span>
+            <i aria-hidden="true">→</i>
+            <span><strong>Chat Adapter</strong><small>127.0.0.1 only</small></span>
+          </div>
+
           <form id="chat-tester-secure-form" class="chat-tester-form">
             <fieldset>
               <legend>Secure a temporary test session</legend>

package/src/ui/local.js

@@ -131,6 +131,123 @@ async function api(path, { method = "GET", body } = {}) {
   return result;
 }
 
+function parseRelmioStreamEvent(block) {
+  const dataLines = [];
+  let event;
+  for (const line of block.split(/\r?\n/u)) {
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (!event || dataLines.length === 0) {
+    throw new Error("The local wizard returned an unreadable stream.");
+  }
+  let data;
+  try {
+    data = JSON.parse(dataLines.join("\n"));
+  } catch {
+    throw new Error("The local wizard returned an unreadable stream.");
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("The local wizard returned an unexpected stream event.");
+  }
+  return { event, data };
+}
+
+async function streamChatTesterMessage(body, onEvent) {
+  if (!token) {
+    throw new Error(
+      "This wizard link is incomplete. Close this tab and open the full URL printed by the active Relmio terminal.",
+    );
+  }
+  let response;
+  try {
+    response = await fetch("/api/local/chat-test/message", {
+      method: "POST",
+      headers: {
+        Accept: "text/event-stream",
+        "Content-Type": "application/json",
+        "X-Setup-Token": token,
+      },
+      body: JSON.stringify(body),
+    });
+  } catch {
+    throw new Error("The local Relmio wizard is not reachable. Keep its terminal open and try again.");
+  }
+  if (
+    !response.ok ||
+    !response.body ||
+    !/^text\/event-stream(?:\s*;|$)/iu.test(response.headers.get("content-type") ?? "") ||
+    response.headers.get("x-relmio-stream") !== "v1"
+  ) {
+    throw new Error("The local wizard could not start a safe response stream.");
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let exhausted = false;
+  let streamError;
+  let terminal;
+  const consume = (block) => {
+    if (!block.trim() || block.trimStart().startsWith(":")) return;
+    if (terminal) {
+      throw new Error("The local wizard sent data after the terminal event.");
+    }
+    const item = parseRelmioStreamEvent(block);
+    if (item.event === "start") return;
+    if (item.event === "progress" || item.event === "delta") {
+      onEvent(item.event, item.data);
+      return;
+    }
+    if (item.event === "error") {
+      const messages = {
+        timeout: "The adapter test took too long. Try again.",
+        upstream_failed: "The local adapter could not complete this response.",
+      };
+      streamError = messages[item.data.code] ?? messages.upstream_failed;
+      return;
+    }
+    if (item.event === "terminal") {
+      terminal = item.data;
+      return;
+    }
+    throw new Error("The local wizard returned an unexpected stream event.");
+  };
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) {
+        exhausted = true;
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const blocks = buffer.split(/\r?\n\r?\n/u);
+      buffer = blocks.pop() ?? "";
+      for (const block of blocks) consume(block);
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) consume(buffer);
+  } finally {
+    if (!exhausted) {
+      try {
+        await reader.cancel();
+      } catch {
+        // The same-origin stream may already have closed after a parse failure.
+      }
+    }
+    reader.releaseLock();
+  }
+
+  if (!terminal || terminal.outcome !== "completed" || typeof terminal.conversationId !== "string") {
+    throw new Error(streamError ?? "The adapter response ended before completion.");
+  }
+  return { conversationId: terminal.conversationId };
+}
+
 function selectedTarget() {
   return document.querySelector('input[name="target"]:checked')?.value;
 }
@@ -341,6 +458,7 @@ function appendChatTesterTurn(kind, text) {
   item.className = `chat-tester-turn chat-tester-turn-${kind}`;
   item.append(heading, content);
   element("chat-tester-transcript").append(item);
+  return content;
 }
 
 function clearChatTesterState() {
@@ -756,13 +874,13 @@ element("chat-tester-message-form").addEventListener("submit", async (event) =>
   const generation = state.chatTester.generation;
   input.value = "";
   appendChatTesterTurn("user", text);
+  const assistantContent = appendChatTesterTurn("assistant", "");
   resetButton.disabled = true;
-  setBusy(button, true, "Waiting for adapter…");
-  setChatTesterStatus("The local wizard is testing the adapter without exposing its credential to the page.");
+  setBusy(button, true, "Streaming response…");
+  setChatTesterStatus("Connecting to the loopback adapter through the secured local wizard…");
   try {
-    const result = await api("/api/local/chat-test/message", {
-      method: "POST",
-      body: {
+    const result = await streamChatTesterMessage(
+      {
         endpointBaseUrl: state.chatTester.endpointBaseUrl,
         keyId: state.chatTester.keyId,
         encryptedCredential: state.chatTester.encryptedCredential,
@@ -771,23 +889,37 @@ element("chat-tester-message-form").addEventListener("submit", async (event) =>
           ? { conversationId: state.chatTester.conversationId }
           : {}),
       },
-    });
-    if (
-      typeof result.conversationId !== "string" ||
-      typeof result.output !== "string"
-    ) {
-      throw new Error("The local adapter returned an unexpected response.");
-    }
+      (event, data) => {
+        if (state.chatTester.generation !== generation) return;
+        if (event === "progress") {
+          setChatTesterStatus("The adapter is working on the response…");
+        } else if (event === "delta" && typeof data.text === "string") {
+          assistantContent.textContent += data.text;
+          setChatTesterStatus("Streaming the adapter response…");
+        }
+      },
+    );
     if (state.chatTester.generation !== generation) {
       return;
     }
     state.chatTester.conversationId = result.conversationId;
-    appendChatTesterTurn("assistant", result.output);
+    if (!assistantContent.textContent) {
+      throw new Error("The local adapter completed without a visible response.");
+    }
     setChatTesterStatus("Response received. Continue this conversation or forget the tester.");
   } catch (error) {
     if (state.chatTester.generation === generation) {
+      if (!assistantContent.textContent) {
+        assistantContent.parentElement?.remove();
+        setChatTesterStatus("No completed adapter response was added. You can retry or forget this tester.");
+      } else {
+        const assistantTurn = assistantContent.parentElement;
+        assistantTurn?.classList.add("chat-tester-turn-incomplete");
+        const heading = assistantTurn?.querySelector("strong");
+        if (heading) heading.textContent = "Local adapter · incomplete";
+        setChatTesterStatus("The response stopped before completion. Partial text is marked incomplete and was not accepted.");
+      }
       showChatTesterError(error);
-      setChatTesterStatus("No adapter response was added. You can retry or forget this tester.");
     }
   } finally {
     resetButton.disabled = false;

package/src/web/server.js

@@ -115,6 +115,64 @@ function sendJson(response, statusCode, body) {
   response.end(contents);
 }
 
+function requestAcceptsEventStream(request) {
+  const value = request.headers.accept;
+  return (
+    typeof value === "string" &&
+    value
+      .split(",")
+      .some((entry) => entry.trim().split(";", 1)[0] === "text/event-stream")
+  );
+}
+
+function startLocalChatTestStream(response) {
+  let ended = false;
+  response.writeHead(200, {
+    "Content-Encoding": "none",
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "X-Accel-Buffering": "no",
+    "X-Relmio-Stream": "v1",
+  });
+  const send = (event, data) => {
+    if (ended || response.writableEnded || response.destroyed) return;
+    response.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+  const keepalive = setInterval(() => {
+    if (!ended && !response.writableEnded && !response.destroyed) {
+      response.write(": keepalive\n\n");
+    }
+  }, 15_000);
+  keepalive.unref?.();
+  send("start", { requestId: randomUUID() });
+  return {
+    send(event, data) {
+      if (event === "progress" || event === "delta") send(event, data);
+    },
+    complete(result) {
+      if (ended) return;
+      send("terminal", {
+        outcome: "completed",
+        conversationId: result.conversationId,
+      });
+      ended = true;
+      clearInterval(keepalive);
+      response.end();
+    },
+    fail(code = "upstream_failed") {
+      if (ended) return;
+      send("error", { code, retryable: true });
+      send("terminal", { outcome: "failed" });
+      ended = true;
+      clearInterval(keepalive);
+      response.end();
+    },
+    dispose() {
+      ended = true;
+      clearInterval(keepalive);
+    },
+  };
+}
+
 function tokenMatches(actual, expected) {
   if (typeof actual !== "string") {
     return false;
@@ -691,13 +749,35 @@ async function handleApi(request, response, path, state) {
     requireLiveLocalAction(state, "Local chat testing");
     requireReadyLocalChatTester(state);
     enforceRateLimit(state, path);
+    const wantsStream = requestAcceptsEventStream(request);
+    const stream = wantsStream ? startLocalChatTestStream(response) : null;
+    const requestController = wantsStream ? new AbortController() : null;
+    const abortOnClose = () => {
+      if (!response.writableEnded) requestController?.abort();
+    };
+    response.once("close", abortOnClose);
     try {
-      sendJson(
-        response,
-        200,
-        createSafeLocalChatTestResponse(await state.localChatTest.message(body)),
+      const result = createSafeLocalChatTestResponse(
+        await state.localChatTest.message(body, {
+          ...(stream
+            ? {
+                onEvent: (event, data) => stream.send(event, data),
+                signal: requestController.signal,
+              }
+            : {}),
+        }),
       );
+      if (stream) stream.complete(result);
+      else sendJson(response, 200, result);
+    } catch (error) {
+      if (stream) {
+        stream.fail(error?.statusCode === 504 ? "timeout" : "upstream_failed");
+      } else {
+        throw error;
+      }
     } finally {
+      response.off("close", abortOnClose);
+      stream?.dispose();
       if (body && typeof body === "object") {
         body.encryptedCredential = undefined;
         body.input = undefined;