# 這是一個(gè)示例的JSON Schema定義
read_file_schema = {
    "type": "function",
    "function": {
        "name": "read_file", # 工具名稱
        "description": "讀取指定路徑文件的內(nèi)容", # 工具描述
        "parameters": { # 參數(shù)定義
            "type": "object",
            "properties": {
                "path": { # 參數(shù)名
                    "type": "string", # 參數(shù)類型
                    "description": "要讀取文件的相對(duì)路徑"# 參數(shù)描述
                }
            },
            "required": ["path"] # 必需的參數(shù)
        }
    }
}

{
  "tool_calls": [
    {
      "id": "call_abc123", # 調(diào)用ID
      "type": "function",
      "function": {
        "name": "read_file", # 模型決定調(diào)用的工具名稱
        "arguments": "{\"path\": \"/path/to/your/file.txt\"}" # 模型決定的參數(shù)，通常是JSON字符串
      }
    }
  ],
"role": "assistant",
"content": null # 如果模型只調(diào)用工具，content可能為空
}

# 假設(shè)你已經(jīng)安裝了某個(gè)支持工具調(diào)用的SDK，例如 together 或 openai
# pip install together # 或 pip install openai

import os
import json
from pathlib import Path # 用于處理文件路徑

# 這里的 client 只是一個(gè)占位符，你需要用實(shí)際的LLM客戶端替換
# 例如: from together import Together; client = Together()
# 或者: from openai import OpenAI; client = OpenAI()
# 請(qǐng)確保 client 對(duì)象支持 chat.completions.create 方法并能處理 tools 參數(shù)
class MockLLMClient:
    def chat(self):
        class Completions:
            def create(self, model, messages, tools=None, tool_choice="auto"):
                print("\n--- Calling Mock LLM ---")
                print("Messages:", messages)
                print("Tools provided:", [t['function']['name'] for t in tools] if tools else"None")
                print("-----------------------")
                # 在實(shí)際應(yīng)用中，這里會(huì)調(diào)用真實(shí)的API并返回模型響應(yīng)
                # 模擬一個(gè)簡(jiǎn)單的工具調(diào)用響應(yīng)
                last_user_message = None
                for msg in reversed(messages):
                    if msg['role'] == 'user':
                        last_user_message = msg['content']
                        break

                if last_user_message:
                    if"Read the file secret.txt"in last_user_message and tools:
                         # 模擬模型決定調(diào)用 read_file 工具
                        return MockResponse(tool_calls=[MockToolCall("read_file", '{"path": "secret.txt"}')])
                    elif"list files"in last_user_message and tools:
                         # 模擬模型決定調(diào)用 list_files 工具
                        return MockResponse(tool_calls=[MockToolCall("list_files", '{}')])
                    elif"Create a congrats.py script"in last_user_message and tools:
                         # 模擬模型決定調(diào)用 edit_file 工具
                         # 這是一個(gè)簡(jiǎn)化的模擬，實(shí)際模型會(huì)解析出路徑和內(nèi)容
                         args = {
                             "path": "congrats.py",
                             "old_str": "",
                             "new_str": "print('Hello, AI Agent!')\n# Placeholder for rot13 code"
                         }
                         return MockResponse(tool_calls=[MockToolCall("edit_file", json.dumps(args))])

                # 模擬一個(gè)處理完工具結(jié)果后的回復(fù)
                if messages and messages[-1]['role'] == 'tool':
                     tool_result = messages[-1]['content']
                     # 需要往前查找對(duì)應(yīng)的assistant/tool_calls消息來(lái)判斷是哪個(gè)工具
                     tool_call_msg_index = -2# 通常在倒數(shù)第二個(gè)
                     while tool_call_msg_index >= 0and messages[tool_call_msg_index].get('role') != 'assistant':
                          tool_call_msg_index -= 1

                     if tool_call_msg_index >= 0and messages[tool_call_msg_index].get('tool_calls'):
                          called_tool_name = messages[tool_call_msg_index]['tool_calls'][0]['function']['name'] # 簡(jiǎn)化處理，假設(shè)只有一個(gè)工具調(diào)用
                          if called_tool_name == 'read_file':
                               return MockResponse(cnotallow=f"OK，文件內(nèi)容已讀到：{tool_result}")
                          elif called_tool_name == 'list_files':
                               return MockResponse(cnotallow=f"當(dāng)前目錄文件列表：{tool_result}")
                          elif called_tool_name == 'edit_file':
                               return MockResponse(cnotallow=f"文件操作完成：{tool_result}")


                # 模擬一個(gè)普通回復(fù)
                return MockResponse(cnotallow="好的，請(qǐng)繼續(xù)。")

        return Completions()

class MockResponse:
     def __init__(self, cnotallow=None, tool_calls=None):
          self.choices = [MockChoice(cnotallow=content, tool_calls=tool_calls)]

class MockChoice:
     def __init__(self, content, tool_calls):
          self.message = MockMessage(cnotallow=content, tool_calls=tool_calls)

class MockMessage:
     def __init__(self, content, tool_calls):
          self.content = content
          self.tool_calls = tool_calls
     def model_dump(self):# 模擬pydantic的model_dump方法
          return {"content": self.content, "tool_calls": self.tool_calls}

class MockToolCall:
     def __init__(self, name, arguments):
          self.id = "call_" + str(hash(name + arguments)) # 簡(jiǎn)單的模擬ID
          self.type = "function"
          self.function = MockFunction(name, arguments)

class MockFunction:
     def __init__(self, name, arguments):
          self.name = name
          self.arguments = arguments

# 在實(shí)際使用時(shí)，請(qǐng)?zhí)鎿Q為你的LLM客戶端初始化代碼
# client = Together() # 示例 Together AI 客戶端
client = MockLLMClient() # 使用Mock客戶端進(jìn)行演示

# 定義文件讀取工具
def read_file(path: str) -> str:
    """
    讀取文件的內(nèi)容并作為字符串返回。

    Args:
        path: 工作目錄中的文件相對(duì)路徑。

    Returns:
        文件的內(nèi)容字符串。

    Raises:
        FileNotFoundError: 文件不存在。
        PermissionError: 沒有權(quán)限讀取文件。
    """
    print(f"Executing tool: read_file with path={path}")
    try:
        # 為了安全，可以增加路徑校驗(yàn)，防止讀取非工作目錄文件
        # resolved_path = Path(path).resolve()
        # if not resolved_path.is_relative_to(Path(".").resolve()):
        #     raise PermissionError("Access denied: Path is outside working directory.")
        with open(path, 'r', encoding='utf-8') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        returnf"錯(cuò)誤：文件 '{path}' 未找到。"
    except PermissionError:
        returnf"錯(cuò)誤：沒有權(quán)限讀取文件 '{path}'。"
    except Exception as e:
        returnf"錯(cuò)誤：讀取文件 '{path}' 時(shí)發(fā)生異常: {str(e)}"

read_file_schema = {
    'type': 'function',
    'function': {'name': 'read_file',
                 'description': '讀取指定路徑文件的內(nèi)容',
                 'parameters': {'type': 'object',
                                'properties': {'path': {'type': 'string',
                                                        'description': '要讀取文件的相對(duì)路徑'}},
                                'required': ['path']}}}


# 定義文件列表工具
def list_files(path: str = "."):
    """
    列出指定路徑下的所有文件和目錄。

    Args:
        path (str): 工作目錄中的目錄相對(duì)路徑。默認(rèn)為當(dāng)前目錄。

    Returns:
        str: 包含文件和目錄列表的JSON字符串。
    """
    print(f"Executing tool: list_files with path={path}")
    result = []
    base_path = Path(path)

    ifnot base_path.exists():
        return json.dumps({"error": f"路徑 '{path}' 不存在"})

    try:
        # 為了安全，可以增加路徑校驗(yàn)
        # resolved_path = base_path.resolve()
        # if not resolved_path.is_relative_to(Path(".").resolve()):
        #      return json.dumps({"error": "Access denied: Path is outside working directory."})

        for entry in base_path.iterdir():
             result.append(str(entry)) # 使用str()避免Path對(duì)象序列化問(wèn)題

        # 也可以使用 os.walk 更徹底，但這里簡(jiǎn)單起見用 iterdir()
        # for root, dirs, files in os.walk(path):
        #     # ... (類似參考文章的邏輯) ...
        #     pass # 這里簡(jiǎn)化處理，只列出當(dāng)前目錄

    except PermissionError:
         return json.dumps({"error": f"沒有權(quán)限訪問(wèn)路徑 '{path}'"})
    except Exception as e:
         return json.dumps({"error": f"列出文件時(shí)發(fā)生異常: {str(e)}"})

    return json.dumps(result)


list_files_schema = {
    "type": "function",
    "function": {
        "name": "list_files",
        "description": "列出指定路徑下的所有文件和目錄。",
        "parameters": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "要列出文件和目錄的相對(duì)路徑。默認(rèn)為當(dāng)前目錄。"
                }
            }
        }
    }
}

# 定義文件編輯工具
def edit_file(path: str, old_str: str, new_str: str):
    """
    通過(guò)替換字符串來(lái)編輯文件。如果 old_str 為空且文件不存在，則創(chuàng)建新文件并寫入 new_str。

    Args:
        path (str): 要編輯文件的相對(duì)路徑。
        old_str (str): 要被替換的字符串。如果為空，表示創(chuàng)建新文件。
        new_str (str): 替換后的字符串。

    Returns:
        str: "OK" 表示成功，否則返回錯(cuò)誤信息。
    """
    print(f"Executing tool: edit_file with path={path}, old_str='{old_str}', new_str='{new_str[:50]}...'") # 打印部分new_str避免過(guò)長(zhǎng)日志

    # 為了安全，可以增加路徑校驗(yàn)
    # resolved_path = Path(path).resolve()
    # if not resolved_path.is_relative_to(Path(".").resolve()):
    #      return "錯(cuò)誤：拒絕訪問(wèn)：路徑超出工作目錄范圍。"

    try:
        if old_str == ""andnot Path(path).exists():
             # 創(chuàng)建新文件
             with open(path, 'w', encoding='utf-8') as file:
                  file.write(new_str)
             return"OK: 新文件創(chuàng)建成功。"
        else:
             # 編輯現(xiàn)有文件
             with open(path, 'r', encoding='utf-8') as file:
                  old_content = file.read()

             if old_str == ""and Path(path).exists():
                  return"錯(cuò)誤：文件已存在，不能用空 old_str 創(chuàng)建。"

             if old_str notin old_content and old_str != "":
                  # 如果指定了 old_str 但未找到，返回錯(cuò)誤
                  returnf"錯(cuò)誤：文件 '{path}' 中未找到字符串 '{old_str}'。"

             new_content = old_content.replace(old_str, new_str)

             # 檢查是否真的有內(nèi)容變化（避免無(wú)意義的寫操作）
             if old_content == new_content and old_str != "":
                 # 如果 old_str 不為空但內(nèi)容沒變，說(shuō)明 old_str 沒找到，上面已經(jīng)處理了這個(gè)情況，這里是額外的校驗(yàn)
                 pass# 應(yīng)該已經(jīng)在上面報(bào)ValueError了，這里保留是為了邏輯清晰

             with open(path, 'w', encoding='utf-8') as file:
                  file.write(new_content)
             return"OK: 文件編輯成功。"

    except FileNotFoundError:
        returnf"錯(cuò)誤：文件未找到: {path}"
    except PermissionError:
        returnf"錯(cuò)誤：沒有權(quán)限編輯文件: {path}"
    except Exception as e:
        returnf"錯(cuò)誤：編輯文件 '{path}' 時(shí)發(fā)生異常: {str(e)}"


edit_file_schema = {
    "type": "function",
    "function": {
        "name": "edit_file",
        "description": "通過(guò)替換字符串來(lái)編輯文件。如果 old_str 為空且文件不存在，則創(chuàng)建新文件并寫入 new_str。",
        "parameters": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "要編輯文件的相對(duì)路徑"
                },
                "old_str": {
                    "type": "string",
                    "description": "要被替換的字符串。如果為空且文件不存在，將創(chuàng)建新文件。"
                },
                "new_str": {
                    "type": "string",
                    "description": "替換后的字符串或新文件內(nèi)容。"
                }
            },
            "required": ["path", "old_str", "new_str"]
        }
    }
}

# 將所有工具的Schema添加到列表中
available_tools = [read_file_schema, list_files_schema, edit_file_schema]

# 創(chuàng)建一個(gè)映射表，將工具名稱映射到實(shí)際函數(shù)
tool_functions = {
    "read_file": read_file,
    "list_files": list_files,
    "edit_file": edit_file,
}

def chat_with_agent():
    messages_history = [{"role": "system", "content": "你是一個(gè)善于使用外部工具來(lái)幫助用戶完成編程任務(wù)的AI助手。當(dāng)你認(rèn)為需要使用工具時(shí)，請(qǐng)按照規(guī)范發(fā)起工具調(diào)用。"}]

    print("AI編程智能體已啟動(dòng)！輸入指令開始交互 (輸入 'exit' 退出)")

    whileTrue:
        user_input = input("你: ")
        if user_input.lower() in ["exit", "quit", "q"]:
            break

        messages_history.append({"role": "user", "content": user_input})

        # 第一次調(diào)用大模型，讓它決定是否需要工具
        try:
            response = client.chat.completions.create(
                model="Qwen/Qwen2.5-7B-Instruct-Turbo", # 替換為你選擇的模型
                messages=messages_history,
                tools=available_tools, # 將工具Schema傳遞給模型
                tool_choice="auto", # 允許模型自動(dòng)選擇是否使用工具
            )
        except Exception as e:
            print(f"調(diào)用大模型API時(shí)發(fā)生錯(cuò)誤: {e}")
            continue# 跳過(guò)當(dāng)前循環(huán)，等待用戶輸入

        # 檢查大模型是否發(fā)起了工具調(diào)用
        response_message = response.choices[0].message
        tool_calls = response_message.tool_calls

        if tool_calls:
            # 如果模型發(fā)起了工具調(diào)用，執(zhí)行工具
            print("\n--- 接收到工具調(diào)用指令 ---")
            # 將模型的回復(fù)（包含工具調(diào)用信息）添加到歷史中
            # 注意：某些API可能在tool_calls的同時(shí)有content，但通常role是assistant
            messages_history.append({"role": "assistant", "tool_calls": tool_calls})

            for tool_call in tool_calls:
                function_name = tool_call.function.name
                function_args = json.loads(tool_call.function.arguments)
                tool_call_id = tool_call.id

                if function_name in tool_functions:
                    # 查找并執(zhí)行對(duì)應(yīng)的工具函數(shù)
                    print(f"--> 執(zhí)行工具: {function_name}，參數(shù): {function_args}")
                    try:
                        # 調(diào)用實(shí)際函數(shù)
                        # 使用 **function_args 將字典解包作為函數(shù)參數(shù)
                        function_response = tool_functions[function_name](**function_args)
                        print(f"<-- 工具執(zhí)行結(jié)果: {str(function_response)[:100]}...") # 打印部分結(jié)果
                    except Exception as e:
                        function_response = f"工具執(zhí)行失敗: {e}"
                        print(f"<-- 工具執(zhí)行結(jié)果: {function_response}")

                    # 將工具執(zhí)行結(jié)果添加到歷史中，再次調(diào)用大模型
                    messages_history.append(
                        {
                            "tool_call_id": tool_call_id,
                            "role": "tool",
                            "name": function_name,
                            "content": str(function_response), # 工具結(jié)果通常作為字符串傳回
                        }
                    )
                else:
                    # 模型調(diào)用了不存在的工具
                    error_message = f"大模型嘗試調(diào)用未知工具: {function_name}"
                    print(error_message)
                    messages_history.append(
                         {
                            "tool_call_id": tool_call_id,
                            "role": "tool",
                            "name": function_name, # 反饋錯(cuò)誤的工具名
                            "content": error_message, # 反饋錯(cuò)誤信息
                         }
                    )


            # 第二次調(diào)用大模型，讓它根據(jù)工具執(zhí)行結(jié)果生成最終回復(fù)
            try:
                print("\n--- 將工具結(jié)果反饋給大模型，獲取最終回復(fù) ---")
                second_response = client.chat.completions.create(
                    model="Qwen/Qwen2.5-7B-Instruct-Turbo", # 替換為你選擇的模型
                    messages=messages_history,
                )
                print("------------------------------------------")
                final_response_message = second_response.choices[0].message.content
                messages_history.append({"role": "assistant", "content": final_response_message})
                print(f"AI: {final_response_message}")

            except Exception as e:
                 print(f"將工具結(jié)果反饋給大模型時(shí)發(fā)生錯(cuò)誤: {e}")
                 # 如果再次調(diào)用失敗，本次交互就斷了，可以考慮是否需要重試或報(bào)錯(cuò)

        else:
            # 如果模型沒有調(diào)用工具，直接輸出模型的回復(fù)
            assistant_response = response_message.content
            messages_history.append({"role": "assistant", "content": assistant_response})
            print(f"AI: {assistant_response}")

# 啟動(dòng)智能體
chat_with_agent()

$ python simple_agent.py
AI編程智能體已啟動(dòng)！輸入指令開始交互 (輸入 'exit' 退出)
你: list files in the current directory
--- Calling Mock LLM ---
Messages: [{'role': 'system', 'content': '...'}, {'role': 'user', 'content': 'list files in the current directory'}]
Tools provided: ['read_file', 'list_files', 'edit_file']
-----------------------
--- 接收到工具調(diào)用指令 ---
--> 執(zhí)行工具: list_files，參數(shù): {}
<-- 工具執(zhí)行結(jié)果: ["secret.txt", "simple_agent.py"]...
--- 將工具結(jié)果反饋給大模型，獲取最終回復(fù) ---
------------------------------------------
AI: 當(dāng)前目錄文件列表：["secret.txt", "simple_agent.py"] # 這個(gè)回復(fù)是模擬的，實(shí)際取決于你的LLM
你: read the file secret.txt
--- Calling Mock LLM ---
Messages: [{'role': 'system', 'content': '...'}, {'role': 'user', 'content': 'read the file secret.txt'}, {'role': 'assistant', 'tool_calls': [...]}] # 包含之前的工具調(diào)用信息
Tools provided: ['read_file', 'list_files', 'edit_file']
-----------------------
--- 接收到工具調(diào)用指令 ---
--> 執(zhí)行工具: read_file，參數(shù): {'path': 'secret.txt'}
<-- 工具執(zhí)行結(jié)果: my secret message is: hello world...
--- 將工具結(jié)果反饋給大模型，獲取最終回復(fù) ---
------------------------------------------
AI: OK，文件內(nèi)容已讀到：my secret message is: hello world # 這個(gè)回復(fù)是模擬的，實(shí)際取決于你的LLM
你: exit