pygpt-net 2.6.36__py3-none-any.whl → 2.6.38__py3-none-any.whl

pygpt_net/controller/chat/handler/openai_stream.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.05 00:00:00                  #
+# ================================================== #
+
+import base64
+import io
+import json
+from typing import Optional, Any
+
+from .utils import capture_openai_usage
+
+
+def process_api_chat(ctx, state, chunk) -> Optional[str]:
+    """
+    OpenAI-compatible Chat Completions stream delta (robust to dict/object tool_calls).
+
+    :param ctx: Chat context
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    :return: Extracted text delta or None
+    """
+    response = None
+    delta = chunk.choices[0].delta if getattr(chunk, "choices", None) else None
+
+    # Capture citations (top-level) if present
+    try:
+        cits = getattr(chunk, "citations", None)
+        if cits:
+            state.citations = cits
+            ctx.urls = cits
+    except Exception:
+        pass
+
+    # Capture usage (top-level) if present
+    try:
+        u = getattr(chunk, "usage", None)
+        if u:
+            capture_openai_usage(state, u)
+    except Exception:
+        pass
+
+    # Text delta
+    if delta and getattr(delta, "content", None) is not None:
+        response = delta.content
+
+    # Tool calls (support OpenAI object or xAI dict)
+    if delta and getattr(delta, "tool_calls", None):
+        state.force_func_call = True
+        for tool_chunk in delta.tool_calls:
+            # Normalize fields
+            if isinstance(tool_chunk, dict):
+                idx = tool_chunk.get("index")
+                id_val = tool_chunk.get("id")
+                fn = tool_chunk.get("function") or {}
+                name_part = fn.get("name")
+                args_part = fn.get("arguments")
+            else:
+                idx = getattr(tool_chunk, "index", None)
+                id_val = getattr(tool_chunk, "id", None)
+                fn_obj = getattr(tool_chunk, "function", None)
+                name_part = getattr(fn_obj, "name", None) if fn_obj else None
+                args_part = getattr(fn_obj, "arguments", None) if fn_obj else None
+
+            # Default index when missing
+            if idx is None or not isinstance(idx, int):
+                idx = len(state.tool_calls)
+
+            # Ensure list length
+            while len(state.tool_calls) <= idx:
+                state.tool_calls.append({
+                    "id": "",
+                    "type": "function",
+                    "function": {"name": "", "arguments": ""}
+                })
+            tool_call = state.tool_calls[idx]
+
+            # Append id fragment (if streamed)
+            if id_val:
+                frag = str(id_val)
+                if not tool_call["id"]:
+                    tool_call["id"] = frag
+                else:
+                    if not tool_call["id"].endswith(frag):
+                        tool_call["id"] += frag
+
+            # Append name fragment
+            if name_part:
+                frag = str(name_part)
+                if not tool_call["function"]["name"]:
+                    tool_call["function"]["name"] = frag
+                else:
+                    if not tool_call["function"]["name"].endswith(frag):
+                        tool_call["function"]["name"] += frag
+
+            # Append arguments fragment (string or JSON)
+            if args_part is not None:
+                if isinstance(args_part, (dict, list)):
+                    frag = json.dumps(args_part, ensure_ascii=False)
+                else:
+                    frag = str(args_part)
+                tool_call["function"]["arguments"] += frag
+
+    return response
+
+
+def process_api_chat_responses(ctx, core, state, chunk, etype: Optional[str]) -> Optional[str]:
+    """
+    OpenAI Responses API stream events.
+
+    :param ctx: Chat context
+    :param core: Core controller
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    :param etype: Event type
+    :return: Extracted text delta or None
+    """
+    response = None
+
+    if etype == "response.completed":
+        # usage on final response
+        try:
+            u = getattr(chunk.response, "usage", None)
+            if u:
+                capture_openai_usage(state, u)
+        except Exception:
+            pass
+
+        for item in chunk.response.output:
+            if item.type == "mcp_list_tools":
+                core.api.openai.responses.mcp_tools = item.tools
+            elif item.type == "mcp_call":
+                call = {
+                    "id": item.id,
+                    "type": "mcp_call",
+                    "approval_request_id": item.approval_request_id,
+                    "arguments": item.arguments,
+                    "error": item.error,
+                    "name": item.name,
+                    "output": item.output,
+                    "server_label": item.server_label,
+                }
+                state.tool_calls.append({
+                    "id": item.id,
+                    "call_id": "",
+                    "type": "function",
+                    "function": {"name": item.name, "arguments": item.arguments}
+                })
+                ctx.extra["mcp_call"] = call
+                core.ctx.update_item(ctx)
+            elif item.type == "mcp_approval_request":
+                call = {
+                    "id": item.id,
+                    "type": "mcp_call",
+                    "arguments": item.arguments,
+                    "name": item.name,
+                    "server_label": item.server_label,
+                }
+                ctx.extra["mcp_approval_request"] = call
+                core.ctx.update_item(ctx)
+
+    elif etype == "response.output_text.delta":
+        response = chunk.delta
+
+    elif etype == "response.output_item.added" and chunk.item.type == "function_call":
+        state.tool_calls.append({
+            "id": chunk.item.id,
+            "call_id": chunk.item.call_id,
+            "type": "function",
+            "function": {"name": chunk.item.name, "arguments": ""}
+        })
+        state.fn_args_buffers[chunk.item.id] = io.StringIO()
+
+    elif etype == "response.function_call_arguments.delta":
+        buf = state.fn_args_buffers.get(chunk.item_id)
+        if buf is not None:
+            buf.write(chunk.delta)
+
+    elif etype == "response.function_call_arguments.done":
+        buf = state.fn_args_buffers.pop(chunk.item_id, None)
+        if buf is not None:
+            try:
+                args_val = buf.getvalue()
+            finally:
+                buf.close()
+            for tc in state.tool_calls:
+                if tc["id"] == chunk.item_id:
+                    tc["function"]["arguments"] = args_val
+                    break
+
+    elif etype == "response.output_text.annotation.added":
+        ann = chunk.annotation
+        if ann['type'] == "url_citation":
+            if state.citations is None:
+                state.citations = []
+            url_citation = ann['url']
+            state.citations.append(url_citation)
+            ctx.urls = state.citations
+        elif ann['type'] == "container_file_citation":
+            state.files.append({
+                "container_id": ann['container_id'],
+                "file_id": ann['file_id'],
+            })
+
+    elif etype == "response.reasoning_summary_text.delta":
+        response = chunk.delta
+
+    elif etype == "response.output_item.done":
+        tool_calls, has_calls = core.api.openai.computer.handle_stream_chunk(ctx, chunk, state.tool_calls)
+        state.tool_calls = tool_calls
+        if has_calls:
+            state.force_func_call = True
+
+    elif etype == "response.code_interpreter_call_code.delta":
+        if not state.is_code:
+            response = "\n\n**Code interpreter**\n```python\n" + chunk.delta
+            state.is_code = True
+        else:
+            response = chunk.delta
+
+    elif etype == "response.code_interpreter_call_code.done":
+        response = "\n\n```\n-----------\n"
+
+    elif etype == "response.image_generation_call.partial_image":
+        image_base64 = chunk.partial_image_b64
+        image_bytes = base64.b64decode(image_base64)
+        if state.img_path:
+            with open(state.img_path, "wb") as f:
+                f.write(image_bytes)
+        del image_bytes
+        state.is_image = True
+
+    elif etype == "response.created":
+        ctx.msg_id = str(chunk.response.id)
+        core.ctx.update_item(ctx)
+
+    elif etype in {"response.done", "response.failed", "error"}:
+        pass
+
+    return response
+
+
+def process_api_completion(chunk) -> Optional[str]:
+    """
+    OpenAI Completions stream text delta.
+
+    :param chunk: Incoming streaming chunk
+    :return: Extracted text delta or None
+    """
+    if getattr(chunk, "choices", None):
+        choice0 = chunk.choices[0]
+        if getattr(choice0, "text", None) is not None:
+            return choice0.text
+    return None

pygpt_net/controller/chat/handler/utils.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.05 00:00:00                  #
+# ================================================== #
+
+import base64
+from typing import Any, Optional
+
+
+def safe_get(obj: Any, path: str) -> Any:
+    """
+    Dot-path getter for dicts and objects.
+
+    :param obj: Source object or dict
+    :param path: Dot-separated path, e.g. 'a.b.0.c'
+    :return: Value at path or None
+    """
+    cur = obj
+    for seg in path.split("."):
+        if cur is None:
+            return None
+        if isinstance(cur, dict):
+            cur = cur.get(seg)
+        else:
+            if seg.isdigit() and isinstance(cur, (list, tuple)):
+                idx = int(seg)
+                if 0 <= idx < len(cur):
+                    cur = cur[idx]
+                else:
+                    return None
+            else:
+                cur = getattr(cur, seg, None)
+    return cur
+
+
+def as_int(val: Any) -> Optional[int]:
+    """
+    Coerce to int if possible, else None.
+
+    :param val: Input value
+    :return: int or None
+    """
+    if val is None:
+        return None
+    try:
+        return int(val)
+    except Exception:
+        try:
+            return int(float(val))
+        except Exception:
+            return None
+
+
+def capture_openai_usage(state, u_obj: Any):
+    """
+    Extract usage for OpenAI/xAI-compatible chunks.
+
+    :param state: Chat state
+    :param u_obj: Usage object/dict
+    """
+    if not u_obj:
+        return
+    state.usage_vendor = "openai"
+    in_tok = as_int(safe_get(u_obj, "input_tokens")) or as_int(safe_get(u_obj, "prompt_tokens"))
+    out_tok = as_int(safe_get(u_obj, "output_tokens")) or as_int(safe_get(u_obj, "completion_tokens"))
+    total = as_int(safe_get(u_obj, "total_tokens"))
+    reasoning = (
+        as_int(safe_get(u_obj, "output_tokens_details.reasoning_tokens")) or
+        as_int(safe_get(u_obj, "completion_tokens_details.reasoning_tokens")) or
+        as_int(safe_get(u_obj, "reasoning_tokens")) or
+        0
+    )
+    out_with_reason = (out_tok or 0) + (reasoning or 0)
+    state.usage_payload = {"in": in_tok, "out": out_with_reason, "reasoning": reasoning or 0, "total": total}
+
+
+def capture_google_usage(state, um_obj: Any):
+    """
+    Extract usage for Google python-genai; prefer total - prompt to include reasoning.
+
+    :param state: Chat state
+    :param um_obj: Usage metadata object/dict
+    """
+    if not um_obj:
+        return
+    state.usage_vendor = "google"
+    prompt = (
+        as_int(safe_get(um_obj, "prompt_token_count")) or
+        as_int(safe_get(um_obj, "prompt_tokens")) or
+        as_int(safe_get(um_obj, "input_tokens"))
+    )
+    total = (
+        as_int(safe_get(um_obj, "total_token_count")) or
+        as_int(safe_get(um_obj, "total_tokens"))
+    )
+    candidates = (
+        as_int(safe_get(um_obj, "candidates_token_count")) or
+        as_int(safe_get(um_obj, "output_tokens"))
+    )
+    reasoning = (
+        as_int(safe_get(um_obj, "candidates_reasoning_token_count")) or
+        as_int(safe_get(um_obj, "reasoning_tokens")) or 0
+    )
+    if total is not None and prompt is not None:
+        out_total = max(0, total - prompt)
+    else:
+        out_total = candidates
+    state.usage_payload = {"in": prompt, "out": out_total, "reasoning": reasoning or 0, "total": total}
+
+
+def collect_google_citations(ctx, state, chunk: Any):
+    """
+    Collect web citations (URLs) from Google GenAI stream.
+
+    :param ctx: Chat context
+    :param state: Chat state
+    :param chunk: Incoming streaming chunk
+    """
+    try:
+        cands = getattr(chunk, "candidates", None) or []
+    except Exception:
+        cands = []
+
+    if not isinstance(state.citations, list):
+        state.citations = []
+
+    def _add_url(url: Optional[str]):
+        if not url or not isinstance(url, str):
+            return
+        url = url.strip()
+        if not (url.startswith("http://") or url.startswith("https://")):
+            return
+        if ctx.urls is None:
+            ctx.urls = []
+        if url not in state.citations:
+            state.citations.append(url)
+        if url not in ctx.urls:
+            ctx.urls.append(url)
+
+    for cand in cands:
+        gm = safe_get(cand, "grounding_metadata") or safe_get(cand, "groundingMetadata")
+        if gm:
+            atts = safe_get(gm, "grounding_attributions") or safe_get(gm, "groundingAttributions") or []
+            try:
+                for att in atts or []:
+                    for path in (
+                        "web.uri",
+                        "web.url",
+                        "source.web.uri",
+                        "source.web.url",
+                        "source.uri",
+                        "source.url",
+                        "uri",
+                        "url",
+                    ):
+                        _add_url(safe_get(att, path))
+            except Exception:
+                pass
+            for path in (
+                "search_entry_point.uri",
+                "search_entry_point.url",
+                "searchEntryPoint.uri",
+                "searchEntryPoint.url",
+                "search_entry_point.rendered_content_uri",
+                "searchEntryPoint.rendered_content_uri",
+            ):
+                _add_url(safe_get(gm, path))
+
+        cm = safe_get(cand, "citation_metadata") or safe_get(cand, "citationMetadata")
+        if cm:
+            cit_arrays = (
+                safe_get(cm, "citation_sources") or
+                safe_get(cm, "citationSources") or
+                safe_get(cm, "citations") or []
+            )
+            try:
+                for cit in cit_arrays or []:
+                    for path in ("uri", "url", "source.uri", "source.url", "web.uri", "web.url"):
+                        _add_url(safe_get(cit, path))
+            except Exception:
+                pass
+
+        try:
+            parts = safe_get(cand, "content.parts") or []
+            for p in parts:
+                pcm = safe_get(p, "citation_metadata") or safe_get(p, "citationMetadata")
+                if pcm:
+                    arr = (
+                        safe_get(pcm, "citation_sources") or
+                        safe_get(pcm, "citationSources") or
+                        safe_get(pcm, "citations") or []
+                    )
+                    for cit in arr or []:
+                        for path in ("uri", "url", "source.uri", "source.url", "web.uri", "web.url"):
+                            _add_url(safe_get(cit, path))
+                gpa = safe_get(p, "grounding_attributions") or safe_get(p, "groundingAttributions") or []
+                for att in gpa or []:
+                    for path in ("web.uri", "web.url", "source.web.uri", "source.web.url", "uri", "url"):
+                        _add_url(safe_get(att, path))
+        except Exception:
+            pass
+
+    if state.citations and (ctx.urls is None or not ctx.urls):
+        ctx.urls = list(state.citations)