embed

type ContextualEmbedder interface {
	Embedder
	EmbedDocumentChunks(ctx context.Context, fullDoc string, chunks []string) ([][]float64, error)
}

type Embedder interface {
	Fingerprint() string
	Dimension(ctx context.Context) (int, error)
	EmbedDocuments(ctx context.Context, texts []string) ([][]float64, error)
	EmbedQueries(ctx context.Context, texts []string) ([][]float64, error)
}

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

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

type OpenAIConfig struct {
	BaseURL string
	Model   string

	// Timeout bounds a single embeddings HTTP attempt. With
	// MaxRetries=0 this is also the total wall-clock budget for a
	// single-batch call. With MaxRetries > 0 the wall-clock extends
	// beyond Timeout: each attempt is still bounded by Timeout, but
	// retries and Retry-After / backoff waits stack on top — see
	// MaxRetries for details.
	//
	// For multi-batch calls the embedder schedules a safety-net
	// parent deadline of approximately:
	//
	//   batches * ((MaxRetries+1) * Timeout + MaxRetries * 30s)
	//
	// where batches = ceil(len(texts)/MaxBatchSize) and 30s is the
	// embed-side cap on each inter-retry Retry-After / backoff wait.
	// Each sub-request keeps a full per-attempt window even when an
	// earlier batch retried through a rate limit, so a slow or
	// retrying early batch cannot starve later batches. The formula
	// saturates at math.MaxInt64 nanoseconds on overflow.
	//
	// A zero or negative value selects defaultOpenAITimeout (15s) at
	// NewOpenAI time. Callers that need a hard global cap should pass
	// a ctx with their own deadline; the embedder honors whichever
	// deadline trips first.
	Timeout  time.Duration
	APIToken string

	// MaxRetries caps the number of retry attempts after a retryable
	// failure (429, 5xx, connection reset, timeout). Zero disables
	// retries. A negative value is normalized to zero at NewOpenAI
	// time so a config typo or bad env parse cannot silently
	// short-circuit every request. Retry-After is always honoured
	// when present, up to an embed-side cap of embedMaxRetryAfter
	// (30s) per gap. Mirrors chat.OpenAIConfig.MaxRetries semantics
	// so consumers that swap between chat and embed get the same
	// retry surface.
	//
	// Retries replay the embeddings POST unchanged — no idempotency
	// key is sent — so on ambiguous transport failures (timeout,
	// connection reset) an upstream that already processed the first
	// attempt may bill both. Self-hosted gateways generally have no
	// billing concern; callers hitting real OpenAI with cost ceilings
	// should leave this at zero or cap it tightly.
	MaxRetries int

	// MaxBatchSize caps how many inputs are sent in a single embeddings
	// request. EmbedDocuments and EmbedQueries chunk their input into
	// sub-requests of at most this size and concatenate the results in
	// order. Zero or negative values select defaultOpenAIMaxBatchSize
	// (512), which is conservative for self-hosted gateways; real OpenAI
	// accepts up to 2048 per request, and operators who know their
	// upstream can raise this explicitly.
	MaxBatchSize int
}