@brandon_9527/tcode 1.0.3 → 1.0.7

package/dist/python-src/entry.py

@@ -6,37 +6,79 @@
 #     main()
 
 
-# ===================== 强制修复 Git Bash 报错：NoConsoleScreenBufferError =====================
-import os
-import sys
+# # ===================== 强制修复 Git Bash 报错：NoConsoleScreenBufferError =====================
+# import os
+# import sys
 
-# 🔥 核心：强制让 prompt_toolkit 使用兼容模式，彻底关闭 Windows 控制台检测
-os.environ["PROMPT_TOOLKIT_NO_WIN32"] = "1"
-os.environ["PROMPT_TOOLKIT_BASIC_OUTPUT"] = "1"
-os.environ["PROMPT_TOOLKIT_FORCE_VT100"] = "1"
+# # 🔥 核心：强制让 prompt_toolkit 使用兼容模式，彻底关闭 Windows 控制台检测
+# os.environ["PROMPT_TOOLKIT_NO_WIN32"] = "1"
+# os.environ["PROMPT_TOOLKIT_BASIC_OUTPUT"] = "1"
+# os.environ["PROMPT_TOOLKIT_FORCE_VT100"] = "1"
 
-# 🔥 强制设置终端类型，让程序认为是 Linux 终端
-if sys.platform == "win32":
-    os.environ["TERM"] = "xterm-256color"
+# # 🔥 强制设置终端类型，让程序认为是 Linux 终端
+# if sys.platform == "win32":
+#     os.environ["TERM"] = "xterm-256color"
 
-# ===================== 下面才是你原来的代码 =====================
+# # ===================== 下面才是你原来的代码 =====================
 
 
 import warnings
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 warnings.filterwarnings("ignore", message="Pydantic serializer warnings")
 
+
+import typer
+import asyncio
+
+
 from main import (
     agent_ui, 
     asingle_agent,
     team_main,
+    run_once,
+    teminal_chat
 )
 
+app = typer.Typer()
+interact_app = typer.Typer()
+app.add_typer(interact_app)
+
+
+@app.callback(invoke_without_command=True, no_args_is_help=False)
+def root(
+    ctx: typer.Context,
+    prompt: str = typer.Option(None, "-p", "--prompt", help="用户输入请求内容"),
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="显示agent执行详细过程"),
+    mode: str = typer.Option("team", "-m", "--mode", help="运行模式，single或team"),
+):
+    if ctx.invoked_subcommand is None:
+        if not prompt:
+            if mode == "single":
+                asyncio.run(asingle_agent())
+            elif mode == "team":
+                asyncio.run(team_main())
+            
+        # 同步环境执行异步任务
+        asyncio.run(run_once(prompt, verbose))
+        # typer.echo(result)
+        # raise typer.Exit()
+    
+
+@interact_app.command("interact")
+def interact_mode(
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="显示agent执行详细过程"),
+):
+    # 执行交互模式
+    asyncio.run(teminal_chat(verbose))
+
+
+
 if __name__ == "__main__":
-    import asyncio
+    app()
+    # import asyncio
     
-    try:
-        asyncio.run(asingle_agent())
-        # asyncio.run(team_main())
-    except Exception as e:
-        pass
+    # try:
+    #     # asyncio.run(asingle_agent())
+    #     asyncio.run(team_main())
+    # except Exception as e:
+    #     pass

package/dist/python-src/main.py

@@ -328,14 +328,15 @@ async def team_main():
     
     def _build_team(agents_conf: Dict[str, Any], domain: str, llm: ChatOpenAI, toolkits: Dict[str, List[BaseTool]], workspace: str, saver=None, store=None, recursion_limit=1000):
         """ """
-        team_conf = agents_conf[domain]
+    
+        team_conf = agents_conf.setdefault(domain, {"members":{}})
         
         # for mname, mconf in team_conf['members'].items():
         #     print(f"member_name: {mname}, member: {mconf}")
             
         agents = []
         for member_name, member in team_conf["members"].items():
-            print(f"member_name: {member_name}, member: {member}")
+            # print(f"member_name: {member_name}, member: {member}")
             
             tools = []
             for tool_name in member["tools"]:
@@ -404,8 +405,7 @@ async def team_main():
     await ui.run_async()
     
     
-async def teminal_chat():
-    """ """
+def build_team():
     from dataclasses import dataclass, field
     from pathlib import Path
     
@@ -414,8 +414,6 @@ async def teminal_chat():
     from src.utils.prompt import apply_template, apply_prompt
     from src.managers.sandbox import Container
     from src.prompts.prompts import leader
-    from src.stream.handler import ainput, anormal_handler
-    
     from src.tools.tools import (
         SkillAgentContext,
         shell, 
@@ -431,13 +429,15 @@ async def teminal_chat():
     from src.tools.web import (
         web_search,
         web_fetch
-    )
-    
+    )    
+    from src.middlewares.dynamic_content import DynamicContentMiddleware
+
     from langgraph.checkpoint.memory import MemorySaver
-    from langchain_core.messages import HumanMessage
     from langchain_core.tools import BaseTool
     
     
+    
+    
     def _prepare(workspace, run_mode, session_id):
         saver = MemorySaver()
         
@@ -493,14 +493,14 @@ async def teminal_chat():
     
     def _build_team(agents_conf: Dict[str, Any], domain: str, llm: ChatOpenAI, toolkits: Dict[str, List[BaseTool]], workspace: str, saver=None, store=None, recursion_limit=1000):
         """ """
-        team_conf = agents_conf[domain]
+        team_conf = agents_conf.setdefault(domain, {"members":{}})
         
         # for mname, mconf in team_conf['members'].items():
         #     print(f"member_name: {mname}, member: {mconf}")
             
         agents = []
         for member_name, member in team_conf["members"].items():
-            print(f"member_name: {member_name}, member: {member}")
+            # print(f"member_name: {member_name}, member: {member}")
             
             tools = []
             for tool_name in member["tools"]:
@@ -540,6 +540,9 @@ async def teminal_chat():
             #     prompt_name="leader_",
             #     WORKSPACE=workspace
             # ),
+            middleware=[
+                DynamicContentMiddleware(),
+            ],
             system_prompt=apply_prompt(leader, WORKSPACE=workspace),
             checkpointer=saver
         ).with_config({"recursion_limit": recursion_limit})
@@ -564,6 +567,15 @@ async def teminal_chat():
         recursion_limit=1000
     )
     
+    return agent, context, instruction_manager
+    
+    
+async def teminal_chat(verbose=True):
+    """ """
+    from langchain_core.messages import HumanMessage
+    from src.stream.handler import ainput, anormal_handler
+    
+    agent, context, instruction_manager = build_team()
     
     try:
         while True:
@@ -580,6 +592,9 @@ async def teminal_chat():
             
             new_query = f"\n [注意]: 执行用户请求必须严格遵循如下准则:\n{executed_instruction}\n\n 用户请求:\n{message}" if executed_instruction else message
             
+            
+            print(f"【new_query】:\n {new_query}")
+            
             stream = agent.astream(
                 {
                     "messages":[HumanMessage(content=new_query)]
@@ -589,7 +604,7 @@ async def teminal_chat():
                 context=context
             ) # .with_config({"recursion_limit": 1000})
             
-            await anormal_handler(stream, detail=True)
+            await anormal_handler(stream, detail=verbose)
             
     except Exception as e:
         import traceback
@@ -597,6 +612,50 @@ async def teminal_chat():
     finally:
         pass
             
+            
+async def run_once(prompt:str = None, verbose: bool=True):
+    from langchain_core.messages import HumanMessage
+    from src.stream.handler import ainput, anormal_handler
+    
+    agent, context, instruction_manager = build_team()
+    
+    query = prompt
+    
+    try:
+        if query == "/comands":
+            for instruction in instruction_manager.list_instructions():
+                # print(instruction)
+                print(f"command: {instruction.name}, description: {instruction.description}")
+        
+        instruction_result = instruction_manager.parse(query)
+        executed_instruction, message = instruction_result["executed_instruction"], instruction_result['message']
+        
+        new_query = f"\n [注意]: 执行用户请求必须严格遵循如下准则:\n{executed_instruction}\n\n 用户请求:\n{message}" if executed_instruction else message
+        
+        
+        if verbose:
+            print(f"user> {new_query}")
+        
+        stream = agent.astream(
+            {
+                "messages":[HumanMessage(content=new_query)]
+            },
+            config = {"configurable": {"thread_id": 1}},
+            stream_mode=["updates", "custom"],
+            context=context
+        ) # .with_config({"recursion_limit": 1000})
+        
+        await anormal_handler(stream, detail=verbose)
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+    
+    finally:
+        pass
+        
+    
+    
         
    
 if __name__ == "__main__":

package/dist/python-src/pyproject.toml

@@ -32,6 +32,7 @@ dependencies = [
   "langchain-core==1.2.13",
   "python-minifier>=3.2.0",
   "ddgs>=9.11.4",
+  "typer>=0.24.1",
 ]
 
 #[project.scripts]
@@ -56,7 +57,7 @@ skip = [
     "resources",
     "_workspace",
     ".autodev",
-    "tools"
+    "tools",
 ]
 
 exclude = [

package/dist/python-src/skill_agent.py

@@ -0,0 +1,144 @@
+import uuid
+from langchain.tools import tool
+from langchain.agents import create_agent
+
+from langgraph.checkpoint.memory import InMemorySaver
+
+
+from langchain.messages import AIMessage, AIMessageChunk, HumanMessage, AnyMessage, ToolMessage
+from langchain_openai import ChatOpenAI
+from dotenv import find_dotenv, load_dotenv
+import os
+
+from pathlib import Path
+import sys
+
+
+from src.stream.handler import ainput, anormal_handler
+from src.middlewares.skill import SkillMiddleware
+
+from src.tools.tools import (
+        SkillAgentContext, 
+        shell,
+        bash,
+        read_file,
+        write_file,
+        glob,
+        grep,
+        edit,
+        list_dir,
+    )
+    
+from src.tools.web import (
+    web_search, 
+    web_fetch
+)
+
+toolkits = {
+    "filetools": [ bash, read_file, write_file, glob, grep, edit, list_dir],
+    "web": [web_search, web_fetch]
+}
+
+
+_ = load_dotenv(find_dotenv())
+
+def get_default_model(streaming: bool = False) -> ChatOpenAI:
+    """
+    修复：兼容所有 OpenAI 格式厂商
+    - 流式：开启 stream_options 获取 usage
+    - 非流式：不传 stream_options，避免报错
+    """
+    # 基础参数
+    model_kwargs = {}
+    #model_kwargs['extra_body'] = {"chat_template_kwargs":{'enable_thinking': False}}
+    extra_body = {"chat_template_kwargs":{'enable_thinking': False}}
+    # 只有流式模式才加 stream_options（非流式不加，避免400错误）
+    # 非流式模式默认输出 usage 信息
+    if streaming:
+        model_kwargs["stream_options"] = {"include_usage": True}
+
+
+    
+    return ChatOpenAI(
+        model_name=os.getenv("DEFAULT_MODEL"),
+        base_url=os.getenv("OPENAI_API_BASE"),
+        api_key=os.getenv("OPENAI_API_KEY"),
+        streaming=streaming,
+        model_kwargs=model_kwargs,  # 动态传入
+        extra_body=extra_body
+    )
+   
+    
+def _render_message_chunk(token: AIMessageChunk) -> None:
+    if token.text:
+        print(token.text, end="|")
+    if token.tool_call_chunks:
+        print(token.tool_call_chunks)
+        
+def _render_completed_message(message: AnyMessage) -> None:
+    if isinstance(message, AIMessage) and message.tool_calls:
+        print(f"Tool calls: {message.tool_calls}")
+    if isinstance(message, ToolMessage):
+        print(f"Tool response: {message.content_blocks}")
+ 
+ 
+async def amain():   
+    model = get_default_model(streaming=True)
+
+    BASE_AGENT_PROMPT = """ 
+    你是一个专业的助手，你的任务是回答用户的问题。
+    你可以使用工具来获取信息，也可以直接回答用户的问题。
+    """
+    
+    agent = create_agent(
+        model=model,
+        system_prompt=BASE_AGENT_PROMPT,
+        tools=[bash, read_file, write_file, glob, grep, edit, list_dir, web_search, web_fetch],
+        middleware=[SkillMiddleware(workspace=Path.cwd())],
+        checkpoint=InMemorySaver(),
+        verbose=True,
+    )
+    
+    context = SkillAgentContext(
+            working_directory=Path.cwd(),
+            # skill_loader=None,
+            sandbox=None
+        )
+    
+    
+    while True:
+        
+        user_input = ainput("User> ")
+        if user_input == "exit":
+            break
+        
+        steam = agent.astream(
+            {
+                "messages": [HumanMessage(content=user_input) ]
+            },
+            config = {"configurable": {"thread_id": 1}},
+            stream_mode=["updates", "custom"],
+            context=context
+        )
+        
+        async for chunk in steam:
+            if chunk["type"] == "messages":
+                token, metadate = chunk["data"]
+                if isinstance(token, AIMessageChunk):
+                    #print(token)
+                    _render_message_chunk(token)
+            elif chunk["type"] == "updates":
+                for source, update in chunk["data"].items():
+                    if source in ("model", "tools"):
+                        _render_completed_message(update["messages"][-1])
+            
+        
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(amain())
+        
+    
+    
+    
+    
+

package/dist/python-src/src/agents/token_tracker.py

@@ -0,0 +1,44 @@
+_H='content'
+_G=' \n    你是一个专业的助手，你的任务是回答用户的问题。\n    你可以使用工具来获取信息，也可以直接回答用户的问题。\n    '
+_F='---------------------------'
+_E='total_tokens'
+_D='output_tokens'
+_C='input_tokens'
+_B=False
+_A='messages'
+from langchain_openai import ChatOpenAI
+from dotenv import find_dotenv,load_dotenv
+import os
+from langchain.messages import AIMessage,AIMessageChunk,AnyMessage,ToolMessage
+from langchain.agents.middleware import AgentMiddleware,ModelRequest,ModelResponse
+from langchain_core.messages import AIMessage
+from typing import Callable,Dict
+_=load_dotenv(find_dotenv())
+def get_default_model(streaming=_B):
+	A=streaming;B={};C={'chat_template_kwargs':{'enable_thinking':_B}}
+	if A:B['stream_options']={'include_usage':True}
+	return ChatOpenAI(model_name=os.getenv('DEFAULT_MODEL'),base_url=os.getenv('OPENAI_API_BASE'),api_key=os.getenv('OPENAI_API_KEY'),streaming=A,model_kwargs=B,extra_body=C)
+class TokenUsageMiddleware(AgentMiddleware):
+	def wrap_model_call(H,request,handler):C=request;print(f"[REQUEST]: {C}");A=handler(C);print(f"[RESPONSE]: {A}");D=A.result[-1];B=D.usage_metadata or{};E=B.get(_C,0);F=B.get(_D,0);G=B.get(_E,0);print(f"--- 模型调用 Token 统计 ---");print(f"输入 Tokens: {E}");print(f"输出 Tokens: {F}");print(f"总计 Tokens: {G}");print(_F);return A
+	async def awrap_model_call(G,request,handler):B=await handler(request);C=B.result[-1];A=C.usage_metadata or{};D=A.get(_C,0);E=A.get(_D,0);F=A.get(_E,0);print(f"\n--- 模型调用 Token 统计 ---");print(f"输入 Tokens: {D}");print(f"输出 Tokens: {E}");print(f"总计 Tokens: {F}");print(_F);return B
+from langchain.agents import create_agent
+from langchain.chat_models import init_chat_model
+def main():B=get_default_model(streaming=_B);C=[];D=_G;E=create_agent(model=B,tools=C,system_prompt=D,middleware=[TokenUsageMiddleware()]);A='请介绍一下LangChain v1的新特性';A='你好';E.invoke({_A:[{'role':'user',_H:A}]})
+def cx(token):
+	A=token
+	if A.text:print(A.text,end='|')
+	if A.tool_call_chunks:print(A.tool_call_chunks)
+def cw(message):
+	A=message
+	if isinstance(A,AIMessage)and A.tool_calls:print(f"Tool calls: {A.tool_calls}")
+	if isinstance(A,ToolMessage):print(f"Tool response: {A.content_blocks}")
+async def amain():
+	E='data';D='type';C='updates';F=get_default_model(streaming=True);G=[];H=_G;I=create_agent(model=F,tools=G,system_prompt=H,middleware=[TokenUsageMiddleware()]);J={'role':'user',_H:'你好'}
+	async for A in I.astream({_A:[J]},stream_mode=[_A,C],version='v2'):
+		if A[D]==_A:
+			B,M=A[E]
+			if isinstance(B,AIMessageChunk):cx(B)
+		elif A[D]==C:
+			for(K,L)in A[E].items():
+				if K in('model','tools'):cw(L[_A][-1])
+if __name__=='__main__':import asyncio;asyncio.run(amain())

package/dist/python-src/src/claw/bus/__init__.py

@@ -0,0 +1,3 @@
+from src.claw.bus.events import InboundMessage,OutboundMessage
+from src.claw.bus.queue import MessageBus
+__all__=['MessageBus','InboundMessage','OutboundMessage']

package/dist/python-src/src/claw/bus/events.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass,field
+from datetime import datetime
+from typing import Any
+@dataclass
+class InboundMessage:
+	channel:str;sender_id:str;chat_id:str;content:str;timestamp:datetime=field(default_factory=datetime.now);media:list[str]=field(default_factory=list);metadata:dict[str,Any]=field(default_factory=dict)
+	@property
+	def session_key(self):return f"{self.channel}:{self.chat_id}"
+@dataclass
+class OutboundMessage:channel:str;chat_id:str;content:str;reply_to:str|None=None;media:list[str]=field(default_factory=list);metadata:dict[str,Any]=field(default_factory=dict)

package/dist/python-src/src/claw/bus/queue.py

@@ -0,0 +1,43 @@
+_A=False
+import asyncio
+from typing import Callable,Awaitable
+from logging import getLogger
+from src.nano.bus.events import InboundMessage,OutboundMessage
+logger=getLogger(__name__)
+class MessageBus:
+	def __init__(A):A.inbound=asyncio.Queue();A.outbound=asyncio.Queue();A._outbound_subscribers={};A._inbound_subscribers={};A._in_running=_A;A._out_running=_A
+	async def publish_inbound(A,msg):await A.inbound.put(msg)
+	async def consume_inbound(A):return await A.inbound.get()
+	async def publish_outbound(A,msg):await A.outbound.put(msg)
+	async def consume_outbound(A):return await A.outbound.get()
+	def subscribe_inbound(A,channel,callback):
+		B=channel
+		if B not in A._inbound_subscribers:A._inbound_subscribers[B]=[]
+		A._inbound_subscribers[B].append(callback)
+	def subscribe_outbound(A,channel,callback):
+		B=channel
+		if B not in A._outbound_subscribers:A._outbound_subscribers[B]=[]
+		A._outbound_subscribers[B].append(callback)
+	async def dispatch_inbound(A):
+		A._in_running=True
+		while A._in_running:
+			try:
+				B=await asyncio.wait_for(A.inbound.get(),timeout=1.);C=A._inbound_subscribers.get(B.channel,[])
+				for D in C:
+					try:await D(B)
+					except Exception as E:logger.error(f"Error dispatching to {B.channel}: {E}")
+			except asyncio.TimeoutError:continue
+	async def dispatch_outbound(A):
+		A._out_running=True
+		while A._out_running:
+			try:
+				B=await asyncio.wait_for(A.outbound.get(),timeout=1.);C=A._outbound_subscribers.get(B.channel,[])
+				for D in C:
+					try:await D(B)
+					except Exception as E:logger.error(f"Error dispatching to {B.channel}: {E}")
+			except asyncio.TimeoutError:continue
+	def stop(A):A._in_running=_A;A._out_running=_A
+	@property
+	def inbound_size(self):return self.inbound.qsize()
+	@property
+	def outbound_size(self):return self.outbound.qsize()

package/dist/python-src/src/claw/channels/__init__.py

@@ -0,0 +1,3 @@
+from src.nano.channels.base import BaseChannel
+from src.nano.channels.manager import ChannelManager
+__all__=['BaseChannel','ChannelManager']

package/dist/python-src/src/claw/channels/base.py

@@ -0,0 +1,30 @@
+from abc import ABC,abstractmethod
+from typing import Any
+from logging import getLogger
+from src.nano.bus.events import InboundMessage,OutboundMessage
+from src.nano.bus.queue import MessageBus
+logger=getLogger(__name__)
+class BaseChannel(ABC):
+	name:str='base'
+	def __init__(A,config,bus):A.config=config;A.bus=bus;A._running=False
+	@abstractmethod
+	async def start(self):0
+	@abstractmethod
+	async def stop(self):0
+	@abstractmethod
+	async def send(self,msg):0
+	def is_allowed(E,sender_id):
+		C=True;A=getattr(E.config,'allow_from',[])
+		if not A:return C
+		B=str(sender_id)
+		if B in A:return C
+		if'|'in B:
+			for D in B.split('|'):
+				if D and D in A:return C
+		return False
+	async def _handle_message(A,sender_id,chat_id,content,media=None,metadata=None):
+		B=sender_id
+		if not A.is_allowed(B):logger.warning(f"Access denied for sender {B} on channel {A.name}.Add them to allowFrom list in config to grant access.");return
+		C=InboundMessage(channel=A.name,sender_id=str(B),chat_id=str(chat_id),content=content,media=media or[],metadata=metadata or{});await A.bus.publish_inbound(C)
+	@property
+	def is_running(self):return self._running

package/dist/python-src/src/claw/channels/feishu.py

@@ -0,0 +1,89 @@
+_E='THUMBSUP'
+_D=False
+_C=True
+_B='tag'
+_A=None
+import asyncio,json,re,threading
+from collections import OrderedDict
+from typing import Any
+from logging import getLogger
+logger=getLogger(__name__)
+from src.nano.bus.events import InboundMessage,OutboundMessage
+from src.nano.bus.queue import MessageBus
+from src.nano.channels.base import BaseChannel
+from src.nano.config.schema import FeishuConfig
+try:import lark_oapi as lark;from lark_oapi.api.im.v1 import CreateMessageRequest,CreateMessageRequestBody,CreateMessageReactionRequest,CreateMessageReactionRequestBody,Emoji,P2ImMessageReceiveV1;FEISHU_AVAILABLE=_C
+except ImportError:FEISHU_AVAILABLE=_D;lark=_A;Emoji=_A
+MSG_TYPE_MAP={'image':'[image]','audio':'[audio]','file':'[file]','sticker':'[sticker]'}
+class FeishuChannel(BaseChannel):
+	name='feishu'
+	def __init__(A,config,bus):B=config;super().__init__(B,bus);A.config=B;A._client=_A;A._ws_client=_A;A._ws_thread=_A;A._processed_message_ids=OrderedDict();A._loop=_A
+	async def start(A):
+		if not FEISHU_AVAILABLE:logger.error('Feishu SDK not installed. Run: pip install lark-oapi');return
+		if not A.config.app_id or not A.config.app_secret:logger.error('Feishu app_id and app_secret not configured');return
+		A._running=_C;A._loop=asyncio.get_running_loop();A._client=lark.Client.builder().app_id(A.config.app_id).app_secret(A.config.app_secret).log_level(lark.LogLevel.INFO).build();B=lark.EventDispatcherHandler.builder(A.config.encrypt_key or'',A.config.verification_token or'').register_p2_im_message_receive_v1(A.dg).build();A._ws_client=lark.ws.Client(A.config.app_id,A.config.app_secret,event_handler=B,log_level=lark.LogLevel.INFO)
+		def C():
+			try:A._ws_client.start()
+			except Exception as B:logger.error(f"Feishu WebSocket error: {B}")
+		A._ws_thread=threading.Thread(target=C,daemon=_C);A._ws_thread.start();logger.info('Feishu bot started with WebSocket long connection');logger.info('No public IP required - using WebSocket to reveive events')
+		while A._running:await asyncio.sleep(1)
+	async def stop(A):
+		A._running=_D
+		if A._ws_client:
+			try:A._ws_client.stop()
+			except Exception as B:logger.warning(f"Error stoppping WebSocket client: {B}")
+		logger.info('Feishu bot stopped')
+	def dh(D,message_id,emoji_type):
+		C=emoji_type;B=message_id
+		try:
+			E=CreateMessageReactionRequest.builder().message_id(B).request_body(CreateMessageReactionRequestBody.builder().reaction_type(Emoji.builder().emoji_type(C).build()).build()).build();A=D._client.im.v1.message_reaction.create(E)
+			if not A.success():logger.warning(f"Failed to add reaction: code={A.code}, msg={A.msg}")
+			else:logger.debug(f"Added {C} reaction to message {B}")
+		except Exception as F:logger.warning(f"Error adding reaction: {F}")
+	async def _add_reaction(A,message_id,emoji_type=_E):
+		if not A._client or not Emoji:return
+		B=asyncio.get_running_loop();await B.run_in_executor(_A,A.dh,message_id,emoji_type)
+	_TABLE_RE=re.compile('((?:^[ \\t]*\\|.+\\|[ \\t]*\\n)(?:^[ \\t]*\\|[-:\\s|]+\\|[ \\t]*\\n)(?:^[ \\t]*\\|.+\\|[ \\t]*\\n?)+)',re.MULTILINE)
+	@staticmethod
+	def dj(table_text):
+		A=[A.strip()for A in table_text.strip().split('\n')if A.strip()]
+		if len(A)<3:return
+		B=lambda l:[A.strip()for A in l.strip('|').split('|')];C=B(A[0]);D=[B(A)for A in A[2:]];E=[{_B:'column','name':f"c{A}",'display_name':B,'width':'auto'}for(A,B)in enumerate(C)];return{_B:'table','page_size':len(D)+1,'columns':E,'rows':[{f"c{A}":B[A]if A<len(B)else''for A in range(len(C))}for B in D]}
+	def di(G,content):
+		E='markdown';D='content';A=content;B,F=[],0
+		for C in G._TABLE_RE.finditer(A):
+			H=A[F:C.start()].strip()
+			if H:B.append({_B:E,D:H})
+			B.append(G.dj(C.group(1))or{_B:E,D:C.group(1)});F=C.end()
+		I=A[F:].strip()
+		if I:B.append({_B:E,D:I})
+		return B or[{_B:E,D:A}]
+	async def send(C,msg):
+		A=msg
+		if not C._client:logger.warning('Feishu client not initialized');return
+		try:
+			if A.chat_id.startswith('oc_'):D='chat_id'
+			else:D='open_id'
+			E=C.di(A.content);F={'config':{'wide_screen_mode':_C},'elements':E};G=json.dumps(F,ensure_ascii=_D);H=CreateMessageRequest.builder().receive_id_type(D).request_body(CreateMessageRequestBody.builder().receive_id(A.chat_id).msg_type('interactive').content(G).build()).build();B=C._client.im.v1.message.create(H)
+			if not B.success():logger.error(f"Failed to send Feishu message: code={B.code},msg={B.msg}, log_id={B.get_log_id()}")
+			else:logger.debug(f"Feishu message sent to {A.chat_id}")
+		except Exception as I:logger.error(f"Error sending Feishu message: {I}")
+	def dg(A,data):
+		if A._loop and A._loop.is_running():asyncio.run_coroutine_threadsafe(A._on_message(data),A._loop)
+	async def _on_message(A,data):
+		J='text'
+		try:
+			G=data.event;B=G.message;F=G.sender;C=B.message_id
+			if C in A._processed_message_ids:return
+			A._processed_message_ids[C]=_A
+			while len(A._processed_message_ids)>1000:A._processed_message_ids.popitem(last=_D)
+			K=F.sender_type
+			if K=='bot':return
+			H=F.sender_id.open_id if F.sender_id else'unknown';L=B.chat_id;I=B.chat_type;D=B.message_type;await A._add_reaction(C,_E)
+			if D==J:
+				try:E=json.loads(B.content).get(J,'')
+				except json.JSONDecodeError:E=B.content or''
+			else:E=MSG_TYPE_MAP.get(D,f"[{D}]")
+			if not E:return
+			M=L if I=='group'else H;await A._handle_message(sender_id=H,chat_id=M,content=E,metadata={'message_id':C,'chat_type':I,'msg_type':D})
+		except Exception as N:logger.error(f"Error processing Feishu message: {N}")