HomeAgent/internal/agent/core/output.go

package core

import (
	"fmt"
	"strings"

	agentAPI "github.com/JianFeeeee/HomeAgent/internal/agent/api"
	agentIO "github.com/JianFeeeee/HomeAgent/internal/agent/io"
	sdk "github.com/JianFeeeee/HomeAgent/internal/sdk"
)

func (a *Agent) executeOutputSendTool(tc agentAPI.ToolCall) string {
	channel := strings.TrimPrefix(tc.Name, "output_send__")
	payload, _ := tc.Arguments["payload"].(string)
	rawType, _ := tc.Arguments["type"].(string)
	if channel == "" || payload == "" {
		return "工具名称格式: output_send__{channel}，payload 不能为空"
	}
	// type 缺省按 text 处理：绝大多数输出就是文本，让模型为"省略一个默认值"付一次
	// 失败重试没有意义（判据该拦的是"不知道发什么"，不是"没写众所周知的默认值"）。
	if rawType == "" {
		rawType = "text"
	}
	// 授权闸（纵深防御）：模型可能凭名字直接调未授权的输出门。
	if !a.IsOutputAllowed(channel) {
		return fmt.Sprintf("通道 [%s] 未授权给本 agent。可用通道见 output_list_channels", channel)
	}

	meta, _ := tc.Arguments["meta"].(string)

	caps := a.io.GetChannelCapabilities(channel)
	if caps == 0 {
		return fmt.Sprintf("通道 [%s] 不存在或不可用。可用输出工具列表见 output_list_channels", channel)
	}
	switch rawType {
	case "text":
		if !caps.Supports(agentIO.CapText) {
			return fmt.Sprintf("通道 [%s] 不支持文本输出（能力: %s）", channel, caps.String())
		}
	case "voice", "audio":
		if !caps.Supports(agentIO.CapAudio) {
			return fmt.Sprintf("通道 [%s] 不支持语音输出（能力: %s）", channel, caps.String())
		}
	case "image":
		if !caps.Supports(agentIO.CapImage) {
			return fmt.Sprintf("通道 [%s] 不支持图片输出（能力: %s）", channel, caps.String())
		}
	case "file":
		if !caps.Supports(agentIO.CapFile) {
			return fmt.Sprintf("通道 [%s] 不支持文件输出（能力: %s）", channel, caps.String())
		}
	}

	args := map[string]interface{}{
		"payload": payload,
		"type":    rawType,
	}
	if meta != "" {
		args["meta"] = meta
	}

	stageCtx := &sdk.StageContext{
		FinalText: payload,
		Phase:     sdk.StageBeforeOutput,
	}
	a.runStage(sdk.StageBeforeOutput, stageCtx)
	if stageCtx.Response != nil {
		return fmt.Sprintf("输出被插件拦截: %s", *stageCtx.Response)
	}
	if stageCtx.FinalText == "" {
		return "输出被插件清空"
	}
	args["payload"] = stageCtx.FinalText

	if dev := a.io.GetDevice(channel); dev != nil {
		result, err := dev.Execute("output", args)
		if err != nil {
			return fmt.Sprintf("通过 [%s] 通道发送失败: %v", channel, err)
		}
		// 通道可能回报「未确认」（已提交但超时未拿到发送确认）——此时不能对模型
		// 谎报「已发送」，否则模型不会重试/核实。
		if m, ok := result.(map[string]interface{}); ok {
			if status, _ := m["status"].(string); status == "unconfirmed" || status == "queued" {
				note, _ := m["note"].(string)
				if note == "" {
					note = "发送已提交但未收到通道确认，结果未知"
				}
				return fmt.Sprintf("[%s] 通道发送结果未确认：%s", channel, note)
			}
		}
		// 成功回执：只返回极简标记，不回传完整插件响应。
		// 「已通过 [qq] 通道发送: map[status:sent message_id:xxx]」这类富回执
		// 会驱动模型继续调用 output_send（回声效应），是 output loop 的根源之一。
		return "ok"
	}

	a.io.EmitTextTo("agent_io", channel, payload)
	return fmt.Sprintf("已通过 [%s] 通道发送", channel)
}

func (a *Agent) executeOutputSendHelp(tc agentAPI.ToolCall) string {
	suffix := strings.TrimPrefix(tc.Name, "output_send__")
	channel := strings.TrimSuffix(suffix, "_help")
	if channel == "" {
		return "工具名称格式: output_send__{channel}_help"
	}

	dev := a.io.GetDevice(channel)
	if dev == nil {
		return fmt.Sprintf("通道 [%s] 不存在", channel)
	}

	caps := a.io.GetChannelCapabilities(channel)
	capStr := "无"
	if caps != 0 {
		capStr = caps.String()
	}

	desc := dev.Description()
	if desc == "" {
		desc = channel + " 输出通道"
	}

	return fmt.Sprintf(`通道 [%s]
描述: %s
能力: %s

【参数说明】
payload — 消息载荷（必填）。type=text 时直接填文字，type=file/image 时填 URL 或路径
meta    — JSON 对象，发送所需的元数据（可选，取决于通道是否需要路由信息）
type    — 载荷类型（必填），枚举值见下方

【type 枚举】
- text    — 文本消息
- voice   — 语音消息
- image   — 图片
- file    — 文件

【meta JSON 格式】
由通道描述定义，通常包含：
- "group_id"  群号（群聊时必填）
- "user_id"   目标用户 QQ 号（私聊时必填）
- "reply_to"  回复某条消息 ID（可选）

示例: output_send__%s(payload="你好", meta="{\"group_id\": 123456789}", type="text")`, channel, desc, capStr, channel)
}

func (a *Agent) executeOutputListChannels() string {
	channels := a.io.ListChannels()
	if len(channels) == 0 {
		return "没有可用通道"
	}
	var parts []string
	parts = append(parts, "可用通道:")
	for _, ch := range channels {
		if ch.OutputCaps == 0 {
			continue
		}
		if !a.IsOutputAllowed(ch.Name) {
			continue
		}
		line := fmt.Sprintf("  - %s: [%s] %s", ch.Name, ch.OutputCaps.String(), ch.Description)
		if t, ok := a.ResolveOutputTarget(ch.Name); ok {
			line += fmt.Sprintf("（目标: %s / inputch %s）", orDash(t.AgentID), orDash(t.InputCh))
		}
		parts = append(parts, line)
		for _, t := range ch.Tools {
			parts = append(parts, fmt.Sprintf("     工具: %s - %s", t.Name, t.Description))
		}
	}
	return strings.Join(parts, "\n")
}