reasoning_layer_python_sdk 1.0.0__py3-none-any.whl

reasoning_layer_python_sdk/generated/models/rl_train_request.py

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from uuid import UUID
+from reasoning_layer_python_sdk.generated.models.conversation_training_config_dto import ConversationTrainingConfigDto
+from reasoning_layer_python_sdk.generated.models.rl_policy_config_dto import RlPolicyConfigDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RlTrainRequest(BaseModel):
+    """
+    Request to start an RL training run.  Supports two modes: - Standalone: Uses `environment_orchestrator::run()` (RL only, no cognitive cycle) - Cognitive: Uses `rl_cognitive_bridge::run()` (unified cognitive-RL loop)
+    """ # noqa: E501
+    conversation_config: Optional[ConversationTrainingConfigDto] = Field(default=None, description="Configuration for conversation-based training (when environment_name starts with \"conversation\")")
+    curiosity_bonus_amount: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Curiosity bonus amount (default: 0.1)")
+    enable_auto_curriculum: Optional[StrictBool] = Field(default=None, description="Enable auto-curriculum (Phase B, dynamic difficulty)")
+    enable_cognitive_cycle: Optional[StrictBool] = Field(default=None, description="If true, uses the cognitive-RL bridge (unified loop). If false, uses the standalone environment orchestrator (RL only).")
+    enable_curiosity_bonus: Optional[StrictBool] = Field(default=None, description="Whether to add curiosity bonus to rewards (only used with cognitive cycle)")
+    enable_deliberation_scaling: Optional[StrictBool] = Field(default=None, description="Enable deliberation scaling (Phase A, uncertainty-gated imagination)")
+    enable_expert_gating: Optional[StrictBool] = Field(default=None, description="Enable MoE dynamic expert gating (Phase F). When true, subsystem learning rates are dynamically routed via learned gating weights.")
+    enable_imagination_learning: Optional[StrictBool] = Field(default=None, description="Enable imagination learning (requires world model)")
+    enable_neural_dqn: Optional[StrictBool] = Field(default=None, description="Enable neural DQN mode (creates CandleNeuralQAdapter)")
+    enable_ontological_grounding: Optional[StrictBool] = Field(default=None, description="Enable ontological grounding loop")
+    enable_plasticity_schedule: Optional[StrictBool] = Field(default=None, description="Enable plasticity schedule (Phase C, differential learning rates per developmental phase)")
+    enable_self_play: Optional[StrictBool] = Field(default=None, description="Enable multi-agent self-play training (Phase E). When true, runs multiple agents in parallel, sharing trajectories.")
+    enable_state_encoder: Optional[StrictBool] = Field(default=None, description="Enable contrastive state encoder (auto-enabled with DQN)")
+    enable_world_model: Optional[StrictBool] = Field(default=None, description="Enable neural world model for imagination learning")
+    encoding_dim: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Encoding dimension for state encoder (default: 8)")
+    environment_name: StrictStr = Field(description="Environment identifier (e.g., \"grid_world_5x5\", \"grid_world_10x10\")")
+    expert_gate_entropy_coefficient: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Expert gating entropy regularization coefficient (default: 0.1)")
+    expert_gate_learning_rate: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Expert gating learning rate (default: 0.01)")
+    expert_gate_temperature: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Expert gating softmax temperature (default: 1.0)")
+    hidden_dim: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Hidden dimension for neural networks (default: 32)")
+    max_steps_per_episode: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Maximum steps per episode (1..=10,000, default: 200)")
+    num_episodes: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of training episodes (1..=10,000)")
+    persist_weights: Optional[StrictBool] = Field(default=None, description="Enable saving/loading DQN weights for persistence across restarts. When true, weights are saved to a tenant-specific path after training and loaded before training starts (continuing from last checkpoint).")
+    rl_config: Optional[RlPolicyConfigDto] = Field(default=None, description="Optional RL policy configuration overrides")
+    self_play_exchange_mode: Optional[StrictStr] = Field(default=None, description="Trajectory exchange mode: \"top_k\" | \"all_to_all\" | \"ring\"")
+    self_play_num_agents: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of agents in self-play population (default: 2, max: 10)")
+    self_play_num_rounds: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of self-play rounds (default: 5, max: 50)")
+    self_play_quality_threshold: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Quality threshold for shared trajectories [0.0, 1.0]")
+    self_play_social_observation: Optional[StrictBool] = Field(default=None, description="Enable social observation (trajectory sharing between agents)")
+    tenant_id: UUID = Field(description="Tenant ID for multi-tenant isolation")
+    __properties: ClassVar[List[str]] = ["conversation_config", "curiosity_bonus_amount", "enable_auto_curriculum", "enable_cognitive_cycle", "enable_curiosity_bonus", "enable_deliberation_scaling", "enable_expert_gating", "enable_imagination_learning", "enable_neural_dqn", "enable_ontological_grounding", "enable_plasticity_schedule", "enable_self_play", "enable_state_encoder", "enable_world_model", "encoding_dim", "environment_name", "expert_gate_entropy_coefficient", "expert_gate_learning_rate", "expert_gate_temperature", "hidden_dim", "max_steps_per_episode", "num_episodes", "persist_weights", "rl_config", "self_play_exchange_mode", "self_play_num_agents", "self_play_num_rounds", "self_play_quality_threshold", "self_play_social_observation", "tenant_id"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RlTrainRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of conversation_config
+        if self.conversation_config:
+            _dict['conversation_config'] = self.conversation_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of rl_config
+        if self.rl_config:
+            _dict['rl_config'] = self.rl_config.to_dict()
+        # set to None if conversation_config (nullable) is None
+        # and model_fields_set contains the field
+        if self.conversation_config is None and "conversation_config" in self.model_fields_set:
+            _dict['conversation_config'] = None
+
+        # set to None if rl_config (nullable) is None
+        # and model_fields_set contains the field
+        if self.rl_config is None and "rl_config" in self.model_fields_set:
+            _dict['rl_config'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RlTrainRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "conversation_config": ConversationTrainingConfigDto.from_dict(obj["conversation_config"]) if obj.get("conversation_config") is not None else None,
+            "curiosity_bonus_amount": obj.get("curiosity_bonus_amount"),
+            "enable_auto_curriculum": obj.get("enable_auto_curriculum"),
+            "enable_cognitive_cycle": obj.get("enable_cognitive_cycle"),
+            "enable_curiosity_bonus": obj.get("enable_curiosity_bonus"),
+            "enable_deliberation_scaling": obj.get("enable_deliberation_scaling"),
+            "enable_expert_gating": obj.get("enable_expert_gating"),
+            "enable_imagination_learning": obj.get("enable_imagination_learning"),
+            "enable_neural_dqn": obj.get("enable_neural_dqn"),
+            "enable_ontological_grounding": obj.get("enable_ontological_grounding"),
+            "enable_plasticity_schedule": obj.get("enable_plasticity_schedule"),
+            "enable_self_play": obj.get("enable_self_play"),
+            "enable_state_encoder": obj.get("enable_state_encoder"),
+            "enable_world_model": obj.get("enable_world_model"),
+            "encoding_dim": obj.get("encoding_dim"),
+            "environment_name": obj.get("environment_name"),
+            "expert_gate_entropy_coefficient": obj.get("expert_gate_entropy_coefficient"),
+            "expert_gate_learning_rate": obj.get("expert_gate_learning_rate"),
+            "expert_gate_temperature": obj.get("expert_gate_temperature"),
+            "hidden_dim": obj.get("hidden_dim"),
+            "max_steps_per_episode": obj.get("max_steps_per_episode"),
+            "num_episodes": obj.get("num_episodes"),
+            "persist_weights": obj.get("persist_weights"),
+            "rl_config": RlPolicyConfigDto.from_dict(obj["rl_config"]) if obj.get("rl_config") is not None else None,
+            "self_play_exchange_mode": obj.get("self_play_exchange_mode"),
+            "self_play_num_agents": obj.get("self_play_num_agents"),
+            "self_play_num_rounds": obj.get("self_play_num_rounds"),
+            "self_play_quality_threshold": obj.get("self_play_quality_threshold"),
+            "self_play_social_observation": obj.get("self_play_social_observation"),
+            "tenant_id": obj.get("tenant_id")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/rl_train_response.py

@@ -0,0 +1,161 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RlTrainResponse(BaseModel):
+    """
+    Response from an RL training run.
+    """ # noqa: E501
+    avg_reward_last_10: Union[StrictFloat, StrictInt] = Field(description="Average reward over the last 10 episodes (or all if fewer)")
+    cognitive_cycles_run: Annotated[int, Field(strict=True, ge=0)] = Field(description="Total cognitive cycles run (0 if cognitive cycle disabled)")
+    collapse_episodes: Optional[List[Annotated[int, Field(strict=True, ge=0)]]] = Field(default=None, description="Episodes where representation collapse was detected")
+    contrastive_losses: Optional[List[Union[StrictFloat, StrictInt]]] = Field(default=None, description="Contrastive losses from encoder training (empty if no encoder)")
+    conversation_decisions: Optional[Dict[str, Annotated[int, Field(strict=True, ge=0)]]] = Field(default=None, description="Conversation-specific metrics when training on conversation environment")
+    curriculum_adjustments: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Auto-curriculum adjustments")
+    curriculum_backtracks: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Auto-curriculum backtracks")
+    curriculum_stage_reached: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Auto-curriculum stage reached (None if disabled)")
+    deliberative_decisions: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of deliberative decisions from deliberation scaling")
+    dynamics_losses: Optional[List[Union[StrictFloat, StrictInt]]] = Field(default=None, description="Dynamics losses from neural world model (empty if no world model)")
+    episode_rewards: List[Union[StrictFloat, StrictInt]] = Field(description="Reward per episode")
+    episode_steps: List[Annotated[int, Field(strict=True, ge=0)]] = Field(description="Steps per episode")
+    episodes_completed: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of episodes completed")
+    expert_avg_entropy: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Average expert weight entropy (0.0 if disabled)")
+    expert_avg_weights: Optional[Dict[str, Union[StrictFloat, StrictInt]]] = Field(default=None, description="Average expert weights (empty map if gating disabled)")
+    expert_collapse_recoveries: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Expert collapse recoveries count")
+    expert_final_weights: Optional[Dict[str, Union[StrictFloat, StrictInt]]] = Field(default=None, description="Final expert weights at end of training")
+    final_contrastive_temperature: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Final contrastive temperature after feedback adaptation")
+    final_exploration_rate: Union[StrictFloat, StrictInt] = Field(description="Final exploration rate after training")
+    final_imagination_steps: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Final imagination steps after feedback adaptation")
+    imagination_transitions: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Imagined transitions from Dyna-Q (0 if disabled)")
+    mode_distribution: Optional[Dict[str, Annotated[int, Field(strict=True, ge=0)]]] = Field(default=None, description="Mode distribution (how often each cognitive mode was selected)")
+    peer_demonstrations_consumed: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of peer demonstrations consumed from self-play trajectory exchange")
+    plasticity_phase_transitions: Optional[List[List[Any]]] = Field(default=None, description="Plasticity phase transitions observed (episode, phase)")
+    reactive_decisions: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of reactive decisions from deliberation scaling")
+    self_play_agent_fitnesses: Optional[List[List[Union[StrictFloat, StrictInt]]]] = Field(default=None, description="Agent fitness per round: outer vec = agents, inner vec = rounds")
+    self_play_best_fitness: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Best agent fitness from self-play (None if self-play disabled)")
+    self_play_mean_fitness_per_round: Optional[List[Union[StrictFloat, StrictInt]]] = Field(default=None, description="Mean fitness per self-play round (empty if disabled)")
+    sort_aware_training_steps: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of sort-aware training steps performed")
+    sorts_discovered: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Sorts discovered by ontological grounding")
+    total_transitions: Annotated[int, Field(strict=True, ge=0)] = Field(description="Total transitions recorded across all episodes")
+    trajectories_exchanged: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Number of trajectories exchanged between agents in self-play")
+    __properties: ClassVar[List[str]] = ["avg_reward_last_10", "cognitive_cycles_run", "collapse_episodes", "contrastive_losses", "conversation_decisions", "curriculum_adjustments", "curriculum_backtracks", "curriculum_stage_reached", "deliberative_decisions", "dynamics_losses", "episode_rewards", "episode_steps", "episodes_completed", "expert_avg_entropy", "expert_avg_weights", "expert_collapse_recoveries", "expert_final_weights", "final_contrastive_temperature", "final_exploration_rate", "final_imagination_steps", "imagination_transitions", "mode_distribution", "peer_demonstrations_consumed", "plasticity_phase_transitions", "reactive_decisions", "self_play_agent_fitnesses", "self_play_best_fitness", "self_play_mean_fitness_per_round", "sort_aware_training_steps", "sorts_discovered", "total_transitions", "trajectories_exchanged"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RlTrainResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if curriculum_stage_reached (nullable) is None
+        # and model_fields_set contains the field
+        if self.curriculum_stage_reached is None and "curriculum_stage_reached" in self.model_fields_set:
+            _dict['curriculum_stage_reached'] = None
+
+        # set to None if self_play_best_fitness (nullable) is None
+        # and model_fields_set contains the field
+        if self.self_play_best_fitness is None and "self_play_best_fitness" in self.model_fields_set:
+            _dict['self_play_best_fitness'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RlTrainResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "avg_reward_last_10": obj.get("avg_reward_last_10"),
+            "cognitive_cycles_run": obj.get("cognitive_cycles_run"),
+            "collapse_episodes": obj.get("collapse_episodes"),
+            "contrastive_losses": obj.get("contrastive_losses"),
+            "conversation_decisions": obj.get("conversation_decisions"),
+            "curriculum_adjustments": obj.get("curriculum_adjustments"),
+            "curriculum_backtracks": obj.get("curriculum_backtracks"),
+            "curriculum_stage_reached": obj.get("curriculum_stage_reached"),
+            "deliberative_decisions": obj.get("deliberative_decisions"),
+            "dynamics_losses": obj.get("dynamics_losses"),
+            "episode_rewards": obj.get("episode_rewards"),
+            "episode_steps": obj.get("episode_steps"),
+            "episodes_completed": obj.get("episodes_completed"),
+            "expert_avg_entropy": obj.get("expert_avg_entropy"),
+            "expert_avg_weights": obj.get("expert_avg_weights"),
+            "expert_collapse_recoveries": obj.get("expert_collapse_recoveries"),
+            "expert_final_weights": obj.get("expert_final_weights"),
+            "final_contrastive_temperature": obj.get("final_contrastive_temperature"),
+            "final_exploration_rate": obj.get("final_exploration_rate"),
+            "final_imagination_steps": obj.get("final_imagination_steps"),
+            "imagination_transitions": obj.get("imagination_transitions"),
+            "mode_distribution": obj.get("mode_distribution"),
+            "peer_demonstrations_consumed": obj.get("peer_demonstrations_consumed"),
+            "plasticity_phase_transitions": obj.get("plasticity_phase_transitions"),
+            "reactive_decisions": obj.get("reactive_decisions"),
+            "self_play_agent_fitnesses": obj.get("self_play_agent_fitnesses"),
+            "self_play_best_fitness": obj.get("self_play_best_fitness"),
+            "self_play_mean_fitness_per_round": obj.get("self_play_mean_fitness_per_round"),
+            "sort_aware_training_steps": obj.get("sort_aware_training_steps"),
+            "sorts_discovered": obj.get("sorts_discovered"),
+            "total_transitions": obj.get("total_transitions"),
+            "trajectories_exchanged": obj.get("trajectories_exchanged")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/root_cause_analysis_request.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RootCauseAnalysisRequest(BaseModel):
+    """
+    Request for root cause analysis
+    """ # noqa: E501
+    effect: StrictStr = Field(description="The effect to analyze")
+    max_depth: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Maximum depth to search")
+    __properties: ClassVar[List[str]] = ["effect", "max_depth"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RootCauseAnalysisRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RootCauseAnalysisRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "effect": obj.get("effect"),
+            "max_depth": obj.get("max_depth")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/root_cause_analysis_response.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from reasoning_layer_python_sdk.generated.models.causal_chain_dto import CausalChainDto
+from reasoning_layer_python_sdk.generated.models.root_cause_dto import RootCauseDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RootCauseAnalysisResponse(BaseModel):
+    """
+    Response with root cause analysis
+    """ # noqa: E501
+    causal_chains: List[CausalChainDto] = Field(description="Causal chains leading to the effect")
+    effect: StrictStr = Field(description="The effect being analyzed")
+    root_causes: List[RootCauseDto] = Field(description="All root causes found")
+    __properties: ClassVar[List[str]] = ["causal_chains", "effect", "root_causes"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RootCauseAnalysisResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in causal_chains (list)
+        _items = []
+        if self.causal_chains:
+            for _item_causal_chains in self.causal_chains:
+                if _item_causal_chains:
+                    _items.append(_item_causal_chains.to_dict())
+            _dict['causal_chains'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in root_causes (list)
+        _items = []
+        if self.root_causes:
+            for _item_root_causes in self.root_causes:
+                if _item_root_causes:
+                    _items.append(_item_root_causes.to_dict())
+            _dict['root_causes'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RootCauseAnalysisResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "causal_chains": [CausalChainDto.from_dict(_item) for _item in obj["causal_chains"]] if obj.get("causal_chains") is not None else None,
+            "effect": obj.get("effect"),
+            "root_causes": [RootCauseDto.from_dict(_item) for _item in obj["root_causes"]] if obj.get("root_causes") is not None else None
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/root_cause_dto.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RootCauseDto(BaseModel):
+    """
+    A root cause with its chain
+    """ # noqa: E501
+    cause: StrictStr = Field(description="The root cause variable")
+    certainty: Union[StrictFloat, StrictInt] = Field(description="Chain certainty")
+    path: List[StrictStr] = Field(description="Full path from cause to effect")
+    via: Optional[StrictStr] = Field(default=None, description="The intermediate variable (via)")
+    __properties: ClassVar[List[str]] = ["cause", "certainty", "path", "via"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RootCauseDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if via (nullable) is None
+        # and model_fields_set contains the field
+        if self.via is None and "via" in self.model_fields_set:
+            _dict['via'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RootCauseDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "cause": obj.get("cause"),
+            "certainty": obj.get("certainty"),
+            "path": obj.get("path"),
+            "via": obj.get("via")
+        })
+        return _obj
+
+