package app import ( "context" "errors" "fmt" "strings" "unicode/utf8" ) type Service struct { cfg Config fetch *Fetcher searcher Searcher jev *Jev llm *LLM log *Log auth *AuthStore // publicJev and gate serve the public endpoint; both nil unless it is enabled. publicJev *Jev gate *publicGate } func (s *Service) search(ctx context.Context, q SearchRequest) (ResultsResponse, error) { out := ResultsResponse{RequestID: callInfo(ctx).ID, Results: []Result{}} if err := q.validate(); err != nil { return out, failure(400, "INVALID_REQUEST", err.Error()) } if s.decider(ctx).Key == "" { return out, failure(503, "JEV_NOT_CONFIGURED", "TYPESAFE_API_KEY is not configured") } hits, err := s.searcher.Search(ctx, q.Query, max(q.NumResults, s.cfg.Candidates)) if err != nil { return out, err } hits = filtered(hits, q.IncludeDomains, q.ExcludeDomains) if err = s.decider(ctx).rank(ctx, q.Query, hits); err != nil { return out, err } rankResults(hits) if q.minScore > 0 { keep := 1 for keep < len(hits) && hits[keep].score >= q.minScore { keep++ } hits = hits[:min(keep, len(hits))] } hits = hits[:min(q.NumResults, len(hits))] if q.Contents == nil { out.Results = hits return out, nil } results, statuses, err := s.enrich(ctx, hits, *q.Contents, q.Query) out.Results = results out.Statuses = statuses rankResults(out.Results) return out, err } func (s *Service) contents(ctx context.Context, q ContentsRequest) (ResultsResponse, error) { out := ResultsResponse{RequestID: callInfo(ctx).ID, Results: []Result{}} urls, err := q.validate() if err != nil { return out, failure(400, "INVALID_REQUEST", err.Error()) } hits := make([]Result, len(urls)) for i, u := range urls { hits[i] = Result{ID: u, URL: u} } out.Results, out.Statuses, err = s.enrich(ctx, hits, q.ContentsOptions, "") return out, err } func (s *Service) enrich(ctx context.Context, hits []Result, o ContentsOptions, query string) ([]Result, []ItemStatus, error) { values := make([]Result, len(hits)) statuses := make([]ItemStatus, len(hits)) success := make([]bool, len(hits)) for i, hit := range hits { statuses[i] = ItemStatus{ID: hit.ID, Status: "error", Error: &ItemError{Tag: "REQUEST_TIMEOUT", HTTPStatusCode: 504}} } err := parallel(ctx, len(hits), s.cfg.Concurrency, func(ctx context.Context, i int) error { result, source, err := s.enrichOne(ctx, hits[i], o, query) statuses[i] = ItemStatus{ID: hits[i].ID, Status: "success", Source: source} if err != nil { tag := "FETCH_DOCUMENT_ERROR" code := 502 var a *APIError if errors.As(err, &a) { tag = a.Tag code = a.Status } else if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) { tag, code = "REQUEST_TIMEOUT", 504 } statuses[i] = ItemStatus{ID: hits[i].ID, Status: "error", Error: &ItemError{Tag: tag, HTTPStatusCode: code}} } else { values[i] = result success[i] = true } return nil // a failed page must not cancel independent source retrieval }) out := []Result{} for i, r := range values { if success[i] { out = append(out, r) } } // A slow tail must not discard already completed sources at the deadline. if len(out) > 0 && errors.Is(err, context.DeadlineExceeded) { err = nil } return out, statuses, err } func (s *Service) enrichOne(ctx context.Context, r Result, o ContentsOptions, query string) (Result, string, error) { d, source, err := s.fetch.load(ctx, r.URL, o) if err != nil { return r, source, err } r.URL = d.FinalURL if d.Title != "" { r.Title = d.Title } r.Author = d.Author r.PublishedDate = d.Published if o.Text.Enabled { text := takeRunes(d.Markdown, o.Text.MaxCharacters) r.Text = &text } // One evidence selection serves both features when their query is identical. packs := map[string]EvidencePack{} selectFor := func(q string) (EvidencePack, error) { if q == "" { q = "summarize the main content, important facts, and material caveats of this document" } if p, ok := packs[q]; ok { return p, nil } p, err := s.decider(ctx).selectEvidence(ctx, d, q, s.cfg.Passages, s.cfg.EvidenceChars) if err == nil { packs[q] = p } return p, err } if o.Highlights.Enabled { q := o.Highlights.Query if q == "" { q = query } p, err := selectFor(q) if err != nil { return r, source, err } r.pack = p r.score = bestScore(p) texts := []string{} scores := []float64{} remaining := o.Highlights.MaxCharacters if remaining == 0 { remaining = s.cfg.EvidenceChars } for _, passage := range p.Passages { n := utf8.RuneCountInString(passage.Text) if n > remaining { continue } texts = append(texts, passage.Text) scores = append(scores, passage.Judgments.Evidence) remaining -= n } r.Highlights = &texts r.HighlightScores = &scores } if o.Summary.Enabled { q := o.Summary.Query if q == "" { q = query } p, err := selectFor(q) if err != nil { return r, source, err } r.pack = p r.score = bestScore(p) label, err := s.decider(ctx).answerability(ctx, p.Query, p) if err != nil { return r, source, err } summary, err := s.llm.preview(ctx, d, p, label) if err != nil { return r, source, err } r.Summary = &summary } return r, source, nil } func bestScore(p EvidencePack) float64 { score := 0.0 for _, v := range p.Passages { score = max(score, v.Judgments.Evidence, v.Judgments.Contradiction) } return score } // answerSourceFloor is the lowest rerank score a search result needs to be read // as an answer source. Off-topic results score about 0.02. const answerSourceFloor = 0.1 func (s *Service) answer(ctx context.Context, q AnswerRequest) (AnswerResponse, error) { out := AnswerResponse{RequestID: callInfo(ctx).ID, Citations: []Result{}} if q.Stream { return out, failure(400, "FEATURE_DISABLED", "streaming is not implemented") } query := SearchRequest{Query: q.Query, NumResults: 5, minScore: answerSourceFloor, Contents: &ContentsOptions{Highlights: Feature{Enabled: true, Set: true}}} r, err := s.search(ctx, query) if err != nil { return out, err } var evidence strings.Builder remaining := s.cfg.EvidenceChars combined := EvidencePack{Query: q.Query, Passages: []Passage{}, BudgetChars: remaining, Model: s.decider(ctx).Model} for _, result := range r.Results { // Sources are numbered as they appear in citations, so an answer's [n] // markers point at citations[n-1]. n := len(out.Citations) + 1 accepted := []Passage{} header := fmt.Sprintf("[%d] %s\n%s\n", n, result.Title, result.URL) for _, p := range result.pack.Passages { p.ID = fmt.Sprintf("source-%d:%s", n, p.ID) cost := utf8.RuneCountInString(evidenceText([]Passage{p})) + 2 if len(accepted) == 0 { cost += utf8.RuneCountInString(header) } if cost > remaining { continue } remaining -= cost accepted = append(accepted, p) } if len(accepted) == 0 { continue } evidence.WriteString(header) evidence.WriteString(evidenceText(accepted)) evidence.WriteString("\n\n") combined.Passages = append(combined.Passages, accepted...) citation := Result{ID: result.ID, URL: result.URL, Title: result.Title, Author: result.Author, PublishedDate: result.PublishedDate} if q.Text { v := evidenceText(accepted) citation.Text = &v } out.Citations = append(out.Citations, citation) } if len(out.Citations) == 0 { return out, failure(422, "NO_CONTENT_FOUND", "no usable source evidence was retained") } combined.UsedChars = utf8.RuneCountInString(evidence.String()) s.log.evidence(ctx, "answer", combined) label, err := s.decider(ctx).answerability(ctx, q.Query, combined) if err != nil { return out, err } assessment := map[string]string{"direct": "answered", "partial": "partial", "background": "unanswered", "none": "unanswered"}[label] out.Answer, err = s.llm.digest(ctx, q.Query, evidence.String(), assessment) return out, err }