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

coze_coding_utils/error/codes.py

@@ -84,6 +84,7 @@ class ErrorCode(IntEnum):
     API_LLM_CONTENT_FILTER = 301007       # 内容过滤
     API_LLM_IMAGE_FORMAT = 301008         # 图片格式不支持
     API_LLM_VIDEO_FORMAT = 301009         # 视频格式不支持
+    API_PROJECT_NOT_FOUND = 301010        # 项目不存在
 
     # 302xxx - 图片生成API错误
     API_IMAGE_GEN_FAILED = 302001         # 图片生成失败
@@ -136,6 +137,7 @@ class ErrorCode(IntEnum):
     INTEGRATION_FEISHU_AUTH_FAILED = 501001  # 飞书认证失败
     INTEGRATION_FEISHU_API_FAILED = 501002   # 飞书API调用失败
     INTEGRATION_FEISHU_DOC_FAILED = 501003   # 飞书文档操作失败
+    INTEGRATION_FEISHU_TABLE_FAILED = 501004   # 飞书表格调用失败
 
     # 502xxx - 微信集成错误
     INTEGRATION_WECHAT_AUTH_FAILED = 502001  # 微信认证失败

coze_coding_utils/error/patterns.py

@@ -112,6 +112,14 @@ ERROR_PATTERNS: List[ErrorPattern] = [
     (['headobject operation', 'not found'],
      ErrorCode.RESOURCE_S3_DOWNLOAD_FAILED, "S3对象不存在"),
 
+    # ==================== 权益类错误 ====================
+    (['因触发限流调用内置集成失败',"限流"],
+     ErrorCode.API_LLM_RATE_LIMIT, "限流"),
+
+     (['project not found'],
+     ErrorCode.API_PROJECT_NOT_FOUND, "项目不存在"),
+
+
     # ==================== OCR/文档处理错误 ====================
     (['ocr识别失败', '无法从响应中提取有效的json'],
      ErrorCode.RESOURCE_FILE_FORMAT_ERROR, "OCR识别失败"),
@@ -261,7 +269,7 @@ ERROR_PATTERNS: List[ErrorPattern] = [
      ErrorCode.CONFIG_API_KEY_MISSING, "AWS凭证缺失"),
     (['生成pdf报告失败', 'stylesheet'],
      ErrorCode.RESOURCE_FILE_FORMAT_ERROR, "PDF样式错误"),
-    (['从数据库查询', '失败'],
+    (['从数据库查询'],
      ErrorCode.INTEGRATION_DB_QUERY, "数据库查询失败"),
     (['excel文件解析', '表格结构检测失败'],
      ErrorCode.RESOURCE_FILE_FORMAT_ERROR, "Excel解析失败"),
@@ -293,6 +301,8 @@ ERROR_PATTERNS: List[ErrorPattern] = [
      ErrorCode.INTEGRATION_DB_CONNECTION, "数据库连接已关闭"),
     (['psycopg2', 'postgresql'],
      ErrorCode.INTEGRATION_DB_QUERY, "数据库错误"),
+    (['数据库读取失败'],
+     ErrorCode.INTEGRATION_DB_CONNECTION, "数据库连接失败"),
 
     # ==================== 网络相关错误 ====================
     (['broken pipe', 'errno 32'],
@@ -365,6 +375,8 @@ ERROR_PATTERNS: List[ErrorPattern] = [
      ErrorCode.API_AUDIO_GEN_FAILED, "腾讯云TTS生成失败"),
 
     # ==================== 飞书相关错误 ====================
+    (['FeishuBitable API error'],
+     ErrorCode.INTEGRATION_FEISHU_TABLE_FAILED, "飞书Bitable API错误"),
     (['获取草稿列表失败'],
      ErrorCode.INTEGRATION_FEISHU_API_FAILED, "飞书获取草稿列表失败"),
     (['飞书api错误'],

coze_coding_utils/file/file.py

@@ -92,14 +92,6 @@ def infer_file_category(path_or_url: str) -> tuple[str, str]:
 class FileOps:
     DOWNLOAD_DIR = "/tmp"
 
-    @staticmethod
-    def read_content(file_obj:File, max_length=10000) -> str:
-        return ""
-
-    @staticmethod
-    def get_local_path(file_obj:File) -> str:
-        return file_obj.url
-
     @staticmethod
     def _get_bytes_stream(file_obj:File) -> tuple[bytes, str]:
         """

coze_coding_utils/helper/stream_runner.py

@@ -0,0 +1,563 @@
+import time
+import asyncio
+import threading
+import contextvars
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Iterator, AsyncIterable
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph.state import CompiledStateGraph
+from coze_coding_utils.helper.agent_helper import (
+    to_stream_input,
+    agent_iter_server_messages,
+)
+
+from coze_coding_utils.error import classify_error
+import asyncio
+import time
+import traceback
+from typing import Any, Dict, AsyncGenerator, Callable
+from coze_coding_utils.runtime_ctx.context import Context
+from coze_coding_utils.messages.server import (
+    create_message_end_dict,
+    create_message_error_dict,
+    MESSAGE_END_CODE_CANCELED,
+)
+from coze_coding_utils.helper.agent_helper import to_client_message
+from coze_coding_utils.error.classifier import ErrorClassifier
+
+logger = logging.getLogger(__name__)
+
+TIMEOUT_SECONDS = 900
+PING_INTERVAL_SECONDS = 30
+
+class WorkflowEventType:
+    WORKFLOW_START = "workflow_start"
+    WORKFLOW_END = "workflow_end"
+    NODE_START = "node_start" # 节点开始事件，只有debug模式发送
+    NODE_END = "node_end" # 节点结束事件，只有debug模式发送
+    ERROR = "error" # 错误事件
+    PING = "ping" # 心跳事件
+
+
+class WorkflowErrorCode:
+    CANCELED = "CANCELED" # 取消事件
+    TIMEOUT = "TIMEOUT" # 超时事件
+
+
+class BaseStreamRunner(ABC):
+    @abstractmethod
+    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> Iterator[Any]:
+        pass
+
+    @abstractmethod
+    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> AsyncIterable[Any]:
+        pass
+
+
+class AgentStreamRunner(BaseStreamRunner):
+    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> Iterator[Any]:
+        client_msg, session_id = to_client_message(payload)
+        run_config["recursion_limit"] = 100
+        run_config["configurable"] = {"thread_id": session_id}
+        stream_input = to_stream_input(client_msg)
+        t0 = time.time()
+        try:
+            items = graph.stream(stream_input, stream_mode="messages", config=run_config, context=ctx)
+            server_msgs_iter = agent_iter_server_messages(
+                items,
+                session_id=client_msg.session_id,
+                query_msg_id=client_msg.local_msg_id,
+                local_msg_id=client_msg.local_msg_id,
+                run_id=ctx.run_id,
+                log_id=ctx.logid,
+            )
+            for sm in server_msgs_iter:
+                yield sm.dict()
+        except asyncio.CancelledError:
+            logger.info(f"Stream cancelled for run_id: {ctx.run_id}")
+            end_msg = create_message_end_dict(
+                code=MESSAGE_END_CODE_CANCELED,
+                message="Stream execution cancelled",
+                session_id=client_msg.session_id,
+                query_msg_id=client_msg.local_msg_id,
+                log_id=ctx.logid,
+                time_cost_ms=int((time.time() - t0) * 1000),
+                reply_id="",
+                sequence_id=1,
+            )
+            yield end_msg
+            raise
+        except Exception as ex:
+            err = classify_error(ex, {"node_name": "stream"})
+            end_msg = create_message_error_dict(
+                code=str(err.code),
+                message=err.message,
+                session_id=client_msg.session_id,
+                query_msg_id=client_msg.local_msg_id,
+                log_id=ctx.logid,
+                reply_id="",
+                sequence_id=1,
+            )
+            yield end_msg
+
+    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> AsyncIterable[Any]:
+        client_msg, session_id = to_client_message(payload)
+        run_config["recursion_limit"] = 100
+        run_config["configurable"] = {"thread_id": session_id}
+        stream_input = to_stream_input(client_msg)
+
+        loop = asyncio.get_running_loop()
+        q: asyncio.Queue = asyncio.Queue()
+        context = contextvars.copy_context()
+        start_time = time.time()
+        cancelled = threading.Event()
+
+        def producer():
+            last_seq = 0
+            try:
+                if cancelled.is_set():
+                    logger.info(f"Producer cancelled before start for run_id: {ctx.run_id}")
+                    return
+
+                items = graph.stream(stream_input, stream_mode="messages", config=run_config, context=ctx)
+                server_msgs_iter = agent_iter_server_messages(
+                    items,
+                    session_id=client_msg.session_id,
+                    query_msg_id=client_msg.local_msg_id,
+                    local_msg_id=client_msg.local_msg_id,
+                    run_id=ctx.run_id,
+                    log_id=ctx.logid,
+                )
+                for sm in server_msgs_iter:
+                    if cancelled.is_set():
+                        logger.info(f"Producer cancelled during iteration for run_id: {ctx.run_id}")
+                        cancel_msg = create_message_end_dict(
+                            code=MESSAGE_END_CODE_CANCELED,
+                            message="Stream cancelled by upstream",
+                            session_id=client_msg.session_id,
+                            query_msg_id=client_msg.local_msg_id,
+                            log_id=ctx.logid,
+                            time_cost_ms=int((time.time() - start_time) * 1000),
+                            reply_id=getattr(sm, 'reply_id', ''),
+                            sequence_id=last_seq + 1,
+                        )
+                        loop.call_soon_threadsafe(q.put_nowait, cancel_msg)
+                        return
+
+                    if time.time() - start_time > TIMEOUT_SECONDS:
+                        logger.error(f"Agent execution timeout after {TIMEOUT_SECONDS}s for run_id: {ctx.run_id}")
+                        timeout_msg = create_message_end_dict(
+                            code="TIMEOUT",
+                            message=f"Execution timeout: exceeded {TIMEOUT_SECONDS} seconds",
+                            session_id=client_msg.session_id,
+                            query_msg_id=client_msg.local_msg_id,
+                            log_id=ctx.logid,
+                            time_cost_ms=int((time.time() - start_time) * 1000),
+                            reply_id=getattr(sm, 'reply_id', ''),
+                            sequence_id=last_seq + 1,
+                        )
+                        loop.call_soon_threadsafe(q.put_nowait, timeout_msg)
+                        return
+                    loop.call_soon_threadsafe(q.put_nowait, sm.dict())
+                    last_seq = sm.sequence_id
+            except Exception as ex:
+                if cancelled.is_set():
+                    logger.info(f"Producer exception after cancel for run_id: {ctx.run_id}, ignoring: {ex}")
+                    return
+                err = classify_error(ex, {"node_name": "astream"})
+                end_msg = create_message_error_dict(
+                    code=str(err.code),
+                    message=err.message,
+                    session_id=client_msg.session_id,
+                    query_msg_id=client_msg.local_msg_id,
+                    log_id=ctx.logid,
+                    reply_id="",
+                    sequence_id=last_seq + 1,
+                )
+                loop.call_soon_threadsafe(q.put_nowait, end_msg)
+            finally:
+                loop.call_soon_threadsafe(q.put_nowait, None)
+
+        threading.Thread(target=lambda: context.run(producer), daemon=True).start()
+
+        try:
+            while True:
+                item = await q.get()
+                if item is None:
+                    break
+                yield item
+        except asyncio.CancelledError:
+            logger.info(f"Stream cancelled for run_id: {ctx.run_id}, signaling producer to stop")
+            cancelled.set()
+            raise
+
+
+class WorkflowStreamRunner(BaseStreamRunner):
+    def __init__(self):
+        self._node_start_times: Dict[str, float] = {}
+
+    def _serialize_data(self, data: Any) -> Any:
+        if isinstance(data, dict):
+            return {k: self._serialize_data(v) for k, v in data.items()}
+        elif isinstance(data, (list, tuple)):
+            return [self._serialize_data(item) for item in data]
+        elif hasattr(data, 'model_dump'):
+            return data.model_dump()
+        elif hasattr(data, 'dict'):
+            return data.dict()
+        elif hasattr(data, '__dict__'):
+            return {k: self._serialize_data(v) for k, v in data.__dict__.items() if not k.startswith('_')}
+        else:
+            return data
+
+    def _build_event(self, event_type: str, ctx: Context, **kwargs) -> Dict[str, Any]:
+        result = {
+            "type": event_type,
+            "timestamp": int(time.time() * 1000),
+            "log_id": ctx.logid,
+            "run_id": ctx.run_id,
+        }
+        result.update(kwargs)
+        return result
+
+    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> Iterator[Any]:
+        run_config["recursion_limit"] = 100
+        if "configurable" not in run_config:
+            run_config["configurable"] = {}
+        run_config["configurable"]["thread_id"] = ctx.run_id
+        
+        t0 = time.time()
+        last_ping_time = t0
+        node_start_times: Dict[str, float] = {}
+        final_output = {}
+        seq = 0
+        is_debug = run_config.get("configurable", {}).get("workflow_debug", False)
+        stream_mode = "debug" if is_debug else "updates"
+
+        try:
+            seq += 1
+            yield (seq, self._build_event(WorkflowEventType.WORKFLOW_START, ctx))
+
+            for event in graph.stream(payload, stream_mode=stream_mode, config=run_config, context=ctx):
+                current_time = time.time()
+                if current_time - last_ping_time >= PING_INTERVAL_SECONDS:
+                    seq += 1
+                    yield (seq, self._build_event(WorkflowEventType.PING, ctx))
+                    last_ping_time = current_time
+                
+                if not is_debug:
+                    if isinstance(event, dict):
+                        logger.info(f"Debug event: {event}")
+                        for node_name, node_output in event.items():
+                            final_output = self._serialize_data(node_output) if node_output else {}
+                    continue
+
+                event_type = event.get("type", "")
+                
+                if event_type == "task":
+                    node_name = event.get("payload", {}).get("name", "")
+                    node_start_times[node_name] = current_time
+                    
+                    input_data = event.get("payload", {}).get("input", {})
+                    seq += 1
+                    yield (seq, self._build_event(
+                        WorkflowEventType.NODE_START,
+                        ctx,
+                        node_name=node_name,
+                        input=self._serialize_data(input_data),
+                    ))
+                    
+                elif event_type == "task_result":
+                    node_name = event.get("payload", {}).get("name", "")
+                    result = event.get("payload", {}).get("result")
+                    
+                    output_data = {}
+                    if result is not None:
+                        if isinstance(result, (list, tuple)) and len(result) > 0:
+                            output_data = self._serialize_data(result[0]) if len(result) == 1 else {"results": [self._serialize_data(r) for r in result]}
+                        else:
+                            output_data = self._serialize_data(result)
+                    
+                    final_output = output_data
+                    
+                    node_start_time = node_start_times.pop(node_name, current_time)
+                    time_cost_ms = int((current_time - node_start_time) * 1000)
+                    
+                    seq += 1
+                    yield (seq, self._build_event(
+                        WorkflowEventType.NODE_END,
+                        ctx,
+                        node_name=node_name,
+                        output=output_data,
+                        time_cost_ms=time_cost_ms,
+                    ))
+
+            seq += 1
+            yield (seq, self._build_event(
+                WorkflowEventType.WORKFLOW_END,
+                ctx,
+                output=final_output,
+                time_cost_ms=int((time.time() - t0) * 1000),
+            ))
+
+        except asyncio.CancelledError:
+            logger.info(f"Workflow stream cancelled for run_id: {ctx.run_id}")
+            seq += 1
+            yield (seq, self._build_event(WorkflowEventType.ERROR, ctx, code=WorkflowErrorCode.CANCELED, message="Stream execution cancelled"))
+            raise
+        except Exception as ex:
+            err = classify_error(ex, {"node_name": "workflow_stream"})
+            seq += 1
+            yield (seq, self._build_event(WorkflowEventType.ERROR, ctx, code=str(err.code), error_msg=err.message))
+
+    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> AsyncIterable[Any]:
+        run_config["recursion_limit"] = 100
+        if "configurable" not in run_config:
+            run_config["configurable"] = {}
+        run_config["configurable"]["thread_id"] = ctx.run_id
+
+        loop = asyncio.get_running_loop()
+        q: asyncio.Queue = asyncio.Queue()
+        context = contextvars.copy_context()
+        start_time = time.time()
+        cancelled = threading.Event()
+        last_ping_time = [start_time]
+        is_debug = run_config.get("configurable", {}).get("workflow_debug", False)
+        stream_mode = "debug" if is_debug else "updates"
+        logger.info(f"Stream mode: {stream_mode}")
+        seq = [0]
+
+        def producer():
+            node_start_times: Dict[str, float] = {}
+            final_output = {}
+            try:
+                if cancelled.is_set():
+                    logger.info(f"Workflow producer cancelled before start for run_id: {ctx.run_id}")
+                    return
+
+                seq[0] += 1
+                loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(WorkflowEventType.WORKFLOW_START, ctx)))
+
+                for event in graph.stream(payload, stream_mode=stream_mode, config=run_config, context=ctx):
+                    if cancelled.is_set():
+                        logger.info(f"Workflow producer cancelled during iteration for run_id: {ctx.run_id}")
+                        seq[0] += 1
+                        loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(WorkflowEventType.ERROR, ctx, code=WorkflowErrorCode.CANCELED, message="Stream cancelled by upstream")))
+                        return
+
+                    if time.time() - start_time > TIMEOUT_SECONDS:
+                        logger.error(f"Workflow execution timeout after {TIMEOUT_SECONDS}s for run_id: {ctx.run_id}")
+                        seq[0] += 1
+                        loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(WorkflowEventType.ERROR, ctx, code=WorkflowErrorCode.TIMEOUT, message=f"Execution timeout: exceeded {TIMEOUT_SECONDS} seconds")))
+                        return
+
+                    current_time = time.time()
+                    if current_time - last_ping_time[0] >= PING_INTERVAL_SECONDS:
+                        seq[0] += 1
+                        loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(WorkflowEventType.PING, ctx)))
+                        last_ping_time[0] = current_time
+
+                    if not is_debug:
+                        if isinstance(event, dict):
+                            for node_name, node_output in event.items():
+                                logger.info(f"Node output: {node_name}")
+                                final_output = self._serialize_data(node_output) if node_output else {}
+                        continue
+
+                    event_type = event.get("type", "")
+                    
+                    if event_type == "task":
+                        node_name = event.get("payload", {}).get("name", "")
+                        node_start_times[node_name] = current_time
+                        
+                        input_data = event.get("payload", {}).get("input", {})
+                        seq[0] += 1
+                        loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(
+                            WorkflowEventType.NODE_START,
+                            ctx,
+                            node_name=node_name,
+                            input=self._serialize_data(input_data),
+                        )))
+                        
+                    elif event_type == "task_result":
+                        node_name = event.get("payload", {}).get("name", "")
+                        result = event.get("payload", {}).get("result")
+                        
+                        output_data = {}
+                        if result is not None:
+                            if isinstance(result, (list, tuple)) and len(result) > 0:
+                                output_data = self._serialize_data(result[0]) if len(result) == 1 else {"results": [self._serialize_data(r) for r in result]}
+                            else:
+                                output_data = self._serialize_data(result)
+                        
+                        final_output = output_data
+                        
+                        node_start_time = node_start_times.pop(node_name, current_time)
+                        time_cost_ms = int((current_time - node_start_time) * 1000)
+                        
+                        seq[0] += 1
+                        loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(
+                            WorkflowEventType.NODE_END,
+                            ctx,
+                            node_name=node_name,
+                            output=output_data,
+                            time_cost_ms=time_cost_ms,
+                        )))
+
+                seq[0] += 1
+                loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(
+                    WorkflowEventType.WORKFLOW_END,
+                    ctx,
+                    output=final_output,
+                    time_cost_ms=int((time.time() - start_time) * 1000),
+                )))
+
+            except Exception as ex:
+                if cancelled.is_set():
+                    logger.info(f"Workflow producer exception after cancel for run_id: {ctx.run_id}, ignoring: {ex}")
+                    return
+                err = classify_error(ex, {"node_name": "workflow_astream"})
+                seq[0] += 1
+                loop.call_soon_threadsafe(q.put_nowait, (seq[0], self._build_event(WorkflowEventType.ERROR, ctx, code=str(err.code), error_msg=err.message)))
+            finally:
+                loop.call_soon_threadsafe(q.put_nowait, None)
+
+        async def ping_sender():
+            while not cancelled.is_set():
+                await asyncio.sleep(PING_INTERVAL_SECONDS)
+                if cancelled.is_set():
+                    break
+                current_time = time.time()
+                if current_time - last_ping_time[0] >= PING_INTERVAL_SECONDS:
+                    seq[0] += 1
+                    await q.put((seq[0], self._build_event(WorkflowEventType.PING, ctx)))
+                    last_ping_time[0] = current_time
+
+        threading.Thread(target=lambda: context.run(producer), daemon=True).start()
+        ping_task = asyncio.create_task(ping_sender())
+
+        try:
+            while True:
+                item = await q.get()
+                if item is None:
+                    break
+                yield item
+        except asyncio.CancelledError:
+            logger.info(f"Workflow stream cancelled for run_id: {ctx.run_id}, signaling producer to stop")
+            cancelled.set()
+            raise
+        finally:
+            cancelled.set()
+            ping_task.cancel()
+            try:
+                await ping_task
+            except asyncio.CancelledError:
+                pass
+
+
+async def agent_stream_handler(
+    payload: Dict[str, Any],
+    ctx: Context,
+    run_id: str,
+    stream_sse_func: Callable,
+    sse_event_func: Callable,
+    error_classifier: ErrorClassifier,
+    register_task_func: Callable[[str, asyncio.Task], None],
+) -> AsyncGenerator[str, None]:
+    task = asyncio.current_task()
+    if task:
+        register_task_func(run_id, task)
+        logger.info(f"Registered agent streaming task for run_id: {run_id}")
+
+    client_msg, _ = to_client_message(payload)
+    t0 = time.time()
+
+    try:
+        async for chunk in stream_sse_func(payload, ctx, need_detail=False):
+            yield chunk
+    except asyncio.CancelledError:
+        logger.info(f"Agent stream cancelled for run_id: {run_id}")
+        end_msg = create_message_end_dict(
+            code=MESSAGE_END_CODE_CANCELED,
+            message="Stream cancelled by user",
+            session_id=client_msg.session_id,
+            query_msg_id=client_msg.local_msg_id,
+            log_id=ctx.logid,
+            time_cost_ms=int((time.time() - t0) * 1000),
+            reply_id="",
+            sequence_id=1,
+        )
+        yield sse_event_func(end_msg)
+        raise
+    except Exception as ex:
+        err = error_classifier.classify(ex, {"node_name": "agent_stream", "run_id": run_id})
+        logger.error(
+            f"Unexpected error in agent_stream: [{err.code}] {err.message}, "
+            f"traceback: {traceback.format_exc()}"
+        )
+        error_msg = create_message_error_dict(
+            code=str(err.code),
+            message=str(ex),
+            session_id=client_msg.session_id,
+            query_msg_id=client_msg.local_msg_id,
+            log_id=ctx.logid,
+            reply_id="",
+            sequence_id=1,
+            local_msg_id=client_msg.local_msg_id,
+        )
+        yield sse_event_func(error_msg)
+
+
+async def workflow_stream_handler(
+    payload: Dict[str, Any],
+    ctx: Context,
+    run_id: str,
+    stream_sse_func: Callable,
+    sse_event_func: Callable,
+    error_classifier: ErrorClassifier,
+    register_task_func: Callable[[str, asyncio.Task], None],
+    workflow_debug: bool = False,
+) -> AsyncGenerator[str, None]:
+    task = asyncio.current_task()
+    if task:
+        register_task_func(run_id, task)
+        logger.info(f"Registered workflow streaming task for run_id: {run_id}")
+
+    try:
+        async for chunk in stream_sse_func(payload, ctx, need_detail=workflow_debug):
+            yield chunk
+    except asyncio.CancelledError:
+        logger.info(f"Workflow stream cancelled for run_id: {run_id}")
+        cancel_event = {
+            "type": "error",
+            "timestamp": int(time.time() * 1000),
+            "log_id": ctx.logid,
+            "run_id": run_id,
+            "code": "CANCELED",
+            "error_msg": "Stream cancelled by user",
+        }
+        yield sse_event_func(cancel_event)
+        raise
+    except Exception as ex:
+        err = error_classifier.classify(ex, {"node_name": "workflow_stream", "run_id": run_id})
+        logger.error(
+            f"Unexpected error in workflow_stream: [{err.code}] {err.message}, "
+            f"traceback: {traceback.format_exc()}"
+        )
+        error_event = {
+            "type": "error",
+            "timestamp": int(time.time() * 1000),
+            "log_id": ctx.logid,
+            "run_id": run_id,
+            "code": str(err.code),
+            "error_msg": str(ex),
+        }
+        yield sse_event_func(error_event)
+
+
+def get_stream_runner(is_agent: bool) -> BaseStreamRunner:
+    if is_agent:
+        return AgentStreamRunner()
+    else:
+        return WorkflowStreamRunner()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coze-coding-utils
-Version: 0.2.2a1
+Version: 0.2.3
 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

{coze_coding_utils-0.2.2a1.dist-info → coze_coding_utils-0.2.3.dist-info}/RECORD

@@ -1,15 +1,16 @@
 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/codes.py,sha256=IdSRHoWlwaIzfzUswmjT_lGS04_RHaHjSJUbV2DIhEA,17162
 coze_coding_utils/error/exceptions.py,sha256=QjGk56ovGG-2V4gHcTeJq3-3ZIQQ8DF692zgIYcEJxI,17074
-coze_coding_utils/error/patterns.py,sha256=YhhBcCoWQuvSbtA271eS3AB81pChypD7nDrPidQDu0s,44412
+coze_coding_utils/error/patterns.py,sha256=_Z_CtsiVng6dQnqWQwYxKrZm_DrLNYL8tw5_oO5I8x8,44871
 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/file/file.py,sha256=fBda18EGSQZ3Xl8OqEaGAb5Rd90_SmhJ1k0jgQk2v7Y,11636
 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/helper/stream_runner.py,sha256=f66n6QJ3zCakhk7Fe4Vz9vTZ2KJuM9v9UJfqX5S3nDA,24050
 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
@@ -31,7 +32,7 @@ coze_coding_utils/openai/types/request.py,sha256=IuNMT2Ce1--_32R30Q2q7Lb2dAwKNy3
 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.3.dist-info/METADATA,sha256=-V3YwNo9i5Z6nlEz92Gy-l_Kg_X4yZ01M4_CtgsEjG4,977
+coze_coding_utils-0.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+coze_coding_utils-0.2.3.dist-info/licenses/LICENSE,sha256=lzckZhAjHlpSJcWvppoST095IHFpBwKiB2pKcBv7vP4,1078
+coze_coding_utils-0.2.3.dist-info/RECORD,,