guard

type AgentLabelsPayload struct {
	Secrecy   []string `json:"secrecy"`
	Integrity []string `json:"integrity"`
}

type BackendCaller interface {
	// CallTool makes a read-only call to the backend MCP server
	// This is used by guards to gather metadata for labeling
	CallTool(ctx context.Context, toolName string, args interface{}) (interface{}, error)
}

type ContextKey string

type Guard interface {
	// Name returns the identifier for this guard (e.g., "github", "noop")
	Name() string

	// LabelAgent initializes guard policy and returns effective agent/session state
	// for the current session.
	// Returns:
	//   - result: effective labels, mode, and normalized policy
	//   - error: any validation/initialization error
	LabelAgent(ctx context.Context, policy interface{}, backend BackendCaller, caps *difc.Capabilities) (*LabelAgentResult, error)

	// LabelResource determines the resource being accessed and its labels
	// This may call the backend (via BackendCaller) to gather metadata needed for labeling
	// Returns:
	//   - resource: The labeled resource (simple or nested structure for fine-grained filtering)
	//   - operation: The type of operation (Read, Write, or ReadWrite)
	//   - error: Any error that occurred during labeling
	LabelResource(ctx context.Context, toolName string, args interface{}, backend BackendCaller, caps *difc.Capabilities) (*difc.LabeledResource, difc.OperationType, error)

	// LabelResponse labels the response data after a successful backend call
	// This is used for fine-grained filtering of collections
	// Returns:
	//   - labeledData: The response data with per-item labels (if applicable)
	//   - error: Any error that occurred during labeling
	// If the guard returns nil for labeledData, the reference monitor will use the
	// resource labels from LabelResource for the entire response
	LabelResponse(ctx context.Context, toolName string, result interface{}, backend BackendCaller, caps *difc.Capabilities) (difc.LabeledData, error)
}

type GuardFactory func() (Guard, error)

type LabelAgentResult struct {
	Agent            AgentLabelsPayload     `json:"agent"`
	DIFCMode         string                 `json:"difc_mode"`
	NormalizedPolicy map[string]interface{} `json:"normalized_policy,omitempty"`
}

type NoopGuard struct{}

type PipelineAccessDenied struct {
	EvalResult  *difc.EvaluationResult
	Resource    *difc.LabeledResource
	AgentLabels *difc.AgentLabels
}

type PipelineInput struct {
	// AgentID identifies the agent in the registry (e.g. "proxy" or an MCP session agent ID).
	AgentID string
	// ToolName is the guard tool name for this request.
	ToolName string
	// Args are the tool arguments; they are stored in context for LabelResponse (Phase 4).
	Args interface{}
	// Guard performs DIFC labeling operations (LabelResource, LabelResponse).
	Guard Guard
	// Evaluator runs coarse-grained and fine-grained DIFC access checks.
	Evaluator *difc.Evaluator
	// AgentRegistry holds per-agent label state.
	AgentRegistry *difc.AgentRegistry
	// Capabilities is the DIFC capability set passed to the guard.
	Capabilities *difc.Capabilities
	// EnforcementMode is the active DIFC enforcement mode.
	EnforcementMode difc.EnforcementMode
	// BackendCaller is used by the guard for metadata enrichment calls.
	BackendCaller BackendCaller
}

type PipelinePreResult struct {
	// AgentLabels is the agent's current label set (updated in Phase 6 for propagate mode).
	AgentLabels *difc.AgentLabels
	// Resource is the labeled resource returned by Phase 1.
	Resource *difc.LabeledResource
	// Operation is the operation type determined in Phase 1.
	Operation difc.OperationType
	// CoarseOutcome is the Phase 2 coarse-grained check outcome.
	CoarseOutcome difc.CoarseCheckOutcome
	// EvalResult is the Phase 2 evaluation result (contains Reason for denial messages).
	EvalResult *difc.EvaluationResult
}

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

type RequestState interface{}

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

type WasmGuardOptions struct {
	// Stdout is the writer for WASM stdout output. Defaults to os.Stderr if nil.
	Stdout io.Writer
	// Stderr is the writer for WASM stderr output. Defaults to os.Stderr if nil.
	Stderr io.Writer
	// CompilationCache overrides the process-level compilation cache.
	// If nil and DisableCompilationCache is false, the shared globalCompilationCache is used.
	CompilationCache wazero.CompilationCache
	// DisableCompilationCache, when true, prevents any compilation cache from being used
	// even if a global or per-instance cache is available. This can be useful to avoid
	// unbounded memory growth when many distinct WASM binaries are loaded over the
	// lifetime of a long-lived process.
	DisableCompilationCache bool
}

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