The Complete Production SOP: How to Deploy and Run OpenAI Function Calling Strict Schema Generator in Autonomous AI Agents

---
name: "openai-function-calling-schemas"
description: "Generate strict, type-safe JSON function calling schemas for reliable tool execution."
metadata:
  author: "OpenAI"
  version: "1.0.0"
  runtime_compatibility:
    - "codex"
    - "claude-code"
    - "cursor"
    - "windsurf"
triggers:
  - "write openai tool definition"
  - "convert pydantic to tool schema"
  - "use strict function calling"
permissions:
  fs_read: true
  fs_write: "workspace"
  shell_exec: false
  net_access: false
---

# OpenAI Function Calling Strict Schema Generator

Enforces type: 'function', strict: true, required parameter arrays, nested object schemas, and Pydantic-to-OpenAI function schema converters.

## Core Execution SOP & Rules
1. Always set strict: true on function schemas to guarantee zero hallucinated arguments.
2. In strict mode, every property key declared under `properties` MUST be listed in the `required` array. Optional fields must use explicit type union `type: ['string', 'null']`.
3. Every object definition MUST define `additionalProperties: false` recursively.
4. Avoid unsupported JSON schema keywords (e.g., `default`, `pattern`, `minimum`, `maximum` unless supported by target model endpoints; prefer string validation in docstrings).

from typing import Type, Any, Dict
from pydantic import BaseModel
from openai import pydantic_function_tool

def build_strict_tool(model: Type[BaseModel], name: str, description: str) -> Dict[str, Any]:
    """Generates a validated OpenAI function calling tool definition adhering to strict schema constraints."""
    tool = pydantic_function_tool(model, name=name, description=description)
    # Explicitly enforce strict mode assertion
    assert tool["function"].get("strict") is True, "Strict mode must be enabled"
    schema = tool["function"]["parameters"]
    assert schema.get("additionalProperties") is False, "additionalProperties: false is mandatory"
    return tool

from typing import Optional, List
from pydantic import BaseModel, Field

class DatabaseQueryInput(BaseModel):
    table_name: str = Field(..., description="The target SQL table name, must match allowed entities.")
    columns: List[str] = Field(..., description="List of column names to select.")
    limit: Optional[int] = Field(None, description="Maximum rows to fetch; null represents default system limit of 100.")
    filter_sql: Optional[str] = Field(None, description="Raw SQL WHERE predicate without the WHERE keyword, or null.")

    model_config = {"extra": "forbid"}

import unittest
from tools.schema_builder import build_strict_tool
from models.query_tool import DatabaseQueryInput

class TestStrictSchema(unittest.TestCase):
    def test_database_query_schema_strictness(self):
        tool = build_strict_tool(DatabaseQueryInput, "execute_database_query", "Executes parameterized SQL queries.")
        fn = tool["function"]
        params = fn["parameters"]
        
        self.assertTrue(fn["strict"])
        self.assertFalse(params["additionalProperties"])
        
        declared_properties = set(params["properties"].keys())
        required_properties = set(params.get("required", []))
        self.assertEqual(declared_properties, required_properties, "All properties must be listed in required")

if __name__ == "__main__":
    unittest.main()