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

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

@@ -0,0 +1,453 @@
+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,
+    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,
+    has_web_search_tool,
+    normalized_sources,
+    run_web_search,
+    search_query_from_messages,
+    text_with_url_citations,
+)
+from utils.helper import extract_image_from_message_content, extract_response_prompt, has_response_image_generation_tool
+from utils.image_tokens import (
+    count_image_content_tokens,
+    count_image_output_items_tokens,
+    image_usage,
+    token_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."
+)
+
+RESPONSE_CONTENT_PART_TYPES = {"text", "input_text", "output_text", "image_url", "input_image", "image"}
+
+
+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:
+    reasoning = body.get("reasoning")
+    if isinstance(reasoning, dict):
+        return normalize_thinking_effort(reasoning.get("effort"))
+    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"))
+    return ""
+
+
+def is_text_response_request(body: dict[str, Any]) -> bool:
+    return not has_response_image_generation_tool(body)
+
+
+def has_unsupported_response_tools(body: dict[str, Any]) -> bool:
+    return has_unsupported_tools(body, {"image_generation", *WEB_SEARCH_TOOL_TYPES})
+
+
+def response_image_tool(body: dict[str, Any]) -> dict[str, object]:
+    for tool in body.get("tools") or []:
+        if isinstance(tool, dict) and tool.get("type") == "image_generation":
+            return tool
+    return {}
+
+
+def extract_response_image(input_value: object) -> tuple[bytes, str] | None:
+    if isinstance(input_value, dict):
+        if str(input_value.get("type") or "").strip() == "input_image":
+            images = extract_image_from_message_content([input_value])
+            return images[0] if images else None
+        images = extract_image_from_message_content(input_value.get("content"))
+        return images[0] if images else None
+    if not isinstance(input_value, list):
+        return None
+    for item in reversed(input_value):
+        if isinstance(item, dict):
+            if str(item.get("type") or "").strip() == "input_image":
+                images = extract_image_from_message_content([item])
+                if images:
+                    return images[0]
+            images = extract_image_from_message_content(item.get("content"))
+            if images:
+                return images[0]
+    return None
+
+
+def _input_image_parts(input_value: object) -> list[dict[str, Any]]:
+    parts: list[dict[str, Any]] = []
+    if isinstance(input_value, dict):
+        content = input_value.get("content")
+        if isinstance(content, list):
+            parts.extend(item for item in content if isinstance(item, dict))
+        return parts
+    if not isinstance(input_value, list):
+        return parts
+    if all(isinstance(item, dict) and item.get("type") for item in input_value):
+        return [item for item in input_value if isinstance(item, dict)]
+    for item in input_value:
+        if isinstance(item, dict):
+            content = item.get("content")
+            if isinstance(content, list):
+                parts.extend(part for part in content if isinstance(part, dict))
+    return parts
+
+
+def _is_response_content_part(value: object) -> bool:
+    if not isinstance(value, dict):
+        return False
+    part_type = str(value.get("type") or "").strip()
+    return part_type in RESPONSE_CONTENT_PART_TYPES or ("image_url" in value and part_type != "message")
+
+
+def _message_content_from_response_item(item: dict[str, Any]) -> object:
+    content = item.get("content")
+    if isinstance(content, list):
+        return [dict(part) if isinstance(part, dict) else part for part in content]
+    if isinstance(content, str):
+        return content
+    return extract_response_prompt([item]) or content or ""
+
+
+def _append_response_message(messages: list[dict[str, Any]], role: object, content: object) -> None:
+    if isinstance(content, str):
+        if content.strip():
+            messages.append({"role": str(role or "user"), "content": content.strip()})
+        return
+    if isinstance(content, list) and content:
+        messages.append({"role": str(role or "user"), "content": content})
+
+
+def messages_from_input(input_value: object, instructions: object = None) -> list[dict[str, Any]]:
+    messages: list[dict[str, Any]] = []
+    system_text = str(instructions or "").strip()
+    if system_text:
+        messages.append({"role": "system", "content": system_text})
+    if isinstance(input_value, str):
+        if input_value.strip():
+            messages.append({"role": "user", "content": input_value.strip()})
+        return messages
+    if isinstance(input_value, dict):
+        if _is_response_content_part(input_value):
+            _append_response_message(messages, "user", [dict(input_value)])
+            return messages
+        _append_response_message(
+            messages,
+            input_value.get("role") or "user",
+            _message_content_from_response_item(input_value),
+        )
+        return messages
+    if isinstance(input_value, list):
+        if all(_is_response_content_part(item) for item in input_value):
+            _append_response_message(messages, "user", [dict(item) for item in input_value if isinstance(item, dict)])
+            return messages
+        pending_parts: list[dict[str, Any]] = []
+        for item in input_value:
+            if _is_response_content_part(item):
+                pending_parts.append(dict(item))
+                continue
+            if pending_parts:
+                _append_response_message(messages, "user", pending_parts)
+                pending_parts = []
+            if not isinstance(item, dict):
+                continue
+            _append_response_message(
+                messages,
+                item.get("role") or "user",
+                _message_content_from_response_item(item),
+            )
+        if pending_parts:
+            _append_response_message(messages, "user", pending_parts)
+    return messages
+
+
+def text_output_item(
+    text: str,
+    item_id: str | None = None,
+    status: str = "completed",
+    annotations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    return {
+        "id": item_id or f"msg_{uuid.uuid4().hex}",
+        "type": "message",
+        "status": status,
+        "role": "assistant",
+        "content": [{"type": "output_text", "text": text, "annotations": annotations or []}],
+    }
+
+
+def web_search_call_item(
+    query: str,
+    item_id: str | None = None,
+    status: str = "completed",
+    sources: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
+    action: dict[str, Any] = {
+        "type": "search",
+        "query": query,
+        "queries": [query],
+    }
+    if sources:
+        action["sources"] = [
+            {"type": "url", "url": source["url"]}
+            for source in sources
+            if source.get("url")
+        ]
+    return {
+        "id": item_id or f"ws_{uuid.uuid4().hex}",
+        "type": "web_search_call",
+        "status": status,
+        "action": action,
+    }
+
+
+def image_output_items(prompt: str, data: list[dict[str, Any]], item_id: str | None = None) -> list[dict[str, Any]]:
+    output = []
+    for item in data:
+        b64_json = str(item.get("b64_json") or "").strip()
+        if b64_json:
+            output.append({
+                "id": item_id or f"ig_{len(output) + 1}",
+                "type": "image_generation_call",
+                "status": "completed",
+                "result": b64_json,
+                "revised_prompt": str(item.get("revised_prompt") or prompt).strip() or prompt,
+            })
+    return output
+
+
+def response_created(response_id: str, model: str, created: int) -> dict[str, Any]:
+    return {
+        "type": "response.created",
+        "response": {
+            "id": response_id,
+            "object": "response",
+            "created_at": created,
+            "status": "in_progress",
+            "error": None,
+            "incomplete_details": None,
+            "model": model,
+            "output": [],
+            "parallel_tool_calls": False,
+        },
+    }
+
+
+def response_completed(
+    response_id: str,
+    model: str,
+    created: int,
+    output: list[dict[str, Any]],
+    usage: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    response = {
+        "type": "response.completed",
+        "response": {
+            "id": response_id,
+            "object": "response",
+            "created_at": created,
+            "status": "completed",
+            "error": None,
+            "incomplete_details": None,
+            "model": model,
+            "output": output,
+            "parallel_tool_calls": False,
+        },
+    }
+    if usage:
+        response["response"]["usage"] = usage
+    return response
+
+
+def text_response_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(messages_from_input(body.get("input"), body.get("instructions"))))
+    if has_unsupported_response_tools(body):
+        messages.insert(0, {"role": "system", "content": TOOL_UNAVAILABLE_SYSTEM_MESSAGE})
+    return model, messages
+
+
+def stream_text_response(backend, body: dict[str, Any], messages: list[dict[str, Any]] | None = None) -> Iterator[dict[str, Any]]:
+    model = str(body.get("model") or "auto").strip() or "auto"
+    messages = messages if messages is not None else messages_from_input(body.get("input"), body.get("instructions"))
+    thinking_effort = thinking_effort_from_body(body)
+    response_id = f"resp_{uuid.uuid4().hex}"
+    item_id = f"msg_{uuid.uuid4().hex}"
+    created = int(time.time())
+    full_text = ""
+    yield response_created(response_id, model, created)
+    yield {"type": "response.output_item.added", "output_index": 0, "item": text_output_item("", item_id, "in_progress")}
+    request = ConversationRequest(model=model, messages=messages, thinking_effort=thinking_effort)
+    for delta in stream_text_deltas(backend, request):
+        full_text += delta
+        yield {"type": "response.output_text.delta", "item_id": item_id, "output_index": 0, "content_index": 0, "delta": delta}
+    yield {"type": "response.output_text.done", "item_id": item_id, "output_index": 0, "content_index": 0, "text": full_text}
+    item = text_output_item(full_text, item_id, "completed")
+    yield {"type": "response.output_item.done", "output_index": 0, "item": item}
+    usage = token_usage(
+        input_text_tokens=count_message_text_tokens(messages, model),
+        input_image_tokens=count_message_image_tokens(messages, model),
+        output_text_tokens=count_text_tokens(full_text, model),
+    )
+    yield response_completed(response_id, model, created, [item], usage)
+
+
+def stream_web_search_response(body: dict[str, Any], messages: list[dict[str, Any]] | None = None) -> Iterator[dict[str, Any]]:
+    model = str(body.get("model") or "auto").strip() or "auto"
+    messages = messages if messages is not None else messages_from_input(body.get("input"), body.get("instructions"))
+    query = search_query_from_messages(messages) or extract_response_prompt(body.get("input"))
+    if not query:
+        raise HTTPException(status_code=400, detail={"error": "input text is required for web_search"})
+
+    response_id = f"resp_{uuid.uuid4().hex}"
+    search_id = f"ws_{uuid.uuid4().hex}"
+    item_id = f"msg_{uuid.uuid4().hex}"
+    created = int(time.time())
+    yield response_created(response_id, model, created)
+
+    searching_item = web_search_call_item(query, search_id, "in_progress")
+    yield {"type": "response.output_item.added", "output_index": 0, "item": searching_item}
+    yield {"type": "response.web_search_call.in_progress", "output_index": 0, "item_id": search_id}
+    yield {"type": "response.web_search_call.searching", "output_index": 0, "item_id": search_id}
+    result = run_web_search(query)
+    search_item = web_search_call_item(query, search_id, "completed", normalized_sources(result))
+    yield {"type": "response.web_search_call.completed", "output_index": 0, "item_id": search_id}
+    yield {"type": "response.output_item.done", "output_index": 0, "item": search_item}
+
+    text, annotations = text_with_url_citations(result)
+    message_item = text_output_item("", item_id, "in_progress", annotations)
+    yield {"type": "response.output_item.added", "output_index": 1, "item": message_item}
+    if text:
+        yield {"type": "response.output_text.delta", "item_id": item_id, "output_index": 1, "content_index": 0, "delta": text}
+    yield {"type": "response.output_text.done", "item_id": item_id, "output_index": 1, "content_index": 0, "text": text}
+    message_item = text_output_item(text, item_id, "completed", annotations)
+    yield {"type": "response.output_item.done", "output_index": 1, "item": message_item}
+    usage = token_usage(
+        input_text_tokens=count_message_text_tokens(messages, model),
+        input_image_tokens=count_message_image_tokens(messages, model),
+        output_text_tokens=count_text_tokens(text, model),
+    )
+    yield response_completed(response_id, model, created, [search_item, message_item], usage)
+
+
+def stream_image_response(
+    image_outputs: Iterable[ImageOutput],
+    prompt: str,
+    model: str,
+    input_image_tokens: int = 0,
+    size: object = None,
+    quality: str = "auto",
+) -> Iterator[dict[str, Any]]:
+    response_id = f"resp_{uuid.uuid4().hex}"
+    created = int(time.time())
+    yield response_created(response_id, model, created)
+    for output in image_outputs:
+        if output.kind == "message":
+            text = output.text
+            item = text_output_item(text)
+            usage = token_usage(
+                input_text_tokens=count_text_tokens(prompt, model),
+                input_image_tokens=input_image_tokens,
+                output_text_tokens=count_text_tokens(text, model),
+            )
+            yield {"type": "response.output_text.delta", "item_id": item["id"], "output_index": 0, "content_index": 0, "delta": text}
+            yield {"type": "response.output_text.done", "item_id": item["id"], "output_index": 0, "content_index": 0, "text": text}
+            yield {"type": "response.output_item.done", "output_index": 0, "item": item}
+            yield response_completed(response_id, model, created, [item], usage)
+            return
+        if output.kind != "result":
+            continue
+        items = image_output_items(prompt, output.data)
+        if items:
+            usage = image_usage(
+                input_text_tokens=count_text_tokens(prompt, model),
+                input_image_tokens=input_image_tokens,
+                output_tokens=count_image_output_items_tokens(output.data, size, quality),
+            )
+            for output_index, item in enumerate(items):
+                yield {"type": "response.output_item.done", "output_index": output_index, "item": item}
+            yield response_completed(response_id, model, created, items, usage)
+            return
+    raise RuntimeError("image generation failed")
+
+
+def collect_response(events: Iterable[dict[str, Any]]) -> dict[str, Any]:
+    completed = {}
+    for event in events:
+        if event.get("type") == "response.completed":
+            completed = event.get("response") if isinstance(event.get("response"), dict) else {}
+    if not completed:
+        raise RuntimeError("response generation failed")
+    return completed
+
+
+def response_events(body: dict[str, Any]) -> Iterator[dict[str, Any]]:
+    if is_text_response_request(body):
+        model, messages = text_response_parts(body)
+        if has_web_search_tool(body) and not has_unsupported_response_tools(body):
+            yield from stream_web_search_response(body, messages)
+            return
+        key = cache_key(body, messages, stream=bool(body.get("stream")))
+        yield from chat_completion_cache.get_or_compute_stream(
+            key,
+            lambda: stream_text_response(text_backend(model), body, messages),
+        )
+        return
+
+    prompt = extract_response_prompt(body.get("input"))
+    if not prompt:
+        raise HTTPException(status_code=400, detail={"error": "input text is required"})
+    model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
+    image_info = extract_response_image(body.get("input"))
+    if image_info:
+        image_data, mime_type = image_info
+        images = encode_images([(image_data, "image.png", mime_type)])
+    else:
+        images = None
+    input_image_tokens = count_image_content_tokens(_input_image_parts(body.get("input")), model)
+    tool = response_image_tool(body)
+    image_outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        size=tool.get("size"),
+        quality=str(tool.get("quality") or "auto"),
+        response_format="b64_json",
+        images=images,
+    ))
+    yield from stream_image_response(image_outputs, prompt, model, input_image_tokens, tool.get("size"), str(tool.get("quality") or "auto"))
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    events = response_events(body)
+    if body.get("stream"):
+        return events
+    return collect_response(events)

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

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from services.account_service import account_service
+from services.openai_backend_api import OpenAIBackendAPI
+
+WEB_SEARCH_TOOL_TYPES = {"web_search", "web_search_preview", "web_search_preview_2025_03_11"}
+SEARCH_CHAT_MODEL_PREFIXES = (
+    "gpt-4o-search-preview",
+    "gpt-4o-mini-search-preview",
+    "gpt-5-search-api",
+)
+
+
+def _tool_type(tool: object) -> str:
+    return str(tool.get("type") or "").strip() if isinstance(tool, dict) else ""
+
+
+def has_web_search_tool(body: dict[str, Any]) -> bool:
+    tools = body.get("tools")
+    if isinstance(tools, list):
+        return any(_tool_type(tool) in WEB_SEARCH_TOOL_TYPES for tool in tools)
+    tool_choice = body.get("tool_choice")
+    return _tool_type(tool_choice) in WEB_SEARCH_TOOL_TYPES
+
+
+def is_web_search_chat_request(body: dict[str, Any]) -> bool:
+    model = str(body.get("model") or "").strip()
+    return (
+        has_web_search_tool(body)
+        or isinstance(body.get("web_search_options"), dict)
+        or any(
+            model == prefix or model.startswith(f"{prefix}-")
+            for prefix in SEARCH_CHAT_MODEL_PREFIXES
+        )
+    )
+
+
+def has_unsupported_tools(body: dict[str, Any], allowed_types: set[str]) -> bool:
+    tools = body.get("tools")
+    if not isinstance(tools, list):
+        return False
+    return any(_tool_type(tool) not in allowed_types for tool in tools if isinstance(tool, dict))
+
+
+def message_text(value: object) -> str:
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, list):
+        parts: list[str] = []
+        for item in value:
+            if isinstance(item, str):
+                text = item.strip()
+            elif isinstance(item, dict):
+                text = str(item.get("text") or item.get("input_text") or "").strip()
+            else:
+                text = ""
+            if text:
+                parts.append(text)
+        return "\n".join(parts).strip()
+    return ""
+
+
+def search_query_from_messages(messages: list[dict[str, Any]]) -> str:
+    for message in reversed(messages):
+        if str(message.get("role") or "").strip().lower() != "user":
+            continue
+        text = message_text(message.get("content"))
+        if text:
+            return text
+    return ""
+
+
+def _readable_annotation_part(parts: list[str]) -> str:
+    for part in parts:
+        value = part.strip()
+        lower = value.lower()
+        if value and not (
+            lower.startswith(("turn", "source", "sources"))
+            or re.fullmatch(r"\d+", value)
+        ):
+            return value
+    return ""
+
+
+def clean_search_text(text: str) -> str:
+    def replace_annotation(match: re.Match[str]) -> str:
+        parts = [part.strip() for part in match.group(1).split("\ue202")]
+        kind = (parts[0] if parts else "").lower()
+        data = parts[1:]
+        if kind == "url":
+            label = data[0] if data else ""
+            url = data[1] if len(data) > 1 else ""
+            if label and url.startswith(("http://", "https://")):
+                return f"{label} ({url})"
+            return label or url
+        if kind == "cite":
+            return _readable_annotation_part(data)
+        return _readable_annotation_part(data)
+
+    text = re.sub(r"\ue200([^\ue201]*)\ue201", replace_annotation, text)
+    text = re.sub(r"\ue200[^\ue201]*$", "", text)
+    return re.sub(r"\s+([.,;:!?])", r"\1", text).strip()
+
+
+def normalized_sources(result: dict[str, Any]) -> list[dict[str, str]]:
+    sources = result.get("sources")
+    if not isinstance(sources, list):
+        return []
+    output: list[dict[str, str]] = []
+    seen: set[str] = set()
+    for item in sources:
+        if not isinstance(item, dict):
+            continue
+        url = str(item.get("url") or "").strip()
+        title = str(item.get("title") or "").strip()
+        snippet = str(item.get("snippet") or "").strip()
+        if not url or url in seen:
+            continue
+        seen.add(url)
+        output.append({"title": title, "url": url, "snippet": snippet})
+    return output
+
+
+def text_with_url_citations(result: dict[str, Any]) -> tuple[str, list[dict[str, Any]]]:
+    text = clean_search_text(str(result.get("answer") or ""))
+    annotations: list[dict[str, Any]] = []
+    sources = normalized_sources(result)
+    if sources:
+        text = text.rstrip()
+        if text:
+            text += "\n\n"
+        text += "Sources:\n"
+        for index, source in enumerate(sources, start=1):
+            title = source["title"] or source["url"]
+            line_prefix = f"{index}. {title}"
+            text += line_prefix
+            if source["url"]:
+                if source["title"]:
+                    text += " - "
+                start = len(text)
+                text += source["url"]
+                annotations.append({
+                    "type": "url_citation",
+                    "start_index": start,
+                    "end_index": len(text),
+                    "url": source["url"],
+                    "title": source["title"] or source["url"],
+                })
+            text += "\n"
+    return text.strip(), annotations
+
+
+def run_web_search(query: str) -> dict[str, Any]:
+    token = account_service.get_text_access_token()
+    result = OpenAIBackendAPI(token).search(query)
+    account_service.mark_text_used(token)
+    return result