Runtime

Overview

The R-Think runtime is responsible for executing reasoning protocols. It manages the lifecycle of each step, applies validation rules at runtime, and captures artifacts for audit.

The runtime operates in three phases:

1. Preparation - Validates input and initializes state.
2. Execution - Runs protocol steps with rule enforcement.
3. Completion - Aggregates artifacts and returns the result.

Creating a Runtime

Use the Runtime factory to create a configured runtime instance.

import { Runtime } from '@r-think/core';

const runtime = Runtime.create({
  id: 'my-runtime',
  protocol: Protocol.sequential,
  rules: [Rule.required('input')],
  artifacts: [Artifact.trace(), Artifact.metrics()]
});

const result = await runtime.execute({ input: 'data' });

Execution Model

R-Think supports two execution models: sequential and parallel. Sequential execution runs steps one after another. Parallel execution runs independent steps concurrently.

// Sequential execution
const sequential = Protocol.define({
  steps: [stepA, stepB, stepC]
});

// Parallel execution
const parallel = Protocol.define({
  steps: [stepA, stepB, stepC],
  mode: 'parallel'
});

// Conditional execution
const conditional = Protocol.define({
  steps: [
    { condition: (ctx) => ctx.type === 'fast', action: fastPath },
    { condition: (ctx) => ctx.type === 'slow', action: slowPath }
  ]
});

Error Handling

The runtime provides structured error handling. Errors are categorized by type and include the full reasoning trace up to the point of failure.

Next Reading