UPDATE

Author: mazzasaverio

examples/job_description.txt

@@ -0,0 +1,49 @@
+{
+    "type": "object",
+    "properties": {
+      "headline": {
+        "type": "string",
+        "description": "Main headline of the news article"
+      },
+      "summary": {
+        "type": "string",
+        "description": "Brief summary of the article"
+      },
+      "publication_date": {
+        "type": ["string", "null"],
+        "description": "Publication date if mentioned"
+      },
+      "author": {
+        "type": ["string", "null"],
+        "description": "Author name if mentioned"
+      },
+      "location": {
+        "type": ["string", "null"],
+        "description": "Geographic location mentioned in the news"
+      },
+      "key_people": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "description": "Names of key people mentioned in the article"
+      },
+      "organizations": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "description": "Organizations or companies mentioned"
+      },
+      "category": {
+        "type": ["string", "null"],
+        "description": "News category (politics, technology, sports, etc.)"
+      },
+      "sentiment": {
+        "type": ["string", "null"],
+        "description": "Overall sentiment of the article (positive, negative, neutral)"
+      }
+    },
+    "required": ["headline", "summary", "key_people", "organizations"],
+    "additionalProperties": false
+  }

examples/news_article.txt

@@ -44,6 +44,10 @@ def extract(
             # Use custom prompt or schema default
             prompt = system_prompt or schema.get_extraction_prompt()
 
+            # Generate schema and ensure additionalProperties is false
+            schema_dict = schema.model_json_schema()
+            self._ensure_additional_properties_false(schema_dict)
+            
             response = self.client.chat.completions.create(
                 model=self.config.openai_model,
                 messages=[
@@ -53,9 +57,9 @@ def extract(
                 response_format={
                     "type": "json_schema",
                     "json_schema": {
-                        "name": schema.get_schema_name().lower(),
+                        "name": schema.get_schema_name().lower().replace(" ", "_"),
                         "strict": True,
-                        "schema": schema.model_json_schema()
+                        "schema": schema_dict
                     }
                 },
                 timeout=self.config.timeout_seconds
@@ -87,6 +91,24 @@ def extract(
             self.logger.error(f"Extraction failed: {e}")
             return ExtractionResult.error_result(str(e))
 
+    def _ensure_additional_properties_false(self, schema_dict: Dict[str, Any]) -> None:
+        """Recursively ensure all objects have additionalProperties: false."""
+        if isinstance(schema_dict, dict):
+            if schema_dict.get("type") == "object":
+                schema_dict["additionalProperties"] = False
+            
+            # Recursively process nested schemas
+            for key, value in schema_dict.items():
+                if key in ["properties", "items", "anyOf", "allOf", "oneOf"]:
+                    if isinstance(value, dict):
+                        self._ensure_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            if isinstance(item, dict):
+                                self._ensure_additional_properties_false(item)
+                elif isinstance(value, dict):
+                    self._ensure_additional_properties_false(value)
+    
     def extract_with_custom_schema(
         self,
         text: str,
@@ -107,6 +129,9 @@ def extract_with_custom_schema(
         try:
             self.logger.info("Starting extraction with custom schema")
 
+            # Ensure custom schema has additionalProperties: false
+            self._ensure_additional_properties_false(schema_dict)
+            
             response = self.client.chat.completions.create(
                 model=self.config.openai_model,
                 messages=[

examples/news_prompt.txt

@@ -3,12 +3,19 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Type
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 
 class BaseSchema(BaseModel, ABC):
     """Abstract base class for all extraction schemas."""
 
+    model_config = ConfigDict(
+        extra="forbid",  # This generates additionalProperties: false
+        validate_assignment=True,
+        str_strip_whitespace=True
+    )
+    """Abstract base class for all extraction schemas."""
+    
     @classmethod
     @abstractmethod
     def get_extraction_prompt(cls) -> str:

examples/news_schema.json

@@ -1,6 +1,6 @@
 """Job description extraction schema."""
 
-from typing import List, Optional
+from typing import List, Union
 from pydantic import Field
 from ..schemas.base import BaseSchema
 
@@ -10,41 +10,32 @@ class JobDescriptionSchema(BaseSchema):
 
     title: str = Field(description="Job title or position name")
     company: str = Field(description="Company name")
-    location: Optional[str] = Field(default=None, description="Job location")
-    employment_type: Optional[str] = Field(
-        default=None, 
+    location: Union[str, None] = Field(description="Job location")
+    employment_type: Union[str, None] = Field(
         description="Employment type (full-time, part-time, contract, etc.)"
     )
-    experience_level: Optional[str] = Field(
-        default=None,
+    experience_level: Union[str, None] = Field(
         description="Required experience level (entry, mid, senior, etc.)"
     )
-    salary_range: Optional[str] = Field(
-        default=None,
+    salary_range: Union[str, None] = Field(
         description="Salary range or compensation information"
     )
     required_skills: List[str] = Field(
-        default_factory=list,
         description="Required technical skills and technologies"
     )
     preferred_skills: List[str] = Field(
-        default_factory=list,
         description="Preferred or nice-to-have skills"
     )
     responsibilities: List[str] = Field(
-        default_factory=list,
         description="Key job responsibilities and duties"
     )
     requirements: List[str] = Field(
-        default_factory=list,
         description="Job requirements and qualifications"
     )
     benefits: List[str] = Field(
-        default_factory=list,
         description="Benefits and perks offered"
     )
-    remote_work: Optional[bool] = Field(
-        default=None,
+    remote_work: Union[bool, None] = Field(
         description="Whether remote work is available"
     )
 

examples/recipe.txt

@@ -1,67 +1,36 @@
 """Recipe extraction schema."""
 
-from typing import List, Optional
-from pydantic import BaseModel, Field
+from typing import List, Union, Dict, Any
+from pydantic import BaseModel, Field, ConfigDict
 from ..schemas.base import BaseSchema
 
 
 class Ingredient(BaseModel):
     """Single ingredient with quantity and unit."""
 
+    model_config = ConfigDict(extra="forbid")
+    
     name: str = Field(description="Ingredient name")
-    quantity: Optional[str] = Field(default=None, description="Amount needed")
-    unit: Optional[str] = Field(default=None, description="Unit of measurement")
-    notes: Optional[str] = Field(default=None, description="Additional notes")
+    quantity: Union[str, None] = Field(description="Amount needed")
+    unit: Union[str, None] = Field(description="Unit of measurement")
+    notes: Union[str, None] = Field(description="Additional notes")
 
 
 class RecipeSchema(BaseSchema):
     """Extract structured information from recipes."""
 
     name: str = Field(description="Recipe name or title")
-    description: Optional[str] = Field(
-        default=None, 
-        description="Brief description of the dish"
-    )
-    cuisine: Optional[str] = Field(
-        default=None,
-        description="Cuisine type (Italian, Asian, etc.)"
-    )
-    difficulty: Optional[str] = Field(
-        default=None,
-        description="Difficulty level (easy, medium, hard)"
-    )
-    prep_time: Optional[str] = Field(
-        default=None,
-        description="Preparation time"
-    )
-    cook_time: Optional[str] = Field(
-        default=None,
-        description="Cooking time"
-    )
-    total_time: Optional[str] = Field(
-        default=None,
-        description="Total time required"
-    )
-    servings: Optional[int] = Field(
-        default=None,
-        description="Number of servings"
-    )
-    ingredients: List[Ingredient] = Field(
-        default_factory=list,
-        description="List of ingredients with quantities"
-    )
-    instructions: List[str] = Field(
-        default_factory=list,
-        description="Step-by-step cooking instructions"
-    )
-    tags: List[str] = Field(
-        default_factory=list,
-        description="Recipe tags (vegetarian, gluten-free, etc.)"
-    )
-    nutrition: Optional[dict] = Field(
-        default=None,
-        description="Nutritional information if available"
-    )
+    description: Union[str, None] = Field(description="Brief description of the dish")
+    cuisine: Union[str, None] = Field(description="Cuisine type (Italian, Asian, etc.)")
+    difficulty: Union[str, None] = Field(description="Difficulty level (easy, medium, hard)")
+    prep_time: Union[str, None] = Field(description="Preparation time")
+    cook_time: Union[str, None] = Field(description="Cooking time")
+    total_time: Union[str, None] = Field(description="Total time required")
+    servings: Union[int, None] = Field(description="Number of servings")
+    ingredients: List[Ingredient] = Field(description="List of ingredients with quantities")
+    instructions: List[str] = Field(description="Step-by-step cooking instructions")
+    tags: List[str] = Field(description="Recipe tags (vegetarian, gluten-free, etc.)")
+    nutrition: Union[Dict[str, Any], None] = Field(description="Nutritional information if available")
 
     @classmethod
     def get_extraction_prompt(cls) -> str: