coze-coding-utils 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

coze_coding_utils/openai/handler.py

@@ -1,298 +0,0 @@
-"""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

@@ -1,37 +0,0 @@
-"""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

@@ -1,24 +0,0 @@
-"""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

@@ -1,178 +0,0 @@
-"""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.0.dist-info/RECORD

@@ -1,37 +0,0 @@
-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.0.dist-info/METADATA,sha256=b7j1K1btf3__Be--lCvD3vY8gQV7gT34rp0tMltmzYI,1498
-coze_coding_utils-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-coze_coding_utils-0.2.0.dist-info/licenses/LICENSE,sha256=lzckZhAjHlpSJcWvppoST095IHFpBwKiB2pKcBv7vP4,1078
-coze_coding_utils-0.2.0.dist-info/RECORD,,