streamtrust 0.4.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.4.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,7 @@ npx streamtrust init
 npx streamtrust verify --adapter ./streamtrust/adapter.mjs
 ```
 
-For reproducible CI, pin `streamtrust@0.4.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
 
@@ -70,6 +70,10 @@ A `vercel-ai` preset runs a minimal Next.js chat built on the AI SDK (`useChat`,
 
 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
 
 ```sh
@@ -88,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.4.0.tgz
+npm install --save-dev ./vendor/streamtrust-0.5.0.tgz
 npx streamtrust init
 npx streamtrust verify --adapter ./streamtrust/adapter.mjs
 ```
@@ -184,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.4.0
+   npm install --save-dev --save-exact streamtrust@0.5.0
    npx streamtrust init
    ```
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamtrust",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Adapter-driven CI verification for streaming application lifecycle guarantees",
   "type": "module",
   "license": "MIT",
@@ -39,7 +39,9 @@
     "README.md",
     "LICENSE",
     "examples/nextchat/*.mjs",
-    "examples/nextchat/README.md"
+    "examples/nextchat/README.md",
+    "examples/open-webui/*.mjs",
+    "examples/open-webui/README.md"
   ],
   "scripts": {
     "test": "node --test test/*.test.mjs",

package/src/cli.js

@@ -19,13 +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 init nextchat\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 {
@@ -40,7 +42,7 @@ export async function main(args) {
     if (args[0] === 'init') {
       const initArgs = args.slice(1);
       const presetIndex = initArgs.indexOf('--preset');
-      let preset = initArgs.length === 1 && initArgs[0] === 'nextchat' ? 'nextchat' : '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);