Vovanda · July 5, 2025 23:49
diff --git a/Readme.md b/Readme.md
diff --git a/openwebui_filter_proxy.py b/openwebui_filter_proxy.py
 import os
 import json
 import logging
 import re
 from urllib.parse import urljoin

 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import StreamingResponse, JSONResponse
 import httpx
 from dotenv import load_dotenv

 # --- Конфигурация ---
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)

 load_dotenv()

 app = FastAPI()

 OPENWEBUI_URL = os.getenv("OPENWEBUI_URL", "https://chat.sawking.tech")
 API_KEY = os.getenv("OPENWEBUI_API_KEY", "your_api_key_here")
 TIMEOUT = 30.0

 ZED_SYSTEM_PROMPT_FILE = os.getenv("ZED_SYSTEM_PROMPT_FILE")
 #replace или disable, или default
 ZED_SYSTEM_PROMPT_MODE = os.getenv("ZED_SYSTEM_PROMPT_MODE", "default").lower()

 def override_system_messages(messages: list[dict]) -> list[dict]:
    ZED_SYSTEM_PROMPT = None
    if ZED_SYSTEM_PROMPT_FILE and os.path.exists(ZED_SYSTEM_PROMPT_FILE):
        with open(ZED_SYSTEM_PROMPT_FILE, encoding="utf-8") as f:
            ZED_SYSTEM_PROMPT = f.read().strip()

    if ZED_SYSTEM_PROMPT_MODE == "disable":
        # Удалить все system-сообщения, ничего не добавлять
        return [m for m in messages if m.get("role") != "system"]

    if ZED_SYSTEM_PROMPT_MODE == "replace" and ZED_SYSTEM_PROMPT:
        # Удалить все system и вставить один кастомный
        messages = [m for m in messages if m.get("role") != "system"]
        messages.insert(0, {"role": "system", "content": ZED_SYSTEM_PROMPT})
        return messages

    # default — не трогаем системный промт
    return messages

 @app.api_route("/v1/{path:path}", methods=["GET", "POST", "PUT", "DELETE"])
 async def proxy_all(request: Request, path: str):
    if path == "chat/completions":
        return await openai_proxy(request)

    target_url = urljoin(f"{OPENWEBUI_URL}/", path)
    try:
        request_body = None
        if request.method in ["POST", "PUT"]:
            try:
                request_body = await request.json()
            except json.JSONDecodeError:
                request_body = None

        async with httpx.AsyncClient(timeout=TIMEOUT) as client:
            response = await client.request(
                method=request.method,
                url=target_url,
                headers={
                    "Authorization": f"Bearer {API_KEY}",
                    "Content-Type": "application/json",
                },
                json=request_body,
                params=dict(request.query_params),
            )

        filtered_headers = {
            k: v for k, v in response.headers.items()
            if k.lower() not in ["content-encoding", "content-length", "transfer-encoding", "connection"]
        }

        return JSONResponse(
            content=response.json(),
            status_code=response.status_code,
            headers=filtered_headers,
        )

    except httpx.ReadTimeout:
        logger.error("Таймаут при обращении к Open WebUI")
        raise HTTPException(status_code=504, detail="Таймаут соединения с Open WebUI")
    except Exception as e:
        logger.error(f"Ошибка проксирования: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

 @app.post("/v1/chat/completions")
 async def openai_proxy(request: Request):
    body = await request.json()

    original_messages = body.get("messages", [])
    modified_messages = override_system_messages(original_messages)

    if modified_messages != original_messages:
        body["messages"] = modified_messages
        logger.info(f"Тело запроса изменено: {json.dumps(body, ensure_ascii=False)}")
    else:
        logger.info(f"Тело запроса без изменений: {json.dumps(body, ensure_ascii=False)}")

    logger.info(f"Обработка chat/completions для модели: {body.get('model')}")

    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
        "Accept": "text/event-stream" if body.get("stream") else "application/json",
    }

    if body.get("stream"):
        return StreamingResponse(event_generator(body, headers), media_type="text/event-stream")
    else:
        return await get_json_response(body, headers)

 async def get_json_response(body: dict, headers: dict):
    async with httpx.AsyncClient(timeout=TIMEOUT) as client:
        response = await client.post(f"{OPENWEBUI_URL}/api/chat/completions", json=body, headers=headers)

    if response.status_code != 200:
        detail = response.json().get("detail", "Open WebUI error")
        logger.error(f"Open WebUI error: {detail}")
        raise HTTPException(status_code=response.status_code, detail=detail)

    data = response.json()
    return {
        "id": data.get("id"),
        "object": "chat.completion",
        "created": data.get("created"),
        "choices": [{
            "index": 0,
            "message": data["choices"][0]["message"],
            "finish_reason": "stop"
        }]
    }


 async def event_generator(body: dict, headers: dict):
    max_log_chunk = 200
    try:
        async with httpx.AsyncClient(timeout=TIMEOUT) as client:
            async with client.stream("POST", f"{OPENWEBUI_URL}/api/chat/completions", json=body, headers=headers) as response:
                if response.status_code != 200:
                    text = await response.aread()
                    logger.error(f"OpenWebUI error: {text.decode()}")
                    yield f"data: {{\"error\": \"{text.decode()}\"}}\n\n"
                    return

                async for line in response.aiter_lines():
                    try:
                        if not line.strip():
                            continue

                        if line.startswith("data: "):
                            json_str = line[len("data: "):].strip()
                            try:
                                data = json.loads(json_str)
                                if "sources" in data:
                                    snippet = json_str[:max_log_chunk].replace("\n", " ")
                                    logger.info(f"Пропущен чанк с 'sources': {snippet}...")
                                    continue
                            except json.JSONDecodeError:
                                pass

                        logger.info(line)
                        yield f"{line}\n"

                    except Exception as inner_e:
                        logger.error(f"Ошибка при обработке строки стрима: {inner_e}")
                        # Не прерываем генератор, чтобы попытаться продолжить стрим
                        continue

    except Exception as e:
        logger.error(f"Ошибка стриминга: {e}")
        yield f"data: {{\"error\": \"Internal server error\"}}\n\n"


 if __name__ == "__main__":
    import uvicorn
    uvicorn.run("openAI_adapter:app", host="127.0.0.1", port=5000, log_level="info")
	import os
	import json
	import logging
	import re
	from urllib.parse import urljoin

	from fastapi import FastAPI, Request, HTTPException
	from fastapi.responses import StreamingResponse, JSONResponse
	import httpx
	from dotenv import load_dotenv

	# --- Конфигурация ---
	logging.basicConfig(level=logging.INFO)
	logger = logging.getLogger(__name__)

	load_dotenv()

	app = FastAPI()

	OPENWEBUI_URL = os.getenv("OPENWEBUI_URL", "https://chat.sawking.tech")
	API_KEY = os.getenv("OPENWEBUI_API_KEY", "your_api_key_here")
	TIMEOUT = 30.0

	ZED_SYSTEM_PROMPT_FILE = os.getenv("ZED_SYSTEM_PROMPT_FILE")
	#replace или disable, или default
	ZED_SYSTEM_PROMPT_MODE = os.getenv("ZED_SYSTEM_PROMPT_MODE", "default").lower()

	def override_system_messages(messages: list[dict]) -> list[dict]:
	ZED_SYSTEM_PROMPT = None
	if ZED_SYSTEM_PROMPT_FILE and os.path.exists(ZED_SYSTEM_PROMPT_FILE):
	with open(ZED_SYSTEM_PROMPT_FILE, encoding="utf-8") as f:
	ZED_SYSTEM_PROMPT = f.read().strip()

	if ZED_SYSTEM_PROMPT_MODE == "disable":
	# Удалить все system-сообщения, ничего не добавлять
	return [m for m in messages if m.get("role") != "system"]

	if ZED_SYSTEM_PROMPT_MODE == "replace" and ZED_SYSTEM_PROMPT:
	# Удалить все system и вставить один кастомный
	messages = [m for m in messages if m.get("role") != "system"]
	messages.insert(0, {"role": "system", "content": ZED_SYSTEM_PROMPT})
	return messages

	# default — не трогаем системный промт
	return messages

	@app.api_route("/v1/{path:path}", methods=["GET", "POST", "PUT", "DELETE"])
	async def proxy_all(request: Request, path: str):
	if path == "chat/completions":
	return await openai_proxy(request)

	target_url = urljoin(f"{OPENWEBUI_URL}/", path)
	try:
	request_body = None
	if request.method in ["POST", "PUT"]:
	try:
	request_body = await request.json()
	except json.JSONDecodeError:
	request_body = None

	async with httpx.AsyncClient(timeout=TIMEOUT) as client:
	response = await client.request(
	method=request.method,
	url=target_url,
	headers={
	"Authorization": f"Bearer {API_KEY}",
	"Content-Type": "application/json",
	},
	json=request_body,
	params=dict(request.query_params),
	)

	filtered_headers = {
	k: v for k, v in response.headers.items()
	if k.lower() not in ["content-encoding", "content-length", "transfer-encoding", "connection"]
	}

	return JSONResponse(
	content=response.json(),
	status_code=response.status_code,
	headers=filtered_headers,
	)

	except httpx.ReadTimeout:
	logger.error("Таймаут при обращении к Open WebUI")
	raise HTTPException(status_code=504, detail="Таймаут соединения с Open WebUI")
	except Exception as e:
	logger.error(f"Ошибка проксирования: {str(e)}")
	raise HTTPException(status_code=500, detail=str(e))

	@app.post("/v1/chat/completions")
	async def openai_proxy(request: Request):
	body = await request.json()

	original_messages = body.get("messages", [])
	modified_messages = override_system_messages(original_messages)

	if modified_messages != original_messages:
	body["messages"] = modified_messages
	logger.info(f"Тело запроса изменено: {json.dumps(body, ensure_ascii=False)}")
	else:
	logger.info(f"Тело запроса без изменений: {json.dumps(body, ensure_ascii=False)}")

	logger.info(f"Обработка chat/completions для модели: {body.get('model')}")

	headers = {
	"Authorization": f"Bearer {API_KEY}",
	"Content-Type": "application/json",
	"Accept": "text/event-stream" if body.get("stream") else "application/json",
	}

	if body.get("stream"):
	return StreamingResponse(event_generator(body, headers), media_type="text/event-stream")
	else:
	return await get_json_response(body, headers)

	async def get_json_response(body: dict, headers: dict):
	async with httpx.AsyncClient(timeout=TIMEOUT) as client:
	response = await client.post(f"{OPENWEBUI_URL}/api/chat/completions", json=body, headers=headers)

	if response.status_code != 200:
	detail = response.json().get("detail", "Open WebUI error")
	logger.error(f"Open WebUI error: {detail}")
	raise HTTPException(status_code=response.status_code, detail=detail)

	data = response.json()
	return {
	"id": data.get("id"),
	"object": "chat.completion",
	"created": data.get("created"),
	"choices": [{
	"index": 0,
	"message": data["choices"][0]["message"],
	"finish_reason": "stop"
	}]
	}


	async def event_generator(body: dict, headers: dict):
	max_log_chunk = 200
	try:
	async with httpx.AsyncClient(timeout=TIMEOUT) as client:
	async with client.stream("POST", f"{OPENWEBUI_URL}/api/chat/completions", json=body, headers=headers) as response:
	if response.status_code != 200:
	text = await response.aread()
	logger.error(f"OpenWebUI error: {text.decode()}")
	yield f"data: {{\"error\": \"{text.decode()}\"}}\n\n"
	return

	async for line in response.aiter_lines():
	try:
	if not line.strip():
	continue

	if line.startswith("data: "):
	json_str = line[len("data: "):].strip()
	try:
	data = json.loads(json_str)
	if "sources" in data:
	snippet = json_str[:max_log_chunk].replace("\n", " ")
	logger.info(f"Пропущен чанк с 'sources': {snippet}...")
	continue
	except json.JSONDecodeError:
	pass

	logger.info(line)
	yield f"{line}\n"

	except Exception as inner_e:
	logger.error(f"Ошибка при обработке строки стрима: {inner_e}")
	# Не прерываем генератор, чтобы попытаться продолжить стрим
	continue

	except Exception as e:
	logger.error(f"Ошибка стриминга: {e}")
	yield f"data: {{\"error\": \"Internal server error\"}}\n\n"


	if __name__ == "__main__":
	import uvicorn
	uvicorn.run("openAI_adapter:app", host="127.0.0.1", port=5000, log_level="info")
No results found