config

type A2AConfig struct {
	Enabled   bool   `yaml:"enabled"`
	Host      string `yaml:"host"`
	Port      int    `yaml:"port"`
	PublicURL string `yaml:"public_url"`

	// Credentials gates incoming A2A requests. When empty the server
	// is unauthenticated (the historical behaviour); when a token is
	// set, every request must present it as a bearer token.
	Credentials A2ACredentials `yaml:"credentials"`
}

type A2ACredentials struct {
	// Token is the expected bearer credential. A literal string is
	// used verbatim; a ${secret:NAME} placeholder is expanded from
	// the secrets store at boot so the token never lives in
	// baifo.yaml in plaintext. Empty disables authentication.
	Token string `yaml:"token"`
}

type AgentLLM struct {
	Provider string `yaml:"provider"`
	Model    string `yaml:"model"`

	// Reasoning is the optional reasoning-effort knob for models that
	// support it: one of "minimal" / "low" / "medium" / "high" (empty
	// or "off" leaves the model's own default). Use list_models to see
	// which models accept reasoning and at which levels. Applied to
	// openai (reasoning_effort), gemini (thinking) and anthropic
	// (extended-thinking budget).
	Reasoning string `yaml:"reasoning"`

	// ReasoningAPI optionally overrides which Anthropic reasoning API the
	// model uses: "enabled" (classic budget-based, for Claude 3.7 /
	// Sonnet 4 / Opus 4) or "adaptive" (effort-based, for Opus 4.5+).
	// Empty auto-detects from the catalogue. Only anthropic uses it;
	// other providers ignore it.
	// Ref: https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
	ReasoningAPI string `yaml:"reasoning_api"`
}

type AgentTemplate struct {
	// Root marks the always-on entry-point agent. Exactly one
	// entry in agents.yaml must set this to true; the loader
	// rejects zero and more-than-one root setups. The flagged
	// agent receives the spawn / memory / todos tools and a
	// secrets allower of AllowAll regardless of AllowedSecrets;
	// all other entries are treated as ordinary spawnable
	// sub-agents.
	Root bool `yaml:"root,omitempty"`

	// Utility marks the background utility agent: the cheap model
	// baifo uses for internal chores that don't deserve the root's
	// (usually expensive) model — today, titling sessions and
	// summarising conversations for context-window compaction. At
	// most one entry may set it; when none does, those chores fall
	// back to the root's LLM. The utility agent never chats, never
	// receives tools and is not spawnable — only its llm block is
	// consumed.
	Utility bool `yaml:"utility,omitempty"`

	Name           string             `yaml:"name"`
	Description    string             `yaml:"description"`
	Prompt         string             `yaml:"prompt"`
	LLM            AgentLLM           `yaml:"llm"`
	Skills         []string           `yaml:"skills"`
	MCPs           []string           `yaml:"mcps"`
	ContextGuard   ContextGuardConfig `yaml:"context_guard"`
	AllowedSecrets []string           `yaml:"allowed_secrets"`
}

type AgentsFile struct {
	Version int             `yaml:"version"`
	Agents  []AgentTemplate `yaml:"agents"`
}

type BackoffConfig struct {
	// Initial is the wait before the first retry (a duration string
	// like "1s", "500ms"). Subsequent waits grow by Multiplier.
	Initial string `yaml:"initial"`

	// Max caps how long a single wait can grow to, so the exponential
	// growth does not blow up to minutes. Duration string.
	Max string `yaml:"max"`

	// Multiplier is the exponential growth factor between attempts.
	// Values <= 1 fall back to the default so the backoff still grows.
	Multiplier float64 `yaml:"multiplier"`

	// Jitter, when true, randomises each wait in the range
	// [delay/2, delay] to avoid synchronised retry storms across
	// concurrent workers. Default true.
	Jitter *bool `yaml:"jitter"`
}

type Config struct {
	Version       int              `yaml:"version"`
	EncryptionKey string           `yaml:"encryption_key"`
	Runtime       RuntimeConfig    `yaml:"runtime"`
	Guardrails    GuardrailsConfig `yaml:"guardrails"`
	Theme         ThemeConfig      `yaml:"theme"`
	A2A           A2AConfig        `yaml:"a2a"`
	Providers     []ProviderEntry  `yaml:"providers"`
	MCPs          []MCPEntry       `yaml:"mcps"`
	Spawn         SpawnConfig      `yaml:"spawn"`
	Secrets       SecretsConfig    `yaml:"secrets"`
}

type ContextGuardConfig struct {
	Enabled   bool   `yaml:"enabled"`
	Strategy  string `yaml:"strategy"`
	MaxTokens int    `yaml:"max_tokens"`
	MaxTurns  int    `yaml:"max_turns"`
}

type GuardrailsConfig struct {
	// TrimOversizedUserText truncates oversized user-role text parts
	// in the request sent to the model. "User text" covers more than
	// what the human types: when a session is resumed under a different
	// agent name, the ADK injects the old transcript (tool dumps
	// included) AS user-role text ("For context: [agent] ..."), which
	// can flood the context window. Model turns and native tool-result
	// blocks are never touched. The trim is ephemeral per-request; the
	// stored session keeps full fidelity.
	TrimOversizedUserText TrimOversizedUserTextConfig `yaml:"trim_oversized_user_text"`
}

type MCPAuth struct {
	// Kind selects the auth mechanism: "none" (default), "oauth".
	Kind string `yaml:"kind"`

	// ClientID is the OAuth client identifier. Optional; empty enables
	// CIMD/DCR discovery on first authenticate.
	ClientID string `yaml:"client_id"`

	// ClientSecretRef is the name of an entry in secrets.yaml whose
	// value is the OAuth client secret. Never the secret itself.
	ClientSecretRef string `yaml:"client_secret_ref"`

	// Registration selects how baifo obtains an OAuth client when no
	// pre-registered ClientID is set. One of:
	//
	//   - "auto" (default): advertise both CIMD (Client ID Metadata
	//     Document) and DCR (RFC 7591). The MCP SDK prefers CIMD when
	//     the authorization server announces support for it, otherwise
	//     it registers dynamically.
	//   - "cimd": advertise ONLY CIMD. Use when you know the AS
	//     supports it and want to avoid creating a DCR client.
	//   - "dcr": advertise ONLY DCR. Use this when the AS announces
	//     CIMD support but rejects our client_id URL (e.g. the domain
	//     is not whitelisted in the IdP), which would otherwise make
	//     the SDK pick CIMD and fail without falling back.
	//
	// Ignored when ClientID/ClientSecretRef are set (those force the
	// client_credentials grant).
	Registration string `yaml:"registration"`
}

type MCPEntry struct {
	Name string `yaml:"name"`
	Type string `yaml:"type"`

	// builtin
	Builtin string `yaml:"builtin"`

	// http
	Endpoint string            `yaml:"endpoint"`
	Headers  map[string]string `yaml:"headers"`
	Insecure bool              `yaml:"insecure"`

	// stdio
	Command string            `yaml:"command"`
	Args    []string          `yaml:"args"`
	Env     map[string]string `yaml:"env"`
	Workdir string            `yaml:"workdir"`

	// Auth holds the optional authentication block. When absent or with
	// kind=none, the MCP is treated as unauthenticated (Headers may still
	// carry static tokens — they are orthogonal to auth.kind).
	Auth MCPAuth `yaml:"auth"`

	// Options carries per-entry tuning for builtin MCPs. Flat by design:
	// option keys are prefixed by category (limit_*) instead of nested,
	// so the block stays one level deep and easy to autocomplete. Only
	// meaningful for type=builtin (each builtin reads the keys it knows;
	// unknown-to-that-builtin keys are ignored).
	Options MCPOptions `yaml:"options"`
}

type MCPOptions struct {
	// LimitExecOutputChars caps stdout and stderr (each, separately)
	// returned by the exec and process_status tools of the builtin
	// filesystem MCP. 0 = default (48000). -1 = unlimited.
	LimitExecOutputChars int `yaml:"limit_exec_output_chars"`

	// LimitReadFileChars caps the total content returned by a single
	// read_file call of the builtin filesystem MCP. 0 = default
	// (120000). -1 = unlimited.
	LimitReadFileChars int `yaml:"limit_read_file_chars"`

	// LimitSearchOutputChars caps the total content (matched lines plus
	// their context) returned by a single search call of the builtin
	// filesystem MCP. Independent of max_results, which only bounds the
	// number of matches, not their size. 0 = default (50000).
	// -1 = unlimited.
	LimitSearchOutputChars int `yaml:"limit_search_output_chars"`
}

type ProviderEntry struct {
	Name    string            `yaml:"name"`
	Type    string            `yaml:"type"`
	URL     string            `yaml:"url"`
	Auth    string            `yaml:"auth"` // "api_key" (default) | "oauth"
	APIKey  string            `yaml:"api_key"`
	Headers map[string]string `yaml:"headers"`

	// Streaming controls whether agents backed by this provider run
	// in SSE streaming mode. A pointer so an omitted field means "use
	// the default" (streaming ON) rather than the zero value. Set it
	// to false only for OpenAI-compatible endpoints that do not
	// implement Server-Sent Events; those reject a streaming request
	// or hang. Streaming is required for long Anthropic turns (the API
	// refuses non-streamed responses that may exceed 10 minutes, which
	// high reasoning budgets can), so leave it on for Anthropic.
	Streaming *bool `yaml:"streaming"`
}

type RetryConfig struct {
	// Enabled turns retries on. Default false (no retries) when the
	// whole block is absent; the loader flips it on when the user
	// provides any retry field, so writing a block implies intent.
	Enabled *bool `yaml:"enabled"`

	// MaxAttempts is the TOTAL number of tries, including the first.
	// 1 means "no retry". Values < 1 are treated as the default.
	MaxAttempts int `yaml:"max_attempts"`

	// Strategy selects how the wait before each retry is computed:
	//
	//   "backoff"      exponential backoff from the Backoff block (default).
	//   "retry-after"  honour the provider's Retry-After header when the
	//                  failure carries one (e.g. a 429 rate limit), and
	//                  fall back to the exponential backoff otherwise.
	Strategy string `yaml:"strategy"`

	// Backoff holds the exponential-backoff knobs. They drive the
	// "backoff" strategy and act as the fallback for "retry-after"
	// when no header is present.
	Backoff BackoffConfig `yaml:"backoff"`
}

type RuntimeConfig struct {
	LogLevel              string `yaml:"log_level"`
	LogFormat             string `yaml:"log_format"`
	LogFile               string `yaml:"log_file"`
	RedactLogs            *bool  `yaml:"redact_logs"`
	AutoResumeSession     *bool  `yaml:"auto_resume_session"`
	ChatAutoScroll        *bool  `yaml:"chat_auto_scroll"`
	ChatKeepToolsExpanded *bool  `yaml:"chat_keep_tools_expanded"`

	// Retry controls how baifo retries failing LLM provider API calls
	// (rate limits, overloads, transient network errors) with an
	// incremental exponential backoff. Absent / disabled means no
	// retries (the historical behaviour).
	Retry RetryConfig `yaml:"retry"`
}

type SecretsConfig struct {
	RedactInLogs *bool `yaml:"redact_in_logs"`
	RedactInTUI  *bool `yaml:"redact_in_tui"`

	// ScrubToolResults toggles the comprehensive-redaction pass that
	// runs after every tool call. The targeted pass (scrubbing the
	// raw values the BeforeToolCallback just substituted) is always
	// on; this knob controls the *additional* sweep that scans the
	// result for ANY value currently in `secrets.yaml`, even ones
	// the model never asked for.
	//
	// Recommended: leave it on. It defends against the "tools that
	// emit secrets they were not given" class of leak — e.g. an MCP
	// echoing a debug header that happens to contain the value of a
	// secret stored under a different name. The cost is a small
	// number of substring scans per tool call; for typical
	// deployments (a few dozen secrets, tool results under a few
	// hundred KB) it adds milliseconds.
	//
	// Default when omitted: true.
	ScrubToolResults *bool `yaml:"scrub_tool_results"`

	// MinScrubLength is the minimum length (in bytes) a stored
	// secret value must have to be eligible for the comprehensive
	// pass. Below this floor the value is skipped to avoid
	// catastrophic false positives — e.g. a secret stored with
	// value "1234" would otherwise redact every "1234" anywhere in
	// any tool result, mangling file contents, JSON numbers, port
	// numbers, you name it.
	//
	// Choose a floor high enough that legitimate substrings of that
	// length almost never appear by accident in tool output, but
	// not so high that real, short secrets stop being protected.
	// The trade-off is direct: HIGHER values → FEWER false
	// positives but MORE secrets bypassed; LOWER values → MORE
	// values protected but MORE chance of redacting unrelated text.
	//
	// Reference points:
	//   -  8 bytes (default) — protects every API key worth
	//      protecting; lets values up to 7 bytes (PINs, short
	//      passwords) escape the comprehensive pass.
	//   - 12 bytes — most modern API keys fit (`ghp_*`, `sk-*`,
	//      `AKIA…`). Short personal secrets are filtered out.
	//   - 16 bytes — only long, high-entropy values are scanned.
	//
	// Short secrets (below the floor) remain protected by the
	// targeted pass when the LLM explicitly references them via
	// `${secret:NAME}`. Only the "leaked from nowhere" scenario is
	// excluded for those values — which is generally acceptable
	// because short, low-entropy secrets are not the threat model
	// the comprehensive pass exists for.
	//
	// 0 or negative disables the floor entirely (every length is
	// scrubbed). Documented as dangerous and not recommended.
	//
	// Default when omitted: 8.
	MinScrubLength *int `yaml:"min_scrub_length"`
}

type SpawnConfig struct {
	Mode           string        `yaml:"mode"`
	CollectTimeout time.Duration `yaml:"collect_timeout"`
}

type ThemeConfig struct {
	NerdFonts bool `yaml:"nerd_fonts"`
}

type TrimOversizedUserTextConfig struct {
	// Enabled toggles this guardrail. Default FALSE when absent:
	// guardrails are opt-in (pointer-bool kept for symmetry with the
	// rest of the config and so an explicit `enabled: false` is
	// distinguishable from an absent block in future migrations).
	Enabled *bool `yaml:"enabled"`

	// MaxChars caps each user-role text part, in characters.
	// 0 / absent = default (DefaultTrimOversizedUserTextMaxChars).
	// Positive = explicit cap.
	// Disabling is done via enabled: false, not via this field.
	MaxChars int `yaml:"max_chars"`
}