streamtrust 0.3.0 → 0.5.0

package/README.md

@@ -10,7 +10,7 @@ StreamTrust is a CI check for streaming applications such as AI chat. Its reusab
 - **Repeated runs.** Each scenario runs N times and the report shows every repetition, because cancellation and retry bugs are often intermittent.
 - **Your contract, written down.** An adapter implements your app's start, stream, cancel, retry and saved-state operations; StreamTrust invokes the adapter scenarios and writes JSON, JUnit, Markdown and HTML reports.
 
-**Status:** `0.3.0`, an early 0.x release for independent teams. APIs and report formats may change before 1.0. The CLI is dependency-free, ESM, and requires Node.js 22+. MIT licensed. Browser and database libraries belong to your adapter and are not installed by StreamTrust.
+**Status:** `0.5.0`, an early 0.x release for independent teams. APIs and report formats may change before 1.0. The CLI is dependency-free, ESM, and requires Node.js 22+. MIT licensed. Browser and database libraries belong to your adapter and are not installed by StreamTrust.
 
 ## Watch the 66-second demo
 
@@ -28,7 +28,31 @@ npx streamtrust init
 npx streamtrust verify --adapter ./streamtrust/adapter.mjs
 ```
 
-For reproducible CI, pin `streamtrust@0.3.0` and commit your lockfile. The generated adapter initially exercises the bundled demonstration; map it to your application before using its results as application evidence.
+For reproducible CI, pin `streamtrust@0.5.0` and commit your lockfile. The generated adapter initially exercises the bundled demonstration; map it to your application before using its results as application evidence.
+
+## GitHub Action
+
+Run StreamTrust through the [official composite GitHub Action](https://github.com/santoshsibyala/streamtrust-action), listed as [StreamTrust CI Verifier on GitHub Marketplace](https://github.com/marketplace/actions/streamtrust-ci-verifier):
+
+```yaml
+- uses: santoshsibyala/streamtrust-action@v1
+  with:
+    adapter: ./streamtrust/adapter.mjs
+    node-version: "22"
+    artifact-name: streamtrust-report
+```
+
+Check out your repository, install adapter dependencies, and start your test services first. The Action runs the pinned StreamTrust CLI, adds a job summary, and uploads diagnostic reports even when verification fails. By default, failed or unsupported checks and harness errors fail the job. See the [complete workflow, inputs, outputs, and failure policies](https://github.com/santoshsibyala/streamtrust-action/blob/main/README.md).
+
+Use `@v1.0.0` to pin this Action release; `@v1` follows compatible Action updates. The generated HTTP adapter initially tests a bundled demo: adapt it to your application before treating its results as application coverage. Adapters run trusted repository code; use disposable test data and keep secrets out of uploaded reports.
+
+### Published HTTP/SSE demo
+
+StreamTrust uses the published Action in its own CI. This [successful main-branch run](https://github.com/santoshsibyala/streamtrust/actions/runs/42171351265) used Action v1.0.0 and CLI 0.3.0 on Node 22: persistence, cancellation, and retry each passed three repetitions (9 PASS).
+
+[![Published HTTP/SSE demo: StreamTrust Action job summary showing 9 PASS, 0 FAIL, 0 UNSUPPORTED, and 0 HARNESS_ERROR](docs/images/published-action-http-sse-summary.png)](https://github.com/santoshsibyala/streamtrust/actions/runs/42171351265#summary-127739661923)
+
+This run checks the bundled HTTP/SSE teaching demo. The existing CLI, LibreChat, NextChat, and Vercel AI SDK workflows separately test the package built from the current checkout.
 
 ## LibreChat integration
 
@@ -40,7 +64,15 @@ A LibreChat preset now exercises persistence, native Stop, regeneration and erro
 
 A `vercel-ai` preset runs a minimal Next.js chat built on the AI SDK (`useChat`, `streamText`) in production mode with a synthetic OpenAI-compatible provider, so it needs no API key. It covers the same four scenarios through the browser and the app's saved state, and can be pointed at your own built AI SDK app after you adjust its selectors and saved-state read. It is not an official Vercel integration.
 
-**Available in StreamTrust 0.3.0.** Install from npm and generate it with `npx streamtrust init streamtrust-vercel-ai --preset vercel-ai`. See the [Vercel AI SDK quick start](examples/vercel-ai/README.md) for what it does and does not verify. It requires Node 22+ and Playwright in your verification project. An [integration workflow](.github/workflows/vercel-ai.yml) exercises the packed CLI against the reference app.
+**Available since StreamTrust 0.3.0.** Install from npm and generate it with `npx streamtrust init streamtrust-vercel-ai --preset vercel-ai`. See the [Vercel AI SDK quick start](examples/vercel-ai/README.md) for what it does and does not verify. It requires Node 22+ and Playwright in your verification project. An [integration workflow](.github/workflows/vercel-ai.yml) exercises the packed CLI against the reference app.
+
+## NextChat integration
+
+Run `npx streamtrust init nextchat` to generate a Playwright adapter for a separate pinned NextChat checkout. It checks saved replies, Stop, regeneration and retry after a provider disconnect against the chat history stored in the browser. The local provider needs no model key. See the [NextChat setup and CI guide](examples/nextchat/README.md) and [integration workflow](.github/workflows/nextchat.yml).
+
+## Open WebUI integration
+
+Generate the Open WebUI preset with `npx streamtrust init open-webui`. The adapter starts a disposable upstream container, drives chat through a browser and compares results with the saved-chat API. The [setup and CI guide](examples/open-webui/README.md) lists the contract for each report scenario.
 
 ## Run from source
 
@@ -60,7 +92,7 @@ Build the tarball with `npm pack` in this repository.
 Put the supplied tarball in your project's `vendor/` directory, then:
 
 ```sh
-npm install --save-dev ./vendor/streamtrust-0.3.0.tgz
+npm install --save-dev ./vendor/streamtrust-0.5.0.tgz
 npx streamtrust init
 npx streamtrust verify --adapter ./streamtrust/adapter.mjs
 ```
@@ -156,7 +188,7 @@ Add StreamTrust as a test step in your existing CI. For GitHub Actions, follow t
 1. Install StreamTrust and create the starting adapter:
 
    ```sh
-   npm install --save-dev --save-exact streamtrust@0.3.0
+   npm install --save-dev --save-exact streamtrust@0.5.0
    npx streamtrust init
    ```
 

package/examples/librechat/README.md

@@ -4,11 +4,11 @@ This preset runs a **built local LibreChat checkout**, native browser UI and rea
 
 ## Installation
 
-Use Node.js 24 and npm 11. In a separate verification project, install StreamTrust 0.3.0 from npm:
+Use Node.js 24 and npm 11. In a separate verification project, install StreamTrust 0.4.0 from npm:
 
 ```sh
 npm init -y
-npm install --save-dev --save-exact streamtrust@0.3.0
+npm install --save-dev --save-exact streamtrust@0.4.0
 npm install --save-dev --save-exact playwright@1.64.1 mongodb@6.20.0 mongodb-memory-server@11.3.0
 npx playwright install chromium
 npx streamtrust init streamtrust-librechat --preset librechat
@@ -74,6 +74,31 @@ Use a fresh report directory for each job. Restrict workflow permissions to `con
 
 Exit 0 means all declared checks passed; 1 means failed or unsupported checks; 2 means setup, timeout, or harness error. Keep the exit status: do not use `continue-on-error`. Inspect reports before calling a failure an upstream defect.
 
+## Run in CI
+
+To use the published GitHub Action, keep the checkout, dependency installation, Playwright installation, and build steps in the CI example above. Replace only its verify step with:
+
+```yaml
+- name: Verify LibreChat with StreamTrust Action
+  uses: santoshsibyala/streamtrust-action@v1
+  with:
+    adapter: streamtrust-librechat/adapter.mjs
+    version: '0.4.0'
+    node-version: '24'
+    output: reports/librechat
+    repetitions: '3'
+    timeout-ms: '600000'
+    artifact-name: librechat-action-report
+    upload-report: 'false'
+    fail-on: failures
+  env:
+    STREAMTRUST_LIBRECHAT_ROOT: ${{ runner.temp }}/librechat
+```
+
+Keep the existing upload step: `upload-report: 'false'` disables the Action's directory upload so CI continues uploading only the four listed report files. The Action still adds a job summary and fails the job on failed or unsupported checks and harness errors. Use a fresh report directory for each invocation.
+
+`@v1` receives compatible Action updates; `@v1.0.0` pins the exact Action release. The CLI version is pinned separately by `version`. See the [Action README](https://github.com/santoshsibyala/streamtrust-action/blob/main/README.md) for setup, inputs, outputs, and failure policies. This uses the published CLI; retain direct CLI calls when testing a locally built, unreleased StreamTrust package.
+
 ## Evidence and limits
 
 `summary-only-v1` returns stable check identifiers, booleans, message counts and provider-call counts. Raw chat text, database records, user identifiers, network URLs and tokens remain in memory and are not returned as report evidence. The preset does not write screenshots, browser traces or application logs. Browser/database exceptions are replaced with fixed errors. App subprocess output is discarded. Upload only the four report files, not the entire working directory.

package/examples/nextchat/README.md

@@ -0,0 +1,51 @@
+# NextChat CI integration
+
+This preset drives a separate [NextChat checkout](https://github.com/ChatGPTNextWeb/NextChat/tree/1d3dc331512929a4b1d3e82354e72acce33b5c7a) with Playwright and a loopback OpenAI-compatible provider. NextChat is MIT licensed. Its source and dependencies stay in the checkout.
+
+## Setup
+
+In a verification project with Node 22 (the install command selects Yarn Classic 1.22.22):
+
+```sh
+npm init -y
+npm install --save-dev --save-exact streamtrust@0.4.0 playwright@1.64.1
+npx playwright install chromium
+npx streamtrust init nextchat
+export STREAMTRUST_NEXTCHAT_ROOT="$PWD/.cache/NextChat"
+git clone https://github.com/ChatGPTNextWeb/NextChat.git "$STREAMTRUST_NEXTCHAT_ROOT"
+git -C "$STREAMTRUST_NEXTCHAT_ROOT" checkout --detach 1d3dc331512929a4b1d3e82354e72acce33b5c7a
+(cd "$STREAMTRUST_NEXTCHAT_ROOT" && npx --yes --package=yarn@1.22.22 -- yarn install --frozen-lockfile --ignore-scripts)
+npx streamtrust verify --adapter nextchat/adapter.mjs --output reports/nextchat --repetitions 3 --timeout-ms 900000
+```
+
+Use a dedicated checkout with clean tracked files and no development dotenv files. The adapter starts NextChat in development mode on loopback, waits for HTTP readiness, and closes the app, provider and browser after verification. Requests use a synthetic key. Each repetition starts in a fresh browser context. To choose another output directory for the template, use `streamtrust init <directory> --preset nextchat`. To use installed Chrome, set `STREAMTRUST_BROWSER_CHANNEL=chrome`.
+
+## What it checks
+
+| Scenario | Expected outcome after reload |
+|---|---|
+| Persistence | One assistant answer matches the complete provider response, with one generation. |
+| Cancellation | Clicking Stop after the first chunk preserves only the partial answer. Late completion text stays absent even if the provider can finish. |
+| `regeneration.replace-turn` | Before Retry, the completed first answer is saved. After reload, the original assistant ID is absent and the sole assistant answer matches the second response. |
+| `error-retry.replace-turn-same-session` | After a mid-stream disconnect, the first partial answer is saved before Retry. The replacement survives reload and the original assistant ID is absent. |
+
+NextChat intentionally replaces the previous turn on Retry, so these NextChat-specific checks verify replacement in the active session; the shared evaluator checks branch preservation on regeneration and a saved error visible after reload before retry.
+
+The adapter reads the selected session in the persisted Zustand record `chat-next-web-store` (IndexedDB database `keyval-store`, object store `keyval`; NextChat also supports localStorage fallback). It compares assistant text from storage with the rendered page and counts streaming provider calls. This tests browser-local persistence in one session. The Stop check covers visible and saved output. It does not establish server-side cancellation. The retry check covers recovery in the same session, without requiring a durable error flag or sibling branches. The pre-Retry read checks partial text for error retry. Whether a failure flag survives a reload before Retry is outside this scenario. Per-run evidence contains only booleans. Message text and IDs stay in memory. A changed selector or unreadable storage can produce a harness error.
+
+## Run in CI
+
+After installing the locked consumer dependencies, installing Chromium, and preparing the pinned checkout above, export `STREAMTRUST_NEXTCHAT_ROOT` for the job. Commit the generated adapter and helper. With CLI 0.4.0 published, use the [StreamTrust Action](https://github.com/santoshsibyala/streamtrust-action):
+
+```yaml
+- name: Verify NextChat
+  uses: santoshsibyala/streamtrust-action@v1
+  with:
+    adapter: nextchat/adapter.mjs
+    version: '0.4.0'
+    node-version: '22'
+    repetitions: '3'
+    timeout-ms: '900000'
+    artifact-name: nextchat-safe-reports
+    fail-on: failures
+```

package/examples/nextchat/adapter.mjs

@@ -0,0 +1,316 @@
+import { chromium } from "playwright";
+import { spawn, execFileSync } from "node:child_process";
+import { createServer } from "node:net";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { startProvider, until } from "./provider.mjs";
+const commit = "1d3dc331512929a4b1d3e82354e72acce33b5c7a";
+
+async function availablePort() {
+  const socket = createServer();
+  await new Promise((ready, reject) => {
+    socket.once("error", reject);
+    socket.listen(0, "127.0.0.1", ready);
+  });
+  const port = socket.address().port;
+  await new Promise((done) => socket.close(done));
+  return port;
+}
+
+async function create() {
+  if (!process.env.STREAMTRUST_NEXTCHAT_ROOT)
+    throw Error(
+      "Set STREAMTRUST_NEXTCHAT_ROOT to the isolated NextChat checkout",
+    );
+  const root = resolve(process.env.STREAMTRUST_NEXTCHAT_ROOT);
+  const git = (...args) =>
+    execFileSync("git", args, { cwd: root, encoding: "utf8" }).trim();
+  if (
+    git("rev-parse", "HEAD") !== commit ||
+    git("status", "--porcelain", "--untracked-files=no")
+  )
+    throw Error("Expected clean pinned NextChat source");
+  for (const file of [
+    ".env",
+    ".env.local",
+    ".env.development",
+    ".env.development.local",
+  ]) {
+    if (existsSync(resolve(root, file)))
+      throw Error("Remove dotenv files from the isolated checkout");
+  }
+  const port = await availablePort();
+  const url = `http://127.0.0.1:${port}`;
+  const provider = await startProvider();
+  const app = spawn(
+    process.execPath,
+    [
+      resolve(root, "node_modules/next/dist/bin/next"),
+      "dev",
+      "-H",
+      "127.0.0.1",
+      "-p",
+      String(port),
+    ],
+    {
+      cwd: root,
+      env: {
+        PATH: process.env.PATH,
+        HOME: process.env.HOME,
+        TMPDIR: process.env.TMPDIR,
+        NEXT_TELEMETRY_DISABLED: "1",
+        BASE_URL: provider.url,
+        OPENAI_API_KEY: "local-synthetic-only",
+        DEFAULT_MODEL: "gpt-4o-mini",
+        CUSTOM_MODELS: "-all,+gpt-4o-mini",
+      },
+      stdio: "ignore",
+    },
+  );
+  let stopped = false;
+  const exited = new Promise((done) => {
+    const onExit = () => {
+      stopped = true;
+      done();
+    };
+    app.once("error", onExit);
+    app.once("exit", onExit);
+  });
+  let browser;
+  const close = async () => {
+    try {
+      await browser?.close();
+    } finally {
+      app.kill("SIGTERM");
+      try {
+        await provider.close();
+      } finally {
+        await exited;
+      }
+    }
+  };
+  try {
+    await until(
+      async () => {
+        if (stopped) throw Error("NextChat exited before readiness");
+        try {
+          return (await fetch(url)).ok;
+        } catch {
+          return false;
+        }
+      },
+      "NextChat readiness",
+      120000,
+    );
+    browser = await chromium.launch({
+      channel: process.env.STREAMTRUST_BROWSER_CHANNEL,
+    });
+  } catch (e) {
+    await close();
+    throw e;
+  }
+  return {
+    name: "NextChat local UI and IndexedDB",
+    metadata: async () => ({
+      evidencePolicy: "summary-only-v1",
+      provider: "local synthetic",
+      browser: browser.version(),
+      commit,
+    }),
+    scenarios: [
+      "persistence",
+      "cancellation",
+      "regeneration.replace-turn",
+      "error-retry.replace-turn-same-session",
+    ],
+    close,
+    async run(scenario, { repetition }) {
+      const context = await browser.newContext({ locale: "en-US" }),
+        page = await context.newPage();
+      page.setDefaultTimeout(10000);
+      await context.route(
+        /^https?:\/\/(?!127\.0\.0\.1[:/]|localhost[:/])/,
+        (r) => r.abort(),
+      );
+      const since = provider.calls.length;
+      const calls = () =>
+        provider.calls.slice(since).filter((x) => typeof x.send === "function");
+      const text = async () => page.locator("body").innerText();
+      const read = () =>
+        page.evaluate(async () => {
+          let db, raw;
+          try {
+            db = await new Promise((ok, fail) => {
+              let r = indexedDB.open("keyval-store");
+              r.onsuccess = () => ok(r.result);
+              r.onerror = () => fail(r.error);
+            });
+            raw = await new Promise((ok, fail) => {
+              let r = db
+                .transaction("keyval")
+                .objectStore("keyval")
+                .get("chat-next-web-store");
+              r.onsuccess = () => ok(r.result);
+              r.onerror = () => fail(r.error);
+            });
+          } catch {
+            // NextChat falls back to localStorage when idb-keyval is unavailable.
+          } finally {
+            db?.close();
+          }
+          const state = JSON.parse(
+            raw || localStorage.getItem("chat-next-web-store") || "{}",
+          ).state;
+          return state?.sessions[state.currentSessionIndex]?.messages || [];
+        });
+      const regenerate = scenario === "regeneration.replace-turn";
+      const retryError = scenario === "error-retry.replace-turn-same-session";
+      const retry = regenerate || retryError;
+      let original;
+      const evidence = {};
+      const checks = [];
+      const check = (name, passed) => checks.push({ name, passed: !!passed });
+      try {
+        await page.goto(url + "/#/chat");
+        const box = page.locator("textarea:visible").last();
+        await box.fill(`Synthetic lifecycle check ${repetition}`);
+        await box.press("Enter");
+        await until(() => calls().length > 0, "first local provider call");
+        let c = calls()[0];
+        c.send(c.prefix);
+        await until(
+          async () => (await text()).includes(c.prefix),
+          "first chunk displayed",
+        );
+        if (scenario === "cancellation") {
+          await page
+            .getByText("Stop", { exact: true })
+            .last()
+            .locator("..")
+            .click();
+          await until(
+            async () =>
+              !(await page
+                .getByText("Stop", { exact: true })
+                .last()
+                .isVisible()),
+            "stop control retired",
+            10000,
+          );
+          if (!c.closed) c.finish();
+        } else if (retryError) {
+          c.error();
+        } else {
+          c.finish();
+        }
+        if (retry) {
+          if (regenerate)
+            await until(
+              async () => (await text()).includes(c.prefix + c.suffix),
+              "first answer complete",
+            );
+          await page
+            .getByText("Stop", { exact: true })
+            .last()
+            .waitFor({ state: "hidden" });
+          await page
+            .locator('[class*="chat-message"]')
+            .filter({ hasText: c.prefix })
+            .last()
+            .hover();
+          const retryButton = page
+            .getByText("Retry", { exact: true })
+            .last()
+            .locator("..");
+          await retryButton.waitFor({ state: "visible" });
+          const assistants = (await read()).filter(
+            (m) => m.role === "assistant",
+          );
+          original = assistants[0];
+          evidence.originalSavedBeforeRetry =
+            assistants.length === 1 &&
+            typeof original.id === "string" &&
+            original.id.length > 0 &&
+            (regenerate
+              ? original.content === c.prefix + c.suffix &&
+                original.streaming === false
+              : typeof original.content === "string" &&
+                original.content.startsWith(c.prefix) &&
+                !original.content.includes(c.suffix));
+          check("originalSavedBeforeRetry", evidence.originalSavedBeforeRetry);
+          await retryButton.click();
+          await until(() => calls().length === 2, "second provider call");
+          c = calls()[1];
+          c.send(c.prefix);
+          c.finish();
+        }
+        const expected =
+          scenario === "cancellation" ? c.prefix : c.prefix + c.suffix;
+        await until(
+          async () => (await text()).includes(expected),
+          "answer visible",
+        );
+        await until(
+          async () =>
+            (await read()).some(
+              (m) =>
+                m.role === "assistant" &&
+                typeof m.content === "string" &&
+                m.content.includes(c.prefix),
+            ),
+          "IndexedDB contains displayed text",
+        );
+        await page.reload();
+        await page.locator("textarea:visible").last().waitFor();
+        await until(
+          async () => (await text()).includes(c.prefix),
+          "rehydrated answer",
+        );
+        const saved = (await read()).filter((m) => m.role === "assistant");
+        check(
+          "Saved answer equals expected text",
+          saved.length === 1 && saved[0].content === expected,
+        );
+        check(
+          "Reload shows expected answer",
+          (await text()).includes(expected),
+        );
+        check("No extra provider call", calls().length === (retry ? 2 : 1));
+        if (scenario === "cancellation")
+          check(
+            "No late completion displayed",
+            !(await text()).includes(c.suffix),
+          );
+        if (retry) {
+          evidence.originalAbsentAfterReload =
+            !!original?.id && saved.every((m) => m.id !== original.id);
+          check(
+            "originalAbsentAfterReload",
+            evidence.originalAbsentAfterReload,
+          );
+        }
+        return { checks, evidence };
+      } catch (error) {
+        if (process.env.STREAMTRUST_NEXTCHAT_DEBUG === "1")
+          console.error(error);
+        throw Error(
+          "NextChat scenario could not complete its UI or storage observation",
+        );
+      } finally {
+        for (const c of calls()) if (!c.closed) c.res.end();
+        await context.close();
+      }
+    },
+  };
+}
+
+export default async function createNextChatAdapter() {
+  try {
+    return await create();
+  } catch {
+    throw Error(
+      "NextChat setup failed. Check the pinned checkout, dotenv files, Yarn dependencies and Chromium installation.",
+    );
+  }
+}

package/examples/nextchat/provider.mjs

@@ -0,0 +1,107 @@
+import { createServer } from "node:http";
+export async function startProvider() {
+  const calls = [];
+  const server = createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Headers", "*");
+    if (req.method === "OPTIONS") return res.end();
+    if (req.url?.endsWith("/models")) {
+      res.setHeader("Content-Type", "application/json");
+      return res.end(
+        JSON.stringify({
+          object: "list",
+          data: [
+            { id: "gpt-4o-mini", object: "model", owned_by: "local-fixture" },
+          ],
+        }),
+      );
+    }
+    let raw = "";
+    for await (const b of req) raw += b;
+    const body = raw ? JSON.parse(raw) : {};
+    const id = `fixture-${calls.length + 1}`;
+    const call = {
+      id,
+      path: req.url,
+      model: body.model,
+      closed: false,
+      sentFinish: false,
+      res,
+      prefix: `Synthetic answer ${calls.length + 1}.`,
+      suffix: " Completed.",
+    };
+    calls.push(call);
+    res.on("close", () => {
+      call.closed = true;
+    });
+    if (!body.stream) {
+      res.setHeader("Content-Type", "application/json");
+      return res.end(
+        JSON.stringify({
+          id,
+          object: "chat.completion",
+          choices: [
+            {
+              index: 0,
+              message: { role: "assistant", content: "Synthetic title" },
+              finish_reason: "stop",
+            },
+          ],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }),
+      );
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+    });
+    res.flushHeaders();
+    call.send = (text) =>
+      res.write(
+        `data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body.model,
+          choices: [
+            { index: 0, delta: { content: text }, finish_reason: null },
+          ],
+        })}\n\n`,
+      );
+    call.finish = () => {
+      call.sentFinish = true;
+      call.send(call.suffix);
+      res.write(
+        `data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body.model,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        })}\n\ndata: [DONE]\n\n`,
+      );
+      res.end();
+    };
+    call.error = () => res.destroy();
+  });
+  await new Promise((ready, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", ready);
+  });
+  return {
+    url: `http://127.0.0.1:${server.address().port}`,
+    calls,
+    async close() {
+      server.closeAllConnections();
+      await new Promise((r) => server.close(r));
+    },
+  };
+}
+export async function until(fn, label, ms = 30000) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (await fn()) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`Adapter timeout: ${label}`);
+}

package/examples/open-webui/README.md

@@ -0,0 +1,48 @@
+# Open WebUI integration
+
+The adapter drives a disposable Open WebUI v0.13.0 instance with Playwright and a local OpenAI-compatible provider. The upstream commit is `c38885a1a737da4968f157092f304f3b5481d0bf`. The official slim image index is pinned to `ghcr.io/open-webui/open-webui@sha256:283efb20756785229a388bcd1e56a052f5284ae8c861717eed5eaaa3bba6b20a` for amd64 and arm64.
+
+## Setup
+
+Install Node 22+, Docker and Playwright. Start Docker before running the verifier. From a verification project, once the CLI release is available:
+
+```sh
+npm install --save-dev --save-exact streamtrust@0.5.0 playwright@1.64.1
+npx playwright install chromium
+npx streamtrust init open-webui
+npx streamtrust verify --adapter open-webui/adapter.mjs --output reports/open-webui --repetitions 3 --timeout-ms 900000
+```
+
+Use `init <directory> --preset open-webui` to choose a directory. The adapter publishes the app on a randomly assigned loopback port, waits for health, signs into a runtime-generated admin account, and dismisses the first-launch release dialog. Each scenario uses a fresh browser context and a new chat. The container data directory lives in tmpfs and is removed on cleanup. The app connects to a mock on the Docker bridge gateway on native Linux or through Docker Desktop host routing on macOS. The provider requires a disposable bearer key.
+
+## Saved state and contracts
+
+The adapter reads the authenticated saved-chat API (`GET /api/v1/chats/{id}`) backed by Open WebUI’s local database. The history contains the assistant records and parent IDs. Reload selects the persisted `current_message_id`, falling back to `chat.history.currentId` when the former is absent. The adapter compares the selected record and visible reply after reload.
+
+| Report scenario | What a pass requires |
+|---|---|
+| `persistence.shared` | Shared evaluator: one matching complete, error-free answer, visible before and after reload, with no new generation on reload. The active saved record must match. |
+| `cancellation.provider-abort-saved-partial` | App-specific: after native Stop, the mock sees its open HTTP response close before completion. The partial answer stays active and saved after reload, no late suffix appears, and generation count stays at one. Open WebUI can mark a stopped message done. |
+| `regeneration.shared-active-sibling` | Shared evaluator plus active selection: the completed original is saved before Regenerate. The original content and ID survive, the replacement has a distinct ID and the same parent, and reload selects the replacement. |
+| `error-retry.shared-saved-visible` | Shared evaluator plus active selection: a synthetic SSE provider error is saved and visible after reload before Regenerate. The replacement is active in storage and visible after a second reload. |
+
+An unavailable required storage field produces UNSUPPORTED where the adapter cannot establish the contract. Runtime or selector errors produce harness errors. Shareable evidence includes booleans and counts. Only the synthetic text-error fixture and the pinned app’s single-user chat lifecycle are in scope.
+
+## Run in CI
+
+Commit the generated adapter and consumer lockfile. On an Ubuntu Docker runner, after checkout, Node setup, `npm ci` and `npx playwright install --with-deps chromium`, use the [StreamTrust Action](https://github.com/santoshsibyala/streamtrust-action):
+
+```yaml
+- uses: santoshsibyala/streamtrust-action@v1
+  with:
+    version: '0.5.0'
+    adapter: open-webui/adapter.mjs
+    repetitions: '3'
+    timeout-ms: '900000'
+    artifact-name: open-webui-safe-reports
+    fail-on: failures
+```
+
+## Upstream license
+
+Open WebUI runs from a separate upstream image under the [Open WebUI License](https://github.com/open-webui/open-webui/blob/c38885a1a737da4968f157092f304f3b5481d0bf/LICENSE). It imposes branding, notice and endorsement conditions. This independent preset preserves the upstream interface and branding and ships only verification code.

package/examples/open-webui/adapter.mjs

@@ -0,0 +1,362 @@
+import { chromium } from "playwright";
+import { evaluateLifecycle } from "streamtrust/checks";
+import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { startProvider, until } from "./provider.mjs";
+
+const image =
+  "ghcr.io/open-webui/open-webui@sha256:283efb20756785229a388bcd1e56a052f5284ae8c861717eed5eaaa3bba6b20a";
+const revision = "c38885a1a737da4968f157092f304f3b5481d0bf";
+const scenarios = [
+  "persistence.shared",
+  "cancellation.provider-abort-saved-partial",
+  "regeneration.shared-active-sibling",
+  "error-retry.shared-saved-visible",
+];
+const docker = (args, env = {}) =>
+  execFileSync("docker", args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...env },
+  }).trim();
+
+// The API gives current_message_id precedence over history.currentId on hydration.
+async function saved(page) {
+  return page.evaluate(async () => {
+    const id = location.pathname.split("/").pop();
+    const response = await fetch("/api/v1/chats/" + id, {
+      headers: { authorization: "Bearer " + localStorage.token },
+    });
+    if (!response.ok) throw Error("Saved-chat API unavailable");
+    const chat = await response.json();
+    const history = chat.chat.history;
+    return {
+      active: chat.current_message_id || history.currentId,
+      answers: Object.values(history.messages).filter(
+        (m) => m.role === "assistant",
+      ),
+    };
+  });
+}
+
+export default async function create() {
+  const name = "streamtrust-webui-" + randomUUID();
+  const key = randomUUID(),
+    password = randomUUID(),
+    email = randomUUID() + "@example.com";
+  let browser,
+    provider,
+    started = false;
+  const close = async () => {
+    try {
+      await browser?.close();
+    } finally {
+      try {
+        if (started) docker(["rm", "-fv", name]);
+      } finally {
+        await provider?.close();
+      }
+    }
+  };
+  try {
+    // Linux containers reach the host on the default bridge gateway. Docker Desktop
+    // provides host.docker.internal for services listening on the host loopback.
+    const linux = process.platform === "linux";
+    const gateway = linux
+      ? docker([
+          "network",
+          "inspect",
+          "bridge",
+          "--format",
+          "{{(index .IPAM.Config 0).Gateway}}",
+        ])
+      : "127.0.0.1";
+    provider = await startProvider(gateway, key);
+    const settings = {
+      WEBUI_ADMIN_EMAIL: email,
+      WEBUI_ADMIN_PASSWORD: password,
+      WEBUI_SECRET_KEY: randomUUID(),
+      ENABLE_SIGNUP: "False",
+      OFFLINE_MODE: "True",
+      ENABLE_OLLAMA_API: "False",
+      ENABLE_OPENAI_API: "True",
+      OPENAI_API_BASE_URL: `http://${
+        linux ? gateway : "host.docker.internal"
+      }:${provider.port}/v1`,
+      OPENAI_API_KEY: key,
+      DEFAULT_MODELS: "gpt-4o-mini",
+      ENABLE_TITLE_GENERATION: "False",
+      ENABLE_TAGS_GENERATION: "False",
+      ENABLE_FOLLOW_UP_GENERATION: "False",
+      ENABLE_VERSION_UPDATE_CHECK: "False",
+      ENABLE_PERSISTENT_CONFIG: "False",
+      HF_HUB_OFFLINE: "1",
+      RAG_EMBEDDING_MODEL_AUTO_UPDATE: "False",
+      RAG_RERANKING_MODEL_AUTO_UPDATE: "False",
+    };
+    docker(
+      [
+        "run",
+        "-d",
+        "--rm",
+        "--name",
+        name,
+        "-p",
+        "127.0.0.1::8080",
+        "--tmpfs",
+        "/app/backend/data",
+        ...Object.keys(settings).flatMap((k) => ["-e", k]),
+        image,
+      ],
+      settings,
+    );
+    started = true;
+    const url = "http://" + docker(["port", name, "8080/tcp"]);
+    await until(
+      async () => {
+        try {
+          return (await fetch(url + "/health")).ok;
+        } catch {
+          return false;
+        }
+      },
+      "container health",
+      180000,
+    );
+    const login = await fetch(url + "/api/v1/auths/signin", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ email, password }),
+    });
+    if (!login.ok) throw Error("Disposable admin sign-in failed");
+    const { token } = await login.json();
+    if (!token) throw Error("Disposable admin session unavailable");
+    browser = await chromium.launch({
+      channel: process.env.STREAMTRUST_BROWSER_CHANNEL,
+    });
+    return {
+      name: "Open WebUI",
+      scenarios,
+      close,
+      metadata: async () => ({
+        commit: revision,
+        image,
+        evidencePolicy: "summary-only-v1",
+      }),
+      async run(label) {
+        const scenario = label.split(".")[0];
+        const ctx = await browser.newContext({
+          locale: "en-US",
+          storageState: {
+            cookies: [],
+            origins: [
+              { origin: url, localStorage: [{ name: "token", value: token }] },
+            ],
+          },
+        });
+        let stage = "opening the local chat";
+        const start = provider.calls.length;
+        const calls = () => provider.calls.slice(start).filter((c) => c.send);
+        const check = (name, passed) => ({ name, passed });
+        try {
+          await ctx.route(/^https?:\/\//, (r) =>
+            new URL(r.request().url()).origin === url
+              ? r.continue()
+              : r.abort(),
+          );
+          const page = await ctx.newPage();
+          const text = () => page.locator("body").innerText();
+          const has = async (value) => (await text()).includes(value);
+          const untilVisible = (value) =>
+            until(() => has(value), "rendered answer");
+          const stop = page.getByRole("button", { name: "Stop", exact: true });
+          const dialog = page.getByRole("dialog", { name: /What.s New/i });
+          await page.addLocatorHandler(dialog, () =>
+            dialog.getByRole("button", { name: "Close", exact: true }).click(),
+          );
+          await page.goto(url);
+          await page
+            .getByText("gpt-4o-mini", { exact: true })
+            .first()
+            .waitFor();
+          await page.locator("#chat-input").fill("Synthetic lifecycle check");
+          await page
+            .getByRole("button", { name: "Send message", exact: true })
+            .click();
+          stage = "waiting for first provider call";
+          await until(() => calls().length === 1, "first generation");
+          const first = calls()[0];
+          first.send(first.prefix);
+          await untilVisible(first.prefix);
+          await page.waitForURL("**/c/*");
+          let target = first,
+            aborted = false,
+            failure,
+            originalId;
+          stage = "settling the first response";
+          if (scenario === "cancellation") {
+            await stop.click();
+            await stop.waitFor({ state: "hidden" });
+            // A closed response counts only while the provider is still holding it open.
+            const deadline = Date.now() + 5000;
+            while (!first.closed && Date.now() < deadline)
+              await new Promise((r) => setTimeout(r, 50));
+            aborted = first.closed && !first.sentFinish;
+            if (!first.closed) first.finish();
+          } else if (scenario === "error-retry") {
+            first.error();
+            await stop.waitFor({ state: "hidden" });
+            const stateBeforeRetry = await saved(page);
+            const failed = stateBeforeRetry.answers.find(
+              (m) =>
+                m.id === stateBeforeRetry.active &&
+                m.content?.includes(first.prefix) &&
+                JSON.stringify(m.error ?? "").includes(
+                  "Synthetic test interruption",
+                ),
+            );
+            await page.reload();
+            await untilVisible(first.prefix);
+            await page
+              .getByText("Synthetic test interruption", { exact: false })
+              .last()
+              .waitFor({ timeout: 5000 })
+              .catch(() => {});
+            failure = {
+              saved: !!failed,
+              visibleAfterReload: await has("Synthetic test interruption"),
+            };
+            if (!failure.saved || !failure.visibleAfterReload)
+              return {
+                checks: [],
+                unsupported:
+                  "Saved provider error and its visible marker could not both be established across reload before retry.",
+                evidence: failure,
+              };
+          } else {
+            first.finish();
+            await untilVisible(first.prefix + first.suffix);
+          }
+          if (scenario === "regeneration" || scenario === "error-retry") {
+            stage = "observing the original and regenerating";
+            if (scenario === "regeneration") {
+              await until(async () => {
+                const state = await saved(page);
+                originalId = state.answers.find(
+                  (m) => m.content === first.prefix + first.suffix,
+                )?.id;
+                return originalId && state.active === originalId;
+              }, "saved original");
+            }
+            await page
+              .getByRole("button", { name: "Regenerate", exact: true })
+              .last()
+              .click();
+            const menu = page
+              .getByRole("menuitem", { name: /regenerate|try again/i })
+              .first();
+            if (await menu.isVisible()) await menu.click();
+            await until(() => calls().length === 2, "second generation");
+            target = calls()[1];
+            target.send(target.prefix);
+            target.finish();
+          }
+          stage = "checking saved state and reload";
+          const expected =
+            scenario === "cancellation"
+              ? target.prefix
+              : target.prefix + target.suffix;
+          await untilVisible(expected);
+          await until(
+            async () =>
+              (await saved(page)).answers.some((m) => m.content === expected),
+            "saved reply",
+          );
+          const beforeReload = await text(),
+            callsBeforeReload = calls().length;
+          await page.reload();
+          await untilVisible(target.prefix);
+          const reloaded = await text(),
+            state = await saved(page);
+          const active = state.answers.find((m) => m.id === state.active);
+          const activeMatches = active?.content === expected;
+          let checks;
+          if (scenario === "cancellation") {
+            checks = [
+              check("Provider observed abort before finish", aborted),
+              check(
+                "Active partial saved and visible after reload",
+                activeMatches && reloaded.includes(expected),
+              ),
+              check("Late suffix absent", !reloaded.includes(first.suffix)),
+              check(
+                "Exactly one generation across reload",
+                calls().length === 1,
+              ),
+            ];
+          } else {
+            if (state.answers.some((m) => typeof m.done !== "boolean"))
+              return {
+                checks: [],
+                unsupported:
+                  "Saved assistant completion state unavailable for shared checks.",
+                evidence: {},
+              };
+            ({ checks } = evaluateLifecycle({
+              scenario,
+              expected,
+              original: first.prefix + first.suffix,
+              previousPrefix: first.prefix,
+              beforeReload,
+              reloaded,
+              callsBeforeReload,
+              callsAfterReload: calls().length,
+              failure,
+              messages: state.answers.map((m) => ({
+                id: m.id,
+                parentId: m.parentId,
+                text: m.content,
+                assistant: true,
+                unfinished: !m.done,
+                error: !!m.error,
+              })),
+            }));
+            checks.push(
+              check("Saved active ID selects expected answer", activeMatches),
+            );
+            if (scenario === "regeneration")
+              checks.push(
+                check(
+                  "Original ID and content retained",
+                  state.answers.some(
+                    (m) =>
+                      m.id === originalId &&
+                      m.content === first.prefix + first.suffix,
+                  ),
+                ),
+              );
+          }
+          return {
+            checks,
+            evidence: {
+              callsBeforeReload,
+              callsAfterReload: calls().length,
+              assistantCount: state.answers.length,
+              activeMatches,
+            },
+          };
+        } catch {
+          throw Error("Open WebUI observation failed while " + stage);
+        } finally {
+          for (const c of calls()) if (!c.closed) c.res.end();
+          await ctx.close();
+        }
+      },
+    };
+  } catch {
+    await close();
+    throw Error(
+      "Open WebUI setup failed. Check Docker, the pinned image, local provider routing, admin bootstrap and Chromium.",
+    );
+  }
+}

package/examples/open-webui/provider.mjs

@@ -0,0 +1,113 @@
+import { createServer } from "node:http";
+export async function startProvider(host, key) {
+  const calls = [];
+  const server = createServer(async (req, res) => {
+    if (req.headers.authorization !== "Bearer " + key) {
+      res.writeHead(401);
+      return res.end();
+    }
+    res.setHeader("Access-Control-Allow-Headers", "*");
+    if (req.method === "OPTIONS") return res.end();
+    if (req.url?.endsWith("/models")) {
+      res.setHeader("Content-Type", "application/json");
+      return res.end(
+        JSON.stringify({
+          object: "list",
+          data: [
+            { id: "gpt-4o-mini", object: "model", owned_by: "local-fixture" },
+          ],
+        }),
+      );
+    }
+    let raw = "";
+    for await (const b of req) raw += b;
+    const body = raw ? JSON.parse(raw) : {};
+    const id = `fixture-${calls.length + 1}`;
+    const call = {
+      id,
+      path: req.url,
+      model: body.model,
+      closed: false,
+      sentFinish: false,
+      res,
+      prefix: `Synthetic answer ${calls.length + 1}.`,
+      suffix: " Completed.",
+    };
+    calls.push(call);
+    res.on("close", () => {
+      call.closed = true;
+    });
+    if (!body.stream) {
+      res.setHeader("Content-Type", "application/json");
+      return res.end(
+        JSON.stringify({
+          id,
+          object: "chat.completion",
+          choices: [
+            {
+              index: 0,
+              message: { role: "assistant", content: "Synthetic title" },
+              finish_reason: "stop",
+            },
+          ],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }),
+      );
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+    });
+    res.flushHeaders();
+    call.send = (text) =>
+      res.write(
+        `data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body.model,
+          choices: [
+            { index: 0, delta: { content: text }, finish_reason: null },
+          ],
+        })}\n\n`,
+      );
+    call.finish = () => {
+      call.sentFinish = true;
+      call.send(call.suffix);
+      res.write(
+        `data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body.model,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        })}\n\ndata: [DONE]\n\n`,
+      );
+      res.end();
+    };
+    call.error = () =>
+      res.end(
+        'data: {"error":{"message":"Synthetic test interruption"}}\n\ndata: [DONE]\n\n',
+      );
+  });
+  await new Promise((ready, reject) => {
+    server.once("error", reject);
+    server.listen(0, host, ready);
+  });
+  return {
+    port: server.address().port,
+    calls,
+    async close() {
+      server.closeAllConnections();
+      await new Promise((r) => server.close(r));
+    },
+  };
+}
+export async function until(fn, label, ms = 30000) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (await fn()) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`Adapter timeout: ${label}`);
+}

package/examples/vercel-ai/README.md

@@ -4,11 +4,11 @@ This preset runs a **minimal Next.js chat built on the AI SDK** (`ai`, `@ai-sdk/
 
 ## Quick start (no API key)
 
-Use Node.js 22 or newer (AI SDK 7 requires it). This preset is available in StreamTrust 0.3.0. In a separate verification project:
+Use Node.js 22 or newer (AI SDK 7 requires it). This preset has been available since StreamTrust 0.3.0. In a separate verification project:
 
 ```sh
 npm init -y
-npm install --save-dev --save-exact streamtrust@0.3.0 playwright@1.64.1
+npm install --save-dev --save-exact streamtrust@0.4.0 playwright@1.64.1
 npx playwright install chromium
 npx streamtrust init streamtrust-vercel-ai --preset vercel-ai
 node streamtrust-vercel-ai/setup.mjs
@@ -93,6 +93,29 @@ Run the installation steps once, then commit your verification project package.j
 
 Exit 0 means all declared checks passed; 1 means failed or unsupported checks; 2 means setup, timeout or harness error. Keep the exit status: do not use `continue-on-error`.
 
+## Run in CI
+
+To use the published GitHub Action, keep the checkout, dependency installation, Playwright installation, and build steps in the CI example above. Replace only its verify step with:
+
+```yaml
+- name: Verify AI SDK app with StreamTrust Action
+  uses: santoshsibyala/streamtrust-action@v1
+  with:
+    adapter: streamtrust-vercel-ai/adapter.mjs
+    version: '0.4.0'
+    node-version: '22'
+    output: reports/vercel-ai
+    repetitions: '3'
+    timeout-ms: '600000'
+    artifact-name: vercel-ai-action-report
+    upload-report: 'false'
+    fail-on: failures
+```
+
+Keep the existing upload step: `upload-report: 'false'` disables the Action's directory upload so CI continues uploading only the four listed report files. The Action still adds a job summary and fails the job on failed or unsupported checks and harness errors. Use a fresh report directory for each invocation.
+
+`@v1` receives compatible Action updates; `@v1.0.0` pins the exact Action release. The CLI version is pinned separately by `version`. See the [Action README](https://github.com/santoshsibyala/streamtrust-action/blob/main/README.md) for setup, inputs, outputs, and failure policies. This uses the published CLI; retain direct CLI calls when testing a locally built, unreleased StreamTrust package.
+
 ## Evidence and limits
 
 Reports use `summary-only-v1`: stable check names, booleans, message counts and provider-call counts. Chat text, message ids, URLs and file paths stay in memory. Reports replace browser and app exceptions with fixed messages even in debug mode. Debug mode prints raw errors to the console; do not enable it in CI that retains logs. This is data minimization, not a sandbox: the adapter and the app under test are trusted code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamtrust",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Adapter-driven CI verification for streaming application lifecycle guarantees",
   "type": "module",
   "license": "MIT",
@@ -37,7 +37,11 @@
     "examples/vercel-ai/reference-app/app/**/*.js",
     "examples/vercel-ai/reference-app/app/**/*.jsx",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "examples/nextchat/*.mjs",
+    "examples/nextchat/README.md",
+    "examples/open-webui/*.mjs",
+    "examples/open-webui/README.md"
   ],
   "scripts": {
     "test": "node --test test/*.test.mjs",
@@ -48,7 +52,14 @@
     "streaming",
     "verification",
     "testing",
-    "sse"
+    "sse",
+    "github-action",
+    "ai",
+    "llm",
+    "chat",
+    "playwright",
+    "librechat",
+    "vercel-ai-sdk"
   ],
   "repository": {
     "type": "git",

package/src/cli.js

@@ -19,11 +19,15 @@ const PRESETS = {
     'reference-app/app/api/chat/route.js', 'reference-app/app/chat/[id]/chat.jsx',
     'reference-app/app/chat/[id]/page.jsx',
   ].map((name) => [`vercel-ai/${name}`, name]),
+  'open-webui': ['adapter.mjs', 'provider.mjs', 'README.md'].map(
+    (name) => [`open-webui/${name}`, name]),
+  nextchat: ['adapter.mjs', 'provider.mjs', 'README.md'].map(
+    (name) => [`nextchat/${name}`, name]),
 };
 export function presets() { return Object.keys(PRESETS); }
 function presetFiles(preset) { return PRESETS[preset]; }
 const HELP = () =>
-  `StreamTrust ${VERSION}\n\nUsage:\n  streamtrust init [directory] [--preset <name>]\n  streamtrust verify --adapter ./streamtrust/adapter.mjs [options]\n\nOptions:\n  --output <directory>    Reports (default: reports/streamtrust)\n  --repetitions <1-1000>   Repetitions per scenario (default: 3)\n  --timeout-ms <integer>  Total run deadline including setup/cleanup (default: 300000)\n  --help                 Show help\n  --version              Show version\n\nPresets: ${presets().join(', ')} (default: http)\n\nExit codes: 0 all pass; 1 failed/unsupported checks; 2 setup, timeout or harness error.\nAdapters execute trusted local code. JavaScript ESM (.mjs) works without dependencies.\n`;
+  `StreamTrust ${VERSION}\n\nUsage:\n  streamtrust init [directory] [--preset <name>]\n  streamtrust init nextchat|open-webui\n  streamtrust verify --adapter ./streamtrust/adapter.mjs [options]\n\nOptions:\n  --output <directory>    Reports (default: reports/streamtrust)\n  --repetitions <1-1000>   Repetitions per scenario (default: 3)\n  --timeout-ms <integer>  Total run deadline including setup/cleanup (default: 300000)\n  --help                 Show help\n  --version              Show version\n\nPresets: ${presets().join(', ')} (default: http)\n\nExit codes: 0 all pass; 1 failed/unsupported checks; 2 setup, timeout or harness error.\nAdapters execute trusted local code. JavaScript ESM (.mjs) works without dependencies.\n`;
 export async function main(args) {
   let outputDir;
   try {
@@ -38,7 +42,7 @@ export async function main(args) {
     if (args[0] === 'init') {
       const initArgs = args.slice(1);
       const presetIndex = initArgs.indexOf('--preset');
-      let preset = 'http';
+      let preset = initArgs.length === 1 && ['nextchat', 'open-webui'].includes(initArgs[0]) ? initArgs[0] : 'http';
       if (presetIndex !== -1) {
         preset = initArgs[presetIndex + 1];
         initArgs.splice(presetIndex, 2);