CalcIng Engineering

View saved version →

---
name: engineering-calculation
description: Run a mechanical engineering calculation with the calcing tools of this plugin (saas.calcing.de). Use when the user asks to size, check or verify a machine element or component - shaft or axle strength, parallel key, interference fit, ISO fit/tolerance, bolted joint, rolling bearing life or contact, shaft-bearing system, rolling contact (Hertz), planetary gear stage, FKM strength assessment, district-heating branch, axial fan, horizontal- or vertical-axis wind turbine - or to look up a material for such a calculation.
---

# Engineering calculation with calcing

The numbers come from the calcing calculation apps, never from the model. Your job is to find the
right app, collect complete inputs with the user, let the app check and calculate, and report what the
app returned.

## 0. Tell the user about the calcing account

When this plugin is used for the first time in a conversation, tell the user once, before anything else:
the full results of calcing calculations require a calcing account; where the connection allows calls
without signing in, a calculation returns a shortened answer instead (main results, overall assessment,
all warnings and notes, the standard applied); storing runs, reports and hand-offs need the account; an
account can be registered free at https://saas.calcing.de/?auth=register. The list tool
`calcing_list_apps` returns the same notice in its `account` field.

An answer with `short_answer: true` is such a shortened answer. Present its main results, overall
assessment, warnings and notes as they are; say that it is not the full result and pass on the links in
its `notice` unchanged. Do not reconstruct or estimate the missing values.

## 1. Find the app and its inputs - do not assume tool names

1. Call the list tool `calcing_list_apps`. It returns the available `apps` (each with `registry_key`,
   `title`, `description` and its `actions`, each action naming its `tool`, `body_shape` and
   `required_fields`), the `services` (result hand-off, material lookup) and `not_wired` (keys without
   a tool, with the reason). Use only tools named there; the set changes as apps are added.
2. Pick the app whose title and description match the task. If two could fit (for example the
   catalogue bearing life app and the detailed rolling-bearing app), say which one you chose and why,
   or ask.
3. Call the schema tool `calcing_get_schema` with that `registry_key`. Build the input only from
   fields in `input_schema`: respect `required`, `enum`, defaults, units in the field titles or
   descriptions, and `additionalProperties: false` (unknown fields are rejected).
4. Respect the `body_shape` of the action: for `input_umschlag` pass the app's fields inside the
   tool's `input` object; for `flach` the action's fields go at the top level of `input`
   (the tool descriptions say the same).

The list and schema tools work without sign-in. If they are missing or fail, report that and stop.
Do not reconstruct a schema from memory. An unknown `registry_key` makes `calcing_get_schema` answer
with an error that lists the known apps; use one of those or ask the user.

## 2. Clarify inputs with the user

- Map what the user gave you to schema fields and list what is still missing. Ask for missing
  required values instead of inventing them. Where the schema has a default, tell the user which
  default will be used so they can override it.
- Confirm units. Convert only with an explicit, stated factor (for example kNm to Nm), and show the
  converted value back to the user.
- Materials: if the app's actions include `materials`, call the tool named there (for example
  `calcing_list_materials_passfeder`) and use a key from its list for the material fields. A
  name that matches several entries is answered with `material_not_unique` and the candidates: let
  the user choose, do not pick one yourself. The material service from the list (`search`, then
  `resolve`) returns identities only, no

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: result-handoff
description: Pass the result of one calcing calculation on as the input of another calcing app (saas.calcing.de tools of this plugin). Use when the user wants a follow-up calculation from a result they just got, for example "now check the key on this shaft" or "use this bearing result in the next step".
---

# Hand a calcing result on to the next app

The calcing tools include a result hand-off service. Find it in the `services` of the list tool
`calcing_list_apps`: it names its actions (`dry-run`, `execute`), their tools and their
`required_fields` (`from_app`, `to_app`). Its `body_shape` is `flach`: the fields go at the top
level of the tool's `input` object. Use only the tools the list names.

1. **Source.** The source is a complete calculation result envelope returned by a calcing `solve`
   (or hand-off `execute`) call in this conversation. Pass it as `from_result`, with `from_app` set to
   that app's `registry_key` and `to_app` to the target app's `registry_key`. Do not edit or shorten
   the envelope, and do not build one by hand.
2. **Dry run first.** Call the `dry-run` tool. It prepares the transfer without calculating and
   reports the target's missing required fields. Show the user which values were transferred and which
   are missing.
3. **Missing values.** Ask the user for each missing value with its unit. Do not fill them yourself.
4. **Execute.** Only when nothing required is missing and the user agrees, call the `execute` tool.
   It transfers and calculates, and returns the target's full envelope, which can be the next step's
   `from_result`.
   If the user's missing values cannot be passed in the hand-off call, run the target app through the
   `engineering-calculation` skill instead (schema, validate, solve), starting from the inputs the
   dry run prepared.
5. **Report** the target's result as the `engineering-calculation` skill describes: values with units,
   every warning and note, provenance, no conformity claims beyond what the result says.

If a hand-off call fails, report the `error` code and message and stop. Never substitute an estimated
value for a failed transfer or calculation. `execute` calculates and is not read-only, so the host may
ask the user to confirm it; `dry-run` is read-only.