add to_runnable decorator & lcc tool message add name and tool_call_id

Author: JqRrt

CHANGLOG.md

@@ -1,3 +1,8 @@
+## [0.1.25] - 2026-01-22
+### Added
+- add to_runnable decorator
+- lcc tool message add name and tool_call_id
+
 ## [0.1.24] - 2026-01-16
 ### Added
 - client init set default client if not exist

cozeloop/decorator/__init__.py

@@ -5,3 +5,4 @@
 
 coze_loop_decorator= CozeLoopDecorator()
 observe = coze_loop_decorator.observe
+to_runnable = coze_loop_decorator.to_runnable

cozeloop/decorator/decorator.py

@@ -4,6 +4,8 @@
 from typing import Optional, Callable, Any, overload, Dict, Generic, Iterator, TypeVar, List, cast, AsyncIterator
 from functools import wraps
 
+from langchain_core.runnables import RunnableLambda, RunnableConfig
+
 from cozeloop import Client, Span, start_span
 from cozeloop.decorator.utils import is_async_func, is_gen_func, is_async_gen_func, is_class_func
 
@@ -312,6 +314,150 @@ async def async_stream_wrapper(*args: Any, **kwargs: Any):
             return decorator(func)
 
 
+    def to_runnable(
+            self,
+            func: Callable = None,
+    ) -> Callable:
+        """
+        Decorator to be RunnableLambda.
+
+        :param func: The function to be decorated, Requirements are as follows：
+                     1. When the func is called, parameter config(RunnableConfig) is required, you must use the config containing cozeloop callback handler of 'current request', otherwise, the trace may be lost!
+
+        Examples:
+            @to_runnable
+            def runnable_func(my_input: dict) -> str:
+                return input
+
+            async def scorer_leader(state: MyState) -> dict | str:
+                await runnable_func({"a": "111", "b": 222, "c": "333"}, config=state.config) # config is required
+        """
+
+        def decorator(func: Callable):
+
+            @wraps(func)
+            def sync_wrapper(*args: Any, **kwargs: Any):
+                config = _get_config(**kwargs)
+                res = None
+                try:
+                    inp = {
+                        "args": args,
+                        "kwargs": kwargs
+                    }
+                    res = RunnableLambda(_param_wrapped_func).invoke(input=inp, config=config, **kwargs)
+                    if hasattr(res, "__iter__"):
+                        return res
+                except StopIteration:
+                    pass
+                except Exception as e:
+                    raise e
+                finally:
+                    if res is not None:
+                        return res
+
+            @wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any):
+                config = _get_config(**kwargs)
+                res = None
+                try:
+                    inp = {
+                        "args": args,
+                        "kwargs": kwargs
+                    }
+                    res = await RunnableLambda(_param_wrapped_func_async).ainvoke(input=inp, config=config, **kwargs)
+                    if hasattr(res, "__aiter__"):
+                        return res
+                except StopIteration:
+                    pass
+                except StopAsyncIteration:
+                    pass
+                except Exception as e:
+                    if e.args and e.args[0] == 'coroutine raised StopIteration':  # coroutine StopIteration
+                        pass
+                    else:
+                        raise e
+                finally:
+                    if res is not None:
+                        return res
+
+            @wraps(func)
+            def gen_wrapper(*args: Any, **kwargs: Any):
+                config = _get_config(**kwargs)
+                try:
+                    inp = {
+                        "args": args,
+                        "kwargs": kwargs
+                    }
+                    gen = RunnableLambda(_param_wrapped_func).invoke(input=inp, config=config, **kwargs)
+                    try:
+                        for item in gen:
+                            yield item
+                    except StopIteration:
+                        pass
+                except Exception as e:
+                    raise e
+
+            @wraps(func)
+            async def async_gen_wrapper(*args: Any, **kwargs: Any):
+                config = _get_config(**kwargs)
+                try:
+                    inp = {
+                        "args": args,
+                        "kwargs": kwargs
+                    }
+                    gen = RunnableLambda(_param_wrapped_func_async).invoke(input=inp, config=config, **kwargs)
+                    items = []
+                    try:
+                        async for item in gen:
+                            items.append(item)
+                            yield item
+                    finally:
+                        pass
+                except StopIteration:
+                    pass
+                except StopAsyncIteration:
+                    pass
+                except Exception as e:
+                    if e.args and e.args[0] == 'coroutine raised StopIteration':
+                        pass
+                    else:
+                        raise e
+
+            # for convert parameter
+            def _param_wrapped_func(input_dict: dict) -> Any:
+                args = input_dict.get("args", ())
+                kwargs = input_dict.get("kwargs", {})
+                return func(*args, **kwargs)
+
+            async def _param_wrapped_func_async(input_dict: dict) -> Any:
+                args = input_dict.get("args", ())
+                kwargs = input_dict.get("kwargs", {})
+                return await func(*args, **kwargs)
+
+            def _get_config(**kwargs: Any) -> RunnableConfig | None:
+                config = kwargs.pop("config", None)
+                if config is None:
+                    config = RunnableConfig(run_name=func.__name__)
+                    config['run_name'] = func.__name__
+                elif isinstance(config, dict):
+                    config['run_name'] = func.__name__
+                return config
+
+            if is_async_gen_func(func):
+                return async_gen_wrapper
+            if is_gen_func(func):
+                return gen_wrapper
+            elif is_async_func(func):
+                return async_wrapper
+            else:
+                return sync_wrapper
+
+        if func is None:
+            return decorator
+        else:
+            return decorator(func)
+
+
 class _CozeLoopTraceStream(Generic[S]):
     def __init__(
             self,

cozeloop/integration/langchain/trace_model/llm_model.py

@@ -53,6 +53,8 @@ class Message:
     tool_calls: List[ToolCall] = None
     metadata: Optional[dict] = None
     reasoning_content: Optional[str] = None
+    name: Optional[str] = None
+    tool_call_id: Optional[str] = None
 
     def __post_init__(self):
         if self.role is not None and (self.role == 'AIMessageChunk' or self.role == 'ai'):
@@ -155,7 +157,7 @@ def __init__(self, messages: List[Union[BaseMessage, List[BaseMessage]]], invoca
                 if message.additional_kwargs is not None and message.additional_kwargs.get('name', ''):
                     name = message.additional_kwargs.get('name', '')
                 tool_call = ToolCall(id=message.tool_call_id, type=message.type, function=ToolFunction(name=name))
-                self._messages.append(Message(role=message.type, content=message.content, tool_calls=[tool_call]))
+                self._messages.append(Message(role=message.type, content=message.content, tool_calls=[tool_call], name=name, tool_call_id=message.tool_call_id))
             else:
                 self._messages.append(Message(role=message.type, content=message.content))
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cozeloop"
-version = "0.1.24"
+version = "0.1.25"
 description = "coze loop sdk"
 authors = ["JiangQi715 <jiangqi.rrt@bytedance.com>"]
 license = "MIT"