@brandon_9527/tcode 1.0.6 → 1.0.7

package/dist/python-src/main.py

@@ -328,7 +328,8 @@ 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}")

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}")

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+import asyncio
+from typing import Any,TYPE_CHECKING
+from logging import getLogger
+from src.claw.bus.events import OutboundMessage
+from src.claw.bus.queue import MessageBus
+from src.claw.channels.base import BaseChannel
+from src.claw.config.schema import Config
+logger=getLogger(__name__)
+class ChannelManager:
+	def __init__(A,config,bus):A.config=config;A.bus=bus;A.channels={};A._dispatch_task=None;A.dk()
+	def dk(A):
+		if A.config.channels.feishu.enabled:
+			try:from src.claw.channels.feishu import FeishuChannel as B;A.channels['feishu']=B(A.config.channels.feishu,A.bus);logger.info('Feishu channel enabled')
+			except ImportError as C:logger.warning(f"Feishu channel not available: {C}")
+	async def _start_channel(B,name,channel):
+		try:await channel.start()
+		except Exception as A:logger.error(f"Failed to start channel {name}: {A}")
+	async def start_all(A):
+		if not A.channels:logger.warning('No channels enabled');return
+		A._dispatch_task=asyncio.create_task(A._dispatch_outbound());B=[]
+		for(C,D)in A.channels.items():logger.info(f"Starting {C} channel ...");B.append(asyncio.create_task(A._start_channel(C,D)))
+		await asyncio.gather(*B,return_exceptions=True)
+	async def stop_all(A):
+		logger.info('Stopping all channels ...')
+		if A._dispatch_task:
+			A._dispatch_task.cancel()
+			try:await A._dispatch_task
+			except asyncio.CancelledError:pass
+		for(B,C)in A.channels.items():
+			try:await C.stop();logger.info(f"Stopped {B} channel")
+			except Exception as D:logger.error(f"Error stopping {B}: {D}")
+	async def _dispatch_outbound(B):
+		logger.info('Outbound dispatcher started')
+		while True:
+			try:
+				A=await asyncio.wait_for(B.bus.consume_outbound(),timeout=1.);C=B.channels.get(A.channel)
+				if C:
+					try:await C.send(A)
+					except Exception as D:logger.error(f"Error sending to {A.channel}: {D}")
+				else:logger.warning(f"Unknown channel: {A.channel}")
+			except asyncio.TimeoutError:continue
+			except asyncio.CancelledError:break
+	def get_channel(A,name):return A.channels.get(name)
+	def get_status(A):return{A:{'enabled':True,'running':B.is_running}for(A,B)in A.channels.items()}
+	@property
+	def enabled_channels(self):return list(self.channels.keys())

package/dist/python-src/src/claw/config/schema.py

@@ -0,0 +1,46 @@
+_C=True
+_B=False
+_A=None
+from pathlib import Path
+from pydantic import BaseModel,Field
+from pydantic_settings import BaseSettings
+class FeishuConfig(BaseModel):enabled:bool=_B;app_id:str='';app_secret:str='';encrypt_key:str='';verification_token:str='';allow_from:list[str]=Field(default_factory=list)
+class DingTalkConfig(BaseModel):enabled:bool=_B;client_id:str='';client_secret:str='';allow_from:list[str]=Field(default_factory=list)
+class EmailConfig(BaseModel):enabled:bool=_B;consent_granted:bool=_B;imap_host:str='';imap_port:int=993;imap_username:str='';imap_password:str='';imap_mailbox:str='INBOX';imap_use_ssl:bool=_C;smtp_host:str='';smtp_port:int=587;smtp_username:str='';smtp_password:str='';smtp_use_tls:bool=_C;smtp_use_ssl:bool=_B;from_address:str='';auto_reply_enabled:bool=_C;poll_interval_seconds:int=30;mark_seen:bool=_C;max_body_chars:int=12000;subject_prefix:str='Re: ';allow_from:list[str]=Field(default_factory=list)
+class MochatMentionConfig(BaseModel):require_in_groups:bool=_B
+class MochatGroupRule(BaseModel):require_mention:bool=_B
+class MochatConfig(BaseModel):enabled:bool=_B;base_url:str='https://mochat.io';socket_url:str='';socket_path:str='/socket.io';socket_disable_msgpack:bool=_B;socket_reconnect_delay_ms:int=1000;socket_max_reconnect_delay_ms:int=10000;socket_connect_timeout_ms:int=10000;refresh_interval_ms:int=30000;watch_timeout_ms:int=25000;watch_limit:int=100;retry_delay_ms:int=500;max_retry_attempts:int=0;claw_token:str='';agent_user_id:str='';sessions:list[str]=Field(default_factory=list);panels:list[str]=Field(default_factory=list);allow_from:list[str]=Field(default_factory=list);mention:MochatMentionConfig=Field(default_factory=MochatMentionConfig);groups:dict[str,MochatGroupRule]=Field(default_factory=dict);reply_delay_mode:str='non-mention';reply_delay_ms:int=120000
+class QQConfig(BaseModel):enabled:bool=_B;app_id:str='';secret:str='';allow_from:list[str]=Field(default_factory=list)
+class ChannelsConfig(BaseModel):feishu:FeishuConfig=Field(default_factory=FeishuConfig);mochat:MochatConfig=Field(default_factory=MochatConfig);dingtalk:DingTalkConfig=Field(default_factory=DingTalkConfig);email:EmailConfig=Field(default_factory=EmailConfig);qq:QQConfig=Field(default_factory=QQConfig)
+class AgentDefaults(BaseModel):workspace:str='~/.nanobot/workspace';model:str='qwen-plus';max_tokens:int=8192;temperature:float=.7;max_tool_iterations:int=200
+class AgentsConfig(BaseModel):defaults:AgentDefaults=Field(default_factory=AgentDefaults)
+class ProviderConfig(BaseModel):api_key:str='';api_base:str|_A=_A;extra_headers:dict[str,str]|_A=_A
+class ProvidersConfig(BaseModel):anthropic:ProviderConfig=Field(default_factory=ProviderConfig);openai:ProviderConfig=Field(default_factory=ProviderConfig);openrouter:ProviderConfig=Field(default_factory=ProviderConfig);deepseek:ProviderConfig=Field(default_factory=ProviderConfig);groq:ProviderConfig=Field(default_factory=ProviderConfig);zhipu:ProviderConfig=Field(default_factory=ProviderConfig);dashscope:ProviderConfig=Field(default_factory=ProviderConfig);vllm:ProviderConfig=Field(default_factory=ProviderConfig);gemini:ProviderConfig=Field(default_factory=ProviderConfig);moonshot:ProviderConfig=Field(default_factory=ProviderConfig);minimax:ProviderConfig=Field(default_factory=ProviderConfig);aihubmix:ProviderConfig=Field(default_factory=ProviderConfig)
+class GatewayConfig(BaseModel):host:str='0.0.0.0';port:int=18790
+class WebSearchConfig(BaseModel):api_key:str='';max_results:int=5
+class WebToolsConfig(BaseModel):search:WebSearchConfig=Field(default_factory=WebSearchConfig)
+class ExecToolConfig(BaseModel):timeout:int=60
+class ToolsConfig(BaseModel):web:WebToolsConfig=Field(default_factory=WebToolsConfig);exec:ExecToolConfig=Field(default_factory=ExecToolConfig);restrict_to_workspace:bool=_B
+class Config(BaseSettings):
+	agents:AgentsConfig=Field(default_factory=AgentsConfig);channels:ChannelsConfig=Field(default_factory=ChannelsConfig);providers:ProvidersConfig=Field(default_factory=ProvidersConfig);gateway:GatewayConfig=Field(default_factory=GatewayConfig);tools:ToolsConfig=Field(default_factory=ToolsConfig)
+	@property
+	def workspace_path(self):return Path(self.agents.defaults.workspace).expanduser()
+	def df(C,model=_A):
+		from nanobot.providers.registry import PROVIDERS as D;E=(model or C.agents.defaults.model).lower()
+		for B in D:
+			A=getattr(C.providers,B.name,_A)
+			if A and any(A in E for A in B.keywords)and A.api_key:return A,B.name
+		for B in D:
+			A=getattr(C.providers,B.name,_A)
+			if A and A.api_key:return A,B.name
+		return _A,_A
+	def get_provider(A,model=_A):B,C=A.df(model);return B
+	def get_provider_name(A,model=_A):C,B=A.df(model);return B
+	def get_api_key(B,model=_A):A=B.get_provider(model);return A.api_key if A else _A
+	def get_api_base(D,model=_A):
+		from nanobot.providers.registry import find_by_name as E;B,C=D.df(model)
+		if B and B.api_base:return B.api_base
+		if C:
+			A=E(C)
+			if A and A.is_gateway and A.default_api_base:return A.default_api_base
+	class Config:env_prefix='NANOBOT_';env_nested_delimiter='__'

package/dist/python-src/src/managers/manager_agent.py

@@ -15,8 +15,8 @@ from pathlib import Path
 import yaml,json,sys,re,os
 sys.path.append('/Users/brandon/workspace/coder/autodev')
 class AgentInfo:
-	def __init__(A,name,content,src_):B=content;A.name=name;A.original_content=B;A.src_=src_;A.meta,A.body=A.bt(B)
-	def bt(F,content):
+	def __init__(A,name,content,src_):B=content;A.name=name;A.original_content=B;A.src_=src_;A.meta,A.body=A.bw(B)
+	def bw(F,content):
 		B=content;C='^---\\n(.*?)\\n---\\n(.*)$';A=re.match(C,B,re.S)
 		if A:D=yaml.safe_load(A.group(1));E=A.group(2).strip();return D,E
 		else:return{},B.strip()

package/dist/python-src/src/managers/manager_instruction.py

@@ -39,7 +39,7 @@ class InstructionManager:
 		if A.project_commands_dir and not os.path.exists(A.project_commands_dir):os.makedirs(A.project_commands_dir)
 		if not os.path.exists(A.user_dir):os.makedirs(A.user_dir)
 		A.reload_instructions()
-	def bw(O,dir_path,source):
+	def bx(O,dir_path,source):
 		F=source;C=dir_path;A={}
 		if not os.path.exists(C):return A
 		for(G,P,I)in os.walk(C):
@@ -54,9 +54,9 @@ class InstructionManager:
 					except Exception as N:print(f"从 {F} 加载命令 {B}/{E} 失败: {str(N)}")
 		return A
 	def reload_instructions(A):
-		A.instructions[_B].clear();A.instructions[_C].clear();A.instructions[_C]=A.bw(A.user_dir,_C)
-		if A.project_commands_dir:A.instructions[_B]=A.bw(A.project_commands_dir,_B)
-	def bx(A,source,domain,name):
+		A.instructions[_B].clear();A.instructions[_C].clear();A.instructions[_C]=A.bx(A.user_dir,_C)
+		if A.project_commands_dir:A.instructions[_B]=A.bx(A.project_commands_dir,_B)
+	def by(A,source,domain,name):
 		B=source
 		if B==_B:
 			if not A.project_commands_dir:raise ValueError('项目目录未初始化，无法操作project来源的指令')
@@ -79,7 +79,7 @@ class InstructionManager:
 	def add_instruction(B,domain,name,settings,content,source=_B):
 		E=source;D=name;C=domain
 		if B.exists(C,D,E):raise ValueError(f"指令 '{E}/{C}/{D}' 已存在")
-		G=B.bx(E,C,D);os.makedirs(os.path.dirname(G),exist_ok=_G)
+		G=B.by(E,C,D);os.makedirs(os.path.dirname(G),exist_ok=_G)
 		with open(G,'w',encoding=_I)as A:
 			A.write('---\n')
 			for(H,F)in settings.items():
@@ -98,7 +98,7 @@ class InstructionManager:
 		D=C.instructions[G][A][B]
 		if I is not _A:D.settings=I
 		if J is not _A:D.original_content=J
-		K=C.bx(G,A,B);os.makedirs(os.path.dirname(K),exist_ok=_G)
+		K=C.by(G,A,B);os.makedirs(os.path.dirname(K),exist_ok=_G)
 		with open(K,'w',encoding=_I)as E:
 			E.write('---\n')
 			for(L,H)in D.settings.items():
@@ -114,7 +114,7 @@ class InstructionManager:
 		else:
 			G,E=C.get_instruction_with_source(A,B)
 			if not E:raise ValueError(f"指令 '{A}/{B}' 不存在于任何来源")
-		F=C.bx(E,A,B)
+		F=C.by(E,A,B)
 		if os.path.exists(F):os.remove(F)
 		C.reload_instructions()
 	def load_all_instructions(A,domain=_D,source=_A):