Goal Engine¶

goal_engine — mvp.goal_engine

Cluster: Goal & Planning | Type: component | MCP Tools: 355

Overview¶

goal_engine decomposes high-level goals into guardrailed search trees with resource bounds, serving as the entry point for the G6 problem-solving pipeline. It exposes 25-op MCP subpackages for orchestration, metacognition, mental models, persistence, verification, and explicit machine learning; use each subpackage's ops and capabilities surfaces for the live registered operation set rather than relying on a hardcoded aggregate count.

When to use:

Breaking complex objectives into resource-bounded subtasks
Orchestrating multi-step reasoning with guardrails and checkpoints
Driving the full G6 algorithm (goal setting, data gathering, decomposition)

Example:

from mvp.goal_engine import GoalDecomposer, GoalInput

decomposer = GoalDecomposer(name="d")
result = decomposer.infer(GoalInput(goal="Classify customer churn"))
# result.ok → True; result.value → SearchTree with subtask nodes

Works well with: core, formal_methods, align_csf, grounding

Public API¶

`GoalDecomposer(AIBlock[GoalInput, SearchTree, None])`¶

Step 1 (Goal Setting) + Step 2 (Data Gathering) of the G6 algorithm.

Methods:

`infer(data: GoalInput) -> Result[SearchTree]`¶

`list_patterns() -> dict[str, object]`¶

Return the applied deterministic-reliability pattern catalog.

`bias() -> dict`¶

`ResourceBoundsSchema(BaseModel)`¶

Pydantic mirror of core.ResourceBounds.

Field	Type	Default
`max_execution_seconds`	`float \\| None`	None
`max_disk_bytes`	`int \\| None`	None
`max_tokens_per_minute`	`int \\| None`	None
`max_tokens_per_hour`	`int \\| None`	None
`max_tokens_per_day`	`int \\| None`	None
`max_tokens_per_week`	`int \\| None`	None
`max_tokens_per_month`	`int \\| None`	None

Methods:

`to_resource_bounds() -> ResourceBounds`¶

Convert to the immutable core.ResourceBounds runtime type.

`GuardrailSpec(BaseModel)`¶

Declarative guardrail — resolved to a Guardrail at runtime.

Field	Type	Default
`name`	`str`	required
`predicate`	`str`	required
`params`	`dict[str, Any]`	Field(default_factory=dict)
`message`	`str`	''

`CheckpointSpec(BaseModel)`¶

Declarative checkpoint — soft assertion logged per node.

Field	Type	Default
`name`	`str`	required
`predicate`	`str`	required
`params`	`dict[str, Any]`	Field(default_factory=dict)
`description`	`str`	''

`BreakpointSpec(BaseModel)`¶

Declarative breakpoint — HITL pause point.

Field	Type	Default
`name`	`str`	required
`description`	`str`	''
`active`	`bool`	True

`GoalInput(BaseModel)`¶

Canonical JSON input schema for the G6 problem-solving engine.

Field	Type	Default
`goal`	`str`	required
`context`	`str \\| None`	None
`constraints`	`list[str]`	Field(default_factory=list)
`resource_bounds`	`ResourceBoundsSchema \\| None`	None
`guardrails`	`list[GuardrailSpec]`	Field(default_factory=list)
`checkpoints`	`list[CheckpointSpec]`	Field(default_factory=list)
`breakpoints`	`list[BreakpointSpec]`	Field(default_factory=list)
`subtasks`	`list['GoalInput']`	Field(default_factory=list)
`success_criteria`	`list[str]`	Field(default_factory=list)

`EMLMCPBlock(AIBlock[MCPEMLInput, MCPEMLOutput, dict])`¶

25-op MCP block for Explicit Machine Learning.

Field	Type	Default
`name`	`str`	'eml_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPEMLInput) -> Result[MCPEMLOutput]`¶

`MCPEMLInput(BaseModel)`¶

Field	Type	Default
`op`	`EMLCommand`	required
`algorithm_id`	`str \\| None`	None
`problem_class`	`str \\| None`	None
`domain`	`str \\| None`	None
`algorithm_name`	`str \\| None`	None
`algorithm_json`	`str \\| None`	None
`confidence`	`float \\| None`	None
`inputs_json`	`str \\| None`	None
`problem`	`str \\| None`	None
`solution`	`str \\| None`	None
`context`	`str \\| None`	None
`rederivation_id`	`str \\| None`	None
`model_id`	`str \\| None`	None
`test_cases_json`	`str \\| None`	None
`code`	`str \\| None`	None
`compilation_id`	`str \\| None`	None
`error_message`	`str \\| None`	None
`safety_report_id`	`str \\| None`	None
`tier`	`int \\| None`	None
`cycle_id`	`str \\| None`	None
`metric_name`	`str \\| None`	None
`metric_value`	`float \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`tags`	`str \\| None`	None

`MCPEMLOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`EMLStore`¶

7-table SQLite store for Explicit Machine Learning.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`register_algorithm(name: str, problem_class: str, domain: str = 'general', algorithm_json: str = '{}', code: str | None = None, confidence: float = 0.0, tags: str = '') -> dict`¶

`get_algorithm(algorithm_id: str) -> dict | None`¶

`get_algorithm_by_class(problem_class: str) -> dict | None`¶

`list_algorithms(domain: str | None = None, problem_class: str | None = None, limit: int = 50) -> list[dict]`¶

`retire_algorithm(algorithm_id: str) -> bool`¶

`increment_usage(algorithm_id: str, success: bool = True) -> None`¶

`search_algorithms(query: str, top_k: int = 5, threshold: float = 0.0) -> list[dict]`¶

`store_model(problem_class: str, algorithm: str, code: str | None = None, confidence: float = 0.0, validation_cases_json: str = '[]', failure_modes_json: str = '[]') -> dict`¶

`get_model(model_id: str) -> dict | None`¶

`update_model(model_id: str, **kwargs) -> bool`¶

`store_rederivation(problem: str, original_solution: str, rederived_solution: str | None = None, match: bool = False, confidence: float = 0.0, pattern_json: str = '{}', attempts: int = 0) -> dict`¶

`get_rederivation(rederivation_id: str) -> dict | None`¶

`store_compilation(model_id: str | None, code: str, syntax_valid: bool = False, tests_passed: bool = False, test_results_json: str = '[]', iterations: int = 0) -> dict`¶

`get_compilation(compilation_id: str) -> dict | None`¶

`store_safety_report(target_id: str, target_type: str = 'algorithm', tier: int = 0, is_safe: bool = True, findings_json: str = '[]') -> dict`¶

`get_safety_report(report_id: str) -> dict | None`¶

`create_cycle(problem: str) -> dict`¶

`update_cycle(cycle_id: str, **kwargs) -> bool`¶

`get_cycle(cycle_id: str) -> dict | None`¶

`record_metric(metric_name: str, metric_value: float, context: str | None = None) -> dict`¶

`get_savings() -> dict`¶

Calculate cost savings from compiled algorithms.

`get_library_health() -> dict`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`GoalEngineMCPBlock(AIBlock[MCPGoalEngineInput, MCPGoalEngineOutput, dict])`¶

25-op MCP block for G6 main loop.

Field	Type	Default
`name`	`str`	'goal_engine_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPGoalEngineInput) -> Result[MCPGoalEngineOutput]`¶

`MCPGoalEngineInput(BaseModel)`¶

Field	Type	Default
`op`	`GoalEngineOp`	required
`goal_id`	`str \\| None`	None
`goal_text`	`str \\| None`	None
`context`	`str \\| None`	None
`constraints_json`	`str \\| None`	None
`resource_bounds_json`	`str \\| None`	None
`status`	`str \\| None`	None
`parent_id`	`str \\| None`	None
`tags`	`str \\| None`	None
`step_index`	`int \\| None`	None
`step_description`	`str \\| None`	None
`result_json`	`str \\| None`	None
`tool_used`	`str \\| None`	None
`duration_ms`	`int \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`notes`	`str \\| None`	None
`stage`	`int \\| None`	None
`failure_mode`	`str \\| None`	None
`metric_name`	`str \\| None`	None
`metric_value`	`float \\| None`	None
`reason`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`stages_json`	`str \\| None`	None

`MCPGoalEngineOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None
`completion_state`	`str`	'qualified-draft'
`warning_card`	`dict[str, Any] \\| None`	None
`evidence`	`dict[str, Any]`	{}

`GoalEngineStore`¶

SQLite persistence for goals, steps, sessions, history, telemetry.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`create_goal(goal_text: str, context: str | None = None, constraints_json: str = '[]', resource_bounds_json: str | None = None, status: str = 'pending', parent_id: str | None = None, depth: int = 0, tags: str = '') -> dict`¶

`get_goal(goal_id: str) -> dict | None`¶

`list_goals(status: str | None = None, tags: str | None = None, limit: int = 50) -> list[dict]`¶

`update_goal(goal_id: str, **kwargs) -> bool`¶

`delete_goal(goal_id: str) -> bool`¶

`count_goals(status: str | None = None) -> int`¶

`create_step(goal_id: str, step_index: int, description: str | None = None, status: str = 'pending', result_json: str | None = None, tool_used: str | None = None, duration_ms: int | None = None) -> dict`¶

`get_steps(goal_id: str) -> list[dict]`¶

`update_step(step_id: str, **kwargs) -> bool`¶

`create_session(name: str | None = None, root_goal_id: str | None = None, notes: str | None = None) -> dict`¶

`get_session(session_id: str) -> dict | None`¶

`record_history(goal_id: str | None, op: str, input_json: str | None = None, output_json: str | None = None) -> str`¶

`query_history(goal_id: str | None = None, limit: int = 50) -> list[dict]`¶

`record_telemetry(session_id: str | None, goal_id: str | None, metric_name: str, metric_value: float) -> str`¶

`get_telemetry(session_id: str | None = None, goal_id: str | None = None, limit: int = 100) -> list[dict]`¶

`search_goals(query: str, top_k: int = 10) -> list[dict]`¶

`MentalModelsMCPBlock(AIBlock[MCPMentalModelsInput, MCPMentalModelsOutput, dict])`¶

25-op MCP block for mental models.

Field	Type	Default
`name`	`str`	'mental_models_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPMentalModelsInput) -> Result[MCPMentalModelsOutput]`¶

`MCPMentalModelsInput(BaseModel)`¶

Field	Type	Default
`op`	`MentalModelsCommand`	required
`model_id`	`str \\| None`	None
`model_name`	`str \\| None`	None
`framework_type`	`str \\| None`	None
`problem`	`str \\| None`	None
`context`	`str \\| None`	None
`description`	`str \\| None`	None
`prompts_json`	`str \\| None`	None
`domain`	`str \\| None`	None
`worth`	`float \\| None`	None
`tags`	`str \\| None`	None
`models_json`	`str \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`notes`	`str \\| None`	None
`application_id`	`str \\| None`	None
`success`	`bool \\| None`	None
`effectiveness`	`float \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None

`MCPMentalModelsOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`MentalModelsStore`¶

SQLite persistence for models, applications, sessions, outcomes.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`store_model(name: str, framework_type: str | None = None, description: str | None = None, prompts_json: str = '[]', domain: str = 'general', worth: float = 0.5, tags: str = '') -> dict`¶

`get_model(model_id: str) -> dict | None`¶

`update_model(model_id: str, **kwargs) -> bool`¶

`delete_model(model_id: str) -> bool`¶

`list_models(framework_type: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`record_application(model_id: str, problem: str, analysis: str, insights_json: str = '[]', domain: str | None = None, effectiveness: float = 0.0) -> dict`¶

`get_applications(model_id: str, limit: int = 50) -> list[dict]`¶

`save_session(name: str | None = None, models_used_json: str = '[]', notes: str | None = None) -> dict`¶

`load_session(session_id: str) -> dict | None`¶

`list_sessions(limit: int = 50) -> list[dict]`¶

`delete_session(session_id: str) -> bool`¶

`record_outcome(model_id: str, application_id: str | None = None, success: bool = False, notes: str | None = None, domain: str | None = None) -> dict`¶

`query_outcomes(model_id: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`search_models(query: str, top_k: int = 10) -> list[dict]`¶

`MetacognitionMCPBlock(AIBlock[MCPMetacognitionInput, MCPMetacognitionOutput, dict])`¶

25-op MCP block for metacognition.

Field	Type	Default
`name`	`str`	'metacognition_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPMetacognitionInput) -> Result[MCPMetacognitionOutput]`¶

`MCPMetacognitionInput(BaseModel)`¶

Field	Type	Default
`op`	`MetacognitionCommand`	required
`domain`	`str \\| None`	None
`skill`	`str \\| None`	None
`level`	`float \\| None`	None
`confidence`	`float \\| None`	None
`evidence_json`	`str \\| None`	None
`bloom_level`	`str \\| None`	None
`policy_id`	`str \\| None`	None
`policy_name`	`str \\| None`	None
`description`	`str \\| None`	None
`conditions_json`	`str \\| None`	None
`actions_json`	`str \\| None`	None
`priority`	`int \\| None`	None
`active`	`bool \\| None`	None
`suggestion`	`str \\| None`	None
`status`	`str \\| None`	None
`result_json`	`str \\| None`	None
`bounds_json`	`str \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`notes`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`context`	`str \\| None`	None

`MCPMetacognitionOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`MetacognitionStore`¶

SQLite persistence for competencies, bloom_levels, policies, improvements, sessions.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`upsert_competence(domain: str, skill: str, level: float = 0.0, confidence: float = 0.5, evidence_json: str = '[]') -> dict`¶

`get_competence(domain: str, skill: str) -> dict | None`¶

`list_competencies(domain: str | None = None, limit: int = 50) -> list[dict]`¶

`upsert_bloom(domain: str, skill: str, level: str = 'remember') -> dict`¶

`get_bloom(domain: str, skill: str) -> dict | None`¶

`list_bloom(domain: str | None = None, limit: int = 50) -> list[dict]`¶

`set_policy(name: str, description: str | None = None, conditions_json: str = '[]', actions_json: str = '[]', priority: int = 0, active: bool = True) -> dict`¶

`get_policy(policy_id: str) -> dict | None`¶

`list_policies(active_only: bool = False, limit: int = 50) -> list[dict]`¶

`record_improvement(domain: str | None, suggestion: str, status: str = 'proposed', result_json: str | None = None) -> dict`¶

`query_improvements(domain: str | None = None, status: str | None = None, limit: int = 50) -> list[dict]`¶

`save_session(name: str | None = None, notes: str | None = None) -> dict`¶

`load_session(session_id: str) -> dict | None`¶

`list_sessions(limit: int = 50) -> list[dict]`¶

`delete_session(session_id: str) -> bool`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`NeurosymbolicMCPBlock(AIBlock[MCPNeurosymbolicInput, MCPNeurosymbolicOutput, dict])`¶

25-op MCP block for Neural-Symbolic Bridge.

Field	Type	Default
`name`	`str`	'neurosymbolic_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPNeurosymbolicInput) -> Result[MCPNeurosymbolicOutput]`¶

`MCPNeurosymbolicInput(BaseModel)`¶

Field	Type	Default
`op`	`NeurosymbolicCommand`	required
`ir_id`	`str \\| None`	None
`name`	`str \\| None`	None
`ir_type`	`str \\| None`	None
`spec_json`	`str \\| None`	None
`constraints_json`	`str \\| None`	None
`domain`	`str \\| None`	None
`formula`	`str \\| None`	None
`synthesis_id`	`str \\| None`	None
`sketch`	`str \\| None`	None
`oracle`	`str \\| None`	None
`candidate`	`str \\| None`	None
`max_iterations`	`int \\| None`	None
`mode`	`str \\| None`	None
`confidence`	`float \\| None`	None
`threshold`	`float \\| None`	None
`reason`	`str \\| None`	None
`claim`	`str \\| None`	None
`evidence`	`str \\| None`	None
`action`	`str \\| None`	None
`context`	`str \\| None`	None
`expression`	`str \\| None`	None
`weights_json`	`str \\| None`	None
`rules_json`	`str \\| None`	None
`verification_id`	`str \\| None`	None
`verification_type`	`str \\| None`	None
`result`	`str \\| None`	None
`model_json`	`str \\| None`	None
`duration_ms`	`float \\| None`	None
`session_name`	`str \\| None`	None
`data_json`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None

`MCPNeurosymbolicOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None
`completion_state`	`str`	'qualified-draft'
`warning_card`	`dict[str, Any] \\| None`	None
`evidence`	`dict[str, Any]`	{}

`NeurosymbolicStore`¶

5-table SQLite store for Neural-Symbolic Bridge.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`create_ir(name: str, ir_type: str, spec_json: str = '{}', constraints_json: str = '{}', domain: str = 'general') -> dict`¶

`get_ir(ir_id: str) -> dict | None`¶

`list_ir(ir_type: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`update_ir_valid(ir_id: str, valid: bool) -> bool`¶

`record_verification(verification_type: str, formula: str, result: str = '', model_json: str = '{}', confidence: float = 0.0, duration_ms: float = 0.0) -> dict`¶

`get_verification(verification_id: str) -> dict | None`¶

`create_synthesis(sketch: str, oracle: str, candidate: str | None = None, status: str = 'pending') -> dict`¶

`get_synthesis(synthesis_id: str) -> dict | None`¶

`update_synthesis(synthesis_id: str, **kwargs) -> bool`¶

`log_oscillation(mode: str, confidence: float = 0.0, action: str | None = None, context: str | None = None) -> dict`¶

`get_latest_mode() -> str`¶

`get_oscillation_history(limit: int = 20) -> list[dict]`¶

`save_session(session_name: str, data_json: str = '{}') -> dict`¶

`get_session(session_name: str) -> dict | None`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`counts() -> dict`¶

`OrchestrationMCPBlock(AIBlock[MCPOrchestrationInput, MCPOrchestrationOutput, dict])`¶

25-op MCP block for dual-process orchestration.

Field	Type	Default
`name`	`str`	'orchestration_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPOrchestrationInput) -> Result[MCPOrchestrationOutput]`¶

`MCPOrchestrationInput(BaseModel)`¶

Field	Type	Default
`op`	`OrchestrationCommand`	required
`problem`	`str \\| None`	None
`context`	`str \\| None`	None
`hypothesis`	`str \\| None`	None
`hypothesis_id`	`str \\| None`	None
`domain`	`str \\| None`	None
`reasoning`	`str \\| None`	None
`outcome`	`str \\| None`	None
`mode`	`str \\| None`	None
`type_i_weight`	`float \\| None`	None
`type_ii_weight`	`float \\| None`	None
`state_json`	`str \\| None`	None
`action`	`str \\| None`	None
`reward`	`float \\| None`	None
`next_state_json`	`str \\| None`	None
`learning_rate`	`float \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`notes`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`weights_json`	`str \\| None`	None
`confidence`	`float \\| None`	None

`MCPOrchestrationOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`OrchestrationStore`¶

SQLite persistence for hypotheses, decisions, weights, rl_buffer, sessions.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`store_hypothesis(problem: str | None, hypothesis: str, mode: str = 'type_i', confidence: float = 0.5) -> dict`¶

`get_hypothesis(hyp_id: str) -> dict | None`¶

`verify_hypothesis(hyp_id: str, verified: bool = True) -> bool`¶

`list_hypotheses(mode: str | None = None, limit: int = 50) -> list[dict]`¶

`record_decision(problem: str | None, mode_used: str, reasoning: str | None = None, outcome: str | None = None, weights_json: str | None = None) -> dict`¶

`query_decisions(mode: str | None = None, limit: int = 50) -> list[dict]`¶

`get_weights(domain: str = 'default') -> dict`¶

`update_weights(domain: str, type_i_weight: float, type_ii_weight: float) -> dict`¶

`record_reward(state_json: str | None, action: str, reward: float, next_state_json: str | None = None) -> dict`¶

`query_rewards(limit: int = 100) -> list[dict]`¶

`save_session(name: str | None = None, notes: str | None = None) -> dict`¶

`load_session(session_id: str) -> dict | None`¶

`list_sessions(limit: int = 50) -> list[dict]`¶

`delete_session(session_id: str) -> bool`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`PatternsMCPBlock(AIBlock[MCPPatternsInput, MCPPatternsOutput, dict])`¶

25-op MCP block for LLM Pattern Library.

Field	Type	Default
`name`	`str`	'patterns_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPPatternsInput) -> Result[MCPPatternsOutput]`¶

`MCPPatternsInput(BaseModel)`¶

Field	Type	Default
`op`	`PatternsCommand`	required
`pattern_id`	`str \\| None`	None
`pattern_name`	`str \\| None`	None
`category`	`str \\| None`	None
`template`	`str \\| None`	None
`description`	`str \\| None`	None
`variables_json`	`str \\| None`	None
`examples_json`	`str \\| None`	None
`domain`	`str \\| None`	None
`composition_id`	`str \\| None`	None
`pattern_ids_json`	`str \\| None`	None
`values_json`	`str \\| None`	None
`tag`	`str \\| None`	None
`tags_json`	`str \\| None`	None
`outcome`	`str \\| None`	None
`score`	`float \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`data_json`	`str \\| None`	None

`MCPPatternsOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`PatternsStore`¶

5-table SQLite store for LLM Pattern Library.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`register_pattern(name: str, template: str, category: str = 'general', description: str = '', variables_json: str = '[]', examples_json: str = '[]', domain: str = 'general') -> dict`¶

`get_pattern(pattern_id: str) -> dict | None`¶

`list_patterns(category: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`update_pattern(pattern_id: str, **kwargs) -> bool`¶

`retire_pattern(pattern_id: str) -> bool`¶

`search_patterns(query: str, top_k: int = 5) -> list[dict]`¶

`select_pattern(query: str, category: str | None = None) -> dict | None`¶

Select the best matching pattern.

`get_by_category(category: str, limit: int = 50) -> list[dict]`¶

`create_composition(name: str, pattern_ids_json: str = '[]', description: str = '') -> dict`¶

`get_composition(composition_id: str) -> dict | None`¶

`record_usage(pattern_id: str, outcome: str = '', score: float = 0.0, context: str = '') -> dict`¶

`get_pattern_stats(pattern_id: str) -> dict | None`¶

`get_effectiveness(limit: int = 20) -> list[dict]`¶

`add_tag(pattern_id: str, tag: str) -> dict`¶

`get_tags(pattern_id: str) -> list[str]`¶

`get_by_tag(tag: str, limit: int = 50) -> list[dict]`¶

`save_session(session_name: str, data_json: str = '{}') -> dict`¶

`load_session(session_id: str | None = None, session_name: str | None = None) -> dict | None`¶

`export_patterns(category: str | None = None) -> list[dict]`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`PersistenceMCPBlock(AIBlock[MCPPersistenceInput, MCPPersistenceOutput, dict])`¶

25-op MCP block for three-tier persistence.

Field	Type	Default
`name`	`str`	'persistence_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPPersistenceInput) -> Result[MCPPersistenceOutput]`¶

`MCPPersistenceInput(BaseModel)`¶

Field	Type	Default
`op`	`PersistenceCommand`	required
`error_id`	`str \\| None`	None
`error_type`	`str \\| None`	None
`error_message`	`str \\| None`	None
`signature`	`str \\| None`	None
`context_json`	`str \\| None`	None
`resolution`	`str \\| None`	None
`rule_id`	`str \\| None`	None
`rule_name`	`str \\| None`	None
`rule_json`	`str \\| None`	None
`action`	`str \\| None`	None
`case_id`	`str \\| None`	None
`problem`	`str \\| None`	None
`solution`	`str \\| None`	None
`outcome`	`str \\| None`	None
`reasoning_json`	`str \\| None`	None
`quality_score`	`float \\| None`	None
`entry_id`	`str \\| None`	None
`event_type`	`str \\| None`	None
`details`	`str \\| None`	None
`skill_id`	`str \\| None`	None
`domain`	`str \\| None`	None
`insights`	`str \\| None`	None
`period_start`	`str \\| None`	None
`period_end`	`str \\| None`	None
`knowledge_id`	`str \\| None`	None
`title`	`str \\| None`	None
`content`	`str \\| None`	None
`category`	`str \\| None`	None
`tags`	`str \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`data_json`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None

`MCPPersistenceOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`PersistenceStore`¶

7-table SQLite store for three-tier persistence.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`record_error(error_type: str, error_message: str, signature: str | None = None, context_json: str | None = None, resolution: str | None = None) -> dict`¶

`get_error(error_id: str) -> dict | None`¶

`list_errors(error_type: str | None = None, limit: int = 50) -> list[dict]`¶

`add_prevention_rule(name: str, rule_json: str, signature: str | None = None, error_id: str | None = None) -> dict`¶

`check_prevention(signature: str | None = None, action: str | None = None) -> list[dict]`¶

`store_case(problem: str, solution: str, outcome: str = 'unknown', reasoning_json: str | None = None, quality_score: float | None = None) -> dict`¶

`get_case(case_id: str) -> dict | None`¶

`increment_case_retrieved(case_id: str) -> None`¶

`retrieve_similar(query: str, top_k: int = 5, min_quality: float = 0.0) -> list[dict]`¶

`update_case_quality(case_id: str, quality_delta: float) -> bool`¶

`list_cases(outcome: str | None = None, limit: int = 50) -> list[dict]`¶

`record_learning(event_type: str, details: str, outcome: str = 'unknown', skill_id: str | None = None, domain: str | None = None, insights: str | None = None) -> dict`¶

`get_journal_entry(entry_id: str) -> dict | None`¶

`list_journal(event_type: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`store_journal_summary(period_start: str, period_end: str, entries_count: int, summary: str, key_patterns: str = '[]') -> dict`¶

`get_journal_trends(limit: int = 100) -> dict`¶

`store_knowledge(title: str, content: str, category: str = 'general', tags: str = '') -> dict`¶

`query_knowledge(query: str, category: str | None = None, top_k: int = 10) -> list[dict]`¶

`update_knowledge(knowledge_id: str, **kwargs: object) -> bool`¶

`list_knowledge(category: str | None = None, limit: int = 50) -> list[dict]`¶

`save_context(session_id: str | None = None, session_name: str | None = None, data_json: str = '{}') -> dict`¶

`load_context(session_id: str) -> dict | None`¶

`list_contexts(limit: int = 50) -> list[dict]`¶

`export_snapshot() -> dict`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

TF-IDF search across all text tables.

`MCPSolverInput(BaseModel)`¶

Field	Type	Default
`op`	`SolverCommand`	required
`tool_id`	`str \\| None`	None
`tool_name`	`str \\| None`	None
`tool_type`	`str \\| None`	None
`description`	`str \\| None`	None
`tool_schema_json`	`str \\| None`	None
`config_json`	`str \\| None`	None
`cost_per_call`	`float \\| None`	None
`domain`	`str \\| None`	None
`category`	`str \\| None`	None
`args_json`	`str \\| None`	None
`timeout_ms`	`float \\| None`	None
`tasks_json`	`str \\| None`	None
`invocation_id`	`str \\| None`	None
`cache_key`	`str \\| None`	None
`result_json`	`str \\| None`	None
`ttl_seconds`	`int \\| None`	None
`policy_name`	`str \\| None`	None
`policy_json`	`str \\| None`	None
`action`	`str \\| None`	None
`failure_threshold`	`int \\| None`	None
`reset_timeout_sec`	`int \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`task`	`str \\| None`	None

`MCPSolverOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None
`completion_state`	`str`	'qualified-draft'
`warning_card`	`dict[str, Any] \\| None`	None
`evidence`	`dict[str, Any]`	{}

`SolverMCPBlock(AIBlock[MCPSolverInput, MCPSolverOutput, dict])`¶

25-op MCP block for Tool Registry + Execution.

Field	Type	Default
`name`	`str`	'solver_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPSolverInput) -> Result[MCPSolverOutput]`¶

`SolverStore`¶

5-table SQLite store for Tool Registry + Execution.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`register_tool(name: str, tool_type: str = 'function', description: str = '', schema_json: str = '{}', config_json: str = '{}', cost_per_call: float = 0.0, domain: str = 'general', category: str = 'general') -> dict`¶

`get_tool(tool_id: str) -> dict | None`¶

`get_tool_by_name(name: str) -> dict | None`¶

`list_tools(domain: str | None = None, category: str | None = None, limit: int = 50) -> list[dict]`¶

`update_tool(tool_id: str, **kwargs) -> bool`¶

`retire_tool(tool_id: str) -> bool`¶

`increment_usage(tool_id: str, success: bool = True) -> None`¶

`record_invocation(tool_id: str, args_json: str = '{}', result_json: str = '{}', success: bool = True, error: str | None = None, execution_time_ms: float = 0.0, cost: float = 0.0) -> dict`¶

`get_invocation(invocation_id: str) -> dict | None`¶

`list_invocations(tool_id: str | None = None, limit: int = 50) -> list[dict]`¶

`get_execution_stats(tool_id: str | None = None) -> dict`¶

`cache_result(cache_key: str, tool_id: str, args_json: str = '{}', result_json: str = '{}', ttl_seconds: int = 3600) -> dict`¶

`lookup_cache(cache_key: str) -> dict | None`¶

`set_policy(policy_name: str, policy_json: str = '{}', description: str = '') -> dict`¶

`get_policy(policy_name: str) -> dict | None`¶

`list_policies(active_only: bool = True) -> list[dict]`¶

`set_circuit_breaker(tool_id: str, failure_threshold: int = 5, reset_timeout_sec: int = 60) -> dict`¶

`get_circuit_breaker(tool_id: str) -> dict | None`¶

`update_circuit_breaker(tool_id: str, **kwargs) -> bool`¶

`reset_circuit_breaker(tool_id: str) -> bool`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`MCPStrategyInput(BaseModel)`¶

Field	Type	Default
`op`	`StrategyCommand`	required
`strategy_id`	`str \\| None`	None
`strategy_name`	`str \\| None`	None
`strategy_type`	`str \\| None`	None
`description`	`str \\| None`	None
`conditions_json`	`str \\| None`	None
`constraints_json`	`str \\| None`	None
`domain`	`str \\| None`	None
`category`	`str \\| None`	None
`task`	`str \\| None`	None
`context_json`	`str \\| None`	None
`strategy_ids_json`	`str \\| None`	None
`composition_id`	`str \\| None`	None
`composition_type`	`str \\| None`	None
`session_id`	`str \\| None`	None
`confidence`	`float \\| None`	None
`threshold`	`float \\| None`	None
`failure_count`	`int \\| None`	None
`failure_limit`	`int \\| None`	None
`reason`	`str \\| None`	None
`outcome`	`str \\| None`	None
`metrics_json`	`str \\| None`	None
`score`	`float \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`data_json`	`str \\| None`	None
`session_name`	`str \\| None`	None

`MCPStrategyOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None
`completion_state`	`str`	'qualified-draft'
`warning_card`	`dict[str, Any] \\| None`	None
`evidence`	`dict[str, Any]`	{}

`StrategyStore`¶

5-table SQLite store for Meta-Strategy Selection.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`register_strategy(name: str, strategy_type: str = 'generic', description: str = '', conditions_json: str = '[]', constraints_json: str = '[]', domain: str = 'general', category: str = '') -> dict`¶

`get_strategy(strategy_id: str) -> dict | None`¶

`list_strategies(domain: str | None = None, category: str | None = None, strategy_type: str | None = None, limit: int = 50) -> list[dict]`¶

`update_strategy(strategy_id: str, **kwargs) -> bool`¶

`retire_strategy(strategy_id: str) -> bool`¶

`increment_strategy_usage(strategy_id: str, success: bool = True, confidence: float = 0.0) -> None`¶

`create_composition(name: str, strategy_ids_json: str = '[]', composition_type: str = 'sequential', description: str = '') -> dict`¶

`get_composition(composition_id: str) -> dict | None`¶

`record_switch(session_id: str, from_strategy_id: str, to_strategy_id: str, reason: str = '', confidence: float = 0.0) -> dict`¶

`get_switch_history(session_id: str, limit: int = 50) -> list[dict]`¶

`record_outcome(strategy_id: str, outcome: str, confidence: float = 0.0, metrics_json: str = '{}', context_json: str = '{}') -> dict`¶

`get_strategy_stats(strategy_id: str) -> dict`¶

`get_effectiveness(domain: str | None = None) -> dict`¶

Aggregate effectiveness metrics across strategies.

`save_session(session_name: str = '', session_id: str | None = None, data_json: str = '{}') -> dict`¶

`load_session(session_id: str) -> dict | None`¶

`export_playbook(domain: str | None = None) -> dict`¶

Export all active strategies as a playbook.

`search(query: str, top_k: int = 10) -> list[dict]`¶

`StrategyMCPBlock(AIBlock[MCPStrategyInput, MCPStrategyOutput, dict])`¶

25-op MCP block for Meta-Strategy Selection.

Field	Type	Default
`name`	`str`	'strategy_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPStrategyInput) -> Result[MCPStrategyOutput]`¶

`MCPTumixInput(BaseModel)`¶

Field	Type	Default
`op`	`TumixCommand`	required
`agent_id`	`str \\| None`	None
`agent_name`	`str \\| None`	None
`agent_type`	`str \\| None`	None
`capabilities_json`	`str \\| None`	None
`config_json`	`str \\| None`	None
`run_id`	`str \\| None`	None
`task`	`str \\| None`	None
`agent_ids_json`	`str \\| None`	None
`context`	`str \\| None`	None
`vote_run_id`	`str \\| None`	None
`candidate`	`str \\| None`	None
`score`	`float \\| None`	None
`voter_id`	`str \\| None`	None
`threshold`	`float \\| None`	None
`outputs_json`	`str \\| None`	None
`result_text`	`str \\| None`	None
`feedback`	`str \\| None`	None
`results_json`	`str \\| None`	None
`outcome`	`str \\| None`	None
`duration`	`float \\| None`	None
`session_id`	`str \\| None`	None
`session_data_json`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`tags`	`str \\| None`	None

`MCPTumixOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`TumixStore`¶

5-table SQLite store for Multi-Agent Execution.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`register_agent(name: str, agent_type: str = 'generic', capabilities_json: str = '[]', config_json: str = '{}', tags: str = '') -> dict`¶

`get_agent(agent_id: str) -> dict | None`¶

`list_agents(agent_type: str | None = None, limit: int = 50) -> list[dict]`¶

`update_agent(agent_id: str, **kwargs) -> bool`¶

`retire_agent(agent_id: str) -> bool`¶

`increment_agent_runs(agent_id: str, success: bool = True, confidence: float = 0.0) -> None`¶

`create_run(task: str, mode: str = 'single', agent_ids_json: str = '[]', context: str | None = None) -> dict`¶

`get_run(run_id: str) -> dict | None`¶

`update_run(run_id: str, **kwargs) -> bool`¶

`cancel_run(run_id: str) -> bool`¶

`record_vote(run_id: str, voter_id: str, candidate: str, score: float = 0.0) -> dict`¶

`tally_votes(run_id: str) -> list[dict]`¶

`get_consensus(run_id: str, threshold: float = 0.5) -> dict`¶

`record_outcome(run_id: str | None, agent_id: str | None, outcome: str, duration: float = 0.0, confidence: float = 0.0) -> dict`¶

`get_agent_stats(agent_id: str) -> dict`¶

`get_run_stats(run_id: str) -> dict`¶

`save_session(session_id: str | None = None, session_data_json: str = '{}') -> dict`¶

`load_session(session_id: str) -> dict | None`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`TumixMCPBlock(AIBlock[MCPTumixInput, MCPTumixOutput, dict])`¶

25-op MCP block for Multi-Agent Execution.

Field	Type	Default
`name`	`str`	'tumix_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPTumixInput) -> Result[MCPTumixOutput]`¶

`MCPVerifierInput(BaseModel)`¶

Field	Type	Default
`op`	`VerifierCommand`	required
`claim`	`str \\| None`	None
`evidence`	`str \\| None`	None
`verification_type`	`str \\| None`	None
`context`	`str \\| None`	None
`verification_id`	`str \\| None`	None
`code`	`str \\| None`	None
`test_cases_json`	`str \\| None`	None
`inputs_json`	`str \\| None`	None
`timeout_ms`	`int \\| None`	None
`step_status`	`str \\| None`	None
`step_output`	`str \\| None`	None
`output_validated`	`bool \\| None`	None
`ns_success`	`bool \\| None`	None
`metric_name`	`str \\| None`	None
`metric_value`	`float \\| None`	None
`threshold_value`	`float \\| None`	None
`threshold_type`	`str \\| None`	None
`metrics_json`	`str \\| None`	None
`thresholds_json`	`str \\| None`	None
`pipeline_id`	`str \\| None`	None
`claims_json`	`str \\| None`	None
`stages_json`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None
`tags`	`str \\| None`	None
`backend`	`str \\| None`	None

`MCPVerifierOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None
`completion_state`	`str`	'qualified-draft'
`warning_card`	`dict[str, Any] \\| None`	None
`evidence`	`dict[str, Any]`	{}

`VerifierStore`¶

5-table SQLite store for verification records.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`record_verification(claim: str, evidence: str | None = None, backend: str = 'auto', verified: bool = False, confidence: float = 0.0, explanation: str = '', details_json: str = '{}', duration_ms: int = 0, tags: str = '') -> dict`¶

`get_verification(verification_id: str) -> dict | None`¶

`list_verifications(backend: str | None = None, limit: int = 50) -> list[dict]`¶

`query_verifications(query: str, top_k: int = 10) -> list[dict]`¶

`record_execution(code: str, success: bool = False, output: str = '', stdout: str = '', stderr: str = '', error: str = '', execution_time_ms: int = 0, timed_out: bool = False) -> dict`¶

`get_execution_stats() -> dict`¶

`set_threshold(metric_name: str, threshold_value: float, threshold_type: str = 'min') -> dict`¶

`get_thresholds() -> list[dict]`¶

`evaluate_metrics(metrics: dict, thresholds: dict | None = None) -> dict`¶

Evaluate metrics against thresholds.

`create_pipeline(stages_json: str = '[]', total_claims: int = 0) -> dict`¶

`update_pipeline(pipeline_id: str, **kwargs) -> bool`¶

`get_pipeline(pipeline_id: str) -> dict | None`¶

`record_ast_report(code: str, is_valid: bool, errors_json: str = '[]', node_counts_json: str = '{}') -> dict`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`VerifierMCPBlock(AIBlock[MCPVerifierInput, MCPVerifierOutput, dict])`¶

25-op MCP block for multi-backend verification.

Field	Type	Default
`name`	`str`	'verifier_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPVerifierInput) -> Result[MCPVerifierOutput]`¶

`MCPWorkflowsInput(BaseModel)`¶

Field	Type	Default
`op`	`WorkflowsCommand`	required
`workflow_id`	`str \\| None`	None
`workflow_name`	`str \\| None`	None
`steps_json`	`str \\| None`	None
`transitions_json`	`str \\| None`	None
`category`	`str \\| None`	None
`domain`	`str \\| None`	None
`run_id`	`str \\| None`	None
`step_name`	`str \\| None`	None
`result_json`	`str \\| None`	None
`error_message`	`str \\| None`	None
`params_json`	`str \\| None`	None
`template_name`	`str \\| None`	None
`outcome`	`str \\| None`	None
`metrics_json`	`str \\| None`	None
`session_id`	`str \\| None`	None
`session_name`	`str \\| None`	None
`data_json`	`str \\| None`	None
`query`	`str \\| None`	None
`limit`	`int \\| None`	None

`MCPWorkflowsOutput(BaseModel)`¶

Field	Type	Default
`ok`	`bool`	required
`message`	`str`	required
`data_json`	`str \\| None`	None
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None

`WorkflowsStore`¶

5-table SQLite store for Workflow Templates & Pipelines.

Constructor:

Parameter	Type	Default
`db_path`	`str`	':memory:'

Methods:

`register_workflow(name: str, steps_json: str = '[]', transitions_json: str = '{}', category: str = 'general', domain: str = 'general') -> dict`¶

`get_workflow(workflow_id: str) -> dict | None`¶

`list_workflows(category: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`update_workflow(workflow_id: str, **kwargs) -> bool`¶

`retire_workflow(workflow_id: str) -> bool`¶

`increment_usage(workflow_id: str, success: bool = True) -> None`¶

`increment_success_count(workflow_id: str) -> None`¶

`create_run(workflow_id: str, first_step: str, params_json: str = '{}') -> dict`¶

`get_run(run_id: str) -> dict | None`¶

`list_runs(workflow_id: str | None = None, status: str | None = None, limit: int = 50) -> list[dict]`¶

`update_run(run_id: str, **kwargs) -> bool`¶

`record_step(run_id: str, step_name: str, step_index: int, status: str = 'pending', result_json: str | None = None, error: str | None = None) -> dict`¶

`complete_step(step_id: str, result_json: str | None = None) -> bool`¶

`fail_step(step_id: str, error: str | None = None) -> bool`¶

`get_step_history(run_id: str) -> list[dict]`¶

`store_template(name: str, description: str = '', steps_json: str = '[]', transitions_json: str = '{}', category: str = 'general', params_schema_json: str = '{}') -> dict`¶

`get_template(name: str) -> dict | None`¶

`list_templates(limit: int = 50) -> list[dict]`¶

`save_session(session_name: str, data_json: str = '{}') -> dict`¶

`load_session(session_name: str | None = None, session_id: str | None = None) -> dict | None`¶

`get_workflow_stats(workflow_id: str | None = None) -> dict`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`WorkflowsMCPBlock(AIBlock[MCPWorkflowsInput, MCPWorkflowsOutput, dict])`¶

25-op MCP block for Workflow Templates & Pipelines.

Field	Type	Default
`name`	`str`	'workflows_mcp'
`state`	`dict \\| None`	None
`db_path`	`str`	''

Methods:

`infer(data: MCPWorkflowsInput) -> Result[MCPWorkflowsOutput]`¶

Functions¶

`register_predicate(name: str, factory: Callable[[dict[str, Any]], Callable[[Any], bool]], override: bool = False) -> None`¶

Register a domain predicate factory without editing this module.

`list_predicates() -> list[str]`¶

Return registered predicate names in stable order.

`resolve_guardrail(spec: GuardrailSpec) -> Guardrail`¶

Convert a declarative GuardrailSpec into a runtime Guardrail.

`resolve_checkpoint(spec: CheckpointSpec) -> Checkpoint`¶

Convert a declarative CheckpointSpec into a runtime Checkpoint.

`resolve_breakpoint(spec: BreakpointSpec) -> Breakpoint`¶

Convert a declarative BreakpointSpec into a runtime Breakpoint.

MCP Tools¶

Operation	Source
`lookup_algorithm`	eml_mcp
`register_algorithm`	eml_mcp
`execute_algorithm`	eml_mcp
`list_algorithms`	eml_mcp
`retire_algorithm`	eml_mcp
`forget_and_rederive`	eml_mcp
`compare_derivations`	eml_mcp
`extract_pattern`	eml_mcp
`get_rederivation`	eml_mcp
`build_model`	eml_mcp
`validate_model`	eml_mcp
`compress_model`	eml_mcp
`get_model`	eml_mcp
`compile_to_code`	eml_mcp
`test_compiled`	eml_mcp
`fix_compilation`	eml_mcp
`validate_safety`	eml_mcp
`get_safety_report`	eml_mcp
`run_eml_cycle`	eml_mcp
`get_cycle_status`	eml_mcp
`record_metric`	eml_mcp
`get_savings`	eml_mcp
`get_library_health`	eml_mcp
`search`	eml_mcp
`info`	eml_mcp
`ops`	eml_mcp
`help`	eml_mcp
`ops`	goal_engine_mcp
`help`	goal_engine_mcp
`capabilities`	goal_engine_mcp
`create_goal`	goal_engine_mcp
`get_goal`	goal_engine_mcp
`list_goals`	goal_engine_mcp
`update_goal`	goal_engine_mcp
`delete_goal`	goal_engine_mcp
`decompose`	goal_engine_mcp
`redecompose`	goal_engine_mcp
`validate`	goal_engine_mcp
`get_subtasks`	goal_engine_mcp
`classify_task`	goal_engine_mcp
`select_tools`	goal_engine_mcp
`plan_pipeline`	goal_engine_mcp
`reason_step`	goal_engine_mcp
`execute_step`	goal_engine_mcp
`accept_result`	goal_engine_mcp
`reject_result`	goal_engine_mcp
`review_result`	goal_engine_mcp
`record_step`	goal_engine_mcp
`query_history`	goal_engine_mcp
`summarize_session`	goal_engine_mcp
`get_progress`	goal_engine_mcp
`check_resources`	goal_engine_mcp
`get_stage_info`	goal_engine_mcp
`get_failure_mode`	goal_engine_mcp
`info`	goal_engine_mcp
`apply`	mental_models_mcp
`synthesize`	mental_models_mcp
`recommend`	mental_models_mcp
`evaluate`	mental_models_mcp
`list_frameworks`	mental_models_mcp
`store_model`	mental_models_mcp
`get_model`	mental_models_mcp
`update_model`	mental_models_mcp
`delete_model`	mental_models_mcp
`list_models`	mental_models_mcp
`apply_first_principles`	mental_models_mcp
`apply_inversion`	mental_models_mcp
`apply_second_order`	mental_models_mcp
`apply_analogical`	mental_models_mcp
`apply_probabilistic`	mental_models_mcp
`apply_systems`	mental_models_mcp
`save_session`	mental_models_mcp
`load_session`	mental_models_mcp
`list_sessions`	mental_models_mcp
`delete_session`	mental_models_mcp
`record_outcome`	mental_models_mcp
`query_outcomes`	mental_models_mcp
`summarize_outcomes`	mental_models_mcp
`search`	mental_models_mcp
`info`	mental_models_mcp
`ops`	mental_models_mcp
`help`	mental_models_mcp
`assess_competence`	metacognition_mcp
`update_competence`	metacognition_mcp
`get_competence`	metacognition_mcp
`list_competencies`	metacognition_mcp
`classify_bloom`	metacognition_mcp
`advance_bloom`	metacognition_mcp
`get_bloom_level`	metacognition_mcp
`bloom_summary`	metacognition_mcp
`set_policy`	metacognition_mcp
`get_policy`	metacognition_mcp
`evaluate_policy`	metacognition_mcp
`list_policies`	metacognition_mcp
`suggest_improvement`	metacognition_mcp
`record_improvement`	metacognition_mcp
`query_improvements`	metacognition_mcp
`get_bounds`	metacognition_mcp
`update_bounds`	metacognition_mcp
`bounds_summary`	metacognition_mcp
`save_session`	metacognition_mcp
`load_session`	metacognition_mcp
`list_sessions`	metacognition_mcp
`delete_session`	metacognition_mcp
`self_assess`	metacognition_mcp
`search`	metacognition_mcp
`info`	metacognition_mcp
`ops`	metacognition_mcp
`help`	metacognition_mcp
`create_ir`	neurosymbolic_mcp
`validate_ir`	neurosymbolic_mcp
`get_ir`	neurosymbolic_mcp
`list_ir`	neurosymbolic_mcp
`check_sat`	neurosymbolic_mcp
`prove`	neurosymbolic_mcp
`get_model`	neurosymbolic_mcp
`simplify_formula`	neurosymbolic_mcp
`synthesize`	neurosymbolic_mcp
`verify_candidate`	neurosymbolic_mcp
`get_counterexample`	neurosymbolic_mcp
`run_cegis_loop`	neurosymbolic_mcp
`get_synthesis`	neurosymbolic_mcp
`get_mode`	neurosymbolic_mcp
`switch_mode`	neurosymbolic_mcp
`assess_confidence`	neurosymbolic_mcp
`run_oscillation_step`	neurosymbolic_mcp
`verify_hybrid`	neurosymbolic_mcp
`neural_to_symbolic`	neurosymbolic_mcp
`symbolic_to_neural`	neurosymbolic_mcp
`record_verification`	neurosymbolic_mcp
`get_verification`	neurosymbolic_mcp
`save_session`	neurosymbolic_mcp
`search`	neurosymbolic_mcp
`info`	neurosymbolic_mcp
`ops`	neurosymbolic_mcp
`help`	neurosymbolic_mcp
`capabilities`	neurosymbolic_mcp
`generate_hypothesis`	orchestration_mcp
`quick_assess`	orchestration_mcp
`intuitive_response`	orchestration_mcp
`pattern_match`	orchestration_mcp
`deliberate_reason`	orchestration_mcp
`verify_hypothesis`	orchestration_mcp
`step_decompose`	orchestration_mcp
`formal_check`	orchestration_mcp
`orchestrate`	orchestration_mcp
`select_mode`	orchestration_mcp
`get_weights`	orchestration_mcp
`update_weights`	orchestration_mcp
`record_decision`	orchestration_mcp
`query_decisions`	orchestration_mcp
`summarize_decisions`	orchestration_mcp
`record_reward`	orchestration_mcp
`query_rewards`	orchestration_mcp
`policy_gradient`	orchestration_mcp
`save_session`	orchestration_mcp
`load_session`	orchestration_mcp
`list_sessions`	orchestration_mcp
`delete_session`	orchestration_mcp
`calibrate`	orchestration_mcp
`search`	orchestration_mcp
`info`	orchestration_mcp
`ops`	orchestration_mcp
`help`	orchestration_mcp
`register_pattern`	patterns_mcp
`get_pattern`	patterns_mcp
`list_patterns`	patterns_mcp
`update_pattern`	patterns_mcp
`retire_pattern`	patterns_mcp
`search_patterns`	patterns_mcp
`select_pattern`	patterns_mcp
`get_by_category`	patterns_mcp
`seed_catalog`	patterns_mcp
`get_catalog_stats`	patterns_mcp
`render_pattern`	patterns_mcp
`compose_patterns`	patterns_mcp
`get_composition`	patterns_mcp
`validate_pattern`	patterns_mcp
`extract_variables`	patterns_mcp
`record_usage`	patterns_mcp
`get_pattern_stats`	patterns_mcp
`get_effectiveness`	patterns_mcp
`tag_pattern`	patterns_mcp
`get_by_tag`	patterns_mcp
`save_session`	patterns_mcp
`load_session`	patterns_mcp
`export_patterns`	patterns_mcp
`search`	patterns_mcp
`info`	patterns_mcp
`ops`	patterns_mcp
`help`	patterns_mcp
`record_error`	persistence_mcp
`get_error`	persistence_mcp
`list_errors`	persistence_mcp
`add_prevention_rule`	persistence_mcp
`check_prevention`	persistence_mcp
`store_case`	persistence_mcp
`retrieve_similar`	persistence_mcp
`adapt_case`	persistence_mcp
`update_case_quality`	persistence_mcp
`list_cases`	persistence_mcp
`record_learning`	persistence_mcp
`get_journal_entry`	persistence_mcp
`list_journal`	persistence_mcp
`summarize_journal`	persistence_mcp
`get_trends`	persistence_mcp
`store_knowledge`	persistence_mcp
`query_knowledge`	persistence_mcp
`update_knowledge`	persistence_mcp
`list_knowledge`	persistence_mcp
`save_context`	persistence_mcp
`load_context`	persistence_mcp
`list_contexts`	persistence_mcp
`export_snapshot`	persistence_mcp
`search`	persistence_mcp
`info`	persistence_mcp
`ops`	persistence_mcp
`help`	persistence_mcp
`register_tool`	solver_mcp
`get_tool`	solver_mcp
`list_tools`	solver_mcp
`update_tool`	solver_mcp
`retire_tool`	solver_mcp
`search_tools`	solver_mcp
`select_tool`	solver_mcp
`execute_tool`	solver_mcp
`execute_batch`	solver_mcp
`get_invocation`	solver_mcp
`list_invocations`	solver_mcp
`get_execution_stats`	solver_mcp
`cache_result`	solver_mcp
`lookup_cache`	solver_mcp
`set_policy`	solver_mcp
`get_policy`	solver_mcp
`check_policy`	solver_mcp
`list_policies`	solver_mcp
`set_circuit_breaker`	solver_mcp
`check_circuit_breaker`	solver_mcp
`reset_circuit_breaker`	solver_mcp
`get_cost_estimate`	solver_mcp
`get_cost_summary`	solver_mcp
`search`	solver_mcp
`info`	solver_mcp
`ops`	solver_mcp
`help`	solver_mcp
`capabilities`	solver_mcp
`register_strategy`	strategy_mcp
`get_strategy`	strategy_mcp
`list_strategies`	strategy_mcp
`update_strategy`	strategy_mcp
`retire_strategy`	strategy_mcp
`evaluate_context`	strategy_mcp
`select_strategy`	strategy_mcp
`select_fallback`	strategy_mcp
`compare_strategies`	strategy_mcp
`compose_strategies`	strategy_mcp
`get_composition`	strategy_mcp
`decompose_strategy`	strategy_mcp
`should_switch`	strategy_mcp
`record_switch`	strategy_mcp
`get_switch_history`	strategy_mcp
`record_outcome`	strategy_mcp
`get_strategy_stats`	strategy_mcp
`get_effectiveness`	strategy_mcp
`recommend`	strategy_mcp
`explain_selection`	strategy_mcp
`save_session`	strategy_mcp
`load_session`	strategy_mcp
`search`	strategy_mcp
`export_playbook`	strategy_mcp
`info`	strategy_mcp
`ops`	strategy_mcp
`help`	strategy_mcp
`register_agent`	tumix_mcp
`get_agent`	tumix_mcp
`list_agents`	tumix_mcp
`update_agent`	tumix_mcp
`retire_agent`	tumix_mcp
`execute_single`	tumix_mcp
`execute_parallel`	tumix_mcp
`execute_sequential`	tumix_mcp
`get_run`	tumix_mcp
`cancel_run`	tumix_mcp
`vote`	tumix_mcp
`tally_votes`	tumix_mcp
`get_consensus`	tumix_mcp
`score_confidence`	tumix_mcp
`check_termination`	tumix_mcp
`refine_result`	tumix_mcp
`merge_results`	tumix_mcp
`record_outcome`	tumix_mcp
`get_agent_stats`	tumix_mcp
`get_run_stats`	tumix_mcp
`select_agents`	tumix_mcp
`save_session`	tumix_mcp
`load_session`	tumix_mcp
`search`	tumix_mcp
`info`	tumix_mcp
`ops`	tumix_mcp
`help`	tumix_mcp
`verify`	verifier_mcp
`verify_code`	verifier_mcp
`verify_math`	verifier_mcp
`verify_logic`	verifier_mcp
`verify_rag`	verifier_mcp
`execute_sandboxed`	verifier_mcp
`validate_ast`	verifier_mcp
`run_tests`	verifier_mcp
`get_execution_stats`	verifier_mcp
`score_step`	verifier_mcp
`score_code`	verifier_mcp
`score_math`	verifier_mcp
`score_analytics`	verifier_mcp
`evaluate_metrics`	verifier_mcp
`set_threshold`	verifier_mcp
`get_thresholds`	verifier_mcp
`record_verification`	verifier_mcp
`get_verification`	verifier_mcp
`list_verifications`	verifier_mcp
`query_verifications`	verifier_mcp
`verify_batch`	verifier_mcp
`verify_pipeline`	verifier_mcp
`get_pipeline_status`	verifier_mcp
`search`	verifier_mcp
`info`	verifier_mcp
`ops`	verifier_mcp
`help`	verifier_mcp
`capabilities`	verifier_mcp
`register_workflow`	workflows_mcp
`get_workflow`	workflows_mcp
`list_workflows`	workflows_mcp
`update_workflow`	workflows_mcp
`retire_workflow`	workflows_mcp
`create_run`	workflows_mcp
`advance_step`	workflows_mcp
`complete_step`	workflows_mcp
`fail_step`	workflows_mcp
`get_run`	workflows_mcp
`list_runs`	workflows_mcp
`cancel_run`	workflows_mcp
`get_step_history`	workflows_mcp
`seed_templates`	workflows_mcp
`get_template`	workflows_mcp
`list_templates`	workflows_mcp
`instantiate_template`	workflows_mcp
`validate_workflow`	workflows_mcp
`estimate_steps`	workflows_mcp
`record_outcome`	workflows_mcp
`get_workflow_stats`	workflows_mcp
`save_session`	workflows_mcp
`load_session`	workflows_mcp
`search`	workflows_mcp
`info`	workflows_mcp
`ops`	workflows_mcp
`help`	workflows_mcp

Goal Engine¶

Overview¶

Public API¶

GoalDecomposer(AIBlock[GoalInput, SearchTree, None])¶

infer(data: GoalInput) -> Result[SearchTree]¶

list_patterns() -> dict[str, object]¶

bias() -> dict¶

ResourceBoundsSchema(BaseModel)¶

to_resource_bounds() -> ResourceBounds¶

GuardrailSpec(BaseModel)¶

CheckpointSpec(BaseModel)¶

BreakpointSpec(BaseModel)¶

GoalInput(BaseModel)¶

EMLMCPBlock(AIBlock[MCPEMLInput, MCPEMLOutput, dict])¶

infer(data: MCPEMLInput) -> Result[MCPEMLOutput]¶

MCPEMLInput(BaseModel)¶

MCPEMLOutput(BaseModel)¶

EMLStore¶

register_algorithm(name: str, problem_class: str, domain: str = 'general', algorithm_json: str = '{}', code: str | None = None, confidence: float = 0.0, tags: str = '') -> dict¶

get_algorithm(algorithm_id: str) -> dict | None¶

get_algorithm_by_class(problem_class: str) -> dict | None¶

list_algorithms(domain: str | None = None, problem_class: str | None = None, limit: int = 50) -> list[dict]¶

retire_algorithm(algorithm_id: str) -> bool¶

increment_usage(algorithm_id: str, success: bool = True) -> None¶

search_algorithms(query: str, top_k: int = 5, threshold: float = 0.0) -> list[dict]¶

store_model(problem_class: str, algorithm: str, code: str | None = None, confidence: float = 0.0, validation_cases_json: str = '[]', failure_modes_json: str = '[]') -> dict¶

get_model(model_id: str) -> dict | None¶

update_model(model_id: str, **kwargs) -> bool¶

store_rederivation(problem: str, original_solution: str, rederived_solution: str | None = None, match: bool = False, confidence: float = 0.0, pattern_json: str = '{}', attempts: int = 0) -> dict¶

get_rederivation(rederivation_id: str) -> dict | None¶

store_compilation(model_id: str | None, code: str, syntax_valid: bool = False, tests_passed: bool = False, test_results_json: str = '[]', iterations: int = 0) -> dict¶

get_compilation(compilation_id: str) -> dict | None¶

store_safety_report(target_id: str, target_type: str = 'algorithm', tier: int = 0, is_safe: bool = True, findings_json: str = '[]') -> dict¶

get_safety_report(report_id: str) -> dict | None¶

create_cycle(problem: str) -> dict¶

update_cycle(cycle_id: str, **kwargs) -> bool¶

get_cycle(cycle_id: str) -> dict | None¶

record_metric(metric_name: str, metric_value: float, context: str | None = None) -> dict¶

get_savings() -> dict¶

get_library_health() -> dict¶

search(query: str, top_k: int = 10) -> list[dict]¶

GoalEngineMCPBlock(AIBlock[MCPGoalEngineInput, MCPGoalEngineOutput, dict])¶

infer(data: MCPGoalEngineInput) -> Result[MCPGoalEngineOutput]¶

MCPGoalEngineInput(BaseModel)¶

MCPGoalEngineOutput(BaseModel)¶

GoalEngineStore¶

create_goal(goal_text: str, context: str | None = None, constraints_json: str = '[]', resource_bounds_json: str | None = None, status: str = 'pending', parent_id: str | None = None, depth: int = 0, tags: str = '') -> dict¶

get_goal(goal_id: str) -> dict | None¶

list_goals(status: str | None = None, tags: str | None = None, limit: int = 50) -> list[dict]¶

update_goal(goal_id: str, **kwargs) -> bool¶

delete_goal(goal_id: str) -> bool¶

count_goals(status: str | None = None) -> int¶

create_step(goal_id: str, step_index: int, description: str | None = None, status: str = 'pending', result_json: str | None = None, tool_used: str | None = None, duration_ms: int | None = None) -> dict¶

get_steps(goal_id: str) -> list[dict]¶

update_step(step_id: str, **kwargs) -> bool¶

create_session(name: str | None = None, root_goal_id: str | None = None, notes: str | None = None) -> dict¶

get_session(session_id: str) -> dict | None¶

record_history(goal_id: str | None, op: str, input_json: str | None = None, output_json: str | None = None) -> str¶

query_history(goal_id: str | None = None, limit: int = 50) -> list[dict]¶

record_telemetry(session_id: str | None, goal_id: str | None, metric_name: str, metric_value: float) -> str¶

get_telemetry(session_id: str | None = None, goal_id: str | None = None, limit: int = 100) -> list[dict]¶

search_goals(query: str, top_k: int = 10) -> list[dict]¶

MentalModelsMCPBlock(AIBlock[MCPMentalModelsInput, MCPMentalModelsOutput, dict])¶

infer(data: MCPMentalModelsInput) -> Result[MCPMentalModelsOutput]¶

MCPMentalModelsInput(BaseModel)¶

MCPMentalModelsOutput(BaseModel)¶

MentalModelsStore¶

store_model(name: str, framework_type: str | None = None, description: str | None = None, prompts_json: str = '[]', domain: str = 'general', worth: float = 0.5, tags: str = '') -> dict¶

get_model(model_id: str) -> dict | None¶

update_model(model_id: str, **kwargs) -> bool¶

delete_model(model_id: str) -> bool¶

list_models(framework_type: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]¶

record_application(model_id: str, problem: str, analysis: str, insights_json: str = '[]', domain: str | None = None, effectiveness: float = 0.0) -> dict¶

get_applications(model_id: str, limit: int = 50) -> list[dict]¶

save_session(name: str | None = None, models_used_json: str = '[]', notes: str | None = None) -> dict¶

load_session(session_id: str) -> dict | None¶

list_sessions(limit: int = 50) -> list[dict]¶

delete_session(session_id: str) -> bool¶

record_outcome(model_id: str, application_id: str | None = None, success: bool = False, notes: str | None = None, domain: str | None = None) -> dict¶

query_outcomes(model_id: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]¶

`GoalDecomposer(AIBlock[GoalInput, SearchTree, None])`¶

`infer(data: GoalInput) -> Result[SearchTree]`¶

`list_patterns() -> dict[str, object]`¶

`bias() -> dict`¶

`ResourceBoundsSchema(BaseModel)`¶

`to_resource_bounds() -> ResourceBounds`¶

`GuardrailSpec(BaseModel)`¶

`CheckpointSpec(BaseModel)`¶

`BreakpointSpec(BaseModel)`¶

`GoalInput(BaseModel)`¶

`EMLMCPBlock(AIBlock[MCPEMLInput, MCPEMLOutput, dict])`¶

`infer(data: MCPEMLInput) -> Result[MCPEMLOutput]`¶

`MCPEMLInput(BaseModel)`¶

`MCPEMLOutput(BaseModel)`¶

`EMLStore`¶

`register_algorithm(name: str, problem_class: str, domain: str = 'general', algorithm_json: str = '{}', code: str | None = None, confidence: float = 0.0, tags: str = '') -> dict`¶

`get_algorithm(algorithm_id: str) -> dict | None`¶

`get_algorithm_by_class(problem_class: str) -> dict | None`¶

`list_algorithms(domain: str | None = None, problem_class: str | None = None, limit: int = 50) -> list[dict]`¶

`retire_algorithm(algorithm_id: str) -> bool`¶

`increment_usage(algorithm_id: str, success: bool = True) -> None`¶

`search_algorithms(query: str, top_k: int = 5, threshold: float = 0.0) -> list[dict]`¶

`store_model(problem_class: str, algorithm: str, code: str | None = None, confidence: float = 0.0, validation_cases_json: str = '[]', failure_modes_json: str = '[]') -> dict`¶

`get_model(model_id: str) -> dict | None`¶

`update_model(model_id: str, **kwargs) -> bool`¶

`store_rederivation(problem: str, original_solution: str, rederived_solution: str | None = None, match: bool = False, confidence: float = 0.0, pattern_json: str = '{}', attempts: int = 0) -> dict`¶

`get_rederivation(rederivation_id: str) -> dict | None`¶

`store_compilation(model_id: str | None, code: str, syntax_valid: bool = False, tests_passed: bool = False, test_results_json: str = '[]', iterations: int = 0) -> dict`¶

`get_compilation(compilation_id: str) -> dict | None`¶

`store_safety_report(target_id: str, target_type: str = 'algorithm', tier: int = 0, is_safe: bool = True, findings_json: str = '[]') -> dict`¶

`get_safety_report(report_id: str) -> dict | None`¶

`create_cycle(problem: str) -> dict`¶

`update_cycle(cycle_id: str, **kwargs) -> bool`¶

`get_cycle(cycle_id: str) -> dict | None`¶

`record_metric(metric_name: str, metric_value: float, context: str | None = None) -> dict`¶

`get_savings() -> dict`¶

`get_library_health() -> dict`¶

`search(query: str, top_k: int = 10) -> list[dict]`¶

`GoalEngineMCPBlock(AIBlock[MCPGoalEngineInput, MCPGoalEngineOutput, dict])`¶

`infer(data: MCPGoalEngineInput) -> Result[MCPGoalEngineOutput]`¶

`MCPGoalEngineInput(BaseModel)`¶

`MCPGoalEngineOutput(BaseModel)`¶

`GoalEngineStore`¶

`create_goal(goal_text: str, context: str | None = None, constraints_json: str = '[]', resource_bounds_json: str | None = None, status: str = 'pending', parent_id: str | None = None, depth: int = 0, tags: str = '') -> dict`¶

`get_goal(goal_id: str) -> dict | None`¶

`list_goals(status: str | None = None, tags: str | None = None, limit: int = 50) -> list[dict]`¶

`update_goal(goal_id: str, **kwargs) -> bool`¶

`delete_goal(goal_id: str) -> bool`¶

`count_goals(status: str | None = None) -> int`¶

`create_step(goal_id: str, step_index: int, description: str | None = None, status: str = 'pending', result_json: str | None = None, tool_used: str | None = None, duration_ms: int | None = None) -> dict`¶

`get_steps(goal_id: str) -> list[dict]`¶

`update_step(step_id: str, **kwargs) -> bool`¶

`create_session(name: str | None = None, root_goal_id: str | None = None, notes: str | None = None) -> dict`¶

`get_session(session_id: str) -> dict | None`¶

`record_history(goal_id: str | None, op: str, input_json: str | None = None, output_json: str | None = None) -> str`¶

`query_history(goal_id: str | None = None, limit: int = 50) -> list[dict]`¶

`record_telemetry(session_id: str | None, goal_id: str | None, metric_name: str, metric_value: float) -> str`¶

`get_telemetry(session_id: str | None = None, goal_id: str | None = None, limit: int = 100) -> list[dict]`¶

`search_goals(query: str, top_k: int = 10) -> list[dict]`¶

`MentalModelsMCPBlock(AIBlock[MCPMentalModelsInput, MCPMentalModelsOutput, dict])`¶

`infer(data: MCPMentalModelsInput) -> Result[MCPMentalModelsOutput]`¶

`MCPMentalModelsInput(BaseModel)`¶

`MCPMentalModelsOutput(BaseModel)`¶

`MentalModelsStore`¶

`store_model(name: str, framework_type: str | None = None, description: str | None = None, prompts_json: str = '[]', domain: str = 'general', worth: float = 0.5, tags: str = '') -> dict`¶

`get_model(model_id: str) -> dict | None`¶

`update_model(model_id: str, **kwargs) -> bool`¶

`delete_model(model_id: str) -> bool`¶

`list_models(framework_type: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`record_application(model_id: str, problem: str, analysis: str, insights_json: str = '[]', domain: str | None = None, effectiveness: float = 0.0) -> dict`¶

`get_applications(model_id: str, limit: int = 50) -> list[dict]`¶

`save_session(name: str | None = None, models_used_json: str = '[]', notes: str | None = None) -> dict`¶

`load_session(session_id: str) -> dict | None`¶

`list_sessions(limit: int = 50) -> list[dict]`¶

`delete_session(session_id: str) -> bool`¶

`record_outcome(model_id: str, application_id: str | None = None, success: bool = False, notes: str | None = None, domain: str | None = None) -> dict`¶

`query_outcomes(model_id: str | None = None, domain: str | None = None, limit: int = 50) -> list[dict]`¶

`search_models(query: str, top_k: int = 10) -> list[dict]`¶

`MetacognitionMCPBlock(AIBlock[MCPMetacognitionInput, MCPMetacognitionOutput, dict])`¶

`infer(data: MCPMetacognitionInput) -> Result[MCPMetacognitionOutput]`¶