Job Framework¶

job_framework — Foundation for all 32 G6 economic job agents.

Cluster: Job Agents | Type: component | MCP Tools: 11

Overview¶

Foundation layer for all 32 G6 economic job agents. Provides the shared JobAgentBlock base class, JobInput/JobOutput schemas, sector classification enums, per-sector safety profiles, a SQLite-backed JobStore, token-bucket rate limiting, multi-tenant isolation, a tamper-evident audit trail, inter-agent communication protocols (A2A, AP2, UCP, Claw/NanoClaw/OpenClaw), capability protocols, agent algebra, federation operators, and an async bridge — everything a job agent needs except the domain logic itself.

When to use:

• Building a new domain-specific job agent by subclassing JobAgentBlock
• Composing multiple job agents into a federated team with TeamBlock or the +/@ algebra operators
• Querying the sector registry to discover which agents are available for a given industry or S&P 500 sector
• Enforcing safety profiles, rate limits, and audit trails uniformly across all economic-sector agents

Example:

from mvp.job_framework import JobAgentBlock, JobInput, JobRegistry, get_job_registry

registry: JobRegistry = get_job_registry()
agents = registry.by_sector("secondary")  # all manufacturing-tier agents

block = JobAgentBlock(name="demo_agent")
result = block.infer(JobInput(
    task="Summarise Q1 KPIs and flag any resource overruns",
    context={"period": "2026-Q1"},
))
# result.ok → True; result.value → JobOutput with result, artifacts, steps_taken

Works well with: job_manager, job_analyst, align_csf

Public API¶

CapabilityType¶

Type-theoretic representation of an agent's capability set.

Methods:

satisfies(protocol: type) -> bool¶

Check whether this type includes the given protocol.

product(other: CapabilityType) -> CapabilityType¶

Intersection of two capability types (A × B).

coproduct(other: CapabilityType) -> CapabilityType¶

Union of two capability types (A + B).

arrow(target: CapabilityType) -> CapabilityType¶

Function type A → B: capabilities needed to transform A into B.

difference(other: CapabilityType) -> CapabilityType¶

Protocols in self not present in other.

is_empty() -> bool¶

True when this type carries no protocols.

AgentCategory¶

Category of agents: objects are agent classes, morphisms are

Methods:

objects() -> frozenset[type]¶

Return all registered agent types.

register(agent_cls: type) -> None¶

Register an agent type as a category object.

morphism(source: type, target: type, transform: Callable | None = None) -> Callable | None¶

Get or set the morphism (transformation) between two agent types.

compose(f_key: tuple[type, type], g_key: tuple[type, type]) -> Callable | None¶

Compose morphisms f: A→B and g: B→C into g∘f: A→C.

identity(agent_cls: type) -> Callable¶

Identity morphism for an agent type.

functor(source_cat: AgentCategory, obj_map: dict[type, type], mor_map: dict[tuple[type, type], Callable] | None = None) -> AgentCategory¶

Apply a functor from source_cat into self, mapping objects and morphisms.

natural_transformation(source_functor: dict[type, type], target_functor: dict[type, type], components: dict[type, Callable] | None = None) -> dict[type, Callable]¶

Define a natural transformation between two functors.

validate_composition() -> list[str]¶

Verify associativity of all composable morphism triples.

to_dict() -> dict¶

Serialize the category to a JSON-safe dict.

from_dict(data: dict, class_registry: dict[str, type] | None = None) -> AgentCategory¶

Deserialize from a dict.

AgentAlgebra¶

Algebraic operations on agents with equational law verification.

Methods:

capability_set(agent: Any) -> frozenset[type]¶

Extract the capability set from an agent instance or class.

union(a: Any, b: Any) -> frozenset[type]¶

Algebraic union of two agents' capability sets (A ∪ B).

compose(a: Any, b: Any) -> frozenset[type]¶

Algebraic composition: capabilities of a then b (union — both available).

identity() -> frozenset[type]¶

Identity element for union: empty set.

difference(a: Any, b: Any) -> frozenset[type]¶

Capabilities in a not present in b.

is_subtype(a: Any, b: Any) -> bool¶

True if a's capabilities are a subset of b's.

compatibility_score(a: Any, b: Any) -> float¶

Jaccard similarity between two agents' capability sets.

minimal_extension(a: Any, target_capabilities: frozenset[type]) -> frozenset[type]¶

Capabilities a must add to satisfy target_capabilities.

verify_laws(a: Any, b: Any, c: Any) -> Result[dict]¶

Verify algebraic laws hold for three agents.

EvidenceKind(str, _Enum)¶

TraceStep¶

AuditReport¶

Methods:

to_dict() -> dict¶

AuditTrail¶

Accumulates decision trace steps for a single workflow execution.

Constructor:

Methods:

add_step(step_name: str, output: str, evidence_kind: EvidenceKind, evidence_ref: _Optional_audit[str]) -> TraceStep¶

add_provenance_step(step_name: str, output: str, evidence_kind, source: str, url = None, freshness_seconds = None)¶

Convenience wrapper: create a structured provenance ref and call add_step.

generate_report() -> AuditReport¶

Extensible(Protocol)¶

Agent can extend its own capabilities at runtime.

Methods:

extend(extension: dict[str, Any]) -> Result[dict]¶

learn_from_business(domain: str, rules: list[str]) -> Result[dict]¶

get_extensions() -> Result[list[dict]]¶

HumanLearnable(Protocol)¶

Agent can receive and internalise human instructions.

Methods:

receive_instruction(instruction: str, context: dict[str, Any] | None = None) -> Result[dict]¶

create_skill(name: str, description: str, steps: list[str]) -> Result[dict]¶

list_skills() -> Result[list[dict]]¶

HumanTrainable(Protocol)¶

Agent can be trained via structured curricula.

Methods:

teach(topic: str, material: str) -> Result[dict]¶

generate_curriculum(domain: str, level: str = 'beginner') -> Result[dict]¶

assess_understanding(topic: str) -> Result[dict]¶

Collaborative(Protocol)¶

Agent can propose, negotiate, and co-execute with peers.

Methods:

propose(task: str, to_agents: list[str]) -> Result[dict]¶

negotiate(proposal_id: str, counter: dict[str, Any]) -> Result[dict]¶

co_execute(task: str, partners: list[str]) -> Result[dict]¶

ProblemSolvable(Protocol)¶

Agent can decompose, solve, and verify problems.

Methods:

decompose(problem: str) -> Result[list[str]]¶

solve(problem: str, context: dict[str, Any] | None = None) -> Result[dict]¶

verify_solution(solution: dict[str, Any], spec: str) -> Result[dict]¶

ExternallyAdaptable(Protocol)¶

Agent can connect to and invoke external tools.

Methods:

connect(service: str, config: dict[str, Any]) -> Result[dict]¶

invoke_external(service: str, operation: str, params: dict[str, Any] | None = None) -> Result[dict]¶

list_external_tools() -> Result[list[dict]]¶

AgentCommunicable(Protocol)¶

Agent can discover, message, and transact with other agents.

Methods:

discover_agents(query: str = '') -> Result[list[dict]]¶

send_task(agent_id: str, task: str, payload: dict[str, Any] | None = None) -> Result[dict]¶

receive_task(task_id: str) -> Result[dict]¶

initiate_payment(mandate: dict[str, Any]) -> Result[dict]¶

KnowledgeGrounded(Protocol)¶

Agent can ground reasoning in a knowledge base.

Methods:

ground(claim: str, domain: str = 'general') -> Result[dict]¶

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

update_kb(fact: str, domain: str = 'general') -> Result[dict]¶

Memorable(Protocol)¶

Agent can remember, recall, reflect on, and forget experiences.

Methods:

remember(key: str, value: Any) -> Result[dict]¶

recall(key: str) -> Result[Any]¶

reflect(topic: str = '') -> Result[dict]¶

forget(key: str) -> Result[dict]¶

Actuatable(Protocol)¶

Agent can sense and actuate in physical or simulated environments.

Methods:

sense(sensor: str, params: dict[str, Any] | None = None) -> Result[dict]¶

act(effector: str, command: dict[str, Any]) -> Result[dict]¶

get_effectors() -> Result[list[str]]¶

get_sensors() -> Result[list[str]]¶

ClawIntent¶

A typed OpenClaw/NanoClaw operation selected from natural language.

ConfidenceScorer¶

Derive calibrated confidence from tool-call and schema signals.

Methods:

record_tool_call(success: bool) -> None¶

Record outcome of one tool invocation.

record_schema_validation(passed: bool) -> None¶

Record outcome of one schema validation check.

has_signals() -> bool¶

True when at least one tool call or schema check has been recorded.

tool_success_rate() -> float¶

Observed ratio; None if no calls recorded yet.

schema_validation_rate() -> float¶

Observed ratio; sentinel -1.0 if no checks recorded yet.

score() -> float¶

Return weighted confidence score in [0.0, 1.0].

score_with_basis() -> tuple[float, str]¶

Return (score, explanation) describing what contributed to confidence.

TaskType(str, _Enum_conf)¶

ConfidenceScore¶

ConfidenceEstimator¶

Estimates output confidence from task type, evidence kinds, and tool calls.

Constructor:

Methods:

estimate(task_type: TaskType, evidence_kinds: list, num_tools_called: int) -> ConfidenceScore¶

ResourceBoundsContract(BaseModel)¶

Resource limits that bound a workflow or tool call.

AuditSummaryContract(BaseModel)¶

Compact audit summary embedded in workflow responses.

WorkflowRequest(BaseModel)¶

Request schema for executing a G6 workflow.

WorkflowResponse(BaseModel)¶

Response schema for a completed G6 workflow execution.

ToolCallRequest(BaseModel)¶

Request schema for a single MCP tool invocation.

ToolCallResponse(BaseModel)¶

Response schema for a single MCP tool invocation.

DebateConfig¶

Configuration for domain-specific debate.

PrimarySector(str, Enum)¶

Five-sector model of the economy.

IndustryCategory(str, Enum)¶

NAICS-inspired 19-category industry classification.

SP500Sector(str, Enum)¶

S&P 500 GICS 11-sector classification.

InstitutionalActor(str, Enum)¶

Five institutional sectors in national accounts.

JobEvalCase¶

A single labeled evaluation case.

EvalResult¶

Scored result for one eval case or a summary over many.

Methods:

overall() -> float¶

JobEvalSuite¶

Run labeled cases through a job block and score the outputs.

Constructor:

Methods:

load_cases(path: str) -> None¶

Append cases from a JSONL file; raises GoldCaseSchemaError on drift.

run(block: 'JobAgentBlock') -> list[EvalResult]¶

Run all cases and return per-case results.

summary(results: list[EvalResult]) -> EvalResult¶

Average results across all cases.

ErrorPolicy(str, Enum)¶

How federated/composed agents handle member failures.

MergeStrategy(str, Enum)¶

How federated agent merges results from members.

FederatedAgent(_get_job_agent_block())¶

Union of two job agents via the + operator.

Methods:

health_check() -> dict¶

Check health of all member agents.

ComposedAgent(_get_job_agent_block())¶

Sequential composition of two job agents via the @ operator.

Methods:

health_check() -> dict¶

Check health of all member agents.

JobAgentBlock(AIBlock[JobInput, JobOutput, dict])¶

Base class for all 32 G6 job agents.

Methods:

ask(task: str, **kwargs: Any) -> Result¶

Simplified API: just describe what you need.

infer(data: Any) -> Result[JobOutput]¶

Orchestrate a job task with safety checks and component access.

get_audit_log() -> list[AuditEntry]¶

Return the current audit trail.

verify_standards(output: JobOutput | None = None, jurisdiction: str = '', failure_mode: str = '') -> Result[dict]¶

Verify this agent's output against professional standards.

extend(extension: dict[str, Any]) -> Result[dict]¶

learn_from_business(domain: str, rules: list[str]) -> Result[dict]¶

get_extensions() -> Result[list[dict]]¶

receive_instruction(instruction: str, context: dict[str, Any] | None = None) -> Result[dict]¶

create_skill(name: str, description: str, steps: list[str]) -> Result[dict]¶

list_skills() -> Result[list[dict]]¶

teach(topic: str, material: str) -> Result[dict]¶

generate_curriculum(domain: str, level: str = 'beginner') -> Result[dict]¶

assess_understanding(topic: str) -> Result[dict]¶

propose(task: str, to_agents: list[str]) -> Result[dict]¶

negotiate(proposal_id: str, counter: dict[str, Any]) -> Result[dict]¶

co_execute(task: str, partners: list[str]) -> Result[dict]¶

decompose(problem: str) -> Result[list[str]]¶

solve(problem: str, context: dict[str, Any] | None = None) -> Result[dict]¶

verify_solution(solution: dict[str, Any], spec: str) -> Result[dict]¶

connect(service: str, config: dict[str, Any]) -> Result[dict]¶

invoke_external(service: str, operation: str, params: dict[str, Any] | None = None) -> Result[dict]¶

list_external_tools() -> Result[list[dict]]¶

discover_agents(query: str = '') -> Result[list[dict]]¶

send_task(agent_id: str, task: str, payload: dict[str, Any] | None = None) -> Result[dict]¶

receive_task(task_id: str) -> Result[dict]¶

initiate_payment(mandate: dict[str, Any]) -> Result[dict]¶

ground(claim: str, domain: str = 'general') -> Result[dict]¶

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

update_kb(fact: str, domain: str = 'general') -> Result[dict]¶

remember(key: str, value: Any) -> Result[dict]¶

recall(key: str) -> Result[Any]¶

reflect(topic: str = '') -> Result[dict]¶

forget(key: str) -> Result[dict]¶

sense(sensor: str, params: dict[str, Any] | None = None) -> Result[dict]¶

act(effector: str, command: dict[str, Any]) -> Result[dict]¶

get_effectors() -> Result[list[str]]¶

get_sensors() -> Result[list[str]]¶

JobRegistry¶

Sector-aware index of job agent components.

Methods:

list_jobs() -> list[dict[str, Any]]¶

get_job(name: str) -> dict[str, Any] | None¶

by_sector(sector: str) -> list[dict[str, Any]]¶

by_industry(industry: str) -> list[dict[str, Any]]¶

by_sp500(sp500: str) -> list[dict[str, Any]]¶

count() -> int¶

Return number of registered jobs (derived dynamically from _JOB_SECTORS).

TokenBucket¶

Thread-safe token bucket rate limiter.

Methods:

try_acquire(tokens: float = 1.0) -> bool¶

Try to consume tokens. Returns True if allowed, False if rate-limited.

acquire(tokens: float = 1.0, timeout: float = 5.0) -> bool¶

Block until tokens are available or timeout. Returns True if acquired.

available() -> float¶

Current available tokens.

RateLimiterRegistry¶

Registry of named rate limiters.

Methods:

get(name: str) -> TokenBucket¶

Get or create a rate limiter by name.

configure(name: str, rate: float, capacity: float) -> None¶

Configure or reconfigure a rate limiter.

try_acquire(name: str, tokens: float = 1.0) -> bool¶

Convenience: try to acquire tokens from a named limiter.

stats() -> dict[str, dict[str, float]]¶

Return available tokens for all registered limiters.

reset() -> None¶

Reset all limiters (useful for testing).

StepStatus(str, Enum)¶

Step¶

A single step in a recipe pipeline.

StepResult¶

Outcome of executing a single step.

Recipe¶

A named multi-step workflow pipeline.

RecipeCheckpoint¶

Serialisable checkpoint for resume after interruption.

Methods:

save(checkpoint_dir: Path) -> Path¶

load(path: Path) -> RecipeCheckpoint¶

RecipeResult¶

Final outcome of a recipe execution.

Methods:

to_dict() -> dict[str, Any]¶

SafetyPolicy(str, Enum)¶

ActionRiskLevel(str, Enum)¶

Methods:

for_action(action: str) -> 'ActionRiskLevel'¶

SafetyDecision¶

SafetyGate¶

Evaluates whether a workflow action is safe to execute.

Constructor:

Methods:

evaluate(action: str, context: dict) -> SafetyDecision¶

approve(decision: SafetyDecision, approver: str) -> SafetyDecision¶

Record human approval and return an allowed decision.

SafetyDecision(Enum)¶

Outcome of a high-stakes safety check.

HighStakeSafetyPolicy(ABC)¶

Abstract base for domain-specific safety enforcement.

Methods:

check(input_data: 'JobInput') -> tuple[SafetyDecision, str]¶

Return (decision, message).

DefaultHighStakeSafetyPolicy(HighStakeSafetyPolicy)¶

Default policy: require professional context for domain-specific output.

Constructor:

Methods:

check(input_data: 'JobInput') -> tuple[SafetyDecision, str]¶

disclaimer() -> str¶

Return the regulated-domain disclaimer for this policy's domain.

SafetyProfile¶

Safety constraints for a given economic sector.

SectorClassification(BaseModel)¶

All four sector classifications for a job.

ToolkitSpec(BaseModel)¶

Routing hints — primary components tried first, but access is unrestricted.

SafetyGateProfile(BaseModel)¶

Gate decision metadata attached to provenance for downstream audit.

ProvenanceRecord(BaseModel)¶

Source attribution and freshness metadata for any job output.

TypedToolRequest(BaseModel)¶

Base class for strongly-typed per-tool MCP request models.

TypedToolResponse(BaseModel)¶

Base class for strongly-typed per-tool MCP response models.

JobContext(_DictCompatMixin, BaseModel)¶

Typed context for job execution (06-P2).

Methods:

from_dict(d: dict[str, Any]) -> JobContext¶

JobConstraints(_DictCompatMixin, BaseModel)¶

Typed constraints for job execution (06-P2).

Methods:

from_dict(d: dict[str, Any]) -> JobConstraints¶

JobResourceBounds(_DictCompatMixin, BaseModel)¶

Typed resource bounds for job execution (06-P2).

Methods:

from_dict(d: dict[str, Any]) -> JobResourceBounds¶

JobParameters(_DictCompatMixin, BaseModel)¶

Typed parameters for job execution (06-P2).

Methods:

from_dict(d: dict[str, Any]) -> JobParameters¶

JobInput(BaseModel)¶

Input to any job agent block.

JobOutput(BaseModel)¶

Output from any job agent block.

MCPJobInput(BaseModel)¶

Base MCP input for job agent sub-packages.

MCPJobOutput(BaseModel)¶

Base MCP output for job agent sub-packages.

TeamInput(BaseModel)¶

Input to TeamBlock — dispatches to multiple job agents.

TeamOutput(BaseModel)¶

Merged output from TeamBlock.

SecretStore¶

Unified secret store with fallback chain.

Constructor:

Methods:

get(key: str) -> str | None¶

Get a secret, trying each provider in order.

set(key: str, value: str, provider_index: int = 0) -> None¶

Store a secret in the specified provider (default: first/primary).

delete(key: str) -> bool¶

Delete from all providers.

require(key: str, description: str = '') -> str¶

Get a secret or raise RuntimeError if not found.

get_or_default(key: str, default: str = '') -> str¶

Get a secret with a fallback default.

access_log() -> list[dict[str, str]]¶

JobStore¶

SQLite-backed base store for job MCP sub-packages.

Constructor:

Methods:

create_task(title: str, description: str = '', context: dict | None = None, priority: int = 0) -> str¶

get_task(task_id: str) -> dict | None¶

update_task(task_id: str, **fields: Any) -> bool¶

list_tasks(status: str = '') -> list[dict]¶

store_result(op: str, result: dict, task_id: str = '', confidence: float = 0.5) -> str¶

get_results(task_id: str = '', op: str = '', limit: int = 50) -> list[dict]¶

log_history(op: str, inp: dict, out: dict, status: str = 'ok', error: str = '', duration_ms: float = 0.0) -> str¶

get_history(op: str = '', limit: int = 50) -> list[dict]¶

log_error(op: str, error: str, context: dict | None = None) -> str¶

store_artifact(name: str, content: dict, kind: str = 'generic', tags: str = '', notes: str = '') -> str¶

retrieve_artifact(artifact_id: str) -> dict | None¶

list_artifacts(kind: str = '', limit: int = 50) -> list[dict]¶

search_artifacts(query: str, limit: int = 20) -> list[dict]¶

archive_artifact(artifact_id: str) -> bool¶

get_cached_llm(cache_key: str) -> str | None¶

Return cached LLM response if not expired, else None.

set_cached_llm(cache_key: str, context_hash: str, question_hash: str, response: str, model: str = 'auto', ttl_hours: int = 168) -> None¶

INSERT OR REPLACE a cached LLM response with TTL.

purge_expired_cache() -> int¶

Delete expired cache entries; return count deleted.

count_all() -> dict[str, int]¶

close() -> None¶

Return connection to pool (file-backed) or close it (:memory:).

JobSubagentProtocol(AgentProtocol)¶

AgentProtocol specialised for JobAgentBlock instances.

Constructor:

TeamBlock(AIBlock[TeamInput, TeamOutput, dict])¶

Dispatches a task across multiple job agent members.

Methods:

infer(data: TeamInput) -> Result[TeamOutput]¶

TenantContext¶

Reentrant context manager that sets the current tenant_id.

Constructor:

Methods:

tenant_id() -> str¶

TenantIsolation¶

Manages per-tenant instances of shared framework singletons.

Methods:

get_store(tenant_id: str) -> JobStore¶

Return a tenant-scoped JobStore (separate SQLite DB per tenant).

get_rate_limiter(tenant_id: str) -> RateLimiterRegistry¶

Return a per-tenant RateLimiterRegistry.

get_secret_store(tenant_id: str) -> SecretStore¶

Return a per-tenant SecretStore.

get_cache(tenant_id: str) -> dict[str, str]¶

Return a per-tenant L1 in-memory cache dict.

cleanup(tenant_id: str) -> None¶

Remove all resources for a tenant, closing stores gracefully.

list_tenants() -> list[str]¶

List all active tenant ids (those with at least one resource).

close_all() -> None¶

Shut down all tenant resources. Intended for application teardown.

Functions¶

run_sync(fn: Callable[..., T], *args: Any, **kwargs: Any) -> T¶

Run a synchronous function in the thread pool.

async_infer(agent: Any, data: Any) -> Any¶

Async wrapper for JobAgentBlock.infer().

async_llm_enrich(context: str, question: str, model: str = 'auto', timeout: float = 15.0, ttl_hours: int = 168) -> str | None¶

Async wrapper for llm_enrich().

gather_agent_tasks(agents_and_inputs: list[tuple[Any, Any]], max_concurrent: int = 10) -> list[Any]¶

Run multiple agent inferences concurrently with a semaphore.

make_async(fn: Callable[..., T]) -> Callable[..., Any]¶

Decorator that wraps a sync function to be async via run_in_executor.

record_audit_entry(store, handler_name: str, operation: str, entity_id: str = '', before: Any = None, after: Any = None) -> str¶

verify_audit_chain(store) -> list[dict]¶

compute_merkle_root(store) -> str¶

Compute a Merkle tree root hash from all audit entries.

detect_tampering(store) -> dict¶

Run comprehensive tampering detection.

route_claw_intent(prompt: str) -> ClawIntent | None¶

Map common OpenClaw/NanoClaw phrases into typed tool operations.

calibrate_from_audit_report(report) -> ConfidenceScore¶

Derive a confidence score from a completed AuditReport.

get_debate_config(agent_name: str) -> DebateConfig¶

Return the debate configuration for a job agent.

should_debate(agent_name: str, operation: str) -> bool¶

Return True if operation should trigger debate for agent_name.

get_grounding_domain(agent_name: str) -> GroundingDomain¶

Return the primary grounding domain for a job agent.

get_all_domains(agent_name: str) -> list[GroundingDomain]¶

Return primary + extra grounding domains for a job agent.

get_seed_queries(agent_name: str) -> list[str]¶

Return seed grounding queries for a job agent, or empty list.

dispatch_shared(op: str, store: JobStore, job_name: str = '', primary_components: list[str] | None = None, ops: list[str] | None = None, **kwargs: Any) -> dict¶

Dispatch a shared op to its handler.

requires_hitl(agent_name: str, operation: str) -> bool¶

Return True if the operation MUST have human approval. FAIL CLOSED.

recommends_hitl(agent_name: str, operation: str) -> bool¶

Return True if the operation SHOULD have human review.

get_hitl_timeout(agent_name: str, operation: str) -> float¶

Return the HITL timeout in seconds for the given operation.

get_all_hitl_ops(agent_name: str) -> dict[str, str]¶

Return all HITL operations for an agent with their level (required/recommended).

maybe_warn_perplexity(domain: str, search_used: bool = True) -> str | None¶

Return a warning string if Perplexity would improve quality for domain.

get_grounding() -> GroundingBlock | None¶

Return a cached GroundingBlock, or None if unavailable.

get_search() -> CtxSearchBlock | None¶

Return a cached CtxSearchBlock (DuckDuckGo default).

get_scraper() -> CtxScraplingBlock | None¶

Return a cached CtxScraplingBlock.

get_rag() -> CtxRAGBlock | None¶

Return a cached CtxRAGBlock.

get_debate(use_mock_llm: bool = False) -> DebateLoop | None¶

Return a new DebateLoop instance.

make_debate_agents(roles: list[str] | None = None) -> list[Any]¶

Build a list of DebateAgent instances from role name strings.

get_experta() -> AdaptExpertaBlock | None¶

Return a cached AdaptExpertaBlock (stateful, forward-chaining).

get_experta_mcp(db_path: str = ':memory:', domain: str = '') -> AdaptExpertaMCPBlock | None¶

Return a cached AdaptExpertaMCPBlock with full T2 learning.

get_sklearn() -> AdaptSklearnBlock | None¶

get_automl() -> AdaptAutoMLBlock | None¶

get_bayesian() -> AdaptBayesianBlock | None¶

get_keras() -> AdaptKerasBlock | None¶

get_pytorch() -> AdaptPyTorchBlock | None¶

get_eurisko() -> AdaptEuriskoBlock | None¶

get_optimisation() -> AdaptOptimisationBlock | None¶

get_pandas() -> AdaptPandasBlock | None¶

get_memory() -> AdaptMemoryBlock | None¶

get_hitl(workspace_root: str | Path | None = None) -> HITLManager | None¶

Return a HITLManager for the given workspace root.

get_job_registry() -> JobRegistry¶

is_otel_available() -> bool¶

Return whether opentelemetry is importable.

get_rate_limiter() -> RateLimiterRegistry¶

Return the global rate limiter registry.

check_rate_limit(resource: str, tokens: float = 1.0) -> bool¶

Check if a request is within rate limits. Returns True if allowed.

run_recipe(recipe: Recipe, initial_input: dict[str, Any], store: Any = None, checkpoint_dir: Path | None = None, resume_from: RecipeCheckpoint | None = None, on_step_complete: Callable[[StepResult], None] | None = None) -> RecipeResult¶

Execute a recipe, optionally resuming from a checkpoint.

get_domain_recipe(domain: str) -> Recipe | None¶

Return the launch-oriented starter recipe for a domain.

list_domain_recipes() -> list[str]¶

Return available launch-oriented starter recipe domains.

get_sector_safety() -> dict[PrimarySector, SafetyProfile]¶

Get sector safety profiles (cached, built from config on first call).

reset_sector_safety() -> None¶

Clear the cached profiles (useful for testing / hot-reload).

get_secret_store() -> SecretStore¶

Get the global secret store singleton.

get_secret(key: str) -> str | None¶

Convenience: get a secret from the global store.

require_secret(key: str, description: str = '') -> str¶

Convenience: require a secret from the global store.

get_connection_pool() -> _ConnectionPool¶

Return the module-level connection pool singleton.

get_current_tenant() -> str¶

Return the current tenant_id or 'default' if none is set.

get_tenant_isolation() -> TenantIsolation¶

Return the module-level TenantIsolation singleton.

MCP Tools¶