HaloAI 助手插件

plugin-ai-blog-agent/
├── build.gradle
├── src/main/java/run/halo/aiblogagent/
│   ├── AiBlogAgentPlugin.java              # 插件入口
│   ├── endpoint/
│   │   └── ChatEndpoint.java                # AI 对话自定义端点
│   ├── agent/
│   │   ├── BlogAgentService.java            # Agent 编排：接收消息 → 调 AI → 执行工具
│   │   └── tools/
│   │       ├── PostTools.java               # 发文章工具
│   │       ├── UpvoteTools.java             # 点赞工具
│   │       └── ContentTools.java            # 搜索/整理/片段工具
│   ├── ui/
│   │   └── ConsoleChatExtension.java        # Console UI 注入
│   └── settings/
│       └── AgentSettings.java               # 插件设置（模型选择等）
├── src/main/resources/
│   ├── extensions/
│   │   ├── plugin.yaml
│   │   ├── settings.yaml
│   │   └── role-template.yaml
│   └── console/
│       └── src/
│           └── components/
│               └── AgentChatPanel.vue        # 聊天面板 Vue 组件
└── README.md

dependencies {
    implementation platform('run.halo.tools.platform:plugin:2.20.0')
    compileOnly 'run.halo.app:api'
    // AI Foundation API
    compileOnly 'run.halo.app:plugin-ai-foundation-api:1.0.0'
}

@Component
public class ChatEndpoint implements CustomEndpoint {

    private final BlogAgentService agentService;

    public ChatEndpoint(BlogAgentService agentService) {
        this.agentService = agentService;
    }

    @Override
    public RouterFunction<ServerResponse> endpoint() {
        return RouterFunctions.route()
            .POST("/chat", this::chat)
            .build();
    }

    private Mono<ServerResponse> chat(ServerRequest request) {
        return request.bodyToMono(ChatRequest.class)
            .flatMap(req -> agentService.chat(req))
            .flatMap(result -> ServerResponse.ok().bodyValue(result));
    }

    @Override
    public GroupVersion groupVersion() {
        return new GroupVersion("console.api.ai-blog-agent.halo.run", "v1alpha1");
    }
}

@Service
public class BlogAgentService {

    private final AiClient aiClient; // AI Foundation 提供的模型客户端
    private final PostTools postTools;
    private final UpvoteTools upvoteTools;
    private final ContentTools contentTools;

    public BlogAgentService(AiClient aiClient,
                            PostTools postTools,
                            UpvoteTools upvoteTools,
                            ContentTools contentTools) {
        this.aiClient = aiClient;
        this.postTools = postTools;
        this.upvoteTools = upvoteTools;
        this.contentTools = contentTools;
    }

    public Mono<ChatResult> chat(ChatRequest request) {
        var tools = List.of(
            postTools.createPostTool(),
            upvoteTools.upvoteTool(),
            contentTools.searchAndSummarizeTool(),
            contentTools.extractHighlightsTool()
        );

        return aiClient.chat(ChatRequest.builder()
            .sessionId(request.sessionId())
            .systemPrompt("""
                你是 Halo 博客的 AI 助手。你可以帮助用户：
                - 创建并发布文章
                - 给文章点赞
                - 搜索并整理文章
                - 提取文章中的优秀片段
                当用户请求涉及以上操作时，调用对应工具完成。
                操作完成后用简洁的中文告知用户结果。
                """)
            .message(request.message())
            .tools(tools)
            .build());
    }
}

@Component
public class PostTools {

    private final ReactiveExtensionClient client;

    public PostTools(ReactiveExtensionClient client) {
        this.client = client;
    }

    public Tool createPostTool() {
        return Tool.builder()
            .name("createPost")
            .description("在 Halo 博客中创建一篇新文章并发布。参数：title（标题），content（Markdown 正文），slug（可选，URL 别名）")
            .inputSchema(Map.of(
                "type", "object",
                "properties", Map.of(
                    "title", Map.of("type", "string", "description", "文章标题"),
                    "content", Map.of("type", "string", "description", "Markdown 格式的正文"),
                    "slug", Map.of("type", "string", "description", "URL 别名，可选")
                ),
                "required", List.of("title", "content")
            ))
            .handler(args -> {
                String title = (String) args.get("title");
                String content = (String) args.get("content");
                String slug = (String) args.getOrDefault("slug", "");

                Post post = new Post();
                post.setMetadata(new Metadata());
                post.getMetadata().setGenerateName("ai-post-");
                post.getMetadata().setAnnotations(Map.of("content.halo.run/slug", slug));

                Post.Spec spec = new Post.Spec();
                spec.setTitle(title);
                spec.setContent(content); // Halo 的 Post content 可以是 Markdown
                spec.setPublish(true);
                spec.setPinned(false);
                spec.setAllowComment(true);
                post.setSpec(spec);

                return client.create(post)
                    .map(created -> "文章已发布：/archives/" + created.getMetadata().getName());
            })
            .build();
    }
}

@Component
public class UpvoteTools {

    private final WebClient webClient; // 指向当前 Halo 实例

    public Tool upvoteTool() {
        return Tool.builder()
            .name("upvotePost")
            .description("给指定的 Halo 文章点赞。参数：postName（文章的唯一名称，即 metadata.name）")
            .inputSchema(Map.of(
                "type", "object",
                "properties", Map.of(
                    "postName", Map.of("type", "string", "description", "文章的 metadata.name")
                ),
                "required", List.of("postName")
            ))
            .handler(args -> {
                String postName = (String) args.get("postName");
                return webClient.post()
                    .uri("/apis/api.halo.run/v1alpha1/trackers/upvote")
                    .bodyValue(Map.of(
                        "group", "content.halo.run",
                        "plural", "posts",
                        "name", postName
                    ))
                    .retrieve()
                    .bodyToMono(String.class)
                    .thenReturn("已为文章 " + postName + " 点赞");
            })
            .build();
    }
}

public Tool searchAndSummarizeTool() {
    return Tool.builder()
        .name("searchAndSummarizePosts")
        .description("搜索 Halo 博客中的文章，并整理出标题、摘要、分类、标签等结构化信息。参数：keyword（搜索关键词）")
        .inputSchema(Map.of(
            "type", "object",
            "properties", Map.of(
                "keyword", Map.of("type", "string", "description", "搜索关键词")
            ),
            "required", List.of("keyword")
        ))
        .handler(args -> {
            String keyword = (String) args.get("keyword");
            return webClient.get()
                .uri(uriBuilder -> uriBuilder
                    .path("/apis/api.halo.run/v1alpha1/indices/post")
                    .queryParam("keyword", keyword)
                    .queryParam("limit", 10)
                    .build())
                .retrieve()
                .bodyToMono(JsonNode.class)
                .map(this::formatSearchResult);
        })
        .build();
}

public Tool getPostContentTool() {
    return Tool.builder()
        .name("getPostContent")
        .description("获取指定文章的完整正文。参数：postName（文章的 metadata.name）")
        .inputSchema(...)
        .handler(args -> {
            String postName = (String) args.get("postName");
            return client.fetch(Post.class, postName)
                .map(post -> post.getSpec().getContent())
                .defaultIfEmpty("文章不存在或内容为空");
        })
        .build();
}

import { definePlugin } from '@halo-dev/ui-shared'

export default definePlugin({
  components: {},
  routes: [
    {
      path: '/ai-blog-agent',
      name: 'AiBlogAgent',
      component: () => import('./components/AgentChatPanel.vue'),
      meta: {
        menu: {
          name: 'AI 博客助手',
          group: 'content',
          icon: ' ri:robot-2-line',
          priority: 30,
        },
      },
    },
  ],
})

<template>
  <div class="agent-chat-panel">
    <div class="messages" ref="messagesRef">
      <div v-for="msg in messages" :key="msg.id" :class="['message', msg.role]">
        <div class="bubble" v-html="renderMarkdown(msg.content)" />
        <div v-if="msg.toolCalls?.length" class="tool-calls">
          <span v-for="tc in msg.toolCalls" :key="tc.id" class="tool-badge">
            🔧 {{ tc.name }} {{ tc.status === 'done' ? '✓' : '...' }}
          </span>
        </div>
      </div>
    </div>
    <div class="input-area">
      <textarea
        v-model="input"
        placeholder="例如：帮我发一篇关于 Halo 插件开发的文章 / 给 xxx 文章点赞 / 整理最近的优秀文章"
        @keydown.enter.exact.prevent="send"
      />
      <button @click="send" :disabled="loading">发送</button>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, nextTick } from 'vue'

const messages = ref<Message[]>([])
const input = ref('')
const loading = ref(false)
const messagesRef = ref<HTMLElement>()

async function send() {
  if (!input.value.trim() || loading.value) return
  const userMsg = input.value
  input.value = ''
  messages.value.push({ id: crypto.randomUUID(), role: 'user', content: userMsg })
  loading.value = true

  try {
    const res = await fetch(
      '/apis/console.api.ai-blog-agent.halo.run/v1alpha1/chat',
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ sessionId: 'default', message: userMsg }),
      }
    )
    const data = await res.json()
    messages.value.push({
      id: crypto.randomUUID(),
      role: 'assistant',
      content: data.content,
      toolCalls: data.toolCalls,
    })
  } finally {
    loading.value = false
    await nextTick()
    messagesRef.value?.scrollTo({ top: messagesRef.value.scrollHeight })
  }
}
</script>

apiVersion: v1alpha1
kind: Role
metadata:
  name: ai-blog-agent-role
  labels:
    halo.run/role-template: "true"
rules:
  - apiGroups: ["console.api.ai-blog-agent.halo.run"]
    resources: ["chat"]
    verbs: ["create"]

apiVersion: v1alpha1
kind: Setting
metadata:
  name: ai-blog-agent-settings
spec:
  forms:
    - group: basic
      label: AI 博客助手设置
      formSchema:
        - $formkit: select
          name: modelName
          label: 对话模型
          options:
            - label: 站点默认模型
              value: default
        - $formkit: checkbox
          name: allowPublishPost
          label: 允许 AI 直接发布文章
          value: false
        - $formkit: checkbox
          name: allowUpvote
          label: 允许 AI 执行点赞操作
          value: true