ir

type AgentNode struct {
	BaseNode
	LLMFields
	SchemaFields
	InteractionFields
	MCP              *MCPConfig // node-level MCP activation/filtering
	ActiveMCPServers []string   // populated after project config resolution
	Publish          string     // persistent artifact name (empty if not set)
	Session          SessionMode
	Tools            []string // tool capability names
	ToolPolicy       []string // per-node tool policy patterns (nil = inherit workflow)
	ToolMaxSteps     int      // max tool-use iterations (0 = not set)
	AwaitMode        AwaitMode
	Compaction       *Compaction // per-node compaction overrides (nil = inherit workflow)
}

type AwaitMode = types.AwaitMode

type BaseNode struct {
	ID string // unique identifier (= DSL name)
}

type Budget struct {
	MaxParallelBranches int
	MaxDuration         string // e.g. "60m"
	MaxCostUSD          float64
	MaxTokens           int
	MaxIterations       int
}

type Compaction struct {
	Threshold      float64 // 0 = inherit (env / 0.85 default)
	PreserveRecent int     // 0 = inherit (default 4)
}

type CompileResult struct {
	Workflow    *Workflow
	Diagnostics []Diagnostic
}

type ComputeExpr struct {
	Key string    // output field name
	AST *expr.AST // parsed expression
	Raw string    // original source for diagnostics / unparse
}

type ComputeNode struct {
	BaseNode
	SchemaFields
	Exprs     []*ComputeExpr // ordered field-name → parsed AST pairs
	AwaitMode AwaitMode
}

type DataMapping struct {
	Key  string // target input field name
	Refs []*Ref // parsed references from the template value
	Raw  string // original template string for debugging
}

type DiagCode string

type Diagnostic struct {
	Code     DiagCode
	Severity Severity
	Message  string
	NodeID   string
	EdgeID   string
	Hint     string
}

type DoneNode struct {
	BaseNode
	AwaitMode AwaitMode // convergence strategy when multiple branches arrive
}

type Edge struct {
	From string // source node ID
	To   string // target node ID

	// Condition (optional). Condition is a field name from the source
	// node's output schema. Negated inverts the check. Mutually exclusive
	// with Expression: the compiler chooses one form per edge.
	Condition string
	Negated   bool

	// Expression (optional). When non-nil, this parsed expression replaces
	// Condition/Negated and is evaluated against the source node's output
	// (exposed as `input`/`outputs.<self>`), the run vars, artifacts, and
	// loop/run namespaces.
	Expression    *expr.AST
	ExpressionSrc string // original source string preserved for unparse/debug

	// Loop reference (optional). LoopName references a Loop in Workflow.Loops.
	LoopName string

	// Data mappings (optional). Each entry maps a target input field
	// to a resolved reference expression.
	With []*DataMapping
}

type FailNode struct {
	BaseNode
	AwaitMode AwaitMode // convergence strategy when multiple branches arrive
}

type FieldType = types.FieldType

type HumanNode struct {
	BaseNode
	SchemaFields
	InteractionFields
	Publish      string
	MinAnswers   int    // minimum answers required
	Instructions string // prompt reference for human instructions
	Model        string // model for LLM-based interaction modes
	SystemPrompt string // prompt reference for LLM-based interaction modes
	AwaitMode    AwaitMode
}

type InteractionFields struct {
	Interaction       InteractionMode // interaction handling mode
	InteractionPrompt string          // prompt reference guiding LLM for llm_or_human decisions
	InteractionModel  string          // model for llm/llm_or_human modes (fallback to Model)
}

type InteractionMode = types.InteractionMode

type JudgeNode struct {
	BaseNode
	LLMFields
	SchemaFields
	InteractionFields
	MCP              *MCPConfig
	ActiveMCPServers []string
	Publish          string
	Session          SessionMode
	Tools            []string
	ToolPolicy       []string // per-node tool policy patterns (nil = inherit workflow)
	ToolMaxSteps     int
	AwaitMode        AwaitMode
	Compaction       *Compaction // per-node compaction overrides (nil = inherit workflow)
}

type LLMFields struct {
	Model           string // model identifier (env refs already noted)
	Backend         string // execution backend name (empty = direct LLM call)
	SystemPrompt    string // prompt reference name
	UserPrompt      string // prompt reference name
	MaxTokens       int    // per-node cap on output tokens (0 = backend default)
	ReasoningEffort string // reasoning effort level: "low", "medium", "high", "xhigh", "max"
	Readonly        bool   // when true, node is not considered mutating for workspace safety
}

type Loop struct {
	Name          string
	MaxIterations int
}

type MCPAuth struct {
	// Type is the authentication scheme. The only supported value is
	// "oauth2"; other values produce a C-code diagnostic.
	Type string

	// AuthURL is the OAuth authorization endpoint the user's browser
	// visits to consent.
	AuthURL string

	// TokenURL is the back-channel endpoint that issues access and
	// refresh tokens.
	TokenURL string

	// RevokeURL is the optional RFC 7009 revocation endpoint.
	RevokeURL string

	// ClientID is the OAuth client identifier registered with the
	// provider.
	ClientID string

	// Scopes is the set of OAuth scopes requested at authorization.
	Scopes []string
}

type MCPConfig struct {
	AutoloadProject *bool
	Inherit         *bool
	Servers         []string
	Disable         []string
}

type MCPServer struct {
	Name      string
	Transport MCPTransport
	Command   string
	Args      []string
	URL       string
	Headers   map[string]string
	Auth      *MCPAuth
}

type MCPTransport = types.MCPTransport

type MermaidView int

type Node interface {
	NodeID() string
	NodeKind() NodeKind
}

type NodeKind int

type Prompt struct {
	Name         string
	Body         string // raw template text
	TemplateRefs []*Ref // references found in the body
}

type Ref struct {
	Kind RefKind
	Path []string // dotted path segments after the namespace
	Raw  string   // original template expression, e.g. "{{outputs.node.field}}"
}

type RefKind int

type RouterMode = types.RouterMode

type RouterNode struct {
	BaseNode
	LLMFields              // only populated for RouterLLM mode
	RouterMode  RouterMode // fan_out_all, condition, round_robin, or llm
	RouterMulti bool       // LLM router: select multiple targets (default: one)
}

type Schema struct {
	Name   string
	Fields []*SchemaField
}

type SchemaField struct {
	Name       string
	Type       FieldType
	EnumValues []string // non-nil only if enum constraint present
}

type SchemaFields struct {
	InputSchema  string // schema reference name (empty if not set)
	OutputSchema string // schema reference name (empty if not set)
}

type SessionMode = types.SessionMode

type Severity int

type ToolNode struct {
	BaseNode
	SchemaFields
	Command     string // command to execute, may contain {{...}} template refs
	CommandRefs []*Ref // parsed template references in Command (resolved at runtime)
	Session     SessionMode
	AwaitMode   AwaitMode
}

type Var struct {
	Name       string
	Type       VarType
	HasDefault bool
	Default    interface{} // string, int64, float64, or bool
}

type VarType int

type Workflow struct {
	Name           string
	Entry          string             // entry node ID
	Nodes          map[string]Node    // node ID → node
	Edges          []*Edge            // ordered list of edges
	Schemas        map[string]*Schema // schema name → resolved schema
	Prompts        map[string]*Prompt // prompt name → resolved prompt
	Vars           map[string]*Var    // var name → resolved variable
	Loops          map[string]*Loop   // loop name → loop definition
	Budget         *Budget            // workflow budget (nil if not set)
	Compaction     *Compaction        // workflow-level compaction overrides (nil = no override)
	MCP            *MCPConfig         // workflow-level MCP activation/filtering
	DefaultBackend string             // workflow-level default backend (empty = not set)
	ToolPolicy     []string           // workflow-level tool policy patterns (nil = open)
	Interaction    *InteractionMode   // workflow-level default interaction mode (nil = not set)
	Worktree       string             // "auto" runs in a per-run git worktree; "" or "none" runs in-place
	// MCPServers contains the explicit top-level declarations from the .iter file.
	MCPServers map[string]*MCPServer
	// ActiveMCPServers and ResolvedMCPServers are populated after project config
	// resolution, not by the compiler itself.
	ActiveMCPServers   []string
	ResolvedMCPServers map[string]*MCPServer
}