fix: address CodeRabbit review comments

API / router (packages/api):
- open-webui: expose serializable procedures as MCP tools via .meta({ mcp })
  and gate knowledge/files/notes reads behind protectedProcedure + interact so
  anonymous board viewers can't enumerate private source content
- integration create: wrap integration + creator-permission + secret writes in
  a single cross-driver transaction so a partial failure can't leave an
  unusable integration
- integration test: scope the permission lookup to the created integration

Integration (packages/integrations):
- open-webui: log only safe metadata (not raw completion chunks) on parse
  failure, flush the final buffered SSE frame before treating the stream as
  truncated, and apply a default request timeout (streaming opts out)

Widget (packages/widgets):
- collapse knowledge rows by default to avoid an N+1 getKnowledgeFiles burst
- strip markdown images from assistant output to block untrusted fetches
- reconcile the selected model when the model list changes
- clear draft attachments when switching to a saved chat
- dedupe async note/chat attaches after the fetch resolves
- discard stale persist responses via a session token so a cleared chat can't
  be rebound to an old Open WebUI chat id
- release the mic stream on mid-start failures and mark the recording cancelled
  on unmount so partial audio isn't transcribed

packages/integrations/src/open-webui/open-webui-integration.ts

@@ -35,6 +35,10 @@ import {
 
 const logger = createLogger({ module: "open-webui-integration" });
 
+// Default per-request timeout so a stalled upstream can't hang model/file/note/
+// chat calls indefinitely. Streaming completions opt out (they are long-lived).
+const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
+
 // The (undici) request options accepted by the shared fetch helper. Derived so
 // the request helpers stay in sync with the underlying fetch types.
 type RequestOptions = NonNullable<Parameters<typeof fetchWithTrustedCertificatesAsync>[1]>;
@@ -220,6 +224,10 @@ export class OpenWebUiIntegration extends Integration {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ model: params.model, messages: params.messages, stream: true }),
+      // Long-lived stream: opt out of the default request timeout and rely on the
+      // caller's abort signal instead (the timeout path would also replace this
+      // signal, breaking cancellation).
+      timeout: undefined,
       signal,
     });
 
@@ -248,8 +256,13 @@ export class OpenWebUiIntegration extends Integration {
         // Some providers end the stream with a finish_reason chunk and no
         // explicit [DONE] sentinel; treat that as a clean completion too.
         if (choice?.finish_reason) return true;
-      } catch {
-        logger.debug("Failed to parse Open WebUI completion chunk", { line: trimmed });
+      } catch (error) {
+        // The chunk can contain model output or grounded user data, so log only
+        // safe metadata rather than the raw payload.
+        logger.debug("Failed to parse Open WebUI completion chunk", {
+          error: error instanceof Error ? error.message : "unknown",
+          payloadLength: payload.length,
+        });
       }
       return false;
     };
@@ -258,7 +271,15 @@ export class OpenWebUiIntegration extends Integration {
     try {
       while (!signal.aborted) {
         const { done, value } = await reader.read();
-        if (done) break;
+        if (done) {
+          // The server may close after the final data: event without a trailing
+          // newline; parse whatever is left so a valid completion isn't treated
+          // as a truncated stream.
+          if (buffer.trim() !== "" && processLine(buffer)) {
+            completed = true;
+          }
+          break;
+        }
 
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -301,6 +322,10 @@ export class OpenWebUiIntegration extends Integration {
     init?: Omit<RequestOptions, "headers"> & { headers?: Record<string, string> },
   ) {
     const response = await fetchWithTrustedCertificatesAsync(this.url(path), {
+      // Apply a default timeout unless the caller opts out (e.g. streaming
+      // completions pass `timeout: undefined` to stay open indefinitely). A
+      // spread after this key lets an explicit caller value win.
+      timeout: DEFAULT_REQUEST_TIMEOUT_MS,
       ...init,
       headers: { ...this.getAuthHeaders(), ...init?.headers },
     });