documentreader

type APIError struct {
	Status int
	Body   string
}

type Chunk struct {
	Filename    string         `json:"filename"`
	ChunkIndex  int            `json:"chunk_index"`
	Text        string         `json:"text"`
	RawText     string         `json:"raw_text"`
	NumTokens   *int           `json:"num_tokens"`
	Headings    []string       `json:"headings"`
	Captions    []string       `json:"captions"`
	PageNumbers []int          `json:"page_numbers"`
	DocItems    []string       `json:"doc_items"`
	Metadata    map[string]any `json:"metadata"`
}

type ChunkOptions struct {
	MaxTokens         int
	Tokenizer         string
	MergePeers        *bool
	UseMarkdownTables *bool
	UseMarkdownImages *bool
	ImagePlaceholder  string
	IncludeRawText    *bool
	ConvertOptions    ConvertOptions
}

type ChunkParser func(rawBody []byte) ([]Chunk, error)

type ConversionResult struct {
	// Markdown is the full document rendered as Markdown.
	Markdown string

	// Images are the pictures extracted from the document (inline figures, diagrams).
	// Each image carries a base64-encoded data URI so the agent can view them.
	Images []ExtractedImage

	// PageCount is the number of pages (0 if unknown).
	PageCount int
}

type ConvertOptions struct {
	FromFormats        []string
	ToFormats          []string
	DoOCR              *bool
	ForceOCR           *bool
	DoTableStructure   *bool
	TableMode          string
	PDFBackend         string
	Pipeline           string
	OCRLang            []string
	ImageExportMode    string
	IncludePageImages  *bool
	IncludeImages      *bool
	AbortOnError       *bool
	DocumentTimeoutSec *float64
	ImagesScale        *float64
}

type ConvertParser func(rawBody []byte) (*ConversionResult, error)

type Converter interface {
	HealthChecker
	ConvertFile(ctx context.Context, filePath string) (*ConversionResult, error)
	ConvertBytes(ctx context.Context, data []byte, filename string) (*ConversionResult, error)
	ConvertURL(ctx context.Context, docURL string) (*ConversionResult, error)
}

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

type ExtractedImage struct {
	// Filename is the suggested on-disk name (e.g. "image_0001.png").
	Filename string
	// MimeType is the image MIME type (e.g. "image/png").
	MimeType string
	// Base64 is the raw base64-encoded image bytes (no data-URI prefix).
	Base64 string
}

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

type GenericConfig struct {
	// BaseURL is the server's base URL, e.g. "http://localhost:5100" for a
	// local seshat-intelligence instance. Required.
	BaseURL string

	// FileField is the multipart form field name the server expects the
	// uploaded file under. docling-serve uses "files"; seshat-intelligence
	// uses "file" (FastAPI's UploadFile parameter is named `file` in its
	// route signature, and FastAPI binds the multipart field name to the
	// parameter name). Required.
	FileField string

	// ConvertPath is the endpoint ConvertFile/ConvertBytes POST the file
	// to, e.g. "/v1/documents" for seshat-intelligence (vs docling-serve's
	// "/v1/convert/file"). Leave empty (with ParseConvert nil) to leave
	// conversion unsupported - ConvertFile/ConvertBytes/ConvertURL then
	// return a clear error instead of attempting a request.
	ConvertPath  string
	ParseConvert ConvertParser

	// ChunkPath is the endpoint ChunkHybridBytes/ChunkHybridFile POST the
	// file to, e.g. "/v1/documents/chunks" for seshat-intelligence (vs
	// docling-serve's "/v1/chunk/hybrid/file"). Leave empty (with
	// ParseChunk nil) to leave chunking unsupported.
	ChunkPath  string
	ParseChunk ChunkParser

	// ChunkFields maps the ChunkOptions of a call (the size the chunks should have, for one) onto the form fields the
	// server's chunk endpoint takes, by name. docling-serve has its own mapping (see ChunkOptions); an arbitrary
	// server has its own names, or none. Leave nil to send the file alone.
	ChunkFields func(ChunkOptions) map[string]string

	// HealthPath is the endpoint IsAvailable GETs. Defaults to "/health" -
	// true for both docling-serve and seshat-intelligence today, but
	// overridable for a server that names it differently.
	HealthPath string

	// The remaining fields mirror Client's own Options (see their doc
	// comments in client.go) - a plain config struct here instead of the
	// same functional-options pattern, since a concrete backend's adapter
	// typically builds one GenericConfig value up front rather than
	// composing it incrementally.
	HTTPClient       *http.Client
	Timeout          time.Duration
	APIKey           string
	TenantID         string
	UserAgent        string
	MaxResponseBytes int64
	Retry            RetryConfig

	// HealthCacheTTL caches IsAvailable results for this duration, mirroring
	// WithHealthCacheTTL. nil (the zero value - easy to get by accident by
	// simply not setting this field) keeps Client's own default (5s), not
	// "disabled" - a pointer, not a plain time.Duration, specifically so an
	// unset field can't be silently misread as an explicit request to
	// disable caching. Pass a pointer to 0 to actually disable it.
	HealthCacheTTL *time.Duration
}

type HealthChecker interface {
	IsAvailable(ctx context.Context) bool
}

type HybridChunker interface {
	HealthChecker
	ChunkHybridBytes(ctx context.Context, data []byte, filename string, opts ChunkOptions) ([]Chunk, error)
}

type Option func(*DoclingClient)

type RetryConfig struct {
	MaxAttempts int
	BaseDelay   time.Duration
	MaxDelay    time.Duration
}