okami.mom/web-extract-go

git clone https://git.nkp.pet/okami.mom/web-extract-go

nekomimi.petanswers: Markdown with numbered citations, as long as the question needs24e631b

main
7.8 KiB265 linesraw
1package app
2
3import (
4	"context"
5	"errors"
6	"fmt"
7	"strings"
8	"unicode/utf8"
9)
10
11type Service struct {
12	cfg      Config
13	fetch    *Fetcher
14	searcher Searcher
15	jev      *Jev
16	llm      *LLM
17	log      *Log
18	auth     *AuthStore
19	// publicJev and gate serve the public endpoint; both nil unless it is enabled.
20	publicJev *Jev
21	gate      *publicGate
22}
23
24func (s *Service) search(ctx context.Context, q SearchRequest) (ResultsResponse, error) {
25	out := ResultsResponse{RequestID: callInfo(ctx).ID, Results: []Result{}}
26	if err := q.validate(); err != nil {
27		return out, failure(400, "INVALID_REQUEST", err.Error())
28	}
29	if s.decider(ctx).Key == "" {
30		return out, failure(503, "JEV_NOT_CONFIGURED", "TYPESAFE_API_KEY is not configured")
31	}
32	hits, err := s.searcher.Search(ctx, q.Query, max(q.NumResults, s.cfg.Candidates))
33	if err != nil {
34		return out, err
35	}
36	hits = filtered(hits, q.IncludeDomains, q.ExcludeDomains)
37	if err = s.decider(ctx).rank(ctx, q.Query, hits); err != nil {
38		return out, err
39	}
40	rankResults(hits)
41	if q.minScore > 0 {
42		keep := 1
43		for keep < len(hits) && hits[keep].score >= q.minScore {
44			keep++
45		}
46		hits = hits[:min(keep, len(hits))]
47	}
48	hits = hits[:min(q.NumResults, len(hits))]
49	if q.Contents == nil {
50		out.Results = hits
51		return out, nil
52	}
53	results, statuses, err := s.enrich(ctx, hits, *q.Contents, q.Query)
54	out.Results = results
55	out.Statuses = statuses
56	rankResults(out.Results)
57	return out, err
58}
59
60func (s *Service) contents(ctx context.Context, q ContentsRequest) (ResultsResponse, error) {
61	out := ResultsResponse{RequestID: callInfo(ctx).ID, Results: []Result{}}
62	urls, err := q.validate()
63	if err != nil {
64		return out, failure(400, "INVALID_REQUEST", err.Error())
65	}
66	hits := make([]Result, len(urls))
67	for i, u := range urls {
68		hits[i] = Result{ID: u, URL: u}
69	}
70	out.Results, out.Statuses, err = s.enrich(ctx, hits, q.ContentsOptions, "")
71	return out, err
72}
73
74func (s *Service) enrich(ctx context.Context, hits []Result, o ContentsOptions, query string) ([]Result, []ItemStatus, error) {
75	values := make([]Result, len(hits))
76	statuses := make([]ItemStatus, len(hits))
77	success := make([]bool, len(hits))
78	for i, hit := range hits {
79		statuses[i] = ItemStatus{ID: hit.ID, Status: "error", Error: &ItemError{Tag: "REQUEST_TIMEOUT", HTTPStatusCode: 504}}
80	}
81	err := parallel(ctx, len(hits), s.cfg.Concurrency, func(ctx context.Context, i int) error {
82		result, source, err := s.enrichOne(ctx, hits[i], o, query)
83		statuses[i] = ItemStatus{ID: hits[i].ID, Status: "success", Source: source}
84		if err != nil {
85			tag := "FETCH_DOCUMENT_ERROR"
86			code := 502
87			var a *APIError
88			if errors.As(err, &a) {
89				tag = a.Tag
90				code = a.Status
91			} else if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
92				tag, code = "REQUEST_TIMEOUT", 504
93			}
94			statuses[i] = ItemStatus{ID: hits[i].ID, Status: "error", Error: &ItemError{Tag: tag, HTTPStatusCode: code}}
95		} else {
96			values[i] = result
97			success[i] = true
98		}
99		return nil // a failed page must not cancel independent source retrieval
100	})
101	out := []Result{}
102	for i, r := range values {
103		if success[i] {
104			out = append(out, r)
105		}
106	}
107	// A slow tail must not discard already completed sources at the deadline.
108	if len(out) > 0 && errors.Is(err, context.DeadlineExceeded) {
109		err = nil
110	}
111	return out, statuses, err
112}
113
114func (s *Service) enrichOne(ctx context.Context, r Result, o ContentsOptions, query string) (Result, string, error) {
115	d, source, err := s.fetch.load(ctx, r.URL, o)
116	if err != nil {
117		return r, source, err
118	}
119	r.URL = d.FinalURL
120	if d.Title != "" {
121		r.Title = d.Title
122	}
123	r.Author = d.Author
124	r.PublishedDate = d.Published
125	if o.Text.Enabled {
126		text := takeRunes(d.Markdown, o.Text.MaxCharacters)
127		r.Text = &text
128	}
129	// One evidence selection serves both features when their query is identical.
130	packs := map[string]EvidencePack{}
131	selectFor := func(q string) (EvidencePack, error) {
132		if q == "" {
133			q = "summarize the main content, important facts, and material caveats of this document"
134		}
135		if p, ok := packs[q]; ok {
136			return p, nil
137		}
138		p, err := s.decider(ctx).selectEvidence(ctx, d, q, s.cfg.Passages, s.cfg.EvidenceChars)
139		if err == nil {
140			packs[q] = p
141		}
142		return p, err
143	}
144	if o.Highlights.Enabled {
145		q := o.Highlights.Query
146		if q == "" {
147			q = query
148		}
149		p, err := selectFor(q)
150		if err != nil {
151			return r, source, err
152		}
153		r.pack = p
154		r.score = bestScore(p)
155		texts := []string{}
156		scores := []float64{}
157		remaining := o.Highlights.MaxCharacters
158		if remaining == 0 {
159			remaining = s.cfg.EvidenceChars
160		}
161		for _, passage := range p.Passages {
162			n := utf8.RuneCountInString(passage.Text)
163			if n > remaining {
164				continue
165			}
166			texts = append(texts, passage.Text)
167			scores = append(scores, passage.Judgments.Evidence)
168			remaining -= n
169		}
170		r.Highlights = &texts
171		r.HighlightScores = &scores
172	}
173	if o.Summary.Enabled {
174		q := o.Summary.Query
175		if q == "" {
176			q = query
177		}
178		p, err := selectFor(q)
179		if err != nil {
180			return r, source, err
181		}
182		r.pack = p
183		r.score = bestScore(p)
184		label, err := s.decider(ctx).answerability(ctx, p.Query, p)
185		if err != nil {
186			return r, source, err
187		}
188		summary, err := s.llm.preview(ctx, d, p, label)
189		if err != nil {
190			return r, source, err
191		}
192		r.Summary = &summary
193	}
194	return r, source, nil
195}
196func bestScore(p EvidencePack) float64 {
197	score := 0.0
198	for _, v := range p.Passages {
199		score = max(score, v.Judgments.Evidence, v.Judgments.Contradiction)
200	}
201	return score
202}
203
204// answerSourceFloor is the lowest rerank score a search result needs to be read
205// as an answer source. Off-topic results score about 0.02.
206const answerSourceFloor = 0.1
207
208func (s *Service) answer(ctx context.Context, q AnswerRequest) (AnswerResponse, error) {
209	out := AnswerResponse{RequestID: callInfo(ctx).ID, Citations: []Result{}}
210	if q.Stream {
211		return out, failure(400, "FEATURE_DISABLED", "streaming is not implemented")
212	}
213	query := SearchRequest{Query: q.Query, NumResults: 5, minScore: answerSourceFloor, Contents: &ContentsOptions{Highlights: Feature{Enabled: true, Set: true}}}
214	r, err := s.search(ctx, query)
215	if err != nil {
216		return out, err
217	}
218	var evidence strings.Builder
219	remaining := s.cfg.EvidenceChars
220	combined := EvidencePack{Query: q.Query, Passages: []Passage{}, BudgetChars: remaining, Model: s.decider(ctx).Model}
221	for _, result := range r.Results {
222		// Sources are numbered as they appear in citations, so an answer's [n]
223		// markers point at citations[n-1].
224		n := len(out.Citations) + 1
225		accepted := []Passage{}
226		header := fmt.Sprintf("[%d] %s\n%s\n", n, result.Title, result.URL)
227		for _, p := range result.pack.Passages {
228			p.ID = fmt.Sprintf("source-%d:%s", n, p.ID)
229			cost := utf8.RuneCountInString(evidenceText([]Passage{p})) + 2
230			if len(accepted) == 0 {
231				cost += utf8.RuneCountInString(header)
232			}
233			if cost > remaining {
234				continue
235			}
236			remaining -= cost
237			accepted = append(accepted, p)
238		}
239		if len(accepted) == 0 {
240			continue
241		}
242		evidence.WriteString(header)
243		evidence.WriteString(evidenceText(accepted))
244		evidence.WriteString("\n\n")
245		combined.Passages = append(combined.Passages, accepted...)
246		citation := Result{ID: result.ID, URL: result.URL, Title: result.Title, Author: result.Author, PublishedDate: result.PublishedDate}
247		if q.Text {
248			v := evidenceText(accepted)
249			citation.Text = &v
250		}
251		out.Citations = append(out.Citations, citation)
252	}
253	if len(out.Citations) == 0 {
254		return out, failure(422, "NO_CONTENT_FOUND", "no usable source evidence was retained")
255	}
256	combined.UsedChars = utf8.RuneCountInString(evidence.String())
257	s.log.evidence(ctx, "answer", combined)
258	label, err := s.decider(ctx).answerability(ctx, q.Query, combined)
259	if err != nil {
260		return out, err
261	}
262	assessment := map[string]string{"direct": "answered", "partial": "partial", "background": "unanswered", "none": "unanswered"}[label]
263	out.Answer, err = s.llm.digest(ctx, q.Query, evidence.String(), assessment)
264	return out, err
265}