dsh-plugin-image-workbench 0.0.0-stage → 1.1.6

package/vendor/chatgpt2api/source/services/protocol/error_response.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi.responses import JSONResponse
+
+
+def _message_from_value(value: object) -> str:
+    if isinstance(value, str):
+        return value
+    if not isinstance(value, dict):
+        return ""
+    message = value.get("message")
+    if isinstance(message, str) and message:
+        return message
+    return _message_from_value(value.get("error"))
+
+
+def error_message_from_detail(detail: object) -> str:
+    if isinstance(detail, list):
+        messages = []
+        for item in detail:
+            if not isinstance(item, dict):
+                continue
+            location = ".".join(str(part) for part in item.get("loc", []) if part != "body")
+            message = str(item.get("msg") or "").strip()
+            if location and message:
+                messages.append(f"{location}: {message}")
+            elif message:
+                messages.append(message)
+        return "; ".join(messages)
+    if isinstance(detail, dict):
+        message = _message_from_value(detail.get("error")) or _message_from_value(detail)
+        if message:
+            return message
+    return str(detail or "").strip()
+
+
+def _default_error_type(status_code: int) -> str:
+    if status_code == 401:
+        return "authentication_error"
+    if status_code == 403:
+        return "permission_error"
+    if status_code == 429:
+        return "rate_limit_error"
+    if 400 <= status_code < 500:
+        return "invalid_request_error"
+    return "server_error"
+
+
+def _default_error_code(status_code: int) -> str:
+    if status_code == 401:
+        return "invalid_api_key"
+    if status_code == 403:
+        return "permission_denied"
+    if status_code == 429:
+        return "rate_limit_exceeded"
+    if 400 <= status_code < 500:
+        return "bad_request"
+    return "upstream_error"
+
+
+def openai_error_payload(
+    detail: object,
+    status_code: int,
+    *,
+    error_type: str | None = None,
+    code: object | None = None,
+    param: object | None = None,
+) -> dict[str, Any]:
+    error_detail = detail.get("error") if isinstance(detail, dict) else None
+    if isinstance(error_detail, dict):
+        return {
+            "error": {
+                "message": error_message_from_detail(error_detail) or "request failed",
+                "type": str(error_detail.get("type") or error_type or _default_error_type(status_code)),
+                "param": error_detail.get("param", param),
+                "code": error_detail.get("code", code if code is not None else _default_error_code(status_code)),
+            }
+        }
+    return {
+        "error": {
+            "message": error_message_from_detail(detail) or "request failed",
+            "type": error_type or _default_error_type(status_code),
+            "param": param,
+            "code": code if code is not None else _default_error_code(status_code),
+        }
+    }
+
+
+def openai_error_response(
+    detail: object,
+    status_code: int,
+    *,
+    headers: dict[str, str] | None = None,
+    error_type: str | None = None,
+    code: object | None = None,
+    param: object | None = None,
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=status_code,
+        content=openai_error_payload(detail, status_code, error_type=error_type, code=code, param=param),
+        headers=headers,
+    )
+
+
+def anthropic_error_response(
+    detail: object,
+    status_code: int,
+    *,
+    headers: dict[str, str] | None = None,
+) -> JSONResponse:
+    error_type = "api_error" if status_code >= 500 else _default_error_type(status_code)
+    return JSONResponse(
+        status_code=status_code,
+        content={
+            "type": "error",
+            "error": {
+                "type": error_type,
+                "message": error_message_from_detail(detail) or "request failed",
+            },
+        },
+        headers=headers,
+    )

package/vendor/chatgpt2api/source/services/protocol/openai_search.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from services.account_service import account_service
+from services.openai_backend_api import OpenAIBackendAPI, SEARCH_MODEL
+
+MODEL = SEARCH_MODEL
+
+
+def handle(body: dict[str, object]) -> dict[str, object]:
+    token = account_service.get_text_access_token()
+    account = account_service.get_account(token) or {}
+    backend = OpenAIBackendAPI(token)
+    try:
+        result = backend.search(str(body["prompt"]))
+    finally:
+        backend.close()
+    account_service.mark_text_used(token)
+    result["_account_email"] = str(account.get("email") or "")
+    return result

package/vendor/chatgpt2api/source/services/protocol/openai_v1_chat_complete.py

@@ -0,0 +1,316 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any, Iterable, Iterator
+
+from fastapi import HTTPException
+
+from services.protocol.chat_completion_cache import cache_key, chat_completion_cache, normalize_text_messages
+from services.protocol.conversation import (
+    ConversationRequest,
+    ImageOutput,
+    collect_image_outputs,
+    collect_text,
+    count_message_image_tokens,
+    count_message_text_tokens,
+    count_text_tokens,
+    encode_images,
+    normalize_messages,
+    stream_image_outputs_with_pool,
+    stream_text_deltas,
+    text_backend,
+)
+from services.protocol.web_search_tool import (
+    WEB_SEARCH_TOOL_TYPES,
+    has_unsupported_tools,
+    is_web_search_chat_request,
+    run_web_search,
+    search_query_from_messages,
+    text_with_url_citations,
+)
+from utils.helper import build_chat_image_markdown_content, extract_chat_image, extract_chat_prompt, is_image_chat_request, parse_image_count
+from utils.image_tokens import (
+    chat_usage_from_image_usage,
+    count_image_inputs_tokens,
+    count_image_output_items_tokens,
+    image_usage,
+)
+
+TOOL_UNAVAILABLE_SYSTEM_MESSAGE = (
+    "This compatibility backend cannot execute local tools, shell commands, non-search tools, "
+    "or file operations. Do not claim to have run tools or inspected external resources. "
+    "If a user asks you to use a tool, say that tool execution is unavailable through this backend."
+)
+
+
+def normalize_thinking_effort(value: object) -> str:
+    normalized = str(value or "").strip().lower()
+    if normalized in {"", "none"}:
+        return ""
+    if normalized in {"low", "medium", "high"}:
+        return normalized
+    if normalized in {"xhigh", "extended"}:
+        return "extended"
+    return ""
+
+
+def thinking_effort_from_body(body: dict[str, Any]) -> str:
+    if "thinking_effort" in body:
+        return normalize_thinking_effort(body.get("thinking_effort"))
+    if "reasoning_effort" in body:
+        return normalize_thinking_effort(body.get("reasoning_effort"))
+    reasoning = body.get("reasoning")
+    if isinstance(reasoning, dict):
+        return normalize_thinking_effort(reasoning.get("effort"))
+    return ""
+
+
+def completion_chunk(model: str, delta: dict[str, Any], finish_reason: str | None = None, completion_id: str = "", created: int | None = None) -> dict[str, Any]:
+    return {
+        "id": completion_id or f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion.chunk",
+        "created": created or int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": delta, "finish_reason": finish_reason}],
+    }
+
+
+def completion_response(
+    model: str,
+    content: str,
+    created: int | None = None,
+    messages: list[dict[str, Any]] | None = None,
+    annotations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    prompt_text_tokens = count_message_text_tokens(messages, model) if messages else 0
+    prompt_image_tokens = count_message_image_tokens(messages, model) if messages else 0
+    prompt_tokens = prompt_text_tokens + prompt_image_tokens
+    completion_tokens = count_text_tokens(content, model) if messages else 0
+    message = {"role": "assistant", "content": content}
+    if annotations:
+        message["annotations"] = annotations
+    return {
+        "id": f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion",
+        "created": created or int(time.time()),
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": message,
+            "finish_reason": "stop",
+        }],
+        "usage": {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": prompt_tokens + completion_tokens,
+            "prompt_tokens_details": {
+                "text_tokens": prompt_text_tokens,
+                "image_tokens": prompt_image_tokens,
+                "cached_tokens": 0,
+            },
+            "completion_tokens_details": {
+                "text_tokens": completion_tokens,
+                "image_tokens": 0,
+                "reasoning_tokens": 0,
+            },
+        },
+    }
+
+
+def stream_text_chat_completion(
+    backend,
+    messages: list[dict[str, Any]],
+    model: str,
+    thinking_effort: str = "",
+) -> Iterator[dict[str, Any]]:
+    completion_id = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+    sent_role = False
+    request = ConversationRequest(model=model, messages=messages, thinking_effort=thinking_effort)
+    for delta_text in stream_text_deltas(backend, request):
+        if not sent_role:
+            sent_role = True
+            yield completion_chunk(model, {"role": "assistant", "content": delta_text}, None, completion_id, created)
+        else:
+            yield completion_chunk(model, {"content": delta_text}, None, completion_id, created)
+    if not sent_role:
+        yield completion_chunk(model, {"role": "assistant", "content": ""}, None, completion_id, created)
+    yield completion_chunk(model, {}, "stop", completion_id, created)
+
+
+def collect_chat_content(chunks: Iterable[dict[str, Any]]) -> str:
+    parts: list[str] = []
+    for chunk in chunks:
+        choices = chunk.get("choices")
+        first = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
+        delta = first.get("delta") if isinstance(first.get("delta"), dict) else {}
+        content = str(delta.get("content") or "")
+        if content:
+            parts.append(content)
+    return "".join(parts)
+
+
+def chat_messages_from_body(body: dict[str, Any]) -> list[dict[str, Any]]:
+    messages = body.get("messages")
+    if isinstance(messages, list) and messages:
+        return [message for message in messages if isinstance(message, dict)]
+    prompt = str(body.get("prompt") or "").strip()
+    if prompt:
+        return [{"role": "user", "content": prompt}]
+    raise HTTPException(status_code=400, detail={"error": "messages or prompt is required"})
+
+
+def chat_image_args(body: dict[str, Any]) -> tuple[str, str, int, list[tuple[bytes, str, str]]]:
+    model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
+    prompt = extract_chat_prompt(body)
+    if not prompt:
+        raise HTTPException(status_code=400, detail={"error": "prompt is required"})
+    images = [
+        (data, f"image_{idx}.png", mime)
+        for idx, (data, mime) in enumerate(extract_chat_image(body), start=1)
+    ]
+    return model, prompt, parse_image_count(body.get("n")), images
+
+
+def text_chat_parts(body: dict[str, Any]) -> tuple[str, list[dict[str, Any]]]:
+    model = str(body.get("model") or "auto").strip() or "auto"
+    messages = normalize_text_messages(normalize_messages(chat_messages_from_body(body)))
+    if has_unsupported_tools(body, WEB_SEARCH_TOOL_TYPES):
+        messages.insert(0, {"role": "system", "content": TOOL_UNAVAILABLE_SYSTEM_MESSAGE})
+    return model, messages
+
+
+def chat_completion_annotations(annotations: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    output = []
+    for item in annotations:
+        if item.get("type") != "url_citation":
+            continue
+        output.append({
+            "type": "url_citation",
+            "url_citation": {
+                "start_index": item.get("start_index", 0),
+                "end_index": item.get("end_index", 0),
+                "url": item.get("url", ""),
+                "title": item.get("title", ""),
+            },
+        })
+    return output
+
+
+def web_search_chat_response(messages: list[dict[str, Any]], model: str) -> dict[str, Any]:
+    query = search_query_from_messages(messages)
+    if not query:
+        raise HTTPException(status_code=400, detail={"error": "messages or prompt is required for web search"})
+    text, annotations = text_with_url_citations(run_web_search(query))
+    return completion_response(
+        model,
+        text,
+        messages=messages,
+        annotations=chat_completion_annotations(annotations),
+    )
+
+
+def stream_web_search_chat_completion(messages: list[dict[str, Any]], model: str) -> Iterator[dict[str, Any]]:
+    query = search_query_from_messages(messages)
+    if not query:
+        raise HTTPException(status_code=400, detail={"error": "messages or prompt is required for web search"})
+    text, _annotations = text_with_url_citations(run_web_search(query))
+    completion_id = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+    yield completion_chunk(model, {"role": "assistant", "content": text}, None, completion_id, created)
+    yield completion_chunk(model, {}, "stop", completion_id, created)
+
+
+def image_result_content(result: dict[str, Any]) -> str:
+    data = result.get("data")
+    if isinstance(data, list) and data:
+        return build_chat_image_markdown_content(result)
+    return str(result.get("message") or "Image generation completed.")
+
+
+def image_chat_response(body: dict[str, Any]) -> dict[str, Any]:
+    model, prompt, n, images = chat_image_args(body)
+    result = collect_image_outputs(stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        response_format="b64_json",
+        images=encode_images(images) or None,
+    )))
+    response = completion_response(model, image_result_content(result), int(result.get("created") or 0) or None)
+    usage = image_usage(
+        input_text_tokens=count_text_tokens(prompt, model),
+        input_image_tokens=count_image_inputs_tokens(images, model),
+        output_tokens=count_image_output_items_tokens(result.get("data")),
+    )
+    response["usage"] = chat_usage_from_image_usage(usage)
+    return response
+
+
+def image_chat_events(body: dict[str, Any]) -> Iterator[dict[str, Any]]:
+    model, prompt, n, images = chat_image_args(body)
+    image_outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        response_format="b64_json",
+        images=encode_images(images) or None,
+    ))
+    yield from stream_image_chat_completion(image_outputs, model)
+
+
+def stream_image_chat_completion(image_outputs: Iterable[ImageOutput], model: str) -> Iterator[dict[str, Any]]:
+    completion_id = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+    sent_role = False
+    sent_text = ""
+    for output in image_outputs:
+        content = ""
+        if output.kind == "progress":
+            content = output.text
+            sent_text += content
+        elif output.kind == "result":
+            content = build_chat_image_markdown_content({"data": output.data})
+        elif output.kind == "message":
+            content = output.text[len(sent_text):] if output.text.startswith(sent_text) else output.text
+        if not content:
+            continue
+        if not sent_role:
+            sent_role = True
+            yield completion_chunk(model, {"role": "assistant", "content": content}, None, completion_id, created)
+        else:
+            yield completion_chunk(model, {"content": content}, None, completion_id, created)
+    if not sent_role:
+        yield completion_chunk(model, {"role": "assistant", "content": ""}, None, completion_id, created)
+    yield completion_chunk(model, {}, "stop", completion_id, created)
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    if body.get("stream"):
+        if is_image_chat_request(body):
+            return image_chat_events(body)
+        model, messages = text_chat_parts(body)
+        if is_web_search_chat_request(body) and not has_unsupported_tools(body, WEB_SEARCH_TOOL_TYPES):
+            return stream_web_search_chat_completion(messages, model)
+        thinking_effort = thinking_effort_from_body(body)
+        key = cache_key(body, messages, stream=True)
+        return chat_completion_cache.get_or_compute_stream(
+            key,
+            lambda: stream_text_chat_completion(text_backend(model), messages, model, thinking_effort),
+        )
+    if is_image_chat_request(body):
+        return image_chat_response(body)
+    model, messages = text_chat_parts(body)
+    if is_web_search_chat_request(body) and not has_unsupported_tools(body, WEB_SEARCH_TOOL_TYPES):
+        return web_search_chat_response(messages, model)
+    thinking_effort = thinking_effort_from_body(body)
+    key = cache_key(body, messages, stream=False)
+    return chat_completion_cache.get_or_compute_response(
+        key,
+        lambda: completion_response(
+            model,
+            collect_text(text_backend(model), ConversationRequest(model=model, messages=messages, thinking_effort=thinking_effort)),
+            messages=messages,
+        ),
+    )

package/vendor/chatgpt2api/source/services/protocol/openai_v1_image_edit.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Any, Iterator
+
+from PIL import Image
+
+from services.protocol.conversation import (
+    ConversationRequest,
+    ImageGenerationError,
+    collect_image_outputs,
+    count_text_tokens,
+    encode_images,
+    stream_image_chunks,
+    stream_image_outputs_with_pool,
+)
+from utils.image_tokens import count_image_inputs_tokens, count_image_output_items_tokens, image_usage
+
+
+def _composite_mask(
+    images: list[tuple[bytes, str, str]],
+    masks: list[tuple[bytes, str, str]],
+) -> list[tuple[bytes, str, str]]:
+    """将 mask 的 alpha 通道合成到图片中，标识需要编辑的区域。
+    
+    mask 的透明区域（低 alpha）= 需要编辑的区域，
+    mask 的不透明区域（高 alpha）= 保留的区域。
+    如果无 mask 则返回原图。
+    """
+    if not masks:
+        return images
+    result: list[tuple[bytes, str, str]] = []
+    for i, (data, filename, mime_type) in enumerate(images):
+        mask_data = masks[i][0] if i < len(masks) else masks[-1][0]
+        img = Image.open(BytesIO(data)).convert("RGBA")
+        mask_img = Image.open(BytesIO(mask_data))
+        if mask_img.mode == "RGBA":
+            alpha = mask_img.split()[3]
+        elif mask_img.mode == "L":
+            alpha = mask_img
+        else:
+            alpha = mask_img.convert("L")
+        alpha = alpha.resize(img.size, Image.LANCZOS)
+        img.putalpha(alpha)
+        buf = BytesIO()
+        img.save(buf, format="PNG")
+        result.append((buf.getvalue(), filename, "image/png"))
+    return result
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    prompt = str(body.get("prompt") or "")
+    images = body.get("images") or []
+    masks = body.get("mask") or []
+    images = _composite_mask(images, masks)
+    model = str(body.get("model") or "gpt-image-2")
+    n = int(body.get("n") or 1)
+    size = body.get("size")
+    quality = str(body.get("quality") or "auto")
+    response_format = str(body.get("response_format") or "b64_json")
+    base_url = str(body.get("base_url") or "") or None
+    progress_callback = body.get("progress_callback")
+    encoded_images = encode_images(images)
+    if not encoded_images:
+        raise ImageGenerationError("image is required")
+    outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        size=size,
+        quality=quality,
+        response_format=response_format,
+        base_url=base_url,
+        images=encoded_images,
+        message_as_error=True,
+        progress_callback=progress_callback,
+    ))
+    if body.get("stream"):
+        return stream_image_chunks(outputs)
+    result = collect_image_outputs(outputs)
+    result["usage"] = image_usage(
+        input_text_tokens=count_text_tokens(prompt, model),
+        input_image_tokens=count_image_inputs_tokens(images, model),
+        output_tokens=count_image_output_items_tokens(result.get("data"), size, quality),
+    )
+    return result

package/vendor/chatgpt2api/source/services/protocol/openai_v1_image_generations.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+from services.protocol.conversation import (
+    ConversationRequest,
+    collect_image_outputs,
+    count_text_tokens,
+    stream_image_chunks,
+    stream_image_outputs_with_pool,
+)
+from utils.image_tokens import count_image_output_items_tokens, image_usage
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    prompt = str(body.get("prompt") or "")
+    model = str(body.get("model") or "gpt-image-2")
+    n = int(body.get("n") or 1)
+    size = body.get("size")
+    quality = str(body.get("quality") or "auto")
+    response_format = str(body.get("response_format") or "b64_json")
+    base_url = str(body.get("base_url") or "") or None
+    progress_callback = body.get("progress_callback")
+    outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        size=size,
+        quality=quality,
+        response_format=response_format,
+        base_url=base_url,
+        message_as_error=True,
+        progress_callback=progress_callback,
+    ))
+    if body.get("stream"):
+        return stream_image_chunks(outputs)
+    result = collect_image_outputs(outputs)
+    result["usage"] = image_usage(
+        input_text_tokens=count_text_tokens(prompt, model),
+        output_tokens=count_image_output_items_tokens(result.get("data"), size, quality),
+    )
+    return result

package/vendor/chatgpt2api/source/services/protocol/openai_v1_models.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+from services.account_service import account_service
+from services.model_service import model_catalog_service
+from utils.helper import CODEX_IMAGE_MODEL
+
+
+def list_models() -> dict[str, Any]:
+    result = model_catalog_service.list_models()
+    data = result.get("data")
+    if not isinstance(data, list):
+        return result
+    seen = {str(item.get("id") or "").strip() for item in data if isinstance(item, dict)}
+    dynamic_models: set[str] = set()
+    accounts = account_service.list_accounts()
+    web_image_accounts = [
+        account
+        for account in accounts
+        if isinstance(account, dict)
+    ]
+    codex_types = {
+        normalized
+        for account in accounts
+        if isinstance(account, dict)
+           and account_service._normalize_source_type(account.get("source_type")) == "codex"
+           and (normalized := account_service._normalize_account_type(account.get("type")))
+    }
+
+    if web_image_accounts:
+        dynamic_models.add("gpt-image-2")
+    if codex_types & {"Plus", "Team", "Pro"}:
+        dynamic_models.add(CODEX_IMAGE_MODEL)
+    if "Plus" in codex_types:
+        dynamic_models.add(f"plus-{CODEX_IMAGE_MODEL}")
+    if "Team" in codex_types:
+        dynamic_models.add(f"team-{CODEX_IMAGE_MODEL}")
+    if "Pro" in codex_types:
+        dynamic_models.add(f"pro-{CODEX_IMAGE_MODEL}")
+
+    for model in sorted(dynamic_models):
+        if model not in seen:
+            data.append({
+                "id": model,
+                "object": "model",
+                "created": 0,
+                "owned_by": "chatgpt2api",
+                "permission": [],
+                "root": model,
+                "parent": None,
+            })
+    return result