// 消息接口定义
export interface ChatMessage {
    role: 'system' | 'user' | 'assistant' | 'tool'; // 系统提示、用户输入、助手回复、工具调用
    content: string | null; // 内容，null 表示工具调用
    reasoning_content?: string; // 推理内容
    tool_call_id?: string; // 工具调用ID
    tool_calls?: {
        id: string;
        type: string;
        function: { name: string; arguments: string };
    }[]; // 工具调用列表
}

// 系统提示词
const system_prompt = `你是一个编码 agent。需要执行命令时调用 bash/sh/cmd 工具，命令结果会作为 tool 消息返回给你。
当任务完成或无需更多操作时，用自然语言回复用户。`;


// 用户提示词
const prompt = '帮我列出当前目录的文件';

// 用户消息队列
const messages: ChatMessage[] = [
  { role: 'system', content: system_prompt },
  { role: 'user', content: prompt },
];

// 工具接口定义
export interface Tool {
    name: string; // 工具名称
    description: string; // 工具描述
    input_schema: Record<string, unknown>; // 输入参数模式
    run: (args: any) => Promise<string>; // 运行函数
}

// 注册工具
this.register({
    name: 'bash',
    description: '在用户的机器上执行一段bash/shell命令',
    input_schema: {
        type: 'object',
        properties: { command: { type: 'string', description: '要执行的bash/shell命令' } },
        required: ['command'],
    },
    async run({ command }: {command: string}) {
        try {
            const { stdout, stderr } = await execAsync(command);
            return stdout + (stderr ? `\n${stderr}` : '');
        } catch (error: any) {
            return `[exit code: ${error.code ?? 1}]\n${error.stdout ?? ''}${error.stderr ?? ''}`;
        }
    }
});

// 发送消息和工具定义给llm
const msg = await llm.chat(messages, tools.list());

for(let turn = 0; turn < maxTurns; turn++) {
    const msg = await llm.chat(messages, tools.list()); // 调用LLM生成回复

    console.log(msg); // 打印回复

    if(msg.tool_calls?.length) { // 如果回复包含工具调用
        messages.push({ 
            role: 'assistant', 
            content: msg.content ?? null, 
            tool_calls: msg.tool_calls, 
            reasoning_content: msg.reasoning_content 
        }); // 添加助手回复消息
        for(const call of msg.tool_calls) { // 遍历工具调用
            const fn = call.function;
            const args = JSON.parse(fn.arguments || '{}'); // 解析工具调用参数
            if(!args) throw new Error('tool arguments not valid'); // 校验参数是否有效
            this.ctx.logger.info(`[tool] %s %o`, fn.name, args); // 打印工具调用参数
            const result = await tools.run(fn.name, args); // 调用工具服务
            messages.push({ role: 'tool', tool_call_id: call.id, content: result }); // 添加工具调用结果消息
        }
        continue; // 继续下一轮循环
    }
    
    return msg.content ?? ''; // 返回助手回复
}

new ConsoleExporter(ctx);

plugin(plugin, config, getOuterStack) {
    const callback = this.resolve(plugin);
    ...
    runtime = { name, callback, fibers, Config: plugin.Config };   // ← 读 plugin.Config
    ...
    const fiber = new Fiber(this.ctx, config, Inject.resolve(plugin.inject), runtime, ...);  // ← 读 plugin.inject
}

// resolve：plugin 是函数/类，还是带 apply 的对象
resolve(plugin) {
    if (typeof plugin === "function") return plugin;   // 类 → 返回类本身
    if (isApplicable(plugin)) return plugin.apply;     // 带 apply 的对象 → 返回 apply
}

import { AgentLoop } from './plugins/agent-loop.js';  // 这里AgentLoop实际是agent-loop.js中导出的class
...
await ctx.plugin(AgentLoop);  // 直接将class传入了

...
export class AgentLoop extends Service {
    static inject = ['llm', 'tools'];     // 改用类静态属性实现
    static Config = z.object({
        maxTurns: z.number().default(20)
    });     // 改用类静态属性实现
    ...
}
export const inject = ['llm', 'tools'];  // 删除此定义
export const Config = z.object({
    maxTurns: z.number().default(20),
});  // 删除此定义

await ctx.plugin(AgentLoop, { maxTurns: 20 });  // 实际的config

try {
    const { stdout, stderr } = await execAsync(command, { timeout: 30_000 });  // 加超时时间，超过这个时间后 Node 强制 kill 子进程
    return stdout + (stderr ? `\n${stderr}` : '');
} catch (error: any) {
    return `[exit code: ${error.code ?? 1}]\n${error.stdout ?? ''}${error.stderr ?? ''}`;  // 捕获错误情况并返回错误信息 供LLM修正
}

export class AgentLoop extends Service {
    static Config = z.object({
        maxTurns: z.number().default(20),
        maxRepeat: z.number().default(3),  // 增加最大指令重复次数配置
    });
    private lastFP: string | null = null;  // 上一次的指令指纹
    private repeatCount = 0;  // 指令重复次数
    // 函数用于检查是否重复
    private repeatCheck(fp: string): boolean {
        if(fp === this.lastFP) {
            this.repeatCount++;
        } else {
            this.repeatCount = 1;
            this.lastFP = fp;
        }
        return this.repeatCount >= this.config.maxRepeat;
    }
    ...
    async run(prompt:string) {
        ...
        // 初始化工具调用指纹列表
        this.lastFP = null;
        this.repeatCount = 0;
        // 循环执行
        for(let turn = 0; turn < this.config.maxTurns; turn++) {
            ...
            if(msg.tool_calls?.length) { // 如果回复包含工具调用
                ...
                for(const call of msg.tool_calls) { // 遍历工具调用
                    ...
                    // 检查工具调用指纹是否已存在
                    const fp = `${fn.name},${fn.arguments}`; // 生成工具调用指纹
                    if(this.repeatCheck(fp)) { // 如果达到最大指令重复次数阈值，提示LLM改变策略
                        messages.push({
                            role: 'tool',
                            tool_call_id: call.id,
                            content: `[error] 检测到连续重复调用同一工具，请改变策略，避免无限循环。当前重复次数：${this.repeatCount}次。`,
                        });
                        continue; // 跳过这个工具调用
                    }
                    ...
                }
                continue; // 继续下一轮循环
            }
            ...
        }
        ...
    }
}