package llmreference
import (
"encoding/json"
"fmt"
"sort"
"strings"
"github.com/Tencent/WeKnora/internal/types"
)
// ModelOutput returns a compact, source-centric representation for the LLM.
// The canonical ToolResult.Output remains untouched for UI, logs and storage.
func (r *Registry) ModelOutput(result *types.ToolResult) string {
if result == nil {
return ""
}
if !result.Success {
if result.Error != "" {
return "Error: " + r.CompactKnownText(result.Error)
}
return "Error: tool call failed"
}
displayType := stringValue(result.Data, "display_type")
switch displayType {
case "grep_results":
return r.modelKnowledgeOutput("keyword", mapsValue(result.Data["chunk_results"]), result.Output)
case "search_results":
return r.modelKnowledgeOutput("semantic", mapsValue(result.Data["results"]), result.Output)
case "knowledge_chunks_list":
return r.modelKnowledgeChunksOutput(result.Data, result.Output)
case "document_info":
return r.modelDocumentInfoOutput(mapsValue(result.Data["documents"]), result.Output)
case "graph_query_results":
return r.modelKnowledgeOutput("graph", mapsValue(result.Data["results"]), result.Output)
case "web_search_results":
return r.modelWebSearchOutput(mapsValue(result.Data["results"]), result.Output)
case "web_fetch_results":
return r.modelWebFetchOutput(mapsValue(result.Data["results"]), result.Output)
default:
r.registerLabeledReferences(result.Output)
return r.CompactKnownText(result.Output)
}
}
func (r *Registry) modelDocumentInfoOutput(rows []map[string]interface{}, fallback string) string {
if len(rows) == 0 {
return r.CompactKnownText(fallback)
}
var b strings.Builder
b.WriteString("\n")
count := 0
for _, row := range rows {
knowledgeID := stringValue(row, "knowledge_id")
docAlias := r.RegisterDocument(knowledgeID)
if boolValue(row, "is_faq") {
chunkID := stringValue(row, "faq_id")
if chunkID == "" {
continue
}
title := firstNonEmpty(stringValue(row, "faq_question"), stringValue(row, "title"))
chunkAlias := r.RegisterChunk(ChunkReference{
ChunkID: chunkID,
KnowledgeID: knowledgeID,
DocumentTitle: title,
ChunkType: "faq",
})
fmt.Fprintf(&b, " \n", escapeAttr(docAlias))
fmt.Fprintf(&b, " \n", escapeAttr(chunkAlias))
if title != "" {
fmt.Fprintf(&b, " %s\n", escapeText(title))
}
for _, answer := range stringSliceValue(row["faq_answers"]) {
fmt.Fprintf(&b, " %s\n", escapeText(answer))
}
b.WriteString(" \n \n")
count++
continue
}
if docAlias == "" {
continue
}
fmt.Fprintf(&b, " \n", intValue(row, "chunk_count"))
if description := stringValue(row, "description"); description != "" {
fmt.Fprintf(&b, " %s\n", escapeText(description))
}
b.WriteString(" \n")
count++
}
b.WriteString("")
if count == 0 {
return r.CompactKnownText(fallback)
}
return b.String()
}
type modelChunk struct {
alias string
docAlias string
kbAlias string
title string
chunkType string
index int
view string
match string
content string
question string
answers []string
images []map[string]interface{}
docRealID string
kbRealID string
chunkReal string
inputOrder int
}
func (r *Registry) modelKnowledgeOutput(mode string, rows []map[string]interface{}, fallback string) string {
chunks := make([]modelChunk, 0, len(rows))
for idx, row := range rows {
chunkID := firstNonEmpty(stringValue(row, "chunk_id"), stringValue(row, "faq_id"), stringValue(row, "id"))
knowledgeID := stringValue(row, "knowledge_id")
kbID := firstNonEmpty(stringValue(row, "knowledge_base_id"), stringValue(row, "knowledge_base"))
title := firstNonEmpty(stringValue(row, "knowledge_title"), stringValue(row, "title"))
if chunkID == "" {
continue
}
chunkType := stringValue(row, "chunk_type")
if stringValue(row, "faq_id") != "" && chunkType == "" {
chunkType = "faq"
}
chunkIndex := intValue(row, "chunk_index")
if chunkIndex == 0 {
chunkIndex = intValue(row, "index")
}
chunkAlias := r.RegisterChunk(ChunkReference{
ChunkID: chunkID,
KnowledgeID: knowledgeID,
KnowledgeBaseID: kbID,
DocumentTitle: title,
ChunkIndex: chunkIndex,
ChunkType: chunkType,
})
chunks = append(chunks, modelChunk{
alias: chunkAlias,
docAlias: r.RegisterDocument(knowledgeID),
kbAlias: r.RegisterKnowledgeBase(kbID),
title: title,
chunkType: chunkType,
index: chunkIndex,
view: viewForRow(row, mode),
match: firstNonEmpty(stringValue(row, "match_snippet"), stringValue(row, "matched_content")),
content: stringValue(row, "content"),
question: firstNonEmpty(stringValue(row, "faq_question"), stringValue(row, "faq_standard_question")),
answers: stringSliceValue(row["faq_answers"]),
images: mapsValue(row["images"]),
docRealID: knowledgeID,
kbRealID: kbID,
chunkReal: chunkID,
inputOrder: idx,
})
}
if len(chunks) == 0 {
return r.CompactKnownText(fallback)
}
return renderKnowledgeChunks(mode, chunks)
}
func viewForRow(row map[string]interface{}, mode string) string {
if stringValue(row, "content") != "" {
return "full"
}
if mode == "deep_read" {
return "full"
}
return "match"
}
func (r *Registry) modelKnowledgeChunksOutput(data map[string]interface{}, fallback string) string {
rows := mapsValue(data["chunks"])
title := stringValue(data, "knowledge_title")
knowledgeID := stringValue(data, "knowledge_id")
for _, row := range rows {
if stringValue(row, "knowledge_id") == "" {
row["knowledge_id"] = knowledgeID
}
if stringValue(row, "knowledge_title") == "" {
row["knowledge_title"] = title
}
}
output := r.modelKnowledgeOutput("deep_read", rows, fallback)
if len(rows) == 0 {
return output
}
remaining := intValue(data, "total_chunks") - intValue(data, "fetched_chunks")
if remaining > 0 {
output = strings.TrimSuffix(output, "")
output += fmt.Sprintf(" \n",
remaining, intValue(data, "page"), intValue(data, "page_size"))
}
return output
}
func renderKnowledgeChunks(mode string, chunks []modelChunk) string {
type docGroup struct {
alias string
kbAlias string
title string
chunks []modelChunk
order int
}
groupsByKey := make(map[string]*docGroup)
var groups []*docGroup
for _, chunk := range chunks {
key := chunk.docAlias
if key == "" {
key = "chunk:" + chunk.alias
}
group := groupsByKey[key]
if group == nil {
group = &docGroup{alias: chunk.docAlias, kbAlias: chunk.kbAlias, title: chunk.title, order: chunk.inputOrder}
groupsByKey[key] = group
groups = append(groups, group)
}
group.chunks = append(group.chunks, chunk)
}
sort.SliceStable(groups, func(i, j int) bool { return groups[i].order < groups[j].order })
var b strings.Builder
fmt.Fprintf(&b, "\n", escapeAttr(mode))
for _, group := range groups {
b.WriteString(" \n")
for _, chunk := range group.chunks {
fmt.Fprintf(&b, " \n")
if chunk.question != "" {
fmt.Fprintf(&b, " %s\n", escapeText(chunk.question))
}
if chunk.match != "" {
fmt.Fprintf(&b, " %s\n", escapeText(chunk.match))
}
if chunk.content != "" {
fmt.Fprintf(&b, " %s\n", escapeText(chunk.content))
}
for _, answer := range chunk.answers {
fmt.Fprintf(&b, " %s\n", escapeText(answer))
}
for _, image := range chunk.images {
imageURL := stringValue(image, "url")
if imageURL == "" {
continue
}
caption := stringValue(image, "caption")
fmt.Fprintf(&b, " \n", caption, imageURL)
}
b.WriteString(" \n")
}
b.WriteString(" \n")
}
b.WriteString("")
return b.String()
}
func (r *Registry) modelWebSearchOutput(rows []map[string]interface{}, fallback string) string {
if len(rows) == 0 {
return r.CompactKnownText(fallback)
}
var b strings.Builder
b.WriteString("\n")
count := 0
for _, row := range rows {
rawURL := stringValue(row, "url")
if rawURL == "" {
continue
}
alias := r.RegisterWeb(rawURL, stringValue(row, "title"))
fmt.Fprintf(&b, " \n", alias, escapeAttr(stringValue(row, "title")))
if snippet := stringValue(row, "snippet"); snippet != "" {
fmt.Fprintf(&b, " %s\n", escapeText(snippet))
}
if published := stringValue(row, "published_at"); published != "" {
fmt.Fprintf(&b, " %s\n", escapeText(published))
}
b.WriteString(" \n")
count++
}
b.WriteString("")
if count == 0 {
return r.CompactKnownText(fallback)
}
return b.String()
}
func (r *Registry) modelWebFetchOutput(rows []map[string]interface{}, fallback string) string {
if len(rows) == 0 {
return r.CompactKnownText(fallback)
}
var b strings.Builder
b.WriteString("\n")
count := 0
for _, row := range rows {
rawURL := stringValue(row, "url")
if rawURL == "" {
continue
}
title := stringValue(row, "title")
alias := r.RegisterWeb(rawURL, title)
fmt.Fprintf(&b, " \n")
if summary := stringValue(row, "summary"); summary != "" {
fmt.Fprintf(&b, " %s\n", escapeText(summary))
}
if content := stringValue(row, "raw_content"); content != "" {
fmt.Fprintf(&b, " %s\n", escapeText(content))
}
b.WriteString(" \n")
count++
}
b.WriteString("")
if count == 0 {
return r.CompactKnownText(fallback)
}
return b.String()
}
func mapsValue(value interface{}) []map[string]interface{} {
if value == nil {
return nil
}
encoded, err := json.Marshal(value)
if err != nil {
return nil
}
var rows []map[string]interface{}
if err := json.Unmarshal(encoded, &rows); err != nil {
return nil
}
return rows
}
func stringValue(values map[string]interface{}, key string) string {
if values == nil {
return ""
}
switch value := values[key].(type) {
case string:
return value
case fmt.Stringer:
return value.String()
case json.Number:
return value.String()
default:
return ""
}
}
func intValue(values map[string]interface{}, key string) int {
if values == nil {
return 0
}
switch value := values[key].(type) {
case int:
return value
case int32:
return int(value)
case int64:
return int(value)
case float64:
return int(value)
case json.Number:
result, _ := value.Int64()
return int(result)
default:
return 0
}
}
func boolValue(values map[string]interface{}, key string) bool {
if values == nil {
return false
}
value, _ := values[key].(bool)
return value
}
func stringSliceValue(value interface{}) []string {
if value == nil {
return nil
}
encoded, err := json.Marshal(value)
if err != nil {
return nil
}
var values []string
if err := json.Unmarshal(encoded, &values); err != nil {
return nil
}
return values
}
func escapeText(value string) string {
replacer := strings.NewReplacer("&", "&", "<", "<", ">", ">")
return replacer.Replace(value)
}