devagent-physical-engine 0.11.2__tar.gz → 0.11.4__tar.gz

{devagent_physical_engine-0.11.2/src/devagent_physical_engine.egg-info → devagent_physical_engine-0.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 0.11.2
+Version: 0.11.4
 Summary: Verification-first agentic planning runtime for robotic and industrial automation.
 Author: Tom Ha
 License: All Rights Reserved
@@ -49,10 +49,12 @@ DevAgent Smart Physical Engine adds AI-assisted engineering to existing automati
 
 ## Current version
 
-**v0.11.2 — Beta software / evidence-gated physical runtime**
+**v0.11.4 — Beta software / evidence-gated physical runtime**
 
 The Python software stack is regression-tested on Python 3.11, 3.12, and 3.13 with separate static/coverage, package-install, and runtime dependency security gates. The UR5e Gazebo/MoveIt path now contains production-candidate continuous-clearance, tool-collision, and workpiece-lifecycle capabilities, but those physical-simulation scopes remain **EXPERIMENTAL until the executable target-workstation v0.11 campaign passes**.
 
+v0.11.3 normalized provider-neutral agent schemas at the OpenAI transport boundary so strict Structured Outputs can represent DevAgent optional fields without changing Anthropic/Gemini or deterministic core semantics. v0.11.4 adds live terminal progress tracing for AI request, engineering, and provider-qualification workflows. Progress is written to `stderr`; final machine-readable JSON remains isolated on `stdout`.
+
 Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 
 ## v0.11 capability status
@@ -63,6 +65,7 @@ Real robot execution remains locked. Functional-safety certification and site qu
 | OpenAI / Anthropic / Gemini structured adapters | Implemented |
 | Planner / Critic / Recovery | Implemented |
 | Natural-language engineering request front door | Implemented |
+| Live terminal stage tracing (`stderr`) | Implemented; `--quiet` supported |
 | Deterministic compiler / semantic / verification gates | Implemented |
 | Multi-vendor robot profile registry | Implemented |
 | UR5e / FANUC CRX / KUKA KR / ABB IRB abstraction | Implemented; physical qualification is vendor-specific |
@@ -195,19 +198,38 @@ export ANTHROPIC_API_KEY='...'
 export GEMINI_API_KEY='...'
 ```
 
-Examples:
+Examples use the currently supported deterministic goal action `load`:
 
 ```bash
 devagent-physical-ai doctor --provider openai
 devagent-physical-ai qualify --provider openai --model <model-id>
 devagent-physical-ai request \
-  "Use a UR5e to move a part from conveyor_a to cnc_04" \
+  "Use a UR5e to load BOX_101 from conveyor_a to cnc_04. Simulate and verify the plan." \
   --provider openai --model <model-id>
 devagent-physical-ai engineer \
-  "Use a UR5e to move a part from conveyor_a to cnc_04" \
+  "Use a UR5e to load BOX_101 from conveyor_a to cnc_04. Simulate and verify the plan." \
   --provider openai --model <model-id>
 ```
 
+Live commands now show stage-by-stage progress while they are running, for example:
+
+```text
+[DevAgent +   0.00s] START        provider=openai model=<model-id>
+[DevAgent +   0.00s] INTERPRETER  understanding engineering request
+[DevAgent +   6.84s] INTERPRETER  validated request_id=REQ-...
+[DevAgent +   6.84s] REASONING    risk_score=1 max_revisions=1 critic_threshold=0.70
+[DevAgent +   6.84s] PLANNER      revision=0 generating high-level task graph
+[DevAgent +  12.21s] PLANNER      revision=0 proposal compiled and deterministically verified
+[DevAgent +  12.21s] CRITIC       revision=0 reviewing verified plan
+[DevAgent +  15.77s] CRITIC       revision=0 decision=accept score=0.91
+[DevAgent +  15.77s] PLANNING     verified plan accepted after revision=0
+[DevAgent +  15.77s] SIMULATION   running deterministic model execution
+[DevAgent +  15.78s] SIMULATION   deterministic model execution completed
+[DevAgent +  15.78s] COMPLETE     ready_for_twin_simulation=true
+```
+
+Progress logs are emitted to `stderr`, so piping `stdout` still produces clean JSON. For CI or scripts that do not want terminal progress, add `--quiet`.
+
 Equivalent routing supports Anthropic and Gemini. Live AI qualification does not unlock real robot execution.
 
 ## Software production gates

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/README.md

@@ -8,10 +8,12 @@ DevAgent Smart Physical Engine adds AI-assisted engineering to existing automati
 
 ## Current version
 
-**v0.11.2 — Beta software / evidence-gated physical runtime**
+**v0.11.4 — Beta software / evidence-gated physical runtime**
 
 The Python software stack is regression-tested on Python 3.11, 3.12, and 3.13 with separate static/coverage, package-install, and runtime dependency security gates. The UR5e Gazebo/MoveIt path now contains production-candidate continuous-clearance, tool-collision, and workpiece-lifecycle capabilities, but those physical-simulation scopes remain **EXPERIMENTAL until the executable target-workstation v0.11 campaign passes**.
 
+v0.11.3 normalized provider-neutral agent schemas at the OpenAI transport boundary so strict Structured Outputs can represent DevAgent optional fields without changing Anthropic/Gemini or deterministic core semantics. v0.11.4 adds live terminal progress tracing for AI request, engineering, and provider-qualification workflows. Progress is written to `stderr`; final machine-readable JSON remains isolated on `stdout`.
+
 Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 
 ## v0.11 capability status
@@ -22,6 +24,7 @@ Real robot execution remains locked. Functional-safety certification and site qu
 | OpenAI / Anthropic / Gemini structured adapters | Implemented |
 | Planner / Critic / Recovery | Implemented |
 | Natural-language engineering request front door | Implemented |
+| Live terminal stage tracing (`stderr`) | Implemented; `--quiet` supported |
 | Deterministic compiler / semantic / verification gates | Implemented |
 | Multi-vendor robot profile registry | Implemented |
 | UR5e / FANUC CRX / KUKA KR / ABB IRB abstraction | Implemented; physical qualification is vendor-specific |
@@ -154,19 +157,38 @@ export ANTHROPIC_API_KEY='...'
 export GEMINI_API_KEY='...'
 ```
 
-Examples:
+Examples use the currently supported deterministic goal action `load`:
 
 ```bash
 devagent-physical-ai doctor --provider openai
 devagent-physical-ai qualify --provider openai --model <model-id>
 devagent-physical-ai request \
-  "Use a UR5e to move a part from conveyor_a to cnc_04" \
+  "Use a UR5e to load BOX_101 from conveyor_a to cnc_04. Simulate and verify the plan." \
   --provider openai --model <model-id>
 devagent-physical-ai engineer \
-  "Use a UR5e to move a part from conveyor_a to cnc_04" \
+  "Use a UR5e to load BOX_101 from conveyor_a to cnc_04. Simulate and verify the plan." \
   --provider openai --model <model-id>
 ```
 
+Live commands now show stage-by-stage progress while they are running, for example:
+
+```text
+[DevAgent +   0.00s] START        provider=openai model=<model-id>
+[DevAgent +   0.00s] INTERPRETER  understanding engineering request
+[DevAgent +   6.84s] INTERPRETER  validated request_id=REQ-...
+[DevAgent +   6.84s] REASONING    risk_score=1 max_revisions=1 critic_threshold=0.70
+[DevAgent +   6.84s] PLANNER      revision=0 generating high-level task graph
+[DevAgent +  12.21s] PLANNER      revision=0 proposal compiled and deterministically verified
+[DevAgent +  12.21s] CRITIC       revision=0 reviewing verified plan
+[DevAgent +  15.77s] CRITIC       revision=0 decision=accept score=0.91
+[DevAgent +  15.77s] PLANNING     verified plan accepted after revision=0
+[DevAgent +  15.77s] SIMULATION   running deterministic model execution
+[DevAgent +  15.78s] SIMULATION   deterministic model execution completed
+[DevAgent +  15.78s] COMPLETE     ready_for_twin_simulation=true
+```
+
+Progress logs are emitted to `stderr`, so piping `stdout` still produces clean JSON. For CI or scripts that do not want terminal progress, add `--quiet`.
+
 Equivalent routing supports Anthropic and Gemini. Live AI qualification does not unlock real robot execution.
 
 ## Software production gates
@@ -292,4 +314,4 @@ DevAgent Smart Physical Engine
 Copyright © 2026 Tom Ha  
 Original creator: Tom Ha  
 Original project: https://github.com/tomha85/devagent-physical-engine  
-All rights reserved.
+All rights reserved.

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devagent-physical-engine"
-version = "0.11.2"
+version = "0.11.4"
 description = "Verification-first agentic planning runtime for robotic and industrial automation."
 readme = "README.md"
 requires-python = ">=3.11"

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/__init__.py

@@ -41,4 +41,4 @@ __all__ = [
     "TwinValidator",
 ]
 
-__version__ = "0.11.2"
+__version__ = "0.11.4"

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/agent/coordinator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Mapping
+from typing import Any, Callable, Mapping
 
 from .contracts import AgentEvidence, CriticDecision, RoutingPolicy
 from .critic import CriticAgent
@@ -9,6 +9,8 @@ from .evidence import task_graph_hash
 from .planner import PlannerAgent
 from ..models import Goal, Resource, TaskGraph, WorldState
 
+ProgressCallback = Callable[[str, str], None]
+
 
 class PlanningCoordinationError(RuntimeError):
     pass
@@ -52,12 +54,18 @@ class PlanningCoordinator:
         critic_policy: RoutingPolicy,
         *,
         engineering_context: Mapping[str, Any] | None = None,
+        progress: ProgressCallback | None = None,
     ) -> VerifiedPlanArtifact:
         feedback: tuple[str, ...] = ()
         planner_evidence: list[AgentEvidence] = []
         critic_evidence: list[AgentEvidence] = []
 
         for revision in range(self.max_revision_rounds + 1):
+            if progress is not None:
+                progress(
+                    "PLANNER",
+                    f"revision={revision} generating high-level task graph",
+                )
             planned = self.planner.plan(
                 goal,
                 resources,
@@ -67,6 +75,15 @@ class PlanningCoordinator:
                 engineering_context=engineering_context,
             )
             planner_evidence.append(planned.evidence)
+            if progress is not None:
+                progress(
+                    "PLANNER",
+                    f"revision={revision} proposal compiled and deterministically verified",
+                )
+                progress(
+                    "CRITIC",
+                    f"revision={revision} reviewing verified plan",
+                )
 
             reviewed = self.critic.review(
                 goal,
@@ -77,11 +94,24 @@ class PlanningCoordinator:
                 engineering_context=engineering_context,
             )
             critic_evidence.append(reviewed.evidence)
+            if progress is not None:
+                progress(
+                    "CRITIC",
+                    (
+                        f"revision={revision} decision={reviewed.critique.decision.value} "
+                        f"score={reviewed.critique.score:.2f}"
+                    ),
+                )
 
             if (
                 reviewed.critique.decision is CriticDecision.ACCEPT
                 and reviewed.critique.score >= self.min_accept_score
             ):
+                if progress is not None:
+                    progress(
+                        "PLANNING",
+                        f"verified plan accepted after revision={revision}",
+                    )
                 return VerifiedPlanArtifact(
                     graph=planned.graph,
                     graph_hash=task_graph_hash(planned.graph),
@@ -91,6 +121,8 @@ class PlanningCoordinator:
                 )
 
             if reviewed.critique.decision is CriticDecision.REJECT:
+                if progress is not None:
+                    progress("PLANNING", f"critic rejected revision={revision}")
                 raise PlanningCoordinationError(
                     "critic_rejected_plan:"
                     + ";".join(reviewed.critique.issues)
@@ -104,5 +136,12 @@ class PlanningCoordinator:
                 feedback = reviewed.critique.issues or (
                     "critic_requested_revision",
                 )
+            if progress is not None:
+                progress(
+                    "PLANNING",
+                    f"revision={revision} requires another planning round",
+                )
 
+        if progress is not None:
+            progress("PLANNING", "revision budget exhausted")
         raise PlanningCoordinationError("revision_budget_exhausted")

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/ai_cli.py

@@ -4,6 +4,9 @@ import argparse
 import importlib.util
 import json
 import os
+import sys
+import time
+from collections.abc import Callable
 
 from .agent import (
     AgentRuntime,
@@ -20,6 +23,8 @@ from .provider_adapters import PROVIDER_NAMES, create_provider
 from .provider_qualification import qualify_live_provider
 from .providers import ModelRegistry, ModelSpec, QualificationStatus
 
+ProgressCallback = Callable[[str, str], None]
+
 
 def _add_live_request_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("text", help="Natural-language engineering request")
@@ -33,6 +38,11 @@ def _add_live_request_args(parser: argparse.ArgumentParser) -> None:
     )
     parser.add_argument("--timeout", type=float, default=30.0)
     parser.add_argument("--max-attempts", type=int, default=2)
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress terminal progress logs; final JSON remains on stdout",
+    )
 
 
 def _parser() -> argparse.ArgumentParser:
@@ -54,6 +64,11 @@ def _parser() -> argparse.ArgumentParser:
     qualify.add_argument("--timeout", type=float, default=30.0)
     qualify.add_argument("--max-attempts", type=int, default=2)
     qualify.add_argument("--max-revisions", type=int, default=2)
+    qualify.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress terminal progress logs; final JSON remains on stdout",
+    )
 
     request = sub.add_parser(
         "request",
@@ -93,6 +108,28 @@ def provider_doctor(provider: str) -> dict:
     }
 
 
+def _terminal_progress(enabled: bool) -> ProgressCallback | None:
+    if not enabled:
+        return None
+    started = time.monotonic()
+
+    def emit(stage: str, message: str) -> None:
+        elapsed = time.monotonic() - started
+        label = stage.strip().upper()[:12]
+        print(
+            f"[DevAgent +{elapsed:7.2f}s] {label:<12} {message}",
+            file=sys.stderr,
+            flush=True,
+        )
+
+    return emit
+
+
+def _emit(progress: ProgressCallback | None, stage: str, message: str) -> None:
+    if progress is not None:
+        progress(stage, message)
+
+
 def _live_runtime(provider_name: str, model: str, *, timeout: float, max_attempts: int):
     provider = create_provider(provider_name)
     registry = ModelRegistry()
@@ -123,30 +160,51 @@ def _live_runtime(provider_name: str, model: str, *, timeout: float, max_attempt
     return provider, runtime, policy
 
 
-def _request(args: argparse.Namespace) -> int:
+def _request(args: argparse.Namespace, progress: ProgressCallback | None = None) -> int:
+    _emit(progress, "START", f"provider={args.provider} model={args.model}")
     _, runtime, policy = _live_runtime(
         args.provider,
         args.model,
         timeout=args.timeout,
         max_attempts=args.max_attempts,
     )
+    _emit(progress, "INTERPRETER", "understanding engineering request")
     interpreted = RequirementInterpreterAgent(runtime).interpret(
         args.text,
         policy,
         follow_ups=args.follow_up,
     )
+    if interpreted.validated is not None:
+        _emit(
+            progress,
+            "INTERPRETER",
+            f"validated request_id={interpreted.validated.request_id}",
+        )
+    elif interpreted.rejection_code:
+        _emit(
+            progress,
+            "INTERPRETER",
+            f"request rejected code={interpreted.rejection_code}",
+        )
+    else:
+        _emit(progress, "INTERPRETER", "more engineering information required")
+
     payload = interpreted.to_dict()
     payload["provider_mode"] = "simulation_only_ephemeral_route"
     payload["real_execution_allowed"] = False
     print(json.dumps(payload, indent=2))
     if interpreted.validated is not None:
+        _emit(progress, "COMPLETE", "request validation passed")
         return 0
     if interpreted.rejection_code:
+        _emit(progress, "COMPLETE", "request validation rejected")
         return 4
+    _emit(progress, "COMPLETE", "request requires follow-up information")
     return 3
 
 
-def _engineer(args: argparse.Namespace) -> int:
+def _engineer(args: argparse.Namespace, progress: ProgressCallback | None = None) -> int:
+    _emit(progress, "START", f"provider={args.provider} model={args.model}")
     _, runtime, policy = _live_runtime(
         args.provider,
         args.model,
@@ -164,6 +222,7 @@ def _engineer(args: argparse.Namespace) -> int:
         planner_policy=policy,
         critic_policy=policy,
         follow_ups=args.follow_up,
+        progress=progress,
     )
     payload = result.to_dict()
     payload["provider_mode"] = "simulation_only_ephemeral_route"
@@ -171,12 +230,25 @@ def _engineer(args: argparse.Namespace) -> int:
     print(json.dumps(payload, indent=2))
     if result.ready_for_twin_simulation:
         return 0
+    _emit(
+        progress,
+        "COMPLETE",
+        (
+            "ready_for_twin_simulation=false "
+            f"failure_code={result.failure_code or 'more_information_required'}"
+        ),
+    )
     if result.interpretation.validated is None and not result.interpretation.rejection_code:
         return 3
     return 4
 
 
-def _natural_language_failure(exc: BaseException) -> int:
+def _natural_language_failure(
+    exc: BaseException,
+    *,
+    progress: ProgressCallback | None = None,
+) -> int:
+    _emit(progress, "FAILED", f"pipeline stopped type={type(exc).__name__}")
     print(
         json.dumps(
             {
@@ -198,18 +270,21 @@ def main(argv: list[str] | None = None) -> int:
         print(json.dumps(result, indent=2))
         return 0 if result["ready_for_live_qualification"] else 1
 
+    progress = _terminal_progress(not getattr(args, "quiet", False))
+
     if args.command == "request":
         try:
-            return _request(args)
+            return _request(args, progress)
         except Exception as exc:
-            return _natural_language_failure(exc)
+            return _natural_language_failure(exc, progress=progress)
 
     if args.command == "engineer":
         try:
-            return _engineer(args)
+            return _engineer(args, progress)
         except Exception as exc:
-            return _natural_language_failure(exc)
+            return _natural_language_failure(exc, progress=progress)
 
+    _emit(progress, "START", f"provider={args.provider} model={args.model}")
     provider = create_provider(args.provider)
     report = qualify_live_provider(
         provider,
@@ -217,6 +292,12 @@ def main(argv: list[str] | None = None) -> int:
         timeout_s=args.timeout,
         max_attempts=args.max_attempts,
         max_revision_rounds=args.max_revisions,
+        progress=progress,
+    )
+    _emit(
+        progress,
+        "RESULT",
+        f"passed={str(report.passed).lower()} failure_code={report.failure_code or 'none'}",
     )
     print(json.dumps(report.to_dict(), indent=2))
     return 0 if report.passed else 2

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/engineering_agent.py

@@ -4,7 +4,12 @@ from dataclasses import asdict, dataclass
 from typing import Any, Sequence
 
 from .agent.contracts import AgentEvidence, RoutingPolicy
-from .agent.coordinator import PlanningCoordinationError, PlanningCoordinator, VerifiedPlanArtifact
+from .agent.coordinator import (
+    PlanningCoordinationError,
+    PlanningCoordinator,
+    ProgressCallback,
+    VerifiedPlanArtifact,
+)
 from .agent.critic import CriticAgent
 from .agent.evidence import task_graph_to_dict
 from .agent.interpreter import InterpretedEngineeringRequest, RequirementInterpreterAgent
@@ -153,7 +158,10 @@ class SmartEngineeringAgent:
         planner_policy: RoutingPolicy,
         critic_policy: RoutingPolicy,
         follow_ups: Sequence[str] = (),
+        progress: ProgressCallback | None = None,
     ) -> SmartEngineeringResult:
+        if progress is not None:
+            progress("INTERPRETER", "understanding engineering request")
         interpreted = self.interpreter.interpret(
             text,
             interpreter_policy,
@@ -161,12 +169,32 @@ class SmartEngineeringAgent:
         )
         request = interpreted.validated
         if request is None:
+            if progress is not None:
+                if interpreted.rejection_code:
+                    progress(
+                        "INTERPRETER",
+                        f"request rejected code={interpreted.rejection_code}",
+                    )
+                else:
+                    progress("INTERPRETER", "more engineering information required")
             return SmartEngineeringResult(
                 interpretation=interpreted,
                 failure_code=interpreted.rejection_code,
             )
 
+        if progress is not None:
+            progress("INTERPRETER", f"validated request_id={request.request_id}")
+
         strategy = self.reasoning_policy.select(request)
+        if progress is not None:
+            progress(
+                "REASONING",
+                (
+                    f"risk_score={strategy.risk_score} "
+                    f"max_revisions={strategy.max_revision_rounds} "
+                    f"critic_threshold={strategy.min_critic_score:.2f}"
+                ),
+            )
         goal = request.goal()
         resources = [request.resource()]
         # Explicit nominal model state, never represented as observed site state.
@@ -191,14 +219,19 @@ class SmartEngineeringAgent:
                 planner_policy,
                 critic_policy,
                 engineering_context=request.to_dict(),
+                progress=progress,
             )
         except PlanningCoordinationError as exc:
+            if progress is not None:
+                progress("PLANNING", "planning coordination failed")
             return SmartEngineeringResult(
                 interpretation=interpreted,
                 reasoning_strategy=strategy,
                 failure_code=f"planning_failed:{str(exc).split(':', 1)[0]}",
             )
         except Exception as exc:
+            if progress is not None:
+                progress("PLANNING", f"planning failed type={type(exc).__name__}")
             # Never expose provider/internal exception text as customer evidence.
             return SmartEngineeringResult(
                 interpretation=interpreted,
@@ -206,6 +239,8 @@ class SmartEngineeringAgent:
                 failure_code=f"planning_failed:{type(exc).__name__}",
             )
 
+        if progress is not None:
+            progress("SIMULATION", "running deterministic model execution")
         simulation_world = WorldState(facts=set(world.facts), values=dict(world.values))
         simulation = ExecutionSupervisor().execute(
             plan.graph,
@@ -216,6 +251,11 @@ class SmartEngineeringAgent:
         )
         if not simulation.completed:
             issue_codes = sorted({issue.code for issue in simulation.issues})
+            if progress is not None:
+                progress(
+                    "SIMULATION",
+                    "blocked by deterministic constraints",
+                )
             return SmartEngineeringResult(
                 interpretation=interpreted,
                 reasoning_strategy=strategy,
@@ -227,6 +267,9 @@ class SmartEngineeringAgent:
                 ),
             )
 
+        if progress is not None:
+            progress("SIMULATION", "deterministic model execution completed")
+            progress("COMPLETE", "ready_for_twin_simulation=true")
         return SmartEngineeringResult(
             interpretation=interpreted,
             reasoning_strategy=strategy,

{devagent_physical_engine-0.11.2 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/provider_adapters/openai.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Callable
+from typing import Any, Callable, Mapping
 
 from ..agent.contracts import ModelRequest, ModelResponse
 from ..agent.runtime import ProviderError, ProviderProtocolError, ProviderUnavailable
@@ -17,6 +17,86 @@ from .common import (
 )
 
 
+def _nullable_openai_schema(value: Mapping[str, Any]) -> dict[str, Any]:
+    """Return an OpenAI-strict-compatible nullable schema for an optional field."""
+
+    result = dict(value)
+    schema_type = result.get("type")
+    if isinstance(schema_type, str):
+        if schema_type != "null":
+            result["type"] = [schema_type, "null"]
+        return result
+    if isinstance(schema_type, list):
+        types = list(schema_type)
+        if "null" not in types:
+            types.append("null")
+        result["type"] = types
+        return result
+
+    enum = result.get("enum")
+    if isinstance(enum, list):
+        values = list(enum)
+        if None not in values:
+            values.append(None)
+        result["enum"] = values
+        return result
+
+    any_of = result.get("anyOf")
+    if isinstance(any_of, list):
+        branches = list(any_of)
+        if not any(
+            isinstance(branch, Mapping) and branch.get("type") == "null"
+            for branch in branches
+        ):
+            branches.append({"type": "null"})
+        result["anyOf"] = branches
+        return result
+
+    return {"anyOf": [result, {"type": "null"}]}
+
+
+def _openai_strict_schema(schema: Mapping[str, Any]) -> dict[str, Any]:
+    """Normalize a provider-neutral schema for OpenAI strict Structured Outputs.
+
+    DevAgent's core schemas intentionally permit omitted optional fields because
+    Anthropic, Gemini, and deterministic parsers support that representation.
+    OpenAI strict Structured Outputs instead requires every property of every
+    object to appear in ``required``. Preserve provider-neutral core semantics by
+    making only those originally optional properties nullable in the OpenAI
+    transport schema, while keeping deterministic parsing/compilation as the
+    final authority.
+    """
+
+    clean = provider_schema(schema)
+
+    def normalize(value: Any) -> Any:
+        if isinstance(value, list):
+            return [normalize(item) for item in value]
+        if not isinstance(value, dict):
+            return value
+
+        result = {key: normalize(item) for key, item in value.items()}
+        properties = result.get("properties")
+        if isinstance(properties, dict):
+            required_raw = result.get("required", [])
+            required = set(required_raw) if isinstance(required_raw, list) else set()
+            normalized_properties: dict[str, Any] = {}
+            for name, property_schema in properties.items():
+                if name in required or not isinstance(property_schema, Mapping):
+                    normalized_properties[name] = property_schema
+                else:
+                    normalized_properties[name] = _nullable_openai_schema(property_schema)
+            result["properties"] = normalized_properties
+            result["required"] = list(normalized_properties)
+            result["additionalProperties"] = False
+        return result
+
+    normalized = normalize(clean)
+    if not isinstance(normalized, dict):  # pragma: no cover - schema contract is mapping
+        raise TypeError("openai_schema_must_be_object")
+    return normalized
+
+
 class OpenAIProvider:
     provider_name = "openai"
 
@@ -58,7 +138,7 @@ class OpenAIProvider:
                         "type": "json_schema",
                         "name": f"devagent_{request.role.value}",
                         "strict": True,
-                        "schema": provider_schema(request.output_schema),
+                        "schema": _openai_strict_schema(request.output_schema),
                     }
                 },
                 max_output_tokens=self._max_output_tokens,