action

type ActionIdentity struct {
	// ID is the unique identifier for the actor.
	ID string
	// Name is the display name of the actor.
	Name string
	// Roles are the roles assigned to the actor.
	Roles []string
	// SessionID is the session identifier for the actor.
	SessionID string
}

type ActionInterceptor interface {
	// Intercept processes a CanonicalAction and returns the result.
	// Returns the (possibly modified) action and an error if rejected.
	Intercept(ctx context.Context, action *CanonicalAction) (*CanonicalAction, error)
}

type ActionInterceptorFunc func(ctx context.Context, action *CanonicalAction) (*CanonicalAction, error)

type ActionType string

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

type ApprovalResult struct {
	Approved bool
	Reason   string
}

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

type CanonicalAction struct {

	// Identity identifies the actor performing the action.
	Identity ActionIdentity

	// Type categorizes the action (tool_call, http_request, etc.).
	Type ActionType
	// Name is the action name (tool name, HTTP method, command name, etc.).
	Name string
	// Arguments contains the action parameters (tool args, query params, etc.).
	Arguments map[string]interface{}

	// Destination captures the target of the action.
	Destination Destination

	// Protocol is the originating protocol (mcp, http, websocket, runtime).
	Protocol string
	// Framework is the agent framework (crewai, autogen, langchain, etc.).
	Framework string
	// Gateway is the gateway that received the action (mcp-gateway, http-gateway, runtime).
	Gateway string

	// RequestTime is when the action was received.
	RequestTime time.Time
	// RequestID uniquely identifies this action request.
	RequestID string
	// Metadata is an extensible bag for protocol-specific data.
	Metadata map[string]interface{}

	// OriginalMessage stores the original protocol-specific message
	// (e.g., *mcp.Message, *http.Request) for denormalization.
	OriginalMessage interface{}
}

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

type DNSResolverOption func(*DNSResolver)

type Decision string

type Destination struct {
	// URL is the full URL if available.
	URL string
	// Domain is the domain name (e.g., "api.example.com").
	Domain string
	// IP is the resolved IP address.
	IP string
	// Port is the port number (0 = unset).
	Port int
	// Scheme is the protocol scheme (http, https, ws, wss, etc.).
	Scheme string
	// Path is the URL path or file path.
	Path string
	// Command is the command name for command_exec actions.
	Command string
	// CmdArgs are the command arguments for command_exec actions.
	CmdArgs []string
}

type ExtractOptions struct {
	// Base64Decode enables base64 decoding of string values before extraction.
	Base64Decode bool
	// MaxDepth is the maximum recursion depth (default 10 when 0).
	MaxDepth int
}

type ExtractedURL struct {
	// RawValue is the original string value found.
	RawValue string
	// URL is the parsed full URL (or constructed from IP:port).
	URL string
	// Domain is the domain name (empty if IP address).
	Domain string
	// IP is the IP address if directly specified (empty if domain).
	IP string
	// Port is the port number (0 if not specified, 80/443 inferred from scheme).
	Port int
	// Scheme is the protocol scheme (http, https, ws, wss, etc.).
	Scheme string
	// Path is the URL path.
	Path string
	// Source is the argument key path where found (e.g., "url", "config.endpoint").
	Source string
}

type HTTPNormalizer struct{}

type InterceptResult struct {
	// Decision is the evaluation outcome (allow, deny, approval_required).
	Decision Decision
	// Reason explains why the decision was made.
	Reason string
	// RuleID is the identifier of the rule that produced this result.
	RuleID string
	// RuleName is the human-readable name of the matching rule.
	RuleName string
	// HelpURL points to documentation about why the action was blocked.
	HelpURL string
	// HelpText provides inline guidance about the decision.
	HelpText string
	// Modifications contains optional modifications to the action
	// (e.g., argument rewriting, header injection).
	Modifications map[string]interface{}
	// ApprovalTimeout is how long to wait for human approval.
	ApprovalTimeout time.Duration
	// ApprovalTimeoutAction is the fallback decision when approval times out.
	ApprovalTimeoutAction Decision
}

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

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

type MCPNormalizer struct{}

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

type Normalizer interface {
	// Normalize converts a protocol-specific message to a CanonicalAction.
	// The original message is stored in CanonicalAction.OriginalMessage
	// for denormalization on the response path.
	Normalize(ctx context.Context, msg interface{}) (*CanonicalAction, error)

	// Denormalize converts an InterceptResult back to a protocol-specific response.
	// Uses CanonicalAction.OriginalMessage to construct the response.
	// For allow decisions, returns the original message.
	// For deny decisions, returns nil and an error describing the denial.
	Denormalize(action *CanonicalAction, result *InterceptResult) (interface{}, error)

	// Protocol returns the protocol name this normalizer handles (e.g., "mcp").
	Protocol() string
}

type OutboundDenyError struct {
	Domain   string
	IP       string
	Port     int
	RuleName string
	HelpText string
	HelpURL  string
	Reason   string
}

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

type OutboundRule struct {
	// ID uniquely identifies this rule.
	ID string
	// Name is the human-readable rule name.
	Name string
	// Mode is blocklist or allowlist.
	Mode RuleMode
	// Targets are the target specifications for this rule.
	Targets []OutboundTarget
	// Action is what happens when the rule matches (block, alert, log).
	Action RuleAction
	// Scope is empty for global rules, otherwise a scope identifier (Phase 4).
	Scope string
	// Priority determines evaluation order (lower = higher priority).
	Priority int
	// Enabled controls whether this rule is active.
	Enabled bool
	// Base64Scan enables base64 URL decoding in URL extraction (OUT-04).
	Base64Scan bool
	// HelpText is shown in deny messages (OUT-10).
	HelpText string
	// HelpURL is a link shown in deny messages (OUT-10).
	HelpURL string
	// ReadOnly is true for default blocklist rules that cannot be modified or deleted.
	ReadOnly bool
	// CreatedAt is when this rule was created.
	CreatedAt time.Time
	// UpdatedAt is when this rule was last modified.
	UpdatedAt time.Time
}

type OutboundRuleStore interface {
	// List returns all rules sorted by Priority ascending.
	List(ctx context.Context) ([]OutboundRule, error)
	// Get returns a single rule by ID. Returns ErrOutboundRuleNotFound if not found.
	Get(ctx context.Context, id string) (*OutboundRule, error)
	// Save creates or updates a rule in the store.
	Save(ctx context.Context, rule *OutboundRule) error
	// Delete removes a rule by ID. Returns ErrOutboundRuleNotFound if not found.
	Delete(ctx context.Context, id string) error
}

type OutboundTarget struct {
	// Type is the kind of target (domain, ip, cidr, domain_glob, port_range).
	Type TargetType
	// Value is the target value (e.g., "evil.com", "10.0.0.0/8", "*.ngrok.io", "1-1024").
	Value string
}

type PendingApproval struct {
	ID            string                 `json:"id"`
	ToolName      string                 `json:"tool_name"`
	Arguments     map[string]interface{} `json:"arguments,omitempty"`
	IdentityName  string                 `json:"identity_name"`
	IdentityID    string                 `json:"identity_id"`
	Status        string                 `json:"status"` // "pending", "approved", "denied", "timed_out"
	CreatedAt     time.Time              `json:"created_at"`
	Timeout       time.Duration          `json:"-"`
	TimeoutAction policy.Action          `json:"-"`
	// contains filtered or unexported fields
}

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

type QuarantineChecker interface {
	IsQuarantined(toolName string) bool
}

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

type ResolvedDest struct {
	// Domain is the original domain that was resolved.
	Domain string
	// IPs contains all resolved IP addresses.
	IPs []string
	// PinnedIP is the first resolved IP, pinned for the request lifetime
	// to prevent DNS rebinding attacks.
	PinnedIP string
	// CachedAt is when this resolution was cached.
	CachedAt time.Time
	// TTL is how long this cache entry is valid.
	TTL time.Duration
}

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

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

type RuleAction string

type RuleMode string

type ScanFinding struct {
	// PatternName is the identifier of the matched pattern (e.g., "system_prompt_override").
	PatternName string
	// PatternCategory groups related patterns (e.g., "prompt_injection", "delimiter_escape").
	PatternCategory string
	// MatchedText is the text that matched, truncated to 100 characters.
	MatchedText string
	// Position is the byte offset where the match starts in the scanned content.
	Position int
}

type ScanMode string

type ScanResult struct {
	// Detected is true if one or more patterns matched.
	Detected bool
	// Findings contains all pattern matches found.
	Findings []ScanFinding
	// ScanDurationNs is how long the scan took in nanoseconds.
	ScanDurationNs int64
}

type TargetType string