Method agent_declaration

aiscript-vm/src/parser/mod.rs:257–336

(&mut self, visibility: Visibility)

    }

    fn agent_declaration(&mut self, visibility: Visibility) -> Option<Stmt<'gc>> {
        self.consume(TokenType::Identifier, "Expect agent name.");
        let name = self.previous;
        self.scopes.push(name.lexeme.to_owned());
        self.consume(TokenType::OpenBrace, "Expect '{' before agent body.");
        let mut fields = HashMap::new();
        while !self.check(TokenType::CloseBrace) && !self.check(TokenType::Fn) && !self.is_at_end()
        {
            let (key, value) = self.field_declaration()?;
            match key.lexeme {
                "instructions" | "model" | "tool_choice" => {
                    if !matches!(
                        value,
                        Expr::Literal {
                            value: Literal::String { .. },
                            ..
                        }
                    ) {
                        self.error(&format!(
                            "Field '{}' in agent declaration should be a string.",
                            key.lexeme
                        ));
                        continue;
                    }
                }
                "tools" => {
                    if !matches!(value, Expr::List { .. }) {
                        self.error("Field 'tools' in agent declaration should be an array.");
                        continue;
                    }
                }
                invalid => self.error_at(
                    key,
                    &format!("Invalid field '{}' in agent declaration.", invalid),
                ),
            }

            if fields.contains_key(key.lexeme) {
                self.error_at(
                    key,
                    &format!("Duplicate field '{}' in agent declaration.", key.lexeme),
                );
                continue;
            }
            fields.insert(key.lexeme, value);
            // Consume comma after field declaration
            if !self.check(TokenType::CloseBrace) {
                self.consume(TokenType::Comma, "Expect ',' after field declaration.");
            }
        }

        // Check for required fields
        let required_fields = ["instructions"];
        for field in required_fields {
            if !fields.contains_key(field) {
                self.error(&format!(
                    "Missing required field '{}' in agent declaration.",
                    field