poml 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c09d0d76e15b722fd0ac52fc6dfe843eebe6f85e18f9b4a4444c43d6c8ca651
-  data.tar.gz: fb88b15378606b36242f7c80b3db61502bc3be8c0403565601250d0e9bce748a
+  metadata.gz: b5ba78c3aed937b9021b7d60fa5615fce4e75067ba607226fcb1c98674e720cf
+  data.tar.gz: 366238332f24e1f4309c64ff8da6fe52822747727e411d3925e92902b4b0ab2c
 SHA512:
-  metadata.gz: 0f61b599f4f5548c38e74fd1413fba6ed3489f8cf8ca4b518d943dcf7205cf8101ae962ef95fc9d9a8eba46ace47f303f0a8d2abcdce643fa1e32be7d6c86abf
-  data.tar.gz: a28b8954f93dd2c5a54a2353029401f37e78047b9d2e74b721d43ec3eb03ab5939cffedf52eabdbc38d73ae6f9d37dcbc65ddf059750167da5a8bd1ee24208d1
+  metadata.gz: f54b42cd18875cb6200eda77ea3f5be6ef21bbb5a8adcc35e3d349c4b7b6c8e8194f9fccc7c618bfe04c44163bcd8363816f04658f8b5ad279958aa6b9a21e64
+  data.tar.gz: caab1eb1555492e0bcc7342baa2b7c5a48c1a5606a172dee3d4983b617572940ce04d5cfda2b1d966da073cec0bc35b71c060435a5354126d265b3e43148fc5f

data/examples/301_new_schema_syntax.poml

@@ -0,0 +1,62 @@
+<!-- Example demonstrating the new schema syntax in POML -->
+<poml>
+  <!-- Example 1: Output schema with new parser attribute -->
+  <meta type="responseschema" parser="json">
+    {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string",
+          "description": "A brief summary of the content"
+        },
+        "sentiment": {
+          "type": "string",
+          "enum": ["positive", "negative", "neutral"]
+        },
+        "confidence": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        }
+      },
+      "required": ["summary", "sentiment"]
+    }
+  </meta>
+
+  <!-- Example 2: Tool definition with new parser attribute -->
+  <meta type="tool" name="analyze_text" description="Analyze text sentiment and content" parser="json">
+    {
+      "type": "object",
+      "properties": {
+        "text": {
+          "type": "string",
+          "description": "The text to analyze"
+        },
+        "include_keywords": {
+          "type": "boolean",
+          "description": "Whether to include keyword extraction",
+          "default": false
+        },
+        "language": {
+          "type": "string",
+          "enum": ["en", "es", "fr", "de"],
+          "default": "en"
+        }
+      },
+      "required": ["text"]
+    }
+  </meta>
+
+  <role>Expert text analyzer</role>
+  <task>
+    Analyze the provided text and return insights about its content, 
+    sentiment, and other relevant characteristics. Use the analyze_text 
+    tool when additional analysis is needed.
+  </task>
+
+  <p>
+    Please analyze this text: "The new POML schema syntax is much clearer 
+    and more consistent with modern API standards. The migration from 'lang' 
+    to 'parser' attributes makes the intent more obvious."
+  </p>
+</poml>

data/examples/302_schema_compatibility.poml

@@ -0,0 +1,48 @@
+<!-- Example showing backward compatibility support -->
+<poml>
+  <!-- This still works: Old lang attribute -->
+  <meta type="responseschema" lang="json">
+    {
+      "type": "object",
+      "properties": {
+        "old_format": {"type": "string"}
+      }
+    }
+  </meta>
+
+  <!-- This is the new way: parser attribute -->
+  <meta type="responseschema" parser="json">
+    {
+      "type": "object", 
+      "properties": {
+        "new_format": {"type": "string"}
+      }
+    }
+  </meta>
+
+  <!-- Expression evaluation with new syntax -->
+  <meta type="tool" name="calculator" parser="eval">
+    {
+      "type": "object",
+      "properties": {
+        "operation": {"type": "string", "enum": ["add", "subtract", "multiply", "divide"]},
+        "a": {"type": "number"},
+        "b": {"type": "number"}
+      }
+    }
+  </meta>
+
+  <role>Compatibility demonstration assistant</role>
+  <task>
+    Show that both old and new schema syntax work correctly.
+    The Ruby POML implementation supports both for backward compatibility.
+  </task>
+
+  <p>This example demonstrates that our Ruby implementation supports both:</p>
+  <list>
+    <item>Legacy `lang="json"` and `lang="expr"` attributes</item>
+    <item>New `parser="json"` and `parser="eval"` attributes</item>
+  </list>
+
+  <p>When both are present, `parser` takes precedence over `lang`.</p>
+</poml>

data/lib/poml/components/content.rb

@@ -135,7 +135,7 @@ module Poml
           end
         end
         return content unless content.empty?
-      rescue => e
+      rescue
         # Zip gem not available or error occurred
       end
 

data/lib/poml/components/data.rb

@@ -9,13 +9,13 @@ module Poml
       
       src = get_attribute('src')
       records_attr = get_attribute('records')
-      columns_attr = get_attribute('columns') 
+      _columns_attr = get_attribute('columns')  # Not used but may be needed for future features
       parser = get_attribute('parser', 'auto')
       syntax = get_attribute('syntax')
-      selected_columns = get_attribute('selectedColumns')
-      selected_records = get_attribute('selectedRecords')
-      max_records = get_attribute('maxRecords')
-      max_columns = get_attribute('maxColumns')
+      selected_columns = parse_array_attribute('selectedColumns')
+      selected_records = parse_array_attribute('selectedRecords')
+      max_records = parse_integer_attribute('maxRecords')
+      max_columns = parse_integer_attribute('maxColumns')
       
       # Load data from source or use provided records
       data = if src
@@ -85,7 +85,7 @@ module Poml
       else
         { records: [], columns: [] }
       end
-    rescue => e
+    rescue
       { records: [], columns: [] }
     end
     
@@ -136,7 +136,12 @@ module Poml
     def parse_records_attribute(records_attr)
       # Handle string records (JSON) or already parsed arrays
       records = if records_attr.is_a?(String)
-        JSON.parse(records_attr)
+        begin
+          JSON.parse(records_attr)
+        rescue JSON::ParserError
+          # Return empty records on parse error
+          return { records: [], columns: [] }
+        end
       else
         records_attr
       end
@@ -150,6 +155,38 @@ module Poml
       { records: records.is_a?(Array) ? records : [records], columns: columns }
     end
     
+    def parse_array_attribute(attr_name)
+      attr_value = get_attribute(attr_name)
+      return nil unless attr_value
+      
+      if attr_value.is_a?(String)
+        begin
+          parsed = JSON.parse(attr_value)
+          parsed.is_a?(Array) ? parsed : nil
+        rescue JSON::ParserError
+          # Try to handle as slice notation
+          attr_value.include?(':') ? attr_value : nil
+        end
+      elsif attr_value.is_a?(Array)
+        attr_value
+      else
+        nil
+      end
+    end
+    
+    def parse_integer_attribute(attr_name)
+      attr_value = get_attribute(attr_name)
+      return nil unless attr_value
+      
+      if attr_value.is_a?(String)
+        attr_value.to_i
+      elsif attr_value.is_a?(Integer)
+        attr_value
+      else
+        nil
+      end
+    end
+    
     def parse_html_table_children
       records = []
       columns = []
@@ -219,13 +256,15 @@ module Poml
         end
       end
       
-      # Apply max records
-      if max_records && records.length > max_records
-        # Show top half and bottom half with ellipsis
-        top_rows = (max_records / 2.0).ceil
-        bottom_rows = max_records - top_rows
-        ellipsis_record = columns.each_with_object({}) { |col, record| record[col[:field]] = '...' }
-        records = records[0...top_rows] + [ellipsis_record] + records[-bottom_rows..-1]
+      # Apply max records - simple truncation with ellipsis row
+      if max_records && max_records > 0 && records.length > max_records
+        truncated_records = records[0...max_records]
+        # Add ellipsis row if we truncated
+        if records.length > max_records && columns
+          ellipsis_record = columns.each_with_object({}) { |col, record| record[col[:field]] = '...' }
+          truncated_records << ellipsis_record
+        end
+        records = truncated_records
       end
       
       # Apply max columns
@@ -440,7 +479,7 @@ module Poml
       base64 = get_attribute('base64')
       extract_text = get_attribute('extractText', false)
       selector = get_attribute('selector', 'body')
-      syntax = get_attribute('syntax', 'text')
+      _syntax = get_attribute('syntax', 'text')  # May be used for future formatting options
       
       content = if url
         fetch_webpage_content(url, selector, extract_text)

data/lib/poml/components/lists.rb

@@ -33,30 +33,14 @@ module Poml
               "- "
             end
             
-            # Get text content and nested elements separately
-            text_content = child.content.strip
-            nested_elements = child.children.reject { |c| c.tag_name == :text }
-            
-            if nested_elements.any?
-              # Item has both text and nested elements (like nested lists)
-              nested_content = nested_elements.map { |nested_child| 
-                Components.render_element(nested_child, @context) 
-              }.join('').strip
-              
-              # Format with text content on first line, nested content indented
-              indented_nested = nested_content.split("\n").map { |line| 
-                line.strip.empty? ? "" : "   #{line}" 
-              }.join("\n").strip
-              
-              if text_content.empty?
-                items << "#{bullet}#{indented_nested}"
-              else
-                items << "#{bullet}#{text_content} \n\n#{indented_nested}"
-              end
+            # Render all content (text + formatting) together
+            content = if child.children.any?
+              Components.render_element(child, @context).strip
             else
-              # Simple text-only item
-              items << "#{bullet}#{text_content}"
+              child.content.strip
             end
+            
+            items << "#{bullet}#{content}"
           end
         end
         
@@ -70,12 +54,26 @@ module Poml
   class ItemComponent < Component
     def render
       apply_stylesheet
-      content = @element.content.empty? ? render_children : @element.content.strip
       
       if xml_mode?
+        content = @element.content.empty? ? render_children : @element.content.strip
         "<item>#{content}</item>\n"
       else
-        content
+        # For raw mode, handle mixed content properly
+        if @element.children.any?
+          # Render text and child elements together
+          result = ""
+          @element.children.each do |child|
+            if child.text?
+              result += child.content
+            else
+              result += Components.render_element(child, @context)
+            end
+          end
+          result.strip
+        else
+          @element.content.strip
+        end
       end
     end
   end

data/lib/poml/components/meta.rb

@@ -77,18 +77,22 @@ module Poml
     end
     
     def handle_response_schema
-      lang = get_attribute('lang', 'auto')
-      name = get_attribute('name')
-      description = get_attribute('description')
+      # Support both old 'lang' and new 'parser' attributes for compatibility
+      parser_attr = get_attribute('parser') || get_attribute('lang', 'auto')
+      _name = get_attribute('name')  # May be used for schema naming in future
+      _description = get_attribute('description')  # May be used for schema documentation in future
       
       content = @element.content.strip
       
-      # Auto-detect format if lang is auto
-      if lang == 'auto'
-        lang = content.start_with?('{') ? 'json' : 'expr'
+      # Auto-detect format if parser_attr is auto
+      if parser_attr == 'auto'
+        parser_attr = content.start_with?('{') ? 'json' : 'expr'
       end
       
-      schema = case lang.downcase
+      # Handle new 'eval' parser type as alias for 'expr'
+      parser_attr = 'expr' if parser_attr == 'eval'
+      
+      schema = case parser_attr.downcase
       when 'json'
         parse_json_schema(content)
       when 'expr'
@@ -106,18 +110,22 @@ module Poml
     def handle_tool_registration
       name = get_attribute('name')
       description = get_attribute('description')
-      lang = get_attribute('lang', 'auto')
+      # Support both old 'lang' and new 'parser' attributes for compatibility
+      parser_attr = get_attribute('parser') || get_attribute('lang', 'auto')
       
       return unless name
       
       content = @element.content.strip
       
-      # Auto-detect format if lang is auto
-      if lang == 'auto'
-        lang = content.start_with?('{') ? 'json' : 'expr'
+      # Auto-detect format if parser_attr is auto
+      if parser_attr == 'auto'
+        parser_attr = content.start_with?('{') ? 'json' : 'expr'
       end
       
-      schema = case lang.downcase
+      # Handle new 'eval' parser type as alias for 'expr'
+      parser_attr = 'expr' if parser_attr == 'eval'
+      
+      schema = case parser_attr.downcase
       when 'json'
         parse_json_schema(content)
       when 'expr'
@@ -168,20 +176,24 @@ module Poml
       
       begin
         JSON.parse(processed_content)
-      rescue JSON::ParserError => e
+      rescue JSON::ParserError
         nil
       end
     end
     
     def evaluate_expression_schema(content)
-      # This is a simplified version - in a full implementation,
-      # you'd want to evaluate JavaScript expressions with Zod support
+      # Handle template expressions in the content
+      processed_content = @context.template_engine.substitute(content)
+      
       begin
-        # For now, just return the content as-is for expression schemas
-        # In a complete implementation, you'd evaluate this as JavaScript
-        { type: 'expression', content: content }
-      rescue => e
-        nil
+        # For expression schemas, try to parse as JSON first
+        # In the original POML, 'expr' mode evaluates JavaScript expressions
+        # but for simplicity in Ruby, we'll try JSON parsing
+        JSON.parse(processed_content)
+      rescue JSON::ParserError
+        # If JSON parsing fails, return a simple schema object
+        # This is a fallback for complex expressions that can't be easily evaluated
+        { 'type' => 'string', 'description' => 'Expression schema result' }
       end
     end
     

data/lib/poml/components/styling.rb

@@ -25,7 +25,7 @@ module Poml
           stylesheet = JSON.parse(stylesheet_content)
           @context.stylesheet.merge!(stylesheet) if stylesheet.is_a?(Hash)
         end
-      rescue => e
+      rescue
         # Silently fail JSON parsing errors
       end
       

data/lib/poml/components/utilities.rb

@@ -161,7 +161,7 @@ module Poml
     def render_conversation_xml(messages)
       result = ['<conversation>']
       messages.each do |msg|
-        speaker = msg['speaker'] || 'human'
+        speaker = msg['speaker'] || msg['role'] || 'human'
         content = msg['content'] || ''
         result << "  <msg speaker=\"#{speaker}\">#{escape_xml(content)}</msg>"
       end
@@ -172,7 +172,7 @@ module Poml
     def render_conversation_markdown(messages)
       result = []
       messages.each do |msg|
-        speaker = msg['speaker'] || 'human'
+        speaker = msg['speaker'] || msg['role'] || 'human'
         content = msg['content'] || ''
         
         case speaker.downcase
@@ -244,12 +244,20 @@ module Poml
           if File.directory?(full_path)
             # Check if directory should be included
             if !filter || entry.match?(Regexp.new(filter))
-              sub_items = build_tree_structure(full_path, filter, max_depth, show_content, current_depth + 1)
-              if sub_items && !sub_items.empty?
+              if current_depth + 1 < max_depth
+                # If we can go deeper, recurse and include subdirectories
+                sub_items = build_tree_structure(full_path, filter, max_depth, show_content, current_depth + 1)
                 items << {
                   name: "#{entry}/",
                   type: 'directory',
-                  children: sub_items
+                  children: sub_items || []
+                }
+              else
+                # At max depth, just show the directory without recursing
+                items << {
+                  name: "#{entry}/",
+                  type: 'directory',
+                  children: []
                 }
               end
             end
@@ -505,4 +513,68 @@ module Poml
       text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
     end
   end
+
+  # File component for reading and including file contents
+  class FileComponent < Component
+    def render
+      apply_stylesheet
+      
+      src = get_attribute('src')
+      
+      # Handle missing src attribute
+      unless src
+        return handle_error("no src specified")
+      end
+      
+      # Resolve file path
+      file_path = resolve_file_path(src)
+      
+      # Check if file exists
+      unless File.exist?(file_path)
+        return handle_error("file not found: #{src}")
+      end
+      
+      # Read file content
+      begin
+        content = File.read(file_path, encoding: 'utf-8')
+        
+        if xml_mode?
+          render_as_xml('file', content, { src: src })
+        else
+          content
+        end
+      rescue => e
+        handle_error("error reading file: #{e.message}")
+      end
+    end
+    
+    private
+    
+    def resolve_file_path(src)
+      # Handle absolute paths
+      return src if src.start_with?('/')
+      
+      # Handle relative paths - try relative to source file first
+      if @context.source_path
+        base_path = File.dirname(@context.source_path)
+        candidate_path = File.join(base_path, src)
+        return candidate_path if File.exist?(candidate_path)
+      end
+      
+      # Try relative to current working directory
+      candidate_path = File.join(Dir.pwd, src)
+      return candidate_path if File.exist?(candidate_path)
+      
+      # Return the original path for final existence check
+      src
+    end
+    
+    def handle_error(message)
+      if xml_mode?
+        render_as_xml('file-error', message)
+      else
+        "[File: #{message}]"
+      end
+    end
+  end
 end

data/lib/poml/components/workflow.rb

@@ -28,22 +28,6 @@ module Poml
     end
   end
 
-  # Human Message component
-  class HumanMessageComponent < Component
-    def render
-      apply_stylesheet
-      
-      content = @element.content.empty? ? render_children : @element.content
-      speaker = get_attribute('speaker', 'human')
-
-      if xml_mode?
-        render_as_xml('human-message', content)
-      else
-        "#{content}\n\n"
-      end
-    end
-  end
-
   # Question-Answer component
   class QAComponent < Component
     def render

data/lib/poml/components.rb

@@ -114,6 +114,8 @@ module Poml
     Folder: FolderComponent,
     tree: TreeComponent,
     Tree: TreeComponent,
+    file: FileComponent,
+    File: FileComponent,
     
     # Styling components
     let: LetComponent,

data/lib/poml/parser.rb

@@ -163,7 +163,7 @@ module Poml
             stylesheet = JSON.parse(stylesheet_text)
             @context.stylesheet.merge!(stylesheet) if stylesheet.is_a?(Hash)
           end
-        rescue => e
+        rescue
           # Silently fail JSON parsing errors
         end
       end
@@ -235,7 +235,8 @@ module Poml
     
     def preprocess_void_elements(content)
       # List of HTML void elements that should be self-closing in XML
-      void_elements = %w[br hr img input area base col embed link meta param source track wbr]
+      # Note: 'meta' is removed from this list because POML meta components can have content
+      void_elements = %w[br hr img input area base col embed link param source track wbr]
       
       # Convert <element> to <element/> for void elements, but only if not already self-closing
       void_elements.each do |element|

data/lib/poml/renderer.rb

@@ -134,7 +134,7 @@ module Poml
       # Check for system-oriented components
       has_role = tag_names.include?(:role)
       has_task = tag_names.include?(:task)
-      has_hint = tag_names.include?(:hint)
+      _has_hint = tag_names.include?(:hint)  # Prefix with underscore to indicate intentionally unused
       
       # Check for human-oriented components or content that suggests user interaction
       has_document = tag_names.include?(:document) || tag_names.include?('Document')

data/lib/poml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Poml
-  VERSION = "0.0.2"
+  VERSION = "0.0.5"
 end

data/lib/poml.rb

@@ -17,69 +17,15 @@ module Poml
   # - stylesheet: Optional stylesheet as string or hash
   # - chat: Boolean indicating chat format (default: true)
   # - output_file: Path to save output (optional)
+  # Process POML markup and return the rendered result
+  # 
+  # Parameters:
+  # - markup: POML markup string or file path
   # - format: 'raw', 'dict', 'openai_chat', 'langchain', 'pydantic' (default: 'dict')
-  # - extra_args: Array of extra CLI args (ignored in pure Ruby implementation)
-  def self.process(markup:, context: nil, stylesheet: nil, chat: true, output_file: nil, format: 'dict', extra_args: [])
-    # Create POML context
-    poml_context = Context.new(
-      variables: context || {},
-      stylesheet: stylesheet,
-      chat: chat
-    )
-
-    # Read markup content and set source path
-    content = if File.exist?(markup.to_s)
-      poml_context.source_path = File.expand_path(markup.to_s)
-      File.read(markup)
-    else
-      markup.to_s
-    end
-
-    # Parse POML content
-    parser = Parser.new(poml_context)
-    parsed_elements = parser.parse(content)
-
-    # Render to the desired format
-    renderer = Renderer.new(poml_context)
-    result = renderer.render(parsed_elements, format)
-
-    # Save to file if specified
-    if output_file
-      File.write(output_file, result)
-    end
-
-    result
-  end
-
-  def self.parse(content, context: nil)
-    context ||= Context.new
-    parser = Parser.new(context)
-    parser.parse(content)
-  end
-
-  def self.render(content, format: 'text', context: nil, **options)
-    context ||= Context.new(**options)
-    elements = parse(content, context: context)
-    renderer = Renderer.new(context)
-    renderer.render(elements, format)
-  end
-
-  # Convenience method for quick text rendering
-  def self.to_text(content, **options)
-    render(content, format: 'raw', **options)
-  end
-
-  # Convenience method for chat format
-  def self.to_chat(content, **options)
-    render(content, format: 'openai_chat', **options)
-  end
-
-  # Convenience method for dict format
-  def self.to_dict(content, **options)
-    render(content, format: 'dict', **options)
-  end
-  
-  # Legacy method for backward compatibility
+  # - context/variables: Hash of template variables
+  # - stylesheet: CSS/styling rules
+  # - chat: Enable chat mode (default: true)
+  # - output_file: File path to write output to
   def self.process(markup:, format: 'dict', **options)
     # Handle file paths
     content = if File.exist?(markup)
@@ -116,4 +62,32 @@ module Poml
       result
     end
   end
+
+  def self.parse(content, context: nil)
+    context ||= Context.new
+    parser = Parser.new(context)
+    parser.parse(content)
+  end
+
+  def self.render(content, format: 'text', context: nil, **options)
+    context ||= Context.new(**options)
+    elements = parse(content, context: context)
+    renderer = Renderer.new(context)
+    renderer.render(elements, format)
+  end
+
+  # Convenience method for quick text rendering
+  def self.to_text(content, **options)
+    render(content, format: 'raw', **options)
+  end
+
+  # Convenience method for chat format
+  def self.to_chat(content, **options)
+    render(content, format: 'openai_chat', **options)
+  end
+
+  # Convenience method for dict format
+  def self.to_dict(content, **options)
+    render(content, format: 'dict', **options)
+  end
 end

data/readme.md

@@ -6,6 +6,8 @@ A Ruby implementation of the POML (Prompt Oriented Markup Language) interpreter.
 
 This is a **Ruby port** of the original [POML library](https://github.com/microsoft/poml) developed by Microsoft, which was originally implemented in JavaScript/TypeScript and Python. This Ruby gem is designed to be **fully compatible** with the original POML specification and will **closely follow** the development of the original library to maintain feature parity.
 
+> **🔄 Recent Update**: The original POML library has introduced **breaking changes** in schema definitions. Schema attributes have been renamed from `lang` to `parser` (e.g., `lang="json"` → `parser="json"`, `lang="expr"` → `parser="eval"`). Our Ruby implementation is being updated to maintain compatibility with these changes.
+
 ## Demo Video
 
 [![The 5-minute guide to POML](https://i3.ytimg.com/vi/b9WDcFsKixo/maxresdefault.jpg)](https://youtu.be/b9WDcFsKixo)
@@ -205,6 +207,8 @@ Customize component appearance:
 - ✅ Stylesheet support
 - ✅ Command-line interface
 - ✅ Chat vs non-chat modes
+- 🔄 **Schema definitions** (updating to new `parser` attribute syntax)
+- 🔄 **Tool registration** (updating for enhanced tool use support)
 
 ## Document Support
 
@@ -239,7 +243,7 @@ Build and install locally:
 
 ```bash
 gem build poml.gemspec
-gem install poml-0.0.1.gem
+gem install poml-0.0.3.gem
 ```
 
 ## License

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: poml
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - Ghennadii Mirosnicenco
 bindir: bin
 cert_chain: []
-date: 2025-08-18 00:00:00.000000000 Z
+date: 2025-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -62,6 +62,8 @@ files:
 - examples/201_orders_qa.poml
 - examples/202_arc_agi.poml
 - examples/301_generate_poml.poml
+- examples/301_new_schema_syntax.poml
+- examples/302_schema_compatibility.poml
 - examples/README.md
 - examples/assets/101_jerry_mouse.jpg
 - examples/assets/101_tom_and_jerry.docx