@uipath/skills 1.201.0-preview.621 → 1.202.0-preview.635

package/skills/uipath-maestro-flow/references/author/references/plugins/merge/planning.md

@@ -1,29 +0,0 @@
-# Merge Node — Planning
-
-## Node Type
-
-`core.logic.merge`
-
-## When to Use
-
-Use a Merge node to synchronize parallel branches before continuing. It waits for all incoming paths to complete.
-
-### Selection Heuristics
-
-| Situation | Use Merge? |
-| --- | --- |
-| Two or more parallel branches need to join before continuing | Yes |
-| Sequential pipeline (no parallel branches) | No — wire nodes directly |
-
-## Ports
-
-| Input Port | Output Port(s) |
-| --- | --- |
-| `input` (accepts multiple connections) | `output` |
-
-## Wiring Rules
-
-- Connect each parallel branch's terminal node to the Merge node's `input` port
-- Merge accepts multiple incoming edges on the same `input` port
-- Execution continues from `output` only after all incoming paths complete
-- Use after forking from a single node to multiple downstream nodes

package/skills/uipath-maestro-flow/references/author/references/plugins/rpa/impl.md

@@ -1,121 +0,0 @@
-# RPA Node — Implementation
-
-RPA nodes invoke RPA processes. Pattern: `uipath.core.rpa-workflow.{key}`.
-
-## Discovery
-
-**Published (tenant registry):**
-
-```bash
-uip maestro flow registry pull --force
-uip maestro flow registry search "uipath.core.rpa-workflow" --output json
-```
-
-Search the **node-type token** `uipath.core.rpa-workflow` — this lists every published RPA workflow — then pick the one you need by its `resourceKey` / folder path and description. Do **not** search by the process name from the request: `registry search` matches the Orchestrator **release name**, which is frequently unrelated to the name the user uses or the folder the process lives in. The requested name often appears only in the folder path, so a keyword search for it returns nothing even though the process exists. Match on the folder path inside `resourceKey`, not on a name keyword.
-
-**An empty result is not authoritative — do not conclude the process is unpublished.** Before treating "not found" as real, confirm all three hold: (a) you searched the `uipath.core.rpa-workflow` token, not a name keyword; (b) `registry pull --force` ran first; (c) you scanned the returned folder paths and descriptions for the target, not just the display names. Only then is the process genuinely absent. Jumping to the local-scaffold fallback on a name-search miss builds a flow that validates but has nothing real to run.
-
-**In-solution (local, no login required):**
-
-```bash
-uip maestro flow registry list --local --output json
-uip maestro flow registry get "<node-type>" --local --output json
-```
-
-Run from inside the flow project directory. Discovers sibling RPA projects in the same `.uipx` solution.
-
-## Registry Validation
-
-```bash
-uip maestro flow registry get "uipath.core.rpa-workflow.{key}" --output json
-uip maestro flow registry get "uipath.core.rpa-workflow.{key}" --local --output json
-```
-
-Confirm:
-
-- Input port: `input`
-- Output port: `output`
-- `model.serviceType` — `Orchestrator.StartJob`
-- `model.bindings.resourceSubType` — `Process`
-- `model.bindings.resourceKey` — the `<FolderPath>.<ResourceName>` string used to scope binding resolution
-- `inputDefinition` — may contain typed input fields (check `properties`)
-- `outputDefinition` — always `error` (`source: "=Error"`); processes with output arguments also declare `output` (`source: "=this"`). Either way do not author `output` on the instance — the converter injects `=this`, and `$vars.{nodeId}.output` carries the process return value
-
-## Adding / Editing
-
-For step-by-step add, delete, and wiring procedures, see [editing-operations.md](../../editing-operations.md). Use the JSON structure below for the node-specific `inputs`.
-
-## JSON Structure
-
-### Node instance (inside `nodes[]`)
-
-The instance carries only per-instance data (`inputs`, `outputs`, `display`). BPMN type, serviceType, version, and binding/context templates come from the definition in `definitions[]`.
-
-```json
-{
-  "id": "processInvoices",
-  "type": "uipath.core.rpa-workflow.invoice-process-abc123",
-  "typeVersion": "<DEFINITION_VERSION>",
-  "display": { "label": "Process Invoices" },
-  "inputs": {
-    "documentPath": "=js:$vars.fileLocation",
-    "batchSize": 50
-  },
-  "outputs": {
-    "error": {
-      "type": "object",
-      "description": "Error information if the RPA process fails",
-      "source": "=Error",
-      "var": "error"
-    }
-  }
-}
-```
-
-**Declare `error` only — `output` is derived.** Authoring it makes the converter copy your `source` verbatim; `"=result.response"` then resolves to null at runtime while `flow validate` passes. See [file-format.md § Node outputs](../../../../shared/file-format.md#node-outputs).
-
-### Top-level `bindings[]` entries (sibling of `nodes`/`edges`/`definitions`)
-
-Add one entry per `(resourceKey, propertyAttribute)` pair. Share entries across node instances that reference the same RPA process — do NOT create duplicates.
-
-```json
-"bindings": [
-  {
-    "id": "bProcessInvoicesName",
-    "name": "name",
-    "type": "string",
-    "resource": "process",
-    "resourceKey": "Finance/Automation.Invoice Processor",
-    "default": "Invoice Processor",
-    "propertyAttribute": "name",
-    "resourceSubType": "Process"
-  },
-  {
-    "id": "bProcessInvoicesFolderPath",
-    "name": "folderPath",
-    "type": "string",
-    "resource": "process",
-    "resourceKey": "Finance/Automation.Invoice Processor",
-    "default": "Finance/Automation",
-    "propertyAttribute": "folderPath",
-    "resourceSubType": "Process"
-  }
-]
-```
-
-> For the resolution mechanics and why these entries are required, see [file-format.md — Bindings](../../../../shared/file-format.md#bindings--orchestrator-resource-bindings-top-level-bindings).
-
-## If the RPA Process Is Genuinely Not Published
-
-Reach this path only after the empty-result confirmation in [Discovery](#discovery) — a brand-name search miss does not qualify. When the process truly does not exist on the tenant and no sibling RPA project provides it, tell the user to create the RPA project inside the same solution using `uipath-rpa`. Once the project exists as a sibling in the `.uipx` solution, discover it with `uip maestro flow registry list --local --output json` and wire it directly — no publish required.
-
-A freshly scaffolded RPA project has no implementation, so the wired flow will pass `flow validate` but fault the moment it is debugged or run (`Robot.JobUnexpectedExitCode`) until `uipath-rpa` fills in the actual workflow. A validated flow is not a working one.
-
-## Debug
-
-| Error | Cause | Fix |
-| --- | --- | --- |
-| Node type not found in registry | Searched by process name (matches release name, not folder), process not published, or registry stale | Search the `uipath.core.rpa-workflow` token and match on folder path — not a name keyword. If in same solution: run `registry list --local`. Otherwise: run `uip login` then `uip maestro flow registry pull --force` |
-| Input schema mismatch | Inputs don't match `inputDefinition` | Run `registry get` and check required inputs in `inputDefinition.properties` |
-| Process execution failed | Underlying RPA process errored | Check `$vars.{nodeId}.error` for details |
-| Mock placeholder still in flow | Process not yet replaced | Follow the mock replacement workflow above |

package/skills/uipath-maestro-flow/references/author/references/plugins/subflow/impl.md

@@ -1,230 +0,0 @@
-# Subflow Node — Implementation
-
-## Node Type
-
-`core.subflow`
-
-## Registry Validation
-
-```bash
-uip maestro flow registry get core.subflow --output json
-```
-
-Confirm: input port `input`, output ports `output` and `error`. Set the node instance `typeVersion` to the `version` field from this response — do not hardcode it.
-
-## Parent Node JSON
-
-```json
-{
-  "id": "subflow1",
-  "type": "core.subflow",
-  "typeVersion": "<DEFINITION_VERSION>",
-  "display": { "label": "Add Numbers", "icon": "layers" },
-  "inputs": {
-    "a": 2,
-    "b": 3
-  },
-  "outputs": {
-    "error": {
-      "type": "object",
-      "description": "Error information if the subflow fails",
-      "source": "=Error",
-      "var": "error"
-    }
-  }
-}
-```
-
-**Declare `error` only — `output` is derived.** Authoring it makes the converter copy your `source` verbatim; `"=result.response"` then resolves to null at runtime while `flow validate` passes. See [file-format.md § Node outputs](../../../../shared/file-format.md#node-outputs).
-
-## Subflow Definition
-
-Subflow contents are stored in a top-level `subflows` object keyed by the parent node's ID:
-
-```json
-{
-  "subflows": {
-    "subflow1": {
-      "nodes": [
-        {
-          "id": "subflow1Start",
-          "type": "core.trigger.manual",
-          "typeVersion": "1.0",
-          "display": { "label": "Start" },
-          "inputs": {
-            "entryPointId": "unique-uuid-here",
-            "isDefaultEntryPoint": true
-          },
-          "outputs": {
-            "output": {
-              "type": "object",
-              "description": "Data passed when manually triggering the workflow.",
-              "source": "null",
-              "var": "output"
-            }
-          }
-        },
-        {
-          "id": "script1",
-          "type": "core.action.script",
-          "typeVersion": "1.0",
-          "display": { "label": "Add Numbers" },
-          "inputs": {
-            "script": "return { result: $vars.subflow1Start.output.a + $vars.subflow1Start.output.b };"
-          },
-          "outputs": {
-            "output": {
-              "type": "object",
-              "description": "The return value of the script",
-              "source": "=result.response",
-              "var": "output"
-            },
-            "error": {
-              "type": "object",
-              "description": "Error information if the script fails",
-              "source": "=Error",
-              "var": "error"
-            }
-          }
-        },
-        {
-          "id": "subflow1End",
-          "type": "core.control.end",
-          "typeVersion": "1.0",
-          "display": { "label": "End" },
-          "inputs": {},
-          "outputs": {
-            "result": { "source": "=js:$vars.script1.output.result" }
-          }
-        }
-      ],
-      "edges": [
-        {
-          "id": "sf-e1",
-          "sourceNodeId": "subflow1Start",
-          "sourcePort": "output",
-          "targetNodeId": "script1",
-          "targetPort": "input"
-        },
-        {
-          "id": "sf-e2",
-          "sourceNodeId": "script1",
-          "sourcePort": "success",
-          "targetNodeId": "subflow1End",
-          "targetPort": "input"
-        }
-      ],
-      "variables": {
-        "globals": [
-          {
-            "id": "a",
-            "direction": "in",
-            "type": "number",
-            "defaultValue": 0,
-            "triggerNodeId": "subflow1Start"
-          },
-          {
-            "id": "b",
-            "direction": "in",
-            "type": "number",
-            "defaultValue": 0,
-            "triggerNodeId": "subflow1Start"
-          },
-          {
-            "id": "result",
-            "direction": "out",
-            "type": "number",
-            "defaultValue": 0
-          }
-        ],
-        "nodes": []
-      },
-      "layout": {
-        "nodes": {
-          "subflow1Start": { "position": { "x": 200, "y": 144 }, "size": { "width": 96, "height": 96 }, "collapsed": false },
-          "script1":       { "position": { "x": 400, "y": 144 }, "size": { "width": 96, "height": 96 }, "collapsed": false },
-          "subflow1End":   { "position": { "x": 600, "y": 144 }, "size": { "width": 96, "height": 96 }, "collapsed": false }
-        }
-      }
-    }
-  }
-}
-```
-
-## Passing a Flow Input Into the Subflow
-
-A **parent flow** forwarding its own trigger input into a subflow must give the parent's `in`
-variable a `triggerNodeId` — same as a subflow `in` variable (rule #3), pointing at the
-parent's trigger node. Omit it and it's a silent trap: `uip maestro flow validate` still
-reports **Valid**, but at `flow debug` the trigger output is empty, the value arrives `null`,
-and the subflow script faults (e.g. `Cannot read property 'split' of null`).
-
-**Parent flow `variables.globals`** — note `triggerNodeId` on the `in` variable:
-```json
-{
-  "variables": {
-    "globals": [
-      { "id": "text", "direction": "in", "type": "string", "defaultValue": "", "triggerNodeId": "start" },
-      { "id": "reversedText", "direction": "out", "type": "string", "defaultValue": "" }
-    ]
-  }
-}
-```
-
-**Parent trigger + subflow node** — the subflow node reads the trigger output and maps it to
-the subflow's `in` variable:
-```json
-{
-  "nodes": [
-    {
-      "id": "start",
-      "type": "core.trigger.manual",
-      "typeVersion": "1.0",
-      "inputs": { "entryPointId": "<uuid>", "isDefaultEntryPoint": true },
-      "outputs": { "output": { "type": "object", "description": "Data passed when manually triggering the process.", "source": "null", "var": "output" } }
-    },
-    {
-      "id": "reverseSubflow",
-      "type": "core.subflow",
-      "typeVersion": "<DEFINITION_VERSION>",
-      "inputs": { "text": "=js:$vars.start.output.text" }
-    }
-  ]
-}
-```
-
-Value flow: caller input `text` → (bound to `start` via the parent global's `triggerNodeId`)
-→ `$vars.start.output.text` → subflow node input `text` → the subflow's own `in` variable
-(with its **own** `triggerNodeId: "<subflowStart>"`) → `$vars.<subflowStart>.output.text`
-inside the subflow. The parent `in` var and the subflow `in` var are **independent variables
-in separate scopes**, joined only by the subflow node's `inputs` mapping; each needs its own
-`triggerNodeId` pointing at its respective Start node.
-
-## Subflow Rules
-
-1. Every subflow **must** have its own Start node (`core.trigger.manual`) and End node (`core.control.end`)
-2. Subflow `variables.globals` with `direction: "in"` map to the parent node's `inputs`
-3. Subflow `in` variables **must** have `triggerNodeId` set to the subflow's Start node ID — this makes them accessible via `$vars.{startNodeId}.output.{varId}`
-4. Subflow `variables.globals` with `direction: "out"` map to the parent node's outputs, accessible via `$vars.{subflowNodeId}.output` in the parent flow
-5. Parent-scope `$vars` are **not** visible inside the subflow — pass values explicitly via inputs
-6. Subflow nodes must have inline `outputs` defined on them (Start node needs `outputs.output`, Script nodes need `outputs.output` and `outputs.error`)
-7. Subflows can be nested (subflow inside subflow), up to 3 levels
-8. Each subflow has its own `nodes`, `edges`, `variables`, and `layout` sections
-9. Subflow node positions go in the subflow's own `layout.nodes` — NOT in the top-level `layout.nodes`. Each subflow scope is independent.
-10. Parent flow forwarding an external input to a subflow: the parent's `in` variable **must** also set `triggerNodeId` to the parent's trigger node ID — same as #3, one scope up. `uip maestro flow validate` still reports **Valid** (it does not fail on the omission); the value silently arrives `null` at runtime. See [Passing a Flow Input Into the Subflow](#passing-a-flow-input-into-the-subflow).
-
-## Creating a Subflow
-
-For the step-by-step procedure, see [Edit/Write: Create a subflow](../../editing-operations-json.md#create-a-subflow). Use the parent node JSON and subflow definition structures above for the node-specific fields.
-
-## Debug
-
-| Error | Cause | Fix |
-| --- | --- | --- |
-| `$vars.inputData` undefined inside subflow script | Missing `triggerNodeId` on subflow `in` variable, or using `$vars.{varId}` directly | Add `triggerNodeId: "{startNodeId}"` to each `in` variable and access via `$vars.{startNodeId}.output.{varId}` |
-| Subflow script sees `null` for a value forwarded from the parent (e.g. `Cannot read property 'split' of null`) | Parent flow's `in` variable is missing `triggerNodeId`, so the parent trigger output is empty and `null` is forwarded into the subflow | Add `triggerNodeId: "{parentStartNodeId}"` to the parent flow's `in` variable (same fix as the row above, but for the root flow) |
-| `$vars.parentNode` undefined inside subflow | Parent scope not accessible | Pass values via subflow `in` variables |
-| Subflow output is null | Missing output mapping on subflow's End node | Map all `out` variables in the End node's `outputs` |
-| Script output is null | Missing inline `outputs` on script node | Add `outputs.output` and `outputs.error` inline on the script node |
-| Missing Start/End node | Subflow lacks required trigger or end | Add `core.trigger.manual` (with `outputs` and `entryPointId`) and `core.control.end` to the subflow |
-| Nesting limit exceeded | Subflow nested more than 3 levels deep | Flatten the structure or use resource nodes for deeper composition |

package/skills/uipath-maestro-flow/references/author/references/plugins/summarize/impl.md

@@ -1,198 +0,0 @@
-# Summarize Pattern Node — Implementation
-
-Summarize synthesizes a response grounded in an attached document. Node type: `uipath.pattern.deep-rag`. BPMN service task with `serviceType: "ECS.DeepRag"`. No process bindings, no connection binding — inputs are the only source of configuration.
-
-## Registry Validation
-
-```bash
-uip maestro flow registry get uipath.pattern.deep-rag --output json
-```
-
-Confirm:
-
-- Input port: `input`
-- Output ports: `output`, `error`
-- `model.type` — `bpmn:ServiceTask`
-- `model.serviceType` — `ECS.DeepRag`
-- `inputDefinition.properties` — `attachment` (declared `string`; runtime wants the **full Flow Attachment object** `{ ID, FullName, MimeType, Metadata }` — keys are case-sensitive, `ID` is uppercase, not `Id` — Studio Web's file-picker form serializes the whole object into that slot, the engine deserializes it back), `prompt` (string), `returnCitations` (boolean)
-- `outputDefinition.output.type` — `"object"`; `outputDefinition.output.source` — `"=response"` (the BPMN engine wraps the result under that key — same convention as every other ServiceTask)
-- `outputDefinition.output.schema` — top-level fields `id` (string) and `content` (object|null) with PascalCase nested fields:
-  - `content.Text` — string
-  - `content.Citations` — array|null of `{ Ordinal: integer, PageNumber: integer, Source: string, Reference: string }`
-- `outputDefinition.error.schema.required` — `code`, `message`, `detail`, `category`, `status`
-
-If the command errors with **"Node type not found: uipath.pattern.deep-rag"**, the CLI build predates Summarize support or the tenant's `canvas.nodes.summarize` server flag is off. Run `uip tools update` and `uip maestro flow registry pull --force`; if it still errors, confirm with your UiPath admin that `canvas.nodes.summarize` is enabled on the tenant.
-
-## Adding / Editing
-
-Pattern nodes are OOTB BPMN service tasks — they are **user-owned** per [Author capability — Node ownership](../../../CAPABILITY.md#node-ownership--who-authors-the-node), so author them by editing the `.flow` JSON directly (Edit/Write). The `uip maestro flow node add` / `edge add` CLI is reserved for CLI-owned nodes (connectors, connector-triggers, managed HTTP), where the CLI populates product-managed state. For OOTB structural edits — adding the Summarize node, wiring its edges, adding the `attachment` flow input — use Edit/Write against the `.flow` file. See [editing-operations.md](../../editing-operations.md) for the JSON authoring mechanics; the snippets below cover what is **specific** to Summarize.
-
-## Wiring `attachment` — file variable bound to the trigger
-
-The canonical canvas-produced shape is a flow `in` variable of `type: "file"` bound to the trigger via `triggerNodeId`, with the Summarize node's `attachment` referencing it through the trigger's output:
-
-```json
-"variables": {
-  "globals": [
-    {
-      "id": "documentFile",
-      "direction": "in",
-      "type": "file",
-      "triggerNodeId": "start"
-    }
-  ]
-}
-```
-
-Then on the Summarize node:
-
-```json
-"inputs": {
-  "attachment": "=js:$vars.start.output.documentFile",
-  ...
-}
-```
-
-Populate that variable at runtime with `uip maestro flow debug --attachment <variableId>=<localPath>` (example: `--attachment documentFile=./path/to/doc.pdf` for the `documentFile` variable above). The CLI uploads the file and binds it as a `{ ID, FullName, MimeType, Metadata }` Attachment object — keys are case-sensitive; `ID` is uppercase, not `Id`. The flag is repeatable; the `<variableId>` (left of `=`) must match a `variables.globals[]` entry's `id` — see [cli-commands.md — Pre-flight](../../../../shared/cli-commands.md#pre-flight---attachment-binding). Do not declare the variable as `type: "object"`, do not reference it as `=js:$vars.<variableId>` directly without the trigger output path, and do not pass a bare GUID/URL/path/`.ID`/`.FullName`.
-
-## JSON Structure
-
-```json
-{
-  "id": "summarizeContract",
-  "type": "uipath.pattern.deep-rag",
-  "typeVersion": "1.0",
-  "display": { "label": "Summarize Contract" },
-  "inputs": {
-    "attachment": "=js:$vars.start.output.documentFile",
-    "prompt": "Write a 5-bullet executive summary covering scope, term, SLAs, penalties, and termination.",
-    "returnCitations": true
-  },
-  "outputs": {
-    "output": {
-      "type": "object",
-      "source": "=response",
-      "var": "output",
-      "schema": {
-        "$schema": "http://json-schema.org/draft-07/schema#",
-        "type": "object",
-        "properties": {
-          "id": { "type": "string" },
-          "content": {
-            "type": ["object", "null"],
-            "properties": {
-              "Text": { "type": "string" },
-              "Citations": {
-                "type": ["array", "null"],
-                "items": {
-                  "type": "object",
-                  "properties": {
-                    "Ordinal":    { "type": "integer" },
-                    "PageNumber": { "type": "integer" },
-                    "Source":     { "type": "string" },
-                    "Reference":  { "type": "string" }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "error": {
-      "type": "object",
-      "description": "Error information if the node fails",
-      "source": "=Error",
-      "var": "error"
-    }
-  }
-}
-```
-
-Notes:
-
-- **No instance-level `model` block.** BPMN type and `serviceType: "ECS.DeepRag"` live only in the corresponding `definitions[]` entry — copy that verbatim from `uip maestro flow registry get uipath.pattern.deep-rag --output json`. Per [Author capability, rule 15](../../../CAPABILITY.md), node instances normally have no `model` block.
-- **`typeVersion` must match `definitions[<deep-rag>].version` exactly** — set it to the `version` field from the `registry get uipath.pattern.deep-rag` response; do not guess. Use the registry's exact form (single-dot `x.y`, e.g. `"1.0"`, not `"1.0.0"`).
-- `outputs.output.source` is the literal **`=response`** (the convention every BPMN ServiceTask follows). Do not rewrite to `=deepRagResult` or similar.
-- `outputs.output.type` is **`"object"`**, with the nested PascalCase schema above.
-- Setting `returnCitations: true` populates `content.Citations`; setting `false` omits the array entirely (the downstream consumer should tolerate either).
-
-## End-node output mapping
-
-If the flow surfaces the synthesized text or citations as flow `out` variables, the End node must map them. Per [Author capability, rule 11](../../../CAPABILITY.md), value-field expressions need the `=js:` prefix. Note the **PascalCase** field names:
-
-```json
-{
-  "id": "end",
-  "type": "core.control.end",
-  "typeVersion": "1.0",
-  "outputs": {
-    "summary":   { "source": "=js:$vars.summarizeContract.output.content.Text" },
-    "citations": { "source": "=js:$vars.summarizeContract.output.content.Citations" }
-  }
-}
-```
-
-Without `=js:`, the runtime stores the literal string (e.g. `"$vars.summarizeContract.output.content.Text"`) into the flow output instead of the real value. When `returnCitations: false`, drop the `citations` mapping rather than mapping a missing field. Lowercase variants (`.text`, `.citations`) do not exist in the response shape — they would resolve to `undefined`.
-
-## Add via CLI (opt-in, not preferred)
-
-The `uip maestro flow node add` / `edge add` CLI is **not** the canonical authoring path for OOTB pattern nodes (see [Node ownership](../../../CAPABILITY.md#node-ownership--who-authors-the-node) — pattern nodes are user-owned). Reach for it only when scripting in a context where Edit/Write isn't available. The shape:
-
-```bash
-uip maestro flow node add <FlowName>.flow uipath.pattern.deep-rag \
-  --label "<LABEL>" \
-  --input '{
-    "attachment": "=js:$vars.<triggerId>.output.<fileVarId>",
-    "prompt": "<INSTRUCTION for the synthesis>",
-    "returnCitations": true
-  }' \
-  --output json
-```
-
-`attachment` must resolve to a **full Flow Attachment object** `{ ID, FullName, MimeType, Metadata }` — keys are case-sensitive; `ID` is uppercase, not `Id`. Reference it through the trigger's output (`$vars.<triggerId>.output.<fileVarId>`) — that's how the canvas wires file-typed flow `in` variables. Do **not** pass a bare GUID, URL, byte stream, or path; even though the OOTB `inputDefinition` declares `type: "string"`, the engine wants the object. Set `returnCitations: false` (or omit) when downstream consumers do not need page-level provenance.
-
-## Accessing Output
-
-```javascript
-// Downstream Script node
-const result = $vars.summarizeContract.output;
-const text = result.content.Text;                   // the synthesized prose
-const citations = result.content.Citations ?? [];   // [{ Ordinal, PageNumber, Source, Reference }, ...]
-return {
-  summary: text,
-  citationCount: citations.length,
-};
-```
-
-Field names are **PascalCase** (`Text`, `Citations`, `Ordinal`, `PageNumber`, `Source`, `Reference`). If `returnCitations: false`, the `Citations` array is not present. Guard with `?? []` or check `result.content.Citations != null` before iterating.
-
-## Validate
-
-```bash
-uip maestro flow validate <FlowName>.flow --output json
-```
-
-The validator checks that required inputs (`attachment`, `prompt`) are present and non-empty.
-
-## Debug
-
-| Error | Cause | Fix |
-| --- | --- | --- |
-| `Node type not found: uipath.pattern.deep-rag` | CLI predates Summarize support, or tenant flag `canvas.nodes.summarize` is off | `uip tools update`, `uip maestro flow registry pull --force`; check with admin that `canvas.nodes.summarize` is enabled if still missing |
-| Runtime: synthesis returns empty `content.Text` | Prompt too vague, or attachment unreadable (image-only PDF with no OCR, corrupted file) | Tighten the prompt; confirm the attachment type is supported and has selectable text |
-| `content.Citations` missing even though set `returnCitations: true` | Downstream consumer read the node's `inputDefaults` before the runtime produced the output | Reference `$vars.{nodeId}.output.content.Citations` only in nodes downstream of Summarize; do not precompute |
-| Downstream `result.content.text` / `result.content.citations` is `undefined` | Used lowercase field names — the response shape is PascalCase | Switch to `result.content.Text` / `result.content.Citations` |
-| Large documents time out | Synthesis cost scales with doc size; single call is bounded | Split the document upstream (per-section Summarize calls + a final merge step) or move to a published [Agent](../agent/impl.md) with a context-grounding resource |
-| Wrong citations (pages off by one, wrong source) | The attached document's page numbering doesn't match the displayed page ordinal | Treat `Ordinal` and `PageNumber` as advisory — present `Source`/`Reference` alongside and let the reader verify |
-
-## What NOT to Do
-
-- **Do not hand-author `model.bindings`** on the node — Summarize has no process or connector binding. Adding a `bindings` block will be stripped or cause validate errors.
-- **Do not pass `--source` on `uip maestro flow node add`** — `--source` is only for inline agent nodes. Summarize has no agent project behind it.
-- **Do not chain Summarize for multi-turn chat.** It is single-turn; each call is independent. Use a published [Agent](../agent/impl.md) for conversational flows.
-- **Do not stuff `prompt` with entire document text.** The attachment is already ingested — the prompt should describe **the task**, not the input.
-- **Do not assume `content.Citations` is always present.** When `returnCitations: false`, the field is omitted; downstream code must guard.
-- **Do not use lowercase field names** (`content.text`, `content.citations`, `.ordinal`, `.page`). The runtime emits PascalCase: `content.Text`, `content.Citations`, `Ordinal`, `PageNumber`, `Source`, `Reference`.
-- **Do not pass `attachment` as a bare string id, GUID, URL, or path.** The OOTB schema and Studio Web's file-picker UI suggest a string, but the runtime needs the **full Flow Attachment object** `{ ID, FullName, MimeType, Metadata }` — keys are case-sensitive; `ID` is uppercase, not `Id`. The canonical wiring is a flow `in` variable of `type: "file"` bound to the trigger via `triggerNodeId`, referenced as `=js:$vars.<triggerId>.output.<fileVarId>` (see Key Inputs in `planning.md`). Bare-id mistakes pass `flow validate` cleanly and fault at runtime.
-- **Do not write `outputs.output.source: "=deepRagResult"`.** The canonical value is `"=response"` (the convention every BPMN ServiceTask follows).

package/skills/uipath-maestro-flow/references/author/references/plugins/summarize/planning.md

@@ -1,71 +0,0 @@
-# Summarize Pattern Node — Planning
-
-The Summarize node runs comprehensive document synthesis over an attached file (PDF, Word, etc.): ingest, retrieve, reason, and return prose — optionally with per-sentence citations back to the source pages. It sits in the **Document Processing** category of the add-node panel.
-
-## Node Type
-
-`uipath.pattern.deep-rag`
-
-(The wire type still reads `deep-rag` even though the canvas display name is "Summarize" — the node type is contractual with the runtime serializer and was not renamed.)
-
-Fixed OOTB node type — no registry suffix, one version. It does not appear in `uip maestro flow registry list` unless the tenant has the platform-side `canvas.nodes.summarize` feature flag enabled. The uip CLI unconditionally requests this flag in its manifest fetch, so the node will appear once the server rolls it out to your tenant.
-
-## When to Use
-
-Use Summarize when the task is **"read this document and produce a thorough answer"** — summarization, Q&A, compliance checks, executive briefs — where depth matters and traceability back to the source is valuable.
-
-### Selection Heuristics
-
-| Situation | Use Summarize? |
-| --- | --- |
-| Summarize a long document (contract, policy, research paper) | Yes |
-| Answer a free-form question grounded in one attached document | Yes |
-| Produce a report where every claim must cite the source page | Yes — set `returnCitations: true` |
-| Short, single-turn Q&A over small text in-memory | No — use [Agent](../agent/planning.md) or [Script](../script/planning.md) |
-| Row-by-row enrichment of tabular data | No — use [Batch Transform](../batch-transform/planning.md) |
-| Multi-document retrieval across a corpus | No — Summarize is scoped to one attachment per call. Chain multiple Summarize nodes (one per doc) and merge results, or use a published [Agent](../agent/planning.md) with a context-grounding resource |
-| The user wants to chat with the document | No — Summarize is single-turn. Use an [Agent](../agent/planning.md) with a context resource for conversational behavior |
-
-### Anti-Patterns
-
-- **Do not use Summarize for small/simple text.** For a few paragraphs inline in `$vars`, a [Script](../script/planning.md) or [Agent](../agent/planning.md) is cheaper and faster.
-- **Do not use Summarize as a general agent.** It cannot call tools, escalate, or loop — it is a single synthesis step. For multi-step reasoning with tool use, use an [Agent](../agent/planning.md).
-- **Do not chain multiple Summarize nodes to emulate multi-document retrieval if the answer requires cross-document reasoning.** Per-document synthesis then merging loses cross-doc grounding. Use a published [Agent](../agent/planning.md) with a proper retrieval resource instead.
-
-## Ports
-
-| Port | Position | Direction | Use |
-| --- | --- | --- | --- |
-| `input` | left | target | Flow sequence input |
-| `output` | right | source | Synthesis text (plus citations if enabled) |
-| `error` | right | source | Error handler |
-
-No artifact ports. Pattern-style nodes do not wire to resource files — the prompt lives on the node inputs.
-
-## Output Variables
-
-`$vars.{nodeId}.output` is an object whose schema is published on the OOTB definition (also mirrored on the node instance's `outputs.output.schema`):
-
-- `id` — string, the result identifier
-- `content` — `object | null`
-  - `content.Text` — string, the synthesized prose
-  - `content.Citations` — `array | null`, present only when `returnCitations: true`. Each entry: `{ Ordinal: integer, PageNumber: integer, Source: string, Reference: string }`
-
-Note the **PascalCase** field names (`Text`, `Citations`, `Ordinal`, `PageNumber`, `Source`, `Reference`) — the runtime emits them this way to match the engine response shape; lowercase variants (`text`, `citations`, `page`) are wrong.
-
-`$vars.{nodeId}.error` — populated on failure: `{ code, message, detail, category, status }`.
-
-## Key Inputs
-
-| Input | Required | Type | Description |
-| --- | --- | --- | --- |
-| `attachment` | Yes | full Flow Attachment | The runtime engine wants the **full Flow Attachment object** `{ ID, FullName, MimeType, Metadata }` — keys are case-sensitive; `ID` is uppercase, not `Id`. Source it as a flow-level `in` variable of `type: "file"` bound to the trigger via `triggerNodeId: "<triggerId>"`. The variable's payload is populated by `uip maestro flow debug --attachment <fileVarId>=<path>` (repeatable; `<fileVarId>=` must match the variable's `id` — see [cli-commands.md — Pre-flight](../../../../shared/cli-commands.md#pre-flight---attachment-binding)). Reference it on the Summarize node as `=js:$vars.<triggerId>.output.<fileVarId>` — that path resolves to the whole Attachment object at runtime. The OOTB `inputDefinition.attachment` declares `type: "string"` because Studio Web's file-picker form serializes the object into that string slot at save time; the engine deserializes it back. **Never** wire a bare GUID, URL, byte stream, file path, or `.ID`/`.FullName` subfield. |
-| `prompt` | Yes | string | The task instruction — e.g., "Write a 3-paragraph executive summary", "List every SLA penalty clause", "Answer: what is the termination notice period?". |
-| `returnCitations` | No | boolean | When `true`, the `content.Citations` array is populated with per-claim page references. Default `false`. |
-
-## Planning Annotation
-
-In the architectural plan:
-
-- `pattern: summarize — <one-line purpose>` with a placeholder for the attachment source (a `=js:$vars.<triggerId>.output.<fileVarId>` reference to a trigger-bound `in` variable of `type: "file"`) and a short summary of the prompt.
-- If the downstream step needs to display or audit sources, call out `returnCitations: true` explicitly in the node table; otherwise leave it `false`.