parser

type ACPDeclaration struct {
	Token  lexer.Token // the 'acp' token
	Name   *Identifier
	Config map[string]Expression
}

type AgentDeclaration struct {
	Token  lexer.Token // the 'agent' token
	Name   *Identifier
	Config map[string]Expression
}

type ArrayLiteral struct {
	Token    lexer.Token // the '[' token
	Elements []Expression
}

type AssignmentStatement struct {
	Token          lexer.Token // the '=' token or identifier token
	Left           Expression  // can be Identifier or IndexExpression
	TypeAnnotation *Identifier // optional type annotation (e.g., ": string")
	Value          Expression
	// Legacy field for backward compatibility
	Name *Identifier
}

type BinaryExpression struct {
	Token    lexer.Token // the operator token
	Left     Expression
	Operator string
	Right    Expression
}

type BlockStatement struct {
	Token      lexer.Token // the '{' token
	Statements []Statement
}

type BooleanLiteral struct {
	Token lexer.Token
	Value bool
}

type BreakStatement struct {
	Token lexer.Token // the 'break' token
}

type CallExpression struct {
	Token     lexer.Token // the '(' token
	Function  Expression  // Identifier or MemberExpression
	Arguments []Expression
}

type CatchClause struct {
	Token     lexer.Token // the 'catch' token
	Parameter *Identifier // error parameter
	Block     *BlockStatement
}

type ContinueStatement struct {
	Token lexer.Token // the 'continue' token
}

type ExportStatement struct {
	Token       lexer.Token // The 'export' token
	Declaration Statement   // The declaration being exported (tool, variable assignment, etc.)
	Name        string      // The name of the exported symbol (extracted from declaration)
}

type Expression interface {
	Node
	// contains filtered or unexported methods
}

type ExpressionStatement struct {
	Token      lexer.Token // the first token of the expression
	Expression Expression
}

type FinallyClause struct {
	Token lexer.Token // the 'finally' token
	Block *BlockStatement
}

type ForOfStatement struct {
	Token    lexer.Token // the 'for' token
	Variable *Identifier
	Iterable Expression
	Body     *BlockStatement
}

type Identifier struct {
	Token lexer.Token // the token.IDENT token
	Value string
}

type IfStatement struct {
	Token       lexer.Token // the 'if' token
	Condition   Expression
	Consequence *BlockStatement
	Alternative Statement // can be another IfStatement (for else if) or BlockStatement (for else)
}

type ImportStatement struct {
	Token   lexer.Token    // The 'import' token
	Path    *StringLiteral // The import path
	Symbols []string       // Symbols to import (empty for side-effect imports)
}

type IndexExpression struct {
	Token lexer.Token // the '[' token
	Left  Expression  // the array or object being indexed
	Index Expression  // the index expression
}

type McpDeclaration struct {
	Token  lexer.Token // the 'mcp' token
	Name   *Identifier
	Config map[string]Expression
}

type MemberExpression struct {
	Token    lexer.Token // the '.' token
	Object   Expression
	Property *Identifier
}

type ModelDeclaration struct {
	Token  lexer.Token // the 'model' token
	Name   *Identifier
	Config map[string]Expression
}

type Node interface {
	TokenLiteral() string
	String() string
}

type NullLiteral struct {
	Token lexer.Token // the 'null' token
}

type NumberLiteral struct {
	Token lexer.Token // the token.NUMBER token
	Value string
}

type ObjectLiteral struct {
	Token lexer.Token // the '{' token
	Pairs map[string]Expression
	Order []string // preserve insertion order for String()
}

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

type PipeExpression struct {
	Token lexer.Token // the '|' token
	Left  Expression
	Right Expression
}

type Program struct {
	Statements []Statement
}

type ReturnStatement struct {
	Token       lexer.Token // the 'return' token
	ReturnValue Expression  // optional return value
}

type Statement interface {
	Node
	// contains filtered or unexported methods
}

type StringLiteral struct {
	Token      lexer.Token // the token.STRING token
	Value      string
	IsTemplate bool // true if this is a template literal (backtick string)
}

type ThrowStatement struct {
	Token      lexer.Token // the 'throw' token
	Expression Expression  // the value to throw (required)
}

type ToolDeclaration struct {
	Token      lexer.Token // the 'tool' token
	Name       *Identifier
	Parameters []*ToolParameter
	ReturnType *Identifier // optional return type annotation
	Body       *BlockStatement
}

type ToolParameter struct {
	Name *Identifier
	Type *Identifier // optional type annotation
}

type TryStatement struct {
	Token         lexer.Token // the 'try' token
	Block         *BlockStatement
	CatchClause   *CatchClause
	FinallyClause *FinallyClause
}

type UnaryExpression struct {
	Token    lexer.Token // the operator token
	Operator string
	Right    Expression
}

type WhileStatement struct {
	Token     lexer.Token // the 'while' token
	Condition Expression
	Body      *BlockStatement
}