coze-coding-utils 0.2.3a1__tar.gz → 0.2.3a3__tar.gz

{coze_coding_utils-0.2.3a1 → coze_coding_utils-0.2.3a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coze-coding-utils
-Version: 0.2.3a1
+Version: 0.2.3a3
 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.3a1 → coze_coding_utils-0.2.3a3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coze-coding-utils"
-version = "0.2.3a1"
+version = "0.2.3a3"
 description = "Utilities for Coze coding client runtime context and helpers."
 readme = "README.md"
 requires-python = ">=3.10"

{coze_coding_utils-0.2.3a1 → coze_coding_utils-0.2.3a3}/src/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-0.2.3a1 → coze_coding_utils-0.2.3a3}/src/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-0.2.3a1 → coze_coding_utils-0.2.3a3}/src/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-0.2.3a1 → coze_coding_utils-0.2.3a3}/src/coze_coding_utils/helper/stream_runner.py

@@ -7,24 +7,30 @@ 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.runtime_ctx.context import Context
 from coze_coding_utils.helper.agent_helper import (
     to_stream_input,
-    to_client_message,
     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 (
-    MESSAGE_END_CODE_CANCELED,
     create_message_end_dict,
+    create_message_error_dict,
+    MESSAGE_END_CODE_CANCELED,
 )
-from coze_coding_utils.error import classify_error
+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"
@@ -84,13 +90,12 @@ class AgentStreamRunner(BaseStreamRunner):
             raise
         except Exception as ex:
             err = classify_error(ex, {"node_name": "stream"})
-            end_msg = create_message_end_dict(
+            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,
-                time_cost_ms=int((time.time() - t0) * 1000),
                 reply_id="",
                 sequence_id=1,
             )
@@ -161,13 +166,12 @@ class AgentStreamRunner(BaseStreamRunner):
                     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_end_dict(
+                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,
-                    time_cost_ms=int((time.time() - start_time) * 1000),
                     reply_id="",
                     sequence_id=last_seq + 1,
                 )
@@ -305,7 +309,7 @@ class WorkflowStreamRunner(BaseStreamRunner):
         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), message=err.message))
+            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
@@ -415,7 +419,7 @@ class WorkflowStreamRunner(BaseStreamRunner):
                     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), message=err.message)))
+                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)
 
@@ -452,6 +456,106 @@ class WorkflowStreamRunner(BaseStreamRunner):
                 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()