portal

type Config struct {
	Name            string
	AssetStore      portal.AssetStore
	ShareStore      portal.ShareStore
	VersionStore    portal.VersionStore
	CollectionStore portal.CollectionStore
	ThreadStore     portal.ThreadStore
	S3Client        portal.S3Client
	S3Bucket        string
	S3Prefix        string
	BaseURL         string
	MaxContentSize  int // max asset content size in bytes (0 = no limit)

	// Embedder embeds search queries for the ranked `search` action. When nil
	// or the noop placeholder, search degrades to lexical-only ranking (the
	// store decides via embedding.EmbedForSearch).
	Embedder embedding.Provider

	// CaptureProvenance resolves which calls an asset write was built from
	// (#1320). Injected by the platform, which owns the audit log the capture
	// is read from. Nil leaves an asset recording its session and owner but no
	// calls — what a deployment without audit gets.
	CaptureProvenance portal.ProvenanceCapturer

	// Directory resolves a person's name to their address for the share
	// action (#1280). Nil (no database, so no directory) leaves sharing
	// working by email address only.
	Directory DirectoryReader
}

type DirectoryReader interface {
	List(ctx context.Context, filter user.Filter) ([]user.User, int, error)
}

type RegisterOptions struct {
	// Repair asks for a corrected version of the file to be saved and
	// registered when the file cannot be read as a table the way it is stored;
	// without it such a file is refused and the refusal says what is wrong
	// with it.
	Repair bool
	// Follow moves the table onto each new revision or version of the file
	// as it is written; off, the table is pinned to the version it was
	// registered over. It is the resolved choice: the tool defaults it to on
	// when the caller says nothing.
	Follow bool
}

type ResourceHoldReader interface {
	ResourceHolds(ctx context.Context, resourceID string) (ResourceHolds, error)
}

type ResourceHolds struct {
	Assets  int `json:"assets"`
	Prompts int `json:"prompts"`
	// More says a count was cut at the bound rather than being the whole of
	// what points at the file. It is reported rather than left implicit
	// because a short count read as a complete one is the mistake this answer
	// exists to prevent.
	More bool `json:"more,omitempty"`
}

type ResourceWriter interface {
	// Create files new content as a managed resource, refusing a scope the
	// caller may not write to.
	Create(ctx context.Context, in resource.NewResource, claims resource.Claims) (*resource.Resource, error)
	// Replace records new content as the resource's next revision, keeping the
	// id, the canonical URI and the filename, and returns the version number
	// the content was recorded as.
	Replace(
		ctx context.Context, id string, up resource.RevisionUpload, claims resource.Claims,
	) (*resource.Resource, int, error)
	// Get reads a resource the caller may see. A replacement resolves the file
	// before it decodes anything, so a reference naming a file that is not
	// there is refused without the payload being read, and so type detection
	// is given the stored filename rather than a name the caller offered --
	// the filename is what a replacement must not change.
	Get(ctx context.Context, id string, claims resource.Claims) (*resource.Resource, error)
	// Locate reads the resource filed at an address, and reports the canonical
	// mcp:// URI that address names whether or not anything is filed there
	// (#1665). Nothing being there is an answer rather than an error: it is
	// what a create-or-replace decides on, and what a lookup of an empty
	// address reports.
	Locate(
		ctx context.Context, addr toolkit.ResourceAddress, claims resource.Claims,
	) (found *resource.Resource, uri string, err error)
	// List returns the resources filed under a folder that the caller may see,
	// newest first, with the total the page was cut from.
	List(
		ctx context.Context, q toolkit.ResourceQuery, claims resource.Claims,
	) (found []resource.Resource, total int, err error)
	// Delete removes a resource and the objects its content lives in,
	// returning the record that was removed. The authority is the authority to
	// change the file, the same rule replacing its content meets.
	Delete(ctx context.Context, id string, claims resource.Claims) (*resource.Resource, error)
}

type TableRegistrar interface {
	// Register makes the referenced file queryable, under the options the
	// caller chose for the registration.
	Register(ctx context.Context, reference, connection, tableName string, opts RegisterOptions) (*TableRegistration, error)
	Unregister(ctx context.Context, registrationID string) error
	Tables(ctx context.Context, reference string) ([]TableRegistration, error)
	// DropAssetTables removes every table registered over an asset. It is what
	// a delete calls: the asset is going, and a table over where its file used
	// to be would answer queries from a schema its owner can no longer see.
	// Best-effort by contract -- a delete must not fail because a scratch table
	// could not be dropped.
	DropAssetTables(ctx context.Context, assetID string)
	// DropResourceTables is DropAssetTables for a deleted managed resource
	// (#1665). The REST delete route already reaches this through the store's
	// own delete hook; a tool call does not cross that route, so the toolkit
	// calls it itself and both doors leave the same state behind.
	DropResourceTables(ctx context.Context, resourceID string)
	// FollowAssetTables and FollowResourceTables are what a write of a new
	// version calls (#1536): every following registration over the file is
	// moved onto the version written, and every registration over it is
	// reported -- followed, pinned and now behind, or not movable and why --
	// as the sentences the write's result carries. Best-effort by contract,
	// like the delete: the file changed, and that write succeeded whatever
	// happened to the tables over it.
	FollowAssetTables(ctx context.Context, assetID string, version int) []string
	FollowResourceTables(ctx context.Context, resourceID string, version int) []string
}

type TableRegistration struct {
	RegistrationID string   `json:"registration_id"`
	Connection     string   `json:"connection"`
	QueryTable     string   `json:"query_table"`
	Columns        []string `json:"columns,omitempty"`
	SampleSQL      string   `json:"sample_sql,omitempty"`
	RegisteredBy   string   `json:"registered_by,omitempty"`
	// Stale means the file has a newer revision or version than the one the
	// table points at, so the rows are the content that was current when it
	// was registered.
	Stale bool `json:"stale"`
	// Follow means the table is moved onto each new revision or version of
	// the file as it is written (#1536); without it the table is pinned to
	// the version it was registered over. FollowError is why the last follow
	// did not move it, empty while the table is where the file is.
	Follow      bool   `json:"follow"`
	FollowError string `json:"follow_error,omitempty"`
	// Repair means the table corrects its file: a new version carrying a
	// defect a reader cannot see past that the platform can correct is saved
	// corrected, as the file's next version, and the table is moved onto that
	// version (#1577). It is the choice made when the table was registered.
	Repair bool `json:"repair"`
	// Repaired says what a correction of the file changed before it could be
	// registered, and is empty when none was needed (#1441). The file itself
	// changed, so the person who asked for the registration is told so.
	Repaired string `json:"repaired,omitempty"`
	// TableChanges is what a replacing registration found about the OTHER
	// tables on the connection after its DROP ran (#1546): one sentence per
	// table that no longer exists. Empty when every other table is still
	// there.
	//
	// It is a change report, not an inventory, and it is named apart from the
	// `tables` a reader queries for that reason (#1666).
	TableChanges []string `json:"table_changes,omitempty"`
}

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