# -*- coding: utf-8 -*-

# mcp_server.py

"""基於倉頡 + DeepSeek + MCP 的智能膳食分析助手"""

from fastapi import FastAPI
from pydantic import BaseModel
import json
from typing import List, Dict, Any
from fastapi.responses import StreamingResponse
from deepseek_client import stream_deepseek, async_stream_deepseek
from text_match import extract_food_simple, extract_food
from loguru import logger
from cachetools import TTLCache
import sys

# 加載食物字典
with open("food_tags.json", encoding="utf-8") as f:
    FOOD_TAGS: Dict[str, Dict[str, Any]] = json.load(f)

app = FastAPI()

class Input(BaseModel):
    input: str

# 全局緩存：prompt -> full_reply_text
CACHE = TTLCache(maxsize=500, ttl=1800)  # 30分鐘自動過期

logger.remove()
logger.add(sys.stdout, level="INFO", enqueue=False, backtrace=False)

# ---- 基礎角色詞 ----
BASE_SYSTEM_PROMPT = (
    "你是一名資深註冊營養師，擅長以簡潔的 Markdown 格式給出科學、可執行的飲食建議。"
    "所有回答需包含以下小節：\n"
    "1. 總體評價\n"
    "2. 推薦攝入（量/食材）\n"
    "3. 過量風險\n"
    "4. 不宜同食\n"
    "5. 行動建議\n"
    "回答請使用中文，並儘量在 300 字以內。"
)

# ---- 場景化模板 ----
PROMPTS = {
    "nutrition_review": (
        BASE_SYSTEM_PROMPT
        + "\n\n【場景】飲食點評。請先總體評價，再按上表 1~5 小節輸出：{input}"
    ),
    "diet_plan": (
        BASE_SYSTEM_PROMPT
        + "\n\n【場景】減脂期餐單。請輸出 3 日食譜 (表格形式)，並在每餐註明熱量估計：{input}"
    ),
    "effects_inquiry": (
        BASE_SYSTEM_PROMPT
        + "\n\n【場景】過量影響。請列出已知副作用及參考文獻：{input}"
    ),
    "avoid_inquiry": (
        BASE_SYSTEM_PROMPT
        + "\n\n【場景】相剋查詢。請説明不宜同食原因及替代方案：{input}"
    ),
}

def _process_input(user_input: str):
    """內部共用邏輯，返回分析結果和 prompt"""
    # === 1. 食物關鍵字匹配 ===
    food_list, exact_hits, fuzzy_hits = extract_food(user_input, FOOD_TAGS.keys())

    # 記錄匹配詳情到日誌
    logger.info(f"[匹配] 精確={exact_hits} 模糊={fuzzy_hits}")

    # === 2. 聚合靜態信息 ===
    tags = list({tag for food in food_list for tag in FOOD_TAGS[food].get("tags", [])})
    effects = {food: FOOD_TAGS[food].get("effects") for food in food_list if FOOD_TAGS[food].get("effects")}
    avoid_with = list({aw for food in food_list for aw in FOOD_TAGS[food].get("avoid_with", [])})
    diet_type = list({dt for food in food_list for dt in FOOD_TAGS[food].get("diet_type", [])})

    # === 3. 根據關鍵詞判定 mode ===
    mode = "nutrition_review"
    if any(k in user_input for k in ["減肥", "減脂", "低卡", "少油", "瘦身", "個人食譜"]):
        mode = "diet_plan"
    elif any(k in user_input for k in ["吃多了", "過量", "上火", "副作用", "影響"]):
        mode = "effects_inquiry"
    elif any(k in user_input for k in ["不能一起", "相剋", "不宜同食", "一起吃"]):
        mode = "avoid_inquiry"

    new_prompt_base = PROMPTS[mode].format(input=user_input)

    # === 4. 拼接靜態附加信息 ===
    notes = []
    if effects:
        notes.append("【過量風險】" + "；".join(f"{food}:{desc}" for food, desc in effects.items()))
    if avoid_with:
        notes.append("【不宜同食】" + "、".join(avoid_with))
    extra_info = "；".join(notes)
    if extra_info:
        new_prompt_base += (
            "\n\n以下為已知靜態信息（請務必先列出【過量風險】與【不宜同食】兩個小節，並完整引用下列內容，否則視為回答不完整）："
            f"{extra_info}"
        )

    # 要求模型以 JSON 輸出，配合 response_format
    new_prompt = new_prompt_base + "\n請使用 markdown bullet list 輸出建議。"

    return {
        "food_list": food_list,
        "tags": tags,
        "effects": effects,
        "avoid_with": avoid_with,
        "diet_type": diet_type,
        "mode": mode,
        "routed_input": new_prompt,
    }

@app.post("/mcp")
async def route_prompt(data: Input):
    user_input = data.input
    result = _process_input(user_input)
    return result

@app.post("/mcp_stream")
async def route_prompt_stream(data: Input):
    user_input = data.input
    result = _process_input(user_input)

    async def event_generator():
        meta_json = json.dumps({k: v for k, v in result.items() if k != 'routed_input'}, ensure_ascii=False)
        # 發送 Meta 事件
        yield f"event: meta\ndata: {meta_json}\n\n"

        prompt_key = result["routed_input"]

        # 若緩存命中，直接按20字符切片發送緩存內容
        if prompt_key in CACHE:
            logger.info("[緩存] 命中")
            cached_text = CACHE[prompt_key]
            # SSE data 行不能包含裸換行，需逐行加前綴
            payload_lines = [f"data: {line}" for line in cached_text.split("\n")]
            payload_block = "\n".join(payload_lines)
            yield f"event: token\n{payload_block}\n\n"
            yield "event: done\ndata: [DONE]\n\n"
            return

        logger.info("[緩存] 未命中")
        collected_chunks = []
        async for chunk in async_stream_deepseek(prompt_key):
            collected_chunks.append(chunk)
            yield f"event: token\ndata: {chunk}\n\n"

        # 緩存完整內容
        full_text = "".join(collected_chunks)
        CACHE[prompt_key] = full_text

        # 結束事件
        yield "event: done\ndata: [DONE]\n\n"

    return StreamingResponse(event_generator(), media_type="text/event-stream")

# deepseek_client.py
# 基於 DeepSeek API 的客户端
import requests
import json
from typing import Generator
import httpx

# 從 config.json 讀取配置
with open("config.json", encoding="utf-8") as f:
    config = json.load(f)

DEEPSEEK_API_KEY = config["DEEPSEEK_API_KEY"]
DEEPSEEK_URL = config["DEEPSEEK_URL"]
MODEL_NAME = config["MODEL_NAME"]

def call_deepseek(prompt):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
    }

    payload = {
        "model": MODEL_NAME,
        "messages": [
            {"role": "user", "content": prompt}
        ]
    }

    response = requests.post(DEEPSEEK_URL, headers=headers, json=payload)
    result = response.json()
    return result["choices"][0]["message"]["content"]

# 新增：流式推理生成器
def stream_deepseek(prompt) -> Generator[str, None, None]:
    """Yield generated content chunks from DeepSeek API using SSE."""
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
    }
    payload = {
        "model": MODEL_NAME,
        "messages": [
            {"role": "user", "content": prompt}
        ],
        "stream": True,
        "max_tokens": 2048,
        "stream_options": {"include_usage": True},
    }

    # 使用 stream=True 觸發增量輸出
    response = requests.post(DEEPSEEK_URL, headers=headers, json=payload, stream=True)
    # iter_lines 將保持連接並逐行讀取
    for line in response.iter_lines(decode_unicode=True):
        if not line:
            continue
        # DeepSeek/SSE 行以 "data: " 開頭
        if line.startswith("data: "):
            data_str = line[6:]
            # 結束標誌
            if data_str.strip() == "[DONE]":
                break
            # 解析 JSON，獲取增量內容
            try:
                data_json = json.loads(data_str)
                # usage 塊 choices 為空，跳過
                choices = data_json.get("choices", [])
                if not choices:
                    continue
                delta = choices[0]["delta"].get("content", "")
                if delta:
                    yield delta
            except json.JSONDecodeError:
                # 忽略無法解析的片段
                continue

# 異步流式生成器
async def async_stream_deepseek(prompt):
    """異步生成器，從 DeepSeek API 生成內容（SSE）。"""
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
    }
    payload = {
        "model": MODEL_NAME,
        "messages": [
            {"role": "user", "content": prompt}
        ],
        "stream": True,
        "max_tokens": 2048,
        "stream_options": {"include_usage": True},
    }
    async with httpx.AsyncClient(timeout=None) as client:
        async with client.stream("POST", DEEPSEEK_URL, headers=headers, json=payload) as resp:
            async for line in resp.aiter_lines():
                if not line:
                    continue
                if line.startswith("data: "):
                    data_str = line[6:]
                    if data_str.strip() == "[DONE]":
                        break
                    try:
                        data_json = json.loads(data_str)
                        choices = data_json.get("choices", [])
                        if not choices:
                            continue
                        delta = choices[0]["delta"].get("content", "")
                        if delta:
                            yield delta
                    except json.JSONDecodeError:
                        continue

# -*- coding: utf-8 -*-
# test_pipeline.py
import requests
from deepseek_client import call_deepseek
import json
from requests.exceptions import ChunkedEncodingError

def test_diet_analysis():
    user_input = "中午吃了炸雞和奶茶，晚上吃了牛肉火鍋"

    # 調用 MCP
    mcp_resp = requests.post("http://localhost:8001/mcp", json={"input": user_input})
    mcp_data = mcp_resp.json()
    print("MCP 返回：", mcp_data)

    # 調用 DeepSeek
    reply = call_deepseek(mcp_data["routed_input"])
    print("DeepSeek 回覆：", reply)

def test_diet_plan():
    user_input = "我想要一個一週減肥計劃，主要食物包括香菇、雞胸肉和燕麥"
    mcp_resp = requests.post("http://localhost:8001/mcp", json={"input": user_input})
    mcp_data = mcp_resp.json()
    print("MCP 返回：", mcp_data)
    reply = call_deepseek(mcp_data["routed_input"])
    print("DeepSeek 回覆：", reply)

def test_effects_inquiry():
    user_input = "香菇吃多了會怎樣？"
    mcp_resp = requests.post("http://localhost:8001/mcp", json={"input": user_input})
    mcp_data = mcp_resp.json()
    print("MCP 返回：", mcp_data)
    reply = call_deepseek(mcp_data["routed_input"])
    print("DeepSeek 回覆：", reply)

def test_avoid_inquiry():
    user_input = "牛奶和蝦能一起吃嗎？"
    mcp_resp = requests.post("http://localhost:8001/mcp", json={"input": user_input})
    mcp_data = mcp_resp.json()
    print("MCP 返回：", mcp_data)
    reply = call_deepseek(mcp_data["routed_input"])
    print("DeepSeek 回覆：", reply)

def test_stream():
    user_input = "我晚上吃什麼比較好呢？ 中午吃了炸雞和奶茶"
    try:
        resp = requests.post(
            "http://localhost:8001/mcp_stream",
            json={"input": user_input},
            stream=True,
            timeout=None,
        )
        print("Stream start →", resp.status_code)
        meta_printed = False
        for line in resp.iter_lines(decode_unicode=True):
            if not line:
                continue
            # SSE: 可能含 event: xxx
            if line.startswith("event: "):
                current_event = line[7:]
                # 下一行應該是 data:
                continue
            if not line.startswith("data: "):
                continue
            data = line[6:]
            # current_event 默認為 token
            current_event = locals().get("current_event", "token")
            if current_event == "meta":
                try:
                    meta_obj = json.loads(data)
                    pretty_meta = json.dumps(meta_obj, ensure_ascii=False)
                    print("Meta:", pretty_meta)
                except json.JSONDecodeError:
                    print("Meta:", data)
                meta_printed = True
                print("\n--- AI 回覆 ---\n", end="")
                continue
            if current_event == "done":
                print("\n✅ Stream done")
                break
            # 其他 token 輸出
            print(data, end="", flush=True)
    except ChunkedEncodingError:
        # 服務器已發送完畢但提前關閉連接，可忽略
        print("\n⚠️ 連接提前關閉，已接收全部內容。")
    finally:
        try:
            resp.close()
        except Exception:
            pass

if __name__ == "__main__":
    # test_diet_analysis()
    # test_diet_plan()
    # test_effects_inquiry()
    # test_avoid_inquiry()
    test_stream()

# -*- coding: utf-8 -*-
# text_match.py
import jieba
import difflib
from typing import Iterable, List, Set, Tuple

def extract_food(
    user_text: str,
    food_vocab: Iterable[str],
    fuzzy_threshold: float = 0.8,
) -> Tuple[List[str], List[str], List[str]]:
    """根據用户輸入提取食物關鍵詞。

    1. 先使用 jieba 分詞命中精確詞。
    2. 對分詞結果做模糊匹配，解決同義詞/花式寫法。

    Args:
        user_text: 用户原始輸入字符串。
        food_vocab: 食物靜態數據庫的鍵集合。
        fuzzy_threshold: SequenceMatcher 相似度閾值 (0-1)。

    Returns:
        去重後的食物列表，按出現順序返回。
    """
    vocab_set: Set[str] = set(food_vocab)
    tokens = jieba.lcut(user_text, cut_all=False)
    hits: List[str] = []
    exact_hits: List[str] = []
    fuzzy_hits: List[str] = []
    added: Set[str] = set()

    for token in tokens:
        # 精確匹配
        if token in vocab_set and token not in added:
            hits.append(token)
            exact_hits.append(token)
            added.add(token)
            continue
        # 模糊匹配
        for food in vocab_set:
            if food in added:
                continue
            if difflib.SequenceMatcher(None, token, food).ratio() >= fuzzy_threshold:
                hits.append(food)
                fuzzy_hits.append(food)
                added.add(food)
                break
    return hits, exact_hits, fuzzy_hits

# 向後兼容的簡化接口
def extract_food_simple(user_text: str, food_vocab: Iterable[str], fuzzy_threshold: float = 0.8) -> List[str]:
    """返回僅 food list 的舊版接口，供其他模塊調用。"""
    return extract_food(user_text, food_vocab, fuzzy_threshold)[0]

{
  "炸雞": {
    "tags": ["高油脂", "高熱量"],
    "effects": "經常食用可能導致能量過剩、血脂升高",
    "avoid_with": ["啤酒"],
    "diet_type": ["增重期", "週末放縱"],
    "recipe_hint": "可使用空氣炸鍋，減少50%油脂攝入"
  },
  "奶茶": {
    "tags": ["高糖", "高熱量"],
    "effects": "過量攝入易導致胰島素抵抗、體重增加",
    "avoid_with": [],
    "diet_type": ["偶爾犒勞"],
    "recipe_hint": "選擇低糖或無糖版本，減少珍珠"
  },
  "可樂": {
    "tags": ["高糖"],
    "effects": "長期高糖飲料攝入可增加蛀牙及肥胖風險",
    "avoid_with": ["咖啡"],
    "diet_type": ["偶爾犒勞"],
    "recipe_hint": "選擇零度可樂或氣泡水替代"
  },
  "滷牛肉": {
    "tags": ["高鈉", "高蛋白"],
    "effects": "高鈉攝入可能升高血壓",
    "avoid_with": [],
    "diet_type": ["增肌期"],
    "recipe_hint": "配合蔬菜食用平衡營養"
  },
  "牛肉火鍋": {
    "tags": ["高油脂", "高鈉"],
    "effects": "高鹽高油易導致水腫",
    "avoid_with": ["冰啤酒"],
    "diet_type": ["增重期"],
    "recipe_hint": "控制湯底油脂和鹽分，搭配蔬菜"
  },
  "蔬菜湯": {
    "tags": ["低熱量", "健康推薦"],
    "effects": "一般安全",
    "avoid_with": [],
    "diet_type": ["減脂期", "日常維穩"],
    "recipe_hint": "少鹽少油"
  },
  "白灼蝦": {
    "tags": ["高蛋白", "健康推薦"],
    "effects": "嘌呤偏高，痛風患者需控制",
    "avoid_with": ["維生素C高的水果"],
    "diet_type": ["增肌期", "減脂期"],
    "recipe_hint": "控制蘸料用量"
  },
  "香菇": {
    "tags": ["高纖維", "低脂"],
    "effects": "過量可能導致脹氣",
    "avoid_with": ["寒性食物"],
    "diet_type": ["減脂期", "日常維穩"],
    "recipe_hint": "烹飪前泡發充分"
  },
  "燕麥": {
    "tags": ["高纖維", "低GI"],
    "effects": "攝入過多可能引起腹脹",
    "avoid_with": [],
    "diet_type": ["減脂期", "增肌期"],
    "recipe_hint": "配合蛋白質食物提高飽腹"
  },
  "糙米": {
    "tags": ["高纖維", "低GI"],
    "effects": "富含植酸，影響礦物質吸收，建議與其他穀物搭配",
    "avoid_with": [],
    "diet_type": ["減脂期", "日常維穩"],
    "recipe_hint": "提前浸泡12小時再煮"
  },
  "炸薯條": {
    "tags": ["高油脂", "高熱量"],
    "effects": "反式脂肪酸攝入風險",
    "avoid_with": ["汽水"],
    "diet_type": ["偶爾犒勞"],
    "recipe_hint": "可使用空氣炸鍋替代油炸"
  }  ,
  "牛油果": {
    "tags": ["高脂肪", "高纖維", "健康推薦"],
    "effects": "脂肪含量高，減脂期注意總熱量",
    "avoid_with": [],
    "diet_type": ["增肌期", "日常維穩"],
    "recipe_hint": "搭配全麥麪包或沙拉"
  },
  "酸奶": {
    "tags": ["高蛋白", "益生菌"],
    "effects": "乳糖不耐人羣可能腹脹",
    "avoid_with": ["高糖穀物"],
    "diet_type": ["減脂期", "增肌期", "日常維穩"],
    "recipe_hint": "選擇無糖或低糖版本"
  },
  "披薩": {
    "tags": ["高油脂", "高熱量"],
    "effects": "高鈉高脂，注意攝入頻次",
    "avoid_with": ["可樂"],
    "diet_type": ["週末放縱"],
    "recipe_hint": "選擇薄底、加多蔬菜版本"
  },
  "紅薯": {
    "tags": ["低GI", "高纖維", "健康推薦"],
    "effects": "過量可致腹脹",
    "avoid_with": [],
    "diet_type": ["減脂期", "日常維穩"],
    "recipe_hint": "蒸煮可保留營養"
  },
  "鮭魚": {
    "tags": ["高蛋白", "Omega-3"],
    "effects": "富含EPA/DHA，有助心血管健康",
    "avoid_with": ["富含草酸蔬菜"],
    "diet_type": ["增肌期", "日常維穩"],
    "recipe_hint": "推薦清蒸或空氣炸鍋"
  },
  "綠茶": {
    "tags": ["低熱量", "抗氧化"],
    "effects": "空腹或過量可致胃刺激",
    "avoid_with": ["牛奶"],
    "diet_type": ["減脂期", "日常維穩"],
    "recipe_hint": "餐後一小時飲用更佳"
  },
  "巧克力": {
    "tags": ["高糖", "高脂"],
    "effects": "攝入過多易長痘和增重",
    "avoid_with": [],
    "diet_type": ["偶爾犒勞"],
    "recipe_hint": "優選 70% 以上黑巧"
  },
  "能量飲料": {
    "tags": ["高糖", "咖啡因"],
    "effects": "過量可能導致心悸、睡眠障礙",
    "avoid_with": ["咖啡"],
    "diet_type": ["比賽備戰", "偶爾提神"],
    "recipe_hint": "控制每日總咖啡因 < 400mg"
  }
}

{
  "DEEPSEEK_API_KEY": "API Key",
  "DEEPSEEK_URL": "API地址",
  "MCP_PORT": 8001,
  "MODEL_NAME": "模型名稱"
}

fastapi
uvicorn
requests
httpx
jieba
cachetools
loguru

pip install -r requirements.txt -i https://mirrors.huaweicloud.com/repository/pypi/simple

uvicorn mcp_server:app --port 8001

python test_pipeline.py

{
    "model": "",
    "api_key": "",
    "base_url": "http://localhost:8001/mcp_stream",
    "system_prompt": ""
}

[dependencies]

[package]
  cjc-version = "0.53.13"
  compile-option = ""
  description = "nothing here"
  link-option = ""
  name = "food_bot"
  output-type = "executable"
  src-dir = ""
  target-dir = ""
  version = "1.0.0"
  package-configuration = {}

package food_bot
import std.console.Console
import std.collection.ArrayList

func cli_chat(env_info: EnvInfo, stream!: Bool) {
  println("\n歡迎使用智能膳食分析助手，輸入exit退出")
  var history: ArrayList<(String, String)> = ArrayList<(String, String)>()
  while (true) {
    print("Input: ")
    var prompt: String = ""
    match(Console.stdIn.readln()) {
      case Some(str1: String) => prompt=str1
      case None => continue
    }
    if (prompt == "exit" || prompt == "exit()") {
      break
    }
    if (prompt == "clear") {
      history.clear()
      println("Output: 已清理歷史對話信息。")
      continue
    }
    // 根據配置或命令行參數判斷是否啓用流式模式
    var use_stream: Bool = stream
    if (!use_stream && env_info.base_url.endsWith("/mcp_stream")) {
      use_stream = true
    }

    print("ChatBox: ")
    let response_option: Option<String> = if (use_stream) {
      stream_chat(prompt, env_info, history)
    } else {
      chat(prompt, env_info, history)
    }
    match (response_option) {
      case Some(response: String) => 
        println("${response}")
        history.append((prompt, response))
      case None =>
        println("發生錯誤，正在重試一次...")
        let retry_option = if (use_stream) {
          stream_chat(prompt, env_info, history)
        } else {
          chat(prompt, env_info, history)
        }
        match(retry_option) {
          case Some(resp2: String) =>
            println("${resp2}")
            history.append((prompt, resp2))
          case None =>
            println("重試失敗，即將退出")
            break
        }
    }
  }
}

main(args: Array<String>): Int64 {
  let env_info = load_env_info()
  var stream: Bool = false
  if (args.size == 1) {
    if (args[0] == "--stream") {
      stream = true
    } else {
      println("參數無效，僅支持 --stream 以開啓流式輸出")
    }
  }
  cli_chat(env_info, stream: stream)
  return 0
}

package food_bot
import encoding.json.stream.*
import std.fs.File
import std.fs.Path
import std.io.ByteArrayStream

public class EnvInfo <: JsonDeserializable<EnvInfo> & JsonSerializable {
  public let model: String          // 模型名稱
  public let api_key: String        // api密鑰
  public let base_url: String       // 調用接口路徑
  public let system_prompt: String  // 預置系統提示詞

  public init(model: String, api_key: String, base_url: String, system_prompt: String) {
    this.model = model
    this.api_key = api_key
    this.base_url = base_url
    this.system_prompt = system_prompt
  }
  
  public static func fromJson(r: JsonReader): EnvInfo {
    var temp_model: String = ""
    var temp_api_key: String = "sk-xxx"
    var temp_base_url: String = "http://xxx.xxx.xxx/v1"
    var temp_system_prompt: String = "You are a helpful assistant."
    while (let Some(v) <- r.peek()) {
      match(v) {
        case BeginObject =>
          r.startObject()
          while(r.peek() != EndObject) {
            let n = r.readName()
            match (n) {
                case "model" => temp_model = r.readValue<String>()
                case "api_key" => temp_api_key = r.readValue<String>()
                case "base_url" => temp_base_url = r.readValue<String>()
                case "system_prompt" => temp_system_prompt = r.readValue<String>()
                case _ => ()
            }
          }
          r.endObject()
          break
        case _ => throw Exception()
      }
    }
    return EnvInfo(temp_model, temp_api_key, temp_base_url, temp_system_prompt)
  }
  
  public func toJson(w: JsonWriter): Unit {
      w.startObject()
      w.writeName("model").writeValue(this.model)
      w.writeName("api_key").writeValue(this.api_key)
      w.writeName("base_url").writeValue(this.base_url)
      w.writeName("system_prompt").writeValue(this.system_prompt)
      w.endObject()
      w.flush()
  }
}

public func save_env_info(): Unit {
  // 該函數用於測試EnvInfo類的序列化為json的能力，順便生成一個env_sample.json樣本做為參考
  let env_path = Path("env_sample.json")
  if (File.exists(env_path)) {
    File.delete(env_path)
  }
  let file = File.create(env_path)
  let env_info = EnvInfo(
    "xxxx",
    "sk-xxxxxx",
    "http://xxx.xxx.xxx/v1/chat/completions",
    "You are a helpful assistant."
  )
  var byte_stream = ByteArrayStream()
  var json_writer = JsonWriter(byte_stream)
  let write_config = WriteConfig.pretty
  json_writer.writeConfig = write_config
  env_info.toJson(json_writer)
  file.write(byte_stream.readToEnd())
  println("`env_sample.json` save ok")
  file.close()
}

public func load_env_info(): EnvInfo {
  // 用於加載配置文件
  let env_path = Path("config.json")
  if (!File.exists(env_path)) {
    throw Exception("The config file not exists, please check again")
  }
  let file = File.openRead(env_path)
  let file_str: Array<UInt8> = file.readToEnd()
  var byte_stream = ByteArrayStream()
  byte_stream.write(file_str)
  let json_reader = JsonReader(byte_stream)
  let env_info: EnvInfo = EnvInfo.fromJson(json_reader)
  file.close()
  // println("model: ${env_info.model}")
  // println("api_key: ${env_info.api_key}")
  // println("base_url: ${env_info.base_url}")
  // println("system_prompt: ${env_info.system_prompt}")
  return env_info
}

package food_bot
import encoding.json.stream.*
import net.http.ClientBuilder
import net.http.HttpHeaders
import net.http.HttpRequestBuilder
import net.tls.TlsClientConfig
import net.tls.CertificateVerifyMode
import std.collection.ArrayList
import std.io.ByteArrayStream
import std.time.Duration
import std.unicode.UnicodeExtension  // for String.trim()

// ===== 可配置常量 =====
public let READ_TIMEOUT_SECONDS: Int64 = 300   // 長輪詢 SSE 建議 300 秒
// ===========================

public enum RoleType {
  User | Assistant | System
}

public func role_type_to_str(role: RoleType): Option<String> {
  return match(role) {
    case RoleType.User => Some("user")
    case RoleType.Assistant => Some("assistant")
    case RoleType.System => Some("system")
  }
}

public func str_to_role_type(role_option_str: Option<String>): RoleType {
  return match(role_option_str) {
    case Some(str) =>
      match(str) {
        case "user" => RoleType.User
        case "assistant" => RoleType.Assistant
        case "system" => RoleType.System
        case _ => RoleType.Assistant 
      }
    case None => RoleType.Assistant 
  }
}

public struct Message<: JsonDeserializable<Message> & JsonSerializable {
  public let role: RoleType
  public var content: String

  public init(role: RoleType, content: String) {
    this.role = role
    this.content = content
  }

  public static func fromJson(r: JsonReader): Message {
    var temp_role: Option<String> = None
    var temp_content: String = ""
    while (let Some(v) <- r.peek()) {
      match(v) {
        case BeginObject =>
          r.startObject()
          while(r.peek() != EndObject) {
            let n = r.readName()
            match(n) {
              case "role" => temp_role = r.readValue<Option<String>>()
              case "content" => temp_content = r.readValue<String>()
              case _ => r.skip()
            }
          }
          r.endObject()
          break
        case _ => throw Exception("can't deserialize for Message")
      }
    }
    let role_type: RoleType = str_to_role_type(temp_role)
    return Message(role_type, temp_content)
  }

  public func toJson(w: JsonWriter) {
    w.startObject()
    w.writeName("role").writeValue<Option<String>>(role_type_to_str(this.role))
    w.writeName("content").writeValue<String>(this.content)
    w.endObject()
    w.flush()
  }
}

public struct ChatRequest <: JsonSerializable {
  private let model: String
  private let messages: ArrayList<Message>
  private let max_tokens: Int64
  private let stream: Bool

  public init(
    model: String,
    messages: ArrayList<Message>,
    max_tokens: Int64,
    stream: Bool
  ) {
    // construction function with messages
    this.model = model
    this.messages = messages
    this.max_tokens = max_tokens
    this.stream = stream
  }

  public init(
    model: String,
    prompt: String,
    history: ArrayList<(String, String)>,
    system_prompt: String,
    max_tokens: Int64,
    stream: Bool
  ){
    // construction function with prompt and system_prompt
    this.model = model
    this.messages = ArrayList<Message>([
      Message(RoleType.System, system_prompt)
    ])
    for ((use_msg, bot_msg) in history) {
      this.messages.append(Message(RoleType.User, use_msg))
      this.messages.append(Message(RoleType.Assistant, bot_msg))
    }
    this.messages.append(Message(RoleType.User, prompt))
    this.max_tokens = max_tokens
    this.stream = stream
  }

  public init(
    model: String,
    prompt: String,
    history: ArrayList<(String, String)>,
    system_prompt: String,
    stream: Bool
  ){
    // construction function with prompt and default arguments
    this.model = model
    this.messages = ArrayList<Message>([
      Message(RoleType.System, system_prompt)
    ])
    for ((use_msg, bot_msg) in history) {
      this.messages.append(Message(RoleType.User, use_msg))
      this.messages.append(Message(RoleType.Assistant, bot_msg))
    }
    this.messages.append(Message(RoleType.User, prompt))
    this.max_tokens = 2000
    this.stream = stream
  }

  public func toJson(w: JsonWriter) {
    w.startObject()
    w.writeName("model").writeValue<String>(this.model)
    w.writeName("messages").writeValue<ArrayList<Message>>(this.messages)
    w.writeName("max_tokens").writeValue<Int64>(this.max_tokens)
    w.writeName("stream").writeValue<Bool>(this.stream)
    w.endObject()
    w.flush()
  }
}

public struct Choice <: JsonDeserializable<Choice> & JsonSerializable {
  public let index: Int32
  public let message: Option<Message>
  public let delta: Option<Message>
  public let finish_reason: Option<String>
  public let logprobs: Option<Float64> // dashscope for qwen need

  public init(
    index: Int32,
    message: Option<Message>,
    delta: Option<Message>,
    finish_reason: Option<String>,
    logprobs: Option<Float64>
  ) {
    this.index = index
    this.message = message
    this.delta = delta
    this.finish_reason = finish_reason
    this.logprobs = logprobs
  }

  public static func fromJson(r: JsonReader): Choice {
    var temp_index: Int32 = -1
    var temp_message: Option<Message> = None
    var temp_delta: Option<Message> = None
    var temp_finish_reason: Option<String> = None
    var temp_logprobs: Option<Float64> = None
    while (let Some(v) <- r.peek()) {
      match(v) {
        case BeginObject =>
          r.startObject()
          while(r.peek() != EndObject) {
              let n = r.readName()
              match (n) {
                  case "index" => temp_index = r.readValue<Int32>()
                  case "message" => temp_message = r.readValue<Option<Message>>()
                  case "delta" => temp_delta = r.readValue<Option<Message>>()
                  case "finish_reason" => temp_finish_reason = r.readValue<Option<String>>()
                  case "logprobs" => temp_logprobs = r.readValue<Option<Float64>>()
                  case _ => r.skip()
              }
          }
          r.endObject()
          break
        case _ => throw Exception("can't deserialize for Choice")
      }
    }
    return Choice(temp_index, temp_message, temp_delta, temp_finish_reason, temp_logprobs)
  }

  public func toJson(w: JsonWriter) {
    w.startObject()
    w.writeName("index").writeValue<Int32>(this.index)
    w.writeName("message").writeValue<Option<Message>>(this.message)
    w.writeName("delta").writeValue<Option<Message>>(this.delta)
    w.writeName("finish_reason").writeValue<Option<String>>(this.finish_reason)
    w.writeName("logprobs").writeValue<Option<Float64>>(this.logprobs)
    w.endObject()
    w.flush()
  }
}

public struct Usage <: JsonDeserializable<Usage> & JsonSerializable {
  public let prompt_tokens: UInt64
  public let completion_tokens: UInt64
  public let total_tokens: UInt64

  public init(prompt_tokens: UInt64, completion_tokens: UInt64, total_tokens: UInt64) {
    this.prompt_tokens = prompt_tokens
    this.completion_tokens = completion_tokens
    this.total_tokens = total_tokens
  }

  public static func fromJson(r: JsonReader): Usage {
    var temp_prompt_tokens: UInt64 = 0
    var temp_completion_tokens: UInt64 = 0
    var temp_total_tokens: UInt64 = 0
    while (let Some(v) <- r.peek()) {
      match(v) {
        case BeginObject =>
          r.startObject()
          while(r.peek() != EndObject) {
              let n = r.readName()
              match (n) {
                  case "prompt_tokens" => temp_prompt_tokens = r.readValue<UInt64>()
                  case "completion_tokens" => temp_completion_tokens = r.readValue<UInt64>()
                  case "total_tokens" => temp_total_tokens = r.readValue<UInt64>()
                  case _ => r.skip()
              }
          }
          r.endObject()
          break
        case _ => throw Exception("can't deserialize for Usage")
      }
    }
    return Usage(temp_prompt_tokens, temp_completion_tokens, temp_total_tokens)
  }

  public func toJson(w: JsonWriter) {
    w.startObject()
    w.writeName("prompt_tokens").writeValue<UInt64>(this.prompt_tokens)
    w.writeName("completion_tokens").writeValue<UInt64>(this.completion_tokens)
    w.writeName("total_tokens").writeValue<UInt64>(this.total_tokens)
    w.endObject()
    w.flush()
  }
}

public struct ChatResponse <: JsonDeserializable<ChatResponse> {
  // some api names `id`, and some names `request_id`
  public let id: Option<String>
  public let request_id: Option<String>
  public let system_fingerprint: Option<String>
  public let model: String
  public let object: String
  public let created: UInt64
  public let choices: ArrayList<Choice>
  public let usage: Option<Usage>

  public init(
    id: Option<String>,
    request_id: Option<String>,
    system_fingerprint: Option<String>,
    model: String,
    object: String,
    created: UInt64,
    choices: ArrayList<Choice>,
    usage: Option<Usage>
  ) {
    this.id = id
    this.request_id = request_id
    this.system_fingerprint = system_fingerprint
    this.model = model
    this.object = object
    this.created = created
    this.choices = choices
    this.usage = usage
  }

  public static func fromJson(r: JsonReader): ChatResponse {
    var temp_id: Option<String> = None
    var temp_request_id: Option<String> = None
    var temp_system_fingerprint: Option<String> = None
    var temp_model: String = ""
    var temp_object: String = ""
    var temp_created: UInt64 = 0
    var temp_choices: ArrayList<Choice> = ArrayList<Choice>([])
    var temp_usage: Option<Usage> = None
    while (let Some(v) <- r.peek()) {
      match(v) {
        case BeginObject =>
          r.startObject()
          while(r.peek() != EndObject) {
              let n = r.readName()
              match (n) {
                  case "id" => temp_id = r.readValue<Option<String>>()
                  case "request_id" => temp_request_id = r.readValue<Option<String>>()
                  case "system_fingerprint" => temp_system_fingerprint = r.readValue<Option<String>>()
                  case "model" => temp_model = r.readValue<String>()
                  case "object" => temp_object = r.readValue<String>()
                  case "created" => temp_created = r.readValue<UInt64>()
                  case "choices" => temp_choices = r.readValue<ArrayList<Choice>>()
                  case "usage" => temp_usage = r.readValue<Option<Usage>>()
                  case _ => r.skip()
              }
          }
          r.endObject()
          break
        case _ => throw Exception("can't deserialize for ChatResponse")
      }
    }
    return ChatResponse(
      temp_id,
      temp_request_id,
      temp_system_fingerprint,
      temp_model,
      temp_object,
      temp_created,
      temp_choices,
      temp_usage
    )
  }
}

public func get_domain(
  url: String
): String {
  var temp_url = url
  if (temp_url.startsWith("https://")) {
    temp_url = temp_url["https://".size..]
  } else if (temp_url.startsWith("http://")) {
    temp_url = temp_url["http://".size..]
  }
  let domain: String = temp_url.split("?")[0].split("/")[0]
  return domain
}

public func build_http_client(
  prompt: String,
  env_info: EnvInfo,
  history: ArrayList<(String, String)>,
  stream!: Bool
){
  // prepare input data
  // If we are targeting the custom `/mcp_stream` backend we must send
  // a very simple JSON body `{ "input": "<prompt>" }` instead of the
  // OpenAI-style `ChatRequest`. Detect this via URL suffix.
  let is_mcp_stream = env_info.base_url.endsWith("/mcp_stream")

  var post_data: Array<UInt8>
  if (is_mcp_stream) {
    var local_stream = ByteArrayStream()
    let local_writer = JsonWriter(local_stream)
    // { "input": "..." }
    local_writer.startObject()
    local_writer.writeName("input").writeValue(prompt)
    local_writer.endObject()
    local_writer.flush()
    post_data = local_stream.readToEnd()
  } else {
    var array_stream = ByteArrayStream()
    let json_writer = JsonWriter(array_stream)
    let chat_res = ChatRequest(
      env_info.model,
      prompt,
      history,
      env_info.system_prompt,
      stream
    )
    chat_res.toJson(json_writer)
    post_data = array_stream.readToEnd()
  }

  // build headers
  var headers: HttpHeaders = HttpHeaders()
  if (!is_mcp_stream) {
    // local backend doesn't require auth header
    headers.add("Authorization", "Bearer ${env_info.api_key}")
  }
  headers.add("Content-Type", "application/json")
  if (stream) {
    headers.add("Accept", "text/event-stream")
  }
  let request = HttpRequestBuilder()
    .url(env_info.base_url)
    .method("POST")
    .body(post_data)
    .readTimeout(Duration.second * READ_TIMEOUT_SECONDS)
    .addHeaders(headers)
    .build()
  let client = if (env_info.base_url.startsWith("https")) {
    var tls_client_config = TlsClientConfig()
    tls_client_config.verifyMode = CertificateVerifyMode.TrustAll
    tls_client_config.domain = get_domain(env_info.base_url)
    ClientBuilder()
      .tlsConfig(tls_client_config)
      .build()
  } else {
    ClientBuilder().build()
  }
  return (request, client)
}

public func chat(
  prompt: String,
  env_info: EnvInfo,
  history: ArrayList<(String, String)>
): Option<String> {
  let (request, client) = build_http_client(
    prompt,
    env_info,
    history,
    stream: false
  ) 
  var result_message: Option<String> = None
  var res_text = ""
  try {
    // call api
    let response = client.send(
      request
    )
    // read result (support max revice 100k data)
    let buffer = Array<Byte>(102400, item: 0)
    let length = response.body.read(buffer)
    res_text = String.fromUtf8(buffer[..length])
    // println("res_text: ${res_text}")
    var input_stream = ByteArrayStream()
    input_stream.write(res_text.toArray())
    // convert text to ChatResponse object
    let json_reader = JsonReader(input_stream)
    let res_object = ChatResponse.fromJson(json_reader)
    let choices: ArrayList<Choice> = res_object.choices
    if (choices.size > 0) {
      let message = choices[0].message.getOrThrow()
      // println("message: ${message.content}")
      result_message = Some(message.content)
      
    } else {
      println("can't found any response")
    }
  } catch (e: Exception) {
    println("ERROR: ${e.message}, reviced text is ${res_text}")
  }
  client.close()
  return result_message
}

public func stream_chat(
  prompt: String,
  env_info: EnvInfo,
  history: ArrayList<(String, String)>
): Option<String> {
  let (request, client) = build_http_client(
    prompt,
    env_info,
    history,
    stream: true
  ) 
  let is_mcp_stream = env_info.base_url.endsWith("/mcp_stream")
  var result_response: String = ""
  var temp_text2 = ""
  try {
    // call api
    let response = client.send(
      request
    )
    // read result
    let buffer = Array<Byte>(10240, item: 0)
    if (is_mcp_stream) {
      var done = false
      var current_event = ""
      while(!done) {
        let length = response.body.read(buffer)
        if (length == 0) {
          break
        }
        let res_text = String.fromUtf8(buffer[..length])
        for (line in res_text.split("\n")) {
          let trimmed = line.trim()
          if (trimmed.size == 0) {
            continue
          }
          if (trimmed.startsWith("event: ")) {
            current_event = trimmed["event: ".size..]
            continue
          }
          if (trimmed.startsWith("data: ")) {
            let data = trimmed["data: ".size..]
            if (current_event == "token") {
              // 累積 token，暫不直接打印
              result_response = result_response + data
            } else if (current_event == "ping") {
              // 服務器心跳，忽略即可
              ()
            } else if (current_event == "error") {
              println("服務器錯誤: ${data}")
              done = true
              result_response = ""  // force empty so caller sees None
              break
            } else if (current_event == "done") {
              done = true
              break
            }
          }
        }
        if (done) {
          break
        }
      }
    } else {
      var finish_reason: Option<String> = None
      while(finish_reason.isNone() && temp_text2 != "[DONE]") {
        let length = response.body.read(buffer)
        let res_text = String.fromUtf8(buffer[..length])

        for (temp_text in res_text.split("\n")) {
          temp_text2 =  if (temp_text.startsWith("data: ")) {
            temp_text["data: ".size..]
          } else {
            temp_text
          }
          if (temp_text2.size == 0) {
            continue
          }
          if (temp_text2 == "[DONE]") {
            break
          }
          var input_stream = ByteArrayStream()
          input_stream.write(temp_text2.toArray())
          // convert text to ChatResponse object
          let json_reader = JsonReader(input_stream)
          let res_object = ChatResponse.fromJson(json_reader)
          let choices: ArrayList<Choice> = res_object.choices
          if (choices.size > 0) {
            finish_reason = choices[0].finish_reason
            if (finish_reason.isNone()) {
              let delta = choices[0].delta.getOrThrow()
              result_response = result_response + delta.content 
            }
          } else {
            println("can't found any response")
          }
        }
      }
    }
  } catch (e: Exception) {
    println("ERROR: ${e.message}, reviced text is ${temp_text2}")
  }
  client.close()
  if (result_response.size > 0) {
    return Some(result_response)
  } else {
    return None
  }
}

cjpm run

["煎餅果子", "滷牛肉", "奶茶"]