[GH-ISSUE #622] Only stream display chat less than 30 seconds when use pipe function? #85

New issue

Closed

opened 2026-10-18 14:08:52 +00:00 by bsakaguchi · 2 comments

bsakaguchi commented 2026-10-18 14:08:52 +00:00

Owner

Copy link

Originally created by @QxNam on GitHub (Jul 14, 2025).
Original GitHub issue: https://github.com/open-webui/docs/issues/622

I have tested many chat cases using n8n-pipe function and only chats with response < 30 seconds show chat assistant, the rest do not show (reload web shows). Why? How to improve response time?
This is the template:

"""
title: n8n Pipe Function
author: Cole Medin
author_url: https://www.youtube.com/@ColeMedin
version: 0.2.0

This module defines a Pipe class that utilizes N8N for an Agent
"""

from typing import Optional, Callable, Awaitable
from pydantic import BaseModel, Field
import os
import time
import requests


def extract_event_info(event_emitter) -> tuple[Optional[str], Optional[str]]:
    if not event_emitter or not event_emitter.__closure__:
        return None, None
    for cell in event_emitter.__closure__:
        if isinstance(request_info := cell.cell_contents, dict):
            chat_id = request_info.get("chat_id")
            message_id = request_info.get("message_id")
            return chat_id, message_id
    return None, None


class Pipe:
    class Valves(BaseModel):
        n8n_url: str = Field(
            default="https://n8n.[your domain].com/webhook/[your webhook URL]"
        )
        n8n_bearer_token: str = Field(default="...")
        input_field: str = Field(default="chatInput")
        response_field: str = Field(default="output")
        emit_interval: float = Field(
            default=2.0, description="Interval in seconds between status emissions"
        )
        enable_status_indicator: bool = Field(
            default=True, description="Enable or disable status indicator emissions"
        )

    def __init__(self):
        self.type = "pipe"
        self.id = "n8n_pipe"
        self.name = "N8N Pipe"
        self.valves = self.Valves()
        self.last_emit_time = 0
        pass

    async def emit_status(
        self,
        __event_emitter__: Callable[[dict], Awaitable[None]],
        level: str,
        message: str,
        done: bool,
    ):
        current_time = time.time()
        if (
            __event_emitter__
            and self.valves.enable_status_indicator
            and (
                current_time - self.last_emit_time >= self.valves.emit_interval or done
            )
        ):
            await __event_emitter__(
                {
                    "type": "status",
                    "data": {
                        "status": "complete" if done else "in_progress",
                        "level": level,
                        "description": message,
                        "done": done,
                    },
                }
            )
            self.last_emit_time = current_time

    async def pipe(
        self,
        body: dict,
        __user__: Optional[dict] = None,
        __event_emitter__: Callable[[dict], Awaitable[None]] = None,
        __event_call__: Callable[[dict], Awaitable[dict]] = None,
    ) -> Optional[dict]:
        await self.emit_status(
            __event_emitter__, "info", "Đang nhập tin nhắn...", False
        )
        chat_id, _ = extract_event_info(__event_emitter__)
        messages = body.get("messages", [])

        # Verify a message is available
        if messages:
            question = messages[-1]["content"]
            try:
                # Invoke N8N workflow
                headers = {
                    "Authorization": f"Bearer {self.valves.n8n_bearer_token}",
                    "Content-Type": "application/json",
                }
                payload = {"sessionId": f"{chat_id}"}
                payload[self.valves.input_field] = question
                payload["user"] = __user__
                response = requests.post(
                    self.valves.n8n_url, json=payload, headers=headers
                )
                if response.status_code == 200:
                    n8n_response = response.json()[self.valves.response_field]
                else:
                    raise Exception(f"Error: {response.status_code} - {response.text}")

                # Set assitant message with chain reply
                body["messages"].append({"role": "assistant", "content": n8n_response})
            except Exception as e:
                await self.emit_status(
                    __event_emitter__,
                    "error",
                    f"Error during sequence execution: {str(e)}",
                    True,
                )
                return {"error": str(e)}
        # If no message is available alert user
        else:
            await self.emit_status(
                __event_emitter__,
                "error",
                "No messages found in the request body",
                True,
            )
            body["messages"].append(
                {
                    "role": "assistant",
                    "content": "No messages found in the request body",
                }
            )

        await self.emit_status(__event_emitter__, "info", "", True)
        return n8n_response

Response from n8n-pipe after 30s will stay like this forever, only when reloading the web will it display.

Originally created by @QxNam on GitHub (Jul 14, 2025). Original GitHub issue: https://github.com/open-webui/docs/issues/622 I have tested many chat cases using n8n-pipe function and only chats with response < 30 seconds show chat assistant, the rest do not show (reload web shows). Why? How to improve response time? This is the template: ``` """ title: n8n Pipe Function author: Cole Medin author_url: https://www.youtube.com/@ColeMedin version: 0.2.0 This module defines a Pipe class that utilizes N8N for an Agent """ from typing import Optional, Callable, Awaitable from pydantic import BaseModel, Field import os import time import requests def extract_event_info(event_emitter) -> tuple[Optional[str], Optional[str]]: if not event_emitter or not event_emitter.__closure__: return None, None for cell in event_emitter.__closure__: if isinstance(request_info := cell.cell_contents, dict): chat_id = request_info.get("chat_id") message_id = request_info.get("message_id") return chat_id, message_id return None, None class Pipe: class Valves(BaseModel): n8n_url: str = Field( default="https://n8n.[your domain].com/webhook/[your webhook URL]" ) n8n_bearer_token: str = Field(default="...") input_field: str = Field(default="chatInput") response_field: str = Field(default="output") emit_interval: float = Field( default=2.0, description="Interval in seconds between status emissions" ) enable_status_indicator: bool = Field( default=True, description="Enable or disable status indicator emissions" ) def __init__(self): self.type = "pipe" self.id = "n8n_pipe" self.name = "N8N Pipe" self.valves = self.Valves() self.last_emit_time = 0 pass async def emit_status( self, __event_emitter__: Callable[[dict], Awaitable[None]], level: str, message: str, done: bool, ): current_time = time.time() if ( __event_emitter__ and self.valves.enable_status_indicator and ( current_time - self.last_emit_time >= self.valves.emit_interval or done ) ): await __event_emitter__( { "type": "status", "data": { "status": "complete" if done else "in_progress", "level": level, "description": message, "done": done, }, } ) self.last_emit_time = current_time async def pipe( self, body: dict, __user__: Optional[dict] = None, __event_emitter__: Callable[[dict], Awaitable[None]] = None, __event_call__: Callable[[dict], Awaitable[dict]] = None, ) -> Optional[dict]: await self.emit_status( __event_emitter__, "info", "Đang nhập tin nhắn...", False ) chat_id, _ = extract_event_info(__event_emitter__) messages = body.get("messages", []) # Verify a message is available if messages: question = messages[-1]["content"] try: # Invoke N8N workflow headers = { "Authorization": f"Bearer {self.valves.n8n_bearer_token}", "Content-Type": "application/json", } payload = {"sessionId": f"{chat_id}"} payload[self.valves.input_field] = question payload["user"] = __user__ response = requests.post( self.valves.n8n_url, json=payload, headers=headers ) if response.status_code == 200: n8n_response = response.json()[self.valves.response_field] else: raise Exception(f"Error: {response.status_code} - {response.text}") # Set assitant message with chain reply body["messages"].append({"role": "assistant", "content": n8n_response}) except Exception as e: await self.emit_status( __event_emitter__, "error", f"Error during sequence execution: {str(e)}", True, ) return {"error": str(e)} # If no message is available alert user else: await self.emit_status( __event_emitter__, "error", "No messages found in the request body", True, ) body["messages"].append( { "role": "assistant", "content": "No messages found in the request body", } ) await self.emit_status(__event_emitter__, "info", "", True) return n8n_response ``` Response from n8n-pipe after 30s will stay like this forever, only when reloading the web will it display. <img width="348" height="61" alt="Image" src="https://github.com/user-attachments/assets/1df7c331-5ac6-4766-9ec6-e8f37d49ab4d" />

bsakaguchi closed this issue 2026-10-18 14:08:52 +00:00

bsakaguchi commented 2026-10-18 14:08:52 +00:00

Author

Owner

Copy link

@QxNam commented on GitHub (Jul 14, 2025):

I have tested many chat cases using n8n-pipe function and only chats with response < 30 seconds show chat assistant, the rest do not show (reload web shows). Why? How to improve response time? This is the template:

"""
title: n8n Pipe Function
author: Cole Medin
author_url: https://www.youtube.com/@ColeMedin
version: 0.2.0

This module defines a Pipe class that utilizes N8N for an Agent
"""

from typing import Optional, Callable, Awaitable
from pydantic import BaseModel, Field
import os
import time
import requests


def extract_event_info(event_emitter) -> tuple[Optional[str], Optional[str]]:
    if not event_emitter or not event_emitter.__closure__:
        return None, None
    for cell in event_emitter.__closure__:
        if isinstance(request_info := cell.cell_contents, dict):
            chat_id = request_info.get("chat_id")
            message_id = request_info.get("message_id")
            return chat_id, message_id
    return None, None


class Pipe:
    class Valves(BaseModel):
        n8n_url: str = Field(
            default="https://n8n.[your domain].com/webhook/[your webhook URL]"
        )
        n8n_bearer_token: str = Field(default="...")
        input_field: str = Field(default="chatInput")
        response_field: str = Field(default="output")
        emit_interval: float = Field(
            default=2.0, description="Interval in seconds between status emissions"
        )
        enable_status_indicator: bool = Field(
            default=True, description="Enable or disable status indicator emissions"
        )

    def __init__(self):
        self.type = "pipe"
        self.id = "n8n_pipe"
        self.name = "N8N Pipe"
        self.valves = self.Valves()
        self.last_emit_time = 0
        pass

    async def emit_status(
        self,
        __event_emitter__: Callable[[dict], Awaitable[None]],
        level: str,
        message: str,
        done: bool,
    ):
        current_time = time.time()
        if (
            __event_emitter__
            and self.valves.enable_status_indicator
            and (
                current_time - self.last_emit_time >= self.valves.emit_interval or done
            )
        ):
            await __event_emitter__(
                {
                    "type": "status",
                    "data": {
                        "status": "complete" if done else "in_progress",
                        "level": level,
                        "description": message,
                        "done": done,
                    },
                }
            )
            self.last_emit_time = current_time

    async def pipe(
        self,
        body: dict,
        __user__: Optional[dict] = None,
        __event_emitter__: Callable[[dict], Awaitable[None]] = None,
        __event_call__: Callable[[dict], Awaitable[dict]] = None,
    ) -> Optional[dict]:
        await self.emit_status(
            __event_emitter__, "info", "Đang nhập tin nhắn...", False
        )
        chat_id, _ = extract_event_info(__event_emitter__)
        messages = body.get("messages", [])

        # Verify a message is available
        if messages:
            question = messages[-1]["content"]
            try:
                # Invoke N8N workflow
                headers = {
                    "Authorization": f"Bearer {self.valves.n8n_bearer_token}",
                    "Content-Type": "application/json",
                }
                payload = {"sessionId": f"{chat_id}"}
                payload[self.valves.input_field] = question
                payload["user"] = __user__
                response = requests.post(
                    self.valves.n8n_url, json=payload, headers=headers
                )
                if response.status_code == 200:
                    n8n_response = response.json()[self.valves.response_field]
                else:
                    raise Exception(f"Error: {response.status_code} - {response.text}")

                # Set assitant message with chain reply
                body["messages"].append({"role": "assistant", "content": n8n_response})
            except Exception as e:
                await self.emit_status(
                    __event_emitter__,
                    "error",
                    f"Error during sequence execution: {str(e)}",
                    True,
                )
                return {"error": str(e)}
        # If no message is available alert user
        else:
            await self.emit_status(
                __event_emitter__,
                "error",
                "No messages found in the request body",
                True,
            )
            body["messages"].append(
                {
                    "role": "assistant",
                    "content": "No messages found in the request body",
                }
            )

        await self.emit_status(__event_emitter__, "info", "", True)
        return n8n_response

Response from n8n-pipe after 30s will stay like this forever, only when reloading the web will it display.

<!-- gh-comment-id:3070993487 --> @QxNam commented on GitHub (Jul 14, 2025): > I have tested many chat cases using n8n-pipe function and only chats with response < 30 seconds show chat assistant, the rest do not show (reload web shows). Why? How to improve response time? This is the template: > > ``` > """ > title: n8n Pipe Function > author: Cole Medin > author_url: https://www.youtube.com/@ColeMedin > version: 0.2.0 > > This module defines a Pipe class that utilizes N8N for an Agent > """ > > from typing import Optional, Callable, Awaitable > from pydantic import BaseModel, Field > import os > import time > import requests > > > def extract_event_info(event_emitter) -> tuple[Optional[str], Optional[str]]: > if not event_emitter or not event_emitter.__closure__: > return None, None > for cell in event_emitter.__closure__: > if isinstance(request_info := cell.cell_contents, dict): > chat_id = request_info.get("chat_id") > message_id = request_info.get("message_id") > return chat_id, message_id > return None, None > > > class Pipe: > class Valves(BaseModel): > n8n_url: str = Field( > default="https://n8n.[your domain].com/webhook/[your webhook URL]" > ) > n8n_bearer_token: str = Field(default="...") > input_field: str = Field(default="chatInput") > response_field: str = Field(default="output") > emit_interval: float = Field( > default=2.0, description="Interval in seconds between status emissions" > ) > enable_status_indicator: bool = Field( > default=True, description="Enable or disable status indicator emissions" > ) > > def __init__(self): > self.type = "pipe" > self.id = "n8n_pipe" > self.name = "N8N Pipe" > self.valves = self.Valves() > self.last_emit_time = 0 > pass > > async def emit_status( > self, > __event_emitter__: Callable[[dict], Awaitable[None]], > level: str, > message: str, > done: bool, > ): > current_time = time.time() > if ( > __event_emitter__ > and self.valves.enable_status_indicator > and ( > current_time - self.last_emit_time >= self.valves.emit_interval or done > ) > ): > await __event_emitter__( > { > "type": "status", > "data": { > "status": "complete" if done else "in_progress", > "level": level, > "description": message, > "done": done, > }, > } > ) > self.last_emit_time = current_time > > async def pipe( > self, > body: dict, > __user__: Optional[dict] = None, > __event_emitter__: Callable[[dict], Awaitable[None]] = None, > __event_call__: Callable[[dict], Awaitable[dict]] = None, > ) -> Optional[dict]: > await self.emit_status( > __event_emitter__, "info", "Đang nhập tin nhắn...", False > ) > chat_id, _ = extract_event_info(__event_emitter__) > messages = body.get("messages", []) > > # Verify a message is available > if messages: > question = messages[-1]["content"] > try: > # Invoke N8N workflow > headers = { > "Authorization": f"Bearer {self.valves.n8n_bearer_token}", > "Content-Type": "application/json", > } > payload = {"sessionId": f"{chat_id}"} > payload[self.valves.input_field] = question > payload["user"] = __user__ > response = requests.post( > self.valves.n8n_url, json=payload, headers=headers > ) > if response.status_code == 200: > n8n_response = response.json()[self.valves.response_field] > else: > raise Exception(f"Error: {response.status_code} - {response.text}") > > # Set assitant message with chain reply > body["messages"].append({"role": "assistant", "content": n8n_response}) > except Exception as e: > await self.emit_status( > __event_emitter__, > "error", > f"Error during sequence execution: {str(e)}", > True, > ) > return {"error": str(e)} > # If no message is available alert user > else: > await self.emit_status( > __event_emitter__, > "error", > "No messages found in the request body", > True, > ) > body["messages"].append( > { > "role": "assistant", > "content": "No messages found in the request body", > } > ) > > await self.emit_status(__event_emitter__, "info", "", True) > return n8n_response > ``` > > Response from n8n-pipe after 30s will stay like this forever, only when reloading the web will it display. <img alt="Image" width="348" height="61" src="https://private-user-images.githubusercontent.com/89223837/466196207-1df7c331-5ac6-4766-9ec6-e8f37d49ab4d.png?jwt=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NTI1Mjc1MjYsIm5iZiI6MTc1MjUyNzIyNiwicGF0aCI6Ii84OTIyMzgzNy80NjYxOTYyMDctMWRmN2MzMzEtNWFjNi00NzY2LTllYzYtZThmMzdkNDlhYjRkLnBuZz9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNTA3MTQlMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjUwNzE0VDIxMDcwNlomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTgwZmFiNDJhM2Y1ODFhN2IwMzBmNTlhOTdkNzBkMGIyYTE4ZWI1OTgyNjA3MzM3MWQ3MjFlYmUyNGJlNzM4MzcmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0In0.3DXsp90Ql_QCs6_nuZkMZOyZmyPVU0rQTmTszTKChgA">

bsakaguchi commented 2026-10-18 14:08:52 +00:00

Author

Owner

Copy link

@QxNam commented on GitHub (Jul 14, 2025):

I have tested many chat cases using n8n-pipe function and only chats with response < 30 seconds show chat assistant, the rest do not show (reload web shows). Why? How to improve response time? This is the template:

"""
title: n8n Pipe Function
author: Cole Medin
author_url: https://www.youtube.com/@ColeMedin
version: 0.2.0

This module defines a Pipe class that utilizes N8N for an Agent
"""

from typing import Optional, Callable, Awaitable
from pydantic import BaseModel, Field
import os
import time
import requests


def extract_event_info(event_emitter) -> tuple[Optional[str], Optional[str]]:
    if not event_emitter or not event_emitter.__closure__:
        return None, None
    for cell in event_emitter.__closure__:
        if isinstance(request_info := cell.cell_contents, dict):
            chat_id = request_info.get("chat_id")
            message_id = request_info.get("message_id")
            return chat_id, message_id
    return None, None


class Pipe:
    class Valves(BaseModel):
        n8n_url: str = Field(
            default="https://n8n.[your domain].com/webhook/[your webhook URL]"
        )
        n8n_bearer_token: str = Field(default="...")
        input_field: str = Field(default="chatInput")
        response_field: str = Field(default="output")
        emit_interval: float = Field(
            default=2.0, description="Interval in seconds between status emissions"
        )
        enable_status_indicator: bool = Field(
            default=True, description="Enable or disable status indicator emissions"
        )

    def __init__(self):
        self.type = "pipe"
        self.id = "n8n_pipe"
        self.name = "N8N Pipe"
        self.valves = self.Valves()
        self.last_emit_time = 0
        pass

    async def emit_status(
        self,
        __event_emitter__: Callable[[dict], Awaitable[None]],
        level: str,
        message: str,
        done: bool,
    ):
        current_time = time.time()
        if (
            __event_emitter__
            and self.valves.enable_status_indicator
            and (
                current_time - self.last_emit_time >= self.valves.emit_interval or done
            )
        ):
            await __event_emitter__(
                {
                    "type": "status",
                    "data": {
                        "status": "complete" if done else "in_progress",
                        "level": level,
                        "description": message,
                        "done": done,
                    },
                }
            )
            self.last_emit_time = current_time

    async def pipe(
        self,
        body: dict,
        __user__: Optional[dict] = None,
        __event_emitter__: Callable[[dict], Awaitable[None]] = None,
        __event_call__: Callable[[dict], Awaitable[dict]] = None,
    ) -> Optional[dict]:
        await self.emit_status(
            __event_emitter__, "info", "Đang nhập tin nhắn...", False
        )
        chat_id, _ = extract_event_info(__event_emitter__)
        messages = body.get("messages", [])

        # Verify a message is available
        if messages:
            question = messages[-1]["content"]
            try:
                # Invoke N8N workflow
                headers = {
                    "Authorization": f"Bearer {self.valves.n8n_bearer_token}",
                    "Content-Type": "application/json",
                }
                payload = {"sessionId": f"{chat_id}"}
                payload[self.valves.input_field] = question
                payload["user"] = __user__
                response = requests.post(
                    self.valves.n8n_url, json=payload, headers=headers
                )
                if response.status_code == 200:
                    n8n_response = response.json()[self.valves.response_field]
                else:
                    raise Exception(f"Error: {response.status_code} - {response.text}")

                # Set assitant message with chain reply
                body["messages"].append({"role": "assistant", "content": n8n_response})
            except Exception as e:
                await self.emit_status(
                    __event_emitter__,
                    "error",
                    f"Error during sequence execution: {str(e)}",
                    True,
                )
                return {"error": str(e)}
        # If no message is available alert user
        else:
            await self.emit_status(
                __event_emitter__,
                "error",
                "No messages found in the request body",
                True,
            )
            body["messages"].append(
                {
                    "role": "assistant",
                    "content": "No messages found in the request body",
                }
            )

        await self.emit_status(__event_emitter__, "info", "", True)
        return n8n_response

Response from n8n-pipe after 30s will stay like this forever, only when reloading the web will it display.

<!-- gh-comment-id:3070994724 --> @QxNam commented on GitHub (Jul 14, 2025): > I have tested many chat cases using n8n-pipe function and only chats with response < 30 seconds show chat assistant, the rest do not show (reload web shows). Why? How to improve response time? This is the template: > > ``` > """ > title: n8n Pipe Function > author: Cole Medin > author_url: https://www.youtube.com/@ColeMedin > version: 0.2.0 > > This module defines a Pipe class that utilizes N8N for an Agent > """ > > from typing import Optional, Callable, Awaitable > from pydantic import BaseModel, Field > import os > import time > import requests > > > def extract_event_info(event_emitter) -> tuple[Optional[str], Optional[str]]: > if not event_emitter or not event_emitter.__closure__: > return None, None > for cell in event_emitter.__closure__: > if isinstance(request_info := cell.cell_contents, dict): > chat_id = request_info.get("chat_id") > message_id = request_info.get("message_id") > return chat_id, message_id > return None, None > > > class Pipe: > class Valves(BaseModel): > n8n_url: str = Field( > default="https://n8n.[your domain].com/webhook/[your webhook URL]" > ) > n8n_bearer_token: str = Field(default="...") > input_field: str = Field(default="chatInput") > response_field: str = Field(default="output") > emit_interval: float = Field( > default=2.0, description="Interval in seconds between status emissions" > ) > enable_status_indicator: bool = Field( > default=True, description="Enable or disable status indicator emissions" > ) > > def __init__(self): > self.type = "pipe" > self.id = "n8n_pipe" > self.name = "N8N Pipe" > self.valves = self.Valves() > self.last_emit_time = 0 > pass > > async def emit_status( > self, > __event_emitter__: Callable[[dict], Awaitable[None]], > level: str, > message: str, > done: bool, > ): > current_time = time.time() > if ( > __event_emitter__ > and self.valves.enable_status_indicator > and ( > current_time - self.last_emit_time >= self.valves.emit_interval or done > ) > ): > await __event_emitter__( > { > "type": "status", > "data": { > "status": "complete" if done else "in_progress", > "level": level, > "description": message, > "done": done, > }, > } > ) > self.last_emit_time = current_time > > async def pipe( > self, > body: dict, > __user__: Optional[dict] = None, > __event_emitter__: Callable[[dict], Awaitable[None]] = None, > __event_call__: Callable[[dict], Awaitable[dict]] = None, > ) -> Optional[dict]: > await self.emit_status( > __event_emitter__, "info", "Đang nhập tin nhắn...", False > ) > chat_id, _ = extract_event_info(__event_emitter__) > messages = body.get("messages", []) > > # Verify a message is available > if messages: > question = messages[-1]["content"] > try: > # Invoke N8N workflow > headers = { > "Authorization": f"Bearer {self.valves.n8n_bearer_token}", > "Content-Type": "application/json", > } > payload = {"sessionId": f"{chat_id}"} > payload[self.valves.input_field] = question > payload["user"] = __user__ > response = requests.post( > self.valves.n8n_url, json=payload, headers=headers > ) > if response.status_code == 200: > n8n_response = response.json()[self.valves.response_field] > else: > raise Exception(f"Error: {response.status_code} - {response.text}") > > # Set assitant message with chain reply > body["messages"].append({"role": "assistant", "content": n8n_response}) > except Exception as e: > await self.emit_status( > __event_emitter__, > "error", > f"Error during sequence execution: {str(e)}", > True, > ) > return {"error": str(e)} > # If no message is available alert user > else: > await self.emit_status( > __event_emitter__, > "error", > "No messages found in the request body", > True, > ) > body["messages"].append( > { > "role": "assistant", > "content": "No messages found in the request body", > } > ) > > await self.emit_status(__event_emitter__, "info", "", True) > return n8n_response > ``` > > Response from n8n-pipe after 30s will stay like this forever, only when reloading the web will it display. <img alt="Image" width="348" height="61" src="https://private-user-images.githubusercontent.com/89223837/466196207-1df7c331-5ac6-4766-9ec6-e8f37d49ab4d.png?jwt=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NTI1Mjc1MjYsIm5iZiI6MTc1MjUyNzIyNiwicGF0aCI6Ii84OTIyMzgzNy80NjYxOTYyMDctMWRmN2MzMzEtNWFjNi00NzY2LTllYzYtZThmMzdkNDlhYjRkLnBuZz9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNTA3MTQlMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjUwNzE0VDIxMDcwNlomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTgwZmFiNDJhM2Y1ODFhN2IwMzBmNTlhOTdkNzBkMGIyYTE4ZWI1OTgyNjA3MzM3MWQ3MjFlYmUyNGJlNzM4MzcmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0In0.3DXsp90Ql_QCs6_nuZkMZOyZmyPVU0rQTmTszTKChgA">

bsakaguchi referenced this issue 2026-10-18 14:10:25 +00:00

[PR #85] [MERGED] chore: Update features.md #234

Sign in to join this conversation.

No Branch/Tag specified

Branches Tags

main

dev

No results found.

Labels

Clear labels   

bug

  

documentation

  

documentation

  

duplicate

  

enhancement

  

enhancement

  

good first issue

  

good first issue

  

good first issue

  

help wanted

  

help wanted

  

pull-request

Mirrored from GitHub Pull Request

No labels

bug

documentation

documentation

duplicate

enhancement

enhancement

good first issue

good first issue

good first issue

help wanted

help wanted

pull-request

Milestone

Clear milestone

No items

No milestone

Projects

Clear projects

No items

No project

Assignees

Clear assignees

No assignees

1 participant

Notifications

Subscribe

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference

open-webui/docs#85

No description provided.