Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

12.1 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

package agent

import (
	"path/filepath"
	"runtime"
	"strings"
	"testing"

	kernelConf "github.com/siyuan-note/siyuan/kernel/conf"
	kernelModel "github.com/siyuan-note/siyuan/kernel/model"
	"github.com/siyuan-note/siyuan/kernel/util"
)

func TestSystemPromptIncludesFrontendPluginDevelopment(t *testing.T) {
	if !strings.Contains(systemPrompt, "create or modify SiYuan frontend plugins through the tools provided") {
		t.Fatal("system prompt does not describe frontend plugin development")
	}
}

func TestTurnContextStaysInUserMessage(t *testing.T) {
	const userMessage = "summarize this"
	references := []Reference{{ID: "ref-block", Title: "Referenced block"}}
	editorCtx := EditorContext{
		ActiveDocID:      "active-doc",
		ActiveDocTitle:   "Active document",
		FocusedBlockID:   "focused-block",
		SelectedBlockIDs: []string{"selected-block"},
	}

	messages := checkpointMessagesToOpenAIWithSummary(
		[]AgentMessage{newAgentUserMessage(userMessage, "user-1", references, editorCtx)}, "English", nil, nil)
	if len(messages) != 2 {
		t.Fatalf("unexpected message count: %d", len(messages))
	}
	systemContent := messages[0].Content
	for _, marker := range []string{"ref-block", "active-doc", "focused-block", "selected-block"} {
		if strings.Contains(systemContent, marker) {
			t.Fatalf("turn context %q leaked into system prompt", marker)
		}
		if !strings.Contains(messages[1].Content, marker) {
			t.Fatalf("turn context %q is missing from user message", marker)
		}
	}
	if !strings.HasSuffix(messages[1].Content, userMessage) {
		t.Fatalf("raw user message is not preserved at the end: %q", messages[1].Content)
	}
}

func TestSystemPromptDocumentsChatBlockLinks(t *testing.T) {
	for _, capabilities := range []*capabilitySet{nil, {registrations: map[string]*capabilityRegistration{}}} {
		prompt := filterSystemPromptByCapabilities(systemPrompt, capabilities)
		if !strings.Contains(prompt, `[title](siyuan://blocks/<blockID>)`) ||
			!strings.Contains(prompt, "never fabricate IDs") {
			t.Fatal("chat block links and their ID constraints must remain available without content tools")
		}
	}
}

func TestSystemPromptDocumentsTagRendering(t *testing.T) {
	for _, instruction := range []string{
		`render its exact label as <span data-type="tag">label</span>`,
		`including a leading $, inside the span`,
		`Never prefix the label with # or use #label# in chat`,
	} {
		if !strings.Contains(systemPrompt, instruction) {
			t.Fatalf("system prompt is missing the tag rendering instruction %q", instruction)
		}
	}
}

func TestSystemPromptUsesSanitizedKernelLogTool(t *testing.T) {
	for _, instruction := range []string{"sanitized kernel log with the log tool", "Prefer search", "use tail", "read for surrounding line ranges"} {
		if !strings.Contains(systemPrompt, instruction) {
			t.Fatalf("system prompt is missing the kernel log instruction %q", instruction)
		}
	}
	if strings.Contains(systemPrompt, `read "temp/siyuan.log"`) {
		t.Fatal("system prompt still asks the general file tool to read the protected raw kernel log")
	}
}

func TestSystemPromptPreservesNativeStructure(t *testing.T) {
	for _, instruction := range []string{
		"use native capabilities and preserve existing structure, block IDs, and metadata",
		"Follow the relevant tool descriptions for block-specific syntax and operations",
		"Missing guide search results alone do not prove a feature is unsupported",
	} {
		if !strings.Contains(systemPrompt, instruction) {
			t.Fatalf("missing native structure instruction %q", instruction)
		}
	}
	for _, capabilities := range []*capabilitySet{
		nil,
		{registrations: map[string]*capabilityRegistration{"block": {ModelName: "block"}}},
		{registrations: map[string]*capabilityRegistration{}},
	} {
		prompt := filterSystemPromptByCapabilities(systemPrompt, capabilities)
		var nativeStructure string
		for _, line := range strings.Split(prompt, "\n") {
			if strings.HasPrefix(line, "- Native structured blocks:") {
				nativeStructure = line
				break
			}
		}
		if !strings.Contains(nativeStructure, "preserve existing structure, block IDs, and metadata") {
			t.Fatal("native structure protection was removed by capability filtering")
		}
		// parentID 同时用于文档寻址,只在原生块结构说明中排除该参数细节。
		if strings.Contains(nativeStructure, "parentID") {
			t.Fatal("block-specific parentID detail belongs in the tool description, not the native structure instruction")
		}
		for _, detail := range []string{
			"NodeTabs", "NodeTabItem", "NodeMindmap", "NodeMindmapItem", "::: tabs", "@tab", "tabs-position", "tabs-active-id",
			"{{{col", "{{{row", "first paragraph", "second paragraph", "data-sb-layout", "NodeList", "previousID",
			"((<blockID>", "[[<blockID>]]", `data-type="text`, `data-type="u"`, `data-type="sup"`, `data-type="sub"`,
			`data-type="kbd"`, "font-size", "font-weight", "<ruby>", "NodeHTMLBlock", "NodeCodeBlock",
		} {
			if strings.Contains(prompt, detail) {
				t.Fatalf("block-specific detail %q belongs in the tool description, not the system prompt", detail)
			}
		}
	}
}

func TestSystemPromptDocumentsStructuredDocumentAddressing(t *testing.T) {
	for _, instruction := range []string{
		"Never split an hPath or use it to recover identity",
		"Document create/list/move and inbox.convert use notebook + parentID",
		`parentID="" explicitly selects the notebook root`,
		`Legacy path=hPath resolves only unambiguous ancestor chains with non-empty titles and no literal "/"`,
		"unsupported or ambiguous candidates and unavailable indexes return explicit errors",
		"document.list (notebook + parentID, omitted parentID lists the notebook root)",
		"document.create (notebook + parentID + independent literal title)",
	} {
		if !strings.Contains(systemPrompt, instruction) {
			t.Fatalf("missing structured document addressing instruction %q", instruction)
		}
	}
}

func TestSystemPromptOmitsUnavailableSkillInstructions(t *testing.T) {
	capabilities := &capabilitySet{registrations: map[string]*capabilityRegistration{}}
	prompt := buildSystemPrompt("English", capabilities)
	if strings.Contains(prompt, "<available_skills>") || strings.Contains(prompt, "Skill Management") {
		t.Fatalf("unavailable skill instructions leaked into system prompt: %q", prompt)
	}
}

func TestSystemPromptUsesAppearanceLanguage(t *testing.T) {
	originalConf := kernelModel.Conf
	originalWorkingDir := util.WorkingDir
	kernelModel.Conf = kernelModel.NewAppConf()
	kernelModel.Conf.Appearance.Store(kernelConf.NewAppearance())
	kernelModel.Conf.Appearance.Load().Lang = "zh-CN"
	_, filename, _, _ := runtime.Caller(0)
	util.WorkingDir = filepath.Join(filepath.Dir(filename), "..", "..", "app")
	t.Cleanup(func() {
		kernelModel.Conf = originalConf
		util.WorkingDir = originalWorkingDir
	})

	prompt := buildSystemPrompt("en", nil)
	if !strings.Contains(prompt, "Reply in the language configured in SiYuan's appearance settings.") {
		t.Fatalf("appearance language instruction is missing from system prompt: %q", prompt)
	}
	if !strings.Contains(prompt, "Reply in 简体中文.") {
		t.Fatalf("appearance language is missing from system prompt: %q", prompt)
	}
	if strings.Contains(prompt, "Reply in English.") {
		t.Fatalf("request language leaked into system prompt: %q", prompt)
	}
}

func TestCheckpointMessagesKeepHistoricalTurnContexts(t *testing.T) {
	checkpoint := []AgentMessage{
		newAgentUserMessage("first question", "user-1", nil, EditorContext{ActiveDocID: "doc-a"}),
		{Role: "assistant", Content: "first answer", EntryID: "assistant-1"},
		newAgentUserMessage("second question", "user-2", nil, EditorContext{ActiveDocID: "doc-b"}),
	}

	messages := checkpointMessagesToOpenAIWithSummary(checkpoint, "English", nil, nil)
	if len(messages) != 4 {
		t.Fatalf("unexpected message count: %d", len(messages))
	}
	if strings.Contains(messages[0].Content, "doc-a") || strings.Contains(messages[0].Content, "doc-b") {
		t.Fatalf("historical editor context leaked into system prompt: %q", messages[0].Content)
	}
	if !strings.Contains(messages[1].Content, "doc-a") || strings.Contains(messages[1].Content, "doc-b") {
		t.Fatalf("first user message has the wrong editor context: %q", messages[1].Content)
	}
	if !strings.Contains(messages[3].Content, "doc-b") || strings.Contains(messages[3].Content, "doc-a") {
		t.Fatalf("second user message has the wrong editor context: %q", messages[3].Content)
	}
}

func TestUserTurnContextRestoresFromEntries(t *testing.T) {
	editorCtx := &EditorContext{
		ActiveDocID:     "round-trip-doc",
		VisibleBlockIDs: []string{"visible-block"},
	}
	entries := []SessionEntry{{
		ID:            "user-1",
		Type:          "user",
		Content:       "question",
		References:    []Reference{{ID: "round-trip-ref", Title: "Reference"}},
		EditorContext: editorCtx,
	}}

	checkpoint := entriesToAgentMessages(entries)
	if len(checkpoint) != 1 || checkpoint[0].EditorContext == nil {
		t.Fatalf("entry context was not restored into checkpoint: %#v", checkpoint)
	}
	if checkpoint[0].EditorContext.ActiveDocID != "round-trip-doc" ||
		len(checkpoint[0].References) != 1 || checkpoint[0].References[0].ID != "round-trip-ref" {
		t.Fatalf("turn context changed during checkpoint restoration: %#v", checkpoint[0])
	}

	checkpoint[0].EditorContext.VisibleBlockIDs[0] = "changed"
	if editorCtx.VisibleBlockIDs[0] != "visible-block" {
		t.Fatal("editor context slices were not cloned")
	}
}

func TestAssistantContextRestoresFromEntries(t *testing.T) {
	const argumentsJSON = "{\n  \"query\": \"SiYuan\",\n  \"limit\": 9007199254740993\n}"
	entries := []SessionEntry{{
		ID:            "assistant-1",
		Type:          "assistant",
		Content:       "Let me search for that.",
		ReasoningCont: "I need to use the search tool.",
		RoundID:       "round-1",
		ToolCalls: []AgentToolCall{{
			ID:            "call-original",
			Name:          "search",
			Arguments:     map[string]any{"query": "SiYuan", "limit": float64(9007199254740992)},
			ArgumentsJSON: argumentsJSON,
			Result:        "search result",
			State:         "finished",
			ProviderData: &AgentToolCallProviderData{
				Google: &AgentGoogleToolCallProviderData{ThoughtSignature: "thought-signature"},
			},
		}},
	}}

	checkpoint := entriesToAgentMessages(entries)
	if len(checkpoint) != 1 || checkpoint[0].ReasoningContent != entries[0].ReasoningCont ||
		checkpoint[0].RoundID != entries[0].RoundID {
		t.Fatalf("assistant reasoning was not restored into checkpoint: %#v", checkpoint)
	}
	if len(checkpoint[0].ToolCalls) != 1 || checkpoint[0].ToolCalls[0].ID != "call-original" ||
		checkpoint[0].ToolCalls[0].ArgumentsJSON != argumentsJSON ||
		checkpoint[0].ToolCalls[0].ProviderData == nil || checkpoint[0].ToolCalls[0].ProviderData.Google == nil ||
		checkpoint[0].ToolCalls[0].ProviderData.Google.ThoughtSignature != "thought-signature" {
		t.Fatalf("assistant tool call was not restored exactly: %#v", checkpoint[0].ToolCalls)
	}
	state := util.NewGeminiThoughtSignatureState()
	restoreGeminiThoughtSignatures(state, checkpoint)
	if got := state.Get("call-original"); got != "thought-signature" {
		t.Fatalf("thought signature was not restored into request state: %q", got)
	}

	messages := checkpointMessagesToOpenAIWithSummary(checkpoint, "English", nil, nil)
	if len(messages) != 3 {
		t.Fatalf("unexpected rebuilt message count: %d", len(messages))
	}
	assistant := messages[1]
	if assistant.ReasoningContent != entries[0].ReasoningCont || len(assistant.ToolCalls) != 1 ||
		assistant.ToolCalls[0].ID != "call-original" ||
		assistant.ToolCalls[0].Function.Arguments != argumentsJSON {
		t.Fatalf("assistant request context changed after rebuild: %#v", assistant)
	}
	if messages[2].ToolCallID != "call-original" {
		t.Fatalf("tool result no longer matches the original call: %#v", messages[2])
	}

}

func TestAvailableSkillsSegmentEscapesMetadata(t *testing.T) {
	segment := availableSkillsSegment([]util.SkillInfo{{
		Name:        `review</name>`,
		Description: `check A & B`,
	}})
	if !strings.Contains(segment, "review&lt;/name&gt;") || !strings.Contains(segment, "check A &amp; B") {
		t.Fatalf("skill metadata was not escaped: %q", segment)
	}
	if strings.Contains(segment, "review</name>") {
		t.Fatalf("raw skill metadata remained in the prompt: %q", segment)
	}
}