coze-coding-utils 0.2.1__py3-none-any.whl → 0.2.2a1__py3-none-any.whl

coze_coding_utils/openai/handler.py

@@ -0,0 +1,298 @@
+"""OpenAI Chat Completions 处理器"""
+
+import asyncio
+import logging
+import threading
+import contextvars
+from typing import Dict, Any, Union, AsyncGenerator
+
+from fastapi.responses import StreamingResponse, JSONResponse
+
+from coze_coding_utils.runtime_ctx.context import Context
+from coze_coding_utils.openai.types.response import OpenAIError, OpenAIErrorResponse
+from coze_coding_utils.openai.converter.request_converter import RequestConverter
+from coze_coding_utils.openai.converter.response_converter import ResponseConverter
+from coze_coding_utils.error import classify_error
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIChatHandler:
+    """OpenAI Chat Completions 处理器"""
+
+    def __init__(self, graph_service: Any):
+        """
+        初始化处理器
+
+        Args:
+            graph_service: GraphService 实例
+        """
+        self.graph_service = graph_service
+        self.request_converter = RequestConverter()
+
+    async def handle(
+        self,
+        payload: Dict[str, Any],
+        ctx: Context,
+    ) -> Union[StreamingResponse, JSONResponse]:
+        """
+        处理请求，根据 stream 参数返回流式或非流式响应
+
+        Args:
+            payload: 请求体
+            ctx: 上下文
+
+        Returns:
+            StreamingResponse 或 JSONResponse
+        """
+        try:
+            # 1. 解析请求
+            request = self.request_converter.parse(payload)
+            session_id = self.request_converter.get_session_id(request)
+
+            if not session_id:
+                return self._error_response(
+                    message="session_id is required",
+                    error_type="invalid_request_error",
+                    code="400001",
+                    status_code=400,
+                )
+
+            # 2. 初始化响应转换器
+            response_converter = ResponseConverter(
+                request_id=f"chatcmpl-{ctx.run_id}",
+                model=request.model,
+            )
+
+            # 3. 转换为 LangGraph 输入
+            stream_input = self.request_converter.to_stream_input(request)
+
+            if not stream_input.get("messages"):
+                return self._error_response(
+                    message="No user message found",
+                    error_type="invalid_request_error",
+                    code="400002",
+                    status_code=400,
+                )
+
+            # 4. 根据 stream 参数处理
+            if request.stream:
+                return self._handle_stream(
+                    stream_input,
+                    session_id,
+                    response_converter,
+                    ctx,
+                )
+            else:
+                return await self._handle_non_stream(
+                    stream_input,
+                    session_id,
+                    response_converter,
+                    ctx,
+                )
+
+        except Exception as e:
+            logger.error(f"Error in OpenAIChatHandler.handle: {e}", exc_info=True)
+            return self._handle_error(e)
+
+    def _handle_stream(
+        self,
+        stream_input: Dict[str, Any],
+        session_id: str,
+        response_converter: ResponseConverter,
+        ctx: Context,
+    ) -> StreamingResponse:
+        """流式响应处理"""
+
+        async def stream_generator() -> AsyncGenerator[str, None]:
+            """异步流式生成器"""
+            loop = asyncio.get_running_loop()
+            queue: asyncio.Queue = asyncio.Queue()
+            context = contextvars.copy_context()
+
+            def producer():
+                """后台线程生产者"""
+                try:
+                    # 获取 graph 并配置
+                    from utils.helper import graph_helper
+                    graph = self.graph_service._get_graph(ctx)
+
+                    if graph_helper.is_agent_proj():
+                        from utils.log.loop_trace import init_agent_config
+                        run_config = init_agent_config(graph, ctx)
+                    else:
+                        from utils.log.loop_trace import init_run_config
+                        run_config = init_run_config(graph, ctx)
+
+                    run_config["recursion_limit"] = 100
+                    run_config["configurable"] = {"thread_id": session_id}
+
+                    # 流式执行 - 直接使用 LangGraph 原始流
+                    items = graph.stream(
+                        stream_input,
+                        stream_mode="messages",
+                        config=run_config,
+                        context=ctx,
+                    )
+
+                    # 使用 iter_langgraph_stream 方法，支持工具参数流式输出
+                    for sse_data in response_converter.iter_langgraph_stream(items):
+                        if sse_data != "data: [DONE]\n\n":  # 不在这里发送 DONE
+                            loop.call_soon_threadsafe(queue.put_nowait, sse_data)
+
+                except Exception as ex:
+                    logger.error(f"Stream producer error: {ex}", exc_info=True)
+                    err = classify_error(ex, {"node_name": "openai_stream"})
+                    error_chunk = self._create_error_sse_chunk(
+                        str(err.code),
+                        str(ex),
+                        response_converter.request_id,
+                    )
+                    loop.call_soon_threadsafe(queue.put_nowait, error_chunk)
+                finally:
+                    loop.call_soon_threadsafe(queue.put_nowait, "data: [DONE]\n\n")
+                    loop.call_soon_threadsafe(queue.put_nowait, None)
+
+            # 启动后台线程
+            threading.Thread(target=lambda: context.run(producer), daemon=True).start()
+
+            # 从队列消费
+            try:
+                while True:
+                    item = await queue.get()
+                    if item is None:
+                        break
+                    yield item
+            except asyncio.CancelledError:
+                logger.info(f"Stream cancelled for run_id: {ctx.run_id}")
+                raise
+
+        return StreamingResponse(
+            stream_generator(),
+            media_type="text/event-stream",
+        )
+
+    async def _handle_non_stream(
+        self,
+        stream_input: Dict[str, Any],
+        session_id: str,
+        response_converter: ResponseConverter,
+        ctx: Context,
+    ) -> JSONResponse:
+        """非流式响应处理"""
+        loop = asyncio.get_running_loop()
+        context = contextvars.copy_context()
+        result_future: asyncio.Future = loop.create_future()
+
+        def producer():
+            """后台线程生产者"""
+            try:
+                # 获取 graph 并配置
+                from utils.helper import graph_helper
+                graph = self.graph_service._get_graph(ctx)
+
+                if graph_helper.is_agent_proj():
+                    from utils.log.loop_trace import init_agent_config
+                    run_config = init_agent_config(graph, ctx)
+                else:
+                    from utils.log.loop_trace import init_run_config
+                    run_config = init_run_config(graph, ctx)
+
+                run_config["recursion_limit"] = 100
+                run_config["configurable"] = {"thread_id": session_id}
+
+                # 流式执行 - 直接使用 LangGraph 原始流
+                items = graph.stream(
+                    stream_input,
+                    stream_mode="messages",
+                    config=run_config,
+                    context=ctx,
+                )
+
+                # 使用 collect_langgraph_to_response 方法收集结果
+                response = response_converter.collect_langgraph_to_response(items)
+                loop.call_soon_threadsafe(
+                    result_future.set_result,
+                    response.to_dict()
+                )
+
+            except Exception as ex:
+                logger.error(f"Non-stream producer error: {ex}", exc_info=True)
+                loop.call_soon_threadsafe(
+                    result_future.set_exception,
+                    ex
+                )
+
+        # 启动后台线程
+        threading.Thread(target=lambda: context.run(producer), daemon=True).start()
+
+        try:
+            result = await result_future
+            return JSONResponse(content=result)
+        except Exception as e:
+            return self._handle_error(e)
+
+    def _handle_error(self, error: Exception) -> JSONResponse:
+        """错误处理，返回 OpenAI 标准错误格式"""
+        err = classify_error(error, {"node_name": "openai_handler"})
+
+        error_type = "internal_error"
+        status_code = 500
+
+        # 根据错误类型映射
+        error_category = err.category.name if err.category else "System"
+        if error_category in ("Invalid", "BadRequest"):
+            error_type = "invalid_request_error"
+            status_code = 400
+        elif error_category == "TimeOut":
+            error_type = "timeout_error"
+            status_code = 408
+        elif error_category == "NotFound":
+            error_type = "not_found_error"
+            status_code = 404
+
+        return self._error_response(
+            message=str(error),
+            error_type=error_type,
+            code=str(err.code),
+            status_code=status_code,
+        )
+
+    @staticmethod
+    def _error_response(
+        message: str,
+        error_type: str,
+        code: str,
+        status_code: int = 500,
+    ) -> JSONResponse:
+        """创建错误响应"""
+        error_resp = OpenAIErrorResponse(
+            error=OpenAIError(
+                message=message,
+                type=error_type,
+                code=code,
+            )
+        )
+        return JSONResponse(
+            content=error_resp.to_dict(),
+            status_code=status_code,
+        )
+
+    @staticmethod
+    def _create_error_sse_chunk(
+        code: str,
+        message: str,
+        request_id: str,
+    ) -> str:
+        """创建错误 SSE chunk"""
+        import json
+        error_data = {
+            "id": request_id,
+            "object": "chat.completion.chunk",
+            "error": {
+                "message": message,
+                "type": "internal_error",
+                "code": code,
+            }
+        }
+        return f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"

coze_coding_utils/openai/types/__init__.py

@@ -0,0 +1,37 @@
+"""OpenAI 类型定义"""
+
+from coze_coding_utils.openai.types.request import (
+    ChatMessage,
+    ChatCompletionRequest,
+)
+from coze_coding_utils.openai.types.response import (
+    ToolCallFunction,
+    ToolCallChunk,
+    Delta,
+    ChunkChoice,
+    ChatCompletionChunk,
+    Usage,
+    Message,
+    Choice,
+    ChatCompletionResponse,
+    OpenAIError,
+    OpenAIErrorResponse,
+)
+
+__all__ = [
+    # Request types
+    "ChatMessage",
+    "ChatCompletionRequest",
+    # Response types
+    "ToolCallFunction",
+    "ToolCallChunk",
+    "Delta",
+    "ChunkChoice",
+    "ChatCompletionChunk",
+    "Usage",
+    "Message",
+    "Choice",
+    "ChatCompletionResponse",
+    "OpenAIError",
+    "OpenAIErrorResponse",
+]

coze_coding_utils/openai/types/request.py

@@ -0,0 +1,24 @@
+"""OpenAI Chat Completions API 请求类型定义"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Union, Dict, Any
+
+
+@dataclass
+class ChatMessage:
+    """聊天消息"""
+    role: str  # "user" | "assistant" | "tool" | "system"
+    content: Union[str, List[Dict[str, Any]], None] = None  # 支持多模态
+    tool_calls: Optional[List[Dict[str, Any]]] = None  # 工具调用 (assistant)
+    tool_call_id: Optional[str] = None  # 工具响应关联ID (tool)
+
+
+@dataclass
+class ChatCompletionRequest:
+    """聊天完成请求"""
+    messages: List[ChatMessage] = field(default_factory=list)
+    model: str = "default"
+    stream: bool = False
+    session_id: str = ""  # 扩展字段：会话 ID
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None

coze_coding_utils/openai/types/response.py

@@ -0,0 +1,178 @@
+"""OpenAI Chat Completions API 响应类型定义"""
+
+from dataclasses import dataclass, field, asdict
+from typing import List, Optional, Dict, Any
+
+
+@dataclass
+class ToolCallFunction:
+    """工具调用函数"""
+    name: str = ""
+    arguments: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"name": self.name, "arguments": self.arguments}
+
+
+@dataclass
+class ToolCallChunk:
+    """工具调用增量 (流式)"""
+    index: int = 0
+    id: Optional[str] = None
+    type: str = "function"
+    function: Optional[ToolCallFunction] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {"index": self.index, "type": self.type}
+        if self.id is not None:
+            result["id"] = self.id
+        if self.function is not None:
+            result["function"] = self.function.to_dict()
+        return result
+
+
+@dataclass
+class Delta:
+    """流式响应增量"""
+    role: Optional[str] = None  # "assistant" | "tool"
+    content: Optional[str] = None
+    tool_calls: Optional[List[ToolCallChunk]] = None
+    tool_call_id: Optional[str] = None  # role=tool 时使用
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {}
+        if self.role is not None:
+            result["role"] = self.role
+        if self.content is not None:
+            result["content"] = self.content
+        if self.tool_calls is not None:
+            result["tool_calls"] = [tc.to_dict() for tc in self.tool_calls]
+        if self.tool_call_id is not None:
+            result["tool_call_id"] = self.tool_call_id
+        return result
+
+
+@dataclass
+class ChunkChoice:
+    """流式响应选项"""
+    index: int = 0
+    delta: Delta = field(default_factory=Delta)
+    finish_reason: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {
+            "index": self.index,
+            "delta": self.delta.to_dict(),
+        }
+        # finish_reason 需要显式设置为 null
+        result["finish_reason"] = self.finish_reason
+        return result
+
+
+@dataclass
+class ChatCompletionChunk:
+    """流式响应 chunk"""
+    id: str = ""
+    object: str = "chat.completion.chunk"
+    created: int = 0
+    model: str = "default"
+    choices: List[ChunkChoice] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "object": self.object,
+            "created": self.created,
+            "model": self.model,
+            "choices": [c.to_dict() for c in self.choices],
+        }
+
+
+@dataclass
+class Usage:
+    """Token 使用情况"""
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class Message:
+    """非流式响应消息"""
+    role: str = "assistant"
+    content: Optional[str] = None
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+    tool_call_id: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {"role": self.role}
+        if self.content is not None:
+            result["content"] = self.content
+        if self.tool_calls is not None:
+            result["tool_calls"] = self.tool_calls
+        if self.tool_call_id is not None:
+            result["tool_call_id"] = self.tool_call_id
+        return result
+
+
+@dataclass
+class Choice:
+    """非流式响应选项"""
+    index: int = 0
+    message: Message = field(default_factory=Message)
+    finish_reason: str = "stop"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "index": self.index,
+            "message": self.message.to_dict(),
+            "finish_reason": self.finish_reason,
+        }
+
+
+@dataclass
+class ChatCompletionResponse:
+    """非流式响应"""
+    id: str = ""
+    object: str = "chat.completion"
+    created: int = 0
+    model: str = "default"
+    choices: List[Choice] = field(default_factory=list)
+    usage: Usage = field(default_factory=Usage)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "object": self.object,
+            "created": self.created,
+            "model": self.model,
+            "choices": [c.to_dict() for c in self.choices],
+            "usage": self.usage.to_dict(),
+        }
+
+
+@dataclass
+class OpenAIError:
+    """OpenAI 错误"""
+    message: str = ""
+    type: str = "internal_error"
+    code: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "message": self.message,
+            "type": self.type,
+            "code": self.code,
+        }
+
+
+@dataclass
+class OpenAIErrorResponse:
+    """OpenAI 错误响应"""
+    error: OpenAIError = field(default_factory=OpenAIError)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"error": self.error.to_dict()}

{coze_coding_utils-0.2.1.dist-info → coze_coding_utils-0.2.2a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coze-coding-utils
-Version: 0.2.1
+Version: 0.2.2a1
 Summary: Utilities for Coze coding client runtime context and helpers.
 Project-URL: Homepage, https://code.byted.org/stone/coze-coding-client
 Author: Bytedance Stone Team
@@ -39,4 +39,4 @@ Requires Python 3.10+.
 
 ## License
 
-MIT
+MIT

coze_coding_utils-0.2.2a1.dist-info/RECORD

@@ -0,0 +1,37 @@
+coze_coding_utils/__init__.py,sha256=OIMKOQLy07Uo5wQkLw3D7j6qRKt4o-smdW-dndYhpHo,37
+coze_coding_utils/error/__init__.py,sha256=SbhsopZ8ZQsbXKZ-GPsw3Fq8AQAOC8W6bZgUZhIOw_k,886
+coze_coding_utils/error/classifier.py,sha256=uXVmufL_sn4w7oNyvrEFXSI_8mCi4mXY353UK5d-d0Y,10028
+coze_coding_utils/error/codes.py,sha256=34sC528UndVa96q0B2_BpvD-PVPPyZwL3wuVErxzx2U,17028
+coze_coding_utils/error/exceptions.py,sha256=QjGk56ovGG-2V4gHcTeJq3-3ZIQQ8DF692zgIYcEJxI,17074
+coze_coding_utils/error/patterns.py,sha256=YhhBcCoWQuvSbtA271eS3AB81pChypD7nDrPidQDu0s,44412
+coze_coding_utils/error/test_classifier.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coze_coding_utils/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coze_coding_utils/file/file.py,sha256=CFhnxHpmh2aPeMOq3PwSsZFsIiQ-YigYxgYvzJAfx_0,11828
+coze_coding_utils/helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coze_coding_utils/helper/agent_helper.py,sha256=q1ZM30xLXoW-m0NJmJ_Y0M-kUAQCBstG_j7xkqsyRSU,22546
+coze_coding_utils/helper/graph_helper.py,sha256=UNtqqiQNAQ4319qcC1vHiLYIL2eGzvGQRgXu3mgLq8Y,8893
+coze_coding_utils/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coze_coding_utils/log/common.py,sha256=mUNkCm68oaPaI6-a5UwLf87AfhrMnVPkEuri16guqKc,168
+coze_coding_utils/log/config.py,sha256=Qkw3JRuGUKJ6CBY7WqHJOFeyCU47cArvUtMsSBifFMo,195
+coze_coding_utils/log/err_trace.py,sha256=iwt5g8-AX0N2KuUpuLXjk5PocL6NZdAGddJh27Sxp_o,2954
+coze_coding_utils/log/loop_trace.py,sha256=68sI1AHKd8oeLti-7trBygTZqIiUu_TcHt93DLItkXQ,2129
+coze_coding_utils/log/node_log.py,sha256=AAreNJJc8Lx1QuCIwvss2ty9z5cDuHEzMobA4ZYSYBI,18040
+coze_coding_utils/log/parser.py,sha256=XuzOkO8SzTbBP_XL1RMFzjqG4IG0iSRStAA2M6latt8,9728
+coze_coding_utils/log/write_log.py,sha256=lDu4_Tjk6eYtWBXI-OOYLqe5ejqTtGnDcrH6M7fMQ2A,7223
+coze_coding_utils/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coze_coding_utils/messages/client.py,sha256=b-pfTeQXbXx_66ut9gSZY4SM_tP8gvPb5HRblcDnKV0,1249
+coze_coding_utils/messages/server.py,sha256=AQtiKWqp3A1iYylIgqUMhRNimDHJZXQGEPcir7pe1k8,5397
+coze_coding_utils/openai/__init__.py,sha256=3nrbbDovMXGDgSFRnJXml6cRHAdlm2MlZA6jaXixcJ4,141
+coze_coding_utils/openai/handler.py,sha256=IBrRG6JyqMAlTG6bmKnJsNMlI2E0uYmHLm0ZCL4Hbsg,10325
+coze_coding_utils/openai/converter/__init__.py,sha256=UC6O3vfQItCFf2ur08ZPuqT8NK1gQQpC3pTkITBzc9M,243
+coze_coding_utils/openai/converter/request_converter.py,sha256=P0tvLu7_nFoovHyHrJgkPBx7mQI7cmprvnAleF8pfLs,5838
+coze_coding_utils/openai/converter/response_converter.py,sha256=atUwAa-sYaUpp-y-JUwRCw_QOnm0js0-S1JBO9Ucnco,18378
+coze_coding_utils/openai/types/__init__.py,sha256=sFBXOYmTABfAXYTmhBLJ8ZLs-xUoWJJ97i8eFx08x3Y,708
+coze_coding_utils/openai/types/request.py,sha256=IuNMT2Ce1--_32R30Q2q7Lb2dAwKNy3hZc4AguDeD9E,805
+coze_coding_utils/openai/types/response.py,sha256=pjHHVR8LSMVFCc3fGzKqXrdoKDIfSCJEfICd_X9Nohc,4808
+coze_coding_utils/runtime_ctx/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
+coze_coding_utils/runtime_ctx/context.py,sha256=G8ld-WnQ1pTJe5OOXC_dTbagXj9IxmpRiPM4X_jWW6o,3992
+coze_coding_utils-0.2.2a1.dist-info/METADATA,sha256=v1GSxZ6VbVzMuIQfLHE5n37z1iYG4UJnKJ3BTCV-lag,979
+coze_coding_utils-0.2.2a1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+coze_coding_utils-0.2.2a1.dist-info/licenses/LICENSE,sha256=lzckZhAjHlpSJcWvppoST095IHFpBwKiB2pKcBv7vP4,1078
+coze_coding_utils-0.2.2a1.dist-info/RECORD,,

coze_coding_utils-0.2.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-coze_coding_utils/__init__.py,sha256=dQtSrS3n4kQxFmK2BrA9n_e5r6YJEMGZ3enaYv-VLeg,36
-coze_coding_utils/runtime_ctx/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
-coze_coding_utils/runtime_ctx/context.py,sha256=G8ld-WnQ1pTJe5OOXC_dTbagXj9IxmpRiPM4X_jWW6o,3992
-coze_coding_utils-0.2.1.dist-info/METADATA,sha256=PaeCjKPUN4nvLGpUYFo0BgyBmHbK9nhozzWxv2Efs-0,978
-coze_coding_utils-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-coze_coding_utils-0.2.1.dist-info/licenses/LICENSE,sha256=lzckZhAjHlpSJcWvppoST095IHFpBwKiB2pKcBv7vP4,1078
-coze_coding_utils-0.2.1.dist-info/RECORD,,