knowledge

type AssetSearcher ¶ added in v1.92.0

type AssetSearcher interface {
	SearchAssets(ctx context.Context, q portal.AssetSearchQuery) ([]portal.ScoredAsset, error)
	Get(ctx context.Context, id string) (*portal.Asset, error)
}

AssetSearcher is what the provider needs from the portal asset store: relevance search over a caller's assets (the text path) and a by-id read (fetch). The concrete postgres asset store satisfies it; declared here so the provider depends on the capability and the platform asserts one authority for "a searchable, fetchable asset store".

type AssetsProvider ¶

type AssetsProvider struct {
	// contains filtered or unexported fields
}

AssetsProvider exposes a caller's managed assets (saved artifacts) to the router. It is per-user: results are restricted to assets the caller owns (assets.owner_id == caller UUID), which is why it keys on Caller.UserID rather than the email the memory and insight providers use.

func NewAssetsProvider(searcher AssetSearcher) *AssetsProvider

func (p *AssetsProvider) Fetch(ctx context.Context, ref string, caller Caller) (*Document, bool, error)

func (*AssetsProvider) Name() string

func (*AssetsProvider) Scope() Scope

func (p *AssetsProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type BrowsePage ¶ added in v1.93.0

type BrowsePage struct {
	Hits   []Hit `json:"hits"`
	Total  int   `json:"total"`
	Offset int   `json:"offset"`
	Limit  int   `json:"limit"`
}

BrowsePage is one page of an enumeration: the members on this page (as Hits, so each carries the same Reference search emits and fetch consumes), the Total members in the source (so a caller knows how many pages remain), and the effective Offset/Limit the Router applied after clamping.

type BrowseQuery ¶ added in v1.93.0

type BrowseQuery struct {
	Caller Caller
	Offset int
	Limit  int
}

BrowseQuery is one enumeration request: page the source from Offset for Limit members, scoped to Caller. Unlike a search Query it carries no intent and no entity URNs; it enumerates a single source in full rather than ranking across many.

type Browser ¶ added in v1.93.0

type Browser interface {
	// Browse returns one page of this provider's members. It sets Hits and Total;
	// the Router stamps the effective Offset and Limit onto the returned page.
	Browse(ctx context.Context, q BrowseQuery) (BrowsePage, error)
}

Browser is the optional capability of a Provider to enumerate its members in full, paginated and with a total count and no relevance threshold (#695). It is the complement of Search: Search ranks a relevant few, Browse lists the whole set so an agent can audit, dedup, govern, or migrate the corpus. A provider that does not implement Browser is search-only, and the Router reports its source as not browsable.

A per-user provider's Browse must scope to the caller exactly as its Search does; the Router additionally refuses to browse a per-user provider for an anonymous caller, so enumeration can never widen what a caller could otherwise see.

type Caller ¶

type Caller struct {
	// UserID is the caller's UUID identity, the owner key for assets.
	UserID string
	// Email is the caller's canonical identity, the owner key for memory
	// and insights.
	Email string
	// Persona is the caller's resolved persona. It scopes entity-keyed memory
	// lookups and selects which persona-scoped prompts are visible. It is not a
	// security boundary on its own (per-user records are scoped by Email/UserID);
	// it narrows persona-targeted content.
	Persona string
}

Caller is the resolved identity of the requester. Per-user providers scope on it, and they do not all key on the same field: captured memory and insights are owned by email (memory_records.created_by), while managed assets are owned by the user's UUID (assets.owner_id). Both fields travel on every request so each provider selects the one it scopes on; a provider whose key is empty must return no results rather than query unscoped.

func (c Caller) Anonymous() bool

type CatalogProvider ¶ added in v1.91.0

type CatalogProvider struct {
	// contains filtered or unexported fields
}

CatalogProvider exposes the technical catalog (DataHub) to the router. It serves two query shapes: a relevance search on Intent (folding datahub_search into search) and an exact entity-keyed lookup on EntityURNs that returns the catalog entity itself, so handing search a dataset URN surfaces its catalog entry alongside the URN-linked memory and insights. Structured catalog navigation (platform/domain/tag/entity-type filters) stays in datahub_browse.

It is shared: the catalog is global, so it is queried for every request and needs no caller identity.

DataHub ranks search results but does not return a numeric score, so the provider derives a descending positional score from the result order; entity-keyed hits take the max score. The router's per-provider normalization then places these on the common scale.

func NewCatalogProvider(searcher tableSearcher) *CatalogProvider

func (p *CatalogProvider) Fetch(ctx context.Context, ref string, _ Caller) (*Document, bool, error)

func (*CatalogProvider) Name() string

func (*CatalogProvider) Scope() Scope

func (p *CatalogProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type ConnectionInfo ¶

type ConnectionInfo struct {
	Name        string
	Kind        string
	Description string
}

ConnectionInfo is one configured data connection, reduced to the fields a relevance search needs. The knowledge package defines it (rather than importing the platform's connection types) so the federation engine stays decoupled; the platform adapts its connection registry to ConnectionLister.

type ConnectionLister ¶

type ConnectionLister interface {
	Connections() []ConnectionInfo
}

ConnectionLister enumerates the deployment's configured connections. The platform implements it over the same toolkit registry list_connections uses, so the search corpus and the connections tool stay in agreement.

type ConnectionsProvider ¶

type ConnectionsProvider struct {
	// contains filtered or unexported fields
}

ConnectionsProvider exposes configured connections to the router as a relevance search. Connections are in the default corpus by design (#645): an agent should discover that, say, a "stripe" or "warehouse" connection exists from one search, rather than having to know to call list_connections first. list_connections stays the full enumeration; this surfaces the connections relevant to a query.

It is shared: connection metadata (name, kind, description) is already globally visible through list_connections, so there is no per-user record to scope here. The security-sensitive boundary is which connections a persona may use, and that is enforced fail-closed at tool-call time on the scoped tools (trino_query, api_invoke_endpoint, ...), unchanged by this provider.

func NewConnectionsProvider(lister ConnectionLister) *ConnectionsProvider

func (p *ConnectionsProvider) Fetch(_ context.Context, ref string, _ Caller) (*Document, bool, error)

func (*ConnectionsProvider) Name() string

func (*ConnectionsProvider) Scope() Scope

func (p *ConnectionsProvider) Search(_ context.Context, q Query) ([]Hit, error)

type ContextDocumentsProvider ¶ added in v1.91.0

type ContextDocumentsProvider struct {
	// contains filtered or unexported fields
}

ContextDocumentsProvider surfaces DataHub context documents in unified search (#692). Context documents are the non-dataset knowledge home that predates knowledge pages; before this source they were undiscoverable from search (the catalog provider only searched datasets), so the knowledge in them was stranded. The catalog is global, so this is a shared source queried for every request.

func NewContextDocumentsProvider(searcher semantic.DocumentSearcher) *ContextDocumentsProvider

func (p *ContextDocumentsProvider) Browse(ctx context.Context, q BrowseQuery) (BrowsePage, error)

func (p *ContextDocumentsProvider) Fetch(ctx context.Context, ref string, _ Caller) (*Document, bool, error)

func (*ContextDocumentsProvider) Name() string

func (*ContextDocumentsProvider) Scope() Scope

func (p *ContextDocumentsProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type Document ¶ added in v1.92.0

type Document struct {
	// Reference is the canonical citation that was dereferenced (echoed back so a
	// caller can re-cite or cache by it).
	Reference string `json:"reference"`
	// Source is the provider provenance label (the same Source a search Hit carries).
	Source string `json:"source"`
	// Title is a short human label for the content (page title, document title,
	// dataset name, asset name, prompt display name, connection name).
	Title string `json:"title,omitempty"`
	// Body is the full textual content for text-bodied sources (knowledge page
	// markdown, context-document body, prompt content). Empty for purely structured
	// sources (a dataset, an asset, a connection), which carry their payload in
	// Content instead.
	Body string `json:"body,omitempty"`
	// Content is the source-native full payload for sources whose record is
	// structured (a dataset's TableContext, an asset's metadata, a connection
	// descriptor, the full prompt record). A source may populate both Body and
	// Content when it has a primary text body and structured metadata around it (a
	// prompt fills Body with its text and Content with the whole record); a purely
	// text-bodied source (knowledge page, context document) leaves Content nil.
	Content any `json:"content,omitempty"`
	// EntityURNs are the catalog entities this content is about, when the source
	// links any (a context document's related assets, a dataset's own URN).
	EntityURNs []string `json:"entity_urns,omitempty"`
	// References are the outbound links this content declares: the other pages and
	// entities it points to, as citable references a caller can fetch in turn (#705).
	// A knowledge page populates these from its tracked entity references, so an agent
	// can deliberately deep-crawl the knowledge graph (fetch the index, follow into
	// the relevant branch) instead of re-parsing links out of the markdown body.
	References []DocumentRef `json:"references,omitempty"`
}

Document is the full, dereferenced content of a reference that search emitted on a Hit. It is the consumer of the Reference field that every searchable source already produces: search returns navigational pointers with truncated snippets, and fetch turns one pointer back into the whole record.

A source fills the shape that fits it: text-bodied sources (knowledge pages, context documents, prompts) put their full text in Body, while structured sources (a catalog dataset's context, a managed asset's metadata, a connection's descriptor) put their native payload in Content. Reference echoes the resolved reference and Source is the provider provenance, so a caller can cite the result the same way search let it cite the pointer.

type DocumentRef ¶ added in v1.94.0

type DocumentRef struct {
	Reference string `json:"reference"`
	Type      string `json:"type"`
}

DocumentRef is one outbound link a Document declares (#705): a reference string a caller can fetch, plus its target type so the caller can decide whether to crawl it (another knowledge page, a dataset, an asset, a connection, ...).

type EndpointCandidate ¶

type EndpointCandidate struct {
	Connection  string
	OperationID string
	Method      string
	Path        string
	Summary     string
	Spec        string
	Score       float64
}

EndpointCandidate is one API operation matched by an endpoint searcher, already ranked and scoped within its API gateway connection. The knowledge package defines it (rather than importing the apigateway concrete) so the federation engine stays decoupled from any one toolkit; the platform adapts each apigateway toolkit to EndpointSearcher.

type EndpointSearcher ¶

type EndpointSearcher interface {
	SearchEndpoints(ctx context.Context, intent string, limit int) ([]EndpointCandidate, error)
}

EndpointSearcher ranks API operations across the connections of one API gateway toolkit, applying that toolkit's per-connection route policy so a caller never sees an operation their persona could not invoke. The platform wires one EndpointSearcher per apigateway toolkit.

type EndpointsProvider ¶

type EndpointsProvider struct {
	// contains filtered or unexported fields
}

EndpointsProvider exposes API endpoints to the router as a relevance search, aggregated across every API gateway toolkit. API endpoints are in the default corpus by design (#645): an agent searching "customer retention" should see a relevant operation next to the dataset and the insight without first having to know an API gateway exists, list connections, and search each one. api_list_endpoints stays the scoped drill-down, the way datahub_browse is the scoped counterpart to catalog search.

It is shared: endpoints are global to the deployment, and each searcher enforces its own per-connection route policy fail-closed, so the provider needs no caller identity of its own.

func NewEndpointsProvider(searchers ...EndpointSearcher) *EndpointsProvider

func (*EndpointsProvider) Name() string

func (*EndpointsProvider) Scope() Scope

func (p *EndpointsProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type Fetcher ¶ added in v1.92.0

type Fetcher interface {
	// Fetch dereferences ref to its full content for caller.
	//
	// owned reports whether ref is a form this provider recognizes. When false the
	// Router moves on to the next provider and doc/err are ignored, so a provider
	// must cheaply decline references that are not its own rather than erroring.
	//
	// When owned is true: a nil err returns doc; ErrNotFound means the reference is
	// well-formed and this provider's, but resolves to nothing the caller may read
	// (deleted, never existed, or out of the caller's scope) and is rendered as a
	// structured not-found; any other err is a real fetch failure (store/transport).
	//
	// A per-user provider must scope the read to caller exactly as its Search does:
	// a reference the caller could not have searched must return ErrNotFound, not
	// content, so fetch never widens what a persona can see.
	Fetch(ctx context.Context, ref string, caller Caller) (doc *Document, owned bool, err error)
}

Fetcher is the optional capability of a Provider to dereference a reference (the canonical citation string search emits on a Hit) to its full content. A provider that can search a store can usually also read one record from it by id; implementing Fetcher exposes that as the other half of search. A provider that does not implement Fetcher is search-only, and the Router skips it when fetching.

The Router asks each scope-permitted Fetcher in turn whether it owns a reference and returns the first owner's content, so ownership across providers is partitioned by reference form (mcp:knowledge_page:, urn:li:dataset:, ...) and never ambiguous.

type Hit ¶

type Hit struct {
	Text       string   `json:"text"`
	Source     string   `json:"source"`
	Ref        string   `json:"ref"`
	Score      float64  `json:"score"`
	Status     string   `json:"status,omitempty"`
	EntityURNs []string `json:"entity_urns,omitempty"`
	Dimension  string   `json:"dimension,omitempty"`
	// CapturedBy is the author (email) of an authored result such as an insight,
	// so a reviewer can see who recorded it. Omitted for sources with no single
	// author (catalog datasets, API endpoints, connections).
	CapturedBy string `json:"captured_by,omitempty"`
	// Reference is the canonical citation string for the hit's entity
	// (mcp:<type>:<key> for an internal entity, urn:... for DataHub), so an agent
	// can reference it from a knowledge page without hand-assembling or guessing
	// the form. Omitted when the entity is not referenceable.
	Reference string `json:"reference,omitempty"`
}

Hit is one knowledge record matched by a provider. Score is the provider's own relevance score; the Router normalizes it across providers before fusing, so callers see a fused rank, not the raw provider score. Source is the provider name, surfaced as provenance. Ref is the record's stable identifier within its source (memory id, insight id, asset id) so a caller can fetch the full record.

The optional fields carry what the specialized search tools returned, so folding them into one search loses nothing: Status is a review or lifecycle state (insight pending/approved/...), EntityURNs are the linked catalog entities (provenance), and Dimension is the memory dimension or category. They are omitted when a source does not populate them.

Temporal validity (valid_from/valid_until) and a live-vs-captured freshness flag remain deferred until a provider populates them (the wiki carries season windows); adding them now would be unexercised fields.

type InsightsProvider ¶

type InsightsProvider struct {
	// contains filtered or unexported fields
}

InsightsProvider exposes captured domain knowledge (insights) to the router.

Insights are knowledge-dimension memory rows owned by the caller (insight.captured_by == caller email). The underlying store scopes to that owner and to the knowledge dimension, so this provider covers exactly the records the MemoryProvider skips.

Scope note (#632): the epic envisions reviewed insights becoming shared across callers. The current store has no review-state-aware sharing, and searching it without an owner would expose every user's personal insights, so PR1 keeps this provider per-user. Promoting reviewed insights to ScopeShared is deferred to the write-path/review work (#633).

func NewInsightsProvider(store insightSource) *InsightsProvider

func (p *InsightsProvider) Fetch(ctx context.Context, ref string, caller Caller) (*Document, bool, error)

func (*InsightsProvider) Name() string

func (*InsightsProvider) Scope() Scope

func (p *InsightsProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type LineageExpander ¶

type LineageExpander interface {
	Expand(ctx context.Context, urns []string) []string
}

LineageExpander optionally widens a set of entity URNs along lineage so an entity-keyed lookup also recalls knowledge about upstream and downstream datasets (the old memory_recall "graph" strategy). Implemented by an adapter over the semantic provider; a nil expander disables expansion, leaving a plain entity lookup.

It lives on the Router, not on any single provider, so the expansion runs once per search and every entity-keyed provider (memory, insights, the technical catalog) sees the same widened URN set, the same way the query embedding is computed once and shared.

func NewLineageExpander(sem semantic.Provider) LineageExpander

type MemoryProvider ¶

type MemoryProvider struct {
	// contains filtered or unexported fields
}

MemoryProvider exposes a caller's personal memory to the knowledge router.

It is per-user: results are restricted to records the caller owns (memory_records.created_by == caller email), the same identity the portal's "my knowledge" search scopes on. It serves two query shapes: relevance search on Intent, and an exact entity-keyed lookup on EntityURNs. Lineage expansion of the entity URNs is the Router's responsibility (so it runs once for every entity-keyed provider), so this provider takes the URN set as given.

It deliberately omits the knowledge dimension on both paths. Captured insights and remembered knowledge are knowledge-dimension memory rows owned by the InsightsProvider; surfacing them here too would double-list the same record. This provider covers the caller's non-knowledge memory (preferences, events, entities, relationships).

func NewMemoryProvider(store memorySearcher) *MemoryProvider

func (p *MemoryProvider) Fetch(ctx context.Context, ref string, caller Caller) (*Document, bool, error)

func (*MemoryProvider) Name() string

func (*MemoryProvider) Scope() Scope

func (p *MemoryProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type PageSearcher ¶ added in v1.89.0

type PageSearcher interface {
	Search(ctx context.Context, q knowledgepage.SearchQuery) ([]knowledgepage.ScoredPage, error)
	ListPagesReferencing(ctx context.Context, ref knowledgepage.EntityRef) ([]knowledgepage.PageRef, error)
	// Get reads one page by id (the other half of search: a hit's reference
	// dereferenced to the full body). Returns knowledgepage.ErrNotFound for a
	// missing id.
	Get(ctx context.Context, id string) (*knowledgepage.Page, error)
	// List returns the offset/limit page of live pages plus the total live-page
	// count, ordered deterministically, for exhaustive enumeration (#695).
	List(ctx context.Context, filter knowledgepage.Filter) ([]knowledgepage.Page, int, error)
	// ListEntityRefs returns the references a page declares (the pages and entities
	// it links to), so a fetch can surface the page's outbound graph edges (#705).
	ListEntityRefs(ctx context.Context, pageID string) ([]knowledgepage.EntityRef, error)
}

PageSearcher is what the provider needs from the knowledge-page store: relevance search over page content (the text path) and the reverse lookup of the pages that reference an entity (the entity path, #634). Declared locally so the provider depends on the capability and tests can supply a fake.

type PagesProvider ¶ added in v1.88.0

type PagesProvider struct {
	// contains filtered or unexported fields
}

PagesProvider exposes the platform's canonical knowledge pages (the internal-knowledge home for business/domain ontology) to the router. Pages are org-shared, so this provider is shared: it is queried for every request and needs no caller identity, and it never holds per-user records.

func NewKnowledgePagesProvider(searcher PageSearcher) *PagesProvider

func (p *PagesProvider) Browse(ctx context.Context, q BrowseQuery) (BrowsePage, error)

func (p *PagesProvider) Fetch(ctx context.Context, ref string, _ Caller) (*Document, bool, error)

func (*PagesProvider) Name() string

func (*PagesProvider) Scope() Scope

func (p *PagesProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type PromptSearcher ¶ added in v1.92.0

type PromptSearcher interface {
	Search(ctx context.Context, q prompt.SearchQuery) ([]prompt.ScoredPrompt, error)
	GetByID(ctx context.Context, id string) (*prompt.Prompt, error)
}

PromptSearcher is what the prompts provider needs from the prompt store: relevance search over visible prompts (the text path) and a by-id read (fetch). The concrete postgres prompt store satisfies it; declared here so the provider depends on the capability and the platform asserts one authority for "a searchable, fetchable prompt store".

type PromptsProvider ¶

type PromptsProvider struct {
	// contains filtered or unexported fields
}

PromptsProvider exposes operational prompts to the router. Prompt visibility is mixed: global prompts are visible to everyone, while persona- and personal-scoped prompts are visible only to the matching caller. The underlying searcher enforces that visibility from the caller identity, so the provider is shared (always queried, returning at least the global prompts even for an anonymous caller) yet never leaks another caller's personal prompts.

func NewPromptsProvider(searcher PromptSearcher) *PromptsProvider

func (p *PromptsProvider) Fetch(ctx context.Context, ref string, caller Caller) (*Document, bool, error)

func (*PromptsProvider) Name() string

func (*PromptsProvider) Scope() Scope

func (p *PromptsProvider) Search(ctx context.Context, q Query) ([]Hit, error)

type Provider ¶

type Provider interface {
	Name() string
	Scope() Scope
	Search(ctx context.Context, q Query) ([]Hit, error)
}

Provider is one searchable knowledge store behind the Router. Name is the provenance label stamped on every Hit. Scope drives the Router's access rules. Search returns the provider's own ranked hits for the query; the Router owns cross-provider normalization and fusion, so a provider only needs to rank within itself.

type Query ¶

type Query struct {
	Intent     string
	Embedding  []float32
	EntityURNs []string
	Status     string
	Caller     Caller
	Limit      int
	Sources    []string
}

Query is one knowledge search. It carries two complementary ways to match, and a provider uses whichever it supports:

• Intent is natural-language text matched by relevance. Embedding is the query vector the Router computes once from Intent and shares across providers; nil selects lexical-only ranking.
• EntityURNs is an exact, entity-keyed lookup: return knowledge linked to these DataHub URNs (memory uses this, optionally expanded along lineage).

At least one of Intent or EntityURNs is set. Status optionally filters by lifecycle/review state where a provider tracks one (insight review status). Caller carries the identity per-user providers scope on. Limit caps the candidate list each provider returns before the allocator builds the balanced display set.

Sources optionally narrows the federation to a subset of provider names (e.g. ["datahub"]). It only narrows: an empty Sources queries every provider the caller can access, and a name in Sources never opts a caller into a provider their scope would otherwise exclude.

type Result ¶

type Result struct {
	Groups   []SourceGroup
	Coverage []SourceCoverage
	Ranking  string
	// UnknownSources lists requested Sources names that match no known source (a
	// typo or an unsupported source), so a caller is told why a narrowed search
	// returned little or nothing instead of being silently given an empty result.
	UnknownSources []string
}

Result is one knowledge search response: the balanced, grouped-by-source display set, the coverage summary (per-source matched vs shown counts so the agent sees breadth beyond what is displayed), and the ranking mode used to produce it.

type Router ¶

type Router struct {
	// contains filtered or unexported fields
}

Router fans one query across every registered provider, normalizes each provider's local relevance scores onto a common scale, fuses them into one ranked list, and enforces per-user scope. It is the single read path behind both the search tool and (later) push injection, so the scope and fusion rules live here once rather than in each surface.

func NewRouter(embedder embedding.Provider, lineage LineageExpander, providers ...Provider) *Router

func (r *Router) BrowsableSources() []string

func (r *Router) Browse(ctx context.Context, source string, q BrowseQuery) (BrowsePage, error)

func (r *Router) Fetch(ctx context.Context, ref string, caller Caller) (*Document, error)

func (r *Router) Providers() []Provider

func (r *Router) Search(ctx context.Context, q Query) (Result, error)

type Scope ¶

type Scope int

Scope declares whether a provider's records are visible to every caller or only to the caller who owns them. The Router uses it to decide which providers a request may touch and with what identity.

const (
	// ScopeShared marks a provider that is queried for every request, with or
	// without a caller identity, because it can always return at least some
	// content visible to everyone (the technical catalog, global prompts). A
	// shared provider may still use the caller identity to widen what it
	// returns (a prompt provider adds the caller's persona/personal prompts to
	// the global ones); "shared" means "always queried", not "ignores the
	// caller". It must never return another caller's private records.
	ScopeShared Scope = iota

	// ScopePerUser marks a provider whose records belong to individual
	// callers (personal memory, personal assets). The Router queries a
	// per-user provider only when the request carries the identity that
	// provider scopes on, and the provider must restrict results to that
	// identity. This is the security boundary that keeps one user's private
	// records out of another user's search.
	ScopePerUser
)

func (s Scope) String() string

type SourceCoverage ¶

type SourceCoverage struct {
	Source  string `json:"source"`
	Matched int    `json:"matched"`
	Shown   int    `json:"shown"`
}

SourceCoverage reports, per source, how many candidates matched the query and how many of those are shown in the grouped result. Matched can exceed Shown when the balanced allocator spent its budget elsewhere; that gap is the anti-tunnel signal that tells the agent where unshown answers live ("14 datasets matched, 3 shown"). Matched is the count of candidates the provider returned for this query, capped at the per-source candidate fetch limit, not a full-corpus count.

type SourceGroup ¶

type SourceGroup struct {
	Source string `json:"source"`
	Hits   []Hit  `json:"hits"`
}

SourceGroup is the displayed hits for one source, in that source's own relevance order. Grouping by source (rather than one flat relevance list) is the anti-tunnel shape: the agent sees that answers exist across memory, the catalog, endpoints, and prompts at once, instead of a top list one strong source dominates.

type ThreadSearcher ¶ added in v1.90.0

type ThreadSearcher interface {
	SearchThreads(ctx context.Context, ownerEmail, intent string, limit int) ([]threads.Thread, error)
}

ThreadSearcher is the lexical feedback-thread search the provider needs. The postgres thread store implements it; declared here so the provider depends on the capability and tests can supply a fake.

type ThreadsProvider ¶ added in v1.90.0

type ThreadsProvider struct {
	// contains filtered or unexported fields
}

ThreadsProvider federates a caller's feedback threads into unified search, so feedback they have given is discoverable knowledge alongside the catalog, insights, and pages. It closes the gap where feedback was the one knowledge source not in the search corpus (#686): the loop now reads feedback, not only writes it. Threads carry no embedding, so this is a lexical source; it is per-user (author email) and fails closed on an empty caller email, never surfacing another user's feedback.

func NewThreadsProvider(store ThreadSearcher) *ThreadsProvider

func (*ThreadsProvider) Name() string

func (*ThreadsProvider) Scope() Scope

func (p *ThreadsProvider) Search(ctx context.Context, q Query) ([]Hit, error)