Repository navigation
Expand file tree
/
Copy pathtool.py
More file actions
181 lines (149 loc) · 4.96 KB
/
Copy pathtool.py
File metadata and controls
181 lines (149 loc) · 4.96 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
"""工具定义"""
from typing import Callable, Optional, Dict, Any, List, Union, get_origin, get_args
import inspect
import json
from pydantic import BaseModel
class Tool:
"""
工具类 - 封装可被Agent调用的函数
使用示例:
@tool
def search(query: str) -> str:
\"\"\"Search the web\"\"\"
return "results"
或带参数装饰:
@tool(name="calc", description="Calculate")
def calculate(expr: str) -> str:
...
或手动创建:
tool = Tool(
name="calculator",
description="Calculate math expressions",
func=calculate,
parameters={...}
)
"""
def __init__(
self,
name: str,
description: str,
func: Callable,
parameters: Optional[Dict[str, Any]] = None,
):
self.name = name
self.description = description
self.func = func
self.parameters = parameters or self._infer_parameters(func)
@staticmethod
def _python_type_to_json_schema(annotation: Any) -> Dict[str, Any]:
"""将Python类型注解转换为JSON Schema"""
if annotation == inspect.Parameter.empty:
return {"type": "string"}
origin = get_origin(annotation)
args = get_args(annotation)
if origin is Union:
non_none_args = [a for a in args if a is not type(None)]
if len(non_none_args) == 1:
return Tool._python_type_to_json_schema(non_none_args[0])
return {"type": "string"}
type_map = {
str: "string",
int: "integer",
float: "number",
bool: "boolean",
list: "array",
dict: "object",
}
if annotation in type_map:
return {"type": type_map[annotation]}
if origin is list:
schema: Dict[str, Any] = {"type": "array"}
if args:
schema["items"] = Tool._python_type_to_json_schema(args[0])
return schema
if origin is dict:
schema = {"type": "object"}
if args and len(args) >= 2:
schema["additionalProperties"] = Tool._python_type_to_json_schema(args[1])
return schema
return {"type": "string"}
def _infer_parameters(self, func: Callable) -> Dict[str, Any]:
"""从函数签名推断参数schema"""
sig = inspect.signature(func)
properties = {}
required = []
for pname, param in sig.parameters.items():
schema = self._python_type_to_json_schema(param.annotation)
schema["description"] = f"Parameter {pname}"
if param.default != inspect.Parameter.empty:
schema["default"] = param.default
else:
required.append(pname)
properties[pname] = schema
return {
"type": "object",
"properties": properties,
"required": required,
}
async def execute(self, **kwargs) -> Any:
"""执行工具"""
if inspect.iscoroutinefunction(self.func):
return await self.func(**kwargs)
return self.func(**kwargs)
def to_openai_format(self) -> Dict[str, Any]:
"""转换为OpenAI工具格式"""
return {
"type": "function",
"function": {
"name": self.name,
"description": self.description,
"parameters": self.parameters,
},
}
def __repr__(self) -> str:
return f"Tool(name='{self.name}', description='{self.description}')"
def _tool_factory(
name: Optional[str] = None,
description: Optional[str] = None,
) -> Callable[[Callable], Tool]:
"""
工具装饰器工厂(内部使用)
当 @tool 带参数调用时使用此工厂:
@tool(name="calc", description="Calculate")
def calculate(expr: str) -> str:
...
"""
def decorator(func: Callable) -> Tool:
tool_name = name or func.__name__
tool_desc = description or (func.__doc__ or "").strip()
return Tool(
name=tool_name,
description=tool_desc,
func=func,
)
return decorator
def tool(
_func: Optional[Callable] = None,
*,
name: Optional[str] = None,
description: Optional[str] = None,
) -> Any:
"""
工具装饰器 - 支持两种用法
用法1 - 直接装饰(无括号):
@tool
def search(query: str) -> str:
\"\"\"Search the web\"\"\"
...
用法2 - 带参数装饰:
@tool(name="calc", description="Calculate")
def calculate(expr: str) -> str:
...
"""
if _func is not None:
return Tool(
name=name or _func.__name__,
description=description or (_func.__doc__ or "").strip(),
func=_func,
)
return _tool_factory(name=name, description=description)