OpenSysML MCP server

Advance the debuggers' simulation clock (%advance), running every state event, action token, change-condition poll and do behavior that comes due, in due order, and report what ran and where the debuggers stand. The clock is the session's: a debugged action and machine both move.

Apply source-preserving edits to a parsed model and return the edited notation (the ApplyEdits RPC): set a value, rename with every reference, add a member, import, documentation, comment, connection, transition, satisfy or metadata, delete, move. Edits are located from the parsed spans, so comments and layout outside them are kept, and the result is re-parsed and validated before it is answered; a refused batch answers `error` and `failure` naming why, and nothing is applied. Nothing is written to disk: the edited text comes back as `content` (one document) or `documents` for the agent to write. The result is the ApplyEditsResponse as protojson writes it.

Edit a model by operations on its elements rather than by text: setValue, rename, addMember, addConnection, addSequence (action-body items), delete, move, and the diagram-layout annotations setLayout, setRoute, setCanvas, setStyle, setNote, setPicture. Targets and owners are qualified names as render_view reports them in nodes[].fqn. Returns the text edits the operations amount to, per document, and the operations refused with why; writes the files only with apply=true.

Ask an SMT solver whether a constraint, requirement or satisfaction can be satisfied at all (%check, experimental), with a satisfying assignment when it can. Needs z3 or cvc5 installed; the status is unavailable otherwise.

Search every schedule of an action or state machine (the CheckBehavior RPC, the REPL's %check-property/%check-diverge settings about %action/%state): a property false at a stable state, a deadlock, a failure or a feature whose final value the schedule decides is witnessed and replayed. `verdict` is holds, fails or undecided; `violations`, `divergences` and `finals` carry each witness as its replay schedule, draws and choices, and the witness file when asked for. With checkInput or checkAssume the symbolic engine answers with `claim`, the inputs it ranged over and its witnesses. Bounded by checkDepth, checkStates and checkTimeout. The result is the CheckBehaviorResponse as protojson writes it.

Release a document held open by open_document: the server goes back to the file on disk (or forgets the document when there is no file). Nothing is written.

List the quick fixes and refactorings available for a range of a document, each with the edits it would make. Nothing is applied; write the edits with your own file tools or use the rename/format/apply_model_edit tools with apply=true.

Run every configuration a SysML v1 tool's results sidecar indexes against the migrated model (the CompareResults RPC, the CLI's -compare-results with -action, -runs, -seed, -draws, -clock-step and -observe): each on its target, for its recorded run count under its duration mode, or the runs and draws given, and table the tool's and OpenSysML's min, mean, p50, p90 and max of each observable with their relative difference. `configurations` carry each one's status (holds, fails, unresolved), its rows, the distributions compared, the errors and notes, and the lines the CLI prints. The result is the CompareResultsResponse as protojson writes it.

Propose completions at a position: keywords, names in scope and members of the type being accessed.

Ask an SMT solver which variants an element's conditions permit (%configure, experimental): a consistent selection, the check of the selections given, or every consistent selection up to a limit. A part or definition is configured over every assertion about its objects. Read-only: no variant is bound.

Convert a SysML v2 model between the representations OpenSysML writes — textual notation, RDF Turtle, the API's JSON element form — (the Convert RPC, the CLI's -convert). Name the model by modelHash, paths or sources (the source the parse read is converted), or by filePath or inline content read afresh. Nothing is written to disk: the converted document comes back as `content` for the agent to write. A SysML v1 model is refused with INVALID_ARGUMENT: use migrate. The result is the ConvertResponse as protojson writes it.

Set breakpoints at nodes of the debugged action (%break), optionally clearing the earlier ones, and report the breakpoints it then has; with nothing to set, lists them. A node the action has none of fails, naming its nodes.

Run the debugged action to completion, or to the first breakpoint a token reaches (%continue), and report its results.

Report where the debugging session stands without changing it: the action's execution state, tokens, breakpoints and feature values (%tokens), or the machine's current state, clock, event queue, signals in flight and state data (%current, %events).

Start a debugging session on an action (%action) or a state machine (%state), performed by an object when one is named. The action is not stepped: debug_step advances one token step, debug_continue runs to completion or a breakpoint. A machine takes its entry; debug_step, advance and send drive it. Starting again replaces the session.

Advance the debugged action one token step, or the debugged state machine one step (%step): one event dispatched, one change event, one round of do actions. A token waiting only on the clock is not stepped; advance moves the clock.

End the debugging session (%stop), letting go of its run; objects the session holds stay.

Find where the name at a position is declared. Standard library declarations are reported as sysml://stdlib/<file> resources.

Report every diagnostic of a parsed model (the GetDiagnostics RPC), as `sysml -validate` does: each with its severity, code, message and position. Parse with `strictConformance` for the strict mode of `sysml -validate -strict`; `disableLint` and `enableLint` select the lints as `sysml -disable-lint`/`-enable-lint` do. The result is the DiagnosticsResponse as protojson writes it.

Outline a document: the elements it declares, nested as they are owned, with their kinds and ranges.

List the document definitions (doc def) declared across the workspace, which render_document renders to Markdown.

Evaluate a SysML expression against a parsed model (the Evaluate RPC, the REPL's %eval): arithmetic, feature reads, quantities with units, collection operators. The result is the EvaluateResponse as protojson writes it: `result` is a Value (64-bit integers are JSON strings, as the proto3 JSON mapping writes them), `error` is set when the expression could not be evaluated. The text spells the value as the REPL prints it.

Invoke a calculation (the EvaluateCalc RPC, the REPL's %calc): a calc definition with positional arguments answers its `result`; a calc usage named with no arguments binds its inputs from its own members and answers every output feature in `outputs`. The result is the EvaluateCalcResponse as protojson writes it.

Run an action definition or usage to completion and report its output parameters (the ExecuteAction RPC, the REPL's %run). Inputs are bound by parameter name. Under an explore schedule every linearization the model admits is run and the answer is the set of distinct `outcomes` with how the exploration ended, instead of one run's outputs. The run is bounded by the service's OPENSYSML_MAX_* budgets; a budget hit is reported in `error`. `advance`, `seed`, `draws` and `clockStep` are the run options of `sysml -advance`, `-seed`, `-draws` and `-clock-step`. With `trace` the answer also carries every record the run made (token steps, waits, accepts, decisions, assignments, completion), up to a failure; `events` are posted to the performer in order, each once every token waits. The result is the ExecuteActionResponse as protojson writes it.

Run a state machine over a sequence of events and report the states visited, the final context and the simulation clock (the ExecuteState RPC, the REPL's %run on a state). With trace the answer also carries every record the run made (entry, exit, transition, accept, send, choice), up to a failure. Under an explore schedule every linearization is run and the answer is the set of distinct `outcomes`. With `advance` the events are sent and the clock then moved by that much, as `sysml -state X -advance T` does; without it the machine runs to quiescence. The run is bounded by the service's OPENSYSML_MAX_* budgets. The result is the ExecuteStateResponse as protojson writes it.

Ask an SMT solver which conditions of an unsatisfiable element conflict (%explain, experimental): a minimal set of conditions, each with the element declaring it and its location.

Explain a diagnostic code (as the CLI's -explain does): what it means, how to resolve it and the specification clause or validation constraint behind it. Every diagnostic the `parse`, `diagnostics` and `workspace_diagnostics` tools report carries one of these codes. With no code, list every code with its one-line summary.

Export the lowered graph of an action or state machine — the subject's and every behavior it performs — as the canonical graphs:<version> JSON external analysis engines read (the ExportGraphs RPC). The result is the ExportGraphsResponse as protojson writes it, the JSON in `content`; the text names the subject and version on its first line and carries the JSON after it.

Show an object's feature values and what its behaviors are doing (%features): the values its attributes hold, the objects its parts and ports hold, its connectors, and the state of each machine it exhibits and action it performs. Objects come from repl_command `%instantiate <name>` or from runs.

Format a SysML v2 / KerML document, or only the lines of a range, in the canonical style. Returns the edits and the resulting text; writes the file only with apply=true. A document that does not parse is left unchanged.

Explain the element at a position: its kind, qualified name, type, value and documentation, as Markdown.

Set the feature values a CSV, TSV, JSON or JSON Lines file assigns, one row per element (the ImportData RPC, the CLI's -import with -import-as, -import-map, -import-format and -import-dry-run): a feature the element declares has its value set, one it inherits is redefined in the element's body with the value, as one edit per file; a value the model refuses leaves every row unapplied and answers `error`. `files` carry each assignment with the element, feature, value and the inherited feature it redefines; the edited text comes back as `content` (one document) or `documents` with the `modelHash` of the imported model, nothing is written to disk. A dry run answers the assignments alone. The result is the ImportDataResponse as protojson writes it.

Import a draw.io (diagrams.net) file that render_view wrote with form drawio and a user edited in draw.io: what moved, resized, folded, re-routed or recoloured, the page size, a note's text and a picture's file become DiagramLayout annotations (Layout, Route, Style, Canvas, Note, Picture) in the view's body, and a name retyped in a node, port or edge label becomes a rename of the element, declaration and references alike, applied as apply_model_edit applies its operations. Cells the rendering lacks, cells naming no element, deleted cells, a label edited beyond its name, an invalid or taken name, an emptied note and a picture source no file under the view's directory names are reported, never created, deleted or guessed. Answers the planned edits and text changes; writes the files only with apply=true.

List the inferred types and values the editor would show inline for the features of a document or range.

List the objects a session holds (%instances): each with its id, type and lifetime, the ones a later instantiation displaced included.

Build an object of a part definition or usage and report its feature values (the Instantiate RPC, the REPL's %instantiate): every attribute's value or default, nested parts as instance ids, with every reachable instance in `instances`. The service keeps the object for the model: run_document_query on the same modelHash can bind it. The result is the InstantiateResponse as protojson writes it.

List the analysis engines this build registers (the ListEngines RPC, as the CLI's -engines does): each with the questions it answers (evaluate, outcomes, holds, sensitive, satisfiable, sweep, compute), the strongest evidence it can produce, the bounds it takes, and whether it can run here. The names are what the verification tools' `engine` argument takes; empty there means auto. With `probe` each external engine is started once and checked against its manifest, as `sysml -engines -probe` does. The result is the ListEnginesResponse as protojson writes it.

Migrate a SysML v1 model — UML XMI with the SysML profile, an Eclipse UML2 .uml file or a Cameo/MagicDraw .mdzip archive — to SysML v2 in one of the representations convert writes (the Migrate RPC, the CLI's -migrate). Migration is not lossless: every v1 element is mapped, approximated, left unmapped or skipped, and `report` accounts for each. Nothing is written to disk: the migrated model comes back as `content`, with any image files it refers to in `files`. The result is the MigrateResponse as protojson writes it.

Hold a document open with the given text, as an editor buffer the server analyzes instead of the file on disk, so text can be checked (diagnostics, hover, render) before it is written. Nothing is written to disk; close_document reverts to the file. format, rename and apply_model_edit with apply=true write the buffer, unless the file changed on disk since it was opened. Returns the diagnostics of the text.

Ask an SMT solver for the best values an analysis case's objectives admit (%optimize, experimental), each objective improved as its trade-study definition says, within the case's conditions.

Parse SysML v2 / KerML documents as one model and return its modelHash, the root namespace of each document and every diagnostic (the ParseSources RPC). Parsing is content-addressed: the same documents give the same modelHash, and the hash is what every other runtime tool takes as modelHash, so parse once and pass the hash, or give those tools the same paths/sources and they parse implicitly. A model is only readable when no diagnostic has severity error. The result is the ParseSourcesResponse as protojson writes it; the text lists each root and the diagnostics as the CLI prints them.

Select elements of a parsed model with a SysML v2 API & Services Query — scope, select, where, orderBy — or OSLC query text (the Query RPC). Each matched element answers its qualified name, metamodel type and the properties select asked for. A query the service cannot evaluate fails with INVALID_ARGUMENT rather than answering empty. The result is the QueryResponse as protojson writes it.