@uipath/skills 1.204.0 → 1.204.1

package/skills/uipath-maestro-flow/examples/GreenhouseWatering.flow.ts

@@ -1,39 +0,0 @@
-/**
- * CAPABILITY: a two-way `.branch` — run one of two paths on a boolean condition.
- *
- * The scenario is deliberately generic (a greenhouse sensor) so it shows the
- * SHAPE, not a task answer: a condition, a `yes` arm, a `no` arm, each ending in
- * its own `.return()`.
- *
- *     .branch(name, <js boolean>, (yes) => …, (no) => …)
- *
- * `js\`…\`` builds the condition from inputs/vars/step outputs; each arm is a
- * sub-builder exactly like the top-level flow. An arm that ends in `.return()`
- * is that path's End node — the two arms are independent endings, not a join.
- */
-import { flow, script, input, out, js, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('greenhouse-watering')
-  .name('GreenhouseWatering')
-  .version('1.0.0')
-  .input({ moisture: types.number, threshold: types.number })
-  .output({ action: types.string })
-
-  .branch(
-    'needsWater',
-    js`${input('moisture')} < ${input('threshold')}`,
-    (yes) =>
-      yes
-        .step('water', script({
-          code: 'return "watered: moisture " + $vars.start.output.moisture + " is below " + $vars.start.output.threshold;',
-        }))
-        .return({ action: out('water') }),
-    (no) =>
-      no
-        .step('hold', script({
-          code: 'return "held off: moisture " + $vars.start.output.moisture + " is at or above " + $vars.start.output.threshold;',
-        }))
-        .return({ action: out('hold') }),
-  )
-
-  .build();

package/skills/uipath-maestro-flow/examples/HarbourRadioLine.flow.ts

@@ -1,31 +0,0 @@
-/**
- * CAPABILITY: answer an INBOUND phone call (`core.trigger.voice`).
- *
- * `voiceTrigger()` takes no arguments — the platform hands the flow a call that
- * has already connected, and the start step publishes its `callContext`. That
- * is the only difference from the outbound shape in
- * `PotteryStudioCallback.flow.ts`, which dials first and reads the context off
- * the dial step instead.
- *
- * Pass `out('start', 'callContext')` whole. It is an OBJECT; reaching inside it
- * for `conversationId` passes the file's schema and then fails at dispatch.
- *
- * Generic scenario: answer the harbour's information line.
- */
-import { flow, voiceTrigger, voiceAgent, endCall, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('harbour-radio-line')
-  .name('HarbourRadioLine')
-  .version('1.0.0')
-  .output({ callSummary: types.string })
-  .trigger(voiceTrigger())
-  .step('greet', voiceAgent({
-    systemPrompt:
-      'Answer the harbour information line. Give tide times and berth availability, '
-      + 'and take a message for the harbourmaster if you cannot help.',
-    callContext: out('start', 'callContext'),
-    voice: { model: 'gemini-3.1-flash-live-preview', persona: 'Kore' },
-  }))
-  .step('hangUp', endCall({ callContext: out('start', 'callContext') }))
-  .return({ callSummary: out('greet') })
-  .build();

package/skills/uipath-maestro-flow/examples/HerbariumDispatch.flow.ts

@@ -1,34 +0,0 @@
-/**
- * CAPABILITY: a scheduled flow that creates an Orchestrator queue item.
- *
- * A scheduled trigger has no caller, so the specimen record is part of the
- * flow. The queue step hands that record to a separately managed worker.
- *
- * Generic scenario: send one preserved plant specimen to a daily cataloguing
- * queue. This demonstrates the timer and queue surfaces without mirroring an
- * eval task's business process.
- */
-import { flow, scheduled, queueItem, script, out, types } from '@uipath/maestro-builder-sdk';
-
-const CATALOG_QUEUE = 'HerbariumCatalog';
-const CATALOG_FOLDER = 'Shared';
-const CATALOG_KEY = '6a09e667-bb67-4e3c-8d3d-20e5b6f14a21';
-
-export default flow('herbarium-dispatch')
-  .name('HerbariumDispatch')
-  .version('1.0.0')
-  .output({ receipt: types.string })
-  .trigger(scheduled({ every: 'R/P1D' }))
-  .step('catalogSpecimen', queueItem({
-    queue: CATALOG_QUEUE,
-    folderPath: CATALOG_FOLDER,
-    key: CATALOG_KEY,
-    item: { SpecimenId: 'HERB-204', Family: 'Polypodiaceae', Cabinet: 'Ferns' },
-    reference: 'HERB-204',
-    priority: 'Normal',
-  }))
-  .step('recordDispatch', script({
-    code: 'return "catalogued specimen HERB-204";',
-  }))
-  .return({ receipt: out('recordDispatch') })
-  .build();

package/skills/uipath-maestro-flow/examples/KilnReview.flow.ts

@@ -1,38 +0,0 @@
-/**
- * CAPABILITY: a human task whose form is supplied by a deployed Action App.
- *
- * The flow identifies the app and binds values to the app's own input names.
- * Outcomes still belong to the flow and are read through `Action`.
- *
- * Generic scenario: let a studio coordinator approve a pottery kiln firing.
- */
-import { flow, hitl, script, input, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('kiln-review')
-  .name('KilnReview')
-  .version('1.0.0')
-  .input({ pieceName: types.string, targetCelsius: types.number })
-  .output({ decision: types.string })
-  .step('reviewFiring', hitl({
-    variant: 'action-app',
-    title: 'Kiln firing review',
-    priority: 'Medium',
-    app: {
-      name: 'Kiln Firing Review',
-      key: '3c6ef372-fe94-4f82-aa0b-6d1f45c8b721',
-      folderPath: 'Shared',
-      inputs: {
-        'Piece Name': input('pieceName'),
-        'Target Celsius': input('targetCelsius'),
-      },
-    },
-    outcomes: ['Fire', 'Hold'],
-  }))
-  .step('recordDecision', script({
-    code: `const action = $vars.reviewFiring.output.Action;
-return action === 'Fire'
-  ? 'scheduled:' + $vars.start.output.pieceName
-  : 'held:' + $vars.start.output.pieceName;`,
-  }))
-  .return({ decision: out('recordDecision') })
-  .build();

package/skills/uipath-maestro-flow/examples/LibraryDeskChat.flow.ts

@@ -1,39 +0,0 @@
-/**
- * CAPABILITY: work a live CHAT — wait for a message, answer it, post a reply.
- *
- * Every conversational step is keyed by a `conversationId`, and
- * `conversationTrigger()` publishes it as `out('start', 'conversationId')`.
- *
- * `waitForMessage` SUSPENDS the flow — it is a catch event, not a poll. Use
- * `conversationalAgent` when the model decides what to say and `sendMessage`
- * when the flow does; this example shows both, so the agent answers and the
- * flow closes the exchange itself.
- *
- * Generic scenario: answer a question at a library help desk.
- */
-import {
-  flow, conversationTrigger, waitForMessage, conversationalAgent, sendMessage,
-  out, types,
-} from '@uipath/maestro-builder-sdk';
-
-export default flow('library-desk-chat')
-  .name('LibraryDeskChat')
-  .version('1.0.0')
-  .output({ answered: types.string })
-  .trigger(conversationTrigger())
-  .step('listen', waitForMessage({
-    conversationId: out('start', 'conversationId'),
-  }))
-  .step('answer', conversationalAgent({
-    model: 'gpt-5.4',
-    systemPrompt: 'Answer library questions in one or two sentences. Say so when unsure.',
-    settings: { mode: 'simple', context: out('listen', 'conversationContext') },
-  }))
-  .step('closeExchange', sendMessage({
-    conversationId: out('start', 'conversationId'),
-    exchangeId: out('listen', 'exchangeId'),
-    content: 'Ask again any time — the desk is open until six.',
-    endExchange: true,
-  }))
-  .return({ answered: out('answer') })
-  .build();

package/skills/uipath-maestro-flow/examples/LighthouseSignal.flow.ts

@@ -1,30 +0,0 @@
-/**
- * CAPABILITY: a standalone HTTP call followed by a delay.
- *
- * `managed: false` emits the plain HTTP node, where response status and body
- * remain ordinary outputs. A delay publishes nothing; the next step reads the
- * HTTP result, not the timer.
- *
- * Generic scenario: read a lighthouse signal and pause before recording it.
- */
-import { flow, http, delay, script, input, out, tmpl, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('lighthouse-signal')
-  .name('LighthouseSignal')
-  .version('1.0.0')
-  .input({ station: types.string })
-  .output({ report: types.string })
-  .step('readSignal', http({
-    method: 'GET',
-    url: tmpl`https://signals.example.com/stations/${input('station')}`,
-    managed: false,
-    returns: { signal: 'string' },
-  }))
-  .step('cooldown', delay({ duration: 'PT2S' }))
-  .step('recordSignal', script({
-    code:
-      'return "station " + $vars.start.output.station + ": "'
-      + ' + String($vars.readSignal.output.body.signal || "unknown");',
-  }))
-  .return({ report: out('recordSignal') })
-  .build();

package/skills/uipath-maestro-flow/examples/MeteorShowerPages.flow.ts

@@ -1,39 +0,0 @@
-/**
- * CAPABILITY: `.doWhile` — run a body, then repeat WHILE a condition holds.
- *
- * The condition is checked AFTER each pass, so the body always runs at least
- * once (`core.logic.dowhile`). That is the difference from `.loop()`, which
- * iterates a collection it already has.
- *
- * The container publishes NO data output. Carry results out through a `.var()`
- * written from inside the body with `{ updates }` — here `page` advances the
- * cursor and doubles as the loop's own state. `limit` caps iterations (1–10,000;
- * blank means the platform default of 10,000), and `body.break()` works exactly
- * as it does in `.loop()`.
- *
- * Generic scenario: page through a meteor-shower sightings feed until it ends.
- */
-import { flow, http, script, js, tmpl, v, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('meteor-shower-pages')
-  .name('MeteorShowerPages')
-  .version('1.0.0')
-  .output({ pagesRead: types.string })
-  .var('page', types.number, 1)
-  .doWhile(
-    'paginate',
-    js`$vars.fetchPage.output.body.hasNextPage === true`,
-    (body) => body
-      .step('fetchPage', http({
-        method: 'GET',
-        url: tmpl`https://sightings.example.com/meteors?page=${v('page')}`,
-        managed: false,
-        returns: { hasNextPage: 'boolean' },
-      }), { updates: { page: js`$vars.page + 1` } }),
-    { limit: 50 },
-  )
-  .step('reportPages', script({
-    code: 'return "read " + String($vars.page - 1) + " page(s) of sightings";',
-  }))
-  .return({ pagesRead: out('reportPages') })
-  .build();

package/skills/uipath-maestro-flow/examples/NeighborhoodWalkPlanner.flow.ts

@@ -1,27 +0,0 @@
-/**
- * CAPABILITY: call a published agentic process and wait for its output.
- *
- * An agentic process is a deployed orchestration rather than an inline model.
- * Its declared output fields become readable after the synchronous step.
- *
- * Generic scenario: ask a community-planning process for a neighborhood walk.
- */
-import { flow, agenticProcess, script, input, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('neighborhood-walk-planner')
-  .name('NeighborhoodWalkPlanner')
-  .version('1.0.0')
-  .input({ district: types.string })
-  .output({ route: types.string })
-  .step('planWalk', agenticProcess({
-    key: '510e527f-ade6-4c92-a860-9f17657dc821',
-    name: 'Neighborhood Walk Planner',
-    folderPath: 'Shared/community-planning',
-    inputs: { District: input('district') },
-    returns: { RouteName: 'string' },
-  }))
-  .step('recordRoute', script({
-    code: 'return "route: " + String($vars.planWalk.output.RouteName);',
-  }))
-  .return({ route: out('recordRoute') })
-  .build();

package/skills/uipath-maestro-flow/examples/ObservatorySeeing.flow.ts

@@ -1,51 +0,0 @@
-/**
- * CAPABILITY: an ERROR PORT — a failed step routes to a handler instead of
- * killing the run.
- *
- *     .step('fetch', http({ url: …, managed: true, returns: { … } }))
- *     .onError((h) => h.return({ … err('fetch', 'message') … }))
- *     .step('onSuccess', …)   // everything after .onError is the SUCCESS path
- *
- * `.onError()` handles the step BEFORE it; its handler is a path of its own.
- * `managed: true` is load-bearing: on the plain HTTP node a 4xx/5xx is a SUCCESS
- * carrying `statusCode`, so the handler would never run (`check` rejects that).
- * The managed node throws on non-2xx, so the failure reaches the port — and it
- * hands back a PARSED body. Read the failure with `err('<step>', '<field>')`
- * (siblings of `out`): `code` (a string), `message`, `detail`, `category`,
- * `status`.
- *
- * Generic scenario: an observatory asks a public sun API when tonight's viewing
- * can start, and states a fallback for when the service is unreachable.
- */
-import { flow, http, script, err, out, input, lit, tmpl, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('observatory-seeing')
-  .name('ObservatorySeeing')
-  .version('1.0.0')
-  .input({ lat: types.number, lng: types.number })
-  .output({ viewingFrom: types.string, source: types.string })
-
-  // Somebody else's uptime, so the call has to ROUTE on failure.
-  .step('fetchSun', http({
-    url: tmpl`https://api.example.com/sun?lat=${input('lat')}&lng=${input('lng')}`,
-    managed: true,
-    // Declare what we read, or the read is refused.
-    returns: { results: 'object' },
-  }))
-  // Service down / rate-limited / unknown coordinates: carry on with a stated
-  // fallback rather than faulting the whole run.
-  .onError((h) => h.return({
-    viewingFrom: lit('sunset unknown — check a local almanac'),
-    source: tmpl`fallback (${err('fetchSun', 'code')}): ${err('fetchSun', 'message')}`,
-  }))
-
-  // Success path — reached only when the call actually succeeded.
-  .step('describe', script({
-    // Read the DECLARED field (`body.results`) and index it in JS; reading
-    // `body.results.sunset` through $vars would not resolve (declaration stops at
-    // `results`).
-    code: 'const r = $vars.fetchSun.output.body.results || {};\nreturn { line: "best viewing after " + (r.sunset || "sunset") };',
-  }))
-  .return({ viewingFrom: out('describe', 'line'), source: lit('live') })
-
-  .build();

package/skills/uipath-maestro-flow/examples/OralHistoryDigest.flow.ts

@@ -1,31 +0,0 @@
-/**
- * CAPABILITY: summarize an uploaded file with the platform Summarize node.
- *
- * The input is the complete file attachment. The result uses the node's
- * PascalCase `content.Text` and `content.Citations` contract.
- *
- * Generic scenario: condense a community oral-history interview for an archive.
- */
-import { flow, summarize, out, err, tmpl, js, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('oral-history-digest')
-  .name('OralHistoryDigest')
-  .version('1.0.0')
-  .input({ interviewFile: types.file })
-  .output({ summary: types.string, citations: types.array })
-  .step('summarizeInterview', summarize({
-    attachment: out('start', 'interviewFile'),
-    prompt: 'Summarize the places, people, dates, and traditions mentioned in this interview.',
-    returnCitations: true,
-  }))
-  // The handler runs BECAUSE `summarizeInterview` failed, so its `content.*`
-  // outputs have no value — return an empty list rather than reading them.
-  .onError((handler) => handler.return({
-    summary: tmpl`could not summarize interview: ${err('summarizeInterview', 'detail')}`,
-    citations: js`[]`,
-  }))
-  .return({
-    summary: out('summarizeInterview', 'content.Text'),
-    citations: out('summarizeInterview', 'content.Citations'),
-  })
-  .build();

package/skills/uipath-maestro-flow/examples/PlanetariumConfirmation.flow.ts

@@ -1,34 +0,0 @@
-/**
- * CAPABILITY: pause mid-flow until a filtered connector event arrives.
- *
- * `waitForEvent` is an action, not a start trigger. The injected event resumes
- * the existing run, and its payload is readable from the wait step's output.
- *
- * Generic scenario: wait for the email confirming a planetarium reservation.
- */
-import { flow, waitForEvent, script, out, types } from '@uipath/maestro-builder-sdk';
-
-const CONFIRMATIONS_FOLDER =
-  'AQMkAGU5ZGFmM2QyLWY4OTEtNDAzNi04MGU2LWRjNzE2OWM0NTllMA==';
-
-export default flow('planetarium-confirmation')
-  .name('PlanetariumConfirmation')
-  .version('1.0.0')
-  .input({ reservationCode: types.string })
-  .output({ confirmation: types.string })
-  .step('awaitConfirmation', waitForEvent({
-    connector: 'uipath-microsoft-outlook365',
-    event: 'email-received',
-    where: { parentFolderId: CONFIRMATIONS_FOLDER },
-    filters: [{ field: 'subject', contains: 'PLANETARIUM' }],
-    // bindings.json labels; both required (check: BINDING_MISSING).
-    connection: 'outlook',
-    folder: 'shared',
-  }))
-  .step('recordConfirmation', script({
-    code:
-      'return "confirmed " + $vars.start.output.reservationCode + ": "'
-      + ' + $vars.awaitConfirmation.output.subject;',
-  }))
-  .return({ confirmation: out('recordConfirmation') })
-  .build();

package/skills/uipath-maestro-flow/examples/PlantNameAdvisor.flow.ts

@@ -1,28 +0,0 @@
-/**
- * CAPABILITY: invoke a published agent resource.
- *
- * Published coded and low-code agents share the same node family. The release
- * key, name, folder, inputs, and declared returns close the deployed contract.
- *
- * Generic scenario: ask a botany advisor for a plant's common name.
- */
-import { flow, agent, script, input, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('plant-name-advisor')
-  .name('PlantNameAdvisor')
-  .version('1.0.0')
-  .input({ description: types.string })
-  .output({ answer: types.string })
-  .step('identifyPlant', agent({
-    key: '9b05688c-2b3e-4b69-86e6-f1f923a264d8',
-    name: 'Plant Name Advisor',
-    folderPath: 'Shared/botany',
-    flavour: 'lowcode',
-    inputs: { description: input('description') },
-    returns: { commonName: 'string' },
-  }))
-  .step('recordName', script({
-    code: 'return "plant: " + String($vars.identifyPlant.output.commonName);',
-  }))
-  .return({ answer: out('recordName') })
-  .build();

package/skills/uipath-maestro-flow/examples/PostcardCaption.flow.ts

@@ -1,44 +0,0 @@
-/**
- * CAPABILITY: an `inlineAgent` — an LLM step defined in this project, with a
- * typed output contract.
- *
- *   systemPrompt / userPrompt : the instruction and the turn (use `{{input.x}}`)
- *   inputs                    : values wired into the prompt from the flow
- *   returns                   : the TYPED object the agent must produce — read
- *                               downstream as `$vars.<step>.output.<field>`
- *
- * A local run cannot call the model, so a `--dry-run` returns `{}` and the reads
- * below are genuinely absent offline — which is the honest bar: a green run
- * proves the agent node is WIRED and its contract is declared, not that the model
- * answered. This one carries no tools or escalation (those are the agent-resource
- * family); it is the plain shape.
- *
- * Generic scenario: draft a short caption for a travel postcard.
- */
-import { flow, inlineAgent, script, out, input, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('postcard-caption')
-  .name('PostcardCaption')
-  .version('1.0.0')
-  .input({ place: types.string, mood: types.string })
-  .output({ caption: types.string })
-
-  .step('write', inlineAgent({
-    model: 'gpt-5.4',
-    systemPrompt:
-      'You write postcard captions for a given place and mood. Return a result '
-      + 'conforming to the output schema. caption: one cheerful sentence, no more '
-      + 'than 15 words. tone: one word.',
-    userPrompt: 'Place: {{input.place}}\nMood: {{input.mood}}',
-    inputs: { place: input('place'), mood: input('mood') },
-    returns: { caption: 'string', tone: 'string' },
-  }))
-
-  // Reads only the agent's own declared returns — the one contract a local run
-  // can honestly assert.
-  .step('render', script({
-    code: 'return "[" + String($vars.write.output.tone) + "] " + String($vars.write.output.caption);',
-  }))
-  .return({ caption: out('render') })
-
-  .build();

package/skills/uipath-maestro-flow/examples/PotteryStudioCallback.flow.ts

@@ -1,41 +0,0 @@
-/**
- * CAPABILITY: place a phone call, talk to the person, hang up.
- *
- * The call is identified by a `callContext` OBJECT. Pass the WHOLE thing —
- * `out('dial', 'callContext')` — never a field inside it. The node's schema
- * types that field as `object`, so a scalar such as
- * `out('dial', 'callContext.conversationId')` passes the file's schema and then
- * fails at dispatch; `check` catches it as `VOICE_CALL_CONTEXT_NOT_OBJECT`.
- *
- * `createOutgoingCall` dials out and publishes the context. An inbound flow
- * instead uses `.trigger(voiceTrigger())`, whose start step publishes the same
- * `callContext`. A persona belongs to its voice model, and `maxIterations` is
- * capped at 8.
- *
- * Generic scenario: remind a customer their pottery is ready for collection.
- */
-import {
-  flow, createOutgoingCall, voiceAgent, endCall, input, out, types,
-} from '@uipath/maestro-builder-sdk';
-
-export default flow('pottery-studio-callback')
-  .name('PotteryStudioCallback')
-  .version('1.0.0')
-  .input({ customerName: types.string, customerPhone: types.string, pieceCount: types.number })
-  .output({ callSummary: types.string })
-  .step('dial', createOutgoingCall({
-    from: '+15550001111',
-    to: input('customerPhone'),
-  }))
-  .step('talk', voiceAgent({
-    systemPrompt:
-      'Tell {{input.customerName}} that {{input.pieceCount}} finished pieces are ready '
-      + 'for collection, and offer a weekday or weekend pickup.',
-    inputs: { customerName: input('customerName'), pieceCount: input('pieceCount') },
-    callContext: out('dial', 'callContext'),
-    voice: { model: 'gemini-3.1-flash-live-preview', persona: 'Kore' },
-    maxIterations: 4,
-  }))
-  .step('hangUp', endCall({ callContext: out('dial', 'callContext') }))
-  .return({ callSummary: out('talk') })
-  .build();

package/skills/uipath-maestro-flow/examples/RecipeScaler.flow.ts

@@ -1,62 +0,0 @@
-/**
- * CAPABILITY: `subflow` — a flow that runs OTHER flows.
- *
- * A `subflow` step hands work to a CHILD flow and reads back what the child
- * returns. Two scopes, one door: the child sees nothing of its caller — inputs
- * arrive through the `subflow(child, { … })` map (keyed by the child's own input
- * names) and results leave through the child's `.return()`.
- *
- *   - A child is declared as a `flow(...)` WITHOUT `.build()`, ABOVE its callers.
- *   - Read a subflow's output BY NAME: `out('step', 'field')`, never bare
- *     `out('step')` (a subflow publishes an OBJECT of its declared outputs).
- *   - Children nest: a child may itself run a subflow.
- *
- * Generic scenario: scale a recipe's ingredients by a factor, with a nested
- * child that phrases one line. No `.input`: variable defaults keep it
- * self-contained.
- */
-import { flow, script, subflow, v, out, input, types } from '@uipath/maestro-builder-sdk';
-
-/** A leaf child: scale one quantity. Declared ABOVE the flows that run it. */
-const scaleIngredient = flow('scale-ingredient')
-  .name('ScaleIngredient')
-  .input({ grams: types.number, factor: types.number })
-  .output({ scaled: types.number })
-  .step('scale', script({ code: 'return Math.round($vars.start.output.grams * $vars.start.output.factor);' }))
-  .return({ scaled: out('scale') });
-
-/** A child that itself runs a subflow — the nesting case. */
-const describeBatch = flow('describe-batch')
-  .name('DescribeBatch')
-  .input({ grams: types.number, factor: types.number, label: types.string })
-  .output({ line: types.string })
-  .step('scaleLabelled', subflow(scaleIngredient, { grams: input('grams'), factor: input('factor') }))
-  .step('phrase', script({
-    code: 'return $vars.start.output.label + ": " + $vars.scaleLabelled.output.scaled + " g";',
-  }))
-  .return({ line: out('phrase') });
-
-export default flow('recipe-scaler')
-  .name('RecipeScaler')
-  .version('1.0.0')
-  .output({ flour: types.number, sugar: types.number, headline: types.string })
-
-  .var('factor', types.number, 2.5)
-  .var('flourBase', types.number, 200)
-  .var('sugarBase', types.number, 120)
-  .var('flourLabel', types.string, 'flour')
-
-  // The same child, twice — nothing shared but its definition.
-  .step('scaleFlour', subflow(scaleIngredient, { grams: v('flourBase'), factor: v('factor') }))
-  .step('scaleSugar', subflow(scaleIngredient, { grams: v('sugarBase'), factor: v('factor') }))
-
-  // A child that nests one level deeper.
-  .step('headline', subflow(describeBatch, { grams: v('flourBase'), factor: v('factor'), label: v('flourLabel') }))
-
-  .return({
-    flour: out('scaleFlour', 'scaled'),
-    sugar: out('scaleSugar', 'scaled'),
-    headline: out('headline', 'line'),
-  })
-
-  .build();

package/skills/uipath-maestro-flow/examples/SeedPacketReader.flow.ts

@@ -1,49 +0,0 @@
-/**
- * CAPABILITY: classify a document, then extract fields against an INLINE schema.
- *
- * `documentClassify` (`uipath.document.classify`) names the document's type.
- * `dynamicExtract` (`uipath.ixp.extract-document-builder`) is the other half of
- * the pair: it carries its own `schema` instead of a published IxP project's
- * trained fields, which is what makes it "dynamic".
- *
- * Dynamic Extract still needs a model DEPLOYMENT identity. `modelName` and
- * `folderKey` below are placeholders in the shape the tenant serves — copy the
- * real pair from the tenant; never construct them.
- *
- * Generic scenario: read the sowing details off a scanned seed packet.
- */
-import { flow, documentClassify, dynamicExtract, script, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('seed-packet-reader')
-  .name('SeedPacketReader')
-  .version('1.0.0')
-  .input({ packetScan: types.file })
-  .output({ summary: types.string })
-  .step('classifyPacket', documentClassify({
-    fileRef: out('start', 'packetScan'),
-    splitPages: false,
-  }))
-  .step('extractSowing', dynamicExtract({
-    fileRef: out('start', 'packetScan'),
-    schema: {
-      type: 'object',
-      properties: {
-        variety: { type: 'string' },
-        sowDepthMm: { type: 'string' },
-        daysToGerminate: { type: 'string' },
-      },
-    },
-    model: {
-      modelName: 'seedpackets-9c41e7b2-ixp',
-      folderKey: '4c9d1f70-6b2e-4a58-9f13-2ad5c8e0b741',
-    },
-  }))
-  .step('summarize', script({
-    code:
-      'const sowing = $vars.extractSowing.output || {};\n'
-      + 'return "type:" + ($vars.classifyPacket.output.DocumentTypeName || "?")\n'
-      + '  + " variety:" + (sowing.variety || "-")\n'
-      + '  + " depth:" + (sowing.sowDepthMm || "-");',
-  }))
-  .return({ summary: out('summarize') })
-  .build();