coze-coding-utils 0.2.3a3__tar.gz → 0.2.4__tar.gz

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

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

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

{coze_coding_utils-0.2.3a3 → coze_coding_utils-0.2.4}/src/coze_coding_utils/helper/stream_runner.py

@@ -4,7 +4,8 @@ import threading
 import contextvars
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Iterator, AsyncIterable
+from dataclasses import dataclass
+from typing import Any, Dict, Iterator, AsyncIterable, Optional, Literal
 from langchain_core.runnables import RunnableConfig
 from langgraph.graph.state import CompiledStateGraph
 from coze_coding_utils.helper.agent_helper import (
@@ -31,6 +32,15 @@ logger = logging.getLogger(__name__)
 TIMEOUT_SECONDS = 900
 PING_INTERVAL_SECONDS = 30
 
+
+@dataclass
+class RunOpt:
+    workflow_debug: bool = False
+
+    @property
+    def stream_mode(self) -> Literal["debug", "updates"]:
+        return "debug" if self.workflow_debug else "updates"
+
 class WorkflowEventType:
     WORKFLOW_START = "workflow_start"
     WORKFLOW_END = "workflow_end"
@@ -47,16 +57,16 @@ class WorkflowErrorCode:
 
 class BaseStreamRunner(ABC):
     @abstractmethod
-    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> Iterator[Any]:
+    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context, run_opt: Optional[RunOpt] = None) -> Iterator[Any]:
         pass
 
     @abstractmethod
-    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> AsyncIterable[Any]:
+    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context, run_opt: Optional[RunOpt] = None) -> AsyncIterable[Any]:
         pass
 
 
 class AgentStreamRunner(BaseStreamRunner):
-    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> Iterator[Any]:
+    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context, run_opt: Optional[RunOpt] = None) -> Iterator[Any]:
         client_msg, session_id = to_client_message(payload)
         run_config["recursion_limit"] = 100
         run_config["configurable"] = {"thread_id": session_id}
@@ -101,7 +111,7 @@ class AgentStreamRunner(BaseStreamRunner):
             )
             yield end_msg
 
-    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> AsyncIterable[Any]:
+    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context, run_opt: Optional[RunOpt] = None) -> AsyncIterable[Any]:
         client_msg, session_id = to_client_message(payload)
         run_config["recursion_limit"] = 100
         run_config["configurable"] = {"thread_id": session_id}
@@ -194,9 +204,6 @@ class AgentStreamRunner(BaseStreamRunner):
 
 
 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()}
@@ -221,7 +228,9 @@ class WorkflowStreamRunner(BaseStreamRunner):
         result.update(kwargs)
         return result
 
-    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context) -> Iterator[Any]:
+    def stream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context, run_opt: Optional[RunOpt] = None) -> Iterator[Any]:
+        if run_opt is None:
+            run_opt = RunOpt()
         run_config["recursion_limit"] = 100
         if "configurable" not in run_config:
             run_config["configurable"] = {}
@@ -232,21 +241,19 @@ class WorkflowStreamRunner(BaseStreamRunner):
         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):
+            for event in graph.stream(payload, stream_mode=run_opt.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 not run_opt.workflow_debug:
                     if isinstance(event, dict):
                         logger.info(f"Debug event: {event}")
                         for node_name, node_output in event.items():
@@ -311,7 +318,9 @@ class WorkflowStreamRunner(BaseStreamRunner):
             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]:
+    async def astream(self, payload: Dict[str, Any], graph: CompiledStateGraph, run_config: RunnableConfig, ctx: Context, run_opt: Optional[RunOpt] = None) -> AsyncIterable[Any]:
+        if run_opt is None:
+            run_opt = RunOpt()
         run_config["recursion_limit"] = 100
         if "configurable" not in run_config:
             run_config["configurable"] = {}
@@ -323,9 +332,7 @@ class WorkflowStreamRunner(BaseStreamRunner):
         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}")
+        logger.info(f"Stream mode: {run_opt.stream_mode}")
         seq = [0]
 
         def producer():
@@ -339,7 +346,7 @@ class WorkflowStreamRunner(BaseStreamRunner):
                 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):
+                for event in graph.stream(payload, stream_mode=run_opt.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
@@ -358,7 +365,7 @@ class WorkflowStreamRunner(BaseStreamRunner):
                         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 not run_opt.workflow_debug:
                         if isinstance(event, dict):
                             for node_name, node_output in event.items():
                                 logger.info(f"Node output: {node_name}")
@@ -474,7 +481,7 @@ async def agent_stream_handler(
     t0 = time.time()
 
     try:
-        async for chunk in stream_sse_func(payload, ctx, need_detail=False):
+        async for chunk in stream_sse_func(payload, ctx):
             yield chunk
     except asyncio.CancelledError:
         logger.info(f"Agent stream cancelled for run_id: {run_id}")
@@ -517,15 +524,17 @@ async def workflow_stream_handler(
     sse_event_func: Callable,
     error_classifier: ErrorClassifier,
     register_task_func: Callable[[str, asyncio.Task], None],
-    workflow_debug: bool = False,
+    run_opt: Optional[RunOpt] = None,
 ) -> AsyncGenerator[str, None]:
+    if run_opt is None:
+        run_opt = RunOpt()
     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):
+        async for chunk in stream_sse_func(payload, ctx, run_opt):
             yield chunk
     except asyncio.CancelledError:
         logger.info(f"Workflow stream cancelled for run_id: {run_id}")

{coze_coding_utils-0.2.3a3 → coze_coding_utils-0.2.4}/src/coze_coding_utils/log/node_log.py

@@ -1,7 +1,6 @@
 import time
 import logging
 from uuid import UUID
-from openai import BaseModel
 from coze_coding_utils.log.config import LOG_DIR
 from coze_coding_utils.log.common import get_execute_mode, is_prod
 import uuid