poml 0.0.3 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57f8a3904a43267d79cbc6fb76465dd51c05da5923e58635304242eb90b04b96
-  data.tar.gz: 591512861013d2ae3d302b342b4678696a4d3691c98a26a2d9cdcd042ec70422
+  metadata.gz: '08ad238aa1b84997e3120a4379473c190293c3e6cb4a9fc08fe373457e3d10b7'
+  data.tar.gz: '028e54bb00290ffd9317902101435a2024a15972d6987e4acf9773b00ccba679'
 SHA512:
-  metadata.gz: ba9aeb9b1e06de010b5daa9489d847dc41f5f5d73a9a02e70d81432e997b1c3a3a32116cf9d85ee2f4c70755024201272e62951381cf6363be59dc807c6c55b0
-  data.tar.gz: 2f763c41a44b095f64fbe75cc64f58af266b50c8d966e0d44e6c382945a21fdde9abdd83a49b17ab57608c90a8481fb3066eca6dbc3633533e16269af1693f61
+  metadata.gz: db5eb9e927864afd49fc424be4d97f0e99f206e967605a878da19e8ae150a1ea13b25dab5a4a93773653765933c1e191e4da2c19496d43b6708a37a4aec7e758
+  data.tar.gz: be6a7c9fc5570bc8bc88483f2d7afcf757cf8d8153128b3f3fb6aa90bf54faaaff5b8a2236d68be7ee03692b40b6b5c97d36494f4c1ccb622fea5d96e408514e

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/examples/303_new_component_syntax.poml

@@ -0,0 +1,45 @@
+<poml>
+  <!-- New syntax using standalone components -->
+  <output-schema parser="json">
+    {
+      "type": "object",
+      "properties": {
+        "analysis": {
+          "type": "object",
+          "properties": {
+            "sentiment": { "type": "string", "enum": ["positive", "negative", "neutral"] },
+            "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+            "key_themes": { "type": "array", "items": { "type": "string" } }
+          },
+          "required": ["sentiment", "confidence", "key_themes"]
+        },
+        "summary": { "type": "string" }
+      },
+      "required": ["analysis", "summary"]
+    }
+  </output-schema>
+
+  <tool-definition name="search_web" description="Search the web for information" parser="json">
+    {
+      "type": "object",
+      "properties": {
+        "query": { "type": "string", "description": "Search query" },
+        "max_results": { "type": "integer", "minimum": 1, "maximum": 10, "default": 5 }
+      },
+      "required": ["query"]
+    }
+  </tool-definition>
+
+  <role>Expert Text Analyst</role>
+  
+  <task>
+    Analyze the provided text and return structured insights including sentiment analysis, 
+    key themes, and a summary. Use the search_web tool if you need additional context.
+  </task>
+
+  <p>Text to analyze: "The new product launch exceeded all expectations with overwhelmingly positive customer feedback and record-breaking sales numbers."</p>
+
+  <output-format>
+    Return your analysis in the structured format defined by the output schema.
+  </output-format>
+</poml>

data/lib/poml/components/base.rb

@@ -162,7 +162,12 @@ module Poml
     COMPONENT_MAPPING = {}
 
     def self.render_element(element, context)
-      component_class = COMPONENT_MAPPING[element.tag_name] || TextComponent
+      # Try to find component using multiple key formats for compatibility
+      tag_name = element.tag_name
+      component_class = COMPONENT_MAPPING[tag_name] || 
+                       COMPONENT_MAPPING[tag_name.to_s] || 
+                       COMPONENT_MAPPING[tag_name.to_sym] ||
+                       TextComponent
       component = component_class.new(element, context)
       component.render
     end

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,7 +9,7 @@ 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 = parse_array_attribute('selectedColumns')
@@ -85,7 +85,7 @@ module Poml
       else
         { records: [], columns: [] }
       end
-    rescue => e
+    rescue
       { records: [], columns: [] }
     end
     
@@ -138,7 +138,7 @@ module Poml
       records = if records_attr.is_a?(String)
         begin
           JSON.parse(records_attr)
-        rescue JSON::ParserError => e
+        rescue JSON::ParserError
           # Return empty records on parse error
           return { records: [], columns: [] }
         end
@@ -479,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

@@ -49,6 +49,12 @@ module Poml
         handle_variables(variables_attr)
       end
       
+      # Handle tool registration via tool attribute
+      tool_attr = get_attribute('tool')
+      if tool_attr
+        handle_tool_registration_with_name(tool_attr)
+      end
+      
       # Handle general metadata attributes
       %w[title description author keywords].each do |attr|
         value = get_attribute(attr)
@@ -77,18 +83,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' : 'eval'
       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'
@@ -98,6 +108,11 @@ module Poml
       end
       
       if schema
+        # Check if there's already a response schema defined
+        if @context.response_schema
+          raise Poml::Error, "Multiple response schemas are not allowed. Only one response schema per document is supported."
+        end
+        
         # Store the schema directly for simplicity
         @context.response_schema = schema
       end
@@ -106,18 +121,67 @@ 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 parser_attr is auto
+      if parser_attr == 'auto'
+        parser_attr = content.start_with?('{') ? 'json' : 'eval'
+      end
+      
+      # 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'
+        evaluate_expression_schema(content)
+      else
+        nil
+      end
+      
+      if schema
+        @context.tools ||= []
+        
+        # If name and description are provided as attributes, use them
+        if name
+          tool_def = {
+            'name' => name,
+            'description' => description
+          }
+          # Merge in the parsed schema (should include parameters, etc.)
+          tool_def.merge!(schema) if schema.is_a?(Hash)
+        elsif schema.is_a?(Hash) && schema['name']
+          # If the schema contains the full tool definition, use it directly
+          tool_def = schema
+        else
+          # No valid tool definition found
+          return
+        end
+        
+        @context.tools << tool_def
+      end
+    end
+    
+    def handle_tool_registration_with_name(tool_name)
+      description = get_attribute('description')
+      # Support both old 'lang' and new 'parser' attributes for compatibility
+      parser_attr = get_attribute('parser') || get_attribute('lang', 'auto')
       
       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' : 'eval'
       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'
@@ -130,7 +194,7 @@ module Poml
         @context.tools ||= []
         # Store tool with string keys for JSON compatibility
         tool_def = {
-          'name' => name,
+          'name' => tool_name,
           'description' => description
         }
         # Merge in the parsed schema (should include parameters, etc.)
@@ -168,20 +232,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/output_schema.rb

@@ -0,0 +1,85 @@
+module Poml
+  # OutputSchema component for defining AI response schemas
+  class OutputSchemaComponent < Component
+    def render
+      apply_stylesheet
+      
+      # 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 parser_attr is auto
+      if parser_attr == 'auto'
+        parser_attr = content.start_with?('{') ? 'json' : 'eval'
+      end
+      
+      # 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'
+        evaluate_expression_schema(content)
+      else
+        nil
+      end
+      
+      if schema
+        # Check if there's already a response schema defined
+        if @context.response_schema
+          raise Poml::Error, "Multiple output-schema elements are not allowed. Only one response schema per document is supported."
+        end
+        
+        # Store the schema directly for simplicity
+        @context.response_schema = schema
+      end
+      
+      # Meta-like components don't produce output
+      ''
+    end
+    
+    private
+    
+    def parse_json_schema(content)
+      # Apply template substitution first
+      substituted_content = @context.template_engine.substitute(content)
+      
+      begin
+        JSON.parse(substituted_content)
+      rescue JSON::ParserError => e
+        raise Poml::Error, "Invalid JSON schema: #{e.message}"
+      end
+    end
+    
+    def evaluate_expression_schema(content)
+      # Apply template substitution first
+      substituted_content = @context.template_engine.substitute(content)
+      
+      begin
+        # In a real implementation, this would evaluate JavaScript expressions
+        # For now, we'll try to parse as JSON if it looks like JSON, 
+        # otherwise treat it as a placeholder
+        if substituted_content.strip.start_with?('{', '[')
+          JSON.parse(substituted_content)
+        else
+          # This would need a JavaScript engine in a real implementation
+          # For now, return a placeholder that indicates expression evaluation
+          {
+            "_expression" => substituted_content,
+            "_note" => "Expression evaluation not implemented in Ruby gem"
+          }
+        end
+      rescue JSON::ParserError
+        # Return expression as-is if it can't be parsed as JSON
+        {
+          "_expression" => substituted_content,
+          "_note" => "Expression evaluation not implemented in Ruby gem"
+        }
+      end
+    end
+  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/tool_definition.rb

@@ -0,0 +1,98 @@
+module Poml
+  # ToolDefinition component for registering AI tools
+  class ToolDefinitionComponent < Component
+    def render
+      apply_stylesheet
+      
+      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')
+      
+      return '' unless name  # Name is required for tools
+      
+      content = @element.content.strip
+      
+      # Auto-detect format if parser_attr is auto
+      if parser_attr == 'auto'
+        parser_attr = content.start_with?('{') ? 'json' : 'eval'
+      end
+      
+      # 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'
+        evaluate_expression_schema(content)
+      else
+        nil
+      end
+      
+      if schema
+        @context.tools ||= []
+        # Store tool with string keys for JSON compatibility
+        tool_def = {
+          'name' => name,
+          'description' => description,
+          'schema' => schema.is_a?(String) ? schema : JSON.generate(schema)
+        }
+        
+        # For compatibility with expected structure, also store as parameters
+        if schema.is_a?(Hash)
+          tool_def['parameters'] = schema
+        end
+        
+        @context.tools << tool_def
+      end
+      
+      # Meta-like components don't produce output
+      ''
+    end
+    
+    private
+    
+    def parse_json_schema(content)
+      # Apply template substitution first
+      substituted_content = @context.template_engine.substitute(content)
+      
+      begin
+        parsed = JSON.parse(substituted_content)
+        # Return the parsed schema directly - don't wrap it
+        parsed
+      rescue JSON::ParserError => e
+        raise Poml::Error, "Invalid JSON schema for tool '#{get_attribute('name')}': #{e.message}"
+      end
+    end
+    
+    def evaluate_expression_schema(content)
+      # Apply template substitution first
+      substituted_content = @context.template_engine.substitute(content)
+      
+      begin
+        # In a real implementation, this would evaluate JavaScript expressions
+        # For now, we'll try to parse as JSON if it looks like JSON, 
+        # otherwise treat it as a placeholder
+        if substituted_content.strip.start_with?('{', '[')
+          parsed = JSON.parse(substituted_content)
+          # Return the parsed schema directly - don't wrap it
+          parsed
+        else
+          # This would need a JavaScript engine in a real implementation
+          # For now, return a placeholder that indicates expression evaluation
+          {
+            "_expression" => substituted_content,
+            "_note" => "Expression evaluation not implemented in Ruby gem"
+          }
+        end
+      rescue JSON::ParserError
+        # Return expression as-is if it can't be parsed as JSON
+        {
+          "_expression" => substituted_content,
+          "_note" => "Expression evaluation not implemented in Ruby gem"
+        }
+      end
+    end
+  end
+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

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

@@ -14,6 +14,8 @@ require_relative 'components/media'
 require_relative 'components/utilities'
 require_relative 'components/meta'
 require_relative 'components/template'
+require_relative 'components/output_schema'
+require_relative 'components/tool_definition'
 
 module Poml
   # Update the component mapping after all components are loaded
@@ -126,6 +128,14 @@ module Poml
     # Meta components
     meta: MetaComponent,
     Meta: MetaComponent,
+    'output-schema': OutputSchemaComponent,
+    'outputschema': OutputSchemaComponent,
+    OutputSchema: OutputSchemaComponent,
+    'tool-definition': ToolDefinitionComponent,
+    'tooldefinition': ToolDefinitionComponent,
+    ToolDefinition: ToolDefinitionComponent,
+    tool: ToolDefinitionComponent,  # 'tool' is an alias for 'tool-definition'
+    Tool: ToolDefinitionComponent,
     
     # Template components
     include: IncludeComponent,

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,9 @@ 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
+      # Note: 'input' is removed because POML input components (for examples) can have content
+      void_elements = %w[br hr img 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.3"
+  VERSION = "0.0.6"
 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.3
+  version: 0.0.6
 platform: ruby
 authors:
 - Ghennadii Mirosnicenco
 bindir: bin
 cert_chain: []
-date: 2025-08-19 00:00:00.000000000 Z
+date: 2025-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -62,6 +62,9 @@ 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/303_new_component_syntax.poml
 - examples/README.md
 - examples/assets/101_jerry_mouse.jpg
 - examples/assets/101_tom_and_jerry.docx
@@ -108,9 +111,11 @@ files:
 - lib/poml/components/lists.rb
 - lib/poml/components/media.rb
 - lib/poml/components/meta.rb
+- lib/poml/components/output_schema.rb
 - lib/poml/components/styling.rb
 - lib/poml/components/template.rb
 - lib/poml/components/text.rb
+- lib/poml/components/tool_definition.rb
 - lib/poml/components/utilities.rb
 - lib/poml/components/workflow.rb
 - lib/poml/components_new.rb