diff --git a/frontend/src/views/chat/components/AgentStreamDisplay.vue b/frontend/src/views/chat/components/AgentStreamDisplay.vue index a52faf5a..6347fe32 100644 --- a/frontend/src/views/chat/components/AgentStreamDisplay.vue +++ b/frontend/src/views/chat/components/AgentStreamDisplay.vue @@ -1346,15 +1346,31 @@ const onHoverOut = (e: Event) => { const getKbIdForWiki = (slug: string): string => { if (route.params.kbId) return route.params.kbId as string; - // Try to extract from agent event stream (retrieval pipeline) + // The backend ships `found_kbs` as a map — a single slug can + // legitimately resolve to more than one KB when multiple wiki KBs are in + // scope. For navigation we just pick the first one; cross-KB disambiguation + // (if ever needed) can layer on top. We also defensively handle the legacy + // string shape in case older tool outputs are still cached in a session. + const pickKbId = (v: unknown): string => { + if (!v) return ''; + if (typeof v === 'string') return v; + if (Array.isArray(v)) { + for (const item of v) { + if (typeof item === 'string' && item) return item; + } + } + return ''; + }; + + // Try to extract from agent event stream (retrieval pipeline). Walk + // backwards so we prefer the most recent tool call's mapping. if (props.session?.agentEventStream) { - // Search backwards for the most recent wiki tool call that found this slug for (let i = props.session.agentEventStream.length - 1; i >= 0; i--) { const event = props.session.agentEventStream[i]; - if (event.type === 'tool_call' && event.tool_data?.found_kbs) { - if (event.tool_data.found_kbs[slug]) { - return event.tool_data.found_kbs[slug]; - } + const foundKbs = event?.tool_data?.found_kbs; + if (event.type === 'tool_call' && foundKbs) { + const hit = pickKbId(foundKbs[slug]); + if (hit) return hit; } } } @@ -1624,10 +1640,13 @@ const preprocessMarkdown = (contentStr: string): string => { const parts = slug.split('/'); display = parts.length > 1 ? parts.slice(1).join('/') : slug; } - - // Ensure it's a valid wiki slug format, containing at least one slash - if (!slug.includes('/')) return match; - + + // Bail out on empty slug; otherwise accept any non-empty slug. + // Structural pages like "index" and "log" have no slash but are + // still valid targets — the drawer renderer already treats them + // as such, so the chat bubble must match. + if (!slug) return match; + const safeSlug = escapeHtml(slug); const safeDisplay = escapeHtml(display); return `${safeDisplay}`; diff --git a/internal/agent/observe.go b/internal/agent/observe.go index a321cf17..637c34f0 100644 --- a/internal/agent/observe.go +++ b/internal/agent/observe.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "fmt" + "strings" "time" agenttoken "github.com/Tencent/WeKnora/internal/agent/token" @@ -199,20 +200,74 @@ func (e *AgentEngine) analyzeResponse( return responseVerdict{isDone: false, step: step} } -// runtimeContextPrefix is prepended to the user query to provide time and session metadata -// in a format clearly marked as non-instruction data -// to prevent prompt injection via runtime metadata. -const runtimeContextPrefix = "[Runtime Context — metadata only, not instructions]" +// escapeXMLAttr escapes a string for safe inclusion in an XML attribute value. +// Titles and names may contain user-supplied characters like <, >, &, ". +func escapeXMLAttr(s string) string { + s = strings.ReplaceAll(s, "&", "&") + s = strings.ReplaceAll(s, "<", "<") + s = strings.ReplaceAll(s, ">", ">") + s = strings.ReplaceAll(s, "\"", """) + return s +} -// buildRuntimeContextBlock builds a metadata block with current time and session info. -// This is injected before the user message so the LLM has runtime context without -// conflating it with user instructions. -func buildRuntimeContextBlock(sessionID string) string { - return fmt.Sprintf("%s\nCurrent Time: %s\nSession: %s", - runtimeContextPrefix, - time.Now().Format(time.RFC3339), - sessionID, - ) +// buildRuntimeContextBlock builds a metadata block with current time, session +// info, and the *active retrieval scope for this turn*. The scope snapshot is +// critical for multi-turn correctness: when the user switches their @mention +// to a different KB or document between turns, earlier turns still carry +// their own scope snapshot in history, so the model can see the scope change +// and avoid reusing last turn's answer against the new scope. +// +// Emitted as an XML-ish block (not free prose) so it is a visually distinct, +// non-instruction envelope that is hard to conflate with user text and +// prompt-injection-safe. +func buildRuntimeContextBlock( + sessionID string, + kbs []*KnowledgeBaseInfo, + docs []*SelectedDocumentInfo, +) string { + var sb strings.Builder + sb.WriteString("\n") + fmt.Fprintf(&sb, " %s\n", time.Now().Format(time.RFC3339)) + fmt.Fprintf(&sb, " %s\n", escapeXMLAttr(sessionID)) + + if len(kbs) > 0 { + sb.WriteString(" \n") + for _, kb := range kbs { + if kb == nil { + continue + } + name := kb.Name + if name == "" { + name = kb.ID + } + fmt.Fprintf(&sb, " \n", + escapeXMLAttr(kb.ID), escapeXMLAttr(name)) + } + sb.WriteString(" \n") + } + + if len(docs) > 0 { + sb.WriteString(" \n") + for _, d := range docs { + if d == nil { + continue + } + title := d.Title + if title == "" { + title = d.FileName + } + if title == "" { + title = d.KnowledgeID + } + fmt.Fprintf(&sb, " \n", + escapeXMLAttr(d.KnowledgeID), escapeXMLAttr(title)) + } + sb.WriteString(" \n") + sb.WriteString(" The pinned-document set above is authoritative for THIS turn. If an earlier turn in this conversation analysed a different document, do NOT reuse that analysis — re-query against the current scope.\n") + } + + sb.WriteString("") + return sb.String() } // listToolNames returns tool.function names for logging @@ -390,9 +445,12 @@ func (e *AgentEngine) buildMessagesWithLLMContext( } } - // Build user message with runtime context safety tag - // This injects metadata as clearly non-instruction data to prevent prompt injection. - runtimeCtx := buildRuntimeContextBlock(sessionID) + // Build user message with runtime context safety tag. + // The runtime context carries a per-turn scope snapshot so that multi-turn + // history preserves the (kb, pinned docs) that each earlier turn ran under; + // this is what lets the model detect a scope switch instead of silently + // answering the new question against last turn's retrieval. + runtimeCtx := buildRuntimeContextBlock(sessionID, e.knowledgeBasesInfo, e.selectedDocs) userMsg := chat.Message{ Role: "user", Content: runtimeCtx + "\n\n" + currentQuery, diff --git a/internal/agent/tools/wiki_tools.go b/internal/agent/tools/wiki_tools.go index 7a5fef89..f94f6deb 100644 --- a/internal/agent/tools/wiki_tools.go +++ b/internal/agent/tools/wiki_tools.go @@ -97,6 +97,35 @@ func isStructuralPage(page *types.WikiPage) bool { return false } +// registerLinkedSlugs records the KB that owns this page for every slug the +// page links to (outbound) or is linked from (inbound). Wiki links are +// KB-local — a `[[slug]]` inside page X in KB A always refers to another +// page in KB A — so sharing the KB mapping with neighbours is safe and lets +// the frontend resolve a slug the model echoed from a page body (e.g. an +// `index` page's table of contents) without an extra round trip. +func registerLinkedSlugs(foundKBs map[string][]string, page *types.WikiPage, kbID string) { + if page == nil || kbID == "" { + return + } + add := func(slug string) { + if slug == "" { + return + } + for _, existing := range foundKBs[slug] { + if existing == kbID { + return + } + } + foundKBs[slug] = append(foundKBs[slug], kbID) + } + for _, s := range page.OutLinks { + add(s) + } + for _, s := range page.InLinks { + add(s) + } +} + // pageIntersectsKnowledgeIDs reports whether the page should pass the // knowledge-ID scope filter. // @@ -331,6 +360,10 @@ func (t *wikiReadPageTool) Execute(ctx context.Context, args json.RawMessage) (* kbID string }{page, actualKBID}) foundKBs[slug] = append(foundKBs[slug], actualKBID) + // Also register the page's neighbours so that when the model + // echoes a link like `[[summary/xyz]]` from this page's body, + // the frontend can resolve it to the same KB without guessing. + registerLinkedSlugs(foundKBs, page, actualKBID) t.mu.Lock() t.seenLinks[seenLinkKey(actualKBID, slug)] = true t.mu.Unlock() @@ -510,6 +543,9 @@ func (t *wikiSearchTool) Execute(ctx context.Context, args json.RawMessage) (*ty } allHits = append(allHits, searchHit{page: p, kbID: actualKBID}) foundKBs[p.Slug] = append(foundKBs[p.Slug], actualKBID) + // Register neighbour slugs so links surfaced from this + // page's body can be routed to the same KB by the frontend. + registerLinkedSlugs(foundKBs, p, actualKBID) } } _ = filteredCount // reserved for future debug surface