@circuitwall/jarela 0.7.0 → 0.7.2

package/.next/standalone/.next/static/chunks/6945-269d42dc1784c71a.js

@@ -0,0 +1,728 @@
+"use strict";
+(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[6945],{
+
+/***/ 1490:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   AU: () => (/* binding */ submitRun),
+/* harmony export */   FH: () => (/* binding */ api),
+/* harmony export */   _C: () => (/* binding */ subscribeRun)
+/* harmony export */ });
+const BASE = "/api/v1";
+const LIST_TTL_MS = 30000;
+function emptyCache() {
+    return {
+        data: null,
+        fetchedAt: 0,
+        inflight: null
+    };
+}
+function cloneRows(rows) {
+    return rows.map((row)=>({
+            ...row
+        }));
+}
+const agentListCache = emptyCache();
+const modelListCache = emptyCache();
+const taskListCache = emptyCache();
+function setAgentListCache(rows, notify = true) {
+    const snap = cloneRows(rows);
+    agentListCache.data = snap;
+    agentListCache.fetchedAt = Date.now();
+    agentListCache.inflight = null;
+    if (notify && "object" !== "undefined") {
+        window.dispatchEvent(new CustomEvent("jarela:agents-changed"));
+    }
+    return cloneRows(snap);
+}
+function setModelListCache(rows, notify = true) {
+    const snap = cloneRows(rows);
+    modelListCache.data = snap;
+    modelListCache.fetchedAt = Date.now();
+    modelListCache.inflight = null;
+    if (notify && "object" !== "undefined") {
+        window.dispatchEvent(new CustomEvent("jarela:models-changed"));
+    }
+    return cloneRows(snap);
+}
+function setTaskListCache(rows, notify = true) {
+    const snap = cloneRows(rows);
+    taskListCache.data = snap;
+    taskListCache.fetchedAt = Date.now();
+    taskListCache.inflight = null;
+    if (notify && "object" !== "undefined") {
+        window.dispatchEvent(new CustomEvent("jarela:tasks-changed"));
+    }
+    return cloneRows(snap);
+}
+function cachedList(cache, fetchFn, setCache, force) {
+    const now = Date.now();
+    if (!force && cache.data && now - cache.fetchedAt < LIST_TTL_MS) {
+        return Promise.resolve(cloneRows(cache.data));
+    }
+    if (!force && cache.inflight) return cache.inflight;
+    const req = fetchFn().then((rows)=>setCache(rows, false));
+    cache.inflight = req;
+    return req;
+}
+async function request(path, init) {
+    const res = await fetch(`${BASE}${path}`, {
+        headers: {
+            "Content-Type": "application/json",
+            ...init?.headers
+        },
+        ...init
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(()=>res.statusText);
+        throw new Error(`${res.status} ${text}`);
+    }
+    return res.json();
+}
+const api = {
+    agents: {
+        list: (opts)=>cachedList(agentListCache, ()=>request("/agents"), setAgentListCache, opts?.force === true),
+        get: (id)=>request(`/agents/${encodeURIComponent(id)}`),
+        create: async (data)=>{
+            const created = await request("/agents", {
+                method: "POST",
+                body: JSON.stringify(data)
+            });
+            if (agentListCache.data) setAgentListCache([
+                ...agentListCache.data,
+                created
+            ]);
+            else if (true) window.dispatchEvent(new CustomEvent("jarela:agents-changed"));
+            return created;
+        },
+        update: async (id, data)=>{
+            const updated = await request(`/agents/${encodeURIComponent(id)}`, {
+                method: "PUT",
+                body: JSON.stringify(data)
+            });
+            if (agentListCache.data) setAgentListCache(agentListCache.data.map((a)=>a.id === id ? updated : a));
+            else if (true) window.dispatchEvent(new CustomEvent("jarela:agents-changed"));
+            return updated;
+        },
+        delete: async (id)=>{
+            const res = await request(`/agents/${encodeURIComponent(id)}`, {
+                method: "DELETE"
+            });
+            if (res.deleted) {
+                if (agentListCache.data) setAgentListCache(agentListCache.data.filter((a)=>a.id !== id));
+                else if (true) window.dispatchEvent(new CustomEvent("jarela:agents-changed"));
+            }
+            return res;
+        },
+        getThread: (id)=>request(`/agents/${encodeURIComponent(id)}/thread`),
+        compact: (id)=>request(`/agents/${encodeURIComponent(id)}/compact`, {
+                method: "POST",
+                body: "{}"
+            })
+    },
+    tools: {
+        list: ()=>request("/tools")
+    },
+    builtinTools: {
+        list: ()=>request("/builtin-tools"),
+        setEnabled: (category, enabled)=>request("/builtin-tools", {
+                method: "PATCH",
+                body: JSON.stringify({
+                    category,
+                    enabled
+                })
+            })
+    },
+    extensions: {
+        list: ()=>request("/extensions"),
+        getToolSecrets: (name)=>request(`/extensions/tools/${encodeURIComponent(name)}/secrets`),
+        saveToolSecrets: (name, values)=>request(`/extensions/tools/${encodeURIComponent(name)}/secrets`, {
+                method: "PUT",
+                body: JSON.stringify({
+                    values
+                })
+            })
+    },
+    threads: {
+        list: (limit = 50, offset = 0)=>request(`/threads?limit=${limit}&offset=${offset}`),
+        create: (agent_id, title)=>request("/threads", {
+                method: "POST",
+                body: JSON.stringify({
+                    agent_id,
+                    title
+                })
+            }),
+        get: (thread_id, opts)=>{
+            const p = new URLSearchParams();
+            if (opts?.limit) p.set("limit", String(opts.limit));
+            if (opts?.before) p.set("before", opts.before);
+            // `after`: only return messages newer than this ISO timestamp. Used
+            // by ChatView post-run to fetch the freshly-persisted user+assistant
+            // pair instead of re-pulling the whole most-recent page.
+            if (opts?.after) p.set("after", opts.after);
+            const qs = p.toString() ? `?${p}` : "";
+            return request(`/threads/${thread_id}${qs}`);
+        },
+        delete: (thread_id)=>request(`/threads/${thread_id}`, {
+                method: "DELETE"
+            }),
+        // Abort the active agent run on this thread. The server's stream loop
+        // catches the resulting AbortError and emits an `error` + `done` so
+        // any UI queue-drain hook (e.g. ChatView) still fires.
+        abortRun: (thread_id)=>request(`/threads/${thread_id}/run`, {
+                method: "DELETE"
+            })
+    },
+    memory: {
+        list: (namespace, search, limit = 50)=>{
+            const p = new URLSearchParams();
+            if (namespace) p.set("namespace", namespace);
+            if (search) p.set("search", search);
+            p.set("limit", String(limit));
+            return request(`/memory?${p}`);
+        },
+        create: (namespace, key, value)=>request("/memory", {
+                method: "POST",
+                body: JSON.stringify({
+                    namespace,
+                    key,
+                    value
+                })
+            }),
+        update: (namespace, key, value)=>request(`/memory/${encodeURIComponent(namespace)}/${encodeURIComponent(key)}`, {
+                method: "PUT",
+                body: JSON.stringify({
+                    value
+                })
+            }),
+        delete: (namespace, key)=>request(`/memory/${encodeURIComponent(namespace)}/${encodeURIComponent(key)}`, {
+                method: "DELETE"
+            })
+    },
+    models: {
+        list: (opts)=>cachedList(modelListCache, ()=>request("/models"), setModelListCache, opts?.force === true),
+        providers: ()=>request("/providers"),
+        catalog: (provider)=>request(`/providers/${encodeURIComponent(provider)}/models`),
+        create: async (name, data)=>{
+            const created = await request("/models", {
+                method: "POST",
+                body: JSON.stringify({
+                    name,
+                    ...data
+                })
+            });
+            if (modelListCache.data) setModelListCache([
+                ...modelListCache.data,
+                created
+            ]);
+            else if (true) window.dispatchEvent(new CustomEvent("jarela:models-changed"));
+            return created;
+        },
+        update: async (name, data)=>{
+            const updated = await request(`/models/${encodeURIComponent(name)}`, {
+                method: "PUT",
+                body: JSON.stringify(data)
+            });
+            if (modelListCache.data) setModelListCache(modelListCache.data.map((m)=>m.name === name ? updated : m));
+            else if (true) window.dispatchEvent(new CustomEvent("jarela:models-changed"));
+            return updated;
+        },
+        delete: async (name)=>{
+            const res = await request(`/models/${encodeURIComponent(name)}`, {
+                method: "DELETE"
+            });
+            if (res.deleted) {
+                if (modelListCache.data) setModelListCache(modelListCache.data.filter((m)=>m.name !== name));
+                else if (true) window.dispatchEvent(new CustomEvent("jarela:models-changed"));
+                // Deleting a model cascades to its assignments server-side; drop the
+                // task list cache so the next read reflects the server.
+                if (taskListCache.data) setTaskListCache(taskListCache.data.filter((t)=>t.model_config_name !== name));
+            }
+            return res;
+        }
+    },
+    profile: {
+        get: ()=>request("/profile"),
+        update: (data)=>request("/profile", {
+                method: "PUT",
+                body: JSON.stringify(data)
+            }),
+        setLocationConsent: (consent)=>request("/profile/location", {
+                method: "PUT",
+                body: JSON.stringify({
+                    consent
+                })
+            }),
+        updateLocation: (data)=>request("/profile/location", {
+                method: "POST",
+                body: JSON.stringify(data)
+            }),
+        clearLocation: ()=>request("/profile/location", {
+                method: "DELETE"
+            })
+    },
+    access: {
+        list: ()=>request("/access"),
+        add: (identity, display_name)=>request("/access", {
+                method: "POST",
+                body: JSON.stringify({
+                    identity,
+                    display_name
+                })
+            }),
+        remove: (identity)=>request(`/access/${encodeURIComponent(identity)}`, {
+                method: "DELETE"
+            })
+    },
+    tasks: {
+        list: (opts)=>cachedList(taskListCache, ()=>request("/tasks"), setTaskListCache, opts?.force === true),
+        assign: async (agent_id, model_config_name, tool_policy)=>{
+            const assigned = await request(`/tasks/${encodeURIComponent(agent_id)}`, {
+                method: "PUT",
+                body: JSON.stringify({
+                    model_config_name,
+                    tool_policy
+                })
+            });
+            if (taskListCache.data) {
+                const exists = taskListCache.data.some((t)=>t.agent_id === agent_id);
+                const next = exists ? taskListCache.data.map((t)=>t.agent_id === agent_id ? assigned : t) : [
+                    ...taskListCache.data,
+                    assigned
+                ];
+                setTaskListCache(next);
+            } else if (true) {
+                window.dispatchEvent(new CustomEvent("jarela:tasks-changed"));
+            }
+            return assigned;
+        },
+        unassign: async (agent_id)=>{
+            const res = await request(`/tasks/${encodeURIComponent(agent_id)}`, {
+                method: "DELETE"
+            });
+            if (taskListCache.data) setTaskListCache(taskListCache.data.filter((t)=>t.agent_id !== agent_id));
+            else if (true) window.dispatchEvent(new CustomEvent("jarela:tasks-changed"));
+            return res;
+        }
+    },
+    mcp: {
+        list: ()=>request("/mcp-servers"),
+        create: (data)=>request("/mcp-servers", {
+                method: "POST",
+                body: JSON.stringify(data)
+            }),
+        update: (name, data)=>request(`/mcp-servers/${encodeURIComponent(name)}`, {
+                method: "PUT",
+                body: JSON.stringify(data)
+            }),
+        delete: (name)=>request(`/mcp-servers/${encodeURIComponent(name)}`, {
+                method: "DELETE"
+            }),
+        registry: (params)=>{
+            const qs = new URLSearchParams();
+            if (params?.q) qs.set("q", params.q);
+            if (params?.cursor) qs.set("cursor", params.cursor);
+            if (params?.fresh) qs.set("fresh", "1");
+            const suffix = qs.toString() ? `?${qs}` : "";
+            return request(`/mcp-servers/registry${suffix}`);
+        }
+    },
+    integrations: {
+        list: ()=>request("/integrations"),
+        save: (name, values)=>request(`/integrations/${encodeURIComponent(name)}`, {
+                method: "PUT",
+                body: JSON.stringify(values)
+            }),
+        delete: (name)=>request(`/integrations/${encodeURIComponent(name)}`, {
+                method: "DELETE"
+            }),
+        test: (name)=>request(`/integrations/${encodeURIComponent(name)}/test`, {
+                method: "POST",
+                body: "{}"
+            }),
+        gmailOauthStart: (creds)=>request(`/integrations/gmail/oauth/start`, {
+                method: "POST",
+                body: JSON.stringify(creds)
+            }),
+        gmailOauthStatus: (state)=>request(`/integrations/gmail/oauth/status?state=${encodeURIComponent(state)}`),
+        outlookOauthStart: (creds)=>request(`/integrations/outlook/oauth/start`, {
+                method: "POST",
+                body: JSON.stringify(creds)
+            }),
+        outlookOauthStatus: (state)=>request(`/integrations/outlook/oauth/status?state=${encodeURIComponent(state)}`)
+    },
+    envSync: {
+        preview: ()=>request("/env-sync"),
+        apply: ()=>request("/env-sync", {
+                method: "POST",
+                body: "{}"
+            }),
+        allowlist: {
+            get: ()=>request("/env-sync/allowlist"),
+            set: (integration, field, envVars)=>request("/env-sync/allowlist", {
+                    method: "PUT",
+                    body: JSON.stringify({
+                        integration,
+                        field,
+                        envVars
+                    })
+                })
+        }
+    },
+    pending: {
+        list: (status)=>request(`/pending-actions${status ? `?status=${status}` : ""}`),
+        // ADR-0010: `extras` carries approval-time secret material (provider keys,
+        // integration credentials) that the agent never sees. The route forwards
+        // it to applyAction; the agent's pending_actions.payload stays clean.
+        approve: (id, extras)=>request(`/pending-actions/${encodeURIComponent(id)}/approve`, {
+                method: "POST",
+                body: JSON.stringify(extras ? {
+                    extras
+                } : {})
+            }),
+        deny: (id)=>request(`/pending-actions/${encodeURIComponent(id)}/deny`, {
+                method: "POST",
+                body: "{}"
+            })
+    },
+    scheduledTasks: {
+        list: (agent_id)=>request(`/scheduled-tasks${agent_id ? `?agent_id=${encodeURIComponent(agent_id)}` : ""}`),
+        // ADR-0032 — patch supports the reaction discriminator. Mirrors the
+        // watchers.update shape; explicit reaction_kind triggers a full replace.
+        update: (id, patch)=>request(`/scheduled-tasks/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(patch)
+            }),
+        cancel: (id)=>request(`/scheduled-tasks/${encodeURIComponent(id)}`, {
+                method: "DELETE"
+            }),
+        runNow: (id)=>request(`/scheduled-tasks/${encodeURIComponent(id)}/run`, {
+                method: "POST",
+                body: "{}"
+            })
+    },
+    // Event-driven watchers (ADR-0027). Polls a built-in tool every N
+    // seconds; only fires the agent when the tool output changes.
+    watchers: {
+        list: (agent_id)=>request(`/watchers${agent_id ? `?agent_id=${encodeURIComponent(agent_id)}` : ""}`),
+        create: (data)=>request("/watchers", {
+                method: "POST",
+                body: JSON.stringify(data)
+            }),
+        update: (id, patch)=>request(`/watchers/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(patch)
+            }),
+        cancel: (id)=>request(`/watchers/${encodeURIComponent(id)}`, {
+                method: "DELETE"
+            }),
+        runNow: (id)=>request(`/watchers/${encodeURIComponent(id)}/run`, {
+                method: "POST",
+                body: "{}"
+            }),
+        // ADR-0031: list registered reaction scripts (`reaction.*` namespace)
+        // for the watcher UI's reaction-kind picker.
+        listReactionScripts: ()=>request("/watchers/reaction-scripts")
+    },
+    // Document RAG (ADR-0024). Folder sources are scanned by the scheduler
+    // every ~10 minutes; the search endpoint is a thin wrapper over the
+    // `documents_search` tool so callers can preview hits without invoking
+    // an agent.
+    documents: {
+        listSources: ()=>request("/documents/sources"),
+        createSource: (data)=>request("/documents/sources", {
+                method: "POST",
+                body: JSON.stringify(data)
+            }),
+        updateSource: (id, patch)=>request(`/documents/sources/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(patch)
+            }),
+        deleteSource: (id)=>request(`/documents/sources/${encodeURIComponent(id)}`, {
+                method: "DELETE"
+            }),
+        reindex: (id)=>request(`/documents/sources/${encodeURIComponent(id)}/reindex`, {
+                method: "POST",
+                body: "{}"
+            }),
+        search: (q, opts)=>{
+            const p = new URLSearchParams({
+                q
+            });
+            if (opts?.limit) p.set("limit", String(opts.limit));
+            if (opts?.source_id) p.set("source_id", opts.source_id);
+            return request(`/documents/search?${p.toString()}`);
+        },
+        getSettings: ()=>request("/documents/settings"),
+        setSettings: (patch)=>request("/documents/settings", {
+                method: "PUT",
+                body: JSON.stringify(patch)
+            })
+    },
+    // Filesystem browse — backs the folder-picker dialog in the Documents
+    // panel. Lists immediate subdirectories at an absolute path.
+    fs: {
+        browse: (p)=>{
+            const qs = p ? `?path=${encodeURIComponent(p)}` : "";
+            return request(`/fs/browse${qs}`);
+        }
+    },
+    githubCopilotAuth: {
+        status: ()=>request("/providers/github-copilot/auth"),
+        start: ()=>request("/providers/github-copilot/auth", {
+                method: "POST",
+                body: "{}"
+            }),
+        poll: (device_code)=>request("/providers/github-copilot/auth", {
+                method: "PUT",
+                body: JSON.stringify({
+                    device_code
+                })
+            }),
+        signOut: ()=>request("/providers/github-copilot/auth", {
+                method: "DELETE"
+            })
+    },
+    bridges: {
+        list: ()=>request("/bridges"),
+        get: (id)=>request(`/bridges/${encodeURIComponent(id)}`),
+        create: (data)=>request("/bridges", {
+                method: "POST",
+                body: JSON.stringify(data)
+            }),
+        update: (id, patch)=>request(`/bridges/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(patch)
+            }),
+        delete: (id)=>request(`/bridges/${encodeURIComponent(id)}`, {
+                method: "DELETE"
+            }),
+        status: (id)=>request(`/bridges/${encodeURIComponent(id)}/status`),
+        pair: (id)=>request(`/bridges/${encodeURIComponent(id)}/pair`, {
+                method: "POST",
+                body: "{}"
+            }),
+        chats: (id)=>request(`/bridges/${encodeURIComponent(id)}/chats`),
+        lookup: (id, phone)=>request(`/bridges/${encodeURIComponent(id)}/lookup`, {
+                method: "POST",
+                body: JSON.stringify({
+                    phone
+                })
+            }),
+        routes: {
+            list: (bridge_id)=>request(`/bridges/${encodeURIComponent(bridge_id)}/routes`),
+            create: (bridge_id, data)=>request(`/bridges/${encodeURIComponent(bridge_id)}/routes`, {
+                    method: "POST",
+                    body: JSON.stringify(data)
+                }),
+            update: (bridge_id, route_id, patch)=>request(`/bridges/${encodeURIComponent(bridge_id)}/routes/${encodeURIComponent(route_id)}`, {
+                    method: "PATCH",
+                    body: JSON.stringify(patch)
+                }),
+            delete: (bridge_id, route_id)=>request(`/bridges/${encodeURIComponent(bridge_id)}/routes/${encodeURIComponent(route_id)}`, {
+                    method: "DELETE"
+                })
+        }
+    },
+    tailscale: {
+        status: ()=>request("/tailscale")
+    },
+    harnesses: {
+        list: ()=>request("/harnesses"),
+        get: (id)=>request(`/harnesses/${encodeURIComponent(id)}`),
+        create: (data)=>request("/harnesses", {
+                method: "POST",
+                body: JSON.stringify(data)
+            }),
+        update: (id, patch)=>request(`/harnesses/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(patch)
+            }),
+        delete: (id)=>request(`/harnesses/${encodeURIComponent(id)}`, {
+                method: "DELETE"
+            }),
+        setDefault: (id)=>request("/harnesses/default", {
+                method: "PUT",
+                body: JSON.stringify({
+                    id
+                })
+            })
+    },
+    proxy: {
+        get: ()=>request("/proxy-config"),
+        save: (input)=>request("/proxy-config", {
+                method: "PUT",
+                body: JSON.stringify(input)
+            }),
+        clear: ()=>request("/proxy-config", {
+                method: "DELETE"
+            })
+    }
+};
+/** POST /threads/:id/run — registers a run and returns immediately. The
+ *  caller is expected to follow up with `subscribeRun()` to receive the
+ *  chunk stream. Idempotent in the sense that two simultaneous submissions
+ *  for the same thread will see one 202 and one 409 (`run_in_flight`). */ async function submitRun(thread_id, message, signal, stream_options, attachments) {
+    const res = await fetch(`${BASE}/threads/${thread_id}/run`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            message,
+            stream_options,
+            attachments
+        }),
+        signal
+    });
+    // 2xx = accepted (currently always 202); 409 = already running. We treat
+    // every other status as a hard error so the consumer's catch fires.
+    if (res.status === 202) {
+        // Drain the body to free the connection — Next.js sends a small JSON
+        // ack but we don't need anything from it.
+        try {
+            await res.json();
+        } catch  {}
+        return {
+            accepted: true
+        };
+    }
+    let body = {};
+    try {
+        body = await res.json();
+    } catch  {}
+    if (res.status === 409) {
+        return {
+            accepted: false,
+            code: body.code ?? "run_in_flight"
+        };
+    }
+    throw new Error(`${res.status} ${body.error ?? res.statusText}`);
+}
+/** GET /threads/:id/run — opens an `EventSource` and yields raw `data:`
+ *  payloads (one JSON event per yield). Closes the source when the consumer
+ *  stops iterating (either via `break` after a terminal `done`/`error`, or
+ *  when the abort signal fires).
+ *
+ *  EventSource handles its own reconnection on transient drops. The
+ *  server-side run keeps publishing into the registry across drops, so a
+ *  resumed connection replays buffered chunks via `subscribe()` and the
+ *  consumer sees the run through to its terminal event.
+ *
+ *  `stream_options` filter flags ride as query params (`show_tools`,
+ *  `show_thinking`); the rest of `StreamOptions` is meaningful only on the
+ *  POST and is ignored here.
+ */ function subscribeRun(thread_id, signal, stream_options) {
+    const params = new URLSearchParams();
+    const includeTools = stream_options?.filters?.include_tools;
+    const includeThinking = stream_options?.filters?.include_thinking;
+    if (includeTools === false) params.set("show_tools", "false");
+    if (includeThinking === false) params.set("show_thinking", "false");
+    const qs = params.toString();
+    const url = `${BASE}/threads/${thread_id}/run${qs ? `?${qs}` : ""}`;
+    return async function*() {
+        const queue = [];
+        const waiters = [];
+        let done = false;
+        let streamError = null;
+        const notify = ()=>{
+            while(waiters.length > 0)waiters.shift()?.();
+        };
+        const es = new EventSource(url, {
+            withCredentials: true
+        });
+        es.onmessage = (e)=>{
+            if (typeof e.data === "string") {
+                queue.push(e.data);
+                try {
+                    const parsed = JSON.parse(e.data);
+                    if (parsed.type === "done" || parsed.type === "error") {
+                        done = true;
+                    }
+                } catch  {}
+                notify();
+            }
+        };
+        // EventSource auto-reconnects on transient network drops. We only treat
+        // it as a hard error if the *first* connect attempt fails (no successful
+        // 'open' ever fired) — anything after that is a recoverable drop and
+        // the server's replay buffer will deliver missed chunks on reconnect.
+        let everOpened = false;
+        es.onopen = ()=>{
+            everOpened = true;
+        };
+        es.onerror = ()=>{
+            if (!everOpened) {
+                streamError = new Error("EventSource failed to open");
+                done = true;
+                notify();
+            }
+        // else: ignore — EventSource will try to reconnect.
+        };
+        const onAbort = ()=>{
+            done = true;
+            try {
+                es.close();
+            } catch  {}
+            notify();
+        };
+        signal.addEventListener("abort", onAbort, {
+            once: true
+        });
+        try {
+            while(!done || queue.length > 0){
+                if (queue.length > 0) {
+                    yield queue.shift();
+                    continue;
+                }
+                if (streamError) throw streamError;
+                await new Promise((resolve)=>waiters.push(resolve));
+            }
+            if (streamError) throw streamError;
+        } finally{
+            signal.removeEventListener("abort", onAbort);
+            try {
+                es.close();
+            } catch  {}
+        }
+    }();
+}
+
+
+/***/ }),
+
+/***/ 7920:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   SN: () => (/* binding */ getAppIssueUrl),
+/* harmony export */   fj: () => (/* binding */ getAppName)
+/* harmony export */ });
+/* unused harmony export getAppDescription */
+/* provided dependency */ var process = __webpack_require__(7358);
+// Branding knobs sourced from NEXT_PUBLIC_* env vars so forks can rebrand
+// the app without patching source. NEXT_PUBLIC_* is the right
+// channel here because Next.js inlines these at build time, which lets
+// client components read them directly (no React Context, no server
+// round-trip). Server-only modules read the same keys at runtime.
+//
+// Keep this module client-safe — no Node-only imports, no DB/FS access.
+const DEFAULT_APP_NAME = "Jarela";
+const DEFAULT_APP_DESCRIPTION = "Jarela — local chat interface for LangGraph agents";
+const DEFAULT_ISSUE_URL = "https://github.com/CircuitWall/jarela/issues/new";
+function getAppName() {
+    return process.env.NEXT_PUBLIC_APP_NAME?.trim() || DEFAULT_APP_NAME;
+}
+function getAppDescription() {
+    return process.env.NEXT_PUBLIC_APP_DESCRIPTION?.trim() || DEFAULT_APP_DESCRIPTION;
+}
+function getAppIssueUrl() {
+    return process.env.NEXT_PUBLIC_APP_ISSUE_URL?.trim() || DEFAULT_ISSUE_URL;
+}
+
+
+/***/ })
+
+}]);
+//# sourceMappingURL=6945-269d42dc1784c71a.js.map