@rsconcept/rstool 0.1.0

package/skills/rstool-helper/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: rstool-helper
+description: RS language and @rsconcept/rstool for AI agents: incremental RSForm construction, formal definitions, typification, diagnostics, modeling, evaluation.
+---
+
+# RS Language & rstool — Compact Guide for Agents
+
+**RS language** is a formal scheme notation for concepts, relations, operations—extends FOL, core: membership `x∈y`; typification via set-theoretic/logical expressions.
+
+**rstool** is the agent API for sessions, upserts, analysis, diagnostics, modeling/evaluation, (de)serialization.
+
+- Library: `@rsconcept/rstool` (npm)
+- Analyzer: `@rsconcept/domain` (installed automatically as a dependency)
+- Language and API reference: bundled `docs/*.md` copied into this skill during installation
+
+## Installing This Skill
+
+After installing the package in an agent project:
+
+```bash
+npm install @rsconcept/rstool
+```
+
+copy the skill into your agent host's skill directory.
+
+Cursor per-project skills:
+
+```bash
+mkdir -p .agents/skills
+cp -R node_modules/@rsconcept/rstool/skills/rstool-helper .agents/skills/rstool-helper
+cp -R node_modules/@rsconcept/rstool/docs .agents/skills/rstool-helper/docs
+```
+
+PowerShell:
+
+```powershell
+New-Item -ItemType Directory -Force .agents/skills
+Copy-Item -Recurse -Force node_modules/@rsconcept/rstool/skills/rstool-helper .agents/skills/rstool-helper
+Copy-Item -Recurse -Force node_modules/@rsconcept/rstool/docs .agents/skills/rstool-helper/docs
+```
+
+This makes the skill self-contained for hosts that only read files under the skill directory.
+
+## Docs/Hints Reference
+
+| Info                                      | Location                                                          |
+| :---------------------------------------- | :---------------------------------------------------------------- |
+| rstool API, methods, error codes          | [REFERENCE.md](REFERENCE.md)                                      |
+| Worked examples, common mistakes          | [EXAMPLES.md](EXAMPLES.md)                                        |
+| Domain vocabulary (English)               | `docs/DOMAIN.md` (bundled with the npm package)                   |
+| Constituenta fields, validation, ordering | `docs/CONSTITUENTA.md`                                            |
+| RSLang syntax (operators, quantifiers)    | `docs/SYNTAX.md`                                                  |
+| Typification grades, radicals             | `docs/TYPIFICATION.md`                                            |
+| Diagnostic code → fix table               | `docs/DIAGNOSTICS.md`                                             |
+| Portal REST API (live data)               | `docs/PORTAL-API.md`                                              |
+| Lezer grammar pointers                    | `docs/GRAMMAR-REF.md` (full grammar lives in `@rsconcept/domain`) |
+| Code samples                              | [EXAMPLES.md](EXAMPLES.md), package README                        |
+
+If you installed `@rsconcept/rstool` from npm, the source docs ship inside `node_modules/@rsconcept/rstool/docs/`; the install commands above copy them into this skill folder.
+
+## Protocol Summary
+
+1. **Start session**: `createSession`
+2. **Add bases/constants**: type `basic` (`X*`), `constant` (`C*`) — `definitionFormal: ''`
+3. **Add derived**: terms, axioms, etc.—only after dependencies present
+4. **Analyze scratch**: `analyzeExpression`
+5. **Process diagnostics**: check `analysis.diagnostics`/`listDiagnostics`; fix by range
+6. **Checkpoint**: `commitStep` (message optional)
+7. **Model values**: `setConstituentaValue` / `setConstituentaValues` for base bindings (`{0:"a",1:"b"}`) or structured values; `getModelState`
+8. **Evaluate**: `evaluateExpression` (scratch) or `evaluateConstituenta` / `recalculateModel` (stored definitions)
+9. **Export/import**: persist with `exportSession`/`importSession` (includes `state.model`)
+
+**Clients**:
+
+- Node: use `RSToolWrapperClient`
+- Stdio process: `npx rstool-wrapper` — JSON per line
+
+## API/REST
+
+For full reference see `docs/PORTAL-API.md`. Short form:
+
+- **Portal UI**: `https://portal.acconcept.ru`
+- **API**: `https://api.portal.acconcept.ru`
+- Endpoints: `GET /api/rsforms/{id}`, `GET /api/rsforms/{id}/details`, `GET /api/library/{id}/versions/{v}`, `GET /api/oss/{id}`, `GET /api/models/{id}`, OpenAPI at `GET /schema`.
+- Don't scrape SPA or use UI query params (`tab=`, etc.).
+- rstool itself never calls the REST API; bring data in via `addOrUpdateConstituenta` after fetching.
+
+## Constituent Types (`cstType`)
+
+| cstType   | Example | Formal    | Notes                |
+| :-------- | :------ | :-------- | :------------------- |
+| basic     | X1      | **empty** | Required             |
+| constant  | C1      | **empty** | Required             |
+| nominal   | S1      | allowed   | Naming               |
+| structure | custom  | allowed   | Structured genus     |
+| term      | D1      | allowed   | Set/term             |
+| axiom     | A1      | allowed   | Logical (type=Logic) |
+| statement | T1      | allowed   | Logical (type=Logic) |
+| function  | F1      | allowed   | Parameterized        |
+| predicate | P1      | allowed   | Parameterized        |
+
+- Non-empty formal for `basic`/`constant` ⇒ error `0x8862` (`definitionNotAllowed`)
+- Empty `basic`/`constant` always typified
+- **Interpretable** (can set value): `basic`, `constant`, `structure`, `axiom`, `term`, `statement`
+- **Inferrable** (computed, do not set directly): `term`, `axiom`, `statement`
+
+## Syntax
+
+- **Globals**: `X1`, `C1`, `D1`, `F1`, `P1`, `A1`, `R1`
+- **Locals**: `x`, `ξ`, `μ2`
+- **Literals**: `42`, `Z`, `∅`
+- Full operator + precedence table: `docs/SYNTAX.md`
+- Grammar pointers: `docs/GRAMMAR-REF.md`
+
+## Expression Types
+
+- **Set-theoretic**: `∪`, `∩`, `\`, `∆`, `×`, `∈`, `⊆`, `ℬ(...)`, tuples
+- **Logical**: `¬`, `&`, `∨`, `⇒`, `⇔`, `∀`, `∃`, comparisons `=`, `≠`, `<`
+- **Parameterized**: `[arg1∈H1, arg2∈H2] body`
+- Detailed semantics in `docs/SYNTAX.md`; typification grades and radicals in `docs/TYPIFICATION.md`.
+
+Always set `cstType` in upserts/analysis to true role.
+
+## Diagnostics Loop
+
+1. Check `analysis.success`
+2. If not, see `analysis.diagnostics` / `listDiagnostics`
+3. Map `code` → cause → fix via `docs/DIAGNOSTICS.md`
+4. Use `from`, `to` to patch `definitionFormal`; re-send
+
+Don’t infer types—always read tool output.
+
+## Declaration Order
+
+1. All `basic`, `constant`
+2. Core/critical first
+3. Topological: dependencies before dependents (e.g. `D1` before `D2` if `D2` refers to `D1`)
+4. Derived right after their sources
+
+## Checklist
+
+- [ ] `sessionId` obtained & tracked
+- [ ] Bases/constants are empty formal
+- [ ] All dependencies exist before upsert
+- [ ] Matching `cstType`
+- [ ] Diagnostics handled before commit/export
+- [ ] Base bindings set before evaluating expressions that reference base elements
+- [ ] For other details, check help topics or [REFERENCE.md](REFERENCE.md)

package/src/index.ts

@@ -0,0 +1,43 @@
+export {
+  toPublicAnalysis,
+  toPublicError,
+  type DomainAnalysisLike,
+  type DomainErrorLike
+} from './mappers/types';
+export {
+  CONTRACT_VERSION,
+  CstType,
+  EvalStatus,
+  RSErrorCode,
+  RSToolAgent,
+  ValueClass,
+  type AddOrUpdateConstituentaInput,
+  type AddOrUpdateConstituentaResult,
+  type AnalysisResult,
+  type AnalyzeExpressionInput,
+  type BasicBinding,
+  type ClearConstituentaValuesInput,
+  type ConstituentaDraft,
+  type ConstituentaState,
+  type DiagnosticRecord,
+  type EvaluateConstituentaInput,
+  type EvaluateExpressionInput,
+  type EvaluationResult,
+  type ListDiagnosticsFilters,
+  type ModelValueState,
+  type RecalculateModelResult,
+  type RSToolAgentContract,
+  type RSToolErrorDescription,
+  type RSToolValue,
+  type SessionHandle,
+  type SessionModelState,
+  type SessionRevision,
+  type SessionState,
+  type SetConstituentaValueInput,
+  type SetConstituentaValuesInput
+} from './models';
+export {
+  RSToolWrapperClient,
+  type RSToolWrapperClientOptions,
+  type WrapperResponse
+} from './wrapper/client';

package/src/mappers/model-adapter.ts

@@ -0,0 +1,276 @@
+import { Graph } from '@rsconcept/domain/graph/graph';
+import { extractGlobals } from '@rsconcept/domain/rslang/api';
+import { type ExpressionType, RSLangAnalyzer, type Value, type ValueClass } from '@rsconcept/domain/rslang';
+import { isBaseSet } from '@rsconcept/domain/library/rsform-api';
+import { type Constituenta, CstType, type RSForm } from '@rsconcept/domain/library/rsform';
+import { RSEngine, type RSEngineServices } from '@rsconcept/domain/library/rsengine';
+import { type BasicBinding, EvalStatus, type RSModel } from '@rsconcept/domain/library/rsmodel';
+import {
+  isInferrable,
+  isInterpretable,
+  toBasicBinding,
+  validateBasicBindingData,
+  validateValueData
+} from '@rsconcept/domain/library/rsmodel-api';
+
+import {
+  type ConstituentaState,
+  type EvaluationResult,
+  type RecalculateModelResult,
+  type SessionModelState,
+  type SessionState,
+  type SetConstituentaValueInput
+} from '../models';
+import { toPublicError } from './types';
+
+const SESSION_MODEL_ID = 0;
+
+export class ModelAdapter {
+  public async setConstituentaValue(
+    session: SessionState,
+    input: SetConstituentaValueInput
+  ): Promise<SessionModelState> {
+    this.validateSetInput(session, input);
+    const engine = this.createEngine(session);
+    const cst = session.items.find(item => item.id === input.target)!;
+    const frontendType = cst.cstType;
+
+    if (isBaseSet(frontendType)) {
+      const binding = toBasicBinding(input.value as Record<string | number, string>);
+      await engine.setBasicValue(input.target, binding);
+    } else {
+      await engine.setStructureValue(input.target, input.value as Value);
+    }
+    session.updatedAt = new Date().toISOString();
+    return structuredClone(session.model);
+  }
+
+  public async setConstituentaValues(
+    session: SessionState,
+    input: { items: SetConstituentaValueInput[] }
+  ): Promise<SessionModelState> {
+    for (const item of input.items) {
+      await this.setConstituentaValue(session, item);
+    }
+    return structuredClone(session.model);
+  }
+
+  public async clearConstituentaValues(session: SessionState, ids: number[]): Promise<SessionModelState> {
+    const engine = this.createEngine(session);
+    for (const id of ids) {
+      await engine.resetValue(id);
+      session.updatedAt = new Date().toISOString();
+    }
+    return structuredClone(session.model);
+  }
+
+  public evaluateExpression(session: SessionState, expression: string, cstType: CstType): EvaluationResult {
+    const engine = this.createEngine(session);
+    const result = engine.evaluateExpression(expression, cstType);
+    const status =
+      result.value === null
+        ? result.errors.length > 0
+          ? EvalStatus.EVAL_FAIL
+          : EvalStatus.EMPTY
+        : EvalStatus.HAS_DATA;
+    return toPublicEvaluationResult(result.value, result.errors, result.iterations, result.cacheHits, status);
+  }
+
+  public evaluateConstituenta(session: SessionState, constituentId: number): EvaluationResult {
+    const cst = session.items.find(item => item.id === constituentId);
+    if (!cst) {
+      throw new Error(`Unknown constituent: ${constituentId}`);
+    }
+    const engine = this.createEngine(session);
+    const result = engine.calculateCst(constituentId);
+    const status = engine.getCstStatus(constituentId);
+    return toPublicEvaluationResult(result.value, result.errors, result.iterations, result.cacheHits, status);
+  }
+
+  public recalculateModel(session: SessionState): RecalculateModelResult {
+    const engine = this.createEngine(session);
+    engine.recalculateAll();
+    const items = session.items.map(item => ({
+      id: item.id,
+      alias: item.alias,
+      value: engine.getCstValue(item.id) as number | number[] | null,
+      status: engine.getCstStatus(item.id)
+    }));
+    return { items };
+  }
+
+  public createEngine(session: SessionState): RSEngine {
+    const schema = buildRSFormFromSession(session);
+    const model = buildRSModelFromSession(session);
+    const engine = new RSEngine(SESSION_MODEL_ID, createInMemoryServices(session));
+    engine.loadData(schema, model);
+    return engine;
+  }
+
+  private validateSetInput(session: SessionState, input: SetConstituentaValueInput): void {
+    const cst = session.items.find(item => item.id === input.target);
+    if (!cst) {
+      throw new Error(`Unknown constituent: ${input.target}`);
+    }
+    const frontendType = cst.cstType;
+    if (!isInterpretable(frontendType)) {
+      throw new Error(`Constituent ${cst.alias} is not interpretable`);
+    }
+    if (isInferrable(frontendType)) {
+      throw new Error(`Constituent ${cst.alias} is inferrable and cannot be set directly`);
+    }
+    if (isBaseSet(frontendType)) {
+      if (!validateBasicBindingData(input.value)) {
+        throw new Error(`Invalid basic binding for ${cst.alias}`);
+      }
+      return;
+    }
+    if (!validateValueData(input.value)) {
+      throw new Error(`Invalid structured value for ${cst.alias}`);
+    }
+  }
+}
+
+function createInMemoryServices(session: SessionState): RSEngineServices {
+  return {
+    setCstValue: async ({ data }) => {
+      for (const item of data) {
+        const entry = {
+          id: item.target,
+          type: item.type,
+          value: item.data as Value | BasicBinding
+        };
+        const index = session.model.items.findIndex(existing => existing.id === item.target);
+        if (index === -1) {
+          session.model.items.push(entry);
+        } else {
+          session.model.items[index] = entry;
+        }
+      }
+    },
+    clearValues: async ({ data }) => {
+      const ids = new Set(data.items);
+      session.model.items = session.model.items.filter(item => !ids.has(item.id));
+    }
+  };
+}
+
+function buildRSFormFromSession(session: SessionState): RSForm {
+  const graph = new Graph<number>();
+  const cstByAlias = new Map<string, Constituenta>();
+  const cstByID = new Map<number, Constituenta>();
+  const analyzer = new RSLangAnalyzer();
+
+  const items = session.items.map(item => {
+    const cst = toFrontendConstituenta(item);
+    cstByAlias.set(cst.alias, cst);
+    cstByID.set(cst.id, cst);
+    graph.addNode(cst.id);
+    if (item.cstType === CstType.BASE) {
+      analyzer.addBase(cst.alias);
+    }
+    if (cst.effectiveType) {
+      analyzer.setGlobal(cst.alias, cst.effectiveType, cst.analysis.valueClass as ValueClass | null);
+    }
+    return cst;
+  });
+
+  for (const cst of items) {
+    for (const alias of extractGlobals(cst.definition_formal)) {
+      const source = cstByAlias.get(alias);
+      if (source) {
+        graph.addEdge(source.id, cst.id);
+      }
+    }
+  }
+
+  return {
+    id: 0,
+    items,
+    cstByAlias,
+    cstByID,
+    graph,
+    analyzer,
+    inheritance: [],
+    attribution: [],
+    attribution_graph: graph.clone(),
+    oss: [],
+    models: [],
+    editors: [],
+    versions: [],
+    is_produced: false,
+    is_attributive: false,
+    version: 'latest'
+  } as unknown as RSForm;
+}
+
+function buildRSModelFromSession(session: SessionState): RSModel {
+  return {
+    id: SESSION_MODEL_ID,
+    schema: 0,
+    editors: [],
+    items: session.model.items.map(item => ({
+      id: item.id,
+      type: item.type,
+      value: item.value as Value | BasicBinding
+    }))
+  } as unknown as RSModel;
+}
+
+function toFrontendConstituenta(item: ConstituentaState): Constituenta {
+  const effectiveType = (item.analysis.type ?? null) as ExpressionType | null;
+  return {
+    id: item.id,
+    alias: item.alias,
+    cst_type: item.cstType,
+    definition_formal: item.definitionFormal,
+    definition_raw: item.definitionFormal,
+    definition_resolved: item.definitionFormal,
+    term_raw: item.term,
+    term_resolved: item.term,
+    term_forms: [],
+    convention: item.convention,
+    typification_manual: '',
+    value_is_property: false,
+    crucial: false,
+    attributes: [],
+    homonyms: [],
+    formalDuplicates: [],
+    analysis: {
+      success: item.analysis.success,
+      type: effectiveType,
+      valueClass: item.analysis.valueClass
+    },
+    effectiveType,
+    is_type_mismatch: false,
+    schema: 0,
+    cst_class: 'derived',
+    status: item.analysis.success ? 'verified' : 'incorrect',
+    is_template: false,
+    is_simple_expression: true,
+    parent_schema_index: 0,
+    parent_schema: null,
+    is_inherited: false,
+    has_inherited_children: false,
+    spawn: [],
+    spawn_alias: []
+  } as unknown as Constituenta;
+}
+
+function toPublicEvaluationResult(
+  value: Value | null,
+  errors: { code: number; from: number; to: number; params?: readonly string[] }[],
+  iterations: number,
+  cacheHits: number,
+  status: EvalStatus
+): EvaluationResult {
+  const diagnostics = errors.map(toPublicError);
+  return {
+    success: diagnostics.length === 0 && value !== null,
+    value: value as EvaluationResult['value'],
+    status,
+    iterations,
+    cacheHits,
+    diagnostics
+  };
+}

package/src/mappers/schema-adapter.ts

@@ -0,0 +1,87 @@
+import { RSLangAnalyzer, type AnalysisFull, type ValueClass } from '@rsconcept/domain/rslang';
+import { getAnalysisFor } from '@rsconcept/domain/library/rsform-api';
+import { CstType, type RSForm } from '@rsconcept/domain/library/rsform';
+
+import {
+  type AnalysisResult,
+  type ConstituentaDraft,
+  type ConstituentaState,
+  type DiagnosticRecord,
+  type SessionState
+} from '../models';
+import { toPublicAnalysis, toPublicError } from './types';
+
+export class SchemaAdapter {
+  public analyzeAgainstSession(
+    session: SessionState,
+    draft: ConstituentaDraft
+  ): { result: AnalysisResult; diagnostics: DiagnosticRecord[] } {
+    const analyzer = this.buildAnalyzer(session);
+    const schema = this.toPseudoRSFormState(session, analyzer);
+    const analysis = getAnalysisFor(draft.definitionFormal, draft.cstType, schema as unknown as RSForm, draft.alias);
+    const result = toPublicAnalysis({
+      success: analysis.success,
+      type: analysis.type as Record<string, unknown> | null,
+      valueClass: analysis.valueClass,
+      errors: analysis.errors
+    });
+    return {
+      result,
+      diagnostics: analysis.errors.map(error => ({
+        sessionId: session.sessionId,
+        constituentId: draft.id,
+        expression: draft.definitionFormal,
+        error: toPublicError(error)
+      }))
+    };
+  }
+
+  public mergeStateWithDraft(
+    session: SessionState,
+    draft: ConstituentaDraft,
+    analysis: AnalysisResult
+  ): ConstituentaState {
+    const state: ConstituentaState = {
+      ...draft,
+      term: draft.term ?? '',
+      definitionText: draft.definitionText ?? '',
+      convention: draft.convention ?? '',
+      analysis
+    };
+    const index = session.items.findIndex(item => item.id === draft.id);
+    if (index === -1) {
+      session.items.push(state);
+    } else {
+      session.items[index] = state;
+    }
+    session.updatedAt = new Date().toISOString();
+    return state;
+  }
+
+  public toPseudoRSFormState(
+    session: SessionState,
+    analyzer: RSLangAnalyzer
+  ): Pick<RSForm, 'items' | 'cstByAlias' | 'analyzer'> {
+    const cstByAlias = new Map(session.items.map(item => [item.alias, item]));
+    return {
+      items: session.items as unknown as RSForm['items'],
+      cstByAlias: cstByAlias as unknown as RSForm['cstByAlias'],
+      analyzer
+    };
+  }
+
+  private buildAnalyzer(session: SessionState): RSLangAnalyzer {
+    const analyzer = new RSLangAnalyzer();
+    for (const item of session.items) {
+      if (item.cstType === CstType.BASE) {
+        analyzer.addBase(item.alias);
+      }
+      analyzer.setGlobal(
+        item.alias,
+        item.analysis.type as AnalysisFull['type'],
+        item.analysis.valueClass as ValueClass | null
+      );
+    }
+    return analyzer;
+  }
+}

package/src/mappers/types.ts

@@ -0,0 +1,35 @@
+import { type ValueClass } from '@rsconcept/domain/rslang';
+
+import { type AnalysisResult, type RSToolErrorDescription } from '../models';
+
+export interface DomainErrorLike {
+  code: number;
+  from: number;
+  to: number;
+  params?: readonly string[];
+}
+
+export interface DomainAnalysisLike {
+  success: boolean;
+  type: Record<string, unknown> | null;
+  valueClass: ValueClass | null;
+  errors: DomainErrorLike[];
+}
+
+export function toPublicError(error: DomainErrorLike): RSToolErrorDescription {
+  return {
+    code: error.code,
+    from: error.from,
+    to: error.to,
+    params: error.params
+  };
+}
+
+export function toPublicAnalysis(analysis: DomainAnalysisLike): AnalysisResult {
+  return {
+    success: analysis.success,
+    type: analysis.type,
+    valueClass: analysis.valueClass,
+    diagnostics: analysis.errors.map(toPublicError)
+  };
+}

package/src/models/analysis.ts

@@ -0,0 +1,13 @@
+import { type CstType, type RSToolErrorDescription, type ValueClass } from './common';
+
+export interface AnalyzeExpressionInput {
+  expression: string;
+  cstType: CstType;
+}
+
+export interface AnalysisResult {
+  success: boolean;
+  type: Record<string, unknown> | null;
+  valueClass: ValueClass | null;
+  diagnostics: RSToolErrorDescription[];
+}

package/src/models/common.ts

@@ -0,0 +1,17 @@
+import { CstType } from '@rsconcept/domain/library/rsform';
+import { EvalStatus, type BasicBinding } from '@rsconcept/domain/library/rsmodel';
+import { ValueClass } from '@rsconcept/domain/rslang';
+import { RSErrorCode } from '@rsconcept/domain/rslang/error';
+
+export { CstType, EvalStatus, RSErrorCode, ValueClass };
+export type { BasicBinding };
+
+/** Runtime evaluation value: number, nested array (set/tuple), or boolean 0/1. */
+export type RSToolValue = number | RSToolValue[];
+
+export interface RSToolErrorDescription {
+  code: number;
+  from: number;
+  to: number;
+  params?: readonly string[];
+}

package/src/models/constituenta.ts

@@ -0,0 +1,35 @@
+import { type AnalysisResult } from './analysis';
+import { type CstType } from './common';
+import { type DiagnosticRecord } from './diagnostic';
+
+export interface ConstituentaDraft {
+  id: number;
+  /** Alias */
+  alias: string;
+  /** CST type */
+  cstType: CstType;
+  /** Formal definition */
+  definitionFormal: string;
+  /** Natural-language term */
+  term?: string;
+  /** Natural-language definition */
+  definitionText?: string;
+  /** Convention or comment */
+  convention?: string;
+}
+
+export interface ConstituentaState extends Omit<ConstituentaDraft, 'term' | 'definitionText' | 'convention'> {
+  term: string;
+  definitionText: string;
+  convention: string;
+  analysis: AnalysisResult;
+}
+
+export interface AddOrUpdateConstituentaInput {
+  draft: ConstituentaDraft;
+}
+
+export interface AddOrUpdateConstituentaResult {
+  state: ConstituentaState;
+  diagnostics: DiagnosticRecord[];
+}

package/src/models/diagnostic.ts

@@ -0,0 +1,12 @@
+import { type RSToolErrorDescription } from './common';
+
+export interface DiagnosticRecord {
+  sessionId: string;
+  constituentId?: number;
+  expression: string;
+  error: RSToolErrorDescription;
+}
+
+export interface ListDiagnosticsFilters {
+  constituentId?: number;
+}

package/src/models/evaluation.ts

@@ -0,0 +1,25 @@
+import {
+  type BasicBinding,
+  type CstType,
+  type EvalStatus,
+  type RSToolErrorDescription,
+  type RSToolValue
+} from './common';
+
+export interface EvaluateExpressionInput {
+  expression: string;
+  cstType: CstType;
+}
+
+export interface EvaluateConstituentaInput {
+  constituentId: number;
+}
+
+export interface EvaluationResult {
+  success: boolean;
+  value: RSToolValue | BasicBinding | null;
+  status: EvalStatus;
+  iterations: number;
+  cacheHits: number;
+  diagnostics: RSToolErrorDescription[];
+}