HTTP with mock://

A url beginning with mock:// returns a canned 200 response. It makes no network request. Direct URLs are accepted only for mock://. To call a real API, you use a saved endpoint, which is covered in the next lesson.

schema: 1
name: HTTP mock
id: http-mock
blocks:
  - id: ping
    kind: http
    method: GET
    url: mock://users
    outputs:
      type: object
      properties:
        path: { type: string }
        mock: { type: boolean }
  - id: read
    kind: code
    language: python
    uses: [steps.ping.status, steps.ping.path, steps.ping.body]
    body: |
      import json, os
      d = json.load(open(os.environ["TERMORQ_INPUT"], encoding="utf-8"))["steps"]["ping"]
      print(json.dumps({"line": f"{d['status']} {d['path']} ({len(d['body'])} bytes)"}))
    outputs:
      type: object
      properties:
        line: { type: string }

What HTTP publishes

Templates work in url too, for example url: "mock://users/{{ loop.index }}".

HTTP with a saved endpoint

Steps

1. Add an HTTP endpoint block and choose your saved endpoint in Properties. Its path parameters, query string, headers, and payload are copied onto the block.
2. Build the request body in a Code block first. Don’t put text between JSON quotes in a template, because quotes and newlines in user input would break the JSON.

- id: prepare_http
  kind: code
  language: python
  uses: [steps.echo.message]
  body: |
    import json, os
    data = json.load(open(os.environ["TERMORQ_INPUT"], encoding="utf-8"))
    payload = {"message": data["steps"]["echo"]["message"]}
    print(json.dumps({"request_json": json.dumps(payload)}))
  outputs:
    type: object
    properties:
      request_json: { type: string }

- id: send_http
  kind: http
  endpoint: Create message
  method: POST
  body: "{{ steps.prepare_http.request_json }}"
  outputs:
    type: object
    properties:
      body: { type: string }

Credentials

The endpoint’s saved credentials stay in the OS keychain and are read during credential preflight, before the run starts. macOS decides whether to show a Keychain prompt. Cancel run is available while preflight is in progress. To use a secret directly, declare it under secrets: and use it in a header template such as {{ secrets.API_TOKEN }}. Termorq masks it in the record.

- id: check_created
  kind: decision
  branches:
    - when: steps.send_http.status == 201
      goto: done
    - else: true
      goto: log_failure

MCP tool

Steps

1. Add an MCP tool block. Choose the saved server, connect it, then choose the tool. Its parameters are copied onto the block.
2. Supply arguments as a template that resolves to one JSON object. As with HTTP bodies, serialise it in code first.

- id: echo_tool
  kind: mcp
  server: Demo tools
  tool: echo
  arguments: "{{ steps.prepare_http.request_json }}"
  outputs:
    type: object
    properties:
      content: { type: array }

- id: read_tool
  kind: code
  language: python
  uses: [steps.echo_tool.content]
  body: |
    import json, os
    content = json.load(open(os.environ["TERMORQ_INPUT"], encoding="utf-8"))["steps"]["echo_tool"]["content"]
    texts = [c.get("text", "") for c in content if c.get("type") == "text"]
    print(json.dumps({"reply": " ".join(texts)}))
  outputs:
    type: object
    properties:
      reply: { type: string }

What MCP publishes

• status: ok, a text representation of the result, and the top-level properties of the MCP result, such as content or structuredContent.
• JSON inside a content[].text string is not turned into workflow properties automatically. Parse it in a Code block.
• If the arguments don’t resolve to a JSON object, the block fails with MCP arguments must resolve to a JSON object.

When a run starts, Termorq connects to the saved server automatically if it isn’t connected yet. If the block fails, open @logs to see whether the credential lookup or the connection failed.

AI block

- id: summarise
  kind: ai
  connection: Summary model
  system: 'Return a single JSON object with a string property named "summary".'
  prompt: "Summarise this message in one sentence: {{ steps.echo.message }}"
  max_tokens: 128
  input_sample: |-
    {"trigger":{"text":"Deploy finished in 4m with 2 warnings"}}
  outputs:
    type: object
    properties:
      summary: { type: string }

How it works

• system and prompt are templates. Values you insert are sent to the model, and secrets are masked in the run record.
• The block always publishes text (the reply) and model.
• If you declare another property, such as summary, Termorq asks the model to end its reply with one JSON object and reads that final line. If the reply doesn’t end with that object, the block fails.
• A new AI block starts with a prompt that already includes earlier properties, and a default summary output.

Test it in isolation

Select the block and choose Open AI editor. Type JSON or plain text in Step input and choose Execute step:

The editor shows the response, errors, published output, and any skills used. Isolated tests don’t start triggers or create a Runs entry. input_sample is saved with the workflow, but a full run never uses it.

  system: 'Classify the message. Reply with one JSON object: {"severity": "info"|"warning"|"error"}.'
  prompt: "{{ steps.echo.message }}"
  outputs:
    type: object
    properties:
      severity:
        type: string
        enum: [info, warning, error]

✦ Autogenerate

Steps

1. Open a Code block’s code editor and click where you want the code to go. The panel remembers the cursor position. If you never clicked in the editor, the code is appended at the end.
2. Choose ✦ Autogenerate on the Snippet row.
3. Choose the Source node. The node wired into this block is selected first. The list shows how many steps back each node is, and shows input if the workflow declares inputs.
4. Review the fields:
   • AI, and nodes with a complete schema: lists their declared outputs and says Schema complete — nothing to add.
   • HTTP: status (number) is always included. body and any top-level JSON keys from the last run are marked Will add to this node’s output schema.
   • MCP, and code without a schema: shows an inferred checklist (text, tool-result fields, or keys from the last run). Fields whose type can’t be inferred are shown in amber with a type picker, defaulting to string. Unchecked fields are left out.
5. Check the Preview, which is written in the block’s language. If code above the cursor already opens TERMORQ_INPUT, the preview reuses that variable. Bash previews use jq.
6. Choose Insert, or Add schema & Insert if fields will be added to the source node’s schema.

What Insert changes

• The code goes on its own lines, tinted teal with an Inserted at cursor (or Appended) badge.
• Each path, such as steps.fetch_users.status, is added to this block’s uses.
• Any new fields are added to the source node’s output schema, so Available data and Save accept them.
• Undo in the notice restores the snippet, uses, and the source schema together. The tint and the notice last 10 seconds by default. You can change this to between 1 and 60 seconds under Settings → Workflows → Code editor.

Reference: Autogenerate code from an earlier node