以开放 API 的聊天接口为例，入口是 ChatApi.post（api/controllers/service_api/app/completion.py:357）：

# api/controllers/service_api/app/completion.py:357
def post(self, session: Session, app_model: App, end_user: EndUser):
    app_mode = AppMode.value_of(app_model.mode)                    # ① 认出应用类型
    if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
        raise NotChatAppError()                                    # ② 类型不对直接拒绝
    payload = ChatRequestPayload.model_validate(... or {})         # ③ 校验请求参数
    args = payload.model_dump(exclude_none=True)
    ...
    streaming = _resolve_agent_app_streaming(app_mode=app_mode, response_mode=payload.response_mode)
    try:
        response = AppGenerateService.generate(                    # ④ ★把活交给 Service
            session=session, app_model=app_model, user=end_user,
            args=args, invoke_from=InvokeFrom.SERVICE_API, streaming=streaming,
        )
        return helper.compact_generate_response(response)          # ⑤ 打包响应返回
    except ...

Service 的 generate（api/services/app_generate_service.py:97）套了一层限流/护栏后，核心分发在 _dispatch_generate（api/services/app_generate_service.py:161），用 match/case 按 AppMode 挑生成器：

# api/services/app_generate_service.py:161
def _dispatch_generate(cls, *, app_model, user, args, invoke_from, streaming, ...):
    effective_mode = (
        AppMode.AGENT_CHAT if app_model.is_agent and app_model.mode != AppMode.AGENT_CHAT
        else app_model.mode
    )
    match effective_mode:
        case AppMode.COMPLETION:                       # 文本生成
            return rate_limit.generate(CompletionAppGenerator...().generate(...), ...)
        case AppMode.AGENT_CHAT:                        # Agent 对话
            return rate_limit.generate(AgentChatAppGenerator().generate(...), ...)
        case AppMode.CHAT:                              # ★我们的例子：聊天助手
            return rate_limit.generate(
                ChatAppGenerator.convert_to_event_stream(
                    ChatAppGenerator().generate(
                        session=session, app_model=app_model, user=user,
                        args=args, invoke_from=invoke_from, streaming=streaming,
                    ),
                ),
                request_id=request_id,
            )
        case AppMode.ADVANCED_CHAT: ...                 # Chatflow（走工作流）
        case AppMode.WORKFLOW: ...                      # 工作流

到了 ChatAppGenerator.generate（api/core/app/apps/chat/app_generator.py:70）。它先把请求"组装"成一个生成实体，建好对话/消息记录和队列，然后另起线程去跑 Runner（api/core/app/apps/chat/app_generator.py:158 起）：

# api/core/app/apps/chat/app_generator.py:158
application_generate_entity = ChatAppGenerateEntity(         # ① 把一切打包成"生成实体"
    task_id=str(uuid.uuid4()),
    app_config=app_config,
    model_conf=ModelConfigConverter.convert(app_config),    #    包含用哪个模型
    query=query, files=list(file_objs),
    user_id=user.id, invoke_from=invoke_from, stream=streaming, ...
)
# ② 建对话记录 + 消息记录（写库）
(conversation, message) = self._init_generate_records(application_generate_entity, conversation)
# ③ 建事件队列（Generator 和 Runner 靠它通信）
queue_manager = MessageBasedAppQueueManager(task_id=..., conversation_id=conversation.id, message_id=message.id)

context = contextvars.copy_context()
@copy_current_request_context
def worker_with_context():
    return context.run(self._generate_worker, session=session,
        flask_app=current_app._get_current_object(),
        application_generate_entity=application_generate_entity,
        queue_manager=queue_manager, conversation_id=conversation.id, message_id=message.id)

worker_thread = threading.Thread(target=worker_with_context)   # ④ ★另起后台线程
worker_thread.start()                                          #    Runner 将在这个线程里跑

response = self._handle_response(                              # ⑤ ★主线程立刻返回"响应流"
    application_generate_entity=application_generate_entity,
    queue_manager=queue_manager, conversation=conversation, message=message,
    user=user, stream=streaming,
)
return ChatAppGenerateResponseConverter.convert(response=response, invoke_from=invoke_from)

后台线程跑的是 _generate_worker（api/core/app/apps/chat/app_generator.py:229），它在 Flask 上下文里 new 一个 Runner 并 run（api/core/app/apps/chat/app_generator.py:255）：

# api/core/app/apps/chat/app_generator.py:229
def _generate_worker(self, flask_app, session, application_generate_entity, queue_manager, conversation_id, message_id):
    with flask_app.app_context():
        try:
            conversation = self._get_conversation(conversation_id)
            message = self._get_message(message_id)
            runner = ChatAppRunner()                       # ★后厨上灶
            runner.run(
                session=session,
                application_generate_entity=application_generate_entity,
                queue_manager=queue_manager,               # ← 把队列交给 runner，它往里写事件
                conversation=conversation, message=message,
            )
        except GenerateTaskStoppedError:
            pass
        except Exception as e:
            queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)  # 出错也发进队列
        finally:
            db.session.close()

ChatAppRunner.run（api/core/app/apps/chat/app_runner.py:33）里做的事，正是 Day03 说的"后厨流程"：

# api/core/app/apps/chat/app_runner.py:33（节选核心步骤）
# ① 组织提示词：模板 + inputs + query + 文件 + 记忆
prompt_messages, stop = self.organize_prompt_messages(...)
# ② 内容审核（敏感词）
_, inputs, query = self.moderation_for_inputs(...)
# ③（可选）命中标注直接回复 / 检索知识库
# ...
# ④ 调模型（结果流会被送进 queue_manager）→ Day05 的主角

L04 的 _handle_response 返回的"响应流"，底层就是任务流水线在从队列消费事件。会话式应用用 EasyUIBasedGenerateTaskPipeline（api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py:71），核心是 _process_stream_response（api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py:258）：

# api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py:258
def _process_stream_response(self, ...):
    for message in self._queue_manager.listen():          # ★不断从队列「读」事件
        event = message.event
        match event:
            case QueueLLMChunkEvent():                    # :321 模型吐了一小段文字
                # → 转成一个 SSE chunk，yield 给前端（前端就看到字蹦出来）
                ...
            case QueueStopEvent() | QueueMessageEndEvent(): # :276 生成结束
                # → 收尾：存最终消息、算 token、yield 结束事件
                ...