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

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coze-coding-utils"
-version = "0.2.3a3"
+version = "0.2.5"
 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.5}/src/coze_coding_utils/helper/agent_helper.py

@@ -1,7 +1,8 @@
 import uuid
 import json
-import os
-from typing import Any, Dict, List, Tuple, Iterator
+import requests
+from urllib.parse import urlparse, urlencode, parse_qs, urljoin
+from typing import Any, Dict, List, Tuple, Iterator, Optional
 import time
 from coze_coding_utils.file.file import File, FileOps, infer_file_category
 from coze_coding_utils.error import classify_error
@@ -31,6 +32,78 @@ from coze_coding_utils.messages.server import (
 )
 
 
+_VIDEO_MIME_MAP: Dict[str, str] = {
+    "mp4": "video/mp4",
+    "avi": "video/x-msvideo",
+    "mov": "video/quicktime",
+    "mkv": "video/x-matroska",
+    "flv": "video/x-flv",
+    "wmv": "video/x-ms-wmv",
+    "webm": "video/webm",
+    "m4v": "video/x-m4v",
+    "3gp": "video/3gpp",
+}
+
+# 下游 LLM API 实际支持的视频 MIME 类型白名单
+_SUPPORTED_VIDEO_MIMES = {
+    "video/mp4",
+    "video/quicktime",
+    "video/webm",
+    "video/3gpp",
+    "video/x-m4v",
+}
+
+
+def _probe_remote_mime(url: str) -> Optional[str]:
+    """HEAD 请求探测远程文件的真实 Content-Type，失败时返回 None"""
+    try:
+        resp = requests.head(url, timeout=5, allow_redirects=True)
+        ct = resp.headers.get("Content-Type", "")
+        return ct.split(";")[0].strip() or None
+    except Exception:
+        return None
+
+
+def _ensure_video_content_type(url: str, mime_type: str) -> str:
+    """
+    对象存储（TOS/S3）的 presigned URL 可能返回 application/octet-stream。
+    通过追加 response-content-type 参数让服务端在响应中覆盖 Content-Type，
+    从而使 LLM API fetch URL 时能拿到正确的 video MIME，而不会因 octet-stream 被拒。
+    已有签名不受影响（TOS/S3 response-* 参数不计入签名哈希）。
+    """
+    parsed = urlparse(url)
+    # 已经有正确的 response-content-type，不重复添加
+    qs = parse_qs(parsed.query, keep_blank_values=True)
+    if qs.get("response-content-type") == [mime_type]:
+        return url
+    sep = "&" if parsed.query else "?"
+    return url + sep + "response-content-type=" + requests.utils.quote(mime_type, safe="")
+
+
+def _build_video_parts(
+    file_data: File, file_info: Any, file_ext: str, mime_override: Optional[str] = None
+) -> List[Dict[str, Any]]:
+    """将视频文件转换为 content_parts，不支持的格式退化为文本描述。
+    mime_override: 外部已探测好的 MIME，传入时跳过内部探测，避免重复 HEAD 请求。
+    """
+    ext = file_ext.lstrip(".").lower()
+    mime_type = mime_override or _VIDEO_MIME_MAP.get(ext)
+    if not mime_type and file_data.is_remote:
+        mime_type = _probe_remote_mime(file_info.url)
+
+    if mime_type and mime_type in _SUPPORTED_VIDEO_MIMES:
+        # 追加 response-content-type 参数，确保对象存储返回正确的 Content-Type
+        # 防止 LLM API fetch URL 时因拿到 application/octet-stream 而报错
+        video_url = _ensure_video_content_type(file_info.url, mime_type) if file_data.is_remote else file_info.url
+        return [
+            {"type": "text", "text": f'{file_data.url}'},
+            {"type": "video_url", "video_url": {"url": video_url, "media_type": mime_type}},
+        ]
+    else:
+        fmt_hint = mime_type or (f".{ext}" if ext else "unknown")
+        return [{"type": "text", "text": f"video url: {file_info.url} (format: {fmt_hint})"}]
+
+
 def to_stream_input(msg: ClientMessage) -> Dict[str, Any]:
     content_parts = []
     if msg and msg.content and msg.content.query and msg.content.query.prompt:
@@ -43,7 +116,23 @@ def to_stream_input(msg: ClientMessage) -> Dict[str, Any]:
                     and block.content.upload_file
             ):
                 file_info = block.content.upload_file
-                file_type, _ = infer_file_category(file_info.url)
+                # 第一轮：从 URL 后缀识别类型
+                file_type, file_ext = infer_file_category(file_info.url)
+                # 第二轮：URL 无后缀时用 file_name 兜底
+                if file_type == "default" and file_info.file_name:
+                    file_type, file_ext = infer_file_category(file_info.file_name)
+                # 第三轮：两轮扩展名都无法识别时，HEAD 探测真实 Content-Type
+                probed_mime: Optional[str] = None
+                if file_type == "default" and file_info.url.startswith(("http://", "https://")):
+                    probed_mime = _probe_remote_mime(file_info.url)
+                    if probed_mime:
+                        top = probed_mime.split("/")[0]
+                        if top == "video":
+                            file_type = "video"
+                        elif top == "image":
+                            file_type = "image"
+                        elif top == "audio":
+                            file_type = "audio"
                 file_data = File(url=file_info.url, file_type=file_type)
                 # check is image
                 if file_data.file_type == "image":
@@ -61,18 +150,7 @@ def to_stream_input(msg: ClientMessage) -> Dict[str, Any]:
                     )
                 # check is video
                 elif file_data.file_type == "video":
-                    content_parts.append(
-                        {
-                            "type": "text",
-                            "text": f'{file_data.url}'
-                        }
-                    )
-                    content_parts.append(
-                        {
-                            "type": "video_url",
-                            "video_url": {"url": file_info.url},
-                        }
-                    )
+                    content_parts.extend(_build_video_parts(file_data, file_info, file_ext, probed_mime))
                 # check is audio
                 elif file_data.file_type == "audio":
                     content_parts.append(

{coze_coding_utils-0.2.3a3 → coze_coding_utils-0.2.5}/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.5}/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

{coze_coding_utils-0.2.3a3 → coze_coding_utils-0.2.5}/src/coze_coding_utils/openai/converter/request_converter.py

@@ -6,6 +6,10 @@ from coze_coding_utils.openai.types.request import (
     ChatMessage,
 )
 from coze_coding_utils.file.file import File, FileOps, infer_file_category
+from coze_coding_utils.helper.agent_helper import (
+    _VIDEO_MIME_MAP,
+    _ensure_video_content_type,
+)
 
 
 class RequestConverter:
@@ -110,6 +114,15 @@ class RequestConverter:
             video_url_data = part.get("video_url", {})
             url = video_url_data.get("url", "")
             if url:
+                _, file_ext = infer_file_category(url)
+                ext = file_ext.lstrip(".").lower()
+                mime_type = _VIDEO_MIME_MAP.get(ext)
+                if mime_type:
+                    fixed_url = _ensure_video_content_type(url, mime_type)
+                    return [
+                        {"type": "text", "text": url},
+                        {"type": "video_url", "video_url": {"url": fixed_url, "media_type": mime_type}},
+                    ]
                 return [
                     {"type": "text", "text": url},
                     {"type": "video_url", "video_url": {"url": url}},
@@ -147,6 +160,15 @@ class RequestConverter:
                     {"type": "image_url", "image_url": {"url": url}},
                 ]
             elif file_type == "video":
+                _, file_ext = infer_file_category(url)
+                ext = file_ext.lstrip(".").lower()
+                mime_type = _VIDEO_MIME_MAP.get(ext)
+                if mime_type:
+                    fixed_url = _ensure_video_content_type(url, mime_type)
+                    return [
+                        {"type": "text", "text": url},
+                        {"type": "video_url", "video_url": {"url": fixed_url, "media_type": mime_type}},
+                    ]
                 return [
                     {"type": "text", "text": url},
                     {"type": "video_url", "video_url": {"url": url}},